Update 2023-08-19 11:12 OpenBSD/amd64-x13
This commit is contained in:
c0dev0id
3508
.vim/bundle/vim-tagbar/autoload/tagbar.vim
Normal file
3508
.vim/bundle/vim-tagbar/autoload/tagbar.vim
Normal file
File diff suppressed because it is too large
Load Diff
62
.vim/bundle/vim-tagbar/autoload/tagbar/debug.vim
Normal file
62
.vim/bundle/vim-tagbar/autoload/tagbar/debug.vim
Normal file
@@ -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 = ''
|
||||
237
.vim/bundle/vim-tagbar/autoload/tagbar/prototypes/basetag.vim
Normal file
237
.vim/bundle/vim-tagbar/autoload/tagbar/prototypes/basetag.vim
Normal file
@@ -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
|
||||
146
.vim/bundle/vim-tagbar/autoload/tagbar/prototypes/fileinfo.vim
Normal file
146
.vim/bundle/vim-tagbar/autoload/tagbar/prototypes/fileinfo.vim
Normal file
@@ -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
|
||||
@@ -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
|
||||
119
.vim/bundle/vim-tagbar/autoload/tagbar/prototypes/normaltag.vim
Normal file
119
.vim/bundle/vim-tagbar/autoload/tagbar/prototypes/normaltag.vim
Normal file
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
57
.vim/bundle/vim-tagbar/autoload/tagbar/sorting.vim
Normal file
57
.vim/bundle/vim-tagbar/autoload/tagbar/sorting.vim
Normal file
@@ -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
|
||||
51
.vim/bundle/vim-tagbar/autoload/tagbar/state.vim
Normal file
51
.vim/bundle/vim-tagbar/autoload/tagbar/state.vim
Normal file
@@ -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
|
||||
773
.vim/bundle/vim-tagbar/autoload/tagbar/types/ctags.vim
Normal file
773
.vim/bundle/vim-tagbar/autoload/tagbar/types/ctags.vim
Normal file
@@ -0,0 +1,773 @@
|
||||
" Type definitions for standard Exuberant Ctags
|
||||
|
||||
function! tagbar#types#ctags#init(supported_types) abort
|
||||
let types = {}
|
||||
|
||||
" Ant {{{1
|
||||
let type_ant = tagbar#prototypes#typeinfo#new()
|
||||
let type_ant.ctagstype = 'ant'
|
||||
let type_ant.kinds = [
|
||||
\ {'short' : 'p', 'long' : 'projects', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'targets', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.ant = type_ant
|
||||
" Asm {{{1
|
||||
let type_asm = tagbar#prototypes#typeinfo#new()
|
||||
let type_asm.ctagstype = 'asm'
|
||||
let type_asm.kinds = [
|
||||
\ {'short' : 'm', 'long' : 'macros', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'd', 'long' : 'defines', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.asm = type_asm
|
||||
" ASP {{{1
|
||||
let type_aspvbs = tagbar#prototypes#typeinfo#new()
|
||||
let type_aspvbs.ctagstype = 'asp'
|
||||
let type_aspvbs.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'constants', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.aspvbs = type_aspvbs
|
||||
" Asymptote {{{1
|
||||
" Asymptote gets parsed well using filetype = c
|
||||
let type_asy = tagbar#prototypes#typeinfo#new()
|
||||
let type_asy.ctagstype = 'c'
|
||||
let type_asy.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'p', 'long' : 'prototypes', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'u', 'long' : 'unions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_asy.sro = '::'
|
||||
let type_asy.kind2scope = {
|
||||
\ 'g' : 'enum',
|
||||
\ 's' : 'struct',
|
||||
\ 'u' : 'union'
|
||||
\ }
|
||||
let type_asy.scope2kind = {
|
||||
\ 'enum' : 'g',
|
||||
\ 'struct' : 's',
|
||||
\ 'union' : 'u'
|
||||
\ }
|
||||
let types.asy = type_asy
|
||||
" Awk {{{1
|
||||
let type_awk = tagbar#prototypes#typeinfo#new()
|
||||
let type_awk.ctagstype = 'awk'
|
||||
let type_awk.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.awk = type_awk
|
||||
" Basic {{{1
|
||||
let type_basic = tagbar#prototypes#typeinfo#new()
|
||||
let type_basic.ctagstype = 'basic'
|
||||
let type_basic.kinds = [
|
||||
\ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'g', 'long' : 'enumerations', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.basic = type_basic
|
||||
" BETA {{{1
|
||||
let type_beta = tagbar#prototypes#typeinfo#new()
|
||||
let type_beta.ctagstype = 'beta'
|
||||
let type_beta.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'fragments', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'slots', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'patterns', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.beta = type_beta
|
||||
" C {{{1
|
||||
let type_c = tagbar#prototypes#typeinfo#new()
|
||||
let type_c.ctagstype = 'c'
|
||||
let type_c.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'p', 'long' : 'prototypes', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'u', 'long' : 'unions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_c.sro = '::'
|
||||
let type_c.kind2scope = {
|
||||
\ 'g' : 'enum',
|
||||
\ 's' : 'struct',
|
||||
\ 'u' : 'union'
|
||||
\ }
|
||||
let type_c.scope2kind = {
|
||||
\ 'enum' : 'g',
|
||||
\ 'struct' : 's',
|
||||
\ 'union' : 'u'
|
||||
\ }
|
||||
let types.c = type_c
|
||||
" C++ {{{1
|
||||
let type_cpp = tagbar#prototypes#typeinfo#new()
|
||||
let type_cpp.ctagstype = 'c++'
|
||||
let type_cpp.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'p', 'long' : 'prototypes', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'u', 'long' : 'unions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_cpp.sro = '::'
|
||||
let type_cpp.kind2scope = {
|
||||
\ 'g' : 'enum',
|
||||
\ 'n' : 'namespace',
|
||||
\ 'c' : 'class',
|
||||
\ 's' : 'struct',
|
||||
\ 'u' : 'union'
|
||||
\ }
|
||||
let type_cpp.scope2kind = {
|
||||
\ 'enum' : 'g',
|
||||
\ 'namespace' : 'n',
|
||||
\ 'class' : 'c',
|
||||
\ 'struct' : 's',
|
||||
\ 'union' : 'u'
|
||||
\ }
|
||||
let types.cpp = type_cpp
|
||||
let types.cuda = type_cpp
|
||||
" C# {{{1
|
||||
let type_cs = tagbar#prototypes#typeinfo#new()
|
||||
let type_cs.ctagstype = 'c#'
|
||||
let type_cs.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'fields', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'typedefs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'E', 'long' : 'events', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'properties', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_cs.sro = '.'
|
||||
let type_cs.kind2scope = {
|
||||
\ 'n' : 'namespace',
|
||||
\ 'i' : 'interface',
|
||||
\ 'c' : 'class',
|
||||
\ 's' : 'struct',
|
||||
\ 'g' : 'enum'
|
||||
\ }
|
||||
let type_cs.scope2kind = {
|
||||
\ 'namespace' : 'n',
|
||||
\ 'interface' : 'i',
|
||||
\ 'class' : 'c',
|
||||
\ 'struct' : 's',
|
||||
\ 'enum' : 'g'
|
||||
\ }
|
||||
let types.cs = type_cs
|
||||
" COBOL {{{1
|
||||
let type_cobol = tagbar#prototypes#typeinfo#new()
|
||||
let type_cobol.ctagstype = 'cobol'
|
||||
let type_cobol.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'data items', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'file descriptions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'g', 'long' : 'group items', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'paragraphs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'P', 'long' : 'program ids', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'sections', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.cobol = type_cobol
|
||||
" DOS Batch {{{1
|
||||
let type_dosbatch = tagbar#prototypes#typeinfo#new()
|
||||
let type_dosbatch.ctagstype = 'dosbatch'
|
||||
let type_dosbatch.kinds = [
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.dosbatch = type_dosbatch
|
||||
" Eiffel {{{1
|
||||
let type_eiffel = tagbar#prototypes#typeinfo#new()
|
||||
let type_eiffel.ctagstype = 'eiffel'
|
||||
let type_eiffel.kinds = [
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'features', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_eiffel.sro = '.' " Not sure, is nesting even possible?
|
||||
let type_eiffel.kind2scope = {
|
||||
\ 'c' : 'class',
|
||||
\ 'f' : 'feature'
|
||||
\ }
|
||||
let type_eiffel.scope2kind = {
|
||||
\ 'class' : 'c',
|
||||
\ 'feature' : 'f'
|
||||
\ }
|
||||
let types.eiffel = type_eiffel
|
||||
" Erlang {{{1
|
||||
let type_erlang = tagbar#prototypes#typeinfo#new()
|
||||
let type_erlang.ctagstype = 'erlang'
|
||||
let type_erlang.kinds = [
|
||||
\ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'd', 'long' : 'macro definitions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'r', 'long' : 'record definitions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_erlang.sro = '.' " Not sure, is nesting even possible?
|
||||
let type_erlang.kind2scope = {
|
||||
\ 'm' : 'module'
|
||||
\ }
|
||||
let type_erlang.scope2kind = {
|
||||
\ 'module' : 'm'
|
||||
\ }
|
||||
let types.erlang = type_erlang
|
||||
" Flex {{{1
|
||||
" Vim doesn't support Flex out of the box, this is based on rough
|
||||
" guesses and probably requires
|
||||
" http://www.vim.org/scripts/script.php?script_id=2909
|
||||
" Improvements welcome!
|
||||
let type_as = tagbar#prototypes#typeinfo#new()
|
||||
let type_as.ctagstype = 'flex'
|
||||
let type_as.kinds = [
|
||||
\ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'properties', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'x', 'long' : 'mxtags', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_as.sro = '.'
|
||||
let type_as.kind2scope = {
|
||||
\ 'c' : 'class'
|
||||
\ }
|
||||
let type_as.scope2kind = {
|
||||
\ 'class' : 'c'
|
||||
\ }
|
||||
let types.mxml = type_as
|
||||
let types.actionscript = type_as
|
||||
" Fortran {{{1
|
||||
let type_fortran = tagbar#prototypes#typeinfo#new()
|
||||
let type_fortran.ctagstype = 'fortran'
|
||||
let type_fortran.kinds = [
|
||||
\ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'programs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'k', 'long' : 'components', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'derived types and structures', 'fold' : 0,
|
||||
\ 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'common blocks', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'b', 'long' : 'block data', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'e', 'long' : 'entry points', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'n', 'long' : 'namelists', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_fortran.sro = '.' " Not sure, is nesting even possible?
|
||||
let type_fortran.kind2scope = {
|
||||
\ 'm' : 'module',
|
||||
\ 'p' : 'program',
|
||||
\ 'f' : 'function',
|
||||
\ 's' : 'subroutine'
|
||||
\ }
|
||||
let type_fortran.scope2kind = {
|
||||
\ 'module' : 'm',
|
||||
\ 'program' : 'p',
|
||||
\ 'function' : 'f',
|
||||
\ 'subroutine' : 's'
|
||||
\ }
|
||||
let types.fortran = type_fortran
|
||||
" Go {{{1
|
||||
let type_go = tagbar#prototypes#typeinfo#new()
|
||||
let type_go.ctagstype = 'go'
|
||||
let type_go.kinds = [
|
||||
\ {'short' : 'p', 'long' : 'packages', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 's', 'long' : 'structs', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'struct members', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_go.sro = '.'
|
||||
let type_go.kind2scope = {
|
||||
\ 's' : 'struct'
|
||||
\ }
|
||||
let type_go.scope2kind = {
|
||||
\ 'struct' : 's'
|
||||
\ }
|
||||
let types.go = type_go
|
||||
" HTML {{{1
|
||||
let type_html = tagbar#prototypes#typeinfo#new()
|
||||
let type_html.ctagstype = 'html'
|
||||
let type_html.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'JavaScript functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'a', 'long' : 'named anchors', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.html = type_html
|
||||
" Java {{{1
|
||||
let type_java = tagbar#prototypes#typeinfo#new()
|
||||
let type_java.ctagstype = 'java'
|
||||
let type_java.kinds = [
|
||||
\ {'short' : 'p', 'long' : 'packages', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'fields', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'g', 'long' : 'enum types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enum constants', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_java.sro = '.'
|
||||
let type_java.kind2scope = {
|
||||
\ 'g' : 'enum',
|
||||
\ 'i' : 'interface',
|
||||
\ 'c' : 'class'
|
||||
\ }
|
||||
let type_java.scope2kind = {
|
||||
\ 'enum' : 'g',
|
||||
\ 'interface' : 'i',
|
||||
\ 'class' : 'c'
|
||||
\ }
|
||||
let types.java = type_java
|
||||
" JavaScript {{{1
|
||||
let type_javascript = tagbar#prototypes#typeinfo#new()
|
||||
let type_javascript.ctagstype = 'javascript'
|
||||
let type_javascript.kinds = [
|
||||
\ {'short': 'v', 'long': 'global variables', 'fold': 0, 'stl': 0},
|
||||
\ {'short': 'c', 'long': 'classes', 'fold': 0, 'stl': 1},
|
||||
\ {'short': 'p', 'long': 'properties', 'fold': 0, 'stl': 0},
|
||||
\ {'short': 'm', 'long': 'methods', 'fold': 0, 'stl': 1},
|
||||
\ {'short': 'f', 'long': 'functions', 'fold': 0, 'stl': 1},
|
||||
\ ]
|
||||
let type_javascript.sro = '.'
|
||||
let type_javascript.kind2scope = {
|
||||
\ 'c' : 'class',
|
||||
\ 'f' : 'function',
|
||||
\ 'm' : 'method',
|
||||
\ 'p' : 'property',
|
||||
\ }
|
||||
let type_javascript.scope2kind = {
|
||||
\ 'class' : 'c',
|
||||
\ 'function' : 'f',
|
||||
\ }
|
||||
let types.javascript = type_javascript
|
||||
" Lisp {{{1
|
||||
let type_lisp = tagbar#prototypes#typeinfo#new()
|
||||
let type_lisp.ctagstype = 'lisp'
|
||||
let type_lisp.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.lisp = type_lisp
|
||||
let types.clojure = type_lisp
|
||||
" Lua {{{1
|
||||
let type_lua = tagbar#prototypes#typeinfo#new()
|
||||
let type_lua.ctagstype = 'lua'
|
||||
let type_lua.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.lua = type_lua
|
||||
" Make {{{1
|
||||
let type_make = tagbar#prototypes#typeinfo#new()
|
||||
let type_make.ctagstype = 'make'
|
||||
let type_make.kinds = [
|
||||
\ {'short' : 'm', 'long' : 'macros', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.make = type_make
|
||||
" Matlab {{{1
|
||||
let type_matlab = tagbar#prototypes#typeinfo#new()
|
||||
let type_matlab.ctagstype = 'matlab'
|
||||
let type_matlab.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.matlab = type_matlab
|
||||
" ObjectiveC {{{1
|
||||
let type_objc = tagbar#prototypes#typeinfo#new()
|
||||
let type_objc.ctagstype = 'objectivec'
|
||||
let type_objc.kinds = [
|
||||
\ {'short' : 'M', 'long' : 'preprocessor macros', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'i', 'long' : 'class interfaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'I', 'long' : 'class implementations', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'class methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'F', 'long' : 'object fields', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'm', 'long' : 'object methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'type structures', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'type aliases', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enumerations', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'properties', 'fold' : 0, 'stl' : 0},
|
||||
\ ]
|
||||
let type_objc.sro = ':'
|
||||
let type_objc.kind2scope = {
|
||||
\ 'i' : 'interface',
|
||||
\ 'I' : 'implementation',
|
||||
\ 's' : 'struct',
|
||||
\ }
|
||||
let type_objc.scope2kind = {
|
||||
\ 'interface' : 'i',
|
||||
\ 'implementation' : 'I',
|
||||
\ 'struct' : 's',
|
||||
\ }
|
||||
let types.objc = type_objc
|
||||
let types.objcpp = type_objc
|
||||
" Ocaml {{{1
|
||||
let type_ocaml = tagbar#prototypes#typeinfo#new()
|
||||
let type_ocaml.ctagstype = 'ocaml'
|
||||
let type_ocaml.kinds = [
|
||||
\ {'short' : 'M', 'long' : 'modules or functors', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'global variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'C', 'long' : 'constructors', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'exceptions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'type names', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'r', 'long' : 'structure fields', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_ocaml.sro = '.' " Not sure, is nesting even possible?
|
||||
let type_ocaml.kind2scope = {
|
||||
\ 'M' : 'Module',
|
||||
\ 'c' : 'class',
|
||||
\ 't' : 'type'
|
||||
\ }
|
||||
let type_ocaml.scope2kind = {
|
||||
\ 'Module' : 'M',
|
||||
\ 'class' : 'c',
|
||||
\ 'type' : 't'
|
||||
\ }
|
||||
let types.ocaml = type_ocaml
|
||||
" Pascal {{{1
|
||||
let type_pascal = tagbar#prototypes#typeinfo#new()
|
||||
let type_pascal.ctagstype = 'pascal'
|
||||
let type_pascal.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.pascal = type_pascal
|
||||
" Perl {{{1
|
||||
let type_perl = tagbar#prototypes#typeinfo#new()
|
||||
let type_perl.ctagstype = 'perl'
|
||||
let type_perl.kinds = [
|
||||
\ {'short' : 'p', 'long' : 'packages', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'formats', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.perl = type_perl
|
||||
" PHP {{{1
|
||||
let type_php = tagbar#prototypes#typeinfo#new()
|
||||
let type_php.ctagstype = 'php'
|
||||
let type_php.kinds = [
|
||||
\ {'short' : 'i', 'long' : 'interfaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'd', 'long' : 'constant definitions', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'j', 'long' : 'javascript functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.php = type_php
|
||||
" Python {{{1
|
||||
let type_python = tagbar#prototypes#typeinfo#new()
|
||||
let type_python.ctagstype = 'python'
|
||||
let type_python.kinds = [
|
||||
\ {'short' : 'i', 'long' : 'imports', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_python.sro = '.'
|
||||
let type_python.kind2scope = {
|
||||
\ 'c' : 'class',
|
||||
\ 'f' : 'function',
|
||||
\ 'm' : 'function'
|
||||
\ }
|
||||
let type_python.scope2kind = {
|
||||
\ 'class' : 'c',
|
||||
\ 'function' : 'f'
|
||||
\ }
|
||||
let types.python = type_python
|
||||
let types.pyrex = type_python
|
||||
let types.cython = type_python
|
||||
" REXX {{{1
|
||||
let type_rexx = tagbar#prototypes#typeinfo#new()
|
||||
let type_rexx.ctagstype = 'rexx'
|
||||
let type_rexx.kinds = [
|
||||
\ {'short' : 's', 'long' : 'subroutines', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.rexx = type_rexx
|
||||
" Ruby {{{1
|
||||
let type_ruby = tagbar#prototypes#typeinfo#new()
|
||||
let type_ruby.ctagstype = 'ruby'
|
||||
let type_ruby.kinds = [
|
||||
\ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'F', 'long' : 'singleton methods', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_ruby.sro = '.'
|
||||
let type_ruby.kind2scope = {
|
||||
\ 'c' : 'class',
|
||||
\ 'm' : 'class',
|
||||
\ 'f' : 'class'
|
||||
\ }
|
||||
let type_ruby.scope2kind = {
|
||||
\ 'class' : 'c'
|
||||
\ }
|
||||
let types.ruby = type_ruby
|
||||
" Scheme {{{1
|
||||
let type_scheme = tagbar#prototypes#typeinfo#new()
|
||||
let type_scheme.ctagstype = 'scheme'
|
||||
let type_scheme.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'sets', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.scheme = type_scheme
|
||||
let types.racket = type_scheme
|
||||
" Shell script {{{1
|
||||
let type_sh = tagbar#prototypes#typeinfo#new()
|
||||
let type_sh.ctagstype = 'sh'
|
||||
let type_sh.kinds = [
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.sh = type_sh
|
||||
let types.csh = type_sh
|
||||
let types.zsh = type_sh
|
||||
" SLang {{{1
|
||||
let type_slang = tagbar#prototypes#typeinfo#new()
|
||||
let type_slang.ctagstype = 'slang'
|
||||
let type_slang.kinds = [
|
||||
\ {'short' : 'n', 'long' : 'namespaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.slang = type_slang
|
||||
" SML {{{1
|
||||
let type_sml = tagbar#prototypes#typeinfo#new()
|
||||
let type_sml.ctagstype = 'sml'
|
||||
let type_sml.kinds = [
|
||||
\ {'short' : 'e', 'long' : 'exception declarations', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'function definitions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'functor definitions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'signature declarations', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'r', 'long' : 'structure declarations', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'type definitions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'value bindings', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let types.sml = type_sml
|
||||
" SQL {{{1
|
||||
" The SQL ctags parser seems to be buggy for me, so this just uses the
|
||||
" normal kinds even though scopes should be available. Improvements
|
||||
" welcome!
|
||||
let type_sql = tagbar#prototypes#typeinfo#new()
|
||||
let type_sql.ctagstype = 'sql'
|
||||
let type_sql.kinds = [
|
||||
\ {'short' : 'P', 'long' : 'packages', 'fold' : 1, 'stl' : 1},
|
||||
\ {'short' : 'd', 'long' : 'prototypes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'cursors', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'F', 'long' : 'record fields', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'L', 'long' : 'block label', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'subtypes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'tables', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'T', 'long' : 'triggers', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'i', 'long' : 'indexes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'events', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'U', 'long' : 'publications', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'R', 'long' : 'services', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'D', 'long' : 'domains', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'V', 'long' : 'views', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'n', 'long' : 'synonyms', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'x', 'long' : 'MobiLink Table Scripts', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'y', 'long' : 'MobiLink Conn Scripts', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'z', 'long' : 'MobiLink Properties', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.sql = type_sql
|
||||
" Tcl {{{1
|
||||
let type_tcl = tagbar#prototypes#typeinfo#new()
|
||||
let type_tcl.ctagstype = 'tcl'
|
||||
let type_tcl.kinds = [
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.tcl = type_tcl
|
||||
" LaTeX {{{1
|
||||
let type_tex = tagbar#prototypes#typeinfo#new()
|
||||
let type_tex.ctagstype = 'tex'
|
||||
let type_tex.kinds = [
|
||||
\ {'short' : 'i', 'long' : 'includes', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'p', 'long' : 'parts', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'chapters', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 's', 'long' : 'sections', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'u', 'long' : 'subsections', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'b', 'long' : 'subsubsections', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'P', 'long' : 'paragraphs', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'G', 'long' : 'subparagraphs', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 0}
|
||||
\ ]
|
||||
let type_tex.sro = '""'
|
||||
let type_tex.kind2scope = {
|
||||
\ 'p' : 'part',
|
||||
\ 'c' : 'chapter',
|
||||
\ 's' : 'section',
|
||||
\ 'u' : 'subsection',
|
||||
\ 'b' : 'subsubsection'
|
||||
\ }
|
||||
let type_tex.scope2kind = {
|
||||
\ 'part' : 'p',
|
||||
\ 'chapter' : 'c',
|
||||
\ 'section' : 's',
|
||||
\ 'subsection' : 'u',
|
||||
\ 'subsubsection' : 'b'
|
||||
\ }
|
||||
let type_tex.sort = 0
|
||||
let types.tex = type_tex
|
||||
" Vala {{{1
|
||||
" Vala is supported by the ctags fork provided by Anjuta, so only add the
|
||||
" type if the fork is used to prevent error messages otherwise
|
||||
if has_key(a:supported_types, 'vala') || executable('anjuta-tags')
|
||||
let type_vala = tagbar#prototypes#typeinfo#new()
|
||||
let type_vala.ctagstype = 'vala'
|
||||
let type_vala.kinds = [
|
||||
\ {'short' : 'e', 'long' : 'Enumerations', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'Enumeration values', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 's', 'long' : 'Structures', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'i', 'long' : 'Interfaces', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'd', 'long' : 'Delegates', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'Classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'Properties', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'Fields', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'm', 'long' : 'Methods', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'E', 'long' : 'Error domains', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'r', 'long' : 'Error codes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'S', 'long' : 'Signals', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_vala.sro = '.'
|
||||
" 'enum' doesn't seem to be used as a scope, but it can't hurt to have
|
||||
" it here
|
||||
let type_vala.kind2scope = {
|
||||
\ 's' : 'struct',
|
||||
\ 'i' : 'interface',
|
||||
\ 'c' : 'class',
|
||||
\ 'e' : 'enum'
|
||||
\ }
|
||||
let type_vala.scope2kind = {
|
||||
\ 'struct' : 's',
|
||||
\ 'interface' : 'i',
|
||||
\ 'class' : 'c',
|
||||
\ 'enum' : 'e'
|
||||
\ }
|
||||
let types.vala = type_vala
|
||||
endif
|
||||
if !has_key(a:supported_types, 'vala') && executable('anjuta-tags')
|
||||
let types.vala.ctagsbin = 'anjuta-tags'
|
||||
endif
|
||||
" Vera {{{1
|
||||
" Why are variables 'virtual'?
|
||||
let type_vera = tagbar#prototypes#typeinfo#new()
|
||||
let type_vera.ctagstype = 'vera'
|
||||
let type_vera.kinds = [
|
||||
\ {'short' : 'd', 'long' : 'macros', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'g', 'long' : 'enums', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'T', 'long' : 'typedefs', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'classes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'enumerators', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'm', 'long' : 'members', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'tasks', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'p', 'long' : 'programs', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let type_vera.sro = '.' " Nesting doesn't seem to be possible
|
||||
let type_vera.kind2scope = {
|
||||
\ 'g' : 'enum',
|
||||
\ 'c' : 'class',
|
||||
\ 'v' : 'virtual'
|
||||
\ }
|
||||
let type_vera.scope2kind = {
|
||||
\ 'enum' : 'g',
|
||||
\ 'class' : 'c',
|
||||
\ 'virtual' : 'v'
|
||||
\ }
|
||||
let types.vera = type_vera
|
||||
" Verilog {{{1
|
||||
let type_verilog = tagbar#prototypes#typeinfo#new()
|
||||
let type_verilog.ctagstype = 'verilog'
|
||||
let type_verilog.kinds = [
|
||||
\ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'e', 'long' : 'events', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'm', 'long' : 'modules', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'n', 'long' : 'net data types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'ports', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'r', 'long' : 'register data types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 't', 'long' : 'tasks', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.verilog = type_verilog
|
||||
" VHDL {{{1
|
||||
" The VHDL ctags parser unfortunately doesn't generate proper scopes
|
||||
let type_vhdl = tagbar#prototypes#typeinfo#new()
|
||||
let type_vhdl.ctagstype = 'vhdl'
|
||||
let type_vhdl.kinds = [
|
||||
\ {'short' : 'P', 'long' : 'packages', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'c', 'long' : 'constants', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 't', 'long' : 'types', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'T', 'long' : 'subtypes', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'r', 'long' : 'records', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'e', 'long' : 'entities', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'p', 'long' : 'procedures', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.vhdl = type_vhdl
|
||||
" Vim {{{1
|
||||
let type_vim = tagbar#prototypes#typeinfo#new()
|
||||
let type_vim.ctagstype = 'vim'
|
||||
let type_vim.kinds = [
|
||||
\ {'short' : 'n', 'long' : 'vimball filenames', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'v', 'long' : 'variables', 'fold' : 1, 'stl' : 0},
|
||||
\ {'short' : 'f', 'long' : 'functions', 'fold' : 0, 'stl' : 1},
|
||||
\ {'short' : 'a', 'long' : 'autocommand groups', 'fold' : 1, 'stl' : 1},
|
||||
\ {'short' : 'c', 'long' : 'commands', 'fold' : 0, 'stl' : 0},
|
||||
\ {'short' : 'm', 'long' : 'maps', 'fold' : 1, 'stl' : 0}
|
||||
\ ]
|
||||
let types.vim = type_vim
|
||||
" YACC {{{1
|
||||
let type_yacc = tagbar#prototypes#typeinfo#new()
|
||||
let type_yacc.ctagstype = 'yacc'
|
||||
let type_yacc.kinds = [
|
||||
\ {'short' : 'l', 'long' : 'labels', 'fold' : 0, 'stl' : 1}
|
||||
\ ]
|
||||
let types.yacc = type_yacc
|
||||
" }}}1
|
||||
|
||||
for [type, typeinfo] in items(types)
|
||||
let typeinfo.ftype = type
|
||||
endfor
|
||||
|
||||
for typeinfo in values(types)
|
||||
call typeinfo.createKinddict()
|
||||
endfor
|
||||
|
||||
return types
|
||||
endfunction
|
||||
|
||||
" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
|
||||
1124
.vim/bundle/vim-tagbar/autoload/tagbar/types/uctags.vim
Normal file
1124
.vim/bundle/vim-tagbar/autoload/tagbar/types/uctags.vim
Normal file
File diff suppressed because it is too large
Load Diff
1622
.vim/bundle/vim-tagbar/doc/tagbar.txt
Normal file
1622
.vim/bundle/vim-tagbar/doc/tagbar.txt
Normal file
File diff suppressed because it is too large
Load Diff
62
.vim/bundle/vim-tagbar/doc/tags
Normal file
62
.vim/bundle/vim-tagbar/doc/tags
Normal file
@@ -0,0 +1,62 @@
|
||||
:TagbarClose tagbar.txt /*:TagbarClose*
|
||||
:TagbarCurrentTag tagbar.txt /*:TagbarCurrentTag*
|
||||
:TagbarDebug tagbar.txt /*:TagbarDebug*
|
||||
:TagbarDebugEnd tagbar.txt /*:TagbarDebugEnd*
|
||||
:TagbarGetTypeConfig tagbar.txt /*:TagbarGetTypeConfig*
|
||||
:TagbarOpen tagbar.txt /*:TagbarOpen*
|
||||
:TagbarOpenAutoClose tagbar.txt /*:TagbarOpenAutoClose*
|
||||
:TagbarSetFoldlevel tagbar.txt /*:TagbarSetFoldlevel*
|
||||
:TagbarShowTag tagbar.txt /*:TagbarShowTag*
|
||||
:TagbarToggle tagbar.txt /*:TagbarToggle*
|
||||
:TagbarTogglePause tagbar.txt /*:TagbarTogglePause*
|
||||
g:tagbar_autoclose tagbar.txt /*g:tagbar_autoclose*
|
||||
g:tagbar_autofocus tagbar.txt /*g:tagbar_autofocus*
|
||||
g:tagbar_autopreview tagbar.txt /*g:tagbar_autopreview*
|
||||
g:tagbar_autoshowtag tagbar.txt /*g:tagbar_autoshowtag*
|
||||
g:tagbar_case_insensitive tagbar.txt /*g:tagbar_case_insensitive*
|
||||
g:tagbar_compact tagbar.txt /*g:tagbar_compact*
|
||||
g:tagbar_ctags_bin tagbar.txt /*g:tagbar_ctags_bin*
|
||||
g:tagbar_ctags_options tagbar.txt /*g:tagbar_ctags_options*
|
||||
g:tagbar_expand tagbar.txt /*g:tagbar_expand*
|
||||
g:tagbar_foldlevel tagbar.txt /*g:tagbar_foldlevel*
|
||||
g:tagbar_hide_nonpublic tagbar.txt /*g:tagbar_hide_nonpublic*
|
||||
g:tagbar_iconchars tagbar.txt /*g:tagbar_iconchars*
|
||||
g:tagbar_indent tagbar.txt /*g:tagbar_indent*
|
||||
g:tagbar_left tagbar.txt /*g:tagbar_left*
|
||||
g:tagbar_previewwin_pos tagbar.txt /*g:tagbar_previewwin_pos*
|
||||
g:tagbar_show_balloon tagbar.txt /*g:tagbar_show_balloon*
|
||||
g:tagbar_show_linenumbers tagbar.txt /*g:tagbar_show_linenumbers*
|
||||
g:tagbar_show_visibility tagbar.txt /*g:tagbar_show_visibility*
|
||||
g:tagbar_silent tagbar.txt /*g:tagbar_silent*
|
||||
g:tagbar_singleclick tagbar.txt /*g:tagbar_singleclick*
|
||||
g:tagbar_sort tagbar.txt /*g:tagbar_sort*
|
||||
g:tagbar_status_func tagbar.txt /*g:tagbar_status_func*
|
||||
g:tagbar_systemenc tagbar.txt /*g:tagbar_systemenc*
|
||||
g:tagbar_updateonsave_maxlines tagbar.txt /*g:tagbar_updateonsave_maxlines*
|
||||
g:tagbar_vertical tagbar.txt /*g:tagbar_vertical*
|
||||
g:tagbar_width tagbar.txt /*g:tagbar_width*
|
||||
g:tagbar_zoomwidth tagbar.txt /*g:tagbar_zoomwidth*
|
||||
tagbar tagbar.txt /*tagbar*
|
||||
tagbar#StopAutoUpdate() tagbar.txt /*tagbar#StopAutoUpdate()*
|
||||
tagbar-autoopen tagbar.txt /*tagbar-autoopen*
|
||||
tagbar-commands tagbar.txt /*tagbar-commands*
|
||||
tagbar-configuration tagbar.txt /*tagbar-configuration*
|
||||
tagbar-contents tagbar.txt /*tagbar-contents*
|
||||
tagbar-credits tagbar.txt /*tagbar-credits*
|
||||
tagbar-extend tagbar.txt /*tagbar-extend*
|
||||
tagbar-features tagbar.txt /*tagbar-features*
|
||||
tagbar-functions tagbar.txt /*tagbar-functions*
|
||||
tagbar-highlight tagbar.txt /*tagbar-highlight*
|
||||
tagbar-history tagbar.txt /*tagbar-history*
|
||||
tagbar-ignore tagbar.txt /*tagbar-ignore*
|
||||
tagbar-installation tagbar.txt /*tagbar-installation*
|
||||
tagbar-intro tagbar.txt /*tagbar-intro*
|
||||
tagbar-issues tagbar.txt /*tagbar-issues*
|
||||
tagbar-keys tagbar.txt /*tagbar-keys*
|
||||
tagbar-other tagbar.txt /*tagbar-other*
|
||||
tagbar-pseudotags tagbar.txt /*tagbar-pseudotags*
|
||||
tagbar-requirements tagbar.txt /*tagbar-requirements*
|
||||
tagbar-statusline tagbar.txt /*tagbar-statusline*
|
||||
tagbar-todo tagbar.txt /*tagbar-todo*
|
||||
tagbar-usage tagbar.txt /*tagbar-usage*
|
||||
tagbar.txt tagbar.txt /*tagbar.txt*
|
||||
153
.vim/bundle/vim-tagbar/plugin/tagbar.vim
Normal file
153
.vim/bundle/vim-tagbar/plugin/tagbar.vim
Normal file
@@ -0,0 +1,153 @@
|
||||
" ============================================================================
|
||||
" 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.7
|
||||
" Note: This plugin was heavily inspired by the 'Taglist' plugin by
|
||||
" Yegappan Lakshmanan and uses a small amount of code from it.
|
||||
"
|
||||
" Original taglist copyright notice:
|
||||
" Permission is hereby granted to use and distribute this code,
|
||||
" with or without modifications, provided that this copyright
|
||||
" notice is copied with it. Like anything else that's free,
|
||||
" taglist.vim is provided *as is* and comes with no warranty of
|
||||
" any kind, either expressed or implied. In no event will the
|
||||
" copyright holder be liable for any damamges resulting from the
|
||||
" use of this software.
|
||||
" ============================================================================
|
||||
|
||||
scriptencoding utf-8
|
||||
|
||||
if &compatible || exists('g:loaded_tagbar')
|
||||
finish
|
||||
endif
|
||||
|
||||
" Basic init {{{1
|
||||
|
||||
if v:version < 700
|
||||
echohl WarningMsg
|
||||
echomsg 'Tagbar: Vim version is too old, Tagbar requires at least 7.0'
|
||||
echohl None
|
||||
finish
|
||||
endif
|
||||
|
||||
if v:version == 700 && !has('patch167')
|
||||
echohl WarningMsg
|
||||
echomsg 'Tagbar: Vim versions lower than 7.0.167 have a bug'
|
||||
\ 'that prevents this version of Tagbar from working.'
|
||||
\ 'Please use the alternate version posted on the website.'
|
||||
echohl None
|
||||
finish
|
||||
endif
|
||||
|
||||
function! s:init_var(var, value) abort
|
||||
if !exists('g:tagbar_' . a:var)
|
||||
execute 'let g:tagbar_' . a:var . ' = ' . string(a:value)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! s:setup_options() abort
|
||||
if !exists('g:tagbar_vertical') || g:tagbar_vertical == 0
|
||||
let previewwin_pos = 'topleft'
|
||||
else
|
||||
let previewwin_pos = 'rightbelow vertical'
|
||||
endif
|
||||
let options = [
|
||||
\ ['autoclose', 0],
|
||||
\ ['autofocus', 0],
|
||||
\ ['autopreview', 0],
|
||||
\ ['autoshowtag', 0],
|
||||
\ ['case_insensitive', 0],
|
||||
\ ['compact', 0],
|
||||
\ ['expand', 0],
|
||||
\ ['foldlevel', 99],
|
||||
\ ['hide_nonpublic', 0],
|
||||
\ ['indent', 2],
|
||||
\ ['left', 0],
|
||||
\ ['previewwin_pos', previewwin_pos],
|
||||
\ ['show_balloon', 1],
|
||||
\ ['show_visibility', 1],
|
||||
\ ['show_linenumbers', 0],
|
||||
\ ['singleclick', 0],
|
||||
\ ['sort', 1],
|
||||
\ ['systemenc', &encoding],
|
||||
\ ['vertical', 0],
|
||||
\ ['width', 40],
|
||||
\ ['zoomwidth', 1],
|
||||
\ ['silent', 0],
|
||||
\ ]
|
||||
|
||||
for [opt, val] in options
|
||||
call s:init_var(opt, val)
|
||||
endfor
|
||||
endfunction
|
||||
call s:setup_options()
|
||||
|
||||
if !exists('g:tagbar_iconchars')
|
||||
if has('multi_byte') && has('unix') && &encoding ==# 'utf-8' &&
|
||||
\ (!exists('+termencoding') || empty(&termencoding) || &termencoding ==# 'utf-8')
|
||||
let g:tagbar_iconchars = ['▶', '▼']
|
||||
else
|
||||
let g:tagbar_iconchars = ['+', '-']
|
||||
endif
|
||||
endif
|
||||
|
||||
function! s:setup_keymaps() abort
|
||||
let keymaps = [
|
||||
\ ['jump', '<CR>'],
|
||||
\ ['preview', 'p'],
|
||||
\ ['previewwin', 'P'],
|
||||
\ ['nexttag', '<C-N>'],
|
||||
\ ['prevtag', '<C-P>'],
|
||||
\ ['showproto', '<Space>'],
|
||||
\ ['hidenonpublic', 'v'],
|
||||
\
|
||||
\ ['openfold', ['+', '<kPlus>', 'zo']],
|
||||
\ ['closefold', ['-', '<kMinus>', 'zc']],
|
||||
\ ['togglefold', ['o', 'za']],
|
||||
\ ['openallfolds', ['*', '<kMultiply>', 'zR']],
|
||||
\ ['closeallfolds', ['=', 'zM']],
|
||||
\ ['incrementfolds', ['zr']],
|
||||
\ ['decrementfolds', ['zm']],
|
||||
\ ['nextfold', 'zj'],
|
||||
\ ['prevfold', 'zk'],
|
||||
\
|
||||
\ ['togglesort', 's'],
|
||||
\ ['togglecaseinsensitive', 'i'],
|
||||
\ ['toggleautoclose', 'c'],
|
||||
\ ['togglepause', 't'],
|
||||
\ ['zoomwin', 'x'],
|
||||
\ ['close', 'q'],
|
||||
\ ['help', ['<F1>', '?']],
|
||||
\ ]
|
||||
|
||||
for [map, key] in keymaps
|
||||
call s:init_var('map_' . map, key)
|
||||
unlet key
|
||||
endfor
|
||||
endfunction
|
||||
call s:setup_keymaps()
|
||||
|
||||
augroup TagbarSession
|
||||
autocmd!
|
||||
autocmd SessionLoadPost * nested call tagbar#RestoreSession()
|
||||
augroup END
|
||||
|
||||
" Commands {{{1
|
||||
command! -nargs=0 Tagbar call tagbar#ToggleWindow()
|
||||
command! -nargs=0 TagbarToggle call tagbar#ToggleWindow()
|
||||
command! -nargs=? TagbarOpen call tagbar#OpenWindow(<f-args>)
|
||||
command! -nargs=0 TagbarOpenAutoClose call tagbar#OpenWindow('fcj')
|
||||
command! -nargs=0 TagbarClose call tagbar#CloseWindow()
|
||||
command! -nargs=1 -bang TagbarSetFoldlevel call tagbar#SetFoldLevel(<args>, <bang>0)
|
||||
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#debug#start_debug(<f-args>)
|
||||
command! -nargs=0 TagbarDebugEnd call tagbar#debug#stop_debug()
|
||||
command! -nargs=0 TagbarTogglePause call tagbar#toggle_pause()
|
||||
|
||||
" Modeline {{{1
|
||||
" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
|
||||
64
.vim/bundle/vim-tagbar/syntax/tagbar.vim
Normal file
64
.vim/bundle/vim-tagbar/syntax/tagbar.vim
Normal file
@@ -0,0 +1,64 @@
|
||||
" File: tagbar.vim
|
||||
" Description: Tagbar syntax settings
|
||||
" Author: Jan Larres <jan@majutsushi.net>
|
||||
" Licence: Vim licence
|
||||
" Website: http://majutsushi.github.com/tagbar/
|
||||
" Version: 2.7
|
||||
|
||||
scriptencoding utf-8
|
||||
|
||||
if exists('b:current_syntax')
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:ics = escape(join(g:tagbar_iconchars, ''), ']^\-')
|
||||
|
||||
let s:pattern = '\(^[' . s:ics . '] \?\)\@3<=[^-+: ]\+[^:]\+$'
|
||||
execute "syntax match TagbarKind '" . s:pattern . "'"
|
||||
|
||||
let s:pattern = '\(\S\@<![' . s:ics . '][-+# ]\?\)\@<=[^*(]\+\(\*\?\(([^)]\+)\)\? :\)\@='
|
||||
execute "syntax match TagbarScope '" . s:pattern . "'"
|
||||
|
||||
let s:pattern = '\S\@<![' . s:ics . ']\([-+# ]\?\)\@='
|
||||
execute "syntax match TagbarFoldIcon '" . s:pattern . "'"
|
||||
|
||||
let s:pattern = '\(\S\@<![' . s:ics . ' ]\)\@<=+\([^-+# ]\)\@='
|
||||
execute "syntax match TagbarVisibilityPublic '" . s:pattern . "'"
|
||||
let s:pattern = '\(\S\@<![' . s:ics . ' ]\)\@<=#\([^-+# ]\)\@='
|
||||
execute "syntax match TagbarVisibilityProtected '" . s:pattern . "'"
|
||||
let s:pattern = '\(\S\@<![' . s:ics . ' ]\)\@<=-\([^-+# ]\)\@='
|
||||
execute "syntax match TagbarVisibilityPrivate '" . s:pattern . "'"
|
||||
|
||||
unlet s:pattern
|
||||
|
||||
syntax match TagbarHelp '^".*' contains=TagbarHelpKey,TagbarHelpTitle
|
||||
syntax match TagbarHelpKey '" \zs.*\ze:' contained
|
||||
syntax match TagbarHelpTitle '" \zs-\+ \w\+ -\+' contained
|
||||
|
||||
syntax match TagbarNestedKind '^\s\+\[[^]]\+\]$'
|
||||
syntax match TagbarType ' : \zs.*'
|
||||
syntax match TagbarSignature '(.*)'
|
||||
syntax match TagbarPseudoID '\*\ze :'
|
||||
|
||||
highlight default link TagbarHelp Comment
|
||||
highlight default link TagbarHelpKey Identifier
|
||||
highlight default link TagbarHelpTitle PreProc
|
||||
highlight default link TagbarKind Identifier
|
||||
highlight default link TagbarNestedKind TagbarKind
|
||||
highlight default link TagbarScope Title
|
||||
highlight default link TagbarType Type
|
||||
highlight default link TagbarSignature SpecialKey
|
||||
highlight default link TagbarPseudoID NonText
|
||||
highlight default link TagbarFoldIcon Statement
|
||||
highlight default link TagbarHighlight Search
|
||||
|
||||
highlight default TagbarAccessPublic guifg=Green ctermfg=Green
|
||||
highlight default TagbarAccessProtected guifg=Blue ctermfg=Blue
|
||||
highlight default TagbarAccessPrivate guifg=Red ctermfg=Red
|
||||
highlight default link TagbarVisibilityPublic TagbarAccessPublic
|
||||
highlight default link TagbarVisibilityProtected TagbarAccessProtected
|
||||
highlight default link TagbarVisibilityPrivate TagbarAccessPrivate
|
||||
|
||||
let b:current_syntax = 'tagbar'
|
||||
|
||||
" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
|
||||
Reference in New Issue
Block a user