" Vimball Archiver by Charles E. Campbell, Jr., Ph.D. UseVimball finish README.md [[[1 19 # Overview Tagbar is a vim plugin for browsing the tags of source code files. It provides a sidebar that displays the ctags-generated tags of the current file, ordered by their scope. This means that for example methods in C++ are displayed under the class they are defined in. Check out the homepage at http://majutsushi.github.io/tagbar/ for more information. # Support for additional filetypes For filetypes that are not supported by Exuberant Ctags check out [the wiki](https://github.com/majutsushi/tagbar/wiki) to see whether other projects offer support for them and how to use them. Please add any other projects/configurations that you find or create yourself so that others can benefit from them, too. # Important: If the file structure is displayed wrong If you notice that there are some errors in the way your file's structure is displayed in Tagbar, please make sure that the bug is actually in Tagbar before you report a bug. Since Tagbar uses [exuberant-ctags](http://ctags.sourceforge.net/) and compatible programs to do the actual file parsing, it is likely that the bug is actually in one of those programs instead. There is an example in `:h tagbar-issues` about how to run ctags manually so you can determine where the bug actually is. If the bug is actually in ctags, please report it on their website instead, as there is nothing I can do about it in Tagbar. Thank you! You can also have a look at ctags bugs that have previously been filed on Tagbar here: https://github.com/majutsushi/tagbar/issues?labels=ctags-bug&page=1&state=closed autoload/tagbar.vim [[[1 4045 " ============================================================================ " File: tagbar.vim " Description: List the current file's tags in a sidebar, ordered by class etc " Author: Jan Larres " Licence: Vim licence " Website: http://majutsushi.github.com/tagbar/ " Version: 2.6 " Note: This plugin was heavily inspired by the 'Taglist' plugin by " Yegappan Lakshmanan and uses a small amount of code from it. " " Original taglist copyright notice: " Permission is hereby granted to use and distribute this code, " with or without modifications, provided that this copyright " notice is copied with it. Like anything else that's free, " taglist.vim is provided *as is* and comes with no warranty of " any kind, either expressed or implied. In no event will the " copyright holder be liable for any damamges resulting from the " use of this software. " ============================================================================ scriptencoding utf-8 " Initialization {{{1 " If another plugin calls an autoloaded Tagbar function on startup before the " plugin/tagbar.vim file got loaded, load it explicitly if exists(':Tagbar') == 0 runtime plugin/tagbar.vim endif " Basic init {{{2 redir => s:ftype_out silent filetype redir END if s:ftype_out !~# 'detection:ON' echomsg 'Tagbar: Filetype detection is turned off, skipping plugin' unlet s:ftype_out finish endif unlet s:ftype_out let s:icon_closed = g:tagbar_iconchars[0] let s:icon_open = g:tagbar_iconchars[1] let s:type_init_done = 0 let s:autocommands_done = 0 let s:statusline_in_use = 0 " 0: not checked yet; 1: checked and found; 2: checked and not found let s:checked_ctags = 0 let s:checked_ctags_types = 0 let s:ctags_types = {} let s:new_window = 1 let s:is_maximized = 0 let s:winrestcmd = '' let s:short_help = 1 let s:nearby_disabled = 0 let s:paused = 0 let s:pwin_by_tagbar = 0 let s:window_expanded = 0 let s:expand_bufnr = -1 let s:window_pos = { \ 'pre' : { 'x' : 0, 'y' : 0 }, \ 'post' : { 'x' : 0, 'y' : 0 } \} " Script-local variable needed since compare functions can't " take extra arguments let s:compare_typeinfo = {} let s:visibility_symbols = { \ 'public' : '+', \ 'protected' : '#', \ 'private' : '-' \ } let g:loaded_tagbar = 1 let s:last_highlight_tline = 0 let s:debug = 0 let s:debug_file = '' " s:Init() {{{2 function! s:Init(silent) abort if s:checked_ctags == 2 && a:silent return 0 elseif s:checked_ctags != 1 if !s:CheckForExCtags(a:silent) return 0 endif endif if !s:checked_ctags_types call s:GetSupportedFiletypes() endif if !s:type_init_done call s:InitTypes() endif if !s:autocommands_done call s:CreateAutocommands() call s:AutoUpdate(fnamemodify(expand('%'), ':p'), 0) endif return 1 endfunction " s:InitTypes() {{{2 function! s:InitTypes() abort call s:LogDebugMessage('Initializing types') let s:known_types = {} " Ant {{{3 let type_ant = s:TypeInfo.New() let type_ant.ctagstype = 'ant' let type_ant.kinds = [ \ {'short' : 'p', 'long' : 'projects', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'targets', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.ant = type_ant " Asm {{{3 let type_asm = s:TypeInfo.New() let type_asm.ctagstype = 'asm' let type_asm.kinds = [ \ {'short' : 'm', 'long' : 'macros', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1}, \ {'short' : 'd', 'long' : 'defines', 'fold' : 0, 'stl' : 1}, \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.asm = type_asm " ASP {{{3 let type_aspvbs = s:TypeInfo.New() let type_aspvbs.ctagstype = 'asp' let type_aspvbs.kinds = [ \ {'short' : 'd', 'long' : 'constants', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.aspvbs = type_aspvbs " Awk {{{3 let type_awk = s:TypeInfo.New() let type_awk.ctagstype = 'awk' let type_awk.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.awk = type_awk " Basic {{{3 let type_basic = s:TypeInfo.New() let type_basic.ctagstype = 'basic' let type_basic.kinds = [ \ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 1}, \ {'short' : 'g', 'long' : 'enumerations', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.basic = type_basic " BETA {{{3 let type_beta = s:TypeInfo.New() let type_beta.ctagstype = 'beta' let type_beta.kinds = [ \ {'short' : 'f', 'long' : 'fragments', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'slots', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'patterns', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.beta = type_beta " C {{{3 let type_c = s:TypeInfo.New() let type_c.ctagstype = 'c' let type_c.kinds = [ \ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0}, \ {'short' : 'p', 'long' : 'prototypes', 'fold' : 1, 'stl' : 0}, \ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0}, \ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0}, \ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1}, \ {'short' : 'u', 'long' : 'unions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 0}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let type_c.sro = '::' let type_c.kind2scope = { \ 'g' : 'enum', \ 's' : 'struct', \ 'u' : 'union' \ } let type_c.scope2kind = { \ 'enum' : 'g', \ 'struct' : 's', \ 'union' : 'u' \ } let s:known_types.c = type_c " C++ {{{3 let type_cpp = s:TypeInfo.New() let type_cpp.ctagstype = 'c++' let type_cpp.kinds = [ \ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0}, \ {'short' : 'p', 'long' : 'prototypes', 'fold' : 1, 'stl' : 0}, \ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0}, \ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0}, \ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1}, \ {'short' : 'u', 'long' : 'unions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 0}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0} \ ] let type_cpp.sro = '::' let type_cpp.kind2scope = { \ 'g' : 'enum', \ 'n' : 'namespace', \ 'c' : 'class', \ 's' : 'struct', \ 'u' : 'union' \ } let type_cpp.scope2kind = { \ 'enum' : 'g', \ 'namespace' : 'n', \ 'class' : 'c', \ 'struct' : 's', \ 'union' : 'u' \ } let s:known_types.cpp = type_cpp " C# {{{3 let type_cs = s:TypeInfo.New() let type_cs.ctagstype = 'c#' let type_cs.kinds = [ \ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0}, \ {'short' : 'f', 'long' : 'fields', 'fold' : 0, 'stl' : 1}, \ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0}, \ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 1}, \ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1}, \ {'short' : 'E', 'long' : 'events', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'properties', 'fold' : 0, 'stl' : 1} \ ] let type_cs.sro = '.' let type_cs.kind2scope = { \ 'n' : 'namespace', \ 'i' : 'interface', \ 'c' : 'class', \ 's' : 'struct', \ 'g' : 'enum' \ } let type_cs.scope2kind = { \ 'namespace' : 'n', \ 'interface' : 'i', \ 'class' : 'c', \ 'struct' : 's', \ 'enum' : 'g' \ } let s:known_types.cs = type_cs " COBOL {{{3 let type_cobol = s:TypeInfo.New() let type_cobol.ctagstype = 'cobol' let type_cobol.kinds = [ \ {'short' : 'd', 'long' : 'data items', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'file descriptions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'g', 'long' : 'group items', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'paragraphs', 'fold' : 0, 'stl' : 1}, \ {'short' : 'P', 'long' : 'program ids', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'sections', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.cobol = type_cobol " DOS Batch {{{3 let type_dosbatch = s:TypeInfo.New() let type_dosbatch.ctagstype = 'dosbatch' let type_dosbatch.kinds = [ \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.dosbatch = type_dosbatch " Eiffel {{{3 let type_eiffel = s:TypeInfo.New() let type_eiffel.ctagstype = 'eiffel' let type_eiffel.kinds = [ \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'features', 'fold' : 0, 'stl' : 1} \ ] let type_eiffel.sro = '.' " Not sure, is nesting even possible? let type_eiffel.kind2scope = { \ 'c' : 'class', \ 'f' : 'feature' \ } let type_eiffel.scope2kind = { \ 'class' : 'c', \ 'feature' : 'f' \ } let s:known_types.eiffel = type_eiffel " Erlang {{{3 let type_erlang = s:TypeInfo.New() let type_erlang.ctagstype = 'erlang' let type_erlang.kinds = [ \ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1}, \ {'short' : 'd', 'long' : 'macro definitions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'r', 'long' : 'record definitions', 'fold' : 0, 'stl' : 1} \ ] let type_erlang.sro = '.' " Not sure, is nesting even possible? let type_erlang.kind2scope = { \ 'm' : 'module' \ } let type_erlang.scope2kind = { \ 'module' : 'm' \ } let s:known_types.erlang = type_erlang " Flex {{{3 " Vim doesn't support Flex out of the box, this is based on rough " guesses and probably requires " http://www.vim.org/scripts/script.php?script_id=2909 " Improvements welcome! let type_as = s:TypeInfo.New() let type_as.ctagstype = 'flex' let type_as.kinds = [ \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'properties', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'x', 'long' : 'mxtags', 'fold' : 0, 'stl' : 0} \ ] let type_as.sro = '.' let type_as.kind2scope = { \ 'c' : 'class' \ } let type_as.scope2kind = { \ 'class' : 'c' \ } let s:known_types.mxml = type_as let s:known_types.actionscript = type_as " Fortran {{{3 let type_fortran = s:TypeInfo.New() let type_fortran.ctagstype = 'fortran' let type_fortran.kinds = [ \ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'programs', 'fold' : 0, 'stl' : 1}, \ {'short' : 'k', 'long' : 'components', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'derived types and structures', 'fold' : 0, \ 'stl' : 1}, \ {'short' : 'c', 'long' : 'common blocks', 'fold' : 0, 'stl' : 1}, \ {'short' : 'b', 'long' : 'block data', 'fold' : 0, 'stl' : 0}, \ {'short' : 'e', 'long' : 'entry points', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}, \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}, \ {'short' : 'n', 'long' : 'namelists', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0} \ ] let type_fortran.sro = '.' " Not sure, is nesting even possible? let type_fortran.kind2scope = { \ 'm' : 'module', \ 'p' : 'program', \ 'f' : 'function', \ 's' : 'subroutine' \ } let type_fortran.scope2kind = { \ 'module' : 'm', \ 'program' : 'p', \ 'function' : 'f', \ 'subroutine' : 's' \ } let s:known_types.fortran = type_fortran " HTML {{{3 let type_html = s:TypeInfo.New() let type_html.ctagstype = 'html' let type_html.kinds = [ \ {'short' : 'f', 'long' : 'JavaScript funtions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'a', 'long' : 'named anchors', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.html = type_html " Java {{{3 let type_java = s:TypeInfo.New() let type_java.ctagstype = 'java' let type_java.kinds = [ \ {'short' : 'p', 'long' : 'packages', 'fold' : 1, 'stl' : 0}, \ {'short' : 'f', 'long' : 'fields', 'fold' : 0, 'stl' : 0}, \ {'short' : 'g', 'long' : 'enum types', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'enum constants', 'fold' : 0, 'stl' : 0}, \ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1} \ ] let type_java.sro = '.' let type_java.kind2scope = { \ 'g' : 'enum', \ 'i' : 'interface', \ 'c' : 'class' \ } let type_java.scope2kind = { \ 'enum' : 'g', \ 'interface' : 'i', \ 'class' : 'c' \ } let s:known_types.java = type_java " JavaScript {{{3 " JavaScript is weird -- it does have scopes, but ctags doesn't seem to " properly generate the information for them, instead it simply uses the " complete name. So ctags has to be fixed before I can do anything here. " Alternatively jsctags/doctorjs will be used if available. let type_javascript = s:TypeInfo.New() let type_javascript.ctagstype = 'javascript' let jsctags = s:CheckFTCtags('jsctags', 'javascript') if jsctags != '' let type_javascript.kinds = [ \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let type_javascript.sro = '.' let type_javascript.kind2scope = { \ 'v' : 'namespace', \ 'f' : 'namespace' \ } let type_javascript.scope2kind = { \ 'namespace' : 'v' \ } let type_javascript.ctagsbin = jsctags let type_javascript.ctagsargs = '-f -' else let type_javascript.kinds = [ \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'properties', 'fold' : 0, 'stl' : 0}, \ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] endif let s:known_types.javascript = type_javascript " Lisp {{{3 let type_lisp = s:TypeInfo.New() let type_lisp.ctagstype = 'lisp' let type_lisp.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.lisp = type_lisp let s:known_types.clojure = type_lisp " Lua {{{3 let type_lua = s:TypeInfo.New() let type_lua.ctagstype = 'lua' let type_lua.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.lua = type_lua " Make {{{3 let type_make = s:TypeInfo.New() let type_make.ctagstype = 'make' let type_make.kinds = [ \ {'short' : 'm', 'long' : 'macros', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.make = type_make " Matlab {{{3 let type_matlab = s:TypeInfo.New() let type_matlab.ctagstype = 'matlab' let type_matlab.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.matlab = type_matlab " Ocaml {{{3 let type_ocaml = s:TypeInfo.New() let type_ocaml.ctagstype = 'ocaml' let type_ocaml.kinds = [ \ {'short' : 'M', 'long' : 'modules or functors', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'C', 'long' : 'constructors', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'exceptions', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'type names', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'r', 'long' : 'structure fields', 'fold' : 0, 'stl' : 0} \ ] let type_ocaml.sro = '.' " Not sure, is nesting even possible? let type_ocaml.kind2scope = { \ 'M' : 'Module', \ 'c' : 'class', \ 't' : 'type' \ } let type_ocaml.scope2kind = { \ 'Module' : 'M', \ 'class' : 'c', \ 'type' : 't' \ } let s:known_types.ocaml = type_ocaml " Pascal {{{3 let type_pascal = s:TypeInfo.New() let type_pascal.ctagstype = 'pascal' let type_pascal.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.pascal = type_pascal " Perl {{{3 let type_perl = s:TypeInfo.New() let type_perl.ctagstype = 'perl' let type_perl.kinds = [ \ {'short' : 'p', 'long' : 'packages', 'fold' : 1, 'stl' : 0}, \ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0}, \ {'short' : 'f', 'long' : 'formats', 'fold' : 0, 'stl' : 0}, \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.perl = type_perl " PHP {{{3 let type_php = s:TypeInfo.New() let type_php.ctagstype = 'php' let type_php.kinds = [ \ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'd', 'long' : 'constant definitions', 'fold' : 0, 'stl' : 0}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'j', 'long' : 'javascript functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.php = type_php " Python {{{3 let type_python = s:TypeInfo.New() let type_python.ctagstype = 'python' let type_python.kinds = [ \ {'short' : 'i', 'long' : 'imports', 'fold' : 1, 'stl' : 0}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0} \ ] let type_python.sro = '.' let type_python.kind2scope = { \ 'c' : 'class', \ 'f' : 'function', \ 'm' : 'function' \ } let type_python.scope2kind = { \ 'class' : 'c', \ 'function' : 'f' \ } let s:known_types.python = type_python let s:known_types.pyrex = type_python let s:known_types.cython = type_python " REXX {{{3 let type_rexx = s:TypeInfo.New() let type_rexx.ctagstype = 'rexx' let type_rexx.kinds = [ \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.rexx = type_rexx " Ruby {{{3 let type_ruby = s:TypeInfo.New() let type_ruby.ctagstype = 'ruby' let type_ruby.kinds = [ \ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'F', 'long' : 'singleton methods', 'fold' : 0, 'stl' : 1} \ ] let type_ruby.sro = '.' let type_ruby.kind2scope = { \ 'c' : 'class', \ 'm' : 'class' \ } let type_ruby.scope2kind = { \ 'class' : 'c' \ } let s:known_types.ruby = type_ruby " Scheme {{{3 let type_scheme = s:TypeInfo.New() let type_scheme.ctagstype = 'scheme' let type_scheme.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'sets', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.scheme = type_scheme let s:known_types.racket = type_scheme " Shell script {{{3 let type_sh = s:TypeInfo.New() let type_sh.ctagstype = 'sh' let type_sh.kinds = [ \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.sh = type_sh let s:known_types.csh = type_sh let s:known_types.zsh = type_sh " SLang {{{3 let type_slang = s:TypeInfo.New() let type_slang.ctagstype = 'slang' let type_slang.kinds = [ \ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.slang = type_slang " SML {{{3 let type_sml = s:TypeInfo.New() let type_sml.ctagstype = 'sml' let type_sml.kinds = [ \ {'short' : 'e', 'long' : 'exception declarations', 'fold' : 0, 'stl' : 0}, \ {'short' : 'f', 'long' : 'function definitions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'functor definitions', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'signature declarations', 'fold' : 0, 'stl' : 0}, \ {'short' : 'r', 'long' : 'structure declarations', 'fold' : 0, 'stl' : 0}, \ {'short' : 't', 'long' : 'type definitions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'value bindings', 'fold' : 0, 'stl' : 0} \ ] let s:known_types.sml = type_sml " SQL {{{3 " The SQL ctags parser seems to be buggy for me, so this just uses the " normal kinds even though scopes should be available. Improvements " welcome! let type_sql = s:TypeInfo.New() let type_sql.ctagstype = 'sql' let type_sql.kinds = [ \ {'short' : 'P', 'long' : 'packages', 'fold' : 1, 'stl' : 1}, \ {'short' : 'd', 'long' : 'prototypes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'cursors', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'F', 'long' : 'record fields', 'fold' : 0, 'stl' : 1}, \ {'short' : 'L', 'long' : 'block label', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'subtypes', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'tables', 'fold' : 0, 'stl' : 1}, \ {'short' : 'T', 'long' : 'triggers', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1}, \ {'short' : 'i', 'long' : 'indexes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'events', 'fold' : 0, 'stl' : 1}, \ {'short' : 'U', 'long' : 'publications', 'fold' : 0, 'stl' : 1}, \ {'short' : 'R', 'long' : 'services', 'fold' : 0, 'stl' : 1}, \ {'short' : 'D', 'long' : 'domains', 'fold' : 0, 'stl' : 1}, \ {'short' : 'V', 'long' : 'views', 'fold' : 0, 'stl' : 1}, \ {'short' : 'n', 'long' : 'synonyms', 'fold' : 0, 'stl' : 1}, \ {'short' : 'x', 'long' : 'MobiLink Table Scripts', 'fold' : 0, 'stl' : 1}, \ {'short' : 'y', 'long' : 'MobiLink Conn Scripts', 'fold' : 0, 'stl' : 1}, \ {'short' : 'z', 'long' : 'MobiLink Properties', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.sql = type_sql " Tcl {{{3 let type_tcl = s:TypeInfo.New() let type_tcl.ctagstype = 'tcl' let type_tcl.kinds = [ \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.tcl = type_tcl " LaTeX {{{3 let type_tex = s:TypeInfo.New() let type_tex.ctagstype = 'tex' let type_tex.kinds = [ \ {'short' : 'i', 'long' : 'includes', 'fold' : 1, 'stl' : 0}, \ {'short' : 'p', 'long' : 'parts', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'chapters', 'fold' : 0, 'stl' : 1}, \ {'short' : 's', 'long' : 'sections', 'fold' : 0, 'stl' : 1}, \ {'short' : 'u', 'long' : 'subsections', 'fold' : 0, 'stl' : 1}, \ {'short' : 'b', 'long' : 'subsubsections', 'fold' : 0, 'stl' : 1}, \ {'short' : 'P', 'long' : 'paragraphs', 'fold' : 0, 'stl' : 0}, \ {'short' : 'G', 'long' : 'subparagraphs', 'fold' : 0, 'stl' : 0}, \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 0} \ ] let type_tex.sro = '""' let type_tex.kind2scope = { \ 'p' : 'part', \ 'c' : 'chapter', \ 's' : 'section', \ 'u' : 'subsection', \ 'b' : 'subsubsection' \ } let type_tex.scope2kind = { \ 'part' : 'p', \ 'chapter' : 'c', \ 'section' : 's', \ 'subsection' : 'u', \ 'subsubsection' : 'b' \ } let type_tex.sort = 0 let s:known_types.tex = type_tex " Vala {{{3 " Vala is supported by the ctags fork provided by Anjuta, so only add the " type if the fork is used to prevent error messages otherwise if has_key(s:ctags_types, 'vala') || executable('anjuta-tags') let type_vala = s:TypeInfo.New() let type_vala.ctagstype = 'vala' let type_vala.kinds = [ \ {'short' : 'e', 'long' : 'Enumerations', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'Enumeration values', 'fold' : 0, 'stl' : 0}, \ {'short' : 's', 'long' : 'Structures', 'fold' : 0, 'stl' : 1}, \ {'short' : 'i', 'long' : 'Interfaces', 'fold' : 0, 'stl' : 1}, \ {'short' : 'd', 'long' : 'Delegates', 'fold' : 0, 'stl' : 1}, \ {'short' : 'c', 'long' : 'Classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'Properties', 'fold' : 0, 'stl' : 0}, \ {'short' : 'f', 'long' : 'Fields', 'fold' : 0, 'stl' : 0}, \ {'short' : 'm', 'long' : 'Methods', 'fold' : 0, 'stl' : 1}, \ {'short' : 'E', 'long' : 'Error domains', 'fold' : 0, 'stl' : 1}, \ {'short' : 'r', 'long' : 'Error codes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'S', 'long' : 'Signals', 'fold' : 0, 'stl' : 1} \ ] let type_vala.sro = '.' " 'enum' doesn't seem to be used as a scope, but it can't hurt to have " it here let type_vala.kind2scope = { \ 's' : 'struct', \ 'i' : 'interface', \ 'c' : 'class', \ 'e' : 'enum' \ } let type_vala.scope2kind = { \ 'struct' : 's', \ 'interface' : 'i', \ 'class' : 'c', \ 'enum' : 'e' \ } let s:known_types.vala = type_vala endif if !has_key(s:ctags_types, 'vala') && executable('anjuta-tags') let s:known_types.vala.ctagsbin = 'anjuta-tags' endif " Vera {{{3 " Why are variables 'virtual'? let type_vera = s:TypeInfo.New() let type_vera.ctagstype = 'vera' let type_vera.kinds = [ \ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0}, \ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1}, \ {'short' : 'T', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0}, \ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0}, \ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'tasks', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}, \ {'short' : 'p', 'long' : 'programs', 'fold' : 0, 'stl' : 1} \ ] let type_vera.sro = '.' " Nesting doesn't seem to be possible let type_vera.kind2scope = { \ 'g' : 'enum', \ 'c' : 'class', \ 'v' : 'virtual' \ } let type_vera.scope2kind = { \ 'enum' : 'g', \ 'class' : 'c', \ 'virtual' : 'v' \ } let s:known_types.vera = type_vera " Verilog {{{3 let type_verilog = s:TypeInfo.New() let type_verilog.ctagstype = 'verilog' let type_verilog.kinds = [ \ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0}, \ {'short' : 'e', 'long' : 'events', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1}, \ {'short' : 'n', 'long' : 'net data types', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'ports', 'fold' : 0, 'stl' : 1}, \ {'short' : 'r', 'long' : 'register data types', 'fold' : 0, 'stl' : 1}, \ {'short' : 't', 'long' : 'tasks', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.verilog = type_verilog " VHDL {{{3 " The VHDL ctags parser unfortunately doesn't generate proper scopes let type_vhdl = s:TypeInfo.New() let type_vhdl.ctagstype = 'vhdl' let type_vhdl.kinds = [ \ {'short' : 'P', 'long' : 'packages', 'fold' : 1, 'stl' : 0}, \ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0}, \ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1}, \ {'short' : 'T', 'long' : 'subtypes', 'fold' : 0, 'stl' : 1}, \ {'short' : 'r', 'long' : 'records', 'fold' : 0, 'stl' : 1}, \ {'short' : 'e', 'long' : 'entities', 'fold' : 0, 'stl' : 1}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.vhdl = type_vhdl " Vim {{{3 let type_vim = s:TypeInfo.New() let type_vim.ctagstype = 'vim' let type_vim.kinds = [ \ {'short' : 'n', 'long' : 'vimball filenames', 'fold' : 0, 'stl' : 1}, \ {'short' : 'v', 'long' : 'variables', 'fold' : 1, 'stl' : 0}, \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'a', 'long' : 'autocommand groups', 'fold' : 1, 'stl' : 1}, \ {'short' : 'c', 'long' : 'commands', 'fold' : 0, 'stl' : 0}, \ {'short' : 'm', 'long' : 'maps', 'fold' : 1, 'stl' : 0} \ ] let s:known_types.vim = type_vim " YACC {{{3 let type_yacc = s:TypeInfo.New() let type_yacc.ctagstype = 'yacc' let type_yacc.kinds = [ \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1} \ ] let s:known_types.yacc = type_yacc " }}}3 call s:LoadUserTypeDefs() for typeinfo in values(s:known_types) call typeinfo.createKinddict() endfor let s:type_init_done = 1 endfunction " s:LoadUserTypeDefs() {{{2 function! s:LoadUserTypeDefs(...) abort if a:0 > 0 let type = a:1 call s:LogDebugMessage("Initializing user type '" . type . "'") let defdict = {} let defdict[type] = g:tagbar_type_{type} else call s:LogDebugMessage('Initializing user types') let defdict = tagbar#getusertypes() endif let transformed = {} for [type, def] in items(defdict) let transformed[type] = s:TransformUserTypeDef(def) endfor for [key, value] in items(transformed) if !has_key(s:known_types, key) || get(value, 'replace', 0) let s:known_types[key] = s:TypeInfo.New(value) else call extend(s:known_types[key], value) endif endfor if a:0 > 0 call s:known_types[type].createKinddict() endif endfunction " s:TransformUserTypeDef() {{{2 " Transform the user definitions into the internal format function! s:TransformUserTypeDef(def) abort let newdef = copy(a:def) if has_key(a:def, 'kinds') let newdef.kinds = [] let kinds = a:def.kinds for kind in kinds let kindlist = split(kind, ':') let kinddict = {'short' : kindlist[0], 'long' : kindlist[1]} let kinddict.fold = get(kindlist, 2, 0) let kinddict.stl = get(kindlist, 3, 1) call add(newdef.kinds, kinddict) endfor endif " If the user only specified one of kind2scope and scope2kind then use it " to generate the respective other if has_key(a:def, 'kind2scope') && !has_key(a:def, 'scope2kind') let newdef.scope2kind = {} for [key, value] in items(a:def.kind2scope) let newdef.scope2kind[value] = key endfor elseif has_key(a:def, 'scope2kind') && !has_key(a:def, 'kind2scope') let newdef.kind2scope = {} for [key, value] in items(a:def.scope2kind) let newdef.kind2scope[value] = key endfor endif return newdef endfunction " s:RestoreSession() {{{2 " Properly restore Tagbar after a session got loaded function! s:RestoreSession() abort call s:LogDebugMessage('Restoring session') let curfile = fnamemodify(bufname('%'), ':p') let tagbarwinnr = bufwinnr('__Tagbar__') if tagbarwinnr == -1 " Tagbar wasn't open in the saved session, nothing to do return else let in_tagbar = 1 if winnr() != tagbarwinnr call s:goto_win(tagbarwinnr) let in_tagbar = 0 endif endif let s:last_autofocus = 0 call s:Init(0) call s:InitWindow(g:tagbar_autoclose) call s:AutoUpdate(curfile, 0) if !in_tagbar call s:goto_win('p') endif endfunction " s:MapKeys() {{{2 function! s:MapKeys() abort call s:LogDebugMessage('Mapping keys') nnoremap