diff --git a/README.md b/README.md
index ae4c100..ba17c63 100644
--- a/README.md
+++ b/README.md
@@ -17,10 +17,10 @@ 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/) or 
-[Universal Ctags](https://ctags.io/) which is a fork of exuberant ctags 
-continuing the development. 
+[Vim 7.3.1058](http://www.vim.org/)  
+[Exuberant Ctags 5.5](http://ctags.sourceforge.net/) or
+[Universal Ctags](https://ctags.io) (recommended), a maintained fork of
+Exuberant Ctags.
 
 ## Installation
 
@@ -30,12 +30,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.
diff --git a/autoload/tagbar.vim b/autoload/tagbar.vim
index 5dae9ec..4d5a1f1 100644
--- a/autoload/tagbar.vim
+++ b/autoload/tagbar.vim
@@ -45,18 +45,18 @@ if s:ftype_out !~# 'detection:ON'
 endif
 unlet s:ftype_out
 
-let s:icon_closed = g:tagbar_iconchars[0]
-let s:icon_open   = g:tagbar_iconchars[1]
+let g:tagbar#icon_closed = g:tagbar_iconchars[0]
+let g:tagbar#icon_open   = g:tagbar_iconchars[1]
 
 let s:type_init_done    = 0
 let s:autocommands_done = 0
 let s:statusline_in_use = 0
+let s:init_done = 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
@@ -78,21 +78,9 @@ let s:window_pos = {
 
 let s:delayed_update_files = []
 
-" 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': [],
@@ -109,10 +97,6 @@ function! s:Init(silent) abort
         endif
     endif
 
-    if !s:checked_ctags_types
-        call s:GetSupportedFiletypes()
-    endif
-
     if !s:type_init_done
         call s:InitTypes()
     endif
@@ -122,351 +106,28 @@ function! s:Init(silent) abort
         call s:AutoUpdate(fnamemodify(expand('%'), ':p'), 0)
     endif
 
+    let s:init_done = 1
     return 1
 endfunction
 
 " s:InitTypes() {{{2
 function! s:InitTypes() abort
-    call s:debug('Initializing types')
+    call tagbar#debug#log('Initializing types')
 
-    let s:known_types = {}
+    let supported_types = s:GetSupportedFiletypes()
 
-    " 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},
-        \ ]
+        let s:known_types = tagbar#types#uctags#init(supported_types)
     else
-        let type_html.kinds = [
-            \ {'short' : 'f', 'long' : 'JavaScript functions', 'fold' : 0, 'stl' : 1},
-            \ {'short' : 'a', 'long' : 'named anchors',        'fold' : 0, 'stl' : 1}
-        \ ]
+        let s:known_types = tagbar#types#ctags#init(supported_types)
     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'
+
+    " Use jsctags/doctorjs if available
     let jsctags = s:CheckFTCtags('jsctags', 'javascript')
     if jsctags != ''
+        call tagbar#debug#log('Detected jsctags, overriding typedef')
+        let type_javascript = tagbar#prototypes#typeinfo#new()
+        let type_javascript.ctagstype = 'javascript'
         let type_javascript.kinds = [
             \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0},
             \ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
@@ -477,405 +138,14 @@ function! s:InitTypes() abort
             \ 'f' : 'namespace'
         \ }
         let type_javascript.scope2kind = {
-            \ 'namespace' : 'v'
+            \ 'namespace' : 'f'
         \ }
         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',
-        \ }
+        let type_javascript.ftype = 'javascript'
+        call type_javascript.createKinddict()
+        let s:known_types.javascript = type_javascript
     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
-
-    for typeinfo in values(s:known_types)
-        call typeinfo.createKinddict()
-    endfor
 
     call s:LoadUserTypeDefs()
 
@@ -903,13 +173,9 @@ 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
 
@@ -920,8 +186,9 @@ function! s:LoadUserTypeDefs(...) abort
     endfor
 
     for [key, value] in items(transformed)
+        call tagbar#debug#log("Initializing user type '" . key . "'")
         if !has_key(s:known_types, key) || get(value, 'replace', 0)
-            let s:known_types[key] = s:TypeInfo.New(value)
+            let s:known_types[key] = tagbar#prototypes#typeinfo#new(value)
         else
             call extend(s:known_types[key], value)
         endif
@@ -966,7 +233,12 @@ endfunction
 " s:RestoreSession() {{{2
 " Properly restore Tagbar after a session got loaded
 function! s:RestoreSession() abort
-    call s:debug('Restoring session')
+    if s:init_done
+        call tagbar#debug#log('Tagbar already initialized; not restoring session')
+        return
+    endif
+
+    call tagbar#debug#log('Restoring session')
 
     let curfile = fnamemodify(bufname('%'), ':p')
 
@@ -974,12 +246,12 @@ function! s:RestoreSession() abort
     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 in_tagbar = 1
+    if winnr() != tagbarwinnr
+        call s:goto_win(tagbarwinnr, 1)
+        let in_tagbar = 0
     endif
 
     let s:last_autofocus = 0
@@ -997,7 +269,7 @@ endfunction
 
 " s:MapKeys() {{{2
 function! s:MapKeys() abort
-    call s:debug('Mapping keys')
+    call tagbar#debug#log('Mapping keys')
 
     nnoremap <script> <silent> <buffer> <2-LeftMouse>
                                               \ :call <SID>JumpToTag(0)<CR>
@@ -1023,6 +295,8 @@ function! s:MapKeys() abort
         \ ['togglefold',    'ToggleFold()'],
         \ ['openallfolds',  'SetFoldLevel(99, 1)'],
         \ ['closeallfolds', 'SetFoldLevel(0, 1)'],
+        \ ['incrementfolds',  'ChangeFoldLevel(1, 1)'],
+        \ ['decrementfolds',  'ChangeFoldLevel(-1, 1)'],
         \ ['nextfold',      'GotoNextFold()'],
         \ ['prevfold',      'GotoPrevFold()'],
         \
@@ -1058,7 +332,7 @@ endfunction
 
 " s:CreateAutocommands() {{{2
 function! s:CreateAutocommands() abort
-    call s:debug('Creating autocommands')
+    call tagbar#debug#log('Creating autocommands')
 
     augroup TagbarAutoCmds
         autocmd!
@@ -1111,7 +385,7 @@ endfunction
 " Test whether the ctags binary is actually Exuberant Ctags and not BSD ctags
 " (or something else)
 function! s:CheckForExCtags(silent) abort
-    call s:debug('Checking for Exuberant Ctags')
+    call tagbar#debug#log('Checking for Exuberant Ctags')
 
     if !exists('g:tagbar_ctags_bin')
         let ctagsbins  = []
@@ -1166,8 +440,8 @@ function! s:CheckForExCtags(silent) abort
 
     let ctags_output = s:ExecuteCtags(ctags_cmd)
 
-    call s:debug("Command output:\n" . ctags_output)
-    call s:debug("Exit code: " . v:shell_error)
+    call tagbar#debug#log("Command output:\n" . ctags_output)
+    call tagbar#debug#log("Exit code: " . v:shell_error)
 
     if v:shell_error || ctags_output !~# '\(Exuberant\|Universal\) Ctags'
         let errmsg = 'Tagbar: Ctags doesn''t seem to be Exuberant Ctags!'
@@ -1194,7 +468,7 @@ endfunction
 
 " s:CtagsErrMsg() {{{2
 function! s:CtagsErrMsg(errmsg, infomsg, silent, ...) abort
-    call s:debug(a:errmsg)
+    call tagbar#debug#log(a:errmsg)
     let ctags_cmd    = a:0 > 0 ? a:1 : ''
     let ctags_output = a:0 > 1 ? a:2 : ''
 
@@ -1229,16 +503,16 @@ endfunction
 
 " s:CheckExCtagsVersion() {{{2
 function! s:CheckExCtagsVersion(output) abort
-    call s:debug('Checking Exuberant Ctags version')
+    call tagbar#debug#log('Checking Exuberant Ctags version')
 
     if a:output =~ 'Universal Ctags'
-        call s:debug("Found Universal Ctags, assuming compatibility")
+        call tagbar#debug#log("Found Universal Ctags, assuming compatibility")
         let s:ctags_is_uctags = 1
         return 1
     endif
 
     if a:output =~ 'Exuberant Ctags Development'
-        call s:debug("Found development version, assuming compatibility")
+        call tagbar#debug#log("Found development version, assuming compatibility")
         return 1
     endif
 
@@ -1246,7 +520,7 @@ function! s:CheckExCtagsVersion(output) abort
     let major     = matchlist[1]
     let minor     = matchlist[2]
 
-    call s:debug("Ctags version: major='" . major . "', minor='" . minor . "'")
+    call tagbar#debug#log("Ctags version: major='" . major . "', minor='" . minor . "'")
 
     return major >= 6 || (major == 5 && minor >= 5)
 endfunction
@@ -1271,7 +545,7 @@ endfunction
 
 " s:GetSupportedFiletypes() {{{2
 function! s:GetSupportedFiletypes() abort
-    call s:debug('Getting filetypes supported by Exuberant Ctags')
+    call tagbar#debug#log('Getting filetypes supported by Exuberant Ctags')
 
     let ctags_cmd = s:EscapeCtagsCmd(g:tagbar_ctags_bin, '--list-languages')
     if ctags_cmd == ''
@@ -1288,589 +562,27 @@ function! s:GetSupportedFiletypes() abort
 
     let types = split(ctags_output, '\n\+')
 
+    let supported_types = {}
     for type in types
         if match(type, '\[disabled\]') == -1
-            let s:ctags_types[tolower(type)] = 1
+            let supported_types[tolower(type)] = 1
         endif
     endfor
 
-    let s:checked_ctags_types = 1
+    return supported_types
 endfunction
 
-" Prototypes {{{1
-" Base tag {{{2
-let s:BaseTag = {}
-
-" s:BaseTag.New() {{{3
-function! s:BaseTag.New(name) abort dict
-    let newobj = copy(self)
-
-    call newobj._init(a:name)
-
-    return newobj
-endfunction
-
-" s:BaseTag._init() {{{3
-function! s:BaseTag._init(name) abort dict
-    let self.name          = a:name
-    let self.fields        = {}
-    let self.fields.line   = 0
-    let self.fields.column = 0
-    let self.prototype     = ''
-    let self.path          = ''
-    let self.fullpath      = a:name
-    let self.depth         = 0
-    let self.parent        = {}
-    let self.tline         = -1
-    let self.fileinfo      = {}
-    let self.typeinfo      = {}
-    let self._childlist    = []
-    let self._childdict    = {}
-endfunction
-
-" s:BaseTag.isNormalTag() {{{3
-function! s:BaseTag.isNormalTag() abort dict
-    return 0
-endfunction
-
-" s:BaseTag.isPseudoTag() {{{3
-function! s:BaseTag.isPseudoTag() abort dict
-    return 0
-endfunction
-
-" s:BaseTag.isKindheader() {{{3
-function! s:BaseTag.isKindheader() abort dict
-    return 0
-endfunction
-
-" s:BaseTag.getPrototype() {{{3
-function! s:BaseTag.getPrototype(short) abort dict
-    return self.prototype
-endfunction
-
-" s:BaseTag._getPrefix() {{{3
-function! s:BaseTag._getPrefix() abort dict
-    let fileinfo = self.fileinfo
-
-    if !empty(self._childlist)
-        if fileinfo.tagfolds[self.fields.kind][self.fullpath]
-            let prefix = s:icon_closed
-        else
-            let prefix = s: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:BaseTag.initFoldState() {{{3
-function! s:BaseTag.initFoldState() abort dict
-    let fileinfo = self.fileinfo
-
-    if s: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:BaseTag.getClosedParentTline() {{{3
-function! s:BaseTag.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:BaseTag.isFoldable() {{{3
-function! s:BaseTag.isFoldable() abort dict
-    return !empty(self._childlist)
-endfunction
-
-" s:BaseTag.isFolded() {{{3
-function! s:BaseTag.isFolded() abort dict
-    return self.fileinfo.tagfolds[self.fields.kind][self.fullpath]
-endfunction
-
-" s:BaseTag.openFold() {{{3
-function! s:BaseTag.openFold() abort dict
-    if self.isFoldable()
-        let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 0
-    endif
-endfunction
-
-" s:BaseTag.closeFold() {{{3
-function! s:BaseTag.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:BaseTag.setFolded() {{{3
-function! s:BaseTag.setFolded(folded) abort dict
-    let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = a:folded
-endfunction
-
-" s:BaseTag.openParents() {{{3
-function! s:BaseTag.openParents() abort dict
-    let parent = self.parent
-
-    while !empty(parent)
-        call parent.openFold()
-        let parent = parent.parent
-    endwhile
-endfunction
-
-" s:BaseTag.addChild() {{{3
-function! s:BaseTag.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:BaseTag.getChildren() {{{3
-function! s:BaseTag.getChildren() dict abort
-    return self._childlist
-endfunction
-
-" s:BaseTag.getChildrenByName() {{{3
-function! s:BaseTag.getChildrenByName(tagname) dict abort
-    return get(self._childdict, a:tagname, [])
-endfunction
-
-" s:BaseTag.removeChild() {{{3
-function! s:BaseTag.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
-
-" Normal tag {{{2
-let s:NormalTag = copy(s:BaseTag)
-
-" s:NormalTag.isNormalTag() {{{3
-function! s:NormalTag.isNormalTag() abort dict
-    return 1
-endfunction
-
-" s:NormalTag.strfmt() {{{3
-function! s:NormalTag.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:NormalTag.str() {{{3
-function! s:NormalTag.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:NormalTag.getPrototype() {{{3
-function! s:NormalTag.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, '^\\V\\^\\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
-
-" Pseudo tag {{{2
-let s:PseudoTag = copy(s:BaseTag)
-
-" s:PseudoTag.isPseudoTag() {{{3
-function! s:PseudoTag.isPseudoTag() abort dict
-    return 1
-endfunction
-
-" s:PseudoTag.strfmt() {{{3
-function! s:PseudoTag.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
-
-" Kind header {{{2
-let s:KindheaderTag = copy(s:BaseTag)
-
-" s:KindheaderTag.isKindheader() {{{3
-function! s:KindheaderTag.isKindheader() abort dict
-    return 1
-endfunction
-
-" s:KindheaderTag.getPrototype() {{{3
-function! s:KindheaderTag.getPrototype(short) abort dict
-    return self.name . ': ' .
-         \ self.numtags . ' ' . (self.numtags > 1 ? 'tags' : 'tag')
-endfunction
-
-" s:KindheaderTag.isFoldable() {{{3
-function! s:KindheaderTag.isFoldable() abort dict
-    return 1
-endfunction
-
-" s:KindheaderTag.isFolded() {{{3
-function! s:KindheaderTag.isFolded() abort dict
-    return self.fileinfo.kindfolds[self.short]
-endfunction
-
-" s:KindheaderTag.openFold() {{{3
-function! s:KindheaderTag.openFold() abort dict
-    let self.fileinfo.kindfolds[self.short] = 0
-endfunction
-
-" s:KindheaderTag.closeFold() {{{3
-function! s:KindheaderTag.closeFold() abort dict
-    let self.fileinfo.kindfolds[self.short] = 1
-    return line('.')
-endfunction
-
-" s:KindheaderTag.toggleFold() {{{3
-function! s:KindheaderTag.toggleFold() abort dict
-    let fileinfo = s:TagbarState().getCurrent(0)
-
-    let fileinfo.kindfolds[self.short] = !fileinfo.kindfolds[self.short]
-endfunction
-
-" Type info {{{2
-let s:TypeInfo = {}
-
-" s:TypeInfo.New() {{{3
-function! s:TypeInfo.New(...) abort dict
-    let newobj = copy(self)
-
-    let newobj.kinddict = {}
-
-    if a:0 > 0
-        call extend(newobj, a:1)
-    endif
-
-    return newobj
-endfunction
-
-" s:TypeInfo.getKind() {{{3
-function! s:TypeInfo.getKind(kind) abort dict
-    let idx = self.kinddict[a:kind]
-    return self.kinds[idx]
-endfunction
-
-" s:TypeInfo.createKinddict() {{{3
-" Create a dictionary of the kind order for fast access in sorting functions
-function! s:TypeInfo.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
-
-" File info {{{2
-let s:FileInfo = {}
-
-" s:FileInfo.New() {{{3
-function! s:FileInfo.New(fname, ftype, typeinfo) abort dict
-    let newobj = copy(self)
-
-    " 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
-
-    return newobj
-endfunction
-
-" s:FileInfo.addTag() {{{3
-function! s:FileInfo.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:FileInfo.getTags() {{{3
-function! s:FileInfo.getTags() dict abort
-    return self._taglist
-endfunction
-
-" s:FileInfo.getTagsByName() {{{3
-function! s:FileInfo.getTagsByName(tagname) dict abort
-    return get(self._tagdict, a:tagname, [])
-endfunction
-
-" s:FileInfo.removeTag() {{{3
-function! s:FileInfo.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:FileInfo.reset() {{{3
-" Reset stuff that gets regenerated while processing a file and save the old
-" tag folds
-function! s:FileInfo.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:FileInfo.clearOldFolds() {{{3
-function! s:FileInfo.clearOldFolds() abort dict
-    if exists('self._tagfolds_old')
-        unlet self._tagfolds_old
-    endif
-endfunction
-
-" s:FileInfo.sortTags() {{{3
-function! s:FileInfo.sortTags() abort dict
-    if get(s:compare_typeinfo, 'sort', g:tagbar_sort)
-        call s:SortTags(self._taglist, 's:CompareByKind')
-    else
-        call s:SortTags(self._taglist, 's:CompareByLine')
-    endif
-endfunction
-
-" s:FileInfo.openKindFold() {{{3
-function! s:FileInfo.openKindFold(kind) abort dict
-    let self.kindfolds[a:kind.short] = 0
-endfunction
-
-" s:FileInfo.closeKindFold() {{{3
-function! s:FileInfo.closeKindFold(kind) abort dict
-    let self.kindfolds[a:kind.short] = 1
-endfunction
-
-" Per-tagbar instance state prototype {{{2
-let s:state = {
-    \ '_current' : {},
-    \ '_paused'  : {},
-\ }
-
-" s:state.New() {{{3
-function! s:state.New() abort dict
-    return deepcopy(self)
-endfunction
-
-" s:state.getCurrent() {{{3
-function! s:state.getCurrent(forcecurrent) abort dict
-    if !s:paused || a:forcecurrent
-        return self._current
-    else
-        return self._paused
-    endif
-endfunction
-
-" s:state.setCurrent() {{{3
-function! s:state.setCurrent(fileinfo) abort dict
-    let self._current = a:fileinfo
-endfunction
-
-" s:state.setPaused() {{{3
-function! s:state.setPaused() abort dict
-    let self._paused = self._current
-endfunction
-
-" Known files {{{2
+" Known files {{{1
 let s:known_files = {
     \ '_files'   : {}
 \ }
 
-" s:known_files.get() {{{3
+" s:known_files.get() {{{2
 function! s:known_files.get(fname) abort dict
     return get(self._files, a:fname, {})
 endfunction
 
-" s:known_files.put() {{{3
+" s:known_files.put() {{{2
 " Optional second argument is the filename
 function! s:known_files.put(fileinfo, ...) abort dict
     if a:0 == 1
@@ -1881,15 +593,15 @@ function! s:known_files.put(fileinfo, ...) abort dict
     endif
 endfunction
 
-" s:known_files.has() {{{3
+" s:known_files.has() {{{2
 function! s:known_files.has(fname) abort dict
     return has_key(self._files, a:fname)
 endfunction
 
-" s:known_files.rm() {{{3
+" s:known_files.rm() {{{2
 function! s:known_files.rm(fname) abort dict
     if s:known_files.has(a:fname)
-        call s:debug('Removing fileinfo for [' . a:fname . ']')
+        call tagbar#debug#log('Removing fileinfo for [' . a:fname . ']')
         call remove(self._files, a:fname)
     endif
 endfunction
@@ -1897,7 +609,7 @@ endfunction
 " Window management {{{1
 " s:ToggleWindow() {{{2
 function! s:ToggleWindow(flags) abort
-    call s:debug('ToggleWindow called')
+    call tagbar#debug#log('ToggleWindow called')
 
     let tagbarwinnr = bufwinnr(s:TagbarBufName())
     if tagbarwinnr != -1
@@ -1907,12 +619,12 @@ function! s:ToggleWindow(flags) abort
 
     call s:OpenWindow(a:flags)
 
-    call s:debug('ToggleWindow finished')
+    call tagbar#debug#log('ToggleWindow finished')
 endfunction
 
 " s:OpenWindow() {{{2
 function! s:OpenWindow(flags) abort
-    call s:debug("OpenWindow called with flags: '" . a:flags . "'")
+    call tagbar#debug#log("OpenWindow called with flags: '" . a:flags . "'")
 
     let autofocus = a:flags =~# 'f'
     let jump      = a:flags =~# 'j'
@@ -1929,7 +641,7 @@ function! s:OpenWindow(flags) abort
             call s:goto_win(tagbarwinnr)
             call s:HighlightTag(g:tagbar_autoshowtag != 2, 1, curline)
         endif
-        call s:debug("OpenWindow finished, Tagbar already open")
+        call tagbar#debug#log("OpenWindow finished, Tagbar already open")
         return
     endif
 
@@ -1958,7 +670,7 @@ function! s:OpenWindow(flags) abort
         return 0
     endif
 
-    " Expand the Vim window to accomodate for the Tagbar window if requested
+    " Expand the Vim window to accommodate for the Tagbar window if requested
     " and save the window positions to be able to restore them later.
     if g:tagbar_expand >= 1 && !s:window_expanded &&
      \ (has('gui_running') || g:tagbar_expand == 2)
@@ -2020,12 +732,12 @@ function! s:OpenWindow(flags) abort
         endif
     endif
 
-    call s:debug('OpenWindow finished')
+    call tagbar#debug#log('OpenWindow finished')
 endfunction
 
 " s:InitWindow() {{{2
 function! s:InitWindow(autoclose) abort
-    call s:debug('InitWindow called with autoclose: ' . a:autoclose)
+    call tagbar#debug#log('InitWindow called with autoclose: ' . a:autoclose)
 
     " Buffer-local options
 
@@ -2096,12 +808,12 @@ function! s:InitWindow(autoclose) abort
         let s:expand_bufnr = bufnr('%')
     endif
 
-    call s:debug('InitWindow finished')
+    call tagbar#debug#log('InitWindow finished')
 endfunction
 
 " s:CloseWindow() {{{2
 function! s:CloseWindow() abort
-    call s:debug('CloseWindow called')
+    call tagbar#debug#log('CloseWindow called')
 
     let tagbarwinnr = bufwinnr(s:TagbarBufName())
     if tagbarwinnr == -1
@@ -2118,7 +830,7 @@ function! s:CloseWindow() abort
         if winbufnr(2) != -1
             " Other windows are open, only close the tagbar one
 
-            let curfile = s:TagbarState().getCurrent(0)
+            let curfile = tagbar#state#get_current_file(0)
 
             close
 
@@ -2149,18 +861,12 @@ function! s:CloseWindow() abort
 
     call s:ShrinkIfExpanded()
 
-    " The window sizes may have changed due to the shrinking happening after
-    " the window closing, so equalize them again.
-    if &equalalways
-        wincmd =
-    endif
-
     if s:autocommands_done && !s:statusline_in_use
         autocmd! TagbarAutoCmds
         let s:autocommands_done = 0
     endif
 
-    call s:debug('CloseWindow finished')
+    call tagbar#debug#log('CloseWindow finished')
 endfunction
 
 " s:ShrinkIfExpanded() {{{2
@@ -2189,6 +895,12 @@ function! s:ShrinkIfExpanded() abort
                        \ ' ' . s:window_pos.pre.y
         endif
     endif
+
+    " The window sizes may have changed due to the shrinking happening after
+    " the window closing, so equalize them again.
+    if &equalalways
+        wincmd =
+    endif
 endfunction
 
 " s:ZoomWindow() {{{2
@@ -2220,7 +932,7 @@ endfunction
 " the current file after startup.
 function! s:CorrectFocusOnStartup() abort
     if bufwinnr(s:TagbarBufName()) != -1 && !g:tagbar_autofocus && !s:last_autofocus
-        let curfile = s:TagbarState().getCurrent(1)
+        let curfile = tagbar#state#get_current_file(1)
         if !empty(curfile) && curfile.fpath != fnamemodify(bufname('%'), ':p')
             let winnr = bufwinnr(curfile.fpath)
             if winnr != -1
@@ -2234,10 +946,10 @@ endfunction
 " s:ProcessFile() {{{2
 " Execute ctags and put the information into a 'FileInfo' object
 function! s:ProcessFile(fname, ftype) abort
-    call s:debug('ProcessFile called [' . a:fname . ']')
+    call tagbar#debug#log('ProcessFile called [' . a:fname . ']')
 
     if !s:IsValidFile(a:fname, a:ftype)
-        call s:debug('Not a valid file, returning')
+        call tagbar#debug#log('Not a valid file, returning')
         return
     endif
 
@@ -2259,10 +971,10 @@ function! s:ProcessFile(fname, ftype) abort
                 call typeinfo.createKinddict()
             endif
         endif
-        let fileinfo = s:FileInfo.New(a:fname, a:ftype, typeinfo)
+        let fileinfo = tagbar#prototypes#fileinfo#new(a:fname, a:ftype, typeinfo)
     endif
 
-    call s:debug('typeinfo for file to process: ' . string(typeinfo))
+    call tagbar#debug#log('typeinfo for file to process: ' . string(typeinfo))
 
     " Use a temporary files for ctags processing instead of the original one.
     " This allows using Tagbar for files accessed with netrw, and also doesn't
@@ -2273,32 +985,41 @@ function! s:ProcessFile(fname, ftype) abort
         let tempfile .= '.' . ext
     endif
 
-    call writefile(getbufline(fileinfo.bufnr, 1, '$'), tempfile)
+    call tagbar#debug#log('Caching file into: ' . tempfile)
+    let templines = getbufline(fileinfo.bufnr, 1, '$')
+    let res = writefile(templines, tempfile)
+
+    if res != 0
+        call tagbar#debug#log('Could not create copy '.tempfile)
+        return
+    endif
     let fileinfo.mtime = getftime(tempfile)
 
     let ctags_output = s:ExecuteCtagsOnFile(tempfile, a:fname, typeinfo)
 
-    call delete(tempfile)
+    if !tagbar#debug#enabled()
+        call delete(tempfile)
+    endif
 
     if ctags_output == -1
-        call s:debug('Ctags error when processing file')
+        call tagbar#debug#log('Ctags error when processing file')
         " Put an empty entry into known_files so the error message is only
         " shown once
         call s:known_files.put({}, a:fname)
         return
     elseif ctags_output == ''
-        call s:debug('Ctags output empty')
+        call tagbar#debug#log('Ctags output empty')
         " No need to go through the tag processing if there are no tags, and
         " preserving the old fold state isn't necessary either
-        call s:known_files.put(s:FileInfo.New(a:fname, a:ftype,
+        call s:known_files.put(tagbar#prototypes#fileinfo#new(a:fname, a:ftype,
                                             \ s:known_types[a:ftype]), a:fname)
         return
     endif
 
-    call s:debug('Filetype tag kinds: ' . string(keys(typeinfo.kinddict)))
+    call tagbar#debug#log('Filetype tag kinds: ' . string(keys(typeinfo.kinddict)))
 
     " Parse the ctags output lines
-    call s:debug('Parsing ctags output')
+    call tagbar#debug#log('Parsing ctags output')
     let rawtaglist = split(ctags_output, '\n\+')
     for line in rawtaglist
         " skip comments
@@ -2322,14 +1043,14 @@ function! s:ProcessFile(fname, ftype) abort
         let curtags = filter(copy(fileinfo.getTags()),
                            \ 'v:val.fields.kind ==# kind.short && ' .
                            \ '!has_key(v:val, "scope")')
-        call s:debug('Processing kind: ' . kind.short .
+        call tagbar#debug#log('Processing kind: ' . kind.short .
                    \ ', number of tags: ' . len(curtags))
 
         if empty(curtags)
             continue
         endif
 
-        let kindtag          = s:KindheaderTag.New(kind.long)
+        let kindtag          = tagbar#prototypes#kindheadertag#new(kind.long)
         let kindtag.short    = kind.short
         let kindtag.numtags  = len(curtags)
         let kindtag.fileinfo = fileinfo
@@ -2343,15 +1064,14 @@ function! s:ProcessFile(fname, ftype) abort
     call fileinfo.clearOldFolds()
 
     " Sort the tags
-    let s:compare_typeinfo = typeinfo
-    call fileinfo.sortTags()
+    call fileinfo.sortTags(typeinfo)
 
     call s:known_files.put(fileinfo)
 endfunction
 
 " s:ExecuteCtagsOnFile() {{{2
 function! s:ExecuteCtagsOnFile(fname, realfname, typeinfo) abort
-    call s:debug('ExecuteCtagsOnFile called [' . a:fname . ']')
+    call tagbar#debug#log('ExecuteCtagsOnFile called [' . a:fname . ']')
 
     if has_key(a:typeinfo, 'ctagsargs') && type(a:typeinfo.ctagsargs) == type('')
         " if ctagsargs is a string, prepend and append space separators
@@ -2377,6 +1097,11 @@ function! s:ExecuteCtagsOnFile(fname, realfname, typeinfo) abort
                           \ '--append=no'
                           \ ]
 
+        " verbose if debug enabled
+        if tagbar#debug#enabled()
+            let ctags_args += [ '-V' ]
+        endif
+
         " Include extra type definitions
         if has_key(a:typeinfo, 'deffile')
             let ctags_args += ['--options=' . expand(a:typeinfo.deffile)]
@@ -2416,9 +1141,9 @@ function! s:ExecuteCtagsOnFile(fname, realfname, typeinfo) abort
     let ctags_output = s:ExecuteCtags(ctags_cmd)
 
     if v:shell_error || ctags_output =~ 'Warning: cannot open source file'
-        call s:debug('Command output:')
-        call s:debug(ctags_output)
-        call s:debug('Exit code: ' . v:shell_error)
+        call tagbar#debug#log('Command output:')
+        call tagbar#debug#log(ctags_output)
+        call tagbar#debug#log('Exit code: ' . v:shell_error)
         " Only display an error message if the Tagbar window is open and we
         " haven't seen the error before.
         if bufwinnr(s:TagbarBufName()) != -1 &&
@@ -2437,7 +1162,9 @@ function! s:ExecuteCtagsOnFile(fname, realfname, typeinfo) abort
         return -1
     endif
 
-    call s:debug('Ctags executed successfully')
+    call tagbar#debug#log('Ctags executed successfully')
+    call tagbar#debug#log_ctags_output(ctags_output)
+
     return ctags_output
 endfunction
 
@@ -2448,29 +1175,32 @@ endfunction
 " fields that are always present: kind, line
 function! s:ParseTagline(part1, part2, typeinfo, fileinfo) abort
     let basic_info  = split(a:part1, '\t')
-
-    let taginfo      = s:NormalTag.New(basic_info[0])
-    let taginfo.file = basic_info[1]
+    let tagname  = basic_info[0]
+    let filename = basic_info[1]
 
     " the pattern can contain tabs and thus may have been split up, so join
     " the rest of the items together again
     let pattern = join(basic_info[2:], "\t")
-    let start   = 2 " skip the slash and the ^
-    let end     = strlen(pattern) - 1
-    if pattern[end - 1] ==# '$'
-        let end -= 1
-        let dollar = '\$'
+    if pattern[0] == '/'
+        let start   = 2 " skip the slash and the ^
+        let end     = strlen(pattern) - 1
+        if pattern[end - 1] ==# '$'
+            let end -= 1
+            let dollar = '\$'
+        else
+            let dollar = ''
+        endif
+        let pattern = '\V\^\C' . strpart(pattern, start, end - start) . dollar
     else
-        let dollar = ''
+        let pattern = ''
     endif
-    let pattern         = strpart(pattern, start, end - start)
-    let taginfo.pattern = '\V\^\C' . pattern . dollar
 
     " When splitting fields make sure not to create empty keys or values in
     " case a value illegally contains tabs
     let fields = split(a:part2, '^\t\|\t\ze\w\+:')
+    let fielddict = {}
     if fields[0] !~# ':'
-        let taginfo.fields.kind = remove(fields, 0)
+        let fielddict.kind = remove(fields, 0)
     endif
     for field in fields
         " can't use split() since the value can contain ':'
@@ -2480,16 +1210,62 @@ function! s:ParseTagline(part1, part2, typeinfo, fileinfo) abort
         let val = substitute(strpart(field, delimit + 1), '\t', '', 'g')
         " File-restricted scoping
         if key == "file"
-            let taginfo.fields[key] = 'yes'
+            let fielddict[key] = 'yes'
         endif
         if len(val) > 0
             if key == 'line' || key == 'column'
-                let taginfo.fields[key] = str2nr(val)
+                let fielddict[key] = str2nr(val)
             else
-                let taginfo.fields[key] = val
+                let fielddict[key] = val
             endif
         endif
     endfor
+
+    " If the tag covers multiple scopes, split it up and create individual tags
+    " for each scope so that the hierarchy can be displayed correctly.
+    " This can happen with PHP's 'namespace' tags in uctags, for example.
+    if has_key(a:typeinfo, 'kind2scope') && has_key(a:typeinfo.kind2scope, fielddict.kind)
+            \ && tagname =~# '\V' . escape(a:typeinfo.sro, '\')
+        let tagparts = split(tagname, '\V' . escape(a:typeinfo.sro, '\'))
+
+        let scope = a:typeinfo.kind2scope[fielddict.kind]
+        if has_key(fielddict, scope)
+            let parent = fielddict[scope]
+        else
+            let parent = ''
+        endif
+        let curfielddict = fielddict
+
+        for i in range(len(tagparts))
+            let part = tagparts[i]
+            call s:ProcessTag(part, filename, pattern, curfielddict,
+                            \ i != len(tagparts) - 1, a:typeinfo, a:fileinfo)
+            if parent != ''
+                let parent = parent . a:typeinfo.sro . part
+            else
+                let parent = part
+            endif
+            let curfielddict = copy(fielddict)
+            let curfielddict[scope] = parent
+        endfor
+    else
+        call s:ProcessTag(tagname, filename, pattern, fielddict, 0,
+                        \ a:typeinfo, a:fileinfo)
+    endif
+endfunction
+
+" s:ProcessTag() {{{2
+function s:ProcessTag(name, filename, pattern, fields, is_split, typeinfo, fileinfo) abort
+    if a:is_split
+        let taginfo = tagbar#prototypes#splittag#new(a:name)
+    else
+        let taginfo = tagbar#prototypes#normaltag#new(a:name)
+    endif
+
+    let taginfo.file    = a:filename
+    let taginfo.pattern = a:pattern
+    call extend(taginfo.fields, a:fields)
+
     " Needed for jsctags
     if has_key(taginfo.fields, 'lineno')
         let taginfo.fields.line = str2nr(taginfo.fields.lineno)
@@ -2500,7 +1276,8 @@ function! s:ParseTagline(part1, part2, typeinfo, fileinfo) abort
     endif
 
     if !has_key(taginfo.fields, 'kind')
-        call s:debug("Warning: No 'kind' field found for tag " . basic_info[0] . "!")
+        call tagbar#debug#log(
+            \ "Warning: No 'kind' field found for tag " . basic_info[0] . "!")
         if index(s:warnings.type, a:typeinfo.ftype) == -1
             call s:warning("No 'kind' field found for tag " . basic_info[0] . "!" .
                          \ " Please read the last section of ':help tagbar-extend'.")
@@ -2533,15 +1310,15 @@ function! s:ParseTagline(part1, part2, typeinfo, fileinfo) abort
             break
         endif
     endfor
-    let pathlist = split(taginfo.path, '\V' . a:typeinfo.sro)
+    let pathlist = split(taginfo.path, '\V' . escape(a:typeinfo.sro, '\'))
     let taginfo.depth = len(pathlist)
 
     " Needed for folding
     try
-        call taginfo.initFoldState()
+        call taginfo.initFoldState(s:known_files)
     catch /^Vim(\a\+):E716:/ " 'Key not present in Dictionary'
         " The tag has a 'kind' that doesn't exist in the type definition
-        call s:debug('Warning: Unknown tag kind: ' . taginfo.fields.kind)
+        call tagbar#debug#log('Warning: Unknown tag kind: ' . taginfo.fields.kind)
         if index(s:warnings.type, a:typeinfo.ftype) == -1
             call s:warning('Unknown tag kind encountered: ' .
                 \ '"' . taginfo.fields.kind . '".' .
@@ -2571,10 +1348,13 @@ function! s:add_tag_recursive(parent, taginfo, pathlist) abort
             let name_siblings = a:parent.getChildrenByName(a:taginfo.name)
         endif
 
+        " Consider a tag as replaceable if the current tag is considered to
+        " have more appropriate information
         for tag in name_siblings
             if (tag.fields.kind ==# '?'
               \ || tag.fields.kind ==# a:taginfo.fields.kind)
-             \ && tag.isPseudoTag()
+             \ && (tag.isPseudoTag()
+              \ || (!a:taginfo.isSplitTag() && tag.isSplitTag()))
                 call add(pseudotags, tag)
             endif
         endfor
@@ -2596,6 +1376,16 @@ function! s:add_tag_recursive(parent, taginfo, pathlist) abort
                   \ 'Pseudotag name:' pseudotag.name
         endif
 
+        " If this is a tag that got created due to splitting up a tag name,
+        " don't replace existing tags of the same kind.
+        if a:taginfo.isSplitTag()
+            for tag in name_siblings
+                if tag.fields.kind ==# a:taginfo.fields.kind
+                    return
+                endif
+            endfor
+        endif
+
         if empty(a:parent)
             call a:taginfo.fileinfo.addTag(a:taginfo)
         else
@@ -2648,6 +1438,8 @@ function! s:add_tag_recursive(parent, taginfo, pathlist) abort
         else
             call grandparent.addChild(parent)
         endif
+    elseif len(parents) == 1
+        let parent = parents[0]
     else
         " If there are multiple possible parents (c.f. issue #139, or tags
         " with the same name but a different kind) then we will pick the one
@@ -2656,12 +1448,34 @@ function! s:add_tag_recursive(parent, taginfo, pathlist) abort
         " Start at line 0 so that pseudotags get included
         let minline = 0
         for candidate in parents
+            " If the line number of the current tag is 0 then we have no way
+            " of determining the best candidate by comparing line numbers.
+            " Just use the first one we have.
+            if a:taginfo.fields.line == 0
+                let parent = candidate
+                break
+            endif
+
             if candidate.fields.line <= a:taginfo.fields.line &&
              \ candidate.fields.line >= minline
                 let parent = candidate
                 let minline = candidate.fields.line
             endif
         endfor
+
+        if !exists('parent')
+            " If we still haven't found a parent it must be below the current
+            " tag, so find the closest parent below the tag. This can happen
+            " for example in Go.
+            let maxline = line('$')
+            for candidate in parents
+                if candidate.fields.line >= a:taginfo.fields.line &&
+                 \ candidate.fields.line <= maxline
+                    let parent = candidate
+                    let maxline = candidate.fields.line
+                endif
+            endfor
+        endif
     endif
 
     " If the parent is a pseudotag it may have gotten created as an in-between
@@ -2673,7 +1487,7 @@ function! s:add_tag_recursive(parent, taginfo, pathlist) abort
         let parentkind = a:taginfo.typeinfo.scope2kind[a:taginfo.scope]
         if parent.fields.kind ==# '?' || parentkind !=# parent.fields.kind
             let parent.fields.kind = parentkind
-            call parent.initFoldState()
+            call parent.initFoldState(s:known_files)
         endif
     endif
 
@@ -2684,18 +1498,20 @@ endfunction
 function! s:create_pseudotag(name, parent, kind, typeinfo, fileinfo) abort
     if !empty(a:parent)
         let curpath = a:parent.fullpath
-        let pscope  = a:typeinfo.kind2scope[a:parent.fields.kind]
+        " If the kind is not present in the kind2scope dictionary, return an
+        " empty scope. This can happen due to incorrect ctags output as in #397.
+        let pscope  = get(a:typeinfo.kind2scope, a:parent.fields.kind, '')
     else
         let curpath = ''
         let pscope  = ''
     endif
 
-    let pseudotag             = s:PseudoTag.New(a:name)
+    let pseudotag             = tagbar#prototypes#pseudotag#new(a:name)
     let pseudotag.fields.kind = a:kind
 
-    let parentscope = substitute(curpath, a:name . '$', '', '')
+    let parentscope = substitute(curpath, '\V' . a:name . '$', '', '')
     let parentscope = substitute(parentscope,
-                               \ '\V\^' . a:typeinfo.sro . '\$', '', '')
+                        \ '\V\^' . escape(a:typeinfo.sro, '\') . '\$', '', '')
 
     if pscope != ''
         let pseudotag.fields[pscope] = parentscope
@@ -2704,71 +1520,21 @@ function! s:create_pseudotag(name, parent, kind, typeinfo, fileinfo) abort
         let pseudotag.fullpath =
                     \ pseudotag.path . a:typeinfo.sro . pseudotag.name
     endif
-    let pseudotag.depth = len(split(pseudotag.path, '\V' . a:typeinfo.sro))
+    let pseudotag.depth = len(split(pseudotag.path, '\V' . escape(a:typeinfo.sro, '\')))
 
     let pseudotag.parent = a:parent
 
     let pseudotag.fileinfo = a:fileinfo
     let pseudotag.typeinfo = a:typeinfo
 
-    call pseudotag.initFoldState()
+    call pseudotag.initFoldState(s:known_files)
 
     return pseudotag
 endfunction
 
-" Sorting {{{1
-" s:SortTags() {{{2
-function! s:SortTags(tags, comparemethod) abort
-    call sort(a:tags, a:comparemethod)
-
-    for tag in a:tags
-        if !empty(tag.getChildren())
-            call s:SortTags(tag.getChildren(), a:comparemethod)
-        endif
-    endfor
-endfunction
-
-" s:CompareByKind() {{{2
-function! s:CompareByKind(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
-
-" s:CompareByLine() {{{2
-function! s:CompareByLine(tag1, tag2) abort
-    return a:tag1.fields.line - a:tag2.fields.line
-endfunction
-
 " s:ToggleSort() {{{2
 function! s:ToggleSort() abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -2779,15 +1545,15 @@ function! s:ToggleSort() abort
 
     match none
 
-    let s:compare_typeinfo = s:known_types[fileinfo.ftype]
+    let compare_typeinfo = s:known_types[fileinfo.ftype]
 
-    if has_key(s:compare_typeinfo, 'sort')
-        let s:compare_typeinfo.sort = !s:compare_typeinfo.sort
+    if has_key(compare_typeinfo, 'sort')
+        let compare_typeinfo.sort = !compare_typeinfo.sort
     else
         let g:tagbar_sort = !g:tagbar_sort
     endif
 
-    call fileinfo.sortTags()
+    call fileinfo.sortTags(compare_typeinfo)
 
     call s:RenderContent()
     call s:SetStatusLine()
@@ -2804,17 +1570,17 @@ endfunction
 " Display {{{1
 " s:RenderContent() {{{2
 function! s:RenderContent(...) abort
-    call s:debug('RenderContent called')
+    call tagbar#debug#log('RenderContent called')
     let s:new_window = 0
 
     if a:0 == 1
         let fileinfo = a:1
     else
-        let fileinfo = s:TagbarState().getCurrent(0)
+        let fileinfo = tagbar#state#get_current_file(0)
     endif
 
     if empty(fileinfo)
-        call s:debug('Empty fileinfo, returning')
+        call tagbar#debug#log('Empty fileinfo, returning')
         return
     endif
 
@@ -2835,10 +1601,10 @@ function! s:RenderContent(...) abort
         call s:goto_win(tagbarwinnr, 1)
     endif
 
-    if !empty(s:TagbarState().getCurrent(0)) &&
-     \ fileinfo.fpath ==# s:TagbarState().getCurrent(0).fpath
+    if !empty(tagbar#state#get_current_file(0)) &&
+     \ fileinfo.fpath ==# tagbar#state#get_current_file(0).fpath
         " We're redisplaying the same file, so save the view
-        call s:debug('Redisplaying file [' . fileinfo.fpath . ']')
+        call tagbar#debug#log('Redisplaying file [' . fileinfo.fpath . ']')
         let saveline = line('.')
         let savecol  = col('.')
         let topline  = line('w0')
@@ -2861,7 +1627,7 @@ function! s:RenderContent(...) abort
         " Print tags
         call s:PrintKinds(typeinfo, fileinfo)
     else
-        call s:debug('No tags found, skipping printing.')
+        call tagbar#debug#log('No tags found, skipping printing.')
         if g:tagbar_compact && s:short_help
             silent 0put ='\" No tags found.'
         else
@@ -2880,8 +1646,8 @@ function! s:RenderContent(...) abort
 
     setlocal nomodifiable
 
-    if !empty(s:TagbarState().getCurrent(0)) &&
-     \ fileinfo.fpath ==# s:TagbarState().getCurrent(0).fpath
+    if !empty(tagbar#state#get_current_file(0)) &&
+     \ fileinfo.fpath ==# tagbar#state#get_current_file(0).fpath
         let scrolloff_save = &scrolloff
         set scrolloff=0
 
@@ -2911,7 +1677,7 @@ endfunction
 
 " s:PrintKinds() {{{2
 function! s:PrintKinds(typeinfo, fileinfo) abort
-    call s:debug('PrintKinds called')
+    call tagbar#debug#log('PrintKinds called')
 
     " If the short or long help is being displayed then the line numbers don't
     " match up with the length of the output list
@@ -2921,7 +1687,7 @@ function! s:PrintKinds(typeinfo, fileinfo) abort
     for kind in a:typeinfo.kinds
         let curtags = filter(copy(a:fileinfo.getTags()),
                            \ 'v:val.fields.kind ==# kind.short')
-        call s:debug('Printing kind: ' . kind.short .
+        call tagbar#debug#log('Printing kind: ' . kind.short .
                    \ ', number of (top-level) tags: ' . len(curtags))
 
         if empty(curtags)
@@ -2942,9 +1708,9 @@ function! s:PrintKinds(typeinfo, fileinfo) abort
             let kindtag = curtags[0].parent
 
             if kindtag.isFolded()
-                let foldmarker = s:icon_closed
+                let foldmarker = g:tagbar#icon_closed
             else
-                let foldmarker = s:icon_open
+                let foldmarker = g:tagbar#icon_open
             endif
 
             let padding = g:tagbar_show_visibility ? ' ' : ''
@@ -3019,7 +1785,7 @@ function! s:PrintTag(tag, depth, output, fileinfo, typeinfo) abort
                     let indent += 1 " fold symbol
                     call add(a:output, repeat(' ', indent) . '[' . ckind.long . ']')
                     " Add basic tag to allow folding when on the header line
-                    let headertag = s:BaseTag.New(ckind.long)
+                    let headertag = tagbar#prototypes#basetag#new(ckind.long)
                     let headertag.parent = a:tag
                     let headertag.fileinfo = a:tag.fileinfo
                     let a:fileinfo.tline[len(a:output) + offset] = headertag
@@ -3057,6 +1823,8 @@ function! s:PrintHelp() abort
         silent  put ='\" ' . s:get_map_str('togglefold') . ': Toggle fold'
         silent  put ='\" ' . s:get_map_str('openallfolds') . ': Open all folds'
         silent  put ='\" ' . s:get_map_str('closeallfolds') . ': Close all folds'
+        silent  put ='\" ' . s:get_map_str('incrementfolds') . ': Increment fold level by 1'
+        silent  put ='\" ' . s:get_map_str('decrementfolds') . ': Decrement fold level by 1'
         silent  put ='\" ' . s:get_map_str('nextfold') . ': Go to next fold'
         silent  put ='\" ' . s:get_map_str('prevfold') . ': Go to previous fold'
         silent  put ='\"'
@@ -3172,9 +1940,9 @@ function! s:HighlightTag(openfolds, ...) abort
         " Make sure the tag is visible in the window
         call winline()
 
-        let foldpat = '[' . s:icon_open . s:icon_closed . ' ]'
-        let pattern = '/^\%' . tagline . 'l\s*' . foldpat . '[-+# ]\zs[^( ]\+\ze/'
-        call s:debug("Highlight pattern: '" . pattern . "'")
+        let foldpat = '[' . g:tagbar#icon_open . g:tagbar#icon_closed . ' ]'
+        let pattern = '/^\%' . tagline . 'l\s*' . foldpat . '[-+# ]\?\zs[^( ]\+\ze/'
+        call tagbar#debug#log("Highlight pattern: '" . pattern . "'")
         if hlexists('TagbarHighlight') " Safeguard in case syntax highlighting is disabled
             execute 'match TagbarHighlight ' . pattern
         else
@@ -3209,23 +1977,27 @@ function! s:JumpToTag(stay_in_tagbar) abort
     " Jump to the line where the tag is defined. Don't use the search pattern
     " since it doesn't take the scope into account and thus can fail if tags
     " with the same name are defined in different scopes (e.g. classes)
+    call tagbar#debug#log('Jumping to line ' . taginfo.fields.line)
     execute taginfo.fields.line
 
     " If the file has been changed but not saved, the tag may not be on the
     " saved line anymore, so search for it in the vicinity of the saved line
-    if match(getline('.'), taginfo.pattern) == -1
-        let interval = 1
-        let forward  = 1
-        while search(taginfo.pattern, 'W' . forward ? '' : 'b') == 0
-            if !forward
-                if interval > line('$')
-                    break
-                else
-                    let interval = interval * 2
+    if taginfo.pattern != ''
+        call tagbar#debug#log('Searching for pattern "' . taginfo.pattern . '"')
+        if match(getline('.'), taginfo.pattern) == -1
+            let interval = 1
+            let forward  = 1
+            while search(taginfo.pattern, 'W' . forward ? '' : 'b') == 0
+                if !forward
+                    if interval > line('$')
+                        break
+                    else
+                        let interval = interval * 2
+                    endif
                 endif
-            endif
-            let forward = !forward
-        endwhile
+                let forward = !forward
+            endwhile
+        endif
     endif
 
     " If the tag is on a different line after unsaved changes update the tag
@@ -3315,9 +2087,13 @@ function! s:ShowInPreviewWin() abort
     " find the correct tag in case of tags with the same name and to speed up
     " the searching. Unfortunately the /\%l pattern doesn't seem to work with
     " psearch.
+    let pattern = taginfo.pattern
+    if pattern == ''
+        let pattern = '\V\^' . escape(getline(taginfo.fields.line), '\') . '\$'
+    endif
     let include_save = &include
     set include=
-    silent! execute taginfo.fields.line . ',$psearch! /' . taginfo.pattern . '/'
+    silent! execute taginfo.fields.line . ',$psearch! /' . pattern . '/'
     let &include = include_save
 
     call s:goto_win('P', 1)
@@ -3385,7 +2161,7 @@ endfunction
 " Folding {{{1
 " s:OpenFold() {{{2
 function! s:OpenFold() abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -3404,7 +2180,7 @@ endfunction
 
 " s:CloseFold() {{{2
 function! s:CloseFold() abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -3425,7 +2201,7 @@ endfunction
 
 " s:ToggleFold() {{{2
 function! s:ToggleFold() abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -3440,7 +2216,7 @@ function! s:ToggleFold() abort
     let newline = line('.')
 
     if curtag.isKindheader()
-        call curtag.toggleFold()
+        call curtag.toggleFold(tagbar#state#get_current_file(0))
     elseif curtag.isFoldable()
         if curtag.isFolded()
             call curtag.openFold()
@@ -3454,6 +2230,22 @@ function! s:ToggleFold() abort
     call s:RenderKeepView(newline)
 endfunction
 
+" s:ChangeFoldLevel() {{{2
+function! s:ChangeFoldLevel(diff, force) abort
+    let fileinfo = tagbar#state#get_current_file(0)
+    if empty(fileinfo)
+        return
+    endif
+
+    if fileinfo.foldlevel == 99
+        call s:MinimizeMaxFoldLevel(fileinfo, fileinfo.getTags())
+    endif
+
+    let level = fileinfo.foldlevel
+    let level = level + a:diff
+    call s:SetFoldLevel(level, a:force)
+endfunction
+
 " s:SetFoldLevel() {{{2
 function! s:SetFoldLevel(level, force) abort
     if a:level < 0
@@ -3461,7 +2253,7 @@ function! s:SetFoldLevel(level, force) abort
         return
     endif
 
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -3504,6 +2296,23 @@ function! s:SetFoldLevelRecursive(fileinfo, tags, level) abort
     endfor
 endfunction
 
+" s:MinimizeMaxFoldLevel() {{{2
+" Set the file's fold level to the lowest value that still shows all tags
+function! s:MinimizeMaxFoldLevel(fileinfo, tags) abort
+    let maxlvl = 0
+    let tags = copy(a:tags)
+
+    for tag in tags
+        if maxlvl < tag.depth
+            let maxlvl = tag.depth
+        endif
+        call tag.setFolded(0)
+        call extend(tags, tag.getChildren())
+    endfor
+
+    let a:fileinfo.foldlevel = maxlvl
+endfunction
+
 " s:OpenParents() {{{2
 function! s:OpenParents(...) abort
     if a:0 == 1
@@ -3582,7 +2391,7 @@ endfunction
 " Helper functions {{{1
 " s:AutoUpdate() {{{2
 function! s:AutoUpdate(fname, force, ...) abort
-    call s:debug('AutoUpdate called [' . a:fname . ']')
+    call tagbar#debug#log('AutoUpdate called [' . a:fname . ']')
 
     " Whether we want to skip actually displaying the tags in Tagbar and only
     " update the fileinfo
@@ -3599,7 +2408,7 @@ function! s:AutoUpdate(fname, force, ...) abort
         " break. MiniBufExplorer does this, for example. Completely disabling
         " autocmds at that point is also not ideal since for example
         " statusline plugins won't be able to update.
-        call s:debug('Still opening window, stopping processing')
+        call tagbar#debug#log('Still opening window, stopping processing')
         return
     endif
 
@@ -3609,18 +2418,18 @@ function! s:AutoUpdate(fname, force, ...) abort
 
     " Don't do anything if we're in the tagbar window
     if ftype == 'tagbar'
-        call s:debug('In Tagbar window, stopping processing')
+        call tagbar#debug#log('In Tagbar window, stopping processing')
         return
     endif
 
     " Only consider the main filetype in cases like 'python.django'
     let sftype = get(split(ftype, '\.'), 0, '')
-    call s:debug("Vim filetype: '" . ftype . "', " .
+    call tagbar#debug#log("Vim filetype: '" . ftype . "', " .
                \ "sanitized filetype: '" . sftype . "'")
 
     " Don't do anything if the file isn't supported
     if !s:IsValidFile(a:fname, sftype)
-        call s:debug('Not a valid file, stopping processing')
+        call tagbar#debug#log('Not a valid file, stopping processing')
         let s:nearby_disabled = 1
         return
     endif
@@ -3636,14 +2445,14 @@ function! s:AutoUpdate(fname, force, ...) abort
         " if a:force || getbufvar(curfile.bufnr, '&modified') ||
         if a:force || empty(curfile) || curfile.ftype != sftype ||
          \ (filereadable(a:fname) && getftime(a:fname) > curfile.mtime)
-            call s:debug('File data outdated, updating [' . a:fname . ']')
+            call tagbar#debug#log('File data outdated, updating [' . a:fname . ']')
             call s:ProcessFile(a:fname, sftype)
             let updated = 1
         else
-            call s:debug('File data seems up to date [' . a:fname . ']')
+            call tagbar#debug#log('File data seems up to date [' . a:fname . ']')
         endif
     elseif !s:known_files.has(a:fname)
-        call s:debug('New file, processing [' . a:fname . ']')
+        call tagbar#debug#log('New file, processing [' . a:fname . ']')
         call s:ProcessFile(a:fname, sftype)
         let updated = 1
     endif
@@ -3657,7 +2466,7 @@ function! s:AutoUpdate(fname, force, ...) abort
     " If we don't have an entry for the file by now something must have gone
     " wrong, so don't change the tagbar content
     if empty(fileinfo)
-        call s:debug('fileinfo empty after processing [' . a:fname . ']')
+        call tagbar#debug#log('fileinfo empty after processing [' . a:fname . ']')
         return
     endif
 
@@ -3665,22 +2474,22 @@ function! s:AutoUpdate(fname, force, ...) abort
     " file is being displayed
     if bufwinnr(s:TagbarBufName()) != -1 && !s:paused &&
      \ (s:new_window || updated ||
-      \ (!empty(s:TagbarState().getCurrent(0)) &&
-       \ a:fname != s:TagbarState().getCurrent(0).fpath))
+      \ (!empty(tagbar#state#get_current_file(0)) &&
+       \ a:fname != tagbar#state#get_current_file(0).fpath))
         call s:RenderContent(fileinfo)
     endif
 
     " Call setCurrent after rendering so RenderContent can check whether the
     " same file is being redisplayed
     if !empty(fileinfo)
-        call s:debug('Setting current file [' . a:fname . ']')
-        call s:TagbarState().setCurrent(fileinfo)
+        call tagbar#debug#log('Setting current file [' . a:fname . ']')
+        call tagbar#state#set_current_file(fileinfo)
         let s:nearby_disabled = 0
     endif
 
     call s:HighlightTag(0)
     call s:SetStatusLine()
-    call s:debug('AutoUpdate finished successfully')
+    call tagbar#debug#log('AutoUpdate finished successfully')
 endfunction
 
 " s:CheckMouseClick() {{{2
@@ -3688,9 +2497,9 @@ function! s:CheckMouseClick() abort
     let line   = getline('.')
     let curcol = col('.')
 
-    if (match(line, s:icon_open . '[-+ ]') + 1) == curcol
+    if (match(line, g:tagbar#icon_open . '[-+ ]') + 1) == curcol
         call s:CloseFold()
-    elseif (match(line, s:icon_closed . '[-+ ]') + 1) == curcol
+    elseif (match(line, g:tagbar#icon_closed . '[-+ ]') + 1) == curcol
         call s:OpenFold()
     elseif g:tagbar_singleclick
         call s:JumpToTag(0)
@@ -3741,12 +2550,12 @@ endfunction
 "       is acceptable. But in cases where arguments may need to be escaped
 "       differently for each &shell type, then pass a list of arguments.
 function! s:EscapeCtagsCmd(ctags_bin, args, ...) abort
-    call s:debug('EscapeCtagsCmd called')
-    call s:debug('ctags_bin: ' . a:ctags_bin)
+    call tagbar#debug#log('EscapeCtagsCmd called')
+    call tagbar#debug#log('ctags_bin: ' . a:ctags_bin)
     if type(a:args)==type('')
-        call s:debug('ctags_args (is a string): ' . a:args)
+        call tagbar#debug#log('ctags_args (is a string): ' . a:args)
     elseif type(a:args)==type([])
-        call s:debug('ctags_args (is a list): ' . string(a:args))
+        call tagbar#debug#log('ctags_args (is a list): ' . string(a:args))
     endif
 
     if exists('+shellslash')
@@ -3821,7 +2630,7 @@ function! s:EscapeCtagsCmd(ctags_bin, args, ...) abort
         endif
     endif
 
-    call s:debug('Escaped ctags command: ' . ctags_cmd)
+    call tagbar#debug#log('Escaped ctags command: ' . ctags_cmd)
 
     if ctags_cmd == ''
         if !s:warnings.encoding
@@ -3839,7 +2648,7 @@ endfunction
 " Partially based on the discussion at
 " http://vim.1045645.n5.nabble.com/bad-default-shellxquote-in-Widows-td1208284.html
 function! s:ExecuteCtags(ctags_cmd) abort
-    call s:debug('Executing ctags command: ' . a:ctags_cmd)
+    call tagbar#debug#log('Executing ctags command: ' . a:ctags_cmd)
 
     if &shell =~# 'fish$'
         " Reset shell since fish isn't really compatible
@@ -3859,10 +2668,10 @@ function! s:ExecuteCtags(ctags_cmd) abort
         set shellcmdflag=/s\ /c
     endif
 
-    if s:debug
+    if tagbar#debug#enabled()
         silent 5verbose let ctags_output = system(a:ctags_cmd)
-        call s:debug(v:statusmsg)
-        call s:debug('Exit code: ' . v:shell_error)
+        call tagbar#debug#log(v:statusmsg)
+        call tagbar#debug#log('Exit code: ' . v:shell_error)
         redraw!
     else
         silent let ctags_output = system(a:ctags_cmd)
@@ -3891,7 +2700,7 @@ function! s:GetNearbyTag(all, forcecurrent, ...) abort
         return {}
     endif
 
-    let fileinfo = s:TagbarState().getCurrent(a:forcecurrent)
+    let fileinfo = tagbar#state#get_current_file(a:forcecurrent)
     if empty(fileinfo)
         return {}
     endif
@@ -3927,7 +2736,7 @@ endfunction
 " does not contain a valid tag (for example because it is empty or only
 " contains a pseudo-tag) return an empty dictionary.
 function! s:GetTagInfo(linenr, ignorepseudo) abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
 
     if empty(fileinfo)
         return {}
@@ -4013,7 +2822,7 @@ endfunction
 
 " s:ToggleHideNonPublicTags() {{{2
 function! s:ToggleHideNonPublicTags() abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -4039,7 +2848,7 @@ endfunction
 
 " s:ToggleCaseInsensitive() {{{2
 function! s:ToggleCaseInsensitive() abort
-    let fileinfo = s:TagbarState().getCurrent(0)
+    let fileinfo = tagbar#state#get_current_file(0)
     if empty(fileinfo)
         return
     endif
@@ -4052,7 +2861,7 @@ function! s:ToggleCaseInsensitive() abort
 
     let g:tagbar_case_insensitive = !g:tagbar_case_insensitive
 
-    call fileinfo.sortTags()
+    call fileinfo.sortTags(fileinfo.typeinfo)
 
     call s:RenderKeepView()
     call s:SetStatusLine()
@@ -4074,31 +2883,31 @@ endfunction
 
 " s:IsValidFile() {{{2
 function! s:IsValidFile(fname, ftype) abort
-    call s:debug('Checking if file is valid [' . a:fname . ']')
+    call tagbar#debug#log('Checking if file is valid [' . a:fname . ']')
 
     if a:fname == '' || a:ftype == ''
-        call s:debug('Empty filename or type')
+        call tagbar#debug#log('Empty filename or type')
         return 0
     endif
 
     if !filereadable(a:fname) && getbufvar(a:fname, 'netrw_tmpfile') == ''
-        call s:debug('File not readable')
+        call tagbar#debug#log('File not readable')
         return 0
     endif
 
     if getbufvar(a:fname, 'tagbar_ignore') == 1
-        call s:debug('File is marked as ignored')
+        call tagbar#debug#log('File is marked as ignored')
         return 0
     endif
 
     let winnr = bufwinnr(a:fname)
     if winnr != -1 && getwinvar(winnr, '&diff')
-        call s:debug('Window is in diff mode')
+        call tagbar#debug#log('Window is in diff mode')
         return 0
     endif
 
     if &previewwindow
-        call s:debug('In preview window')
+        call tagbar#debug#log('In preview window')
         return 0
     endif
 
@@ -4108,7 +2917,7 @@ function! s:IsValidFile(fname, ftype) abort
             " file, so load it now
             call s:LoadUserTypeDefs(a:ftype)
         else
-            call s:debug('Unsupported filetype: ' . a:ftype)
+            call tagbar#debug#log('Unsupported filetype: ' . a:ftype)
             return 0
         endif
     endif
@@ -4134,8 +2943,8 @@ function! s:SetStatusLine()
         let in_tagbar = 1
     endif
 
-    if !empty(s:TagbarState().getCurrent(0))
-        let fileinfo = s:TagbarState().getCurrent(0)
+    if !empty(tagbar#state#get_current_file(0))
+        let fileinfo = tagbar#state#get_current_file(0)
         let fname = fnamemodify(fileinfo.fpath, ':t')
         let sorted = get(fileinfo.typeinfo, 'sort', g:tagbar_sort)
     else
@@ -4180,6 +2989,7 @@ function! s:HandleOnlyWindow() abort
     let s:vim_quitting = 0
 
     if vim_quitting && !s:HasOpenFileWindows()
+        call tagbar#debug#log('Closing Tagbar window due to QuitPre event')
         if winnr('$') >= 1
             call s:goto_win(tagbarwinnr, 1)
         endif
@@ -4270,7 +3080,7 @@ endfunction
 
 " s:do_delayed_update() {{{2
 function! s:do_delayed_update() abort
-    let curfile = s:TagbarState().getCurrent(0)
+    let curfile = tagbar#state#get_current_file(0)
     if empty(curfile)
         let curfname = ''
     else
@@ -4330,22 +3140,13 @@ function! s:TagbarBufName() abort
     return t:tagbar_buf_name
 endfunction
 
-" s:TagbarState() {{{2
-function! s:TagbarState() abort
-    if !exists('t:tagbar_state')
-        let t:tagbar_state = s:state.New()
-    endif
-
-    return t:tagbar_state
-endfunction
-
 " s:goto_win() {{{2
 function! s:goto_win(winnr, ...) abort
     let cmd = type(a:winnr) == type(0) ? a:winnr . 'wincmd w'
                                      \ : 'wincmd ' . a:winnr
     let noauto = a:0 > 0 ? a:1 : 0
 
-    call s:debug("goto_win(): " . cmd . ", " . noauto)
+    call tagbar#debug#log("goto_win(): " . cmd . ", " . noauto)
 
     if noauto
         noautocmd execute cmd
@@ -4395,55 +3196,15 @@ function! TagbarBalloonExpr() abort
         return ''
     endif
 
-    return taginfo.getPrototype(0)
-endfunction
-
-" Debugging {{{1
-" s:StartDebug() {{{2
-function! s:StartDebug(filename) abort
-    if empty(a:filename)
-        let s:debug_file = 'tagbardebug.log'
-    else
-        let s:debug_file = a:filename
-    endif
-
-    " Empty log file
-    exe 'redir! > ' . s:debug_file
-    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 = 1
-endfunction
-
-" s:StopDebug() {{{2
-function! s:StopDebug() abort
-    let s:debug = 0
-    let s:debug_file = ''
-endfunction
-
-" s:debug() {{{2
-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
-function! s:debug(msg) abort
-    if s:debug
-        execute 'redir >> ' . s:debug_file
-        silent echon s:gettime() . ': ' . a:msg . "\n"
-        redir END
+    let prototype = taginfo.getPrototype(0)
+    if has('multi_byte')
+        if g:tagbar_systemenc != &encoding
+            let prototype = iconv(prototype, &encoding, g:tagbar_systemenc)
+        elseif $LANG != ''
+            let prototype = iconv(prototype, &encoding, $LANG)
+        endif
     endif
+    return prototype
 endfunction
 
 " Autoload functions {{{1
@@ -4478,15 +3239,6 @@ function! tagbar#highlighttag(openfolds, force) abort
     call s:HighlightTag(a:openfolds, a:force)
 endfunction
 
-function! tagbar#StartDebug(...) abort
-    let filename = a:0 > 0 ? a:1 : ''
-    call s:StartDebug(filename)
-endfunction
-
-function! tagbar#StopDebug() abort
-    call s:StopDebug()
-endfunction
-
 function! tagbar#RestoreSession() abort
     call s:RestoreSession()
 endfunction
@@ -4498,12 +3250,16 @@ function! tagbar#toggle_pause() abort
     let s:paused = !s:paused
 
     if s:paused
-        call s:TagbarState().setPaused()
+        call tagbar#state#set_paused()
     else
         call s:AutoUpdate(fnamemodify(expand('%'), ':p'), 1)
     endif
 endfunction
 
+function! tagbar#is_paused() abort
+    return s:paused
+endfunction
+
 " tagbar#getusertypes() {{{2
 function! tagbar#getusertypes() abort
     let userdefs = filter(copy(g:), 'v:key =~ "^tagbar_type_"')
@@ -4521,7 +3277,7 @@ endfunction
 " Automatically open Tagbar if one of the open buffers contains a supported
 " file
 function! tagbar#autoopen(...) abort
-    call s:debug('tagbar#autoopen called [' . bufname('%') . ']')
+    call tagbar#debug#log('tagbar#autoopen called [' . bufname('%') . ']')
     let always = a:0 > 0 ? a:1 : 1
 
     call s:Init(0)
@@ -4531,14 +3287,14 @@ function! tagbar#autoopen(...) abort
             let ftype = s:DetectFiletype(bufnr)
             if s:IsValidFile(bufname(bufnr), ftype)
                 call s:OpenWindow('')
-                call s:debug('tagbar#autoopen finished after finding valid ' .
+                call tagbar#debug#log('tagbar#autoopen finished after finding valid ' .
                            \ 'file [' . bufname(bufnr) . ']')
                 return
             endif
         endif
     endfor
 
-    call s:debug('tagbar#autoopen finished without finding valid file')
+    call tagbar#debug#log('tagbar#autoopen finished without finding valid file')
 endfunction
 
 " tagbar#currenttag() {{{2
@@ -4579,8 +3335,8 @@ endfunction
 function! tagbar#currentfile() abort
     let filename = ''
 
-    if !empty(s:TagbarState().getCurrent(1))
-        let filename = fnamemodify(s:TagbarState().getCurrent(1).fpath, ':t')
+    if !empty(tagbar#state#get_current_file(1))
+        let filename = fnamemodify(tagbar#state#get_current_file(1).fpath, ':t')
     endif
 
     return filename
diff --git a/autoload/tagbar/debug.vim b/autoload/tagbar/debug.vim
new file mode 100644
index 0000000..04caec1
--- /dev/null
+++ b/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 = ''
diff --git a/autoload/tagbar/prototypes/basetag.vim b/autoload/tagbar/prototypes/basetag.vim
new file mode 100644
index 0000000..ea7d948
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/prototypes/fileinfo.vim b/autoload/tagbar/prototypes/fileinfo.vim
new file mode 100644
index 0000000..6cd7e8f
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/prototypes/kindheadertag.vim b/autoload/tagbar/prototypes/kindheadertag.vim
new file mode 100644
index 0000000..de67086
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/prototypes/normaltag.vim b/autoload/tagbar/prototypes/normaltag.vim
new file mode 100644
index 0000000..9bf8cf3
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/prototypes/pseudotag.vim b/autoload/tagbar/prototypes/pseudotag.vim
new file mode 100644
index 0000000..50e4ad1
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/prototypes/splittag.vim b/autoload/tagbar/prototypes/splittag.vim
new file mode 100644
index 0000000..7263cd5
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/prototypes/typeinfo.vim b/autoload/tagbar/prototypes/typeinfo.vim
new file mode 100644
index 0000000..1c3f452
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/sorting.vim b/autoload/tagbar/sorting.vim
new file mode 100644
index 0000000..ab9b179
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/state.vim b/autoload/tagbar/state.vim
new file mode 100644
index 0000000..261bcfc
--- /dev/null
+++ b/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
diff --git a/autoload/tagbar/types/ctags.vim b/autoload/tagbar/types/ctags.vim
new file mode 100644
index 0000000..442466c
--- /dev/null
+++ b/autoload/tagbar/types/ctags.vim
@@ -0,0 +1,752 @@
+" 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
+    " 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
diff --git a/autoload/tagbar/types/uctags.vim b/autoload/tagbar/types/uctags.vim
new file mode 100644
index 0000000..da3f4a6
--- /dev/null
+++ b/autoload/tagbar/types/uctags.vim
@@ -0,0 +1,1064 @@
+" Type definitions for Universal Ctags
+
+function! tagbar#types#uctags#init(supported_types) abort
+    let types = {}
+
+    " Ada {{{1
+    let type_ada = tagbar#prototypes#typeinfo#new()
+    let type_ada.ctagstype = 'ada'
+    let type_ada.kinds = [
+        \ {'short' : 'P', 'long' : 'package specifications',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'packages',                      'fold' : 0, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'types',                         'fold' : 0, 'stl' : 1},
+        \ {'short' : 'u', 'long' : 'subtypes',                      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'record type components',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'l', 'long' : 'enum type literals',            'fold' : 0, 'stl' : 0},
+        \ {'short' : 'v', 'long' : 'variables',                     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'generic formal parameters',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'n', 'long' : 'constants',                     'fold' : 0, 'stl' : 0},
+        \ {'short' : 'x', 'long' : 'user defined exceptions',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'R', 'long' : 'subprogram specifications',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'r', 'long' : 'subprograms',                   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'K', 'long' : 'task specifications',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'k', 'long' : 'tasks',                         'fold' : 0, 'stl' : 1},
+        \ {'short' : 'O', 'long' : 'protected data specifications', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'o', 'long' : 'protected data',                'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'task/protected data entries',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'b', 'long' : 'labels',                        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'i', 'long' : 'loop/declare identifiers',      'fold' : 0, 'stl' : 1},
+    \ ]
+    let type_ada.sro        = '.' " Not sure if possible
+    let type_ada.kind2scope = {
+        \ 'P' : 'packspec',
+        \ 't' : 'type',
+    \ }
+    let type_ada.scope2kind = {
+        \ 'packspec' : 'P',
+        \ 'type'     : 't',
+    \ }
+    let types.ada = type_ada
+    " 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' : 'i', 'long' : 'antfiles',   'fold' : 0, 'stl' : 0},
+        \ {'short' : 'P', 'long' : 'properties', 'fold' : 0, 'stl' : 0},
+        \ {'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' : 's', 'long' : 'sections',  '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
+    " Autoconf {{{1
+    let type_autoconf = tagbar#prototypes#typeinfo#new()
+    let type_autoconf.ctagstype = 'autoconf'
+    let type_autoconf.kinds = [
+        \ {'short': 'p', 'long': 'packages',            'fold': 0, 'stl': 1},
+        \ {'short': 't', 'long': 'templates',           'fold': 0, 'stl': 1},
+        \ {'short': 'm', 'long': 'autoconf macros',     'fold': 0, 'stl': 1},
+        \ {'short': 'w', 'long': '"with" options',      'fold': 0, 'stl': 1},
+        \ {'short': 'e', 'long': '"enable" options',    'fold': 0, 'stl': 1},
+        \ {'short': 's', 'long': 'substitution keys',   'fold': 0, 'stl': 1},
+        \ {'short': 'c', 'long': 'automake conditions', 'fold': 0, 'stl': 1},
+        \ {'short': 'd', 'long': 'definitions',         'fold': 0, 'stl': 1},
+    \ ]
+    let types.config = type_autoconf
+    " Automake {{{1
+    let type_automake = tagbar#prototypes#typeinfo#new()
+    let type_automake.ctagstype = 'automake'
+    let type_automake.kinds = [
+        \ {'short' : 'I', 'long' : 'makefiles',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'd', 'long' : 'directories', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'P', 'long' : 'programs',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'M', 'long' : 'manuals',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'macros',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'targets',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'T', 'long' : 'ltlibraries', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'L', 'long' : 'libraries',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'S', 'long' : 'scripts',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'D', 'long' : 'datum',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'conditions',  'fold' : 0, 'stl' : 1},
+    \ ]
+    let types.automake = type_automake
+    " 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' : 'h', 'long' : 'header files', 'fold' : 1, 'stl' : 0},
+        \ {'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' : 'h', 'long' : 'header files', 'fold' : 1, 'stl' : 0},
+        \ {'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
+    " Clojure {{{1
+    let type_clojure = tagbar#prototypes#typeinfo#new()
+    let type_clojure.ctagstype = 'clojure'
+    let type_clojure.kinds     = [
+        \ {'short': 'n', 'long': 'namespace', 'fold': 0, 'stl': 1},
+        \ {'short': 'f', 'long': 'function',  'fold': 0, 'stl': 1},
+    \ ]
+    let type_clojure.sro = '.'
+    let type_clojure.kind2scope = {
+        \ 'n' : 'namespace',
+    \ }
+    let type_clojure.scope2kind = {
+        \ 'namespace'  : 'n'
+    \ }
+    let types.clojure = type_clojure
+    " Ctags config {{{1
+    let type_ctags = tagbar#prototypes#typeinfo#new()
+    let type_ctags.ctagstype = 'ctags'
+    let type_ctags.kinds = [
+        \ {'short' : 'l', 'long' : 'language definitions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'k', 'long' : 'kind definitions',     'fold' : 0, 'stl' : 1},
+    \ ]
+    let type_ctags.sro        = '.' " Not actually possible
+    let type_ctags.kind2scope = {
+        \ 'l' : 'langdef',
+    \ }
+    let type_ctags.scope2kind = {
+        \ 'langdef' : 'l',
+    \ }
+    let types.ctags = type_ctags
+    " 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' : 'D', 'long' : 'divisions',         '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' : 'source code file',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'sections',          'fold' : 0, 'stl' : 1}
+    \ ]
+    let types.cobol = type_cobol
+    " CSS {{{1
+    let type_css = tagbar#prototypes#typeinfo#new()
+    let type_css.ctagstype = 'css'
+    let type_css.kinds     = [
+        \ {'short' : 's', 'long' : 'selector',   'fold' : 0, 'stl' : 0},
+        \ {'short' : 'i', 'long' : 'identities', 'fold' : 1, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',    'fold' : 1, 'stl' : 0}
+    \ ]
+    let types.css = type_css
+    " D {{{1
+    let type_d = tagbar#prototypes#typeinfo#new()
+    let type_d.ctagstype = 'D'
+    let type_d.kinds = [
+        \ {'short' : 'M', 'long' : 'modules',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'V', 'long' : 'version statements',   'fold' : 1, 'stl' : 0},
+        \ {'short' : 'n', 'long' : 'namespaces',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'T', 'long' : 'templates',            'fold' : 0, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'i', 'long' : 'interfaces',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'structure names',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'g', 'long' : 'enumeration names',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enumerators',          'fold' : 0, 'stl' : 0},
+        \ {'short' : 'u', 'long' : 'union names',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'function prototypes',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'function definitions', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'members',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'a', 'long' : 'aliases',              'fold' : 1, 'stl' : 0},
+        \ {'short' : 'X', 'long' : 'mixins',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variable definitions', 'fold' : 0, 'stl' : 0},
+    \ ]
+    let type_d.sro = '.'
+    let type_d.kind2scope = {
+        \ 'g' : 'enum',
+        \ 'n' : 'namespace',
+        \ 'i' : 'interface',
+        \ 'c' : 'class',
+        \ 's' : 'struct',
+        \ 'u' : 'union'
+    \ }
+    let type_d.scope2kind = {
+        \ 'enum'      : 'g',
+        \ 'namespace' : 'n',
+        \ 'interface' : 'i',
+        \ 'class'     : 'c',
+        \ 'struct'    : 's',
+        \ 'union'     : 'u'
+    \ }
+    let types.d = type_d
+    " 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
+    " Elm {{{1
+    " based on https://github.com/bitterjug/vim-tagbar-ctags-elm/blob/master/ftplugin/elm/tagbar-elm.vim
+    let type_elm = tagbar#prototypes#typeinfo#new()
+    let type_elm.ctagstype = 'elm'
+    let type_elm.kinds = [
+        \ {'short' : 'm', 'long' : 'modules',           'fold' : 0, 'stl' : 0},
+        \ {'short' : 'i', 'long' : 'imports',           'fold' : 1, 'stl' : 0},
+        \ {'short' : 't', 'long' : 'types',             'fold' : 1, 'stl' : 0},
+        \ {'short' : 'a', 'long' : 'type aliases',      'fold' : 0, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'type constructors', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'p', 'long' : 'ports',             'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',         'fold' : 1, 'stl' : 0},
+    \ ]
+    let type_elm.sro = ':'
+    let type_elm.kind2scope = {
+        \ 'f' : 'function',
+        \ 'm' : 'module',
+        \ 't' : 'type'
+    \ }
+    let type_elm.scope2kind = {
+        \ 'function' : 'f',
+        \ 'module'   : 'm',
+        \ 'type'     : 't'
+    \ }
+    let types.elm = type_elm
+    " 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},
+        \ {'short' : 't', 'long' : 'type 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' : 'enumerations',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 'N', 'long' : 'enumeration values', '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' : 'M', 'long' : 'type bound procedures',   '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' : '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},
+    \ ]
+    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' : 'a', 'long' : 'annotations',    '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': 'constants',        'fold': 0, 'stl': 0},
+        \ {'short': 'c', 'long': 'classes',          'fold': 0, 'stl': 1},
+        \ {'short': 'g', 'long': 'generators',       'fold': 0, 'stl': 0},
+        \ {'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
+    " 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' : 'I', 'long' : 'makefiles', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'm', 'long' : 'macros',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'targets',   '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},
+        \ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}
+    \ ]
+    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' : 't', 'long' : 'type aliases',          'fold' : 0, 'stl' : 1},
+        \ {'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' : 'E', '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' : 'e', 'long' : 'enumerations',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'f', 'long' : 'functions',             'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'properties',            'fold' : 0, 'stl' : 0},
+        \ {'short' : 'P', 'long' : 'protocols',             'fold' : 0, 'stl' : 0},
+    \ ]
+    let type_objc.sro        = ':'
+    let type_objc.kind2scope = {
+        \ 'i' : 'interface',
+        \ 'I' : 'implementation',
+        \ 's' : 'struct',
+        \ 'p' : 'protocol',
+    \ }
+    let type_objc.scope2kind = {
+        \ 'interface' : 'i',
+        \ 'implementation' : 'I',
+        \ 'struct' : 's',
+        \ 'protocol' : 'p',
+    \ }
+    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},
+        \ {'short' : 'p', 'long' : 'signature items',     '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
+    " Perl 6 {{{1
+    let type_perl6 = tagbar#prototypes#typeinfo#new()
+    let type_perl6.ctagstype = 'perl6'
+    let type_perl6.kinds     = [
+        \ {'short' : 'o', 'long' : 'modules',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'p', 'long' : 'packages',    'fold' : 1, 'stl' : 0},
+        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'g', 'long' : 'grammars',    'fold' : 0, 'stl' : 0},
+        \ {'short' : 'm', 'long' : 'methods',     'fold' : 0, 'stl' : 1},
+        \ {'short' : 'r', 'long' : 'roles',       'fold' : 0, 'stl' : 1},
+        \ {'short' : 'u', 'long' : 'rules',       'fold' : 0, 'stl' : 0},
+        \ {'short' : 'b', 'long' : 'submethods',  'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'tokens',      'fold' : 0, 'stl' : 0},
+    \ ]
+    let types.perl6 = type_perl6
+    " PHP {{{1
+    let type_php = tagbar#prototypes#typeinfo#new()
+    let type_php.ctagstype = 'php'
+    let type_php.kinds     = [
+        \ {'short' : 'n', 'long' : 'namespaces',           'fold' : 0, 'stl' : 0},
+        \ {'short' : 'a', 'long' : 'use aliases',          'fold' : 1, 'stl' : 0},
+        \ {'short' : 'd', 'long' : 'constant definitions', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'i', 'long' : 'interfaces',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'traits',               'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'classes',              'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'variables',            'fold' : 1, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',            'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_php.sro        = '\\'
+    let type_php.kind2scope = {
+        \ 'c' : 'class',
+        \ 'n' : 'namespace',
+        \ 'i' : 'interface',
+        \ 't' : 'trait',
+    \ }
+    let type_php.scope2kind = {
+        \ 'class'     : 'c',
+        \ 'namespace' : 'n',
+        \ 'interface' : 'i',
+        \ 'trait'     : 't',
+    \ }
+    let types.php = type_php
+    " Protobuf {{{1
+    let type_protobuf = tagbar#prototypes#typeinfo#new()
+    let type_protobuf.ctagstype = 'Protobuf'
+    let type_protobuf.kinds = [
+        \ {'short' : 'p', 'long' : 'packages',       'fold' : 0, 'stl' : 0},
+        \ {'short' : 'm', 'long' : 'messages',       'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'fields',         'fold' : 0, 'stl' : 0},
+        \ {'short' : 'e', 'long' : 'enum constants', 'fold' : 0, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'enum types',     'fold' : 0, 'stl' : 0},
+        \ {'short' : 's', 'long' : 'services',       'fold' : 0, 'stl' : 0},
+    \ ]
+    let types.proto = type_protobuf
+    " Python {{{1
+    let type_python = tagbar#prototypes#typeinfo#new()
+    let type_python.ctagstype = 'python'
+    let type_python.kinds     = [
+        \ {'short' : 'i', 'long' : 'modules',   '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 type_python.kind2scope.m = 'member'
+    let type_python.scope2kind.member = 'm'
+    let types.python = type_python
+    let types.pyrex  = type_python
+    let types.cython = type_python
+    " R {{{1
+    let type_r = tagbar#prototypes#typeinfo#new()
+    let type_r.ctagstype = 'R'
+    let type_r.kinds = [
+        \ {'short' : 'l', 'long' : 'libraries',          'fold' : 1, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'functions',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 's', 'long' : 'sources',            'fold' : 0, 'stl' : 0},
+        \ {'short' : 'g', 'long' : 'global variables',   'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'function variables', 'fold' : 0, 'stl' : 0},
+    \ ]
+    let types.r = type_r
+    " 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' : 'S', 'long' : 'singleton methods', 'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_ruby.sro        = '.'
+    let type_ruby.kind2scope = {
+        \ 'c' : 'class',
+        \ 'f' : 'method',
+        \ 'm' : 'module'
+    \ }
+    let type_ruby.scope2kind = {
+        \ 'class'  : 'c',
+        \ 'method' : 'f',
+        \ 'module' : 'm'
+    \ }
+    let types.ruby = type_ruby
+    " Rust {{{1
+    let type_rust = tagbar#prototypes#typeinfo#new()
+    let type_rust.ctagstype = 'rust'
+    let type_rust.kinds     = [
+        \ {'short' : 'n', 'long' : 'module',          'fold' : 1, 'stl' : 0},
+        \ {'short' : 's', 'long' : 'struct',          'fold' : 0, 'stl' : 1},
+        \ {'short' : 'i', 'long' : 'trait',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'c', 'long' : 'implementation',  'fold' : 0, 'stl' : 0},
+        \ {'short' : 'f', 'long' : 'function',        'fold' : 0, 'stl' : 1},
+        \ {'short' : 'g', 'long' : 'enum',            'fold' : 0, 'stl' : 1},
+        \ {'short' : 't', 'long' : 'type alias',      'fold' : 0, 'stl' : 1},
+        \ {'short' : 'v', 'long' : 'global variable', 'fold' : 0, 'stl' : 1},
+        \ {'short' : 'M', 'long' : 'macro',           'fold' : 0, 'stl' : 1},
+        \ {'short' : 'm', 'long' : 'struct field',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'e', 'long' : 'enum variant',    'fold' : 0, 'stl' : 1},
+        \ {'short' : 'P', 'long' : 'method',          'fold' : 0, 'stl' : 1}
+    \ ]
+    let type_rust.sro        = '::'
+    let type_rust.kind2scope = {
+        \ 'n' : 'module',
+        \ 's' : 'struct',
+        \ 'i' : 'interface',
+        \ 'c' : 'implementation',
+        \ 'f' : 'function',
+        \ 'g' : 'enum',
+        \ 'P' : 'method',
+    \ }
+    let type_rust.scope2kind = {
+        \ 'module'        : 'n',
+        \ 'struct'        : 's',
+        \ 'interface'     : 'i',
+        \ 'implementation': 'c',
+        \ 'function'      : 'f',
+        \ 'enum'          : 'g',
+        \ 'method'        : 'P',
+    \ }
+    let types.rust = type_rust
+    " 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},
+        \ {'short' : 'a', 'long' : 'aliases',      'fold' : 0, 'stl' : 0},
+        \ {'short' : 's', 'long' : 'script files', 'fold' : 0, 'stl' : 0}
+    \ ]
+    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' : 'E', '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' : 'n', 'long' : 'namespaces', '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' : 'h', 'long' : 'header files', 'fold' : 1, 'stl' : 0},
+        \ {'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' : 'i', 'long' : 'interfaces',  'fold' : 0, 'stl' : 1},
+        \ {'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' : 's', 'long' : 'signals',     'fold' : 0, 'stl' : 0},
+        \ {'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' : 'b', 'long' : 'blocks',              '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
diff --git a/doc/tagbar.txt b/doc/tagbar.txt
index 63b6883..0efcf37 100644
--- a/doc/tagbar.txt
+++ b/doc/tagbar.txt
@@ -346,6 +346,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|.
@@ -1200,8 +1206,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
@@ -1269,8 +1278,9 @@ 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. Remove the |tagbar-statusline| support from your vimrc if you use it, and
-     make sure you don't have any autocommands that load Tagbar on startup.
+  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.
@@ -1282,7 +1292,12 @@ 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.
+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.
+
 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.
diff --git a/plugin/tagbar.vim b/plugin/tagbar.vim
index cc03e38..9eee0d0 100644
--- a/plugin/tagbar.vim
+++ b/plugin/tagbar.vim
@@ -108,6 +108,8 @@ function! s:setup_keymaps() abort
         \ ['togglefold',    ['o', 'za']],
         \ ['openallfolds',  ['*', '<kMultiply>', 'zR']],
         \ ['closeallfolds', ['=', 'zM']],
+        \ ['incrementfolds',  ['zr']],
+        \ ['decrementfolds',  ['zm']],
         \ ['nextfold',      'zj'],
         \ ['prevfold',      'zk'],
         \
@@ -141,8 +143,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
diff --git a/syntax/tagbar.vim b/syntax/tagbar.vim
index ef7686e..5d67393 100644
--- a/syntax/tagbar.vim
+++ b/syntax/tagbar.vim
@@ -12,7 +12,8 @@ if exists("b:current_syntax")
 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 . '][-+# ]\?\)\@<=[^*(]\+\(\*\?\(([^)]\+)\)\? :\)\@='