git.r.bdr.sh - rbdr/dotfiles/blob - vim/autoload/tagbar.vim

   1 " ============================================================================
   2 " File:        tagbar.vim
   3 " Description: List the current file's tags in a sidebar, ordered by class etc
   4 " Author:      Jan Larres <jan@majutsushi.net>
   5 " Licence:     Vim licence
   6 " Website:     http://majutsushi.github.com/tagbar/
   7 " Version:     2.3
   8 " Note:        This plugin was heavily inspired by the 'Taglist' plugin by
   9 "              Yegappan Lakshmanan and uses a small amount of code from it.
  10 "
  11 " Original taglist copyright notice:
  12 "              Permission is hereby granted to use and distribute this code,
  13 "              with or without modifications, provided that this copyright
  14 "              notice is copied with it. Like anything else that's free,
  15 "              taglist.vim is provided *as is* and comes with no warranty of
  16 "              any kind, either expressed or implied. In no event will the
  17 "              copyright holder be liable for any damamges resulting from the
  18 "              use of this software.
  19 " ============================================================================
  20
  21 scriptencoding utf-8
  22
  23 " Initialization {{{1
  24
  25 " Basic init {{{2
  26
  27 if !exists('g:tagbar_ctags_bin')
  28     if executable('ctags-exuberant')
  29         let g:tagbar_ctags_bin = 'ctags-exuberant'
  30     elseif executable('exuberant-ctags')
  31         let g:tagbar_ctags_bin = 'exuberant-ctags'
  32     elseif executable('exctags')
  33         let g:tagbar_ctags_bin = 'exctags'
  34     elseif has('macunix') && executable('/usr/local/bin/ctags')
  35         " Homebrew default location
  36         let g:tagbar_ctags_bin = '/usr/local/bin/ctags'
  37     elseif has('macunix') && executable('/opt/local/bin/ctags')
  38         " Macports default location
  39         let g:tagbar_ctags_bin = '/opt/local/bin/ctags'
  40     elseif executable('ctags')
  41         let g:tagbar_ctags_bin = 'ctags'
  42     elseif executable('ctags.exe')
  43         let g:tagbar_ctags_bin = 'ctags.exe'
  44     elseif executable('tags')
  45         let g:tagbar_ctags_bin = 'tags'
  46     else
  47         echomsg 'Tagbar: Exuberant ctags not found, skipping plugin'
  48         finish
  49     endif
  50 else
  51     " reset 'wildignore' temporarily in case *.exe is included in it
  52     let wildignore_save = &wildignore
  53     set wildignore&
  54
  55     let g:tagbar_ctags_bin = expand(g:tagbar_ctags_bin)
  56
  57     let &wildignore = wildignore_save
  58
  59     if !executable(g:tagbar_ctags_bin)
  60         echomsg 'Tagbar: Exuberant ctags not found in specified place,'
  61               \ 'skipping plugin'
  62         finish
  63     endif
  64 endif
  65
  66 redir => s:ftype_out
  67 silent filetype
  68 redir END
  69 if s:ftype_out !~# 'detection:ON'
  70     echomsg 'Tagbar: Filetype detection is turned off, skipping plugin'
  71     unlet s:ftype_out
  72     finish
  73 endif
  74 unlet s:ftype_out
  75
  76 let s:icon_closed = g:tagbar_iconchars[0]
  77 let s:icon_open   = g:tagbar_iconchars[1]
  78
  79 let s:type_init_done    = 0
  80 let s:autocommands_done = 0
  81 let s:checked_ctags     = 0
  82 let s:window_expanded   = 0
  83
  84 let s:access_symbols = {
  85     \ 'public'    : '+',
  86     \ 'protected' : '#',
  87     \ 'private'   : '-'
  88 \ }
  89
  90 let g:loaded_tagbar = 1
  91
  92 let s:last_highlight_tline = 0
  93 let s:debug = 0
  94 let s:debug_file = ''
  95
  96 " s:Init() {{{2
  97 function! s:Init()
  98     if !s:type_init_done
  99         call s:InitTypes()
 100     endif
 101
 102     if !s:checked_ctags
 103         if !s:CheckForExCtags()
 104             return
 105         endif
 106     endif
 107 endfunction
 108
 109 " s:InitTypes() {{{2
 110 function! s:InitTypes()
 111     call s:LogDebugMessage('Initializing types')
 112
 113     let s:known_types = {}
 114
 115     " Ant {{{3
 116     let type_ant = {}
 117     let type_ant.ctagstype = 'ant'
 118     let type_ant.kinds     = [
 119         \ {'short' : 'p', 'long' : 'projects', 'fold' : 0},
 120         \ {'short' : 't', 'long' : 'targets',  'fold' : 0}
 121     \ ]
 122     let s:known_types.ant = type_ant
 123     " Asm {{{3
 124     let type_asm = {}
 125     let type_asm.ctagstype = 'asm'
 126     let type_asm.kinds     = [
 127         \ {'short' : 'm', 'long' : 'macros',  'fold' : 0},
 128         \ {'short' : 't', 'long' : 'types',   'fold' : 0},
 129         \ {'short' : 'd', 'long' : 'defines', 'fold' : 0},
 130         \ {'short' : 'l', 'long' : 'labels',  'fold' : 0}
 131     \ ]
 132     let s:known_types.asm = type_asm
 133     " ASP {{{3
 134     let type_aspvbs = {}
 135     let type_aspvbs.ctagstype = 'asp'
 136     let type_aspvbs.kinds     = [
 137         \ {'short' : 'd', 'long' : 'constants',   'fold' : 0},
 138         \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
 139         \ {'short' : 'f', 'long' : 'functions',   'fold' : 0},
 140         \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0},
 141         \ {'short' : 'v', 'long' : 'variables',   'fold' : 0}
 142     \ ]
 143     let s:known_types.aspvbs = type_aspvbs
 144     " Awk {{{3
 145     let type_awk = {}
 146     let type_awk.ctagstype = 'awk'
 147     let type_awk.kinds     = [
 148         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
 149     \ ]
 150     let s:known_types.awk = type_awk
 151     " Basic {{{3
 152     let type_basic = {}
 153     let type_basic.ctagstype = 'basic'
 154     let type_basic.kinds     = [
 155         \ {'short' : 'c', 'long' : 'constants',    'fold' : 0},
 156         \ {'short' : 'g', 'long' : 'enumerations', 'fold' : 0},
 157         \ {'short' : 'f', 'long' : 'functions',    'fold' : 0},
 158         \ {'short' : 'l', 'long' : 'labels',       'fold' : 0},
 159         \ {'short' : 't', 'long' : 'types',        'fold' : 0},
 160         \ {'short' : 'v', 'long' : 'variables',    'fold' : 0}
 161     \ ]
 162     let s:known_types.basic = type_basic
 163     " BETA {{{3
 164     let type_beta = {}
 165     let type_beta.ctagstype = 'beta'
 166     let type_beta.kinds     = [
 167         \ {'short' : 'f', 'long' : 'fragments', 'fold' : 0},
 168         \ {'short' : 's', 'long' : 'slots',     'fold' : 0},
 169         \ {'short' : 'v', 'long' : 'patterns',  'fold' : 0}
 170     \ ]
 171     let s:known_types.beta = type_beta
 172     " C {{{3
 173     let type_c = {}
 174     let type_c.ctagstype = 'c'
 175     let type_c.kinds     = [
 176         \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
 177         \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1},
 178         \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
 179         \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
 180         \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0},
 181         \ {'short' : 's', 'long' : 'structs',     'fold' : 0},
 182         \ {'short' : 'u', 'long' : 'unions',      'fold' : 0},
 183         \ {'short' : 'm', 'long' : 'members',     'fold' : 0},
 184         \ {'short' : 'v', 'long' : 'variables',   'fold' : 0},
 185         \ {'short' : 'f', 'long' : 'functions',   'fold' : 0}
 186     \ ]
 187     let type_c.sro        = '::'
 188     let type_c.kind2scope = {
 189         \ 'g' : 'enum',
 190         \ 's' : 'struct',
 191         \ 'u' : 'union'
 192     \ }
 193     let type_c.scope2kind = {
 194         \ 'enum'   : 'g',
 195         \ 'struct' : 's',
 196         \ 'union'  : 'u'
 197     \ }
 198     let s:known_types.c = type_c
 199     " C++ {{{3
 200     let type_cpp = {}
 201     let type_cpp.ctagstype = 'c++'
 202     let type_cpp.kinds     = [
 203         \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
 204         \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1},
 205         \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
 206         \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
 207         \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0},
 208         \ {'short' : 'n', 'long' : 'namespaces',  'fold' : 0},
 209         \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
 210         \ {'short' : 's', 'long' : 'structs',     'fold' : 0},
 211         \ {'short' : 'u', 'long' : 'unions',      'fold' : 0},
 212         \ {'short' : 'f', 'long' : 'functions',   'fold' : 0},
 213         \ {'short' : 'm', 'long' : 'members',     'fold' : 0},
 214         \ {'short' : 'v', 'long' : 'variables',   'fold' : 0}
 215     \ ]
 216     let type_cpp.sro        = '::'
 217     let type_cpp.kind2scope = {
 218         \ 'g' : 'enum',
 219         \ 'n' : 'namespace',
 220         \ 'c' : 'class',
 221         \ 's' : 'struct',
 222         \ 'u' : 'union'
 223     \ }
 224     let type_cpp.scope2kind = {
 225         \ 'enum'      : 'g',
 226         \ 'namespace' : 'n',
 227         \ 'class'     : 'c',
 228         \ 'struct'    : 's',
 229         \ 'union'     : 'u'
 230     \ }
 231     let s:known_types.cpp = type_cpp
 232     " C# {{{3
 233     let type_cs = {}
 234     let type_cs.ctagstype = 'c#'
 235     let type_cs.kinds     = [
 236         \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
 237         \ {'short' : 'f', 'long' : 'fields',      'fold' : 0},
 238         \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
 239         \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
 240         \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0},
 241         \ {'short' : 'n', 'long' : 'namespaces',  'fold' : 0},
 242         \ {'short' : 'i', 'long' : 'interfaces',  'fold' : 0},
 243         \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
 244         \ {'short' : 's', 'long' : 'structs',     'fold' : 0},
 245         \ {'short' : 'E', 'long' : 'events',      'fold' : 0},
 246         \ {'short' : 'm', 'long' : 'methods',     'fold' : 0},
 247         \ {'short' : 'p', 'long' : 'properties',  'fold' : 0}
 248     \ ]
 249     let type_cs.sro        = '.'
 250     let type_cs.kind2scope = {
 251         \ 'n' : 'namespace',
 252         \ 'i' : 'interface',
 253         \ 'c' : 'class',
 254         \ 's' : 'struct',
 255         \ 'g' : 'enum'
 256     \ }
 257     let type_cs.scope2kind = {
 258         \ 'namespace' : 'n',
 259         \ 'interface' : 'i',
 260         \ 'class'     : 'c',
 261         \ 'struct'    : 's',
 262         \ 'enum'      : 'g'
 263     \ }
 264     let s:known_types.cs = type_cs
 265     " COBOL {{{3
 266     let type_cobol = {}
 267     let type_cobol.ctagstype = 'cobol'
 268     let type_cobol.kinds     = [
 269         \ {'short' : 'd', 'long' : 'data items',        'fold' : 0},
 270         \ {'short' : 'f', 'long' : 'file descriptions', 'fold' : 0},
 271         \ {'short' : 'g', 'long' : 'group items',       'fold' : 0},
 272         \ {'short' : 'p', 'long' : 'paragraphs',        'fold' : 0},
 273         \ {'short' : 'P', 'long' : 'program ids',       'fold' : 0},
 274         \ {'short' : 's', 'long' : 'sections',          'fold' : 0}
 275     \ ]
 276     let s:known_types.cobol = type_cobol
 277     " DOS Batch {{{3
 278     let type_dosbatch = {}
 279     let type_dosbatch.ctagstype = 'dosbatch'
 280     let type_dosbatch.kinds     = [
 281         \ {'short' : 'l', 'long' : 'labels',    'fold' : 0},
 282         \ {'short' : 'v', 'long' : 'variables', 'fold' : 0}
 283     \ ]
 284     let s:known_types.dosbatch = type_dosbatch
 285     " Eiffel {{{3
 286     let type_eiffel = {}
 287     let type_eiffel.ctagstype = 'eiffel'
 288     let type_eiffel.kinds     = [
 289         \ {'short' : 'c', 'long' : 'classes',  'fold' : 0},
 290         \ {'short' : 'f', 'long' : 'features', 'fold' : 0}
 291     \ ]
 292     let type_eiffel.sro        = '.' " Not sure, is nesting even possible?
 293     let type_eiffel.kind2scope = {
 294         \ 'c' : 'class',
 295         \ 'f' : 'feature'
 296     \ }
 297     let type_eiffel.scope2kind = {
 298         \ 'class'   : 'c',
 299         \ 'feature' : 'f'
 300     \ }
 301     let s:known_types.eiffel = type_eiffel
 302     " Erlang {{{3
 303     let type_erlang = {}
 304     let type_erlang.ctagstype = 'erlang'
 305     let type_erlang.kinds     = [
 306         \ {'short' : 'm', 'long' : 'modules',            'fold' : 0},
 307         \ {'short' : 'd', 'long' : 'macro definitions',  'fold' : 0},
 308         \ {'short' : 'f', 'long' : 'functions',          'fold' : 0},
 309         \ {'short' : 'r', 'long' : 'record definitions', 'fold' : 0}
 310     \ ]
 311     let type_erlang.sro        = '.' " Not sure, is nesting even possible?
 312     let type_erlang.kind2scope = {
 313         \ 'm' : 'module'
 314     \ }
 315     let type_erlang.scope2kind = {
 316         \ 'module' : 'm'
 317     \ }
 318     let s:known_types.erlang = type_erlang
 319     " Flex {{{3
 320     " Vim doesn't support Flex out of the box, this is based on rough
 321     " guesses and probably requires
 322     " http://www.vim.org/scripts/script.php?script_id=2909
 323     " Improvements welcome!
 324     let type_mxml = {}
 325     let type_mxml.ctagstype = 'flex'
 326     let type_mxml.kinds     = [
 327         \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0},
 328         \ {'short' : 'c', 'long' : 'classes',          'fold' : 0},
 329         \ {'short' : 'm', 'long' : 'methods',          'fold' : 0},
 330         \ {'short' : 'p', 'long' : 'properties',       'fold' : 0},
 331         \ {'short' : 'f', 'long' : 'functions',        'fold' : 0},
 332         \ {'short' : 'x', 'long' : 'mxtags',           'fold' : 0}
 333     \ ]
 334     let type_mxml.sro        = '.'
 335     let type_mxml.kind2scope = {
 336         \ 'c' : 'class'
 337     \ }
 338     let type_mxml.scope2kind = {
 339         \ 'class' : 'c'
 340     \ }
 341     let s:known_types.mxml = type_mxml
 342     " Fortran {{{3
 343     let type_fortran = {}
 344     let type_fortran.ctagstype = 'fortran'
 345     let type_fortran.kinds     = [
 346         \ {'short' : 'm', 'long' : 'modules',                      'fold' : 0},
 347         \ {'short' : 'p', 'long' : 'programs',                     'fold' : 0},
 348         \ {'short' : 'k', 'long' : 'components',                   'fold' : 0},
 349         \ {'short' : 't', 'long' : 'derived types and structures', 'fold' : 0},
 350         \ {'short' : 'c', 'long' : 'common blocks',                'fold' : 0},
 351         \ {'short' : 'b', 'long' : 'block data',                   'fold' : 0},
 352         \ {'short' : 'e', 'long' : 'entry points',                 'fold' : 0},
 353         \ {'short' : 'f', 'long' : 'functions',                    'fold' : 0},
 354         \ {'short' : 's', 'long' : 'subroutines',                  'fold' : 0},
 355         \ {'short' : 'l', 'long' : 'labels',                       'fold' : 0},
 356         \ {'short' : 'n', 'long' : 'namelists',                    'fold' : 0},
 357         \ {'short' : 'v', 'long' : 'variables',                    'fold' : 0}
 358     \ ]
 359     let type_fortran.sro        = '.' " Not sure, is nesting even possible?
 360     let type_fortran.kind2scope = {
 361         \ 'm' : 'module',
 362         \ 'p' : 'program',
 363         \ 'f' : 'function',
 364         \ 's' : 'subroutine'
 365     \ }
 366     let type_fortran.scope2kind = {
 367         \ 'module'     : 'm',
 368         \ 'program'    : 'p',
 369         \ 'function'   : 'f',
 370         \ 'subroutine' : 's'
 371     \ }
 372     let s:known_types.fortran = type_fortran
 373     " HTML {{{3
 374     let type_html = {}
 375     let type_html.ctagstype = 'html'
 376     let type_html.kinds     = [
 377         \ {'short' : 'f', 'long' : 'JavaScript funtions', 'fold' : 0},
 378         \ {'short' : 'a', 'long' : 'named anchors',       'fold' : 0}
 379     \ ]
 380     let s:known_types.html = type_html
 381     " Java {{{3
 382     let type_java = {}
 383     let type_java.ctagstype = 'java'
 384     let type_java.kinds     = [
 385         \ {'short' : 'p', 'long' : 'packages',       'fold' : 1},
 386         \ {'short' : 'f', 'long' : 'fields',         'fold' : 0},
 387         \ {'short' : 'g', 'long' : 'enum types',     'fold' : 0},
 388         \ {'short' : 'e', 'long' : 'enum constants', 'fold' : 0},
 389         \ {'short' : 'i', 'long' : 'interfaces',     'fold' : 0},
 390         \ {'short' : 'c', 'long' : 'classes',        'fold' : 0},
 391         \ {'short' : 'm', 'long' : 'methods',        'fold' : 0}
 392     \ ]
 393     let type_java.sro        = '.'
 394     let type_java.kind2scope = {
 395         \ 'g' : 'enum',
 396         \ 'i' : 'interface',
 397         \ 'c' : 'class'
 398     \ }
 399     let type_java.scope2kind = {
 400         \ 'enum'      : 'g',
 401         \ 'interface' : 'i',
 402         \ 'class'     : 'c'
 403     \ }
 404     let s:known_types.java = type_java
 405     " JavaScript {{{3
 406     " JavaScript is weird -- it does have scopes, but ctags doesn't seem to
 407     " properly generate the information for them, instead it simply uses the
 408     " complete name. So ctags has to be fixed before I can do anything here.
 409     " Alternatively jsctags/doctorjs will be used if available.
 410     let type_javascript = {}
 411     let type_javascript.ctagstype = 'javascript'
 412     let jsctags = s:CheckFTCtags('jsctags', 'javascript')
 413     if jsctags != ''
 414         let type_javascript.kinds = [
 415             \ {'short' : 'v', 'long' : 'variables', 'fold' : 0},
 416             \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
 417         \ ]
 418         let type_javascript.sro        = '.'
 419         let type_javascript.kind2scope = {
 420             \ 'v' : 'namespace',
 421             \ 'f' : 'namespace'
 422         \ }
 423         let type_javascript.scope2kind = {
 424             \ 'namespace' : 'v'
 425         \ }
 426         let type_javascript.ctagsbin   = jsctags
 427         let type_javascript.ctagsargs  = '-f -'
 428     else
 429         let type_javascript.kinds = [
 430             \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0},
 431             \ {'short' : 'c', 'long' : 'classes',          'fold' : 0},
 432             \ {'short' : 'p', 'long' : 'properties',       'fold' : 0},
 433             \ {'short' : 'm', 'long' : 'methods',          'fold' : 0},
 434             \ {'short' : 'f', 'long' : 'functions',        'fold' : 0}
 435         \ ]
 436     endif
 437     let s:known_types.javascript = type_javascript
 438     " Lisp {{{3
 439     let type_lisp = {}
 440     let type_lisp.ctagstype = 'lisp'
 441     let type_lisp.kinds     = [
 442         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
 443     \ ]
 444     let s:known_types.lisp = type_lisp
 445     " Lua {{{3
 446     let type_lua = {}
 447     let type_lua.ctagstype = 'lua'
 448     let type_lua.kinds     = [
 449         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
 450     \ ]
 451     let s:known_types.lua = type_lua
 452     " Make {{{3
 453     let type_make = {}
 454     let type_make.ctagstype = 'make'
 455     let type_make.kinds     = [
 456         \ {'short' : 'm', 'long' : 'macros', 'fold' : 0}
 457     \ ]
 458     let s:known_types.make = type_make
 459     " Matlab {{{3
 460     let type_matlab = {}
 461     let type_matlab.ctagstype = 'matlab'
 462     let type_matlab.kinds     = [
 463         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
 464     \ ]
 465     let s:known_types.matlab = type_matlab
 466     " Ocaml {{{3
 467     let type_ocaml = {}
 468     let type_ocaml.ctagstype = 'ocaml'
 469     let type_ocaml.kinds     = [
 470         \ {'short' : 'M', 'long' : 'modules or functors', 'fold' : 0},
 471         \ {'short' : 'v', 'long' : 'global variables',    'fold' : 0},
 472         \ {'short' : 'c', 'long' : 'classes',             'fold' : 0},
 473         \ {'short' : 'C', 'long' : 'constructors',        'fold' : 0},
 474         \ {'short' : 'm', 'long' : 'methods',             'fold' : 0},
 475         \ {'short' : 'e', 'long' : 'exceptions',          'fold' : 0},
 476         \ {'short' : 't', 'long' : 'type names',          'fold' : 0},
 477         \ {'short' : 'f', 'long' : 'functions',           'fold' : 0},
 478         \ {'short' : 'r', 'long' : 'structure fields',    'fold' : 0}
 479     \ ]
 480     let type_ocaml.sro        = '.' " Not sure, is nesting even possible?
 481     let type_ocaml.kind2scope = {
 482         \ 'M' : 'Module',
 483         \ 'c' : 'class',
 484         \ 't' : 'type'
 485     \ }
 486     let type_ocaml.scope2kind = {
 487         \ 'Module' : 'M',
 488         \ 'class'  : 'c',
 489         \ 'type'   : 't'
 490     \ }
 491     let s:known_types.ocaml = type_ocaml
 492     " Pascal {{{3
 493     let type_pascal = {}
 494     let type_pascal.ctagstype = 'pascal'
 495     let type_pascal.kinds     = [
 496         \ {'short' : 'f', 'long' : 'functions',  'fold' : 0},
 497         \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0}
 498     \ ]
 499     let s:known_types.pascal = type_pascal
 500     " Perl {{{3
 501     let type_perl = {}
 502     let type_perl.ctagstype = 'perl'
 503     let type_perl.kinds     = [
 504         \ {'short' : 'p', 'long' : 'packages',    'fold' : 1},
 505         \ {'short' : 'c', 'long' : 'constants',   'fold' : 0},
 506         \ {'short' : 'f', 'long' : 'formats',     'fold' : 0},
 507         \ {'short' : 'l', 'long' : 'labels',      'fold' : 0},
 508         \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0}
 509     \ ]
 510     let s:known_types.perl = type_perl
 511     " PHP {{{3
 512     let type_php = {}
 513     let type_php.ctagstype = 'php'
 514     let type_php.kinds     = [
 515         \ {'short' : 'i', 'long' : 'interfaces',           'fold' : 0},
 516         \ {'short' : 'c', 'long' : 'classes',              'fold' : 0},
 517         \ {'short' : 'd', 'long' : 'constant definitions', 'fold' : 0},
 518         \ {'short' : 'f', 'long' : 'functions',            'fold' : 0},
 519         \ {'short' : 'v', 'long' : 'variables',            'fold' : 0},
 520         \ {'short' : 'j', 'long' : 'javascript functions', 'fold' : 0}
 521     \ ]
 522     let s:known_types.php = type_php
 523     " Python {{{3
 524     let type_python = {}
 525     let type_python.ctagstype = 'python'
 526     let type_python.kinds     = [
 527         \ {'short' : 'i', 'long' : 'imports',   'fold' : 1},
 528         \ {'short' : 'c', 'long' : 'classes',   'fold' : 0},
 529         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0},
 530         \ {'short' : 'm', 'long' : 'members',   'fold' : 0},
 531         \ {'short' : 'v', 'long' : 'variables', 'fold' : 0}
 532     \ ]
 533     let type_python.sro        = '.'
 534     let type_python.kind2scope = {
 535         \ 'c' : 'class',
 536         \ 'f' : 'function',
 537         \ 'm' : 'function'
 538     \ }
 539     let type_python.scope2kind = {
 540         \ 'class'    : 'c',
 541         \ 'function' : 'f'
 542     \ }
 543     let s:known_types.python = type_python
 544     " REXX {{{3
 545     let type_rexx = {}
 546     let type_rexx.ctagstype = 'rexx'
 547     let type_rexx.kinds     = [
 548         \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0}
 549     \ ]
 550     let s:known_types.rexx = type_rexx
 551     " Ruby {{{3
 552     let type_ruby = {}
 553     let type_ruby.ctagstype = 'ruby'
 554     let type_ruby.kinds     = [
 555         \ {'short' : 'm', 'long' : 'modules',           'fold' : 0},
 556         \ {'short' : 'c', 'long' : 'classes',           'fold' : 0},
 557         \ {'short' : 'f', 'long' : 'methods',           'fold' : 0},
 558         \ {'short' : 'F', 'long' : 'singleton methods', 'fold' : 0}
 559     \ ]
 560     let type_ruby.sro        = '.'
 561     let type_ruby.kind2scope = {
 562         \ 'c' : 'class',
 563         \ 'm' : 'class'
 564     \ }
 565     let type_ruby.scope2kind = {
 566         \ 'class' : 'c'
 567     \ }
 568     let s:known_types.ruby = type_ruby
 569     " Scheme {{{3
 570     let type_scheme = {}
 571     let type_scheme.ctagstype = 'scheme'
 572     let type_scheme.kinds     = [
 573         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0},
 574         \ {'short' : 's', 'long' : 'sets',      'fold' : 0}
 575     \ ]
 576     let s:known_types.scheme = type_scheme
 577     " Shell script {{{3
 578     let type_sh = {}
 579     let type_sh.ctagstype = 'sh'
 580     let type_sh.kinds     = [
 581         \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
 582     \ ]
 583     let s:known_types.sh = type_sh
 584     let s:known_types.csh = type_sh
 585     let s:known_types.zsh = type_sh
 586     " SLang {{{3
 587     let type_slang = {}
 588     let type_slang.ctagstype = 'slang'
 589     let type_slang.kinds     = [
 590         \ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0},
 591         \ {'short' : 'f', 'long' : 'functions',  'fold' : 0}
 592     \ ]
 593     let s:known_types.slang = type_slang
 594     " SML {{{3
 595     let type_sml = {}
 596     let type_sml.ctagstype = 'sml'
 597     let type_sml.kinds     = [
 598         \ {'short' : 'e', 'long' : 'exception declarations', 'fold' : 0},
 599         \ {'short' : 'f', 'long' : 'function definitions',   'fold' : 0},
 600         \ {'short' : 'c', 'long' : 'functor definitions',    'fold' : 0},
 601         \ {'short' : 's', 'long' : 'signature declarations', 'fold' : 0},
 602         \ {'short' : 'r', 'long' : 'structure declarations', 'fold' : 0},
 603         \ {'short' : 't', 'long' : 'type definitions',       'fold' : 0},
 604         \ {'short' : 'v', 'long' : 'value bindings',         'fold' : 0}
 605     \ ]
 606     let s:known_types.sml = type_sml
 607     " SQL {{{3
 608     " The SQL ctags parser seems to be buggy for me, so this just uses the
 609     " normal kinds even though scopes should be available. Improvements
 610     " welcome!
 611     let type_sql = {}
 612     let type_sql.ctagstype = 'sql'
 613     let type_sql.kinds     = [
 614         \ {'short' : 'P', 'long' : 'packages',               'fold' : 1},
 615         \ {'short' : 'c', 'long' : 'cursors',                'fold' : 0},
 616         \ {'short' : 'f', 'long' : 'functions',              'fold' : 0},
 617         \ {'short' : 'F', 'long' : 'record fields',          'fold' : 0},
 618         \ {'short' : 'L', 'long' : 'block label',            'fold' : 0},
 619         \ {'short' : 'p', 'long' : 'procedures',             'fold' : 0},
 620         \ {'short' : 's', 'long' : 'subtypes',               'fold' : 0},
 621         \ {'short' : 't', 'long' : 'tables',                 'fold' : 0},
 622         \ {'short' : 'T', 'long' : 'triggers',               'fold' : 0},
 623         \ {'short' : 'v', 'long' : 'variables',              'fold' : 0},
 624         \ {'short' : 'i', 'long' : 'indexes',                'fold' : 0},
 625         \ {'short' : 'e', 'long' : 'events',                 'fold' : 0},
 626         \ {'short' : 'U', 'long' : 'publications',           'fold' : 0},
 627         \ {'short' : 'R', 'long' : 'services',               'fold' : 0},
 628         \ {'short' : 'D', 'long' : 'domains',                'fold' : 0},
 629         \ {'short' : 'V', 'long' : 'views',                  'fold' : 0},
 630         \ {'short' : 'n', 'long' : 'synonyms',               'fold' : 0},
 631         \ {'short' : 'x', 'long' : 'MobiLink Table Scripts', 'fold' : 0},
 632         \ {'short' : 'y', 'long' : 'MobiLink Conn Scripts',  'fold' : 0}
 633     \ ]
 634     let s:known_types.sql = type_sql
 635     " Tcl {{{3
 636     let type_tcl = {}
 637     let type_tcl.ctagstype = 'tcl'
 638     let type_tcl.kinds     = [
 639         \ {'short' : 'c', 'long' : 'classes',    'fold' : 0},
 640         \ {'short' : 'm', 'long' : 'methods',    'fold' : 0},
 641         \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0}
 642     \ ]
 643     let s:known_types.tcl = type_tcl
 644     " LaTeX {{{3
 645     let type_tex = {}
 646     let type_tex.ctagstype = 'tex'
 647     let type_tex.kinds     = [
 648         \ {'short' : 'p', 'long' : 'parts',          'fold' : 0},
 649         \ {'short' : 'c', 'long' : 'chapters',       'fold' : 0},
 650         \ {'short' : 's', 'long' : 'sections',       'fold' : 0},
 651         \ {'short' : 'u', 'long' : 'subsections',    'fold' : 0},
 652         \ {'short' : 'b', 'long' : 'subsubsections', 'fold' : 0},
 653         \ {'short' : 'P', 'long' : 'paragraphs',     'fold' : 0},
 654         \ {'short' : 'G', 'long' : 'subparagraphs',  'fold' : 0}
 655     \ ]
 656     let s:known_types.tex = type_tex
 657     " Vera {{{3
 658     " Why are variables 'virtual'?
 659     let type_vera = {}
 660     let type_vera.ctagstype = 'vera'
 661     let type_vera.kinds     = [
 662         \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
 663         \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
 664         \ {'short' : 'T', 'long' : 'typedefs',    'fold' : 0},
 665         \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
 666         \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
 667         \ {'short' : 'm', 'long' : 'members',     'fold' : 0},
 668         \ {'short' : 'f', 'long' : 'functions',   'fold' : 0},
 669         \ {'short' : 't', 'long' : 'tasks',       'fold' : 0},
 670         \ {'short' : 'v', 'long' : 'variables',   'fold' : 0},
 671         \ {'short' : 'p', 'long' : 'programs',    'fold' : 0}
 672     \ ]
 673     let type_vera.sro        = '.' " Nesting doesn't seem to be possible
 674     let type_vera.kind2scope = {
 675         \ 'g' : 'enum',
 676         \ 'c' : 'class',
 677         \ 'v' : 'virtual'
 678     \ }
 679     let type_vera.scope2kind = {
 680         \ 'enum'      : 'g',
 681         \ 'class'     : 'c',
 682         \ 'virtual'   : 'v'
 683     \ }
 684     let s:known_types.vera = type_vera
 685     " Verilog {{{3
 686     let type_verilog = {}
 687     let type_verilog.ctagstype = 'verilog'
 688     let type_verilog.kinds     = [
 689         \ {'short' : 'c', 'long' : 'constants',           'fold' : 0},
 690         \ {'short' : 'e', 'long' : 'events',              'fold' : 0},
 691         \ {'short' : 'f', 'long' : 'functions',           'fold' : 0},
 692         \ {'short' : 'm', 'long' : 'modules',             'fold' : 0},
 693         \ {'short' : 'n', 'long' : 'net data types',      'fold' : 0},
 694         \ {'short' : 'p', 'long' : 'ports',               'fold' : 0},
 695         \ {'short' : 'r', 'long' : 'register data types', 'fold' : 0},
 696         \ {'short' : 't', 'long' : 'tasks',               'fold' : 0}
 697     \ ]
 698     let s:known_types.verilog = type_verilog
 699     " VHDL {{{3
 700     " The VHDL ctags parser unfortunately doesn't generate proper scopes
 701     let type_vhdl = {}
 702     let type_vhdl.ctagstype = 'vhdl'
 703     let type_vhdl.kinds     = [
 704         \ {'short' : 'P', 'long' : 'packages',   'fold' : 1},
 705         \ {'short' : 'c', 'long' : 'constants',  'fold' : 0},
 706         \ {'short' : 't', 'long' : 'types',      'fold' : 0},
 707         \ {'short' : 'T', 'long' : 'subtypes',   'fold' : 0},
 708         \ {'short' : 'r', 'long' : 'records',    'fold' : 0},
 709         \ {'short' : 'e', 'long' : 'entities',   'fold' : 0},
 710         \ {'short' : 'f', 'long' : 'functions',  'fold' : 0},
 711         \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0}
 712     \ ]
 713     let s:known_types.vhdl = type_vhdl
 714     " Vim {{{3
 715     let type_vim = {}
 716     let type_vim.ctagstype = 'vim'
 717     let type_vim.kinds     = [
 718         \ {'short' : 'v', 'long' : 'variables',          'fold' : 1},
 719         \ {'short' : 'f', 'long' : 'functions',          'fold' : 0},
 720         \ {'short' : 'a', 'long' : 'autocommand groups', 'fold' : 1},
 721         \ {'short' : 'c', 'long' : 'commands',           'fold' : 0},
 722         \ {'short' : 'm', 'long' : 'maps',               'fold' : 1}
 723     \ ]
 724     let s:known_types.vim = type_vim
 725     " YACC {{{3
 726     let type_yacc = {}
 727     let type_yacc.ctagstype = 'yacc'
 728     let type_yacc.kinds     = [
 729         \ {'short' : 'l', 'long' : 'labels', 'fold' : 0}
 730     \ ]
 731     let s:known_types.yacc = type_yacc
 732     " }}}3
 733
 734     let user_defs = s:GetUserTypeDefs()
 735     for [key, value] in items(user_defs)
 736         if !has_key(s:known_types, key) ||
 737          \ (has_key(value, 'replace') && value.replace)
 738             let s:known_types[key] = value
 739         else
 740             call extend(s:known_types[key], value)
 741         endif
 742     endfor
 743
 744     " Create a dictionary of the kind order for fast
 745     " access in sorting functions
 746     for type in values(s:known_types)
 747         let i = 0
 748         let type.kinddict = {}
 749         for kind in type.kinds
 750             let type.kinddict[kind.short] = i
 751             let i += 1
 752         endfor
 753     endfor
 754
 755     let s:type_init_done = 1
 756 endfunction
 757
 758 " s:GetUserTypeDefs() {{{2
 759 function! s:GetUserTypeDefs()
 760     call s:LogDebugMessage('Initializing user types')
 761
 762     redir => defs
 763     silent execute 'let g:'
 764     redir END
 765
 766     let deflist = split(defs, '\n')
 767     call map(deflist, 'substitute(v:val, ''^\S\+\zs.*'', "", "")')
 768     call filter(deflist, 'v:val =~ "^tagbar_type_"')
 769
 770     let defdict = {}
 771     for defstr in deflist
 772         let type = substitute(defstr, '^tagbar_type_', '', '')
 773         execute 'let defdict["' . type . '"] = g:' . defstr
 774     endfor
 775
 776     " If the user only specified one of kind2scope and scope2kind use it to
 777     " generate the other one
 778     " Also, transform the 'kind' definitions into dictionary format
 779     for def in values(defdict)
 780         if has_key(def, 'kinds')
 781             let kinds = def.kinds
 782             let def.kinds = []
 783             for kind in kinds
 784                 let kindlist = split(kind, ':')
 785                 let kinddict = {'short' : kindlist[0], 'long' : kindlist[1]}
 786                 if len(kindlist) == 3
 787                     let kinddict.fold = kindlist[2]
 788                 else
 789                     let kinddict.fold = 0
 790                 endif
 791                 call add(def.kinds, kinddict)
 792             endfor
 793         endif
 794
 795         if has_key(def, 'kind2scope') && !has_key(def, 'scope2kind')
 796             let def.scope2kind = {}
 797             for [key, value] in items(def.kind2scope)
 798                 let def.scope2kind[value] = key
 799             endfor
 800         elseif has_key(def, 'scope2kind') && !has_key(def, 'kind2scope')
 801             let def.kind2scope = {}
 802             for [key, value] in items(def.scope2kind)
 803                 let def.kind2scope[value] = key
 804             endfor
 805         endif
 806     endfor
 807
 808     return defdict
 809 endfunction
 810
 811 " s:RestoreSession() {{{2
 812 " Properly restore Tagbar after a session got loaded
 813 function! s:RestoreSession()
 814     call s:LogDebugMessage('Restoring session')
 815
 816     let tagbarwinnr = bufwinnr('__Tagbar__')
 817     if tagbarwinnr == -1
 818         " Tagbar wasn't open in the saved session, nothing to do
 819         return
 820     else
 821         let in_tagbar = 1
 822         if winnr() != tagbarwinnr
 823             execute tagbarwinnr . 'wincmd w'
 824             let in_tagbar = 0
 825         endif
 826     endif
 827
 828     call s:Init()
 829
 830     call s:InitWindow(g:tagbar_autoclose)
 831
 832     " Leave the Tagbar window and come back so the update event gets triggered
 833     wincmd p
 834     execute tagbarwinnr . 'wincmd w'
 835
 836     if !in_tagbar
 837         wincmd p
 838     endif
 839 endfunction
 840
 841 " s:MapKeys() {{{2
 842 function! s:MapKeys()
 843     call s:LogDebugMessage('Mapping keys')
 844
 845     nnoremap <script> <silent> <buffer> <2-LeftMouse>
 846                                               \ :call <SID>JumpToTag(0)<CR>
 847     nnoremap <script> <silent> <buffer> <LeftRelease>
 848                                  \ <LeftRelease>:call <SID>CheckMouseClick()<CR>
 849
 850     inoremap <script> <silent> <buffer> <2-LeftMouse>
 851                                               \ <C-o>:call <SID>JumpToTag(0)<CR>
 852     inoremap <script> <silent> <buffer> <LeftRelease>
 853                             \ <LeftRelease><C-o>:call <SID>CheckMouseClick()<CR>
 854
 855     nnoremap <script> <silent> <buffer> <CR>    :call <SID>JumpToTag(0)<CR>
 856     nnoremap <script> <silent> <buffer> p       :call <SID>JumpToTag(1)<CR>
 857     nnoremap <script> <silent> <buffer> <Space> :call <SID>ShowPrototype()<CR>
 858
 859     nnoremap <script> <silent> <buffer> +        :call <SID>OpenFold()<CR>
 860     nnoremap <script> <silent> <buffer> <kPlus>  :call <SID>OpenFold()<CR>
 861     nnoremap <script> <silent> <buffer> zo       :call <SID>OpenFold()<CR>
 862     nnoremap <script> <silent> <buffer> -        :call <SID>CloseFold()<CR>
 863     nnoremap <script> <silent> <buffer> <kMinus> :call <SID>CloseFold()<CR>
 864     nnoremap <script> <silent> <buffer> zc       :call <SID>CloseFold()<CR>
 865     nnoremap <script> <silent> <buffer> o        :call <SID>ToggleFold()<CR>
 866     nnoremap <script> <silent> <buffer> za       :call <SID>ToggleFold()<CR>
 867
 868     nnoremap <script> <silent> <buffer> *    :call <SID>SetFoldLevel(99)<CR>
 869     nnoremap <script> <silent> <buffer> <kMultiply>
 870                                            \ :call <SID>SetFoldLevel(99)<CR>
 871     nnoremap <script> <silent> <buffer> zR   :call <SID>SetFoldLevel(99)<CR>
 872     nnoremap <script> <silent> <buffer> =    :call <SID>SetFoldLevel(0)<CR>
 873     nnoremap <script> <silent> <buffer> zM   :call <SID>SetFoldLevel(0)<CR>
 874
 875     nnoremap <script> <silent> <buffer> <C-N>
 876                                         \ :call <SID>GotoNextToplevelTag(1)<CR>
 877     nnoremap <script> <silent> <buffer> <C-P>
 878                                         \ :call <SID>GotoNextToplevelTag(-1)<CR>
 879
 880     nnoremap <script> <silent> <buffer> s    :call <SID>ToggleSort()<CR>
 881     nnoremap <script> <silent> <buffer> x    :call <SID>ZoomWindow()<CR>
 882     nnoremap <script> <silent> <buffer> q    :call <SID>CloseWindow()<CR>
 883     nnoremap <script> <silent> <buffer> <F1> :call <SID>ToggleHelp()<CR>
 884 endfunction
 885
 886 " s:CreateAutocommands() {{{2
 887 function! s:CreateAutocommands()
 888     call s:LogDebugMessage('Creating autocommands')
 889
 890     augroup TagbarAutoCmds
 891         autocmd!
 892         autocmd BufEnter   __Tagbar__ nested call s:QuitIfOnlyWindow()
 893         autocmd BufUnload  __Tagbar__ call s:CleanUp()
 894         autocmd CursorHold __Tagbar__ call s:ShowPrototype()
 895
 896         autocmd BufWritePost *
 897             \ if line('$') < g:tagbar_updateonsave_maxlines |
 898                 \ call s:AutoUpdate(fnamemodify(expand('<afile>'), ':p')) |
 899             \ endif
 900         autocmd BufEnter,CursorHold,FileType * call
 901                     \ s:AutoUpdate(fnamemodify(expand('<afile>'), ':p'))
 902         autocmd BufDelete * call
 903                     \ s:CleanupFileinfo(fnamemodify(expand('<afile>'), ':p'))
 904     augroup END
 905
 906     let s:autocommands_done = 1
 907 endfunction
 908
 909 " s:CheckForExCtags() {{{2
 910 " Test whether the ctags binary is actually Exuberant Ctags and not GNU ctags
 911 " (or something else)
 912 function! s:CheckForExCtags()
 913     call s:LogDebugMessage('Checking for Exuberant Ctags')
 914
 915     let ctags_cmd = s:EscapeCtagsCmd(g:tagbar_ctags_bin, '--version')
 916     if ctags_cmd == ''
 917         return
 918     endif
 919
 920     let ctags_output = s:ExecuteCtags(ctags_cmd)
 921
 922     if v:shell_error || ctags_output !~# 'Exuberant Ctags'
 923         echoerr 'Tagbar: Ctags doesn''t seem to be Exuberant Ctags!'
 924         echomsg 'GNU ctags will NOT WORK.'
 925               \ 'Please download Exuberant Ctags from ctags.sourceforge.net'
 926               \ 'and install it in a directory in your $PATH'
 927               \ 'or set g:tagbar_ctags_bin.'
 928         echomsg 'Executed command: "' . ctags_cmd . '"'
 929         if !empty(ctags_output)
 930             echomsg 'Command output:'
 931             for line in split(ctags_output, '\n')
 932                 echomsg line
 933             endfor
 934         endif
 935         return 0
 936     elseif !s:CheckExCtagsVersion(ctags_output)
 937         echoerr 'Tagbar: Exuberant Ctags is too old!'
 938         echomsg 'You need at least version 5.5 for Tagbar to work.'
 939               \ 'Please download a newer version from ctags.sourceforge.net.'
 940         echomsg 'Executed command: "' . ctags_cmd . '"'
 941         if !empty(ctags_output)
 942             echomsg 'Command output:'
 943             for line in split(ctags_output, '\n')
 944                 echomsg line
 945             endfor
 946         endif
 947         return 0
 948     else
 949         let s:checked_ctags = 1
 950         return 1
 951     endif
 952 endfunction
 953
 954 " s:CheckExCtagsVersion() {{{2
 955 function! s:CheckExCtagsVersion(output)
 956     call s:LogDebugMessage('Checking Exuberant Ctags version')
 957
 958     if a:output =~ 'Exuberant Ctags Development'
 959         return 1
 960     endif
 961
 962     let matchlist = matchlist(a:output, '\vExuberant Ctags (\d+)\.(\d+)')
 963     let major     = matchlist[1]
 964     let minor     = matchlist[2]
 965
 966     return major >= 6 || (major == 5 && minor >= 5)
 967 endfunction
 968
 969 " s:CheckFTCtags() {{{2
 970 function! s:CheckFTCtags(bin, ftype)
 971     if executable(a:bin)
 972         return a:bin
 973     endif
 974
 975     if exists('g:tagbar_type_' . a:ftype)
 976         execute 'let userdef = ' . 'g:tagbar_type_' . a:ftype
 977         if has_key(userdef, 'ctagsbin')
 978             return userdef.ctagsbin
 979         else
 980             return ''
 981         endif
 982     endif
 983
 984     return ''
 985 endfunction
 986
 987 " Prototypes {{{1
 988 " Base tag {{{2
 989 let s:BaseTag = {}
 990
 991 " s:BaseTag._init() {{{3
 992 function! s:BaseTag._init(name) dict
 993     let self.name        = a:name
 994     let self.fields      = {}
 995     let self.fields.line = 0
 996     let self.path        = ''
 997     let self.fullpath    = a:name
 998     let self.depth       = 0
 999     let self.parent      = {}
1000     let self.tline       = -1
1001     let self.fileinfo    = {}
1002 endfunction
1003
1004 " s:BaseTag.isNormalTag() {{{3
1005 function! s:BaseTag.isNormalTag() dict
1006     return 0
1007 endfunction
1008
1009 " s:BaseTag.isPseudoTag() {{{3
1010 function! s:BaseTag.isPseudoTag() dict
1011     return 0
1012 endfunction
1013
1014 " s:BaseTag.isKindheader() {{{3
1015 function! s:BaseTag.isKindheader() dict
1016     return 0
1017 endfunction
1018
1019 " s:BaseTag.getPrototype() {{{3
1020 function! s:BaseTag.getPrototype() dict
1021     return ''
1022 endfunction
1023
1024 " s:BaseTag._getPrefix() {{{3
1025 function! s:BaseTag._getPrefix() dict
1026     let fileinfo = self.fileinfo
1027
1028     if has_key(self, 'children') && !empty(self.children)
1029         if fileinfo.tagfolds[self.fields.kind][self.fullpath]
1030             let prefix = s:icon_closed
1031         else
1032             let prefix = s:icon_open
1033         endif
1034     else
1035         let prefix = ' '
1036     endif
1037     if has_key(self.fields, 'access')
1038         let prefix .= get(s:access_symbols, self.fields.access, ' ')
1039     else
1040         let prefix .= ' '
1041     endif
1042
1043     return prefix
1044 endfunction
1045
1046 " s:BaseTag.initFoldState() {{{3
1047 function! s:BaseTag.initFoldState() dict
1048     let fileinfo = self.fileinfo
1049
1050     if s:known_files.has(fileinfo.fpath) &&
1051      \ has_key(fileinfo._tagfolds_old[self.fields.kind], self.fullpath)
1052         " The file has been updated and the tag was there before, so copy its
1053         " old fold state
1054         let fileinfo.tagfolds[self.fields.kind][self.fullpath] =
1055                     \ fileinfo._tagfolds_old[self.fields.kind][self.fullpath]
1056     elseif self.depth >= fileinfo.foldlevel
1057         let fileinfo.tagfolds[self.fields.kind][self.fullpath] = 1
1058     else
1059         let fileinfo.tagfolds[self.fields.kind][self.fullpath] =
1060                     \ fileinfo.kindfolds[self.fields.kind]
1061     endif
1062 endfunction
1063
1064 " s:BaseTag.getClosedParentTline() {{{3
1065 function! s:BaseTag.getClosedParentTline() dict
1066     let tagline = self.tline
1067     let fileinfo = self.fileinfo
1068
1069     let parent = self.parent
1070     while !empty(parent)
1071         if parent.isFolded()
1072             let tagline = parent.tline
1073             break
1074         endif
1075         let parent = parent.parent
1076     endwhile
1077
1078     return tagline
1079 endfunction
1080
1081 " s:BaseTag.isFoldable() {{{3
1082 function! s:BaseTag.isFoldable() dict
1083     return has_key(self, 'children') && !empty(self.children)
1084 endfunction
1085
1086 " s:BaseTag.isFolded() {{{3
1087 function! s:BaseTag.isFolded() dict
1088     return self.fileinfo.tagfolds[self.fields.kind][self.fullpath]
1089 endfunction
1090
1091 " s:BaseTag.openFold() {{{3
1092 function! s:BaseTag.openFold() dict
1093     if self.isFoldable()
1094         let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 0
1095     endif
1096 endfunction
1097
1098 " s:BaseTag.closeFold() {{{3
1099 function! s:BaseTag.closeFold() dict
1100     let newline = line('.')
1101
1102     if !empty(self.parent) && self.parent.isKindheader()
1103         " Tag is child of generic 'kind'
1104         call self.parent.closeFold()
1105         let newline = self.parent.tline
1106     elseif self.isFoldable() && !self.isFolded()
1107         " Tag is parent of a scope and is not folded
1108         let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 1
1109         let newline = self.tline
1110     elseif !empty(self.parent)
1111         " Tag is normal child, so close parent
1112         let parent = self.parent
1113         let self.fileinfo.tagfolds[parent.fields.kind][parent.fullpath] = 1
1114         let newline = parent.tline
1115     endif
1116
1117     return newline
1118 endfunction
1119
1120 " s:BaseTag.setFolded() {{{3
1121 function! s:BaseTag.setFolded(folded) dict
1122     let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = a:folded
1123 endfunction
1124
1125 " s:BaseTag.openParents() {{{3
1126 function! s:BaseTag.openParents() dict
1127     let parent = self.parent
1128
1129     while !empty(parent)
1130         call parent.openFold()
1131         let parent = parent.parent
1132     endwhile
1133 endfunction
1134
1135 " Normal tag {{{2
1136 let s:NormalTag = copy(s:BaseTag)
1137
1138 " s:NormalTag.New() {{{3
1139 function! s:NormalTag.New(name) dict
1140     let newobj = copy(self)
1141
1142     call newobj._init(a:name)
1143
1144     return newobj
1145 endfunction
1146
1147 " s:NormalTag.isNormalTag() {{{3
1148 function! s:NormalTag.isNormalTag() dict
1149     return 1
1150 endfunction
1151
1152 " s:NormalTag.str() {{{3
1153 function! s:NormalTag.str() dict
1154     let fileinfo = self.fileinfo
1155     let typeinfo = s:known_types[fileinfo.ftype]
1156
1157     let suffix = get(self.fields, 'signature', '')
1158     if has_key(self.fields, 'type')
1159         let suffix .= ' : ' . self.fields.type
1160     elseif has_key(typeinfo, 'kind2scope') &&
1161          \ has_key(typeinfo.kind2scope, self.fields.kind)
1162         let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
1163     endif
1164
1165     return self._getPrefix() . self.name . suffix . "\n"
1166 endfunction
1167
1168 " s:NormalTag.getPrototype() {{{3
1169 function! s:NormalTag.getPrototype() dict
1170     return self.prototype
1171 endfunction
1172
1173 " Pseudo tag {{{2
1174 let s:PseudoTag = copy(s:BaseTag)
1175
1176 " s:PseudoTag.New() {{{3
1177 function! s:PseudoTag.New(name) dict
1178     let newobj = copy(self)
1179
1180     call newobj._init(a:name)
1181
1182     return newobj
1183 endfunction
1184
1185 " s:PseudoTag.isPseudoTag() {{{3
1186 function! s:PseudoTag.isPseudoTag() dict
1187     return 1
1188 endfunction
1189
1190 " s:PseudoTag.str() {{{3
1191 function! s:PseudoTag.str() dict
1192     let fileinfo = self.fileinfo
1193     let typeinfo = s:known_types[fileinfo.ftype]
1194
1195     let suffix = get(self.fields, 'signature', '')
1196     if has_key(typeinfo.kind2scope, self.fields.kind)
1197         let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
1198     endif
1199
1200     return self._getPrefix() . self.name . '*' . suffix
1201 endfunction
1202
1203 " Kind header {{{2
1204 let s:KindheaderTag = copy(s:BaseTag)
1205
1206 " s:KindheaderTag.New() {{{3
1207 function! s:KindheaderTag.New(name) dict
1208     let newobj = copy(self)
1209
1210     call newobj._init(a:name)
1211
1212     return newobj
1213 endfunction
1214
1215 " s:KindheaderTag.isKindheader() {{{3
1216 function! s:KindheaderTag.isKindheader() dict
1217     return 1
1218 endfunction
1219
1220 " s:KindheaderTag.getPrototype() {{{3
1221 function! s:KindheaderTag.getPrototype() dict
1222     return self.name . ': ' .
1223          \ self.numtags . ' ' . (self.numtags > 1 ? 'tags' : 'tag')
1224 endfunction
1225
1226 " s:KindheaderTag.isFoldable() {{{3
1227 function! s:KindheaderTag.isFoldable() dict
1228     return 1
1229 endfunction
1230
1231 " s:KindheaderTag.isFolded() {{{3
1232 function! s:KindheaderTag.isFolded() dict
1233     return self.fileinfo.kindfolds[self.short]
1234 endfunction
1235
1236 " s:KindheaderTag.openFold() {{{3
1237 function! s:KindheaderTag.openFold() dict
1238     let self.fileinfo.kindfolds[self.short] = 0
1239 endfunction
1240
1241 " s:KindheaderTag.closeFold() {{{3
1242 function! s:KindheaderTag.closeFold() dict
1243     let self.fileinfo.kindfolds[self.short] = 1
1244     return line('.')
1245 endfunction
1246
1247 " s:KindheaderTag.toggleFold() {{{3
1248 function! s:KindheaderTag.toggleFold() dict
1249     let fileinfo = s:known_files.getCurrent()
1250
1251     let fileinfo.kindfolds[self.short] = !fileinfo.kindfolds[self.short]
1252 endfunction
1253
1254 " File info {{{2
1255 let s:FileInfo = {}
1256
1257 " s:FileInfo.New() {{{3
1258 function! s:FileInfo.New(fname, ftype) dict
1259     let newobj = copy(self)
1260
1261     " The complete file path
1262     let newobj.fpath = a:fname
1263
1264     " File modification time
1265     let newobj.mtime = getftime(a:fname)
1266
1267     " The vim file type
1268     let newobj.ftype = a:ftype
1269
1270     " List of the tags that are present in the file, sorted according to the
1271     " value of 'g:tagbar_sort'
1272     let newobj.tags = []
1273
1274     " Dictionary of the tags, indexed by line number in the file
1275     let newobj.fline = {}
1276
1277     " Dictionary of the tags, indexed by line number in the tagbar
1278     let newobj.tline = {}
1279
1280     " Dictionary of the folding state of 'kind's, indexed by short name
1281     let newobj.kindfolds = {}
1282     let typeinfo = s:known_types[a:ftype]
1283     " copy the default fold state from the type info
1284     for kind in typeinfo.kinds
1285         let newobj.kindfolds[kind.short] =
1286                     \ g:tagbar_foldlevel == 0 ? 1 : kind.fold
1287     endfor
1288
1289     " Dictionary of dictionaries of the folding state of individual tags,
1290     " indexed by kind and full path
1291     let newobj.tagfolds = {}
1292     for kind in typeinfo.kinds
1293         let newobj.tagfolds[kind.short] = {}
1294     endfor
1295
1296     " The current foldlevel of the file
1297     let newobj.foldlevel = g:tagbar_foldlevel
1298
1299     return newobj
1300 endfunction
1301
1302 " s:FileInfo.reset() {{{3
1303 " Reset stuff that gets regenerated while processing a file and save the old
1304 " tag folds
1305 function! s:FileInfo.reset() dict
1306     let self.mtime = getftime(self.fpath)
1307     let self.tags  = []
1308     let self.fline = {}
1309     let self.tline = {}
1310
1311     let self._tagfolds_old = self.tagfolds
1312     let self.tagfolds = {}
1313
1314     let typeinfo = s:known_types[self.ftype]
1315     for kind in typeinfo.kinds
1316         let self.tagfolds[kind.short] = {}
1317     endfor
1318 endfunction
1319
1320 " s:FileInfo.clearOldFolds() {{{3
1321 function! s:FileInfo.clearOldFolds() dict
1322     if exists('self._tagfolds_old')
1323         unlet self._tagfolds_old
1324     endif
1325 endfunction
1326
1327 " s:FileInfo.sortTags() {{{3
1328 function! s:FileInfo.sortTags() dict
1329     if has_key(s:compare_typeinfo, 'sort')
1330         if s:compare_typeinfo.sort
1331             call s:SortTags(self.tags, 's:CompareByKind')
1332         else
1333             call s:SortTags(self.tags, 's:CompareByLine')
1334         endif
1335     elseif g:tagbar_sort
1336         call s:SortTags(self.tags, 's:CompareByKind')
1337     else
1338         call s:SortTags(self.tags, 's:CompareByLine')
1339     endif
1340 endfunction
1341
1342 " s:FileInfo.openKindFold() {{{3
1343 function! s:FileInfo.openKindFold(kind) dict
1344     let self.kindfolds[a:kind.short] = 0
1345 endfunction
1346
1347 " s:FileInfo.closeKindFold() {{{3
1348 function! s:FileInfo.closeKindFold(kind) dict
1349     let self.kindfolds[a:kind.short] = 1
1350 endfunction
1351
1352 " Known files {{{2
1353 let s:known_files = {
1354     \ '_current' : {},
1355     \ '_files'   : {}
1356 \ }
1357
1358 " s:known_files.getCurrent() {{{3
1359 function! s:known_files.getCurrent() dict
1360     return self._current
1361 endfunction
1362
1363 " s:known_files.setCurrent() {{{3
1364 function! s:known_files.setCurrent(fileinfo) dict
1365     let self._current = a:fileinfo
1366 endfunction
1367
1368 " s:known_files.get() {{{3
1369 function! s:known_files.get(fname) dict
1370     return get(self._files, a:fname, {})
1371 endfunction
1372
1373 " s:known_files.put() {{{3
1374 " Optional second argument is the filename
1375 function! s:known_files.put(fileinfo, ...) dict
1376     if a:0 == 1
1377         let self._files[a:1] = a:fileinfo
1378     else
1379         let fname = a:fileinfo.fpath
1380         let self._files[fname] = a:fileinfo
1381     endif
1382 endfunction
1383
1384 " s:known_files.has() {{{3
1385 function! s:known_files.has(fname) dict
1386     return has_key(self._files, a:fname)
1387 endfunction
1388
1389 " s:known_files.rm() {{{3
1390 function! s:known_files.rm(fname) dict
1391     if s:known_files.has(a:fname)
1392         call remove(self._files, a:fname)
1393     endif
1394 endfunction
1395
1396 " Window management {{{1
1397 " s:ToggleWindow() {{{2
1398 function! s:ToggleWindow()
1399     let tagbarwinnr = bufwinnr("__Tagbar__")
1400     if tagbarwinnr != -1
1401         call s:CloseWindow()
1402         return
1403     endif
1404
1405     call s:OpenWindow('')
1406 endfunction
1407
1408 " s:OpenWindow() {{{2
1409 function! s:OpenWindow(flags)
1410     let autofocus = a:flags =~# 'f'
1411     let jump      = a:flags =~# 'j'
1412     let autoclose = a:flags =~# 'c'
1413
1414     " If the tagbar window is already open check jump flag
1415     " Also set the autoclose flag if requested
1416     let tagbarwinnr = bufwinnr('__Tagbar__')
1417     if tagbarwinnr != -1
1418         if winnr() != tagbarwinnr && jump
1419             execute tagbarwinnr . 'wincmd w'
1420             if autoclose
1421                 let w:autoclose = autoclose
1422             endif
1423         endif
1424         return
1425     endif
1426
1427     call s:Init()
1428
1429     " Expand the Vim window to accomodate for the Tagbar window if requested
1430     if g:tagbar_expand && !s:window_expanded && has('gui_running')
1431         let &columns += g:tagbar_width + 1
1432         let s:window_expanded = 1
1433     endif
1434
1435     let eventignore_save = &eventignore
1436     set eventignore=all
1437
1438     let openpos = g:tagbar_left ? 'topleft vertical ' : 'botright vertical '
1439     exe 'silent keepalt ' . openpos . g:tagbar_width . 'split ' . '__Tagbar__'
1440
1441     let &eventignore = eventignore_save
1442
1443     call s:InitWindow(autoclose)
1444
1445     wincmd p
1446
1447     " Jump back to the tagbar window if autoclose or autofocus is set. Can't
1448     " just stay in it since it wouldn't trigger the update event
1449     if g:tagbar_autoclose || autofocus || g:tagbar_autofocus
1450         let tagbarwinnr = bufwinnr('__Tagbar__')
1451         execute tagbarwinnr . 'wincmd w'
1452     endif
1453 endfunction
1454
1455 " s:InitWindow() {{{2
1456 function! s:InitWindow(autoclose)
1457     setlocal noreadonly " in case the "view" mode is used
1458     setlocal buftype=nofile
1459     setlocal bufhidden=hide
1460     setlocal noswapfile
1461     setlocal nobuflisted
1462     setlocal nomodifiable
1463     setlocal filetype=tagbar
1464     setlocal nolist
1465     setlocal nonumber
1466     setlocal nowrap
1467     setlocal winfixwidth
1468     setlocal textwidth=0
1469     setlocal nocursorline
1470     setlocal nocursorcolumn
1471
1472     if exists('+relativenumber')
1473         setlocal norelativenumber
1474     endif
1475
1476     setlocal nofoldenable
1477     setlocal foldcolumn=0
1478     " Reset fold settings in case a plugin set them globally to something
1479     " expensive. Apparently 'foldexpr' gets executed even if 'foldenable' is
1480     " off, and then for every appended line (like with :put).
1481     setlocal foldmethod&
1482     setlocal foldexpr&
1483
1484     " Earlier versions have a bug in local, evaluated statuslines
1485     if v:version > 701 || (v:version == 701 && has('patch097'))
1486         setlocal statusline=%!TagbarGenerateStatusline()
1487     else
1488         setlocal statusline=Tagbar
1489     endif
1490
1491     " Script-local variable needed since compare functions can't
1492     " take extra arguments
1493     let s:compare_typeinfo = {}
1494
1495     let s:is_maximized = 0
1496     let s:short_help   = 1
1497
1498     let w:autoclose = a:autoclose
1499
1500     if has('balloon_eval')
1501         setlocal balloonexpr=TagbarBalloonExpr()
1502         set ballooneval
1503     endif
1504
1505     let cpoptions_save = &cpoptions
1506     set cpoptions&vim
1507
1508     if !hasmapto('JumpToTag', 'n')
1509         call s:MapKeys()
1510     endif
1511
1512     if !s:autocommands_done
1513         call s:CreateAutocommands()
1514     endif
1515
1516     let &cpoptions = cpoptions_save
1517 endfunction
1518
1519 " s:CloseWindow() {{{2
1520 function! s:CloseWindow()
1521     let tagbarwinnr = bufwinnr('__Tagbar__')
1522     if tagbarwinnr == -1
1523         return
1524     endif
1525
1526     let tagbarbufnr = winbufnr(tagbarwinnr)
1527
1528     if winnr() == tagbarwinnr
1529         if winbufnr(2) != -1
1530             " Other windows are open, only close the tagbar one
1531             close
1532             wincmd p
1533         endif
1534     else
1535         " Go to the tagbar window, close it and then come back to the
1536         " original window
1537         let curbufnr = bufnr('%')
1538         execute tagbarwinnr . 'wincmd w'
1539         close
1540         " Need to jump back to the original window only if we are not
1541         " already in that window
1542         let winnum = bufwinnr(curbufnr)
1543         if winnr() != winnum
1544             exe winnum . 'wincmd w'
1545         endif
1546     endif
1547
1548     " If the Vim window has been expanded, and Tagbar is not open in any other
1549     " tabpages, shrink the window again
1550     if s:window_expanded
1551         let tablist = []
1552         for i in range(tabpagenr('$'))
1553             call extend(tablist, tabpagebuflist(i + 1))
1554         endfor
1555
1556         if index(tablist, tagbarbufnr) == -1
1557             let &columns -= g:tagbar_width + 1
1558             let s:window_expanded = 0
1559         endif
1560     endif
1561 endfunction
1562
1563 " s:ZoomWindow() {{{2
1564 function! s:ZoomWindow()
1565     if s:is_maximized
1566         execute 'vert resize ' . g:tagbar_width
1567         let s:is_maximized = 0
1568     else
1569         vert resize
1570         let s:is_maximized = 1
1571     endif
1572 endfunction
1573
1574 " Tag processing {{{1
1575 " s:ProcessFile() {{{2
1576 " Execute ctags and put the information into a 'FileInfo' object
1577 function! s:ProcessFile(fname, ftype)
1578     call s:LogDebugMessage('ProcessFile called on ' . a:fname)
1579
1580     if !s:IsValidFile(a:fname, a:ftype)
1581         call s:LogDebugMessage('Not a valid file, returning')
1582         return
1583     endif
1584
1585     let ctags_output = s:ExecuteCtagsOnFile(a:fname, a:ftype)
1586
1587     if ctags_output == -1
1588         call s:LogDebugMessage('Ctags error when processing file')
1589         " put an empty entry into known_files so the error message is only
1590         " shown once
1591         call s:known_files.put({}, a:fname)
1592         return
1593     elseif ctags_output == ''
1594         call s:LogDebugMessage('Ctags output empty')
1595         return
1596     endif
1597
1598     " If the file has only been updated preserve the fold states, otherwise
1599     " create a new entry
1600     if s:known_files.has(a:fname)
1601         let fileinfo = s:known_files.get(a:fname)
1602         call fileinfo.reset()
1603     else
1604         let fileinfo = s:FileInfo.New(a:fname, a:ftype)
1605     endif
1606
1607     let typeinfo = s:known_types[a:ftype]
1608
1609     " Parse the ctags output lines
1610     call s:LogDebugMessage('Parsing ctags output')
1611     let rawtaglist = split(ctags_output, '\n\+')
1612     for line in rawtaglist
1613         " skip comments
1614         if line =~# '^!_TAG_'
1615             continue
1616         endif
1617
1618         let parts = split(line, ';"')
1619         if len(parts) == 2 " Is a valid tag line
1620             let taginfo = s:ParseTagline(parts[0], parts[1], typeinfo, fileinfo)
1621             let fileinfo.fline[taginfo.fields.line] = taginfo
1622             call add(fileinfo.tags, taginfo)
1623         endif
1624     endfor
1625
1626     " Process scoped tags
1627     let processedtags = []
1628     if has_key(typeinfo, 'kind2scope')
1629         call s:LogDebugMessage('Processing scoped tags')
1630
1631         let scopedtags = []
1632         let is_scoped = 'has_key(typeinfo.kind2scope, v:val.fields.kind) ||
1633                        \ has_key(v:val, "scope")'
1634         let scopedtags += filter(copy(fileinfo.tags), is_scoped)
1635         call filter(fileinfo.tags, '!(' . is_scoped . ')')
1636
1637         call s:AddScopedTags(scopedtags, processedtags, {}, 0,
1638                            \ typeinfo, fileinfo)
1639
1640         if !empty(scopedtags)
1641             echoerr 'Tagbar: ''scopedtags'' not empty after processing,'
1642                   \ 'this should never happen!'
1643                   \ 'Please contact the script maintainer with an example.'
1644         endif
1645     endif
1646     call s:LogDebugMessage('Number of top-level tags: ' . len(processedtags))
1647
1648     " Create a placeholder tag for the 'kind' header for folding purposes
1649     for kind in typeinfo.kinds
1650
1651         let curtags = filter(copy(fileinfo.tags),
1652                            \ 'v:val.fields.kind ==# kind.short')
1653         call s:LogDebugMessage('Processing kind: ' . kind.short .
1654                              \ ', number of tags: ' . len(curtags))
1655
1656         if empty(curtags)
1657             continue
1658         endif
1659
1660         let kindtag          = s:KindheaderTag.New(kind.long)
1661         let kindtag.short    = kind.short
1662         let kindtag.numtags  = len(curtags)
1663         let kindtag.fileinfo = fileinfo
1664
1665         for tag in curtags
1666             let tag.parent = kindtag
1667         endfor
1668     endfor
1669
1670     if !empty(processedtags)
1671         call extend(fileinfo.tags, processedtags)
1672     endif
1673
1674     " Clear old folding information from previous file version to prevent leaks
1675     call fileinfo.clearOldFolds()
1676
1677     " Sort the tags
1678     let s:compare_typeinfo = typeinfo
1679     call fileinfo.sortTags()
1680
1681     call s:known_files.put(fileinfo)
1682 endfunction
1683
1684 " s:ExecuteCtagsOnFile() {{{2
1685 function! s:ExecuteCtagsOnFile(fname, ftype)
1686     call s:LogDebugMessage('ExecuteCtagsOnFile called on ' . a:fname)
1687
1688     let typeinfo = s:known_types[a:ftype]
1689
1690     if has_key(typeinfo, 'ctagsargs')
1691         let ctags_args = ' ' . typeinfo.ctagsargs . ' '
1692     else
1693         let ctags_args  = ' -f - '
1694         let ctags_args .= ' --format=2 '
1695         let ctags_args .= ' --excmd=pattern '
1696         let ctags_args .= ' --fields=nksSa '
1697         let ctags_args .= ' --extra= '
1698         let ctags_args .= ' --sort=yes '
1699
1700         " Include extra type definitions
1701         if has_key(typeinfo, 'deffile')
1702             let ctags_args .= ' --options=' . typeinfo.deffile . ' '
1703         endif
1704
1705         let ctags_type = typeinfo.ctagstype
1706
1707         let ctags_kinds = ''
1708         for kind in typeinfo.kinds
1709             let ctags_kinds .= kind.short
1710         endfor
1711
1712         let ctags_args .= ' --language-force=' . ctags_type .
1713                         \ ' --' . ctags_type . '-kinds=' . ctags_kinds . ' '
1714     endif
1715
1716     if has_key(typeinfo, 'ctagsbin')
1717         " reset 'wildignore' temporarily in case *.exe is included in it
1718         let wildignore_save = &wildignore
1719         set wildignore&
1720         let ctags_bin = expand(typeinfo.ctagsbin)
1721         let &wildignore = wildignore_save
1722     else
1723         let ctags_bin = g:tagbar_ctags_bin
1724     endif
1725
1726     let ctags_cmd = s:EscapeCtagsCmd(ctags_bin, ctags_args, a:fname)
1727     if ctags_cmd == ''
1728         return ''
1729     endif
1730
1731     let ctags_output = s:ExecuteCtags(ctags_cmd)
1732
1733     if v:shell_error || ctags_output =~ 'Warning: cannot open source file'
1734         echoerr 'Tagbar: Could not execute ctags for ' . a:fname . '!'
1735         echomsg 'Executed command: "' . ctags_cmd . '"'
1736         if !empty(ctags_output)
1737             call s:LogDebugMessage('Command output:')
1738             call s:LogDebugMessage(ctags_output)
1739             echomsg 'Command output:'
1740             for line in split(ctags_output, '\n')
1741                 echomsg line
1742             endfor
1743         endif
1744         return -1
1745     endif
1746
1747     call s:LogDebugMessage('Ctags executed successfully')
1748     return ctags_output
1749 endfunction
1750
1751 " s:ParseTagline() {{{2
1752 " Structure of a tag line:
1753 " tagname<TAB>filename<TAB>expattern;"fields
1754 " fields: <TAB>name:value
1755 " fields that are always present: kind, line
1756 function! s:ParseTagline(part1, part2, typeinfo, fileinfo)
1757     let basic_info  = split(a:part1, '\t')
1758
1759     let taginfo      = s:NormalTag.New(basic_info[0])
1760     let taginfo.file = basic_info[1]
1761
1762     " the pattern can contain tabs and thus may have been split up, so join
1763     " the rest of the items together again
1764     let pattern = join(basic_info[2:], "\t")
1765     let start   = 2 " skip the slash and the ^
1766     let end     = strlen(pattern) - 1
1767     if pattern[end - 1] ==# '$'
1768         let end -= 1
1769         let dollar = '\$'
1770     else
1771         let dollar = ''
1772     endif
1773     let pattern           = strpart(pattern, start, end - start)
1774     let taginfo.pattern   = '\V\^\C' . pattern . dollar
1775     let prototype         = substitute(pattern,   '^[[:space:]]\+', '', '')
1776     let prototype         = substitute(prototype, '[[:space:]]\+$', '', '')
1777     let taginfo.prototype = prototype
1778
1779     let fields = split(a:part2, '\t')
1780     let taginfo.fields.kind = remove(fields, 0)
1781     for field in fields
1782         " can't use split() since the value can contain ':'
1783         let delimit             = stridx(field, ':')
1784         let key                 = strpart(field, 0, delimit)
1785         let val                 = strpart(field, delimit + 1)
1786         if len(val) > 0
1787             let taginfo.fields[key] = val
1788         endif
1789     endfor
1790     " Needed for jsctags
1791     if has_key(taginfo.fields, 'lineno')
1792         let taginfo.fields.line = taginfo.fields.lineno
1793     endif
1794
1795     " Make some information easier accessible
1796     if has_key(a:typeinfo, 'scope2kind')
1797         for scope in keys(a:typeinfo.scope2kind)
1798             if has_key(taginfo.fields, scope)
1799                 let taginfo.scope = scope
1800                 let taginfo.path  = taginfo.fields[scope]
1801
1802                 let taginfo.fullpath = taginfo.path . a:typeinfo.sro .
1803                                      \ taginfo.name
1804                 break
1805             endif
1806         endfor
1807         let taginfo.depth = len(split(taginfo.path, '\V' . a:typeinfo.sro))
1808     endif
1809
1810     let taginfo.fileinfo = a:fileinfo
1811
1812     " Needed for folding
1813     try
1814         call taginfo.initFoldState()
1815     catch /^Vim(\a\+):E716:/ " 'Key not present in Dictionary'
1816         " The tag has a 'kind' that doesn't exist in the type definition
1817         echoerr 'Your ctags and Tagbar configurations are out of sync!'
1818               \ 'Please read '':help tagbar-extend''.'
1819     endtry
1820
1821     return taginfo
1822 endfunction
1823
1824 " s:AddScopedTags() {{{2
1825 " Recursively process tags. Unfortunately there is a problem: not all tags in
1826 " a hierarchy are actually there. For example, in C++ a class can be defined
1827 " in a header file and implemented in a .cpp file (so the class itself doesn't
1828 " appear in the .cpp file and thus doesn't generate a tag). Another example
1829 " are anonymous structures like namespaces, structs, enums, and unions, that
1830 " also don't get a tag themselves. These tags are thus called 'pseudo-tags' in
1831 " Tagbar. Properly parsing them is quite tricky, so try not to think about it
1832 " too much.
1833 function! s:AddScopedTags(tags, processedtags, parent, depth,
1834                         \ typeinfo, fileinfo)
1835     if !empty(a:parent)
1836         let curpath = a:parent.fullpath
1837         let pscope  = a:typeinfo.kind2scope[a:parent.fields.kind]
1838     else
1839         let curpath = ''
1840         let pscope  = ''
1841     endif
1842
1843     let is_cur_tag = 'v:val.depth == a:depth'
1844
1845     if !empty(curpath)
1846         " Check whether the tag is either a direct child at the current depth
1847         " or at least a proper grandchild with pseudo-tags in between. If it
1848         " is a direct child also check for matching scope.
1849         let is_cur_tag .= ' &&
1850         \ (v:val.path ==# curpath ||
1851          \ match(v:val.path, ''\V\^\C'' . curpath . a:typeinfo.sro) == 0) &&
1852         \ (v:val.path ==# curpath ? (v:val.scope ==# pscope) : 1)'
1853     endif
1854
1855     let curtags = filter(copy(a:tags), is_cur_tag)
1856
1857     if !empty(curtags)
1858         call filter(a:tags, '!(' . is_cur_tag . ')')
1859
1860         let realtags   = []
1861         let pseudotags = []
1862
1863         while !empty(curtags)
1864             let tag = remove(curtags, 0)
1865
1866             if tag.path != curpath
1867                 " tag is child of a pseudo-tag, so create a new pseudo-tag and
1868                 " add all its children to it
1869                 let pseudotag = s:ProcessPseudoTag(curtags, tag, a:parent,
1870                                                  \ a:typeinfo, a:fileinfo)
1871
1872                 call add(pseudotags, pseudotag)
1873             else
1874                 call add(realtags, tag)
1875             endif
1876         endwhile
1877
1878         " Recursively add the children of the tags on the current level
1879         for tag in realtags
1880             let tag.parent = a:parent
1881
1882             if !has_key(a:typeinfo.kind2scope, tag.fields.kind)
1883                 continue
1884             endif
1885
1886             if !has_key(tag, 'children')
1887                 let tag.children = []
1888             endif
1889
1890             call s:AddScopedTags(a:tags, tag.children, tag, a:depth + 1,
1891                                \ a:typeinfo, a:fileinfo)
1892         endfor
1893         call extend(a:processedtags, realtags)
1894
1895         " Recursively add the children of the tags that are children of the
1896         " pseudo-tags on the current level
1897         for tag in pseudotags
1898             call s:ProcessPseudoChildren(a:tags, tag, a:depth, a:typeinfo,
1899                                        \ a:fileinfo)
1900         endfor
1901         call extend(a:processedtags, pseudotags)
1902     endif
1903
1904     " Now we have to check if there are any pseudo-tags at the current level
1905     " so we have to check for real tags at a lower level, i.e. grandchildren
1906     let is_grandchild = 'v:val.depth > a:depth'
1907
1908     if !empty(curpath)
1909         let is_grandchild .=
1910         \ ' && match(v:val.path, ''\V\^\C'' . curpath . a:typeinfo.sro) == 0'
1911     endif
1912
1913     let grandchildren = filter(copy(a:tags), is_grandchild)
1914
1915     if !empty(grandchildren)
1916         call s:AddScopedTags(a:tags, a:processedtags, a:parent, a:depth + 1,
1917                            \ a:typeinfo, a:fileinfo)
1918     endif
1919 endfunction
1920
1921 " s:ProcessPseudoTag() {{{2
1922 function! s:ProcessPseudoTag(curtags, tag, parent, typeinfo, fileinfo)
1923     let curpath = !empty(a:parent) ? a:parent.fullpath : ''
1924
1925     let pseudoname = substitute(a:tag.path, curpath, '', '')
1926     let pseudoname = substitute(pseudoname, '\V\^' . a:typeinfo.sro, '', '')
1927     let pseudotag  = s:CreatePseudoTag(pseudoname, a:parent, a:tag.scope,
1928                                      \ a:typeinfo, a:fileinfo)
1929     let pseudotag.children = [a:tag]
1930
1931     " get all the other (direct) children of the current pseudo-tag
1932     let ispseudochild = 'v:val.path ==# a:tag.path && v:val.scope ==# a:tag.scope'
1933     let pseudochildren = filter(copy(a:curtags), ispseudochild)
1934     if !empty(pseudochildren)
1935         call filter(a:curtags, '!(' . ispseudochild . ')')
1936         call extend(pseudotag.children, pseudochildren)
1937     endif
1938
1939     return pseudotag
1940 endfunction
1941
1942 " s:ProcessPseudoChildren() {{{2
1943 function! s:ProcessPseudoChildren(tags, tag, depth, typeinfo, fileinfo)
1944     for childtag in a:tag.children
1945         let childtag.parent = a:tag
1946
1947         if !has_key(a:typeinfo.kind2scope, childtag.fields.kind)
1948             continue
1949         endif
1950
1951         if !has_key(childtag, 'children')
1952             let childtag.children = []
1953         endif
1954
1955         call s:AddScopedTags(a:tags, childtag.children, childtag, a:depth + 1,
1956                            \ a:typeinfo, a:fileinfo)
1957     endfor
1958
1959     let is_grandchild = 'v:val.depth > a:depth &&
1960                        \ match(v:val.path, ''^\C'' . a:tag.fullpath) == 0'
1961     let grandchildren = filter(copy(a:tags), is_grandchild)
1962     if !empty(grandchildren)
1963         call s:AddScopedTags(a:tags, a:tag.children, a:tag, a:depth + 1,
1964                            \ a:typeinfo, a:fileinfo)
1965     endif
1966 endfunction
1967
1968 " s:CreatePseudoTag() {{{2
1969 function! s:CreatePseudoTag(name, parent, scope, typeinfo, fileinfo)
1970     if !empty(a:parent)
1971         let curpath = a:parent.fullpath
1972         let pscope  = a:typeinfo.kind2scope[a:parent.fields.kind]
1973     else
1974         let curpath = ''
1975         let pscope  = ''
1976     endif
1977
1978     let pseudotag             = s:PseudoTag.New(a:name)
1979     let pseudotag.fields.kind = a:typeinfo.scope2kind[a:scope]
1980
1981     let parentscope = substitute(curpath, a:name . '$', '', '')
1982     let parentscope = substitute(parentscope,
1983                                \ '\V\^' . a:typeinfo.sro . '\$', '', '')
1984
1985     if pscope != ''
1986         let pseudotag.fields[pscope] = parentscope
1987         let pseudotag.scope    = pscope
1988         let pseudotag.path     = parentscope
1989         let pseudotag.fullpath =
1990                     \ pseudotag.path . a:typeinfo.sro . pseudotag.name
1991     endif
1992     let pseudotag.depth = len(split(pseudotag.path, '\V' . a:typeinfo.sro))
1993
1994     let pseudotag.parent = a:parent
1995
1996     let pseudotag.fileinfo = a:fileinfo
1997
1998     call pseudotag.initFoldState()
1999
2000     return pseudotag
2001 endfunction
2002
2003 " Sorting {{{1
2004 " s:SortTags() {{{2
2005 function! s:SortTags(tags, comparemethod)
2006     call sort(a:tags, a:comparemethod)
2007
2008     for tag in a:tags
2009         if has_key(tag, 'children')
2010             call s:SortTags(tag.children, a:comparemethod)
2011         endif
2012     endfor
2013 endfunction
2014
2015 " s:CompareByKind() {{{2
2016 function! s:CompareByKind(tag1, tag2)
2017     let typeinfo = s:compare_typeinfo
2018
2019     if typeinfo.kinddict[a:tag1.fields.kind] <#
2020      \ typeinfo.kinddict[a:tag2.fields.kind]
2021         return -1
2022     elseif typeinfo.kinddict[a:tag1.fields.kind] >#
2023          \ typeinfo.kinddict[a:tag2.fields.kind]
2024         return 1
2025     else
2026         " Ignore '~' prefix for C++ destructors to sort them directly under
2027         " the constructors
2028         if a:tag1.name[0] ==# '~'
2029             let name1 = a:tag1.name[1:]
2030         else
2031             let name1 = a:tag1.name
2032         endif
2033         if a:tag2.name[0] ==# '~'
2034             let name2 = a:tag2.name[1:]
2035         else
2036             let name2 = a:tag2.name
2037         endif
2038
2039         if name1 <=# name2
2040             return -1
2041         else
2042             return 1
2043         endif
2044     endif
2045 endfunction
2046
2047 " s:CompareByLine() {{{2
2048 function! s:CompareByLine(tag1, tag2)
2049     return a:tag1.fields.line - a:tag2.fields.line
2050 endfunction
2051
2052 " s:ToggleSort() {{{2
2053 function! s:ToggleSort()
2054     let fileinfo = s:known_files.getCurrent()
2055     if empty(fileinfo)
2056         return
2057     endif
2058
2059     let curline = line('.')
2060
2061     match none
2062
2063     let s:compare_typeinfo = s:known_types[fileinfo.ftype]
2064
2065     if has_key(s:compare_typeinfo, 'sort')
2066         let s:compare_typeinfo.sort = !s:compare_typeinfo.sort
2067     else
2068         let g:tagbar_sort = !g:tagbar_sort
2069     endif
2070
2071     call fileinfo.sortTags()
2072
2073     call s:RenderContent()
2074
2075     execute curline
2076 endfunction
2077
2078 " Display {{{1
2079 " s:RenderContent() {{{2
2080 function! s:RenderContent(...)
2081     call s:LogDebugMessage('RenderContent called')
2082
2083     if a:0 == 1
2084         let fileinfo = a:1
2085     else
2086         let fileinfo = s:known_files.getCurrent()
2087     endif
2088
2089     if empty(fileinfo)
2090         call s:LogDebugMessage('Empty fileinfo, returning')
2091         return
2092     endif
2093
2094     let tagbarwinnr = bufwinnr('__Tagbar__')
2095
2096     if &filetype == 'tagbar'
2097         let in_tagbar = 1
2098     else
2099         let in_tagbar = 0
2100         let prevwinnr = winnr()
2101         execute tagbarwinnr . 'wincmd w'
2102     endif
2103
2104     if !empty(s:known_files.getCurrent()) &&
2105      \ fileinfo.fpath ==# s:known_files.getCurrent().fpath
2106         " We're redisplaying the same file, so save the view
2107         call s:LogDebugMessage('Redisplaying file' . fileinfo.fpath)
2108         let saveline = line('.')
2109         let savecol  = col('.')
2110         let topline  = line('w0')
2111     endif
2112
2113     let lazyredraw_save = &lazyredraw
2114     set lazyredraw
2115     let eventignore_save = &eventignore
2116     set eventignore=all
2117
2118     setlocal modifiable
2119
2120     silent %delete _
2121
2122     call s:PrintHelp()
2123
2124     let typeinfo = s:known_types[fileinfo.ftype]
2125
2126     " Print tags
2127     call s:PrintKinds(typeinfo, fileinfo)
2128
2129     " Delete empty lines at the end of the buffer
2130     for linenr in range(line('$'), 1, -1)
2131         if getline(linenr) =~ '^$'
2132             execute 'silent ' . linenr . 'delete _'
2133         else
2134             break
2135         endif
2136     endfor
2137
2138     setlocal nomodifiable
2139
2140     if !empty(s:known_files.getCurrent()) &&
2141      \ fileinfo.fpath ==# s:known_files.getCurrent().fpath
2142         let scrolloff_save = &scrolloff
2143         set scrolloff=0
2144
2145         call cursor(topline, 1)
2146         normal! zt
2147         call cursor(saveline, savecol)
2148
2149         let &scrolloff = scrolloff_save
2150     else
2151         " Make sure as much of the Tagbar content as possible is shown in the
2152         " window by jumping to the top after drawing
2153         execute 1
2154         call winline()
2155
2156         " Invalidate highlight cache from old file
2157         let s:last_highlight_tline = 0
2158     endif
2159
2160     let &lazyredraw  = lazyredraw_save
2161     let &eventignore = eventignore_save
2162
2163     if !in_tagbar
2164         execute prevwinnr . 'wincmd w'
2165     endif
2166 endfunction
2167
2168 " s:PrintKinds() {{{2
2169 function! s:PrintKinds(typeinfo, fileinfo)
2170     call s:LogDebugMessage('PrintKinds called')
2171
2172     let first_tag = 1
2173
2174     for kind in a:typeinfo.kinds
2175         let curtags = filter(copy(a:fileinfo.tags),
2176                            \ 'v:val.fields.kind ==# kind.short')
2177         call s:LogDebugMessage('Printing kind: ' . kind.short .
2178                              \ ', number of (top-level) tags: ' . len(curtags))
2179
2180         if empty(curtags)
2181             continue
2182         endif
2183
2184         if has_key(a:typeinfo, 'kind2scope') &&
2185          \ has_key(a:typeinfo.kind2scope, kind.short)
2186             " Scoped tags
2187             for tag in curtags
2188                 if g:tagbar_compact && first_tag && s:short_help
2189                     silent 0put =tag.str()
2190                 else
2191                     silent  put =tag.str()
2192                 endif
2193
2194                 " Save the current tagbar line in the tag for easy
2195                 " highlighting access
2196                 let curline                   = line('.')
2197                 let tag.tline                 = curline
2198                 let a:fileinfo.tline[curline] = tag
2199
2200                 " Print children
2201                 if tag.isFoldable() && !tag.isFolded()
2202                     for ckind in a:typeinfo.kinds
2203                         let childtags = filter(copy(tag.children),
2204                                           \ 'v:val.fields.kind ==# ckind.short')
2205                         if len(childtags) > 0
2206                             " Print 'kind' header of following children
2207                             if !has_key(a:typeinfo.kind2scope, ckind.short)
2208                                 silent put ='    [' . ckind.long . ']'
2209                                 let a:fileinfo.tline[line('.')] = tag
2210                             endif
2211                             for childtag in childtags
2212                                 call s:PrintTag(childtag, 1,
2213                                               \ a:fileinfo, a:typeinfo)
2214                             endfor
2215                         endif
2216                     endfor
2217                 endif
2218
2219                 if !g:tagbar_compact
2220                     silent put _
2221                 endif
2222
2223                 let first_tag = 0
2224             endfor
2225         else
2226             " Non-scoped tags
2227             let kindtag = curtags[0].parent
2228
2229             if kindtag.isFolded()
2230                 let foldmarker = s:icon_closed
2231             else
2232                 let foldmarker = s:icon_open
2233             endif
2234
2235             if g:tagbar_compact && first_tag && s:short_help
2236                 silent 0put =foldmarker . ' ' . kind.long
2237             else
2238                 silent  put =foldmarker . ' ' . kind.long
2239             endif
2240
2241             let curline                   = line('.')
2242             let kindtag.tline             = curline
2243             let a:fileinfo.tline[curline] = kindtag
2244
2245             if !kindtag.isFolded()
2246                 for tag in curtags
2247                     let str = tag.str()
2248                     silent put ='  ' . str
2249
2250                     " Save the current tagbar line in the tag for easy
2251                     " highlighting access
2252                     let curline                   = line('.')
2253                     let tag.tline                 = curline
2254                     let a:fileinfo.tline[curline] = tag
2255                     let tag.depth                 = 1
2256                 endfor
2257             endif
2258
2259             if !g:tagbar_compact
2260                 silent put _
2261             endif
2262
2263             let first_tag = 0
2264         endif
2265     endfor
2266 endfunction
2267
2268 " s:PrintTag() {{{2
2269 function! s:PrintTag(tag, depth, fileinfo, typeinfo)
2270     " Print tag indented according to depth
2271     silent put =repeat(' ', a:depth * 2) . a:tag.str()
2272
2273     " Save the current tagbar line in the tag for easy
2274     " highlighting access
2275     let curline                   = line('.')
2276     let a:tag.tline               = curline
2277     let a:fileinfo.tline[curline] = a:tag
2278
2279     " Recursively print children
2280     if a:tag.isFoldable() && !a:tag.isFolded()
2281         for ckind in a:typeinfo.kinds
2282             let childtags = filter(copy(a:tag.children),
2283                                  \ 'v:val.fields.kind ==# ckind.short')
2284             if len(childtags) > 0
2285                 " Print 'kind' header of following children
2286                 if !has_key(a:typeinfo.kind2scope, ckind.short)
2287                     silent put ='    ' . repeat(' ', a:depth * 2) .
2288                               \ '[' . ckind.long . ']'
2289                     let a:fileinfo.tline[line('.')] = a:tag
2290                 endif
2291                 for childtag in childtags
2292                     call s:PrintTag(childtag, a:depth + 1,
2293                                   \ a:fileinfo, a:typeinfo)
2294                 endfor
2295             endif
2296         endfor
2297     endif
2298 endfunction
2299
2300 " s:PrintHelp() {{{2
2301 function! s:PrintHelp()
2302     if !g:tagbar_compact && s:short_help
2303         silent 0put ='\" Press <F1> for help'
2304         silent  put _
2305     elseif !s:short_help
2306         silent 0put ='\" Tagbar keybindings'
2307         silent  put ='\"'
2308         silent  put ='\" --------- General ---------'
2309         silent  put ='\" <Enter>   : Jump to tag definition'
2310         silent  put ='\" <Space>   : Display tag prototype'
2311         silent  put ='\"'
2312         silent  put ='\" ---------- Folds ----------'
2313         silent  put ='\" +, zo     : Open fold'
2314         silent  put ='\" -, zc     : Close fold'
2315         silent  put ='\" o, za     : Toggle fold'
2316         silent  put ='\" *, zR     : Open all folds'
2317         silent  put ='\" =, zM     : Close all folds'
2318         silent  put ='\"'
2319         silent  put ='\" ---------- Misc -----------'
2320         silent  put ='\" s          : Toggle sort'
2321         silent  put ='\" x          : Zoom window in/out'
2322         silent  put ='\" q          : Close window'
2323         silent  put ='\" <F1>       : Remove help'
2324         silent  put _
2325     endif
2326 endfunction
2327
2328 " s:RenderKeepView() {{{2
2329 " The gist of this function was taken from NERDTree by Martin Grenfell.
2330 function! s:RenderKeepView(...)
2331     if a:0 == 1
2332         let line = a:1
2333     else
2334         let line = line('.')
2335     endif
2336
2337     let curcol  = col('.')
2338     let topline = line('w0')
2339
2340     call s:RenderContent()
2341
2342     let scrolloff_save = &scrolloff
2343     set scrolloff=0
2344
2345     call cursor(topline, 1)
2346     normal! zt
2347     call cursor(line, curcol)
2348
2349     let &scrolloff = scrolloff_save
2350
2351     redraw
2352 endfunction
2353
2354 " User actions {{{1
2355 " s:HighlightTag() {{{2
2356 function! s:HighlightTag()
2357     let tagline = 0
2358
2359     let tag = s:GetNearbyTag()
2360     if !empty(tag)
2361         let tagline = tag.tline
2362     endif
2363
2364     " Don't highlight the tag again if it's the same one as last time.
2365     " This prevents the Tagbar window from jumping back after scrolling with
2366     " the mouse.
2367     if tagline == s:last_highlight_tline
2368         return
2369     else
2370         let s:last_highlight_tline = tagline
2371     endif
2372
2373     let eventignore_save = &eventignore
2374     set eventignore=all
2375
2376     let tagbarwinnr = bufwinnr('__Tagbar__')
2377     let prevwinnr   = winnr()
2378     execute tagbarwinnr . 'wincmd w'
2379
2380     match none
2381
2382     " No tag above cursor position so don't do anything
2383     if tagline == 0
2384         execute prevwinnr . 'wincmd w'
2385         let &eventignore = eventignore_save
2386         redraw
2387         return
2388     endif
2389
2390     if g:tagbar_autoshowtag
2391         call s:OpenParents(tag)
2392     endif
2393
2394     " Check whether the tag is inside a closed fold and highlight the parent
2395     " instead in that case
2396     let tagline = tag.getClosedParentTline()
2397
2398     " Go to the line containing the tag
2399     execute tagline
2400
2401     " Make sure the tag is visible in the window
2402     call winline()
2403
2404     let foldpat = '[' . s:icon_open . s:icon_closed . ' ]'
2405     let pattern = '/^\%' . tagline . 'l\s*' . foldpat . '[-+# ]\zs[^( ]\+\ze/'
2406     execute 'match TagbarHighlight ' . pattern
2407
2408     execute prevwinnr . 'wincmd w'
2409
2410     let &eventignore = eventignore_save
2411
2412     redraw
2413 endfunction
2414
2415 " s:JumpToTag() {{{2
2416 function! s:JumpToTag(stay_in_tagbar)
2417     let taginfo = s:GetTagInfo(line('.'), 1)
2418
2419     let autoclose = w:autoclose
2420
2421     if empty(taginfo) || has_key(taginfo, 'numtags')
2422         return
2423     endif
2424
2425     let tagbarwinnr = winnr()
2426
2427     let eventignore_save = &eventignore
2428     set eventignore=all
2429
2430     " This elaborate construct will try to switch to the correct
2431     " buffer/window; if the buffer isn't currently shown in a window it will
2432     " open it in the first window with a non-special buffer in it
2433     wincmd p
2434     let filebufnr = bufnr(taginfo.fileinfo.fpath)
2435     if bufnr('%') != filebufnr
2436         let filewinnr = bufwinnr(filebufnr)
2437         if filewinnr != -1
2438             execute filewinnr . 'wincmd w'
2439         else
2440             for i in range(1, winnr('$'))
2441                 execute i . 'wincmd w'
2442                 if &buftype == ''
2443                     execute 'buffer ' . filebufnr
2444                     break
2445                 endif
2446             endfor
2447         endif
2448         " To make ctrl-w_p work we switch between the Tagbar window and the
2449         " correct window once
2450         execute tagbarwinnr . 'wincmd w'
2451         wincmd p
2452     endif
2453
2454     " Mark current position so it can be jumped back to
2455     mark '
2456
2457     " Jump to the line where the tag is defined. Don't use the search pattern
2458     " since it doesn't take the scope into account and thus can fail if tags
2459     " with the same name are defined in different scopes (e.g. classes)
2460     execute taginfo.fields.line
2461
2462     " If the file has been changed but not saved, the tag may not be on the
2463     " saved line anymore, so search for it in the vicinity of the saved line
2464     if match(getline('.'), taginfo.pattern) == -1
2465         let interval = 1
2466         let forward  = 1
2467         while search(taginfo.pattern, 'W' . forward ? '' : 'b') == 0
2468             if !forward
2469                 if interval > line('$')
2470                     break
2471                 else
2472                     let interval = interval * 2
2473                 endif
2474             endif
2475             let forward = !forward
2476         endwhile
2477     endif
2478
2479     " If the tag is on a different line after unsaved changes update the tag
2480     " and file infos/objects
2481     let curline = line('.')
2482     if taginfo.fields.line != curline
2483         let taginfo.fields.line = curline
2484         let taginfo.fileinfo.fline[curline] = taginfo
2485     endif
2486
2487     " Center the tag in the window
2488     normal! z.
2489
2490     if foldclosed('.') != -1
2491         .foldopen!
2492     endif
2493
2494     redraw
2495
2496     let &eventignore = eventignore_save
2497
2498     if a:stay_in_tagbar
2499         call s:HighlightTag()
2500         execute tagbarwinnr . 'wincmd w'
2501     elseif g:tagbar_autoclose || autoclose
2502         call s:CloseWindow()
2503     else
2504         call s:HighlightTag()
2505     endif
2506 endfunction
2507
2508 " s:ShowPrototype() {{{2
2509 function! s:ShowPrototype()
2510     let taginfo = s:GetTagInfo(line('.'), 1)
2511
2512     if empty(taginfo)
2513         return
2514     endif
2515
2516     echo taginfo.getPrototype()
2517 endfunction
2518
2519 " s:ToggleHelp() {{{2
2520 function! s:ToggleHelp()
2521     let s:short_help = !s:short_help
2522
2523     " Prevent highlighting from being off after adding/removing the help text
2524     match none
2525
2526     call s:RenderContent()
2527
2528     execute 1
2529     redraw
2530 endfunction
2531
2532 " s:GotoNextToplevelTag() {{{2
2533 function! s:GotoNextToplevelTag(direction)
2534     let curlinenr = line('.')
2535     let newlinenr = line('.')
2536
2537     if a:direction == 1
2538         let range = range(line('.') + 1, line('$'))
2539     else
2540         let range = range(line('.') - 1, 1, -1)
2541     endif
2542
2543     for tmplinenr in range
2544         let taginfo = s:GetTagInfo(tmplinenr, 0)
2545
2546         if empty(taginfo)
2547             continue
2548         elseif empty(taginfo.parent)
2549             let newlinenr = tmplinenr
2550             break
2551         endif
2552     endfor
2553
2554     if curlinenr != newlinenr
2555         execute newlinenr
2556         call winline()
2557     endif
2558
2559     redraw
2560 endfunction
2561
2562 " Folding {{{1
2563 " s:OpenFold() {{{2
2564 function! s:OpenFold()
2565     let fileinfo = s:known_files.getCurrent()
2566     if empty(fileinfo)
2567         return
2568     endif
2569
2570     let curline = line('.')
2571
2572     let tag = s:GetTagInfo(curline, 0)
2573     if empty(tag)
2574         return
2575     endif
2576
2577     call tag.openFold()
2578
2579     call s:RenderKeepView()
2580 endfunction
2581
2582 " s:CloseFold() {{{2
2583 function! s:CloseFold()
2584     let fileinfo = s:known_files.getCurrent()
2585     if empty(fileinfo)
2586         return
2587     endif
2588
2589     match none
2590
2591     let curline = line('.')
2592
2593     let curtag = s:GetTagInfo(curline, 0)
2594     if empty(curtag)
2595         return
2596     endif
2597
2598     let newline = curtag.closeFold()
2599
2600     call s:RenderKeepView(newline)
2601 endfunction
2602
2603 " s:ToggleFold() {{{2
2604 function! s:ToggleFold()
2605     let fileinfo = s:known_files.getCurrent()
2606     if empty(fileinfo)
2607         return
2608     endif
2609
2610     match none
2611
2612     let curtag = s:GetTagInfo(line('.'), 0)
2613     if empty(curtag)
2614         return
2615     endif
2616
2617     let newline = line('.')
2618
2619     if curtag.isKindheader()
2620         call curtag.toggleFold()
2621     elseif curtag.isFoldable()
2622         if curtag.isFolded()
2623             call curtag.openFold()
2624         else
2625             let newline = curtag.closeFold()
2626         endif
2627     else
2628         let newline = curtag.closeFold()
2629     endif
2630
2631     call s:RenderKeepView(newline)
2632 endfunction
2633
2634 " s:SetFoldLevel() {{{2
2635 function! s:SetFoldLevel(level)
2636     if a:level < 0
2637         echoerr 'Foldlevel can''t be negative'
2638         return
2639     endif
2640
2641     let fileinfo = s:known_files.getCurrent()
2642     if empty(fileinfo)
2643         return
2644     endif
2645
2646     call s:SetFoldLevelRecursive(fileinfo, fileinfo.tags, a:level)
2647
2648     let typeinfo = s:known_types[fileinfo.ftype]
2649
2650     " Apply foldlevel to 'kind's
2651     if a:level == 0
2652         for kind in typeinfo.kinds
2653             call fileinfo.closeKindFold(kind)
2654         endfor
2655     else
2656         for kind in typeinfo.kinds
2657             call fileinfo.openKindFold(kind)
2658         endfor
2659     endif
2660
2661     let fileinfo.foldlevel = a:level
2662
2663     call s:RenderContent()
2664 endfunction
2665
2666 " s:SetFoldLevelRecursive() {{{2
2667 " Apply foldlevel to normal tags
2668 function! s:SetFoldLevelRecursive(fileinfo, tags, level)
2669     for tag in a:tags
2670         if tag.depth >= a:level
2671             call tag.setFolded(1)
2672         else
2673             call tag.setFolded(0)
2674         endif
2675
2676         if has_key(tag, 'children')
2677             call s:SetFoldLevelRecursive(a:fileinfo, tag.children, a:level)
2678         endif
2679     endfor
2680 endfunction
2681
2682 " s:OpenParents() {{{2
2683 function! s:OpenParents(...)
2684     let tagline = 0
2685
2686     if a:0 == 1
2687         let tag = a:1
2688     else
2689         let tag = s:GetNearbyTag()
2690     endif
2691
2692     call tag.openParents()
2693
2694     call s:RenderKeepView()
2695 endfunction
2696
2697 " Helper functions {{{1
2698 " s:CleanUp() {{{2
2699 function! s:CleanUp()
2700     silent autocmd! TagbarAutoCmds
2701
2702     unlet s:is_maximized
2703     unlet s:compare_typeinfo
2704     unlet s:short_help
2705 endfunction
2706
2707 " s:CleanupFileinfo() {{{2
2708 function! s:CleanupFileinfo(fname)
2709     call s:known_files.rm(a:fname)
2710 endfunction
2711
2712 " s:QuitIfOnlyWindow() {{{2
2713 function! s:QuitIfOnlyWindow()
2714     " Before quitting Vim, delete the tagbar buffer so that
2715     " the '0 mark is correctly set to the previous buffer.
2716     if winbufnr(2) == -1
2717         " Check if there is more than one tab page
2718         if tabpagenr('$') == 1
2719             bdelete
2720             quit
2721         else
2722             close
2723         endif
2724     endif
2725 endfunction
2726
2727 " s:AutoUpdate() {{{2
2728 function! s:AutoUpdate(fname)
2729     call s:LogDebugMessage('AutoUpdate called on ' . a:fname)
2730
2731     " Don't do anything if tagbar is not open or if we're in the tagbar window
2732     let tagbarwinnr = bufwinnr('__Tagbar__')
2733     if tagbarwinnr == -1 || &filetype == 'tagbar'
2734         call s:LogDebugMessage('Tagbar window not open or in Tagbar window')
2735         return
2736     endif
2737
2738     " Only consider the main filetype in cases like 'python.django'
2739     let ftype = get(split(&filetype, '\.'), 0, '')
2740     call s:LogDebugMessage('Vim filetype: ' . &filetype .
2741                          \ ', sanitized filetype: ' . ftype)
2742
2743     " Don't do anything if the file isn't supported
2744     if !s:IsValidFile(a:fname, ftype)
2745         call s:LogDebugMessage('Not a valid file, stopping processing')
2746         return
2747     endif
2748
2749     " Process the file if it's unknown or the information is outdated
2750     " Also test for entries that exist but are empty, which will be the case
2751     " if there was an error during the ctags execution
2752     if s:known_files.has(a:fname) && !empty(s:known_files.get(a:fname))
2753         if s:known_files.get(a:fname).mtime != getftime(a:fname)
2754             call s:LogDebugMessage('Filedata outdated, updating ' . a:fname)
2755             call s:ProcessFile(a:fname, ftype)
2756         endif
2757     elseif !s:known_files.has(a:fname)
2758         call s:LogDebugMessage('Unknown file, processing ' . a:fname)
2759         call s:ProcessFile(a:fname, ftype)
2760     endif
2761
2762     let fileinfo = s:known_files.get(a:fname)
2763
2764     " If we don't have an entry for the file by now something must have gone
2765     " wrong, so don't change the tagbar content
2766     if empty(fileinfo)
2767         call s:LogDebugMessage('fileinfo empty after processing: ' . a:fname)
2768         return
2769     endif
2770
2771     " Display the tagbar content
2772     call s:RenderContent(fileinfo)
2773
2774     " Call setCurrent after rendering so RenderContent can check whether the
2775     " same file is redisplayed
2776     if !empty(fileinfo)
2777         call s:LogDebugMessage('Setting current file to ' . a:fname)
2778         call s:known_files.setCurrent(fileinfo)
2779     endif
2780
2781     call s:HighlightTag()
2782     call s:LogDebugMessage('AutoUpdate finished successfully')
2783 endfunction
2784
2785 " s:IsValidFile() {{{2
2786 function! s:IsValidFile(fname, ftype)
2787     if a:fname == '' || a:ftype == ''
2788         call s:LogDebugMessage('Empty filename or type')
2789         return 0
2790     endif
2791
2792     if !filereadable(a:fname)
2793         call s:LogDebugMessage('File not readable')
2794         return 0
2795     endif
2796
2797     if !has_key(s:known_types, a:ftype)
2798         call s:LogDebugMessage('Unsupported filetype: ' . a:ftype)
2799         return 0
2800     endif
2801
2802     return 1
2803 endfunction
2804
2805 " s:EscapeCtagsCmd() {{{2
2806 " Assemble the ctags command line in a way that all problematic characters are
2807 " properly escaped and converted to the system's encoding
2808 " Optional third parameter is a file name to run ctags on
2809 function! s:EscapeCtagsCmd(ctags_bin, args, ...)
2810     call s:LogDebugMessage('EscapeCtagsCmd called')
2811     call s:LogDebugMessage('ctags_bin: ' . a:ctags_bin)
2812     call s:LogDebugMessage('ctags_args: ' . a:args)
2813
2814     if exists('+shellslash')
2815         let shellslash_save = &shellslash
2816         set noshellslash
2817     endif
2818
2819     if a:0 == 1
2820         let fname = shellescape(a:1)
2821     else
2822         let fname = ''
2823     endif
2824
2825     let ctags_cmd = shellescape(a:ctags_bin) . ' ' . a:args . ' ' . fname
2826
2827     if exists('+shellslash')
2828         let &shellslash = shellslash_save
2829     endif
2830
2831     " Needed for cases where 'encoding' is different from the system's
2832     " encoding
2833     if g:tagbar_systemenc != &encoding
2834         let ctags_cmd = iconv(ctags_cmd, &encoding, g:tagbar_systemenc)
2835     elseif $LANG != ''
2836         let ctags_cmd = iconv(ctags_cmd, &encoding, $LANG)
2837     endif
2838
2839     call s:LogDebugMessage('Escaped ctags command: ' . ctags_cmd)
2840
2841     if ctags_cmd == ''
2842         echoerr 'Tagbar: Encoding conversion failed!'
2843               \ 'Please make sure your system is set up correctly'
2844               \ 'and that Vim is compiled with the "iconv" feature.'
2845     endif
2846
2847     return ctags_cmd
2848 endfunction
2849
2850 " s:ExecuteCtags() {{{2
2851 " Execute ctags with necessary shell settings
2852 " Partially based on the discussion at
2853 " http://vim.1045645.n5.nabble.com/bad-default-shellxquote-in-Widows-td1208284.html
2854 function! s:ExecuteCtags(ctags_cmd)
2855     if exists('+shellslash')
2856         let shellslash_save = &shellslash
2857         set noshellslash
2858     endif
2859
2860     if &shell =~ 'cmd\.exe'
2861         let shellxquote_save = &shellxquote
2862         set shellxquote=\"
2863         let shellcmdflag_save = &shellcmdflag
2864         set shellcmdflag=/s\ /c
2865     endif
2866
2867     let ctags_output = system(a:ctags_cmd)
2868
2869     if &shell =~ 'cmd\.exe'
2870         let &shellxquote  = shellxquote_save
2871         let &shellcmdflag = shellcmdflag_save
2872     endif
2873
2874     if exists('+shellslash')
2875         let &shellslash = shellslash_save
2876     endif
2877
2878     return ctags_output
2879 endfunction
2880
2881 " s:GetTagInfo() {{{2
2882 " Return the info dictionary of the tag on the specified line. If the line
2883 " does not contain a valid tag (for example because it is empty or only
2884 " contains a pseudo-tag) return an empty dictionary.
2885 function! s:GetTagInfo(linenr, ignorepseudo)
2886     let fileinfo = s:known_files.getCurrent()
2887
2888     if empty(fileinfo)
2889         return {}
2890     endif
2891
2892     " Don't do anything in empty and comment lines
2893     let curline = getline(a:linenr)
2894     if curline =~ '^\s*$' || curline[0] == '"'
2895         return {}
2896     endif
2897
2898     " Check if there is a tag on the current line
2899     if !has_key(fileinfo.tline, a:linenr)
2900         return {}
2901     endif
2902
2903     let taginfo = fileinfo.tline[a:linenr]
2904
2905     " Check if the current tag is not a pseudo-tag
2906     if a:ignorepseudo && taginfo.isPseudoTag()
2907         return {}
2908     endif
2909
2910     return taginfo
2911 endfunction
2912
2913 " s:GetNearbyTag() {{{2
2914 " Get the tag info for a file near the cursor in the current file
2915 function! s:GetNearbyTag()
2916     let fileinfo = s:known_files.getCurrent()
2917
2918     let curline = line('.')
2919     let tag = {}
2920
2921     " If a tag appears in a file more than once (for example namespaces in
2922     " C++) only one of them has a 'tline' entry and can thus be highlighted.
2923     " The only way to solve this would be to go over the whole tag list again,
2924     " making everything slower. Since this should be a rare occurence and
2925     " highlighting isn't /that/ important ignore it for now.
2926     for line in range(curline, 1, -1)
2927         if has_key(fileinfo.fline, line)
2928             let tag = fileinfo.fline[line]
2929             break
2930         endif
2931     endfor
2932
2933     return tag
2934 endfunction
2935
2936 " s:CheckMouseClick() {{{2
2937 function! s:CheckMouseClick()
2938     let line   = getline('.')
2939     let curcol = col('.')
2940
2941     if (match(line, s:icon_open . '[-+ ]') + 1) == curcol
2942         call s:CloseFold()
2943     elseif (match(line, s:icon_closed . '[-+ ]') + 1) == curcol
2944         call s:OpenFold()
2945     elseif g:tagbar_singleclick
2946         call s:JumpToTag(0)
2947     endif
2948 endfunction
2949
2950 " s:DetermineFiletype() {{{2
2951 function! s:DetectFiletype(bufnr)
2952     " Filetype has already been detected for loaded buffers, but not
2953     " necessarily for unloaded ones
2954     let ftype = getbufvar(a:bufnr, '&filetype')
2955
2956     if bufloaded(a:bufnr)
2957         return ftype
2958     endif
2959
2960     if ftype != ''
2961         return ftype
2962     endif
2963
2964     " Unloaded buffer with non-detected filetype, need to detect filetype
2965     " manually
2966     let bufname = bufname(a:bufnr)
2967
2968     let eventignore_save = &eventignore
2969     set eventignore=FileType
2970     let filetype_save = &filetype
2971
2972     exe 'doautocmd filetypedetect BufRead ' . bufname
2973     let ftype = &filetype
2974
2975     let &filetype = filetype_save
2976     let &eventignore = eventignore_save
2977
2978     return ftype
2979 endfunction
2980
2981
2982 " TagbarBalloonExpr() {{{2
2983 function! TagbarBalloonExpr()
2984     let taginfo = s:GetTagInfo(v:beval_lnum, 1)
2985
2986     if empty(taginfo)
2987         return
2988     endif
2989
2990     return taginfo.getPrototype()
2991 endfunction
2992
2993 " TagbarGenerateStatusline() {{{2
2994 function! TagbarGenerateStatusline()
2995     if g:tagbar_sort
2996         let text = '[Name]'
2997     else
2998         let text = '[Order]'
2999     endif
3000
3001     if !empty(s:known_files.getCurrent())
3002         let filename = fnamemodify(s:known_files.getCurrent().fpath, ':t')
3003         let text .= ' ' . filename
3004     endif
3005
3006     return text
3007 endfunction
3008
3009 " Debugging {{{1
3010 " s:StartDebug() {{{2
3011 function! s:StartDebug(filename)
3012     if empty(a:filename)
3013         let s:debug_file = 'tagbardebug.log'
3014     else
3015         let s:debug_file = a:filename
3016     endif
3017
3018     " Empty log file
3019     exe 'redir! > ' . s:debug_file
3020     redir END
3021
3022     " Check whether the log file could be created
3023     if !filewritable(s:debug_file)
3024         echomsg 'Tagbar: Unable to create log file ' . s:debug_file
3025         let s:debug_file = ''
3026         return
3027     endif
3028
3029     let s:debug = 1
3030 endfunction
3031
3032 " s:StopDebug() {{{2
3033 function! s:StopDebug()
3034     let s:debug = 0
3035     let s:debug_file = ''
3036 endfunction
3037
3038 " s:LogDebugMessage() {{{2
3039 function! s:LogDebugMessage(msg)
3040     if s:debug
3041         exe 'redir >> ' . s:debug_file
3042         silent echon strftime('%H:%M:%S') . ': ' . a:msg . "\n"
3043         redir END
3044     endif
3045 endfunction
3046
3047 " Autoload functions {{{1
3048 function! tagbar#ToggleWindow()
3049     call s:ToggleWindow()
3050 endfunction
3051
3052 function! tagbar#OpenWindow(...)
3053     let flags = a:0 > 0 ? a:1 : ''
3054     call s:OpenWindow(flags)
3055 endfunction
3056
3057 function! tagbar#CloseWindow()
3058     call s:CloseWindow()
3059 endfunction
3060
3061 function! tagbar#SetFoldLevel(...)
3062     call s:SetFoldLevel(a:1)
3063 endfunction
3064
3065 function! tagbar#OpenParents()
3066     call s:OpenParents()
3067 endfunction
3068
3069 function! tagbar#StartDebug(...)
3070     let filename = a:0 > 0 ? a:1 : ''
3071     call s:StartDebug(filename)
3072 endfunction
3073
3074 function! tagbar#StopDebug()
3075     call s:StopDebug()
3076 endfunction
3077
3078 function! tagbar#RestoreSession()
3079     call s:RestoreSession()
3080 endfunction
3081
3082 " Automatically open Tagbar if one of the open buffers contains a supported
3083 " file
3084 function! tagbar#autoopen()
3085     call s:Init()
3086
3087     for bufnr in range(1, bufnr('$'))
3088         if buflisted(bufnr)
3089             let ftype = s:DetectFiletype(bufnr)
3090             if s:IsValidFile(bufname(bufnr), ftype)
3091                 call s:OpenWindow('')
3092                 return
3093             endif
3094         endif
3095     endfor
3096 endfunction
3097
3098 " Modeline {{{1
3099 " vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1