Fix for embedded interfaces

Introducing small function for displaying type (kind) of a current tag.
Useful for putting it in the status bar.

.github/workflows/check.yml

@@ -0,0 +1,34 @@
+name: Check
+
+on: [push, pull_request]
+
+jobs:
+  check:
+    strategy:
+      fail-fast: false
+      matrix:
+        vimFlavor: ["vim", "nvim"]
+        tagsProvider: ["exuberant-ctags", "universal-tags"]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@master
+    - name: Install ${{ matrix.tagsProvider }}
+      run: |
+        case ${{ matrix.tagsProvider }} in
+          exuberant-*) sudo apt-get install ctags ;;
+          universal-*) sudo snap install universal-ctags ;;
+        esac
+    - name: Install ${{ matrix.vimFlavor }}
+      if: matrix.vimFlavor == 'nvim'
+      run: |
+        sudo add-apt-repository universe
+        sudo apt-get update
+        sudo apt-get install neovim
+    - name: Review ctags version
+      run: ctags --version
+    - name: Review ${{ matrix.vimFlavor }} version
+      run: ${{ matrix.vimFlavor }} --version
+    - name: "Try tagbar#OpenWindow()"
+      run: |
+        ${{ matrix.tagsProvider == 'nvim' && 'nvim -i NONE -u /dev/null --headless' || 'vim -i NONE' }} "+set rtp+=$(pwd)" "+call tagbar#OpenWindow() | q" "+cq" plugin/tagbar.vim

.github/workflows/vint.yml

@@ -0,0 +1,15 @@
+name: Vint
+on: [push, pull_request]
+jobs:
+  vint:
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@master
+    - name: Run vint with reviewdog
+      uses: reviewdog/action-vint@v1.0.1
+      with:
+        github_token: ${{ secrets.github_token }}
+        reporter: github-pr-review

.vintrc.yaml

@@ -0,0 +1,5 @@
+cmdargs:
+  severity: style_problem
+  color: true
+  env:
+    neovim: false

README.md

@@ -1,5 +1,8 @@
 # Tagbar: a class outline viewer for Vim
 
+[![Vint](https://github.com/majutsushi/tagbar/workflows/Vint/badge.svg)](https://github.com/majutsushi/tagbar/actions?workflow=Vint)
+[![Check](https://github.com/majutsushi/tagbar/workflows/Check/badge.svg)](https://github.com/majutsushi/tagbar/actions?workflow=Check)
+
 ## What Tagbar is
 
 Tagbar is a Vim plugin that provides an easy way to browse the tags of the
@@ -17,8 +20,16 @@ creates the tags it needs on-the-fly in-memory without creating any files.
 
 ## Dependencies
 
-[Vim 7.0](http://www.vim.org/) (But see note below)  
-[Exuberant ctags 5.5](http://ctags.sourceforge.net/)
+* [Vim](http://www.vim.org/) >= 7.3.1058
+  or any version of [NeoVim](https://neovim.io/).
+
+* [Exuberant Ctags](http://ctags.sourceforge.net/) >= 5.5,
+  or (**highly recommended**) any version of [Universal
+  Ctags](https://ctags.io) which is a currently maintained fork of Exuberant
+  Ctags with many bugfixes, support for many more formats, and proper Unicode
+  support. Some additional formats can also be handled by other providers such
+  as [jsctags](https://github.com/sergioramos/jsctags),
+  [phpctags](https://github.com/vim-php/phpctags), or others.
 
 ## Installation
 
@@ -28,12 +39,6 @@ Extract the archive or clone the repository into a directory in your
 `: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.
@@ -82,8 +87,11 @@ against Tagbar](https://github.com/majutsushi/tagbar/issues?labels=ctags-bug&pag
 
 ## License
 
-Vim license, see LICENSE
+Tagbar is distributed under the terms of the *Vim license*, see the included [LICENSE][] file.
 
-## Maintainer
+## Contributors
 
-Jan Larres <[jan@majutsushi.net](mailto:jan@majutsushi.net)>
+Tagbar was originally written by [Jan Larres](https://github.com/majutsushi).
+It is actively maintained by [Caleb Maclennan](https://github.com/alerque).
+At least [45 others have contributed](https://github.com/majutsushi/tagbar/graphs/contributors) features and bug fixes over the years.
+Please document [issues](https://github.com/majutsushi/tagbar/issues) or submit [pull requests](https://github.com/majutsushi/tagbar/issues) on Github.

autoload/tagbar/debug.vim

@@ -0,0 +1,62 @@
+function! tagbar#debug#start_debug(...) abort
+    let filename = a:0 > 0 ? a:1 : ''
+
+    if empty(filename)
+        let s:debug_file = 'tagbardebug.log'
+    else
+        let s:debug_file = filename
+    endif
+
+    " Clear log file and start it with version info
+    exe 'redir! > ' . s:debug_file
+    silent version
+    redir END
+
+    " Check whether the log file could be created
+    if !filewritable(s:debug_file)
+        echomsg 'Tagbar: Unable to create log file ' . s:debug_file
+        let s:debug_file = ''
+        return
+    endif
+
+    let s:debug_enabled = 1
+endfunction
+
+function! tagbar#debug#stop_debug() abort
+    let s:debug_enabled = 0
+    let s:debug_file = ''
+endfunction
+
+function! tagbar#debug#log(msg) abort
+    if s:debug_enabled
+        execute 'redir >> ' . s:debug_file
+        silent echon s:gettime() . ': ' . a:msg . "\n"
+        redir END
+    endif
+endfunction
+
+function! tagbar#debug#log_ctags_output(output) abort
+    if s:debug_enabled
+        exe 'redir! > ' . s:debug_file . '.ctags_out'
+        silent echon a:output
+        redir END
+    endif
+endfunction
+
+function! tagbar#debug#enabled() abort
+    return s:debug_enabled
+endfunction
+
+if has('reltime')
+    function! s:gettime() abort
+        let time = split(reltimestr(reltime()), '\.')
+        return strftime('%Y-%m-%d %H:%M:%S.', time[0]) . time[1]
+    endfunction
+else
+    function! s:gettime() abort
+        return strftime('%Y-%m-%d %H:%M:%S')
+    endfunction
+endif
+
+let s:debug_enabled = 0
+let s:debug_file = ''

autoload/tagbar/prototypes/basetag.vim

@@ -0,0 +1,237 @@
+let s:visibility_symbols = {
+    \ 'public'    : '+',
+    \ 'protected' : '#',
+    \ 'private'   : '-'
+\ }
+
+function! tagbar#prototypes#basetag#new(name) abort
+    let newobj = {}
+
+    let newobj.name          = a:name
+    let newobj.fields        = {}
+    let newobj.fields.line   = 0
+    let newobj.fields.column = 0
+    let newobj.prototype     = ''
+    let newobj.path          = ''
+    let newobj.fullpath      = a:name
+    let newobj.depth         = 0
+    let newobj.parent        = {}
+    let newobj.tline         = -1
+    let newobj.fileinfo      = {}
+    let newobj.typeinfo      = {}
+    let newobj._childlist    = []
+    let newobj._childdict    = {}
+
+    let newobj.isNormalTag = function(s:add_snr('s:isNormalTag'))
+    let newobj.isPseudoTag = function(s:add_snr('s:isPseudoTag'))
+    let newobj.isSplitTag = function(s:add_snr('s:isSplitTag'))
+    let newobj.isKindheader = function(s:add_snr('s:isKindheader'))
+    let newobj.getPrototype = function(s:add_snr('s:getPrototype'))
+    let newobj._getPrefix = function(s:add_snr('s:_getPrefix'))
+    let newobj.initFoldState = function(s:add_snr('s:initFoldState'))
+    let newobj.getClosedParentTline = function(s:add_snr('s:getClosedParentTline'))
+    let newobj.isFoldable = function(s:add_snr('s:isFoldable'))
+    let newobj.isFolded = function(s:add_snr('s:isFolded'))
+    let newobj.openFold = function(s:add_snr('s:openFold'))
+    let newobj.closeFold = function(s:add_snr('s:closeFold'))
+    let newobj.setFolded = function(s:add_snr('s:setFolded'))
+    let newobj.openParents = function(s:add_snr('s:openParents'))
+    let newobj.addChild = function(s:add_snr('s:addChild'))
+    let newobj.getChildren = function(s:add_snr('s:getChildren'))
+    let newobj.getChildrenByName = function(s:add_snr('s:getChildrenByName'))
+    let newobj.removeChild = function(s:add_snr('s:removeChild'))
+
+    return newobj
+endfunction
+
+" s:isNormalTag() {{{1
+function! s:isNormalTag() abort dict
+    return 0
+endfunction
+
+" s:isPseudoTag() {{{1
+function! s:isPseudoTag() abort dict
+    return 0
+endfunction
+
+" s:isSplitTag {{{1
+function! s:isSplitTag() abort dict
+    return 0
+endfunction
+
+" s:isKindheader() {{{1
+function! s:isKindheader() abort dict
+    return 0
+endfunction
+
+" s:getPrototype() {{{1
+function! s:getPrototype(short) abort dict
+    return self.prototype
+endfunction
+
+" s:_getPrefix() {{{1
+function! s:_getPrefix() abort dict
+    let fileinfo = self.fileinfo
+
+    if !empty(self._childlist)
+        if fileinfo.tagfolds[self.fields.kind][self.fullpath]
+            let prefix = g:tagbar#icon_closed
+        else
+            let prefix = g:tagbar#icon_open
+        endif
+    else
+        let prefix = ' '
+    endif
+    " Visibility is called 'access' in the ctags output
+    if g:tagbar_show_visibility
+        if has_key(self.fields, 'access')
+            let prefix .= get(s:visibility_symbols, self.fields.access, ' ')
+        elseif has_key(self.fields, 'file')
+            let prefix .= s:visibility_symbols.private
+        else
+            let prefix .= ' '
+        endif
+    endif
+
+    return prefix
+endfunction
+
+" s:initFoldState() {{{1
+function! s:initFoldState(known_files) abort dict
+    let fileinfo = self.fileinfo
+
+    if a:known_files.has(fileinfo.fpath) &&
+     \ has_key(fileinfo, '_tagfolds_old') &&
+     \ has_key(fileinfo._tagfolds_old[self.fields.kind], self.fullpath)
+        " The file has been updated and the tag was there before, so copy its
+        " old fold state
+        let fileinfo.tagfolds[self.fields.kind][self.fullpath] =
+                    \ fileinfo._tagfolds_old[self.fields.kind][self.fullpath]
+    elseif self.depth >= fileinfo.foldlevel
+        let fileinfo.tagfolds[self.fields.kind][self.fullpath] = 1
+    else
+        let fileinfo.tagfolds[self.fields.kind][self.fullpath] =
+                    \ fileinfo.kindfolds[self.fields.kind]
+    endif
+endfunction
+
+" s:getClosedParentTline() {{{1
+function! s:getClosedParentTline() abort dict
+    let tagline  = self.tline
+
+    " Find the first closed parent, starting from the top of the hierarchy.
+    let parents   = []
+    let curparent = self.parent
+    while !empty(curparent)
+        call add(parents, curparent)
+        let curparent = curparent.parent
+    endwhile
+    for parent in reverse(parents)
+        if parent.isFolded()
+            let tagline = parent.tline
+            break
+        endif
+    endfor
+
+    return tagline
+endfunction
+
+" s:isFoldable() {{{1
+function! s:isFoldable() abort dict
+    return !empty(self._childlist)
+endfunction
+
+" s:isFolded() {{{1
+function! s:isFolded() abort dict
+    return self.fileinfo.tagfolds[self.fields.kind][self.fullpath]
+endfunction
+
+" s:openFold() {{{1
+function! s:openFold() abort dict
+    if self.isFoldable()
+        let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 0
+    endif
+endfunction
+
+" s:closeFold() {{{1
+function! s:closeFold() abort dict
+    let newline = line('.')
+
+    if !empty(self.parent) && self.parent.isKindheader()
+        " Tag is child of generic 'kind'
+        call self.parent.closeFold()
+        let newline = self.parent.tline
+    elseif self.isFoldable() && !self.isFolded()
+        " Tag is parent of a scope and is not folded
+        let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 1
+        let newline = self.tline
+    elseif !empty(self.parent)
+        " Tag is normal child, so close parent
+        let parent = self.parent
+        let self.fileinfo.tagfolds[parent.fields.kind][parent.fullpath] = 1
+        let newline = parent.tline
+    endif
+
+    return newline
+endfunction
+
+" s:setFolded() {{{1
+function! s:setFolded(folded) abort dict
+    let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = a:folded
+endfunction
+
+" s:openParents() {{{1
+function! s:openParents() abort dict
+    let parent = self.parent
+
+    while !empty(parent)
+        call parent.openFold()
+        let parent = parent.parent
+    endwhile
+endfunction
+
+" s:addChild() {{{1
+function! s:addChild(tag) abort dict
+    call add(self._childlist, a:tag)
+
+    if has_key(self._childdict, a:tag.name)
+        call add(self._childdict[a:tag.name], a:tag)
+    else
+        let self._childdict[a:tag.name] = [a:tag]
+    endif
+endfunction
+
+" s:getChildren() {{{1
+function! s:getChildren() dict abort
+    return self._childlist
+endfunction
+
+" s:getChildrenByName() {{{1
+function! s:getChildrenByName(tagname) dict abort
+    return get(self._childdict, a:tagname, [])
+endfunction
+
+" s:removeChild() {{{1
+function! s:removeChild(tag) dict abort
+    let idx = index(self._childlist, a:tag)
+    if idx >= 0
+        call remove(self._childlist, idx)
+    endif
+
+    let namelist = get(self._childdict, a:tag.name, [])
+    let idx = index(namelist, a:tag)
+    if idx >= 0
+        call remove(namelist, idx)
+    endif
+endfunction
+
+" s:add_snr() {{{1
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/prototypes/fileinfo.vim

@@ -0,0 +1,146 @@
+function! tagbar#prototypes#fileinfo#new(fname, ftype, typeinfo) abort
+    let newobj = {}
+
+    " The complete file path
+    let newobj.fpath = a:fname
+
+    let newobj.bufnr = bufnr(a:fname)
+
+    " File modification time
+    let newobj.mtime = getftime(a:fname)
+
+    " The vim file type
+    let newobj.ftype = a:ftype
+
+    " List of the tags that are present in the file, sorted according to the
+    " value of 'g:tagbar_sort'
+    let newobj._taglist = []
+    let newobj._tagdict = {}
+
+    " Dictionary of the tags, indexed by line number in the file
+    let newobj.fline = {}
+
+    " Dictionary of the tags, indexed by line number in the tagbar
+    let newobj.tline = {}
+
+    " Dictionary of the folding state of 'kind's, indexed by short name
+    let newobj.kindfolds = {}
+    let newobj.typeinfo = a:typeinfo
+    " copy the default fold state from the type info
+    for kind in a:typeinfo.kinds
+        let newobj.kindfolds[kind.short] =
+                    \ g:tagbar_foldlevel == 0 ? 1 : kind.fold
+    endfor
+
+    " Dictionary of dictionaries of the folding state of individual tags,
+    " indexed by kind and full path
+    let newobj.tagfolds = {}
+    for kind in a:typeinfo.kinds
+        let newobj.tagfolds[kind.short] = {}
+    endfor
+
+    " The current foldlevel of the file
+    let newobj.foldlevel = g:tagbar_foldlevel
+
+    let newobj.addTag = function(s:add_snr('s:addTag'))
+    let newobj.getTags = function(s:add_snr('s:getTags'))
+    let newobj.getTagsByName = function(s:add_snr('s:getTagsByName'))
+    let newobj.removeTag = function(s:add_snr('s:removeTag'))
+    let newobj.reset = function(s:add_snr('s:reset'))
+    let newobj.clearOldFolds = function(s:add_snr('s:clearOldFolds'))
+    let newobj.sortTags = function(s:add_snr('s:sortTags'))
+    let newobj.openKindFold = function(s:add_snr('s:openKindFold'))
+    let newobj.closeKindFold = function(s:add_snr('s:closeKindFold'))
+
+    return newobj
+endfunction
+
+" s:addTag() {{{1
+function! s:addTag(tag) abort dict
+    call add(self._taglist, a:tag)
+
+    if has_key(self._tagdict, a:tag.name)
+        call add(self._tagdict[a:tag.name], a:tag)
+    else
+        let self._tagdict[a:tag.name] = [a:tag]
+    endif
+endfunction
+
+" s:getTags() {{{1
+function! s:getTags() dict abort
+    return self._taglist
+endfunction
+
+" s:getTagsByName() {{{1
+function! s:getTagsByName(tagname) dict abort
+    return get(self._tagdict, a:tagname, [])
+endfunction
+
+" s:removeTag() {{{1
+function! s:removeTag(tag) dict abort
+    let idx = index(self._taglist, a:tag)
+    if idx >= 0
+        call remove(self._taglist, idx)
+    endif
+
+    let namelist = get(self._tagdict, a:tag.name, [])
+    let idx = index(namelist, a:tag)
+    if idx >= 0
+        call remove(namelist, idx)
+    endif
+endfunction
+
+" s:reset() {{{1
+" Reset stuff that gets regenerated while processing a file and save the old
+" tag folds
+function! s:reset() abort dict
+    let self.mtime = getftime(self.fpath)
+    let self._taglist = []
+    let self._tagdict = {}
+    let self.fline = {}
+    let self.tline = {}
+
+    let self._tagfolds_old = self.tagfolds
+    let self.tagfolds = {}
+
+    for kind in self.typeinfo.kinds
+        let self.tagfolds[kind.short] = {}
+    endfor
+endfunction
+
+" s:clearOldFolds() {{{1
+function! s:clearOldFolds() abort dict
+    if exists('self._tagfolds_old')
+        unlet self._tagfolds_old
+    endif
+endfunction
+
+" s:sortTags() {{{1
+function! s:sortTags(compare_typeinfo) abort dict
+    if get(a:compare_typeinfo, 'sort', g:tagbar_sort)
+        call tagbar#sorting#sort(self._taglist, 'kind', a:compare_typeinfo)
+    else
+        call tagbar#sorting#sort(self._taglist, 'line', a:compare_typeinfo)
+    endif
+endfunction
+
+" s:openKindFold() {{{1
+function! s:openKindFold(kind) abort dict
+    let self.kindfolds[a:kind.short] = 0
+endfunction
+
+" s:closeKindFold() {{{1
+function! s:closeKindFold(kind) abort dict
+    let self.kindfolds[a:kind.short] = 1
+endfunction
+
+" s:add_snr() {{{1
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/prototypes/kindheadertag.vim

@@ -0,0 +1,61 @@
+function! tagbar#prototypes#kindheadertag#new(name) abort
+    let newobj = tagbar#prototypes#basetag#new(a:name)
+
+    let newobj.isKindheader = function(s:add_snr('s:isKindheader'))
+    let newobj.getPrototype = function(s:add_snr('s:getPrototype'))
+    let newobj.isFoldable = function(s:add_snr('s:isFoldable'))
+    let newobj.isFolded = function(s:add_snr('s:isFolded'))
+    let newobj.openFold = function(s:add_snr('s:openFold'))
+    let newobj.closeFold = function(s:add_snr('s:closeFold'))
+    let newobj.toggleFold = function(s:add_snr('s:toggleFold'))
+
+    return newobj
+endfunction
+
+" s:isKindheader() {{{1
+function! s:isKindheader() abort dict
+    return 1
+endfunction
+
+" s:getPrototype() {{{1
+function! s:getPrototype(short) abort dict
+    return self.name . ': ' .
+         \ self.numtags . ' ' . (self.numtags > 1 ? 'tags' : 'tag')
+endfunction
+
+" s:isFoldable() {{{1
+function! s:isFoldable() abort dict
+    return 1
+endfunction
+
+" s:isFolded() {{{1
+function! s:isFolded() abort dict
+    return self.fileinfo.kindfolds[self.short]
+endfunction
+
+" s:openFold() {{{1
+function! s:openFold() abort dict
+    let self.fileinfo.kindfolds[self.short] = 0
+endfunction
+
+" s:closeFold() {{{1
+function! s:closeFold() abort dict
+    let self.fileinfo.kindfolds[self.short] = 1
+    return line('.')
+endfunction
+
+" s:toggleFold() {{{1
+function! s:toggleFold(fileinfo) abort dict
+    let a:fileinfo.kindfolds[self.short] = !a:fileinfo.kindfolds[self.short]
+endfunction
+
+" s:add_snr() {{{1
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/prototypes/normaltag.vim

@@ -0,0 +1,119 @@
+function! tagbar#prototypes#normaltag#new(name) abort
+    let newobj = tagbar#prototypes#basetag#new(a:name)
+
+    let newobj.isNormalTag = function(s:add_snr('s:isNormalTag'))
+    let newobj.strfmt = function(s:add_snr('s:strfmt'))
+    let newobj.str = function(s:add_snr('s:str'))
+    let newobj.getPrototype = function(s:add_snr('s:getPrototype'))
+
+    return newobj
+endfunction
+
+" s:isNormalTag() {{{1
+function! s:isNormalTag() abort dict
+    return 1
+endfunction
+
+" s:strfmt() {{{1
+function! s:strfmt() abort dict
+    let typeinfo = self.typeinfo
+
+    let suffix = get(self.fields, 'signature', '')
+    if has_key(self.fields, 'type')
+        let suffix .= ' : ' . self.fields.type
+    elseif has_key(get(typeinfo, 'kind2scope', {}), self.fields.kind)
+        let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
+    endif
+
+    return self._getPrefix() . self.name . suffix
+endfunction
+
+" s:str() {{{1
+function! s:str(longsig, full) abort dict
+    if a:full && self.path !=# ''
+        let str = self.path . self.typeinfo.sro . self.name
+    else
+        let str = self.name
+    endif
+
+    if has_key(self.fields, 'signature')
+        if a:longsig
+            let str .= self.fields.signature
+        else
+            let str .= '()'
+        endif
+    endif
+
+    return str
+endfunction
+
+" s:getPrototype() {{{1
+function! s:getPrototype(short) abort dict
+    if self.prototype !=# ''
+        let prototype = self.prototype
+    else
+        let bufnr = self.fileinfo.bufnr
+
+        if self.fields.line == 0 || !bufloaded(bufnr)
+            " No linenumber available or buffer not loaded (probably due to
+            " 'nohidden'), try the pattern instead
+            return substitute(self.pattern, '^\\M\\^\\C\s*\(.*\)\\$$', '\1', '')
+        endif
+
+        let line = getbufline(bufnr, self.fields.line)[0]
+        let list = split(line, '\zs')
+
+        let start = index(list, '(')
+        if start == -1
+            return substitute(line, '^\s\+', '', '')
+        endif
+
+        let opening = count(list, '(', 0, start)
+        let closing = count(list, ')', 0, start)
+        if closing >= opening
+            return substitute(line, '^\s\+', '', '')
+        endif
+
+        let balance = opening - closing
+
+        let prototype = line
+        let curlinenr = self.fields.line + 1
+        while balance > 0
+            let curline = getbufline(bufnr, curlinenr)[0]
+            let curlist = split(curline, '\zs')
+            let balance += count(curlist, '(')
+            let balance -= count(curlist, ')')
+            let prototype .= "\n" . curline
+            let curlinenr += 1
+        endwhile
+
+        let self.prototype = prototype
+    endif
+
+    if a:short
+        " join all lines and remove superfluous spaces
+        let prototype = substitute(prototype, '^\s\+', '', '')
+        let prototype = substitute(prototype, '\_s\+', ' ', 'g')
+        let prototype = substitute(prototype, '(\s\+', '(', 'g')
+        let prototype = substitute(prototype, '\s\+)', ')', 'g')
+        " Avoid hit-enter prompts
+        let maxlen = &columns - 12
+        if len(prototype) > maxlen
+            let prototype = prototype[:maxlen - 1 - 3]
+            let prototype .= '...'
+        endif
+    endif
+
+    return prototype
+endfunction
+
+" s:add_snr() {{{1
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/prototypes/pseudotag.vim

@@ -0,0 +1,36 @@
+function! tagbar#prototypes#pseudotag#new(name) abort
+    let newobj = tagbar#prototypes#basetag#new(a:name)
+
+    let newobj.isPseudoTag = function(s:add_snr('s:isPseudoTag'))
+    let newobj.strfmt = function(s:add_snr('s:strfmt'))
+
+    return newobj
+endfunction
+
+" s:isPseudoTag() {{{1
+function! s:isPseudoTag() abort dict
+    return 1
+endfunction
+
+" s:strfmt() {{{1
+function! s:strfmt() abort dict
+    let typeinfo = self.typeinfo
+
+    let suffix = get(self.fields, 'signature', '')
+    if has_key(typeinfo.kind2scope, self.fields.kind)
+        let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
+    endif
+
+    return self._getPrefix() . self.name . '*' . suffix
+endfunction
+
+" s:add_snr() {{{1
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/prototypes/splittag.vim

@@ -0,0 +1,26 @@
+" A tag that was created because of a tag name that covers multiple scopes
+" Inherits the fields of the "main" tag it was split from.
+" May be replaced during tag processing if it appears as a normal tag later,
+" just like a pseudo tag.
+
+function! tagbar#prototypes#splittag#new(name) abort
+    let newobj = tagbar#prototypes#normaltag#new(a:name)
+
+    let newobj.isSplitTag = function(s:add_snr('s:isSplitTag'))
+
+    return newobj
+endfunction
+
+function! s:isSplitTag() abort dict
+    return 1
+endfunction
+
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/prototypes/typeinfo.vim

@@ -0,0 +1,42 @@
+function! tagbar#prototypes#typeinfo#new(...) abort
+    let newobj = {}
+
+    let newobj.kinddict = {}
+
+    if a:0 > 0
+        call extend(newobj, a:1)
+    endif
+
+    let newobj.getKind = function(s:add_snr('s:getKind'))
+    let newobj.createKinddict = function(s:add_snr('s:createKinddict'))
+
+    return newobj
+endfunction
+
+" s:getKind() {{{1
+function! s:getKind(kind) abort dict
+    let idx = self.kinddict[a:kind]
+    return self.kinds[idx]
+endfunction
+
+" s:createKinddict() {{{1
+" Create a dictionary of the kind order for fast access in sorting functions
+function! s:createKinddict() abort dict
+    let i = 0
+    for kind in self.kinds
+        let self.kinddict[kind.short] = i
+        let i += 1
+    endfor
+    let self.kinddict['?'] = i
+endfunction
+
+" s:add_snr() {{{1
+function! s:add_snr(funcname) abort
+    if !exists('s:snr')
+        let s:snr = matchstr(expand('<sfile>'), '<SNR>\d\+_\zeget_snr$')
+    endif
+    return s:snr . a:funcname
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/sorting.vim

@@ -0,0 +1,57 @@
+" Script-local variable needed since compare functions can't
+" take additional arguments
+let s:compare_typeinfo = {}
+
+function! tagbar#sorting#sort(tags, compareby, compare_typeinfo) abort
+    let s:compare_typeinfo = a:compare_typeinfo
+
+    let comparemethod =
+            \ a:compareby ==# 'kind' ? 's:compare_by_kind' : 's:compare_by_line'
+
+    call sort(a:tags, comparemethod)
+
+    for tag in a:tags
+        if !empty(tag.getChildren())
+            call tagbar#sorting#sort(tag.getChildren(), a:compareby,
+                                   \ a:compare_typeinfo)
+        endif
+    endfor
+endfunction
+
+function! s:compare_by_kind(tag1, tag2) abort
+    let typeinfo = s:compare_typeinfo
+
+    if typeinfo.kinddict[a:tag1.fields.kind] <#
+     \ typeinfo.kinddict[a:tag2.fields.kind]
+        return -1
+    elseif typeinfo.kinddict[a:tag1.fields.kind] >#
+         \ typeinfo.kinddict[a:tag2.fields.kind]
+        return 1
+    else
+        " Ignore '~' prefix for C++ destructors to sort them directly under
+        " the constructors
+        if a:tag1.name[0] ==# '~'
+            let name1 = a:tag1.name[1:]
+        else
+            let name1 = a:tag1.name
+        endif
+        if a:tag2.name[0] ==# '~'
+            let name2 = a:tag2.name[1:]
+        else
+            let name2 = a:tag2.name
+        endif
+
+        let ci = g:tagbar_case_insensitive
+        if (((!ci) && (name1 <=# name2)) || (ci && (name1 <=? name2)))
+            return -1
+        else
+            return 1
+        endif
+    endif
+endfunction
+
+function! s:compare_by_line(tag1, tag2) abort
+    return a:tag1.fields.line - a:tag2.fields.line
+endfunction
+
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/state.vim

@@ -0,0 +1,51 @@
+function! tagbar#state#get_current_file(force_current) abort
+    return s:get().getCurrent(a:force_current)
+endfunction
+
+function! tagbar#state#set_current_file(fileinfo) abort
+    call s:get().setCurrentFile(a:fileinfo)
+endfunction
+
+function! tagbar#state#set_paused() abort
+    call s:get().setPaused()
+endfunction
+
+function! s:get() abort
+    if !exists('t:tagbar_state')
+        let t:tagbar_state = s:State.New()
+    endif
+
+    return t:tagbar_state
+endfunction
+
+let s:State = {
+    \ '_current' : {},
+    \ '_paused'  : {},
+\ }
+
+" s:state.New() {{{1
+function! s:State.New() abort dict
+    return deepcopy(self)
+endfunction
+
+" s:state.getCurrent() {{{1
+function! s:State.getCurrent(force_current) abort dict
+    if !tagbar#is_paused() || a:force_current
+        return self._current
+    else
+        return self._paused
+    endif
+endfunction
+
+" s:state.setCurrentFile() {{{1
+function! s:State.setCurrentFile(fileinfo) abort dict
+    let self._current = a:fileinfo
+endfunction
+
+" s:state.setPaused() {{{1
+function! s:State.setPaused() abort dict
+    let self._paused = self._current
+endfunction
+
+" Modeline {{{1
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

autoload/tagbar/types/ctags.vim

@@ -0,0 +1,773 @@
+" Type definitions for standard Exuberant Ctags
+
+function! tagbar#types#ctags#init(supported_types) abort
+    let types = {}
+
+    " Ant {{{1
+    let type_ant = tagbar#prototypes#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 types.ant = type_ant
+    " Asm {{{1
+    let type_asm = tagbar#prototypes#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 types.asm = type_asm
+    " ASP {{{1
+    let type_aspvbs = tagbar#prototypes#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 types.aspvbs = type_aspvbs
+    " Asymptote {{{1
+    " Asymptote gets parsed well using filetype = c
+    let type_asy = tagbar#prototypes#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 types.asy = type_asy
+    " Awk {{{1
+    let type_awk = tagbar#prototypes#typeinfo#new()
+    let type_awk.ctagstype = 'awk'
+    let type_awk.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.awk = type_awk
+    " Basic {{{1
+    let type_basic = tagbar#prototypes#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 types.basic = type_basic
+    " BETA {{{1
+    let type_beta = tagbar#prototypes#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 types.beta = type_beta
+    " C {{{1
+    let type_c = tagbar#prototypes#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 types.c = type_c
+    " C++ {{{1
+    let type_cpp = tagbar#prototypes#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 types.cpp = type_cpp
+    let types.cuda = type_cpp
+    " C# {{{1
+    let type_cs = tagbar#prototypes#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 types.cs = type_cs
+    " COBOL {{{1
+    let type_cobol = tagbar#prototypes#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 types.cobol = type_cobol
+    " DOS Batch {{{1
+    let type_dosbatch = tagbar#prototypes#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 types.dosbatch = type_dosbatch
+    " Eiffel {{{1
+    let type_eiffel = tagbar#prototypes#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 types.eiffel = type_eiffel
+    " Erlang {{{1
+    let type_erlang = tagbar#prototypes#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 types.erlang = type_erlang
+    " Flex {{{1
+    " 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 = tagbar#prototypes#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 types.mxml = type_as
+    let types.actionscript = type_as
+    " Fortran {{{1
+    let type_fortran = tagbar#prototypes#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 types.fortran = type_fortran
+    " Go {{{1
+    let type_go = tagbar#prototypes#typeinfo#new()
+    let type_go.ctagstype = 'go'
+    let type_go.kinds = [
+        \ {'short' : 'p', 'long' : 'packages',       'fold' : 0, 'stl' : 0},
+        \ {'short' : 'i', 'long' : 'interfaces',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'constants',      'fold' : 0, 'stl' : 0},
+        \ {'short' : 's', 'long' : 'structs',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'struct members', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'types',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',      'fold' : 0, 'stl' : 0}
+    \ ]
+    let type_go.sro = '.'
+    let type_go.kind2scope = {
+        \ 's' : 'struct'
+    \ }
+    let type_go.scope2kind = {
+        \ 'struct' : 's'
+    \ }
+    let types.go = type_go
+    " HTML {{{1
+    let type_html = tagbar#prototypes#typeinfo#new()
+    let type_html.ctagstype = 'html'
+    let type_html.kinds = [
+        \ {'short' : 'f', 'long' : 'JavaScript functions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'a', 'long' : 'named anchors',        'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.html = type_html
+    " Java {{{1
+    let type_java = tagbar#prototypes#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 types.java = type_java
+    " JavaScript {{{1
+    let type_javascript = tagbar#prototypes#typeinfo#new()
+    let type_javascript.ctagstype = 'javascript'
+    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',
+    \ }
+    let types.javascript = type_javascript
+    " Lisp {{{1
+    let type_lisp = tagbar#prototypes#typeinfo#new()
+    let type_lisp.ctagstype = 'lisp'
+    let type_lisp.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.lisp = type_lisp
+    let types.clojure = type_lisp
+    " Lua {{{1
+    let type_lua = tagbar#prototypes#typeinfo#new()
+    let type_lua.ctagstype = 'lua'
+    let type_lua.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.lua = type_lua
+    " Make {{{1
+    let type_make = tagbar#prototypes#typeinfo#new()
+    let type_make.ctagstype = 'make'
+    let type_make.kinds     = [
+        \ {'short' : 'm', 'long' : 'macros', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.make = type_make
+    " Matlab {{{1
+    let type_matlab = tagbar#prototypes#typeinfo#new()
+    let type_matlab.ctagstype = 'matlab'
+    let type_matlab.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.matlab = type_matlab
+    " ObjectiveC {{{1
+    let type_objc = tagbar#prototypes#typeinfo#new()
+    let type_objc.ctagstype = 'objectivec'
+    let type_objc.kinds = [
+        \ {'short' : 'M', 'long' : 'preprocessor macros',   'fold' : 1, 'stl' : 0},
+        \ {'short' : 'v', 'long' : 'global variables',      'fold' : 0, 'stl' : 0},
+        \ {'short' : 'i', 'long' : 'class interfaces',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'I', 'long' : 'class implementations', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'class methods',         'fold' : 0, 'stl' : 1},
+        \ {'short' : 'F', 'long' : 'object fields',         'fold' : 0, 'stl' : 0},
+        \ {'short' : 'm', 'long' : 'object methods',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'type structures',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'type aliases',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerations',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'properties',            'fold' : 0, 'stl' : 0},
+    \ ]
+    let type_objc.sro        = ':'
+    let type_objc.kind2scope = {
+        \ 'i' : 'interface',
+        \ 'I' : 'implementation',
+        \ 's' : 'struct',
+    \ }
+    let type_objc.scope2kind = {
+        \ 'interface' : 'i',
+        \ 'implementation' : 'I',
+        \ 'struct' : 's',
+    \ }
+    let types.objc = type_objc
+    let types.objcpp = type_objc
+    " Ocaml {{{1
+    let type_ocaml = tagbar#prototypes#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 types.ocaml = type_ocaml
+    " Pascal {{{1
+    let type_pascal = tagbar#prototypes#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 types.pascal = type_pascal
+    " Perl {{{1
+    let type_perl = tagbar#prototypes#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 types.perl = type_perl
+    " PHP {{{1
+    let type_php = tagbar#prototypes#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 types.php = type_php
+    " Python {{{1
+    let type_python = tagbar#prototypes#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 types.python = type_python
+    let types.pyrex  = type_python
+    let types.cython = type_python
+    " REXX {{{1
+    let type_rexx = tagbar#prototypes#typeinfo#new()
+    let type_rexx.ctagstype = 'rexx'
+    let type_rexx.kinds     = [
+        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.rexx = type_rexx
+    " Ruby {{{1
+    let type_ruby = tagbar#prototypes#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',
+        \ 'f' : 'class'
+    \ }
+    let type_ruby.scope2kind = {
+        \ 'class' : 'c'
+    \ }
+    let types.ruby = type_ruby
+    " Scheme {{{1
+    let type_scheme = tagbar#prototypes#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 types.scheme = type_scheme
+    let types.racket = type_scheme
+    " Shell script {{{1
+    let type_sh = tagbar#prototypes#typeinfo#new()
+    let type_sh.ctagstype = 'sh'
+    let type_sh.kinds     = [
+        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.sh = type_sh
+    let types.csh = type_sh
+    let types.zsh = type_sh
+    " SLang {{{1
+    let type_slang = tagbar#prototypes#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 types.slang = type_slang
+    " SML {{{1
+    let type_sml = tagbar#prototypes#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 types.sml = type_sml
+    " SQL {{{1
+    " 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 = tagbar#prototypes#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 types.sql = type_sql
+    " Tcl {{{1
+    let type_tcl = tagbar#prototypes#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 types.tcl = type_tcl
+    " LaTeX {{{1
+    let type_tex = tagbar#prototypes#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 types.tex = type_tex
+    " Vala {{{1
+    " 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(a:supported_types, 'vala') || executable('anjuta-tags')
+        let type_vala = tagbar#prototypes#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 types.vala = type_vala
+    endif
+    if !has_key(a:supported_types, 'vala') && executable('anjuta-tags')
+        let types.vala.ctagsbin = 'anjuta-tags'
+    endif
+    " Vera {{{1
+    " Why are variables 'virtual'?
+    let type_vera = tagbar#prototypes#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 types.vera = type_vera
+    " Verilog {{{1
+    let type_verilog = tagbar#prototypes#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 types.verilog = type_verilog
+    " VHDL {{{1
+    " The VHDL ctags parser unfortunately doesn't generate proper scopes
+    let type_vhdl = tagbar#prototypes#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 types.vhdl = type_vhdl
+    " Vim {{{1
+    let type_vim = tagbar#prototypes#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 types.vim = type_vim
+    " YACC {{{1
+    let type_yacc = tagbar#prototypes#typeinfo#new()
+    let type_yacc.ctagstype = 'yacc'
+    let type_yacc.kinds     = [
+        \ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.yacc = type_yacc
+    " }}}1
+
+    for [type, typeinfo] in items(types)
+        let typeinfo.ftype = type
+    endfor
+
+    for typeinfo in values(types)
+        call typeinfo.createKinddict()
+    endfor
+
+    return types
+endfunction
+
+" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1

doc/tagbar.txt

@@ -3,7 +3,7 @@
 Author:         Jan Larres <jan@majutsushi.net>
 Licence:        Vim licence, see |license|
 Homepage:       http://majutsushi.github.com/tagbar/
-Version:        2.6.1
+Version:        2.7
 
 ==============================================================================
 Contents                                            *tagbar* *tagbar-contents*
@@ -76,7 +76,7 @@ auto-generated name.
 
 Another case where pseudo-tags appear is in C++ implementation files. Since
 classes are usually defined in a header file but the member methods and
-variables in the implementation file the class itself won't generate a tag
+variables are in the implementation file the class itself won't generate a tag
 in that file.
 
 Since pseudo-tags don't really exist they cannot be jumped to from the Tagbar
@@ -306,6 +306,15 @@ COMMANDS                                                     *tagbar-commands*
 :TagbarDebugEnd                                              *:TagbarDebugEnd*
     End debug mode, debug messages will no longer be written to the logfile.
 
+
+------------------------------------------------------------------------------
+FUNCTIONS                                                   *tagbar-functions*
+
+*tagbar#StopAutoUpdate()*
+    Remove autocommands that might have been installed to automatically
+    update tag information.  This should be called after you have used
+    |tagbar#currenttag| manually.
+
 ------------------------------------------------------------------------------
 KEY MAPPINGS                                                     *tagbar-keys*
 
@@ -346,6 +355,12 @@ o/za          Toggle the fold under the cursor or the current one if there is
                 Map option: tagbar_map_openallfolds
 =/zM          Close all folds by setting foldlevel to 0.
                 Map option: tagbar_map_closeallfolds
+zr            Increase the fold level of the buffer by 1. Opens all folds one
+              level.
+                Map option: tagbar_map_incrementfolds
+zm            Decrease the fold level of the buffer by 1. Closes all folds one
+              level.
+                Map option: tagbar_map_decrementfolds
 zj            Go to the start of the next fold, like the standard Vim |zj|.
                 Map option: tagbar_map_nextfold
 zk            Go to the end of the previous fold, like the standard Vim |zk|.
@@ -354,6 +369,8 @@ s             Toggle sort order between name and file order.
                 Map option: tagbar_map_togglesort
 c             Toggle the |g:tagbar_autoclose| option.
                 Map option: tagbar_map_toggleautoclose
+t             Toggle the pause (like :TagbarTogglePause)
+                Map option: tagbar_map_togglepause
 x             Toggle zooming the window.
                 Map option: tagbar_map_zoomwin
 q             Close the Tagbar window.
@@ -384,6 +401,26 @@ Example:
         let g:tagbar_ctags_bin = 'C:\Ctags5.8\ctags.exe'
 <
 
+                                                      *g:tagbar_ctags_options*
+g:tagbar_ctags_options
+Default: undefined
+
+Use this option to specify a list of filenames to pass to ctags with the
+'--options' flag.  This is similar to the deffile key for tagbar type
+extensions, see |tagbar-extend|, but acts globally. The special value 'NONE'
+as the first entry disables reading of the default configuration files (e.g.
+~/.ctags). Without this, if ~/.ctags and other files listed in
+g:tagbar_ctags_options include some of the same patterns, tagbar might show
+duplicate entries.
+
+Example:
+>
+        let g:tagbar_ctags_options = ['NONE', split(&rtp,",")[0].'/ctags.cnf']
+
+This causes ctags to use settings from ~/.vim/ctags.cnf, ignoring other
+configuration files.
+
+
                                                                *g:tagbar_left*
 g:tagbar_left~
 Default: 0
@@ -481,6 +518,18 @@ Example:
         let g:tagbar_sort = 0
 <
 
+                                                   *g:tagbar_case_insensitive*
+g:tagbar_case_insensitive~
+Default: 0
+
+If this option is set a case-insensitive comparison is used when the tags
+are sorted according to their name. If it is unset a case-sensitive
+comparison is used.
+
+Example:
+>
+        let g:tagbar_case_insensitive = 1
+<
                                                             *g:tagbar_compact*
 g:tagbar_compact~
 Default: 0
@@ -506,6 +555,22 @@ Example:
         let g:tagbar_indent = 1
 <
 
+                                                       *g:tagbar_show_balloon*
+g:tagbar_show_balloon~
+Default: 1
+
+Whether balloon messages should be shown in the Tagbar window.
+
+Possible values are:
+  0: Don't show any balloon messages.
+  1: Show balloon messages. This is only available in the GUI when
+     compiled with the |+balloon_eval| feature.
+
+Example:
+>
+        let g:tagbar_show_balloon = 0
+<
+
                                                     *g:tagbar_show_visibility*
 g:tagbar_show_visibility~
 Default: 1
@@ -709,6 +774,18 @@ default statusline:
         let g:tagbar_status_func = 'TagbarStatusFunc'
 <
 
+                                                           *g:tagbar_silent*
+g:tagbar_silent~
+Default: 0
+
+By default if the cursor is over a tag in the tagbar window, information
+about the tag is echoed out. Set this option to disable that behavior.
+
+Example:
+>
+        let g:tagbar_silent = 1
+<
+
 ------------------------------------------------------------------------------
 HIGHLIGHT COLOURS                                           *tagbar-highlight*
 
@@ -833,10 +910,25 @@ tagbar#currenttag({format}, {default} [, {flags}])
         %{tagbar#currenttag('[%s] ','')}
 <   then the function "myfunc" will be shown as "[myfunc()] ".
 
+Additionally you can show the kind (type) of the current tag, using following
+function:
+
+tagbar#currenttagtype({format}, {default})
+    {format} and {default} are treated in the same way as for
+    tagbar#currenttag function.
+
+    Altering previous example, like below: >
+        %{tagbar#currenttag('[%s] ','')}\ %{tagbar#currenttagtype("(%s) ", '')
+<   the function "myfunc" will be shown as "[myfunc()] (function)".
+
 Note that if there is an error when processing the current file no error
 message will be shown in order to not disrupt the statusline. If the function
 doesn't seem to work right open the Tagbar window to see any error messages.
 
+Note you should call |tagbar#StopAutoUpdate| manually in case you do not want
+to display the current tag anymore.  Otherwise the autocommands to update the
+state are being executed all the time still.
+
 ------------------------------------------------------------------------------
 IGNORING SPECIFIC FILES                                        *tagbar-ignore*
 
@@ -932,7 +1024,7 @@ kind2scope: A dictionary describing the mapping of tag kinds (in their
                     int var;
                 };
 <           We then run ctags in the following way: >
-                ctags -f - --format=2 --excmd=pattern --extra= --fields=nksaSmt test.cpp
+                ctags -f - --format=2 --excmd=pattern --extras= --fields=nksaSmt test.cpp
 <           Then the output for the variable "var" would look like this: >
                 var	tmp.cpp /^    int var;$/;"	kind:m	line:11	class:Foo	access:private
 <           This shows that the scope name for an entry in a C++ class is
@@ -1176,8 +1268,11 @@ certain tag kinds in some projects.
 In order to use this feature you need to create User |autocommand|s in an
 augroup called "TagbarProjects" and have it create a buffer-local variable
 called "b:tagbar_type". This variable has to hold a type definition just like
-the normal ones described in this chapter. This definition will then be
-applied only to the files matched by the autocommand.
+the normal ones described in this chapter. If there already is a definition
+then the project-specific one will be merged with the existing one, with the
+project-specific one taking precedence. This makes it possible to have
+project-specific overrides. This definition will then be applied only to the
+files matched by the autocommand.
 
 Note that there can be multiple definitions of the augroup with their own
 autocommands (for example in separate project directories); they will get
@@ -1233,10 +1328,12 @@ try running ctags manually to see whether ctags reports the wrong information
 or whether that information is correct and Tagbar does something wrong. To run
 ctags manually execute the following command in a terminal:
 >
-        ctags -f - --format=2 --excmd=pattern --extra= --fields=nksaSmt myfile
+        ctags -f - --format=2 --excmd=pattern --extras= --fields=nksaSmt myfile
 <
 If you set the |g:tagbar_ctags_bin| variable you probably have to use the same
-value here instead of simply "ctags".
+value here instead of simply "ctags". Also, if you use
+|:tagbar_ctags_options|, you should include the equivalent --options flag in
+the call to ctags.
 
 If something more fundamental isn't working right then try running the
 |:messages| command to see if Tagbar printed any error messages that might
@@ -1245,14 +1342,26 @@ have been missed.
 If the bug does seem to be in Tagbar then you can use Tagbar's debug mode to
 try to find the source of the problem. Usually you would use it like this:
 
-  1. Open Vim without loading any files.
-  2. Run :TagbarDebug.
-  3. Open the file you are having problems with.
-  4. Open Tagbar. If the problem is with the statusline functionality this
+  1. Remove the |tagbar-statusline| support from your vimrc if you use it
+     unless the problem is with this functionality, and make sure you don't
+     have any autocommands that load Tagbar on startup.
+  2. Open Vim without loading any files.
+  3. Run :TagbarDebug.
+  4. Open the file you are having problems with.
+  5. Open Tagbar. If the problem is with the statusline functionality this
      step may not be necessary.
-  5. Exit Vim.
+  6. Exit Vim.
+
+Note that it is important that the "TagbarDebug" command gets called before
+any other call to a Tagbar command or function, so step 1 is important to get
+a complete log.
+
+This should leave a file called "tagbardebug.log" in the current directory. If
+ctags got executed successfully then there should also be a file called
+"tagbardebug.log.ctags_out" which contains the full output of the last ctags
+invocation. This can be very helpful when debugging but may contain sensitive
+information and is therefore kept in a separate file.
 
-This should leave a file called "tagbardebug.log" in the current directory.
 See |tagbar-commands| for more information on the debug commands. When you
 look at the file you should especially pay attention to the reported file type
 and the ctags command line in the log file.
@@ -1312,6 +1421,22 @@ Known issues~
 ==============================================================================
 8. History                                                    *tagbar-history*
 
+2.7 (2017-01-09)
+    - Added support for Universal Ctags, courtesy of Dmytro Konstantinov
+    - Added option to arrange Tagbar window vertically
+    - Added case-insensitive sort option, courtesy of Martin Vuille
+    - Added option to configure zoom width
+    - Added option to hide non-public tags
+    - Added "silent" option to disable the display of tag information in the
+      command line, courtesy of Anmol Sethi
+    - Added mappings for moving between folds
+    - Improved handling of calling :bdelete/:bwipeout/:quit when Tagbar is
+      open
+    - Improved handling of multiple tabs with separate Tagbar instances,
+      courtesy of Martin Vuille
+    - Better handling of various errors to allow Tagbar to continue working
+    - Various other small improvements and bugfixes
+
 2.6.1 (2014-01-23)
     - Automatically close the preview window when jumping to a tag
     - Don't forget the previous window in certain situations, which was

plugin/tagbar.vim

@@ -4,7 +4,7 @@
 " Author:      Jan Larres <jan@majutsushi.net>
 " Licence:     Vim licence
 " Website:     http://majutsushi.github.com/tagbar/
-" Version:     2.6.1
+" 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.
 "
@@ -20,7 +20,7 @@
 
 scriptencoding utf-8
 
-if &cp || exists('g:loaded_tagbar')
+if &compatible || exists('g:loaded_tagbar')
     finish
 endif
 
@@ -59,6 +59,7 @@ function! s:setup_options() abort
         \ ['autofocus', 0],
         \ ['autopreview', 0],
         \ ['autoshowtag', 0],
+        \ ['case_insensitive', 0],
         \ ['compact', 0],
         \ ['expand', 0],
         \ ['foldlevel', 99],
@@ -66,6 +67,7 @@ function! s:setup_options() abort
         \ ['indent', 2],
         \ ['left', 0],
         \ ['previewwin_pos', previewwin_pos],
+        \ ['show_balloon', 1],
         \ ['show_visibility', 1],
         \ ['show_linenumbers', 0],
         \ ['singleclick', 0],
@@ -74,6 +76,7 @@ function! s:setup_options() abort
         \ ['vertical', 0],
         \ ['width', 40],
         \ ['zoomwidth', 1],
+        \ ['silent', 0],
     \ ]
 
     for [opt, val] in options
@@ -83,8 +86,8 @@ endfunction
 call s:setup_options()
 
 if !exists('g:tagbar_iconchars')
-    if has('multi_byte') && has('unix') && &encoding == 'utf-8' &&
-     \ (empty(&termencoding) || &termencoding == 'utf-8')
+    if has('multi_byte') && has('unix') && &encoding ==# 'utf-8' &&
+     \ (!exists('+termencoding') || empty(&termencoding) || &termencoding ==# 'utf-8')
         let g:tagbar_iconchars = ['▶', '▼']
     else
         let g:tagbar_iconchars = ['+', '-']
@@ -106,14 +109,18 @@ function! s:setup_keymaps() abort
         \ ['togglefold',    ['o', 'za']],
         \ ['openallfolds',  ['*', '<kMultiply>', 'zR']],
         \ ['closeallfolds', ['=', 'zM']],
+        \ ['incrementfolds',  ['zr']],
+        \ ['decrementfolds',  ['zm']],
         \ ['nextfold',      'zj'],
         \ ['prevfold',      'zk'],
         \
-        \ ['togglesort',      's'],
-        \ ['toggleautoclose', 'c'],
-        \ ['zoomwin',         'x'],
-        \ ['close',           'q'],
-        \ ['help',            ['<F1>', '?']],
+        \ ['togglesort',            's'],
+        \ ['togglecaseinsensitive', 'i'],
+        \ ['toggleautoclose',       'c'],
+        \ ['togglepause',           't'],
+        \ ['zoomwin',               'x'],
+        \ ['close',                 'q'],
+        \ ['help',                  ['<F1>', '?']],
     \ ]
 
     for [map, key] in keymaps
@@ -138,8 +145,8 @@ command! -nargs=1 -bang TagbarSetFoldlevel  call tagbar#SetFoldLevel(<args>, <ba
 command! -nargs=0 TagbarShowTag       call tagbar#highlighttag(1, 1)
 command! -nargs=? TagbarCurrentTag    echo tagbar#currenttag('%s', 'No current tag', <f-args>)
 command! -nargs=1 TagbarGetTypeConfig call tagbar#gettypeconfig(<f-args>)
-command! -nargs=? TagbarDebug         call tagbar#StartDebug(<f-args>)
-command! -nargs=0 TagbarDebugEnd      call tagbar#StopDebug()
+command! -nargs=? TagbarDebug         call tagbar#debug#start_debug(<f-args>)
+command! -nargs=0 TagbarDebugEnd      call tagbar#debug#stop_debug()
 command! -nargs=0 TagbarTogglePause   call tagbar#toggle_pause()
 
 " Modeline {{{1

syntax/tagbar.vim

@@ -3,16 +3,17 @@
 " Author:      Jan Larres <jan@majutsushi.net>
 " Licence:     Vim licence
 " Website:     http://majutsushi.github.com/tagbar/
-" Version:     2.6.1
+" Version:     2.7
 
 scriptencoding utf-8
 
-if exists("b:current_syntax")
+if exists('b:current_syntax')
     finish
 endif
 
 let s:ics = escape(join(g:tagbar_iconchars, ''), ']^\-')
-let s:pattern = '\(^[' . s:ics . '] \?\)\@<=[^-+: ]\+[^:]\+$'
+
+let s:pattern = '\(^[' . s:ics . '] \?\)\@3<=[^-+: ]\+[^:]\+$'
 execute "syntax match TagbarKind '" . s:pattern . "'"
 
 let s:pattern = '\(\S\@<![' . s:ics . '][-+# ]\?\)\@<=[^*(]\+\(\*\?\(([^)]\+)\)\? :\)\@='
@@ -58,6 +59,6 @@ highlight default link TagbarVisibilityPublic    TagbarAccessPublic
 highlight default link TagbarVisibilityProtected TagbarAccessProtected
 highlight default link TagbarVisibilityPrivate   TagbarAccessPrivate
 
-let b:current_syntax = "tagbar"
+let b:current_syntax = 'tagbar'
 
 " vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1