" Vimball Archiver by Charles E. Campbell UseVimball finish LICENSE [[[1 82 TAGBAR LICENSE This is the normal Vim license (see ':h license' in Vim) with the necessary replacements for the project and maintainer information. I) There are no restrictions on distributing unmodified copies of Tagbar except that they must include this license text. You can also distribute unmodified parts of Tagbar, likewise unrestricted except that they must include this license text. You are also allowed to include executables that you made from the unmodified Tagbar sources, plus your own usage examples and scripts. II) It is allowed to distribute a modified (or extended) version of Tagbar, including executables and/or source code, when the following four conditions are met: 1) This license text must be included unmodified. 2) The modified Tagbar must be distributed in one of the following five ways: a) If you make changes to Tagbar yourself, you must clearly describe in the distribution how to contact you. When the maintainer asks you (in any way) for a copy of the modified Tagbar you distributed, you must make your changes, including source code, available to the maintainer without fee. The maintainer reserves the right to include your changes in the official version of Tagbar. What the maintainer will do with your changes and under what license they will be distributed is negotiable. If there has been no negotiation then this license, or a later version, also applies to your changes. The current maintainer is Jan Larres . If this changes it will be announced in appropriate places (most likely majutsushi.github.io/tagbar and/or github.com/majutsushi/tagbar). When it is completely impossible to contact the maintainer, the obligation to send him your changes ceases. Once the maintainer has confirmed that he has received your changes they will not have to be sent again. b) If you have received a modified Tagbar that was distributed as mentioned under a) you are allowed to further distribute it unmodified, as mentioned at I). If you make additional changes the text under a) applies to those changes. c) Provide all the changes, including source code, with every copy of the modified Tagbar you distribute. This may be done in the form of a context diff. You can choose what license to use for new code you add. The changes and their license must not restrict others from making their own changes to the official version of Tagbar. d) When you have a modified Tagbar which includes changes as mentioned under c), you can distribute it without the source code for the changes if the following three conditions are met: - The license that applies to the changes permits you to distribute the changes to the Tagbar maintainer without fee or restriction, and permits the Tagbar maintainer to include the changes in the official version of Tagbar without fee or restriction. - You keep the changes for at least three years after last distributing the corresponding modified Tagbar. When the maintainer or someone who you distributed the modified Tagbar to asks you (in any way) for the changes within this period, you must make them available to him. - You clearly describe in the distribution how to contact you. This contact information must remain valid for at least three years after last distributing the corresponding modified Tagbar, or as long as possible. e) When the GNU General Public License (GPL) applies to the changes, you can distribute the modified Tagbar under the GNU GPL version 2 or any later version. 3) A message must be added, at least in the documentation, such that the user of the modified Tagbar is able to see that it was modified. When distributing as mentioned under 2)e) adding the message is only required for as far as this does not conflict with the license used for the changes. 4) The contact information as required under 2)a) and 2)d) must not be removed or changed, except that the person himself can make corrections. III) If you distribute a modified version of Tagbar, you are encouraged to use the Tagbar license for your changes and make them available to the maintainer, including the source code. The preferred way to do this is by e-mail or by uploading the files to a server and e-mailing the URL. If the number of changes is small (e.g., a modified Makefile) e-mailing a context diff will do. The e-mail address to be used is IV) It is not allowed to remove this license from the distribution of the Tagbar sources, parts of it or from a modified version. You may use this license for previous Tagbar releases instead of the license that they came with, at your option. README.md [[[1 89 # Tagbar: a class outline viewer for Vim ## What Tagbar is Tagbar is a Vim plugin that provides an easy way to browse the tags of the current file and get an overview of its structure. It does this by creating 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. ## What Tagbar is not Tagbar is not a general-purpose tool for managing `tags` files. It only creates the tags it needs on-the-fly in-memory without creating any files. `tags` file management is provided by other plugins, like for example [easytags](https://github.com/xolox/vim-easytags). ## Dependencies [Vim 7.0](http://www.vim.org/) (But see note below) [Exuberant ctags 5.5](http://ctags.sourceforge.net/) ## Installation Extract the archive or clone the repository into a directory in your `'runtimepath'`, or use a plugin manager of your choice like [pathogen](https://github.com/tpope/vim-pathogen). Don't forget to run `:helptags` if your plugin manager doesn't do it for you so you can access the documentation with `:help tagbar`. Note: Vim versions < 7.0.167 have a bug that prevents Tagbar from working. If you are affected by this use this alternate Tagbar download instead: [zip](https://github.com/majutsushi/tagbar/zipball/70fix). It is on par with version 2.2 but probably won't be updated after that due to the amount of changes required. If the ctags executable is not installed in one of the directories in your `$PATH` environment variable you have to set the `g:tagbar_ctags_bin` variable, see the documentation for more info. ## Quickstart Put something like the following into your ~/.vimrc: ```vim nmap :TagbarToggle ``` If you do this the F8 key will toggle the Tagbar window. You can of course use any shortcut you want. For more flexible ways to open and close the window (and the rest of the functionality) see the documentation. ## 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. ## Note: If the file structure display is 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 an issue. 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 the program responsible for that filetype 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 against Tagbar](https://github.com/majutsushi/tagbar/issues?labels=ctags-bug&page=1&state=closed). ## Screenshots ![screenshot1](https://i.imgur.com/Sf9Ls2r.png) ![screenshot2](https://i.imgur.com/n4bpPv3.png) ## License Vim license, see LICENSE ## Maintainer Jan Larres <[jan@majutsushi.net](mailto:jan@majutsushi.net)> autoload/tagbar.vim [[[1 4564 " ============================================================================ " 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.7 " 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 if exists(':Tagbar') == 0 echomsg 'Tagbar: Could not load plugin code, check your runtimepath!' finish 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_is_uctags = 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:buffer_seqno = 0 let s:vim_quitting = 0 let s:last_alt_bufnr = -1 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 = '' let s:warnings = { \ 'type': [], \ 'encoding': 0 \ } " 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:debug('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 " Asymptote {{{3 " Asymptote gets parsed well using filetype = c let type_asy = s:TypeInfo.New() let type_asy.ctagstype = 'c' let type_asy.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_asy.sro = '::' let type_asy.kind2scope = { \ 'g' : 'enum', \ 's' : 'struct', \ 'u' : 'union' \ } let type_asy.scope2kind = { \ 'enum' : 'g', \ 'struct' : 's', \ 'union' : 'u' \ } let s:known_types.asy = type_asy " 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 let s:known_types.cuda = 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' if s:ctags_is_uctags let type_html.kinds = [ \ {'short' : 'a', 'long' : 'named anchors', 'fold' : 0, 'stl' : 1}, \ {'short' : 'h', 'long' : 'H1 headings', 'fold' : 0, 'stl' : 1}, \ {'short' : 'i', 'long' : 'H2 headings', 'fold' : 0, 'stl' : 1}, \ {'short' : 'j', 'long' : 'H3 headings', 'fold' : 0, 'stl' : 1}, \ ] else let type_html.kinds = [ \ {'short' : 'f', 'long' : 'JavaScript functions', 'fold' : 0, 'stl' : 1}, \ {'short' : 'a', 'long' : 'named anchors', 'fold' : 0, 'stl' : 1} \ ] endif 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 " 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}, \ ] let type_javascript.sro = '.' let type_javascript.kind2scope = { \ 'c' : 'class', \ 'f' : 'function', \ 'm' : 'method', \ 'p' : 'property', \ } let type_javascript.scope2kind = { \ 'class' : 'c', \ 'function' : 'f', \ } 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' \ } if s:ctags_is_uctags " Universal Ctags treats member functions differently from normal " functions let type_python.kind2scope.m = 'member' let type_python.scope2kind.member = 'm' endif 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 for [type, typeinfo] in items(s:known_types) let typeinfo.ftype = type endfor 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:debug("Initializing user type '" . type . "'") let defdict = {} let defdict[type] = g:tagbar_type_{type} else call s:debug('Initializing user types') let defdict = tagbar#getusertypes() endif let transformed = {} for [type, def] in items(defdict) let transformed[type] = s:TransformUserTypeDef(def) let transformed[type].ftype = type 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:debug('Restoring session') let curfile = fnamemodify(bufname('%'), ':p') let tagbarwinnr = bufwinnr(s:TagbarBufName()) 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:debug('Mapping keys') nnoremap