Commits

aef  committed e9eec70

Committing to merge

  • Participants
  • Parent commits 8166908

Comments (0)

Files changed (50)

File vim/bundle/tagbar/.git/HEAD

-ref: refs/heads/master

File vim/bundle/tagbar/.git/config

-[core]
-	repositoryformatversion = 0
-	filemode = true
-	bare = false
-	logallrefupdates = true
-[remote "origin"]
-	fetch = +refs/heads/*:refs/remotes/origin/*
-	url = https://github.com/majutsushi/tagbar.git
-[branch "master"]
-	remote = origin
-	merge = refs/heads/master

File vim/bundle/tagbar/.git/description

-Unnamed repository; edit this file 'description' to name the repository.

File vim/bundle/tagbar/.git/hooks/applypatch-msg.sample

-#!/bin/sh
-#
-# An example hook script to check the commit log message taken by
-# applypatch from an e-mail message.
-#
-# The hook should exit with non-zero status after issuing an
-# appropriate message if it wants to stop the commit.  The hook is
-# allowed to edit the commit message file.
-#
-# To enable this hook, rename this file to "applypatch-msg".
-
-. git-sh-setup
-test -x "$GIT_DIR/hooks/commit-msg" &&
-	exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"}
-:

File vim/bundle/tagbar/.git/hooks/commit-msg.sample

-#!/bin/sh
-#
-# An example hook script to check the commit log message.
-# Called by "git commit" with one argument, the name of the file
-# that has the commit message.  The hook should exit with non-zero
-# status after issuing an appropriate message if it wants to stop the
-# commit.  The hook is allowed to edit the commit message file.
-#
-# To enable this hook, rename this file to "commit-msg".
-
-# Uncomment the below to add a Signed-off-by line to the message.
-# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
-# hook is more suited to it.
-#
-# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
-# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
-
-# This example catches duplicate Signed-off-by lines.
-
-test "" = "$(grep '^Signed-off-by: ' "$1" |
-	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
-	echo >&2 Duplicate Signed-off-by lines.
-	exit 1
-}

File vim/bundle/tagbar/.git/hooks/post-update.sample

-#!/bin/sh
-#
-# An example hook script to prepare a packed repository for use over
-# dumb transports.
-#
-# To enable this hook, rename this file to "post-update".
-
-exec git update-server-info

File vim/bundle/tagbar/.git/hooks/pre-applypatch.sample

-#!/bin/sh
-#
-# An example hook script to verify what is about to be committed
-# by applypatch from an e-mail message.
-#
-# The hook should exit with non-zero status after issuing an
-# appropriate message if it wants to stop the commit.
-#
-# To enable this hook, rename this file to "pre-applypatch".
-
-. git-sh-setup
-test -x "$GIT_DIR/hooks/pre-commit" &&
-	exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"}
-:

File vim/bundle/tagbar/.git/hooks/pre-commit.sample

-#!/bin/sh
-#
-# An example hook script to verify what is about to be committed.
-# Called by "git commit" with no arguments.  The hook should
-# exit with non-zero status after issuing an appropriate message if
-# it wants to stop the commit.
-#
-# To enable this hook, rename this file to "pre-commit".
-
-if git rev-parse --verify HEAD >/dev/null 2>&1
-then
-	against=HEAD
-else
-	# Initial commit: diff against an empty tree object
-	against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
-fi
-
-# If you want to allow non-ascii filenames set this variable to true.
-allownonascii=$(git config hooks.allownonascii)
-
-# Redirect output to stderr.
-exec 1>&2
-
-# Cross platform projects tend to avoid non-ascii filenames; prevent
-# them from being added to the repository. We exploit the fact that the
-# printable range starts at the space character and ends with tilde.
-if [ "$allownonascii" != "true" ] &&
-	# Note that the use of brackets around a tr range is ok here, (it's
-	# even required, for portability to Solaris 10's /usr/bin/tr), since
-	# the square bracket bytes happen to fall in the designated range.
-	test $(git diff --cached --name-only --diff-filter=A -z $against |
-	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
-then
-	echo "Error: Attempt to add a non-ascii file name."
-	echo
-	echo "This can cause problems if you want to work"
-	echo "with people on other platforms."
-	echo
-	echo "To be portable it is advisable to rename the file ..."
-	echo
-	echo "If you know what you are doing you can disable this"
-	echo "check using:"
-	echo
-	echo "  git config hooks.allownonascii true"
-	echo
-	exit 1
-fi
-
-# If there are whitespace errors, print the offending file names and fail.
-exec git diff-index --check --cached $against --

File vim/bundle/tagbar/.git/hooks/pre-rebase.sample

-#!/bin/sh
-#
-# Copyright (c) 2006, 2008 Junio C Hamano
-#
-# The "pre-rebase" hook is run just before "git rebase" starts doing
-# its job, and can prevent the command from running by exiting with
-# non-zero status.
-#
-# The hook is called with the following parameters:
-#
-# $1 -- the upstream the series was forked from.
-# $2 -- the branch being rebased (or empty when rebasing the current branch).
-#
-# This sample shows how to prevent topic branches that are already
-# merged to 'next' branch from getting rebased, because allowing it
-# would result in rebasing already published history.
-
-publish=next
-basebranch="$1"
-if test "$#" = 2
-then
-	topic="refs/heads/$2"
-else
-	topic=`git symbolic-ref HEAD` ||
-	exit 0 ;# we do not interrupt rebasing detached HEAD
-fi
-
-case "$topic" in
-refs/heads/??/*)
-	;;
-*)
-	exit 0 ;# we do not interrupt others.
-	;;
-esac
-
-# Now we are dealing with a topic branch being rebased
-# on top of master.  Is it OK to rebase it?
-
-# Does the topic really exist?
-git show-ref -q "$topic" || {
-	echo >&2 "No such branch $topic"
-	exit 1
-}
-
-# Is topic fully merged to master?
-not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
-if test -z "$not_in_master"
-then
-	echo >&2 "$topic is fully merged to master; better remove it."
-	exit 1 ;# we could allow it, but there is no point.
-fi
-
-# Is topic ever merged to next?  If so you should not be rebasing it.
-only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
-only_next_2=`git rev-list ^master           ${publish} | sort`
-if test "$only_next_1" = "$only_next_2"
-then
-	not_in_topic=`git rev-list "^$topic" master`
-	if test -z "$not_in_topic"
-	then
-		echo >&2 "$topic is already up-to-date with master"
-		exit 1 ;# we could allow it, but there is no point.
-	else
-		exit 0
-	fi
-else
-	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
-	/usr/bin/perl -e '
-		my $topic = $ARGV[0];
-		my $msg = "* $topic has commits already merged to public branch:\n";
-		my (%not_in_next) = map {
-			/^([0-9a-f]+) /;
-			($1 => 1);
-		} split(/\n/, $ARGV[1]);
-		for my $elem (map {
-				/^([0-9a-f]+) (.*)$/;
-				[$1 => $2];
-			} split(/\n/, $ARGV[2])) {
-			if (!exists $not_in_next{$elem->[0]}) {
-				if ($msg) {
-					print STDERR $msg;
-					undef $msg;
-				}
-				print STDERR " $elem->[1]\n";
-			}
-		}
-	' "$topic" "$not_in_next" "$not_in_master"
-	exit 1
-fi
-
-exit 0
-
-################################################################
-
-This sample hook safeguards topic branches that have been
-published from being rewound.
-
-The workflow assumed here is:
-
- * Once a topic branch forks from "master", "master" is never
-   merged into it again (either directly or indirectly).
-
- * Once a topic branch is fully cooked and merged into "master",
-   it is deleted.  If you need to build on top of it to correct
-   earlier mistakes, a new topic branch is created by forking at
-   the tip of the "master".  This is not strictly necessary, but
-   it makes it easier to keep your history simple.
-
- * Whenever you need to test or publish your changes to topic
-   branches, merge them into "next" branch.
-
-The script, being an example, hardcodes the publish branch name
-to be "next", but it is trivial to make it configurable via
-$GIT_DIR/config mechanism.
-
-With this workflow, you would want to know:
-
-(1) ... if a topic branch has ever been merged to "next".  Young
-    topic branches can have stupid mistakes you would rather
-    clean up before publishing, and things that have not been
-    merged into other branches can be easily rebased without
-    affecting other people.  But once it is published, you would
-    not want to rewind it.
-
-(2) ... if a topic branch has been fully merged to "master".
-    Then you can delete it.  More importantly, you should not
-    build on top of it -- other people may already want to
-    change things related to the topic as patches against your
-    "master", so if you need further changes, it is better to
-    fork the topic (perhaps with the same name) afresh from the
-    tip of "master".
-
-Let's look at this example:
-
-		   o---o---o---o---o---o---o---o---o---o "next"
-		  /       /           /           /
-		 /   a---a---b A     /           /
-		/   /               /           /
-	       /   /   c---c---c---c B         /
-	      /   /   /             \         /
-	     /   /   /   b---b C     \       /
-	    /   /   /   /             \     /
-    ---o---o---o---o---o---o---o---o---o---o---o "master"
-
-
-A, B and C are topic branches.
-
- * A has one fix since it was merged up to "next".
-
- * B has finished.  It has been fully merged up to "master" and "next",
-   and is ready to be deleted.
-
- * C has not merged to "next" at all.
-
-We would want to allow C to be rebased, refuse A, and encourage
-B to be deleted.
-
-To compute (1):
-
-	git rev-list ^master ^topic next
-	git rev-list ^master        next
-
-	if these match, topic has not merged in next at all.
-
-To compute (2):
-
-	git rev-list master..topic
-
-	if this is empty, it is fully merged to "master".

File vim/bundle/tagbar/.git/hooks/prepare-commit-msg.sample

-#!/bin/sh
-#
-# An example hook script to prepare the commit log message.
-# Called by "git commit" with the name of the file that has the
-# commit message, followed by the description of the commit
-# message's source.  The hook's purpose is to edit the commit
-# message file.  If the hook fails with a non-zero status,
-# the commit is aborted.
-#
-# To enable this hook, rename this file to "prepare-commit-msg".
-
-# This hook includes three examples.  The first comments out the
-# "Conflicts:" part of a merge commit.
-#
-# The second includes the output of "git diff --name-status -r"
-# into the message, just before the "git status" output.  It is
-# commented because it doesn't cope with --amend or with squashed
-# commits.
-#
-# The third example adds a Signed-off-by line to the message, that can
-# still be edited.  This is rarely a good idea.
-
-case "$2,$3" in
-  merge,)
-    /usr/bin/perl -i.bak -ne 's/^/# /, s/^# #/#/ if /^Conflicts/ .. /#/; print' "$1" ;;
-
-# ,|template,)
-#   /usr/bin/perl -i.bak -pe '
-#      print "\n" . `git diff --cached --name-status -r`
-#	 if /^#/ && $first++ == 0' "$1" ;;
-
-  *) ;;
-esac
-
-# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
-# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

File vim/bundle/tagbar/.git/hooks/update.sample

-#!/bin/sh
-#
-# An example hook script to blocks unannotated tags from entering.
-# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
-#
-# To enable this hook, rename this file to "update".
-#
-# Config
-# ------
-# hooks.allowunannotated
-#   This boolean sets whether unannotated tags will be allowed into the
-#   repository.  By default they won't be.
-# hooks.allowdeletetag
-#   This boolean sets whether deleting tags will be allowed in the
-#   repository.  By default they won't be.
-# hooks.allowmodifytag
-#   This boolean sets whether a tag may be modified after creation. By default
-#   it won't be.
-# hooks.allowdeletebranch
-#   This boolean sets whether deleting branches will be allowed in the
-#   repository.  By default they won't be.
-# hooks.denycreatebranch
-#   This boolean sets whether remotely creating branches will be denied
-#   in the repository.  By default this is allowed.
-#
-
-# --- Command line
-refname="$1"
-oldrev="$2"
-newrev="$3"
-
-# --- Safety check
-if [ -z "$GIT_DIR" ]; then
-	echo "Don't run this script from the command line." >&2
-	echo " (if you want, you could supply GIT_DIR then run" >&2
-	echo "  $0 <ref> <oldrev> <newrev>)" >&2
-	exit 1
-fi
-
-if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
-	echo "Usage: $0 <ref> <oldrev> <newrev>" >&2
-	exit 1
-fi
-
-# --- Config
-allowunannotated=$(git config --bool hooks.allowunannotated)
-allowdeletebranch=$(git config --bool hooks.allowdeletebranch)
-denycreatebranch=$(git config --bool hooks.denycreatebranch)
-allowdeletetag=$(git config --bool hooks.allowdeletetag)
-allowmodifytag=$(git config --bool hooks.allowmodifytag)
-
-# check for no description
-projectdesc=$(sed -e '1q' "$GIT_DIR/description")
-case "$projectdesc" in
-"Unnamed repository"* | "")
-	echo "*** Project description file hasn't been set" >&2
-	exit 1
-	;;
-esac
-
-# --- Check types
-# if $newrev is 0000...0000, it's a commit to delete a ref.
-zero="0000000000000000000000000000000000000000"
-if [ "$newrev" = "$zero" ]; then
-	newrev_type=delete
-else
-	newrev_type=$(git cat-file -t $newrev)
-fi
-
-case "$refname","$newrev_type" in
-	refs/tags/*,commit)
-		# un-annotated tag
-		short_refname=${refname##refs/tags/}
-		if [ "$allowunannotated" != "true" ]; then
-			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
-			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
-			exit 1
-		fi
-		;;
-	refs/tags/*,delete)
-		# delete tag
-		if [ "$allowdeletetag" != "true" ]; then
-			echo "*** Deleting a tag is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	refs/tags/*,tag)
-		# annotated tag
-		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
-		then
-			echo "*** Tag '$refname' already exists." >&2
-			echo "*** Modifying a tag is not allowed in this repository." >&2
-			exit 1
-		fi
-		;;
-	refs/heads/*,commit)
-		# branch
-		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
-			echo "*** Creating a branch is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	refs/heads/*,delete)
-		# delete branch
-		if [ "$allowdeletebranch" != "true" ]; then
-			echo "*** Deleting a branch is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	refs/remotes/*,commit)
-		# tracking branch
-		;;
-	refs/remotes/*,delete)
-		# delete tracking branch
-		if [ "$allowdeletebranch" != "true" ]; then
-			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
-			exit 1
-		fi
-		;;
-	*)
-		# Anything else (is there anything else?)
-		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
-		exit 1
-		;;
-esac
-
-# --- Finished
-exit 0

File vim/bundle/tagbar/.git/index

Binary file removed.

File vim/bundle/tagbar/.git/info/exclude

-# git ls-files --others --exclude-from=.git/info/exclude
-# Lines that start with '#' are comments.
-# For a project mostly in C, the following would be a good set of
-# exclude patterns (uncomment them if you want to use them):
-# *.[oa]
-# *~

File vim/bundle/tagbar/.git/logs/HEAD

-0000000000000000000000000000000000000000 81cfb3f9038ca6de5716dc170212e29dfb0bf94f Adrian Fraiha <adrian@argh.localdomain> 1324961828 -0500	clone: from https://github.com/majutsushi/tagbar.git

File vim/bundle/tagbar/.git/logs/refs/heads/master

-0000000000000000000000000000000000000000 81cfb3f9038ca6de5716dc170212e29dfb0bf94f Adrian Fraiha <adrian@argh.localdomain> 1324961828 -0500	clone: from https://github.com/majutsushi/tagbar.git

File vim/bundle/tagbar/.git/objects/pack/pack-bc2c881cb56741413acf7d11429b545397d380a1.idx

Binary file removed.

File vim/bundle/tagbar/.git/objects/pack/pack-bc2c881cb56741413acf7d11429b545397d380a1.pack

Binary file removed.

File vim/bundle/tagbar/.git/packed-refs

-# pack-refs with: peeled 
-5dfb7cc2abe8ad78d489e8da36bc3f2cb0087c92 refs/remotes/origin/70fix
-b92b01003ca2d54a6a940ff202e840b4060006a9 refs/remotes/origin/gh-pages
-81cfb3f9038ca6de5716dc170212e29dfb0bf94f refs/remotes/origin/master
-c6bbfcdba14a612690d6791db8ec5d5e27c6ed5a refs/tags/v1.0
-91deffb04dfe56c261eb7dfc6ac2ef92e6a5dad2 refs/tags/v1.1
-84121aac7d90d095edf75acfc9c31a53171f2f6f refs/tags/v1.2
-518b07de1225d9729104db73f157dce17c79b70f refs/tags/v1.5
-b4ed33c4bcd8d1d6ca5ea9f03407aff61006f7ad refs/tags/v2.0
-a76d07cfeb67af5ba1ba903ff57a7e3cd547e840 refs/tags/v2.0.1
-9d5af93a5b875e40bc32212d850917deb6651023 refs/tags/v2.1
-4cc123f3f2fc5b952254c7a520688d7966a0119c refs/tags/v2.2
-81cfb3f9038ca6de5716dc170212e29dfb0bf94f refs/tags/v2.3

File vim/bundle/tagbar/.git/refs/heads/master

-81cfb3f9038ca6de5716dc170212e29dfb0bf94f

File vim/bundle/tagbar/.git/refs/remotes/origin/HEAD

-ref: refs/remotes/origin/master

File vim/bundle/tagbar/.gitattributes

-.gitignore     export-ignore
-.gitattributes export-ignore
-README         export-ignore
-.info          export-ignore

File vim/bundle/tagbar/.gitignore

-/doc/tags

File vim/bundle/tagbar/.info

-tagbar
-3465

File vim/bundle/tagbar/README

-Tagbar is a vim plugin for browsing the tags of source code files. It provides
-a sidebar that displays the ctags-generated tags of the current file, ordered
-by their scope. This means that for example methods in C++ are displayed under
-the class they are defined in.
-
-Check out the homepage at http://majutsushi.github.com/tagbar/ for more
-information.

File vim/bundle/tagbar/autoload/tagbar.vim

-" ============================================================================
-" File:        tagbar.vim
-" Description: List the current file's tags in a sidebar, ordered by class etc
-" Author:      Jan Larres <jan@majutsushi.net>
-" Licence:     Vim licence
-" Website:     http://majutsushi.github.com/tagbar/
-" Version:     2.3
-" Note:        This plugin was heavily inspired by the 'Taglist' plugin by
-"              Yegappan Lakshmanan and uses a small amount of code from it.
-"
-" Original taglist copyright notice:
-"              Permission is hereby granted to use and distribute this code,
-"              with or without modifications, provided that this copyright
-"              notice is copied with it. Like anything else that's free,
-"              taglist.vim is provided *as is* and comes with no warranty of
-"              any kind, either expressed or implied. In no event will the
-"              copyright holder be liable for any damamges resulting from the
-"              use of this software.
-" ============================================================================
-
-scriptencoding utf-8
-
-" Initialization {{{1
-
-" Basic init {{{2
-
-if !exists('g:tagbar_ctags_bin')
-    if executable('ctags-exuberant')
-        let g:tagbar_ctags_bin = 'ctags-exuberant'
-    elseif executable('exuberant-ctags')
-        let g:tagbar_ctags_bin = 'exuberant-ctags'
-    elseif executable('exctags')
-        let g:tagbar_ctags_bin = 'exctags'
-    elseif has('macunix') && executable('/usr/local/bin/ctags')
-        " Homebrew default location
-        let g:tagbar_ctags_bin = '/usr/local/bin/ctags'
-    elseif has('macunix') && executable('/opt/local/bin/ctags')
-        " Macports default location
-        let g:tagbar_ctags_bin = '/opt/local/bin/ctags'
-    elseif executable('ctags')
-        let g:tagbar_ctags_bin = 'ctags'
-    elseif executable('ctags.exe')
-        let g:tagbar_ctags_bin = 'ctags.exe'
-    elseif executable('tags')
-        let g:tagbar_ctags_bin = 'tags'
-    else
-        echomsg 'Tagbar: Exuberant ctags not found, skipping plugin'
-        finish
-    endif
-else
-    " reset 'wildignore' temporarily in case *.exe is included in it
-    let wildignore_save = &wildignore
-    set wildignore&
-
-    let g:tagbar_ctags_bin = expand(g:tagbar_ctags_bin)
-
-    let &wildignore = wildignore_save
-
-    if !executable(g:tagbar_ctags_bin)
-        echomsg 'Tagbar: Exuberant ctags not found in specified place,'
-              \ 'skipping plugin'
-        finish
-    endif
-endif
-
-redir => s:ftype_out
-silent filetype
-redir END
-if s:ftype_out !~# 'detection:ON'
-    echomsg 'Tagbar: Filetype detection is turned off, skipping plugin'
-    unlet s:ftype_out
-    finish
-endif
-unlet s:ftype_out
-
-let s:icon_closed = g:tagbar_iconchars[0]
-let s:icon_open   = g:tagbar_iconchars[1]
-
-let s:type_init_done    = 0
-let s:autocommands_done = 0
-let s:checked_ctags     = 0
-let s:window_expanded   = 0
-
-let s:access_symbols = {
-    \ 'public'    : '+',
-    \ 'protected' : '#',
-    \ 'private'   : '-'
-\ }
-
-let g:loaded_tagbar = 1
-
-let s:last_highlight_tline = 0
-let s:debug = 0
-let s:debug_file = ''
-
-" s:Init() {{{2
-function! s:Init()
-    if !s:type_init_done
-        call s:InitTypes()
-    endif
-
-    if !s:checked_ctags
-        if !s:CheckForExCtags()
-            return
-        endif
-    endif
-endfunction
-
-" s:InitTypes() {{{2
-function! s:InitTypes()
-    call s:LogDebugMessage('Initializing types')
-
-    let s:known_types = {}
-
-    " Ant {{{3
-    let type_ant = {}
-    let type_ant.ctagstype = 'ant'
-    let type_ant.kinds     = [
-        \ {'short' : 'p', 'long' : 'projects', 'fold' : 0},
-        \ {'short' : 't', 'long' : 'targets',  'fold' : 0}
-    \ ]
-    let s:known_types.ant = type_ant
-    " Asm {{{3
-    let type_asm = {}
-    let type_asm.ctagstype = 'asm'
-    let type_asm.kinds     = [
-        \ {'short' : 'm', 'long' : 'macros',  'fold' : 0},
-        \ {'short' : 't', 'long' : 'types',   'fold' : 0},
-        \ {'short' : 'd', 'long' : 'defines', 'fold' : 0},
-        \ {'short' : 'l', 'long' : 'labels',  'fold' : 0}
-    \ ]
-    let s:known_types.asm = type_asm
-    " ASP {{{3
-    let type_aspvbs = {}
-    let type_aspvbs.ctagstype = 'asp'
-    let type_aspvbs.kinds     = [
-        \ {'short' : 'd', 'long' : 'constants',   'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0},
-        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0}
-    \ ]
-    let s:known_types.aspvbs = type_aspvbs
-    " Awk {{{3
-    let type_awk = {}
-    let type_awk.ctagstype = 'awk'
-    let type_awk.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
-    \ ]
-    let s:known_types.awk = type_awk
-    " Basic {{{3
-    let type_basic = {}
-    let type_basic.ctagstype = 'basic'
-    let type_basic.kinds     = [
-        \ {'short' : 'c', 'long' : 'constants',    'fold' : 0},
-        \ {'short' : 'g', 'long' : 'enumerations', 'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',    'fold' : 0},
-        \ {'short' : 'l', 'long' : 'labels',       'fold' : 0},
-        \ {'short' : 't', 'long' : 'types',        'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',    'fold' : 0}
-    \ ]
-    let s:known_types.basic = type_basic
-    " BETA {{{3
-    let type_beta = {}
-    let type_beta.ctagstype = 'beta'
-    let type_beta.kinds     = [
-        \ {'short' : 'f', 'long' : 'fragments', 'fold' : 0},
-        \ {'short' : 's', 'long' : 'slots',     'fold' : 0},
-        \ {'short' : 'v', 'long' : 'patterns',  'fold' : 0}
-    \ ]
-    let s:known_types.beta = type_beta
-    " C {{{3
-    let type_c = {}
-    let type_c.ctagstype = 'c'
-    let type_c.kinds     = [
-        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
-        \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1},
-        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
-        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
-        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0},
-        \ {'short' : 's', 'long' : 'structs',     'fold' : 0},
-        \ {'short' : 'u', 'long' : 'unions',      'fold' : 0},
-        \ {'short' : 'm', 'long' : 'members',     'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0}
-    \ ]
-    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 = {}
-    let type_cpp.ctagstype = 'c++'
-    let type_cpp.kinds     = [
-        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
-        \ {'short' : 'p', 'long' : 'prototypes',  'fold' : 1},
-        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
-        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
-        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0},
-        \ {'short' : 'n', 'long' : 'namespaces',  'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
-        \ {'short' : 's', 'long' : 'structs',     'fold' : 0},
-        \ {'short' : 'u', 'long' : 'unions',      'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0},
-        \ {'short' : 'm', 'long' : 'members',     'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0}
-    \ ]
-    let type_cpp.sro        = '::'
-    let type_cpp.kind2scope = {
-        \ 'g' : 'enum',
-        \ 'n' : 'namespace',
-        \ 'c' : 'class',
-        \ 's' : 'struct',
-        \ 'u' : 'union'
-    \ }
-    let type_cpp.scope2kind = {
-        \ 'enum'      : 'g',
-        \ 'namespace' : 'n',
-        \ 'class'     : 'c',
-        \ 'struct'    : 's',
-        \ 'union'     : 'u'
-    \ }
-    let s:known_types.cpp = type_cpp
-    " C# {{{3
-    let type_cs = {}
-    let type_cs.ctagstype = 'c#'
-    let type_cs.kinds     = [
-        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
-        \ {'short' : 'f', 'long' : 'fields',      'fold' : 0},
-        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
-        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
-        \ {'short' : 't', 'long' : 'typedefs',    'fold' : 0},
-        \ {'short' : 'n', 'long' : 'namespaces',  'fold' : 0},
-        \ {'short' : 'i', 'long' : 'interfaces',  'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
-        \ {'short' : 's', 'long' : 'structs',     'fold' : 0},
-        \ {'short' : 'E', 'long' : 'events',      'fold' : 0},
-        \ {'short' : 'm', 'long' : 'methods',     'fold' : 0},
-        \ {'short' : 'p', 'long' : 'properties',  'fold' : 0}
-    \ ]
-    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 = {}
-    let type_cobol.ctagstype = 'cobol'
-    let type_cobol.kinds     = [
-        \ {'short' : 'd', 'long' : 'data items',        'fold' : 0},
-        \ {'short' : 'f', 'long' : 'file descriptions', 'fold' : 0},
-        \ {'short' : 'g', 'long' : 'group items',       'fold' : 0},
-        \ {'short' : 'p', 'long' : 'paragraphs',        'fold' : 0},
-        \ {'short' : 'P', 'long' : 'program ids',       'fold' : 0},
-        \ {'short' : 's', 'long' : 'sections',          'fold' : 0}
-    \ ]
-    let s:known_types.cobol = type_cobol
-    " DOS Batch {{{3
-    let type_dosbatch = {}
-    let type_dosbatch.ctagstype = 'dosbatch'
-    let type_dosbatch.kinds     = [
-        \ {'short' : 'l', 'long' : 'labels',    'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables', 'fold' : 0}
-    \ ]
-    let s:known_types.dosbatch = type_dosbatch
-    " Eiffel {{{3
-    let type_eiffel = {}
-    let type_eiffel.ctagstype = 'eiffel'
-    let type_eiffel.kinds     = [
-        \ {'short' : 'c', 'long' : 'classes',  'fold' : 0},
-        \ {'short' : 'f', 'long' : 'features', 'fold' : 0}
-    \ ]
-    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 = {}
-    let type_erlang.ctagstype = 'erlang'
-    let type_erlang.kinds     = [
-        \ {'short' : 'm', 'long' : 'modules',            'fold' : 0},
-        \ {'short' : 'd', 'long' : 'macro definitions',  'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',          'fold' : 0},
-        \ {'short' : 'r', 'long' : 'record definitions', 'fold' : 0}
-    \ ]
-    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_mxml = {}
-    let type_mxml.ctagstype = 'flex'
-    let type_mxml.kinds     = [
-        \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',          'fold' : 0},
-        \ {'short' : 'm', 'long' : 'methods',          'fold' : 0},
-        \ {'short' : 'p', 'long' : 'properties',       'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',        'fold' : 0},
-        \ {'short' : 'x', 'long' : 'mxtags',           'fold' : 0}
-    \ ]
-    let type_mxml.sro        = '.'
-    let type_mxml.kind2scope = {
-        \ 'c' : 'class'
-    \ }
-    let type_mxml.scope2kind = {
-        \ 'class' : 'c'
-    \ }
-    let s:known_types.mxml = type_mxml
-    " Fortran {{{3
-    let type_fortran = {}
-    let type_fortran.ctagstype = 'fortran'
-    let type_fortran.kinds     = [
-        \ {'short' : 'm', 'long' : 'modules',                      'fold' : 0},
-        \ {'short' : 'p', 'long' : 'programs',                     'fold' : 0},
-        \ {'short' : 'k', 'long' : 'components',                   'fold' : 0},
-        \ {'short' : 't', 'long' : 'derived types and structures', 'fold' : 0},
-        \ {'short' : 'c', 'long' : 'common blocks',                'fold' : 0},
-        \ {'short' : 'b', 'long' : 'block data',                   'fold' : 0},
-        \ {'short' : 'e', 'long' : 'entry points',                 'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',                    'fold' : 0},
-        \ {'short' : 's', 'long' : 'subroutines',                  'fold' : 0},
-        \ {'short' : 'l', 'long' : 'labels',                       'fold' : 0},
-        \ {'short' : 'n', 'long' : 'namelists',                    'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',                    'fold' : 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 = {}
-    let type_html.ctagstype = 'html'
-    let type_html.kinds     = [
-        \ {'short' : 'f', 'long' : 'JavaScript funtions', 'fold' : 0},
-        \ {'short' : 'a', 'long' : 'named anchors',       'fold' : 0}
-    \ ]
-    let s:known_types.html = type_html
-    " Java {{{3
-    let type_java = {}
-    let type_java.ctagstype = 'java'
-    let type_java.kinds     = [
-        \ {'short' : 'p', 'long' : 'packages',       'fold' : 1},
-        \ {'short' : 'f', 'long' : 'fields',         'fold' : 0},
-        \ {'short' : 'g', 'long' : 'enum types',     'fold' : 0},
-        \ {'short' : 'e', 'long' : 'enum constants', 'fold' : 0},
-        \ {'short' : 'i', 'long' : 'interfaces',     'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',        'fold' : 0},
-        \ {'short' : 'm', 'long' : 'methods',        'fold' : 0}
-    \ ]
-    let type_java.sro        = '.'
-    let type_java.kind2scope = {
-        \ 'g' : 'enum',
-        \ 'i' : 'interface',
-        \ 'c' : 'class'
-    \ }
-    let type_java.scope2kind = {
-        \ 'enum'      : 'g',
-        \ 'interface' : 'i',
-        \ 'class'     : 'c'
-    \ }
-    let s:known_types.java = type_java
-    " JavaScript {{{3
-    " JavaScript is weird -- it does have scopes, but ctags doesn't seem to
-    " properly generate the information for them, instead it simply uses the
-    " complete name. So ctags has to be fixed before I can do anything here.
-    " Alternatively jsctags/doctorjs will be used if available.
-    let type_javascript = {}
-    let type_javascript.ctagstype = 'javascript'
-    let jsctags = s:CheckFTCtags('jsctags', 'javascript')
-    if jsctags != ''
-        let type_javascript.kinds = [
-            \ {'short' : 'v', 'long' : 'variables', 'fold' : 0},
-            \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
-        \ ]
-        let type_javascript.sro        = '.'
-        let type_javascript.kind2scope = {
-            \ 'v' : 'namespace',
-            \ 'f' : 'namespace'
-        \ }
-        let type_javascript.scope2kind = {
-            \ 'namespace' : 'v'
-        \ }
-        let type_javascript.ctagsbin   = jsctags
-        let type_javascript.ctagsargs  = '-f -'
-    else
-        let type_javascript.kinds = [
-            \ {'short' : 'v', 'long' : 'global variables', 'fold' : 0},
-            \ {'short' : 'c', 'long' : 'classes',          'fold' : 0},
-            \ {'short' : 'p', 'long' : 'properties',       'fold' : 0},
-            \ {'short' : 'm', 'long' : 'methods',          'fold' : 0},
-            \ {'short' : 'f', 'long' : 'functions',        'fold' : 0}
-        \ ]
-    endif
-    let s:known_types.javascript = type_javascript
-    " Lisp {{{3
-    let type_lisp = {}
-    let type_lisp.ctagstype = 'lisp'
-    let type_lisp.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
-    \ ]
-    let s:known_types.lisp = type_lisp
-    " Lua {{{3
-    let type_lua = {}
-    let type_lua.ctagstype = 'lua'
-    let type_lua.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
-    \ ]
-    let s:known_types.lua = type_lua
-    " Make {{{3
-    let type_make = {}
-    let type_make.ctagstype = 'make'
-    let type_make.kinds     = [
-        \ {'short' : 'm', 'long' : 'macros', 'fold' : 0}
-    \ ]
-    let s:known_types.make = type_make
-    " Matlab {{{3
-    let type_matlab = {}
-    let type_matlab.ctagstype = 'matlab'
-    let type_matlab.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
-    \ ]
-    let s:known_types.matlab = type_matlab
-    " Ocaml {{{3
-    let type_ocaml = {}
-    let type_ocaml.ctagstype = 'ocaml'
-    let type_ocaml.kinds     = [
-        \ {'short' : 'M', 'long' : 'modules or functors', 'fold' : 0},
-        \ {'short' : 'v', 'long' : 'global variables',    'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',             'fold' : 0},
-        \ {'short' : 'C', 'long' : 'constructors',        'fold' : 0},
-        \ {'short' : 'm', 'long' : 'methods',             'fold' : 0},
-        \ {'short' : 'e', 'long' : 'exceptions',          'fold' : 0},
-        \ {'short' : 't', 'long' : 'type names',          'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',           'fold' : 0},
-        \ {'short' : 'r', 'long' : 'structure fields',    'fold' : 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 = {}
-    let type_pascal.ctagstype = 'pascal'
-    let type_pascal.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions',  'fold' : 0},
-        \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0}
-    \ ]
-    let s:known_types.pascal = type_pascal
-    " Perl {{{3
-    let type_perl = {}
-    let type_perl.ctagstype = 'perl'
-    let type_perl.kinds     = [
-        \ {'short' : 'p', 'long' : 'packages',    'fold' : 1},
-        \ {'short' : 'c', 'long' : 'constants',   'fold' : 0},
-        \ {'short' : 'f', 'long' : 'formats',     'fold' : 0},
-        \ {'short' : 'l', 'long' : 'labels',      'fold' : 0},
-        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0}
-    \ ]
-    let s:known_types.perl = type_perl
-    " PHP {{{3
-    let type_php = {}
-    let type_php.ctagstype = 'php'
-    let type_php.kinds     = [
-        \ {'short' : 'i', 'long' : 'interfaces',           'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',              'fold' : 0},
-        \ {'short' : 'd', 'long' : 'constant definitions', 'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',            'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',            'fold' : 0},
-        \ {'short' : 'j', 'long' : 'javascript functions', 'fold' : 0}
-    \ ]
-    let s:known_types.php = type_php
-    " Python {{{3
-    let type_python = {}
-    let type_python.ctagstype = 'python'
-    let type_python.kinds     = [
-        \ {'short' : 'i', 'long' : 'imports',   'fold' : 1},
-        \ {'short' : 'c', 'long' : 'classes',   'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0},
-        \ {'short' : 'm', 'long' : 'members',   'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables', 'fold' : 0}
-    \ ]
-    let type_python.sro        = '.'
-    let type_python.kind2scope = {
-        \ 'c' : 'class',
-        \ 'f' : 'function',
-        \ 'm' : 'function'
-    \ }
-    let type_python.scope2kind = {
-        \ 'class'    : 'c',
-        \ 'function' : 'f'
-    \ }
-    let s:known_types.python = type_python
-    " REXX {{{3
-    let type_rexx = {}
-    let type_rexx.ctagstype = 'rexx'
-    let type_rexx.kinds     = [
-        \ {'short' : 's', 'long' : 'subroutines', 'fold' : 0}
-    \ ]
-    let s:known_types.rexx = type_rexx
-    " Ruby {{{3
-    let type_ruby = {}
-    let type_ruby.ctagstype = 'ruby'
-    let type_ruby.kinds     = [
-        \ {'short' : 'm', 'long' : 'modules',           'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',           'fold' : 0},
-        \ {'short' : 'f', 'long' : 'methods',           'fold' : 0},
-        \ {'short' : 'F', 'long' : 'singleton methods', 'fold' : 0}
-    \ ]
-    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 = {}
-    let type_scheme.ctagstype = 'scheme'
-    let type_scheme.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0},
-        \ {'short' : 's', 'long' : 'sets',      'fold' : 0}
-    \ ]
-    let s:known_types.scheme = type_scheme
-    " Shell script {{{3
-    let type_sh = {}
-    let type_sh.ctagstype = 'sh'
-    let type_sh.kinds     = [
-        \ {'short' : 'f', 'long' : 'functions', 'fold' : 0}
-    \ ]
-    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 = {}
-    let type_slang.ctagstype = 'slang'
-    let type_slang.kinds     = [
-        \ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',  'fold' : 0}
-    \ ]
-    let s:known_types.slang = type_slang
-    " SML {{{3
-    let type_sml = {}
-    let type_sml.ctagstype = 'sml'
-    let type_sml.kinds     = [
-        \ {'short' : 'e', 'long' : 'exception declarations', 'fold' : 0},
-        \ {'short' : 'f', 'long' : 'function definitions',   'fold' : 0},
-        \ {'short' : 'c', 'long' : 'functor definitions',    'fold' : 0},
-        \ {'short' : 's', 'long' : 'signature declarations', 'fold' : 0},
-        \ {'short' : 'r', 'long' : 'structure declarations', 'fold' : 0},
-        \ {'short' : 't', 'long' : 'type definitions',       'fold' : 0},
-        \ {'short' : 'v', 'long' : 'value bindings',         'fold' : 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 = {}
-    let type_sql.ctagstype = 'sql'
-    let type_sql.kinds     = [
-        \ {'short' : 'P', 'long' : 'packages',               'fold' : 1},
-        \ {'short' : 'c', 'long' : 'cursors',                'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',              'fold' : 0},
-        \ {'short' : 'F', 'long' : 'record fields',          'fold' : 0},
-        \ {'short' : 'L', 'long' : 'block label',            'fold' : 0},
-        \ {'short' : 'p', 'long' : 'procedures',             'fold' : 0},
-        \ {'short' : 's', 'long' : 'subtypes',               'fold' : 0},
-        \ {'short' : 't', 'long' : 'tables',                 'fold' : 0},
-        \ {'short' : 'T', 'long' : 'triggers',               'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',              'fold' : 0},
-        \ {'short' : 'i', 'long' : 'indexes',                'fold' : 0},
-        \ {'short' : 'e', 'long' : 'events',                 'fold' : 0},
-        \ {'short' : 'U', 'long' : 'publications',           'fold' : 0},
-        \ {'short' : 'R', 'long' : 'services',               'fold' : 0},
-        \ {'short' : 'D', 'long' : 'domains',                'fold' : 0},
-        \ {'short' : 'V', 'long' : 'views',                  'fold' : 0},
-        \ {'short' : 'n', 'long' : 'synonyms',               'fold' : 0},
-        \ {'short' : 'x', 'long' : 'MobiLink Table Scripts', 'fold' : 0},
-        \ {'short' : 'y', 'long' : 'MobiLink Conn Scripts',  'fold' : 0}
-    \ ]
-    let s:known_types.sql = type_sql
-    " Tcl {{{3
-    let type_tcl = {}
-    let type_tcl.ctagstype = 'tcl'
-    let type_tcl.kinds     = [
-        \ {'short' : 'c', 'long' : 'classes',    'fold' : 0},
-        \ {'short' : 'm', 'long' : 'methods',    'fold' : 0},
-        \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0}
-    \ ]
-    let s:known_types.tcl = type_tcl
-    " LaTeX {{{3
-    let type_tex = {}
-    let type_tex.ctagstype = 'tex'
-    let type_tex.kinds     = [
-        \ {'short' : 'p', 'long' : 'parts',          'fold' : 0},
-        \ {'short' : 'c', 'long' : 'chapters',       'fold' : 0},
-        \ {'short' : 's', 'long' : 'sections',       'fold' : 0},
-        \ {'short' : 'u', 'long' : 'subsections',    'fold' : 0},
-        \ {'short' : 'b', 'long' : 'subsubsections', 'fold' : 0},
-        \ {'short' : 'P', 'long' : 'paragraphs',     'fold' : 0},
-        \ {'short' : 'G', 'long' : 'subparagraphs',  'fold' : 0}
-    \ ]
-    let s:known_types.tex = type_tex
-    " Vera {{{3
-    " Why are variables 'virtual'?
-    let type_vera = {}
-    let type_vera.ctagstype = 'vera'
-    let type_vera.kinds     = [
-        \ {'short' : 'd', 'long' : 'macros',      'fold' : 1},
-        \ {'short' : 'g', 'long' : 'enums',       'fold' : 0},
-        \ {'short' : 'T', 'long' : 'typedefs',    'fold' : 0},
-        \ {'short' : 'c', 'long' : 'classes',     'fold' : 0},
-        \ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0},
-        \ {'short' : 'm', 'long' : 'members',     'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',   'fold' : 0},
-        \ {'short' : 't', 'long' : 'tasks',       'fold' : 0},
-        \ {'short' : 'v', 'long' : 'variables',   'fold' : 0},
-        \ {'short' : 'p', 'long' : 'programs',    'fold' : 0}
-    \ ]
-    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 = {}
-    let type_verilog.ctagstype = 'verilog'
-    let type_verilog.kinds     = [
-        \ {'short' : 'c', 'long' : 'constants',           'fold' : 0},
-        \ {'short' : 'e', 'long' : 'events',              'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',           'fold' : 0},
-        \ {'short' : 'm', 'long' : 'modules',             'fold' : 0},
-        \ {'short' : 'n', 'long' : 'net data types',      'fold' : 0},
-        \ {'short' : 'p', 'long' : 'ports',               'fold' : 0},
-        \ {'short' : 'r', 'long' : 'register data types', 'fold' : 0},
-        \ {'short' : 't', 'long' : 'tasks',               'fold' : 0}
-    \ ]
-    let s:known_types.verilog = type_verilog
-    " VHDL {{{3
-    " The VHDL ctags parser unfortunately doesn't generate proper scopes
-    let type_vhdl = {}
-    let type_vhdl.ctagstype = 'vhdl'
-    let type_vhdl.kinds     = [
-        \ {'short' : 'P', 'long' : 'packages',   'fold' : 1},
-        \ {'short' : 'c', 'long' : 'constants',  'fold' : 0},
-        \ {'short' : 't', 'long' : 'types',      'fold' : 0},
-        \ {'short' : 'T', 'long' : 'subtypes',   'fold' : 0},
-        \ {'short' : 'r', 'long' : 'records',    'fold' : 0},
-        \ {'short' : 'e', 'long' : 'entities',   'fold' : 0},
-        \ {'short' : 'f', 'long' : 'functions',  'fold' : 0},
-        \ {'short' : 'p', 'long' : 'procedures', 'fold' : 0}
-    \ ]
-    let s:known_types.vhdl = type_vhdl
-    " Vim {{{3
-    let type_vim = {}
-    let type_vim.ctagstype = 'vim'
-    let type_vim.kinds     = [
-        \ {'short' : 'v', 'long' : 'variables',          'fold' : 1},
-        \ {'short' : 'f', 'long' : 'functions',          'fold' : 0},
-        \ {'short' : 'a', 'long' : 'autocommand groups', 'fold' : 1},
-        \ {'short' : 'c', 'long' : 'commands',           'fold' : 0},
-        \ {'short' : 'm', 'long' : 'maps',               'fold' : 1}
-    \ ]
-    let s:known_types.vim = type_vim
-    " YACC {{{3
-    let type_yacc = {}
-    let type_yacc.ctagstype = 'yacc'
-    let type_yacc.kinds     = [
-        \ {'short' : 'l', 'long' : 'labels', 'fold' : 0}
-    \ ]
-    let s:known_types.yacc = type_yacc
-    " }}}3
-
-    let user_defs = s:GetUserTypeDefs()
-    for [key, value] in items(user_defs)
-        if !has_key(s:known_types, key) ||
-         \ (has_key(value, 'replace') && value.replace)
-            let s:known_types[key] = value
-        else
-            call extend(s:known_types[key], value)
-        endif
-    endfor
-
-    " Create a dictionary of the kind order for fast
-    " access in sorting functions
-    for type in values(s:known_types)
-        let i = 0
-        let type.kinddict = {}
-        for kind in type.kinds
-            let type.kinddict[kind.short] = i
-            let i += 1
-        endfor
-    endfor
-
-    let s:type_init_done = 1
-endfunction
-
-" s:GetUserTypeDefs() {{{2
-function! s:GetUserTypeDefs()
-    call s:LogDebugMessage('Initializing user types')
-
-    redir => defs
-    silent execute 'let g:'
-    redir END
-
-    let deflist = split(defs, '\n')
-    call map(deflist, 'substitute(v:val, ''^\S\+\zs.*'', "", "")')
-    call filter(deflist, 'v:val =~ "^tagbar_type_"')
-
-    let defdict = {}
-    for defstr in deflist
-        let type = substitute(defstr, '^tagbar_type_', '', '')
-        execute 'let defdict["' . type . '"] = g:' . defstr
-    endfor
-
-    " If the user only specified one of kind2scope and scope2kind use it to
-    " generate the other one
-    " Also, transform the 'kind' definitions into dictionary format
-    for def in values(defdict)
-        if has_key(def, 'kinds')
-            let kinds = def.kinds
-            let def.kinds = []
-            for kind in kinds
-                let kindlist = split(kind, ':')
-                let kinddict = {'short' : kindlist[0], 'long' : kindlist[1]}
-                if len(kindlist) == 3
-                    let kinddict.fold = kindlist[2]
-                else
-                    let kinddict.fold = 0
-                endif
-                call add(def.kinds, kinddict)
-            endfor
-        endif
-
-        if has_key(def, 'kind2scope') && !has_key(def, 'scope2kind')
-            let def.scope2kind = {}
-            for [key, value] in items(def.kind2scope)
-                let def.scope2kind[value] = key
-            endfor
-        elseif has_key(def, 'scope2kind') && !has_key(def, 'kind2scope')
-            let def.kind2scope = {}
-            for [key, value] in items(def.scope2kind)
-                let def.kind2scope[value] = key
-            endfor
-        endif
-    endfor
-
-    return defdict
-endfunction
-
-" s:RestoreSession() {{{2
-" Properly restore Tagbar after a session got loaded
-function! s:RestoreSession()
-    call s:LogDebugMessage('Restoring session')
-
-    let tagbarwinnr = bufwinnr('__Tagbar__')
-    if tagbarwinnr == -1
-        " Tagbar wasn't open in the saved session, nothing to do
-        return
-    else
-        let in_tagbar = 1
-        if winnr() != tagbarwinnr
-            execute tagbarwinnr . 'wincmd w'
-            let in_tagbar = 0
-        endif
-    endif
-
-    call s:Init()
-
-    call s:InitWindow(g:tagbar_autoclose)
-
-    " Leave the Tagbar window and come back so the update event gets triggered
-    wincmd p
-    execute tagbarwinnr . 'wincmd w'
-
-    if !in_tagbar
-        wincmd p
-    endif
-endfunction
-
-" s:MapKeys() {{{2
-function! s:MapKeys()
-    call s:LogDebugMessage('Mapping keys')
-
-    nnoremap <script> <silent> <buffer> <2-LeftMouse>
-                                              \ :call <SID>JumpToTag(0)<CR>
-    nnoremap <script> <silent> <buffer> <LeftRelease>
-                                 \ <LeftRelease>:call <SID>CheckMouseClick()<CR>
-
-    inoremap <script> <silent> <buffer> <2-LeftMouse>
-                                              \ <C-o>:call <SID>JumpToTag(0)<CR>
-    inoremap <script> <silent> <buffer> <LeftRelease>
-                            \ <LeftRelease><C-o>:call <SID>CheckMouseClick()<CR>
-
-    nnoremap <script> <silent> <buffer> <CR>    :call <SID>JumpToTag(0)<CR>
-    nnoremap <script> <silent> <buffer> p       :call <SID>JumpToTag(1)<CR>
-    nnoremap <script> <silent> <buffer> <Space> :call <SID>ShowPrototype()<CR>
-
-    nnoremap <script> <silent> <buffer> +        :call <SID>OpenFold()<CR>
-    nnoremap <script> <silent> <buffer> <kPlus>  :call <SID>OpenFold()<CR>
-    nnoremap <script> <silent> <buffer> zo       :call <SID>OpenFold()<CR>
-    nnoremap <script> <silent> <buffer> -        :call <SID>CloseFold()<CR>
-    nnoremap <script> <silent> <buffer> <kMinus> :call <SID>CloseFold()<CR>
-    nnoremap <script> <silent> <buffer> zc       :call <SID>CloseFold()<CR>
-    nnoremap <script> <silent> <buffer> o        :call <SID>ToggleFold()<CR>
-    nnoremap <script> <silent> <buffer> za       :call <SID>ToggleFold()<CR>
-
-    nnoremap <script> <silent> <buffer> *    :call <SID>SetFoldLevel(99)<CR>
-    nnoremap <script> <silent> <buffer> <kMultiply>
-                                           \ :call <SID>SetFoldLevel(99)<CR>
-    nnoremap <script> <silent> <buffer> zR   :call <SID>SetFoldLevel(99)<CR>
-    nnoremap <script> <silent> <buffer> =    :call <SID>SetFoldLevel(0)<CR>
-    nnoremap <script> <silent> <buffer> zM   :call <SID>SetFoldLevel(0)<CR>
-
-    nnoremap <script> <silent> <buffer> <C-N>
-                                        \ :call <SID>GotoNextToplevelTag(1)<CR>
-    nnoremap <script> <silent> <buffer> <C-P>
-                                        \ :call <SID>GotoNextToplevelTag(-1)<CR>
-
-    nnoremap <script> <silent> <buffer> s    :call <SID>ToggleSort()<CR>
-    nnoremap <script> <silent> <buffer> x    :call <SID>ZoomWindow()<CR>
-    nnoremap <script> <silent> <buffer> q    :call <SID>CloseWindow()<CR>
-    nnoremap <script> <silent> <buffer> <F1> :call <SID>ToggleHelp()<CR>
-endfunction
-
-" s:CreateAutocommands() {{{2
-function! s:CreateAutocommands()
-    call s:LogDebugMessage('Creating autocommands')
-
-    augroup TagbarAutoCmds
-        autocmd!
-        autocmd BufEnter   __Tagbar__ nested call s:QuitIfOnlyWindow()
-        autocmd BufUnload  __Tagbar__ call s:CleanUp()
-        autocmd CursorHold __Tagbar__ call s:ShowPrototype()
-
-        autocmd BufWritePost *
-            \ if line('$') < g:tagbar_updateonsave_maxlines |
-                \ call s:AutoUpdate(fnamemodify(expand('<afile>'), ':p')) |
-            \ endif
-        autocmd BufEnter,CursorHold,FileType * call
-                    \ s:AutoUpdate(fnamemodify(expand('<afile>'), ':p'))
-        autocmd BufDelete * call
-                    \ s:CleanupFileinfo(fnamemodify(expand('<afile>'), ':p'))
-    augroup END
-
-    let s:autocommands_done = 1
-endfunction
-
-" s:CheckForExCtags() {{{2
-" Test whether the ctags binary is actually Exuberant Ctags and not GNU ctags
-" (or something else)
-function! s:CheckForExCtags()
-    call s:LogDebugMessage('Checking for Exuberant Ctags')
-
-    let ctags_cmd = s:EscapeCtagsCmd(g:tagbar_ctags_bin, '--version')
-    if ctags_cmd == ''
-        return
-    endif
-
-    let ctags_output = s:ExecuteCtags(ctags_cmd)
-
-    if v:shell_error || ctags_output !~# 'Exuberant Ctags'
-        echoerr 'Tagbar: Ctags doesn''t seem to be Exuberant Ctags!'
-        echomsg 'GNU ctags will NOT WORK.'
-              \ 'Please download Exuberant Ctags from ctags.sourceforge.net'
-              \ 'and install it in a directory in your $PATH'
-              \ 'or set g:tagbar_ctags_bin.'
-        echomsg 'Executed command: "' . ctags_cmd . '"'
-        if !empty(ctags_output)
-            echomsg 'Command output:'
-            for line in split(ctags_output, '\n')
-                echomsg line
-            endfor
-        endif
-        return 0
-    elseif !s:CheckExCtagsVersion(ctags_output)
-        echoerr 'Tagbar: Exuberant Ctags is too old!'
-        echomsg 'You need at least version 5.5 for Tagbar to work.'
-              \ 'Please download a newer version from ctags.sourceforge.net.'
-        echomsg 'Executed command: "' . ctags_cmd . '"'
-        if !empty(ctags_output)
-            echomsg 'Command output:'
-            for line in split(ctags_output, '\n')
-                echomsg line
-            endfor
-        endif
-        return 0
-    else
-        let s:checked_ctags = 1
-        return 1
-    endif
-endfunction
-
-" s:CheckExCtagsVersion() {{{2
-function! s:CheckExCtagsVersion(output)
-    call s:LogDebugMessage('Checking Exuberant Ctags version')
-
-    if a:output =~ 'Exuberant Ctags Development'
-        return 1
-    endif
-
-    let matchlist = matchlist(a:output, '\vExuberant Ctags (\d+)\.(\d+)')
-    let major     = matchlist[1]
-    let minor     = matchlist[2]
-
-    return major >= 6 || (major == 5 && minor >= 5)
-endfunction
-
-" s:CheckFTCtags() {{{2
-function! s:CheckFTCtags(bin, ftype)
-    if executable(a:bin)
-        return a:bin
-    endif
-
-    if exists('g:tagbar_type_' . a:ftype)
-        execute 'let userdef = ' . 'g:tagbar_type_' . a:ftype
-        if has_key(userdef, 'ctagsbin')
-            return userdef.ctagsbin
-        else
-            return ''
-        endif
-    endif
-
-    return ''
-endfunction
-
-" Prototypes {{{1
-" Base tag {{{2
-let s:BaseTag = {}
-
-" s:BaseTag._init() {{{3
-function! s:BaseTag._init(name) dict
-    let self.name        = a:name
-    let self.fields      = {}
-    let self.fields.line = 0
-    let self.path        = ''
-    let self.fullpath    = a:name
-    let self.depth       = 0
-    let self.parent      = {}
-    let self.tline       = -1
-    let self.fileinfo    = {}
-endfunction
-
-" s:BaseTag.isNormalTag() {{{3
-function! s:BaseTag.isNormalTag() dict
-    return 0
-endfunction
-
-" s:BaseTag.isPseudoTag() {{{3
-function! s:BaseTag.isPseudoTag() dict
-    return 0
-endfunction
-
-" s:BaseTag.isKindheader() {{{3
-function! s:BaseTag.isKindheader() dict
-    return 0
-endfunction
-
-" s:BaseTag.getPrototype() {{{3
-function! s:BaseTag.getPrototype() dict
-    return ''
-endfunction
-
-" s:BaseTag._getPrefix() {{{3
-function! s:BaseTag._getPrefix() dict
-    let fileinfo = self.fileinfo
-
-    if has_key(self, 'children') && !empty(self.children)
-        if fileinfo.tagfolds[self.fields.kind][self.fullpath]
-            let prefix = s:icon_closed
-        else
-            let prefix = s:icon_open
-        endif
-    else
-        let prefix = ' '
-    endif
-    if has_key(self.fields, 'access')
-        let prefix .= get(s:access_symbols, self.fields.access, ' ')
-    else
-        let prefix .= ' '
-    endif
-
-    return prefix
-endfunction
-
-" s:BaseTag.initFoldState() {{{3
-function! s:BaseTag.initFoldState() dict
-    let fileinfo = self.fileinfo
-
-    if s:known_files.has(fileinfo.fpath) &&
-     \ 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() dict
-    let tagline = self.tline
-    let fileinfo = self.fileinfo
-
-    let parent = self.parent
-    while !empty(parent)
-        if parent.isFolded()
-            let tagline = parent.tline
-            break
-        endif
-        let parent = parent.parent
-    endwhile
-
-    return tagline
-endfunction
-
-" s:BaseTag.isFoldable() {{{3
-function! s:BaseTag.isFoldable() dict
-    return has_key(self, 'children') && !empty(self.children)
-endfunction
-
-" s:BaseTag.isFolded() {{{3
-function! s:BaseTag.isFolded() dict
-    return self.fileinfo.tagfolds[self.fields.kind][self.fullpath]
-endfunction
-
-" s:BaseTag.openFold() {{{3
-function! s:BaseTag.openFold() dict
-    if self.isFoldable()
-        let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = 0
-    endif
-endfunction
-
-" s:BaseTag.closeFold() {{{3
-function! s:BaseTag.closeFold() 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) dict
-    let self.fileinfo.tagfolds[self.fields.kind][self.fullpath] = a:folded
-endfunction
-
-" s:BaseTag.openParents() {{{3
-function! s:BaseTag.openParents() dict
-    let parent = self.parent
-
-    while !empty(parent)
-        call parent.openFold()
-        let parent = parent.parent
-    endwhile
-endfunction
-
-" Normal tag {{{2
-let s:NormalTag = copy(s:BaseTag)
-
-" s:NormalTag.New() {{{3
-function! s:NormalTag.New(name) dict
-    let newobj = copy(self)
-
-    call newobj._init(a:name)
-
-    return newobj
-endfunction
-
-" s:NormalTag.isNormalTag() {{{3
-function! s:NormalTag.isNormalTag() dict
-    return 1
-endfunction
-
-" s:NormalTag.str() {{{3
-function! s:NormalTag.str() dict
-    let fileinfo = self.fileinfo
-    let typeinfo = s:known_types[fileinfo.ftype]
-
-    let suffix = get(self.fields, 'signature', '')
-    if has_key(self.fields, 'type')
-        let suffix .= ' : ' . self.fields.type
-    elseif has_key(typeinfo, 'kind2scope') &&
-         \ has_key(typeinfo.kind2scope, self.fields.kind)
-        let suffix .= ' : ' . typeinfo.kind2scope[self.fields.kind]
-    endif
-
-    return self._getPrefix() . self.name . suffix . "\n"
-endfunction
-
-" s:NormalTag.getPrototype() {{{3
-function! s:NormalTag.getPrototype() dict
-    return self.prototype
-endfunction
-
-" Pseudo tag {{{2
-let s:PseudoTag = copy(s:BaseTag)
-
-" s:PseudoTag.New() {{{3
-function! s:PseudoTag.New(name) dict
-    let newobj = copy(self)
-
-    call newobj._init(a:name)
-
-    return newobj
-endfunction
-
-" s:PseudoTag.isPseudoTag() {{{3
-function! s:PseudoTag.isPseudoTag() dict
-    return 1
-endfunction
-
-" s:PseudoTag.str() {{{3
-function! s:PseudoTag.str() dict
-    let fileinfo = self.fileinfo
-    let typeinfo = s:known_types[fileinfo.ftype]
-
-    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.New() {{{3
-function! s:KindheaderTag.New(name) dict
-    let newobj = copy(self)
-
-    call newobj._init(a:name)
-
-    return newobj
-endfunction
-
-" s:KindheaderTag.isKindheader() {{{3
-function! s:KindheaderTag.isKindheader() dict
-    return 1
-endfunction
-
-" s:KindheaderTag.getPrototype() {{{3
-function! s:KindheaderTag.getPrototype() dict
-    return self.name . ': ' .
-         \ self.numtags . ' ' . (self.numtags > 1 ? 'tags' : 'tag')
-endfunction
-
-" s:KindheaderTag.isFoldable() {{{3
-function! s:KindheaderTag.isFoldable() dict
-    return 1
-endfunction
-
-" s:KindheaderTag.isFolded() {{{3
-function! s:KindheaderTag.isFolded() dict
-    return self.fileinfo.kindfolds[self.short]
-endfunction
-
-" s:KindheaderTag.openFold() {{{3
-function! s:KindheaderTag.openFold() dict
-    let self.fileinfo.kindfolds[self.short] = 0
-endfunction
-
-" s:KindheaderTag.closeFold() {{{3
-function! s:KindheaderTag.closeFold() dict
-    let self.fileinfo.kindfolds[self.short] = 1
-    return line('.')
-endfunction
-
-" s:KindheaderTag.toggleFold() {{{3
-function! s:KindheaderTag.toggleFold() dict
-    let fileinfo = s:known_files.getCurrent()
-
-    let fileinfo.kindfolds[self.short] = !fileinfo.kindfolds[self.short]
-endfunction
-
-" File info {{{2
-let s:FileInfo = {}
-
-" s:FileInfo.New() {{{3
-function! s:FileInfo.New(fname, ftype) dict
-    let newobj = copy(self)
-
-    " The complete file path
-    let newobj.fpath = 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.tags = []
-
-    " 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 typeinfo = s:known_types[a:ftype]
-    " copy the default fold state from the type info
-    for kind in 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 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.reset() {{{3
-" Reset stuff that gets regenerated while processing a file and save the old
-" tag folds
-function! s:FileInfo.reset() dict
-    let self.mtime = getftime(self.fpath)
-    let self.tags  = []
-    let self.fline = {}
-    let self.tline = {}
-
-    let self._tagfolds_old = self.tagfolds
-    let self.tagfolds = {}
-
-    let typeinfo = s:known_types[self.ftype]
-    for kind in typeinfo.kinds
-        let self.tagfolds[kind.short] = {}
-    endfor
-endfunction
-
-" s:FileInfo.clearOldFolds() {{{3
-function! s:FileInfo.clearOldFolds() dict
-    if exists('self._tagfolds_old')
-        unlet self._tagfolds_old
-    endif
-endfunction
-
-" s:FileInfo.sortTags() {{{3
-function! s:FileInfo.sortTags() dict
-    if has_key(s:compare_typeinfo, 'sort')
-        if s:compare_typeinfo.sort
-            call s:SortTags(self.tags, 's:CompareByKind')
-        else
-            call s:SortTags(self.tags, 's:CompareByLine')
-        endif
-    elseif g:tagbar_sort
-        call s:SortTags(self.tags, 's:CompareByKind')
-    else
-        call s:SortTags(self.tags, 's:CompareByLine')