psi-jack/ultimate-vim
1
0
Fork 0
mirror of synced 2024-11-30 04:35:35 -05:00
Code Issues Releases Wiki Activity
ultimate-vim/vim_plugin_candinates_src/cscope-15.8a/contrib/cctree.vim

3399 lines
107 KiB
VimL
Raw Normal View History

update cscope from 15.7a to 15.8a and add Exuberant Ctags version58
2012-10-20 13:47:16 -04:00
" C Call-Tree Explorer (CCTree) <CCTree.vim>
"
"
" Script Info and Documentation
"=============================================================================
" Copyright: Copyright (C) August 2008 - 2011, Hari Rangarajan
" 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,
" cctree.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.
"
" Name Of File: CCTree.vim
" Description: C Call-Tree Explorer Vim Plugin
" Maintainer: Hari Rangarajan <hari.rangarajan@gmail.com>
" URL: http://vim.sourceforge.net/scripts/script.php?script_id=2368
" Last Change: May 18, 2011
" Version: 1.51
"
"=============================================================================
"
" {{{ Description:
" Plugin generates dependency-trees for symbols using a cscope database
" in Vim.
" }}}
" {{{ Requirements: 1) Vim 7.xx , 2) Cscope
"
" Tested on Unix and the following Win32 versions:
" + Cscope, mlcscope (WIN32)
" http://code.google.com/p/cscope-win32/
" http://www.bell-labs.com/project/wwexptools/packages.html
" }}}
" {{{ Installation:
" Copy this file to ~/.vim/plugins/
" or to /vimfiles/plugins/ (on Win32 platforms)
"
" It might also be possible to load it as a filetype plugin
" ~/.vim/ftplugin/c/
"
" Need to set :filetype plugin on
"
" }}}
" {{{ Usage:
" Build cscope database, for example:
" > cscope -b -i cscope.files
" [Tip: add -c option to build uncompressed databases for faster
" load speeds]
"
" Load database with command ":CCTreeLoadDB"
" (Please note that it might take a while depending on the
" database size)
"
" Append database with command ":CCTreeAppendDB"
" Allows multiple cscope files to be loaded and cross-referenced
" Illustration:
" :CCTreeAppendDB ./cscope.out
" :CCTreeAppendDB ./dir1/cscope.out
" :CCTreeAppendDB ./dir2/cscope.out
"
" A database name, i.e., my_cscope.out, can be specified with
" the command. If not provided, a prompt will ask for the
" filename; default is cscope.out.
"
" To show loaded databases, use command ":CCTreeShowLoadedDBs"
"
" To unload all databases, use command ":CCTreeUnLoadDB"
" Note: There is no provision to unload databases individually
"
" To save the current set of databases loaded in to memory onto disk
" in native CCTree XRef format, use command ":CCTreeSaveXRefDB"
"
" To load a saved native CCTree XRef format file, use
" command ":CCTreeLoadXRefDB"
"
" To load a saved native CCTree XRef format file, use
" command ":CCTreeLoadXRefDBFromDisk"
"
" Notes: No merging database support for CCTree native DB's [at present].
"
"
" To have multiple CCTree preview windows, use ":CCTreeWindowSaveCopy"
" Note: Once saved, only the depth of the preview window can be changed
"
" Default Mappings:
" Get reverse call tree for symbol <C-\><
" Get forward call tree for symbol <C-\>>
" Increase depth of tree and update <C-\>=
" Decrease depth of tree and update <C-\>-
"
" Open symbol in other window <CR>
" Preview symbol in other window <Ctrl-P>
"
" Save copy of preview window <C-\>y
" Highlight current call-tree flow <C-l>
" Compress(Fold) call tree view zs
" (This is useful for viewing long
" call trees which span across
" multiple pages)
"
" Custom user-mappings:
" Users can custom-map the short-cut keys by
" overriding the following variables in their
" Vim start-up configuration
"
" g:CCTreeKeyTraceForwardTree = '<C-\>>'
" g:CCTreeKeyTraceReverseTree = '<C-\><'
" g:CCTreeKeyHilightTree = '<C-l>' " Static highlighting
" g:CCTreeKeySaveWindow = '<C-\>y'
" g:CCTreeKeyToggleWindow = '<C-\>w'
" g:CCTreeKeyCompressTree = 'zs' " Compress call-tree
" g:CCTreeKeyDepthPlus = '<C-\>='
" g:CCTreeKeyDepthMinus = '<C-\>-'
"
" Command List:
" CCTreeLoadDB <dbname>
" CCTreeAppendDB <dbname>
" CCTreeLoadXRefDB <dbname>
" CCTreeSaveXRefDB <dbname>
" CCTreeLoadXRefDBFromDisk <dbname>
"
" CCTreeUnLoadDB
" CCTreeShowLoadedDBs
"
" CCTreeTraceForward <symbolname>
" CCTreeTraceReverse <symbolname>
" CCTreeRecurseDepthPlus
" CCTreeRecurseDepthMinus
" CCTreeWindowSaveCopy
"
" Only in preview window:
" CCTreeWindowHiCallTree (same as <C-l> shorcut)
" Highlight calling tree for keyword at cursor
"
" Dynamic configuration:
" CCTreeOptsEnable <option> (<tab> for auto-complete)
" CCTreeOptsDisable <option> (<tab> for auto-complete)
" CCTreeOptsToggle <option> (<tab> for auto-complete)
" Options:
" DynamicTreeHiLights: Control dynamic tree highlighting
" UseUnicodeSymbols: Use of UTF-8 special characters for
" tree
" UseConceal: Use (+Conceal) feature instead of 'ignore'
" syntax highlighting. Allows CCTree window
" to be exported in HTML without syntax markup
" characters. (Vim 7.3+ only)
" EnhancedSymbolProcessing: Cross-reference enums, macros,
" global variables, typedefs (Warning: Database
" processing speeds will be slow).
"
"
"
" Settings:
" Customize behavior by changing the variable settings
"
" UTF-8 usage:
" UTF-8 symbols should work fine on the majority of
" X11 systems; however, some terminals might cause problems.
"
" To use symbols for drawing the tree, this option can be enabled.
" g:CCTreeUseUTF8Symbols = 1
" The options interface (CCTreeOptsxxx) can be used to
" modify options on-the-fly.
"
" Cscope database file, g:CCTreeCscopeDb = "cscope.out"
" Maximum call levels, g:CCTreeRecursiveDepth = 3
" Maximum visible(unfolded) level, g:CCTreeMinVisibleDepth = 3
" Orientation of window, g:CCTreeOrientation = "topleft"
" (standard vim options for split: [right|left][above|below])
"
" Use Vertical window, g:CCTreeWindowVertical = 1
" Min width for window, g:CCTreeWindowMinWidth = 40
" g:CCTreeWindowWidth = -1, auto-select best width to fit
"
" Horizontal window, g:CCTreeWindowHeight, default is -1
"
"
" Display format, g:CCTreeDisplayMode, default 1
"
" Values: 1 -- Ultra-compact (takes minimum screen width)
" 2 -- Compact (Takes little more space)
" 3 -- Wide (Takes copious amounts of space)
"
" For vertical splits, 1 and 2 are good, while 3 is good for
" horizontal displays
"
" NOTE: To get older behavior, add the following to your vimrc
" let g:CCTreeDisplayMode = 3
" let g:CCTreeWindowVertical = 0
"
" Syntax Coloring:
" CCTreeSymbol is the symbol name
" CCTreeMarkers include "|","+--->"
"
" CCTreeHiSymbol is the highlighted call tree functions
" CCTreeHiMarkers is the same as CCTreeMarkers except
" these denote the highlighted call-tree
"
"
" CCTreeHiXXXX allows dynamic highlighting of the call-tree.
" To observe the effect, move the cursor to the function to
" highlight the current call-tree. This option can be
" turned off using the setting, g:CCTreeHilightCallTree.
" For faster highlighting, the value of 'updatetime' can be
" changed.
"
" Support for large database files:
" Vimscript does not have an API for reading files line-by-line. This
" becomes a problem when parsing large databases. CCTree can overcome
" the limitation using an external utility (i.e., GNU coreutils: split)
" or VimScript's perl interpreter interface (:version must indicate +perl)
"
" The following settings are tailored to suit GNU coreutils split; the default
" settings should work with no changes on typical linux/unix distros
" (Monopoly OSes will require installation of unixutils or equivalent)
"
" External command is setup with the following parameters:
" g:CCTreeSplitProgCmd = 'PROG_SPLIT SPLIT_OPT SPLIT_SIZE IN_FILE OUT_FILE_PREFIX'
"
" Break-down of individual parameters:
" The split utility is assumed to be on the path; otherwise, specify full path
" g:CCTreeSplitProg = 'split'
"
" Option for splitting files (-C or -l)
" g:CCTreeSplitProgOption = '-C'
" If split program does not support -C, then this parameter must be set to
" the number of lines in the split files
" g:CCTreeDbFileSplitLines = -1
" Largest filesize Vimscript can handle; file sizes greater than this will
" be temporarily split
" g:CCTreeDbFileMaxSize = 40000000 (40 Mbytes)
"
" Sample system command:
" Typical:
" split -C 40000000 inputFile outputFilePrefix
"
" When g:CCTreeDbFileSplitLines is set to 10000 (-C options will be ignored)
" split -l 10000 inputFile outputFilePrefix
"
"
" Using perl interface:
" By default, perl usage is disabled. Set
" g:CCTreeUsePerl = 1 to enable the perl interface.
"
" Perl interface is typically faster than native Vimscript.
" This option can be used independent of the file size
"
" For more info on setting up perl interface
" :help perl-using or :help perl-dynamic
"
" Writing large Xref Databases:
" CCTree can use external utilities to write extremely large files beyond
" VimScripts capabilities. It requires the use of an external tool that can
" join text files (i.e., 'cat' in unix). This utility is triggered if the size
" of the file being written exceeds g:CCTreeDbFileMaxSize (40 Mb or as configured)
"
" The join utility command is configured by default as follows:
" let CCTreeJoinProgCmd = 'PROG_JOIN JOIN_OPT IN_FILES > OUT_FILE'
"
" let g:CCTreeJoinProg = 'cat' " PROG_JOIN
" let g:CCTreeJoinProgOpts = "" " JOIN_OPT
"
"
" }}}
" {{{ Limitations:
" Basic Symbol Processing:
" The accuracy of the call-tree will only be as good as the cscope
" database generation.
" NOTE: Different flavors of Cscope have some known
" limitations due to the lexical analysis engine. This results
" in incorrectly identified function blocks, etc.
" Enhanced Symbol Processing:
" (1) Cscope does not mark-up nameless enums correctly; hence,
" CCTree cannot recognize nameless enum symbols.
" }}}
" {{{ History:
" Version 1.51: May 18, 2011
" 1. Robust error reporting when external (split/cat) utils fail
" Version 1.50: May 6, 2011
" 1. Support cross-referencing of global variables, macros,
" enums, and typedefs.
" Version 1.40: April 22, 2011
" 1. Maintain order of functions called during forward tracing
" Version 1.39: April 18, 2011
" 1. Use +Conceal feature for highlighting (only Vim 7.3)
" Version 1.33: April 5, 2011
" 1. Load and trace CCTree native XRefDb directly from disk
" 2. Fix AppendDB command when 'ignorecase' is set
" Version 1.26: March 28, 2011
" 1. Fix macro cross-referencing limitation
" 2. Correct native xref file format
" Version 1.21: March 21, 2011
" 1. Support serialization of loaded
" cscope databases (for faster loading)
" Version 1.07: March 09, 2011
" 1. Fix new keymaps incorrectly applied to buffer
" 2. CCTreeOptsToggle command for toggling options
"
" Version 1.04: March 06, 2011
" 1. Customization for key mappings
" 2. Dynamic configuration of UI variables
" 3. Folding long call-trees to show current path dynamically
"
" Version 1.01: March 04, 2011
" 1. Make UTF-8 symbols for tree optional
"
" Version 1.00: March 02, 2011
" 1. Staging release for upcoming features
" - Complete refactoring of code to take
" advantage of VimScript's OO features
" 2. Faster decompression of symbols
" 3. Display related changes
" - Use of unicode symbols for tree
" 4. Bugfixes related to multi-database loading
"
" Version 0.90: February 18, 2011
" 1. Support for large databases using external split utility or perl
" interface
"
" Version 0.85: February 9, 2011
" 1. Significant increase in database loading and decompression speeds
"
" Version 0.80: February 4, 2011
" 1. Reduce memory usage by removing unused xref symbols
"
" Version 0.75: June 23, 2010
" 1. Support for saving CCTree preview window; multiple
" CCTree windows can now be open
"
" Version 0.71: May 11, 2010
" 1. Fix script bug
" Version 0.70: May 8, 2010
" 1. Functionality to load multiple cscope databases
"
" Version 0.65: July 12, 2009
" 1. Toggle preview window
"
" Version 0.61: December 24, 2008
" 1. Fixed bug when processing include files
" 2. Remove 'set ruler' option
"
" Version 0.60: November 26, 2008
" 1. Added support for source-file dependency tree
"
" Version 0.50: October 17, 2008
" 1. Optimizations for compact memory foot-print and
" improved compressed-database load speeds
"
" Version 0.41: October 6, 2008
" 1. Minor fix: Compressed cscope databases will load
" incorrectly if encoding is not 8-bit
"
" Version 0.4: September 28, 2008
" 1. Rewrite of "tree-display" code
" 2. New syntax hightlighting
" 3. Dynamic highlighting for call-trees
" 4. Support for new window modes (vertical, horizontal)
" 5. New display format option for compact or wide call-trees
" NOTE: defaults for tree-orientation set to vertical
"
" Version 0.3:
" September 21, 2008
" 1. Support compressed cscope databases
" 2. Display window related bugs fixed
" 3. More intuitive display and folding capabilities
"
" Version 0.2:
" September 12, 2008
" (Patches from Yegappan Lakshmanan, thanks!)
" 1. Support for using the plugin in Vi-compatible mode.
" 2. Filtering out unwanted lines before processing the db.
" 3. Command-line completion for the commands.
" 4. Using the cscope db from any directory.
"
" Version 0.1:
" August 31,2008
" 1. Cross-referencing support for only functions and macros
" Functions inside macro definitions will be incorrectly
" attributed to the top level calling function
"
" }}}
" {{{ Thanks:
"
" Qaiser Durrani (ver 1.51 -- Reporting issues with SunOS)
" Ben Fritz (ver 1.39 -- Suggestion/Testing for conceal feature)
" Ben Fritz (ver 1.26 -- Bug report)
" Frank Chang (ver 1.0x -- testing/UI enhancement ideas/bug fixes)
" Arun Chaganty/Timo Tiefel (Ver 0.60 -- bug report)
" Michael Wookey (Ver 0.4 -- Testing/bug report/patches)
" Yegappan Lakshmanan (Ver 0.2 -- Patches)
"
" The Vim Community, ofcourse :)
"=============================================================================
" }}}
" {{{ Init
if !exists('loaded_cctree') && v:version >= 700
" First time loading the cctree plugin
let loaded_cctree = 1
else
"finish
endif
" Line continuation used here
let s:cpo_save = &cpoptions
set cpoptions&vim
" Trick to get the current script ID
map <SID>xx <SID>xx
let s:sid = substitute(maparg('<SID>xx'), '<SNR>\(\d\+_\)xx$', '\1', '')
unmap <SID>xx
"}}}
" {{{ Global variables; Modify in .vimrc to modify default behavior
" {{{General
if !exists('CCTreeCscopeDb')
let CCTreeCscopeDb = "cscope.out"
endif
" revisit
if !exists('CCTreeDb')
let CCTreeDb = "cctree.out"
endif
if !exists('CCTreeRecursiveDepth')
let CCTreeRecursiveDepth = 3
endif
if !exists('CCTreeMinVisibleDepth')
let CCTreeMinVisibleDepth = 3
endif
if !exists('CCTreeEnhancedSymbolProcessing')
let CCTreeEnhancedSymbolProcessing = 0
endif
" }}}
" {{{ Custom user-key mappings
if !exists('CCTreeKeyTraceForwardTree')
let g:CCTreeKeyTraceForwardTree = '<C-\>>'
endif
if !exists('CCTreeKeyTraceReverseTree')
let g:CCTreeKeyTraceReverseTree = '<C-\><'
endif
if !exists('CCTreeKeyHilightTree')
let g:CCTreeKeyHilightTree = '<C-l>' " Static highlighting
endif
if !exists('CCTreeKeySaveWindow ')
let g:CCTreeKeySaveWindow = '<C-\>y'
endif
if !exists('CCTreeKeyToggleWindow ')
let g:CCTreeKeyToggleWindow = '<C-\>w'
endif
if !exists('CCTreeKeyCompressTree ')
let g:CCTreeKeyCompressTree = 'zs' " Compress call-tree
endif
if !exists('CCTreeKeyDepthPlus')
let g:CCTreeKeyDepthPlus = '<C-\>='
endif
if !exists('CCTreeKeyDepthMinus')
let g:CCTreeKeyDepthMinus = '<C-\>-'
endif
" }}}
" {{{ CCTree UI settings
if !exists('CCTreeOrientation')
let CCTreeOrientation = "topleft"
endif
if !exists('CCTreeWindowVertical')
let CCTreeWindowVertical = 1
endif
if !exists('CCTreeWindowWidth')
" -1 is auto select best width
let CCTreeWindowWidth = -1
endif
if !exists('CCTreeWindowMinWidth')
let CCTreeWindowMinWidth = 25
endif
if !exists('CCTreeWindowHeight')
let CCTreeWindowHeight = -1
endif
if !exists('CCTreeDisplayMode')
let CCTreeDisplayMode = 1
endif
if !exists('CCTreeHilightCallTree')
let CCTreeHilightCallTree = 1
endif
" }}}
" {{{ Split prog
if !exists('CCTreeSplitProgCmd')
let CCTreeSplitProgCmd = 'PROG_SPLIT SPLIT_OPT SPLIT_SIZE IN_FILE OUT_FILE_PREFIX'
endif
if !exists('CCTreeSplitProg')
"PROG_SPLIT
let CCTreeSplitProg = 'split'
endif
if !exists('CCTreeSplitProgOption')
"SPLIT_OPT
let CCTreeSplitProgOption = '-C'
endif
if !exists('CCTreeDbFileSplitLines')
" if SPLIT_OPT is -l
" If split program does not support -C, then this parameter must be set to
" the number of lines in the split files
let CCTreeDbFileSplitLines = -1
endif
if !exists('CCTreeSplitProgCmd')
let CCTreeSplitProgCmd = 'PROG_SPLIT SPLIT_OPT SPLIT_SIZE IN_FILE OUT_FILE_PREFIX'
endif
if !exists('CCTreeDbFileMaxSize')
" if SPLIT_OPT is -C
let CCTreeDbFileMaxSize = 40000000 "40 Mbytes
endif
" }}}
" {{{ Join/Cat prog
if !exists('CCTreeJoinProgCmd')
let CCTreeJoinProgCmd = 'PROG_JOIN JOIN_OPT IN_FILES > OUT_FILE'
endif
if !exists('CCTreeJoinProg')
"PROG_JOIN
let CCTreeJoinProg = 'cat'
endif
if !exists('CCTreeJoinProgOpts')
let CCTreeJoinProgOpts = ""
endif
" }}}
" {{{ Misc (perl)
if !exists('CCTreeUsePerl')
" Disabled by default
let CCTreeUsePerl = 0
if 0 " Auto-detect perl interface (Experimental code)
if has('perl)
perl << PERL_EOF
VIM::DoCommand("let CCTreeUsePerl = 1");
PERL_EOF
endif
endif
endif
if has('conceal')
let s:CCTreeUseConceal = 1
else
let s:CCTreeUseConceal = 0
endif
if !exists('CCTreeUseUTF8Symbols')
let CCTreeUseUTF8Symbols = 0
endif
" }}}
" }}}
" {{{ Plugin related local variables
let s:pluginname = 'CCTree'
let s:windowtitle = 'CCTree-View'
let s:windowsavetitle = 'CCTree-View-Copy'
let s:DBClasses = { 'cscopeid': 'Cscope', 'cctreexref' : 'CCTree XRef'}
let s:DBStorage = { 'memory': 'Memory', 'disk' : 'Disk'}
" }}}
" {{{ Turn on/off debugs
let s:tag_debug=0
" Use the Decho plugin for debugging
function! DBGecho(...)
if s:tag_debug
Decho(a:000)
endif
endfunction
function! DBGredir(...)
if s:tag_debug
Decho(a:000)
endif
endfunction
function! Pause()
call input("sasasD", "asdads")
endfunction
" }}}
" {{{ Progress bar (generic, numeric, rolling)
let s:GenericProgressBar= {
\ 'depth': 0,
\ 'depthChar': '',
\ 'currentChar': 0,
\ 'updateTime': 0,
\ 'rangeChars': [],
\ 'formatStr' : '',
\ 'units' : ''
\ }
function! s:GenericProgressBar.mCreate(rangechars, depthchar, fmtStr)
let pbr = deepcopy(s:GenericProgressBar)
unlet pbr.mCreate
let pbr.rangeChars = a:rangechars
let pbr.depthChar = a:depthchar
let pbr.formatStr = a:fmtStr
return pbr
endfunction
function! s:GenericProgressBar.mSetDepth(val) dict
let self.depth = a:val
endfunction
function! s:GenericProgressBar.mUpdate() dict
let staticchars = repeat(self.depthChar, self.depth)
let displayStr = substitute(self.formatStr, "\@PROGRESS\@",
\ staticchars . self.rangeChars[self.currentChar], "")
call s:StatusLine.mSetExtraInfo(displayStr)
endfunction
function! s:GenericProgressBar.mDone()
call s:StatusLine.mSetExtraInfo("")
endfunction
let s:ProgressBarRoll = {
\ 'updateTime' : 0,
\ 'curTime' : 0
\}
function! s:ProgressBarRoll.mCreate(rollchars, depthChar) dict
let gpbr = s:GenericProgressBar.mCreate(a:rollchars, a:depthChar, "\@PROGRESS\@")
let pbr = extend(gpbr, deepcopy(s:ProgressBarRoll))
unlet pbr.mCreate
let pbr.curTime = localtime()
return pbr
endfunction
function! s:ProgressBarRoll.mTick(count) dict
if (localtime() - self.curTime) > self.updateTime
let self.currentChar += 1
if self.currentChar == len(self.rangeChars)
let self.currentChar = 0
endif
let self.curTime = localtime()
call self.mUpdate()
endif
endfunction
let s:ProgressBarNumeric = {
\ 'progress1current' : 0,
\ 'progressmax' : 0,
\ 'progress1percent' : 0,
\ 'progresspercent' : 0,
\}
function! s:ProgressBarNumeric.mCreate(maxcount, unit) dict
let gpbr = s:GenericProgressBar.mCreate(range(0,200), '',
\ "Processing \@PROGRESS\@\%, total ". a:maxcount . " " . a:unit)
let progressbar = extend(gpbr, deepcopy(s:ProgressBarNumeric))
unlet progressbar.mCreate
let progressbar.progressmax = a:maxcount
let progressbar.progress1percent = a:maxcount/100
let progressbar.units = a:unit
return progressbar
endfunction
function! s:ProgressBarNumeric.mTick(count) dict
let self.progress1current += a:count
if self.progress1percent <= self.progress1current
let tmp = (self.progress1current/self.progress1percent)
let self.progresspercent += tmp
let self.progress1current -= tmp * self.progress1percent
let self.currentChar += 1
call self.mUpdate()
endif
endfunction
" }}}
" {{{ Status line
let s:StatusLine = {
\ 'symlastprogress' : 0,
\ 'symprogress' : 0,
\ 'cursym' : 0,
\ 'savedStatusLine' : '',
\ 'statusextra' : '',
\ 'local':0
\}
function! s:StatusLine.mInit() dict
let self.savedStatusLine = &l:statusline
setlocal statusline=%{CCTreeStatusLine()}
endfunction
function! s:StatusLine.mRestore() dict
let self.currentstatus = ''
let self.statusextra = ''
let &l:statusline = s:StatusLine.savedStatusLine
redrawstatus
endfunction
function! s:StatusLine.mSetInfo(msg) dict
let s:StatusLine.currentstatus = a:msg
redrawstatus
endfunction
function! s:StatusLine.mSetExtraInfo(msg) dict
let s:StatusLine.statusextra = a:msg
redrawstatus
endfunction
function! CCTreeStatusLine()
return s:pluginname. " ".
\ s:StatusLine.currentstatus . " -- ".
\ s:StatusLine.statusextra
endfunction
"}}}
" {{{ Shell command interface
let s:ShellCmds = {'shellOutput': ''}
function! s:ShellCmds.mSplit(inFile, outFile)
let cmdEx = substitute(g:CCTreeSplitProgCmd, "PROG_SPLIT", g:CCTreeSplitProg,"")
let cmdEx = substitute(cmdEx, "SPLIT_OPT", g:CCTreeSplitProgOption,"")
if g:CCTreeDbFileSplitLines != -1
let cmdEx = substitute(cmdEx, "SPLIT_SIZE", g:CCTreeDbFileSplitLines,"")
else
let cmdEx = substitute(cmdEx, "SPLIT_SIZE", g:CCTreeDbFileMaxSize,"")
endif
let cmdEx = substitute(cmdEx, "IN_FILE", a:inFile,"")
let cmdEx = substitute(cmdEx, "OUT_FILE_PREFIX", a:outFile,"")
return cmdEx
endfunction
function! s:ShellCmds.mJoin(inFileList, outFile)
let cmdEx = substitute(g:CCTreeJoinProgCmd, "PROG_JOIN", g:CCTreeJoinProg,"")
let cmdEx = substitute(cmdEx, "JOIN_OPT", g:CCTreeJoinProgOpts,"")
let cmdEx = substitute(cmdEx, "IN_FILES", a:inFileList,"")
let cmdEx = substitute(cmdEx, "OUT_FILE", a:outFile,"")
return cmdEx
endfunction
function! s:ShellCmds.mExec(cmd)
let s:shellOutput= system(a:cmd)
if s:shellOutput != ''
" Failed
return s:CCTreeRC.Error
endif
return s:CCTreeRC.Success
endfunction
" }}}
" {{{ Virtual file interface
let s:vFile = {}
function! s:vFile.mCreate(fname, mode)
if a:mode == 'r'
return s:vFileR.mCreate(a:fname)
elseif a:mode == 'w'
return s:vFileW.mCreate(a:fname)
endif
return -1
endfunction
let s:vFileW = {
\ 'splitfiles' : [],
\ 'totSplits' : 0,
\ 'lines' : [],
\ 'fileSize' : 0
\}
function! s:vFileW.mCreate(fname) dict
let vfile = deepcopy(s:vFileW)
unlet vfile.mCreate
let vfile.link = a:fname
return vfile
endfunction
function! s:vFileW.mCreateSplit() dict
" first split, create name
if self.totSplits == 0
let self.tlink = tempname()
endif
let fname = self.tlink .'_'. self.totSplits
call writefile(self.lines, fname)
call add(self.splitfiles, fname)
let self.lines = []
let self.totSplits += 1
endfunction
function! s:vFileW.mTestForSplit() dict
if self.fileSize > g:CCTreeDbFileMaxSize
call self.mCreateSplit()
endif
endfunction
function! s:vFileW.mAddFileSize(size) dict
let self.fileSize += a:size
endfunction
function! s:vFileW.mWriteList(linelist) dict
call extend(self.lines, a:linelist)
call self.mTestForSplit()
endfunction
function! s:vFileW.mWriteLine(line) dict
call add(self.lines, a:line)
call self.mAddFileSize(len(a:line))
call self.mTestForSplit()
endfunction
function! s:vFileW.mClose() dict
if self.totSplits == 0
call writefile(self.lines, self.link)
else
" force remaining lines into a new split
call self.mCreateSplit()
" now join all of them
let filelist = join(self.splitfiles, " ")
let cmdEx = s:ShellCmds.mJoin(filelist, self.link)
if s:ShellCmds.mExec(cmdEx) != s:CCTreeRC.Success
let msg = s:shellOutput ."Shell command: ".cmdEx. " failed!".
\ " Refer help to setup split/join utils."
call s:CCTreeUtils.mWarningPrompt(msg)
endif
endif
for afile in self.splitfiles
call delete(afile)
endfor
return 0
endfunction
let s:vFileR = {
\ 'splitfiles' : [],
\ 'currentSplitIdx' : 0,
\ 'totSplits' : 0,
\ 'lines' : [],
\ 'valid' : 0,
\ 'mode' : ""
\}
function! s:vFileR.mIsLargeFile() dict
if (getfsize(self.link) > g:CCTreeDbFileMaxSize)
return 1
endif
return 0
endfunction
function! s:vFileR.mCreate(fname) dict
let vfile = deepcopy(s:vFileR)
unlet vfile.mCreate
let vfile.link = a:fname
let vfile.valid = filereadable(a:fname)
let vfile.size = getfsize(a:fname)
return vfile
endfunction
function! s:vFileR.mOpen() dict
if self.mode == 'w'
" no need to do anything
return 0
endif
if self.mIsLargeFile() == 0
"little trick to keep interface uniform when we don't split
call add(self.splitfiles, self.link)
let self.totSplits = 1
else
let tmpDb = tempname()
let cmdEx = s:ShellCmds.mSplit(self.link, tmpDb)
if s:ShellCmds.mExec(cmdEx) != s:CCTreeRC.Success
let msg = s:shellOutput ."Shell command: ".cmdEx. " failed!".
\ " Refer help to setup split/join utils."
call s:CCTreeUtils.mWarningPrompt(msg)
return -1
else
let self.splitfiles = split(expand(tmpDb."*"), "\n")
endif
if empty(self.splitfiles)
return -1
endif
endif
let self.totSplits = len(self.splitfiles)
return 0
endfunction
function! s:vFileR.mRead() dict
if (self.currentSplitIdx >= len(self.splitfiles))
" out of bounds
return -1
endif
let self.lines = readfile(self.splitfiles[self.currentSplitIdx])
let self.currentSplitIdx += 1
return 0
endfunction
function! s:vFileR.mRewind() dict
let self.currentSplitIdx = 0
let self.lines = []
endfunction
function! s:vFileR.mClose() dict
if self.totSplits == 1
return
endif
for afile in self.splitfiles
call delete(afile)
endfor
endfunction
"}}}
" {{{Stop watch
let s:StopWatch = {
\ 'text' : "(no reltime feature)",
\}
function! s:StopWatch.mCreate() dict
let stopWatch = deepcopy(s:StopWatch)
unlet stopWatch.mCreate
call stopWatch.mReset()
return stopWatch
endfunction
function! s:StopWatch.mReset() dict
if has('reltime')
let self.startRTime = reltime()
else
let self.startRTime = localtime()
endif
endfunction
function! s:StopWatch.mSnapElapsed() dict
if has('reltime')
let self.text = reltimestr(reltime(self.startRTime))
else
let self.text = localtime() - self.startRTime
endif
endfunction
function! s:StopWatch.mGetText() dict
return self.text
endfunction
"}}}
" {{{ Digraph character compression/decompression routines
let s:CharMaps = {
\'savedEncoding' : '',
\'mapkind' : ''
\}
" The encoding needs to be changed to 8-bit, otherwise we can't swap special
" 8-bit characters; restore after done
function! s:CharMaps.mInitTranslator() dict
if self.mapkind == 'Alpha'
let self.savedEncoding = &encoding
let &encoding="latin1"
endif
endfunction
function! s:CharMaps.mDoneTranslator() dict
if self.mapkind == 'Alpha'
let &encoding=self.savedEncoding
endif
endfunction
function! s:CharMaps.CrossProduct(seq1, seq2) dict
let cpSeq = []
for dc1 in range(strlen(a:seq1))
for dc2 in range(strlen(a:seq2))
call add(cpSeq, a:seq1[dc1].a:seq2[dc2])
endfor
endfor
return cpSeq
endfunction
let s:TranslateMap = {}
function! s:TranslateMap.mCreate (srcsym, destsym, mapkind, regex) dict
let dicttable = extend(deepcopy(s:CharMaps), deepcopy(s:TranslateMap))
unlet dicttable.CrossProduct
let dicttable.mappings = {}
" map lower
let maxsym = min([len(a:srcsym),len (a:destsym)])
let index = 0
while (index < maxsym)
let dicttable.mappings[a:srcsym[index]] = a:destsym[index]
let index += 1
endwhile
" Need mapping lens, we assume it's constant across the board
let dicttable.mapsrclen = len(a:srcsym[0])
let dicttable.regex = a:regex
if a:mapkind == 'Alpha'
let dicttable.mTranslate = dicttable.mTranslateAlpha
elseif a:mapkind == 'Numeric'
let dicttable.mTranslate = dicttable.mTranslateNumeric
endif
let dicttable.mapkind = a:mapkind
unlet dicttable.mTranslateNumeric
unlet dicttable.mTranslateAlpha
return dicttable
endfunction
function! s:TranslateMap.mTranslateNumeric(value) dict
let index = 0
let retval = ""
" remember to deal with multi-byte characters
while index < len(a:value)
let char1 = char2nr(a:value[index])
if has_key(self.mappings, char1)
let newmap = self.mappings[char1]
else
" take only the first character
let newmap = a:value[index]
endif
let retval .= newmap
let index += 1
endwhile
return retval
endfunction
function! s:TranslateMap.mTranslateAlpha(value) dict
let retval = substitute(a:value, self.regex, '\=self.mappings[submatch(1)]', "g")
return retval
endfunction
function! s:CCTreeGetXRefDbMaps(maptype, mapkind)
let dichar1 = ",0123456789"
let dichar2 = ",0123456789"
return s:CCTreeCreateGenericMaps(a:maptype, a:mapkind, dichar1, dichar2)
endfunction
function! s:CCTreeGetCscopeMaps(maptype, mapkind)
let dichar1 = " teisaprnl(of)=c"
let dichar2 = " tnerpla"
return s:CCTreeCreateGenericMaps(a:maptype, a:mapkind, dichar1, dichar2)
endfunction
function! s:CCTreeCreateGenericMaps(maptype, mapkind, dichar1, dichar2)
let s:CharMaps.mapkind = a:mapkind
call s:CharMaps.mInitTranslator()
if a:mapkind == 'Numeric'
let ab = map(range(128,255), 'v:val')
elseif a:mapkind == 'Alpha'
let ab = map(range(128,255), 'nr2char(v:val)')
else
return {}
endif
let ac = s:CharMaps.CrossProduct(a:dichar1, a:dichar2)
if a:maptype == 'Compress'
let maps = s:TranslateMap.mCreate(ac, ab, a:mapkind,
\'\(['.a:dichar1.']['.a:dichar2.']\)\C')
elseif a:maptype == 'Uncompress'
let maps = s:TranslateMap.mCreate(ab, ac, a:mapkind,
\'\([\d128-\d255]\)')
endif
call s:CharMaps.mDoneTranslator()
return maps
endfunction
" }}}
" {{{ Unique list filter object
let s:UniqList = {}
function! s:UniqList.mFilterEntries(lstval) dict
let valdict = {}
let reslist = ''
for aval in a:lstval
if !has_key(valdict, aval)
let valdict[aval] = ''
let reslist .= (aval . ",")
endif
endfor
return reslist
endfunction
let s:CCTreeUniqListFilter = deepcopy(s:UniqList)
function! s:CCTreeMakeCommaListUnique(clist)
let entries = split(a:clist, ",")
if len(entries) > 0
return s:CCTreeUniqListFilter.mFilterEntries(entries)
endif
return ""
endfunction
" }}}
" {{{ Buffer/Window
func! s:FindOpenBuffer(filename)
let bnrHigh = bufnr("$")
"tabpagebuflist(tabpagenr())
for bufnrs in range(1, bnrHigh)
if (bufexists(bufnrs) == 1 && bufname(bufnrs) == a:filename && bufloaded(bufnrs) != 0 )
return bufnrs
endif
endfor
" Could not find the buffer
return 0
endfunction
func! s:FindOpenWindow(filename)
let bufnr = s:FindOpenBuffer(a:filename)
if (bufnr > 0)
let newWinnr = bufwinnr(bufnr)
if newWinnr != -1
exec newWinnr.'wincmd w'
return 1
endif
endif
" Could not find the buffer
return 0
endfunction
" }}}
" {{{ Utils library
let s:Utils = {}
" Use this function to determine the correct "g" flag
" for substitution
function! s:Utils.mGetSearchFlag(gvalue)
let ret = (!a:gvalue)* (&gdefault) + (!&gdefault)*(a:gvalue)
if ret == 1
return 'g'
endif
return ''
endfunc
" Strlen works for multibyte characters
function! s:Utils.mStrlenEx(val)
return strlen(substitute(a:val, ".", "x", "g"))
endfunc
" }}}
" {{{ Generic db loader interface
let s:GenericDbLdr = {
\ 'fDBName' : '',
\ 'class' : 'Generic',
\ }
function! s:GenericDbLdr.mCreate(fname) dict
let gdb = deepcopy(s:GenericDbLdr)
unlet gdb.mCreate
let gdb.fDBName = a:fname
if !filereadable(a:fname)
return s:CCTreeRC.Error
endif
return gdb
endfunction
function! s:GenericDbLdr.mParseDbHeader(gRdr)
let header = readfile(self.fDBName, "", a:gRdr.headerLines)
return a:gRdr.mParseDbHeader(header)
endfunction
let s:XRefMemDbLdr = {
\ 'class' : s:DBStorage.memory
\}
function! s:XRefMemDbLdr.mCreate(fname) dict
let gdb = s:GenericDbLdr.mCreate(a:fname)
if type(gdb) != type({})
return gdb
endif
let mdb = extend(gdb, deepcopy(s:XRefMemDbLdr))
unlet mdb.mCreate
return mdb
endfunction
if has('perl') && g:CCTreeUsePerl == 1
" Perl function
function! s:XRefMemDbLdr.mLoadFileIntoXRefDb(xRefDb, gRdr) dict
let stage = 1
for afltr in a:gRdr.opts
let stageidxstr = 'Stage ('.stage.'/'.len(a:gRdr.opts).') '
call s:StatusLine.mSetInfo(stageidxstr. ': (PERL) Loading database ')
call a:gRdr.mProcessingStateInit()
let pBar = s:ProgressBarNumeric.mCreate(getfsize(self.fDBName), "bytes")
echomsg 'filtering '. afltr
perl << PERL_EOF
#use strict;
#use warnings FATAL => 'all';
#use warnings NONFATAL => 'redefine';
my $filebytes = 0;
my $filterpat = VIM::Eval("afltr");
open (CSCOPEDB, VIM::Eval("self.fDBName")) or die "File trouble!";
#VIM::DoCommand("echomsg '".$filterpat."'");
while (<CSCOPEDB>) {
$filebytes += length($_);
chomp($_);
if ($_ !~ $filterpat) {
next;
}
VIM::DoCommand("call pBar.mTick(".$filebytes.")");
$filebytes = 0;
VIM::DoCommand("call a:gRdr.mProcessSymbol(a:xRefDb, '".$_."')");
}
VIM::DoCommand("call pBar.mDone()");
close(CSCOPEDB);
PERL_EOF
call a:gRdr.mProcessingStateDone()
let stage += 1
endfor
endfunction
else
" Native Vim function
function! s:XRefMemDbLdr.mLoadFileIntoXRefDb(xRefDb, gRdr) dict
let vDbFile = s:vFile.mCreate(self.fDBName, "r")
if vDbFile.valid == 0
return -1
endif
if vDbFile.mIsLargeFile() == 1
call s:StatusLine.mSetExtraInfo('Database '
\.' >'.g:CCTreeDbFileMaxSize .' bytes. Splitting '.
\'into smaller chunks... (this may take some time)')
endif
try
if vDbFile.mOpen() == 0
call self.mReadFileIntoXRefDb(vDbFile,
\ a:xRefDb,
\ a:gRdr)
endif
finally
call vDbFile.mClose()
endtry
endfunction
endif
function! s:XRefMemDbLdr.mReadFileIntoXRefDb(vDbFile, xrefdb, gRdr)
let stage = 0
for afltr in a:gRdr.opts
call a:vDbFile.mRewind()
let stage += 1
call a:gRdr.mProcessingStateInit()
while 1 == 1
if a:vDbFile.mRead() == -1
break
endif
let stageidxstr = 'Stage ('.stage.'/'.len(a:gRdr.opts).') '
let fileidxstr = '('.a:vDbFile.currentSplitIdx.'/'.a:vDbFile.totSplits.') '
call s:StatusLine.mSetInfo(stageidxstr. ': Reading database chunk '.fileidxstr)
" Filter-out lines that doesn't have relevant information
let plist = a:gRdr.mReadLinesFromFile(a:vDbFile, afltr)
let pBar = s:ProgressBarNumeric.mCreate(len(plist), "items")
call s:StatusLine.mSetInfo(stageidxstr.': Analyzing database chunk '.fileidxstr)
call self.mProcessListIntoXrefDb(plist, a:gRdr, a:xrefdb, pBar)
call pBar.mDone()
" clean-up memory
call garbagecollect()
endwhile
call a:gRdr.mProcessingStateDone()
endfor
endfunction
function! s:XRefMemDbLdr.mProcessListIntoXrefDb(symbols, rdr, xrefdb, pbar)
for a in a:symbols
call a:pbar.mTick(1)
call a:rdr.mProcessSymbol(a:xrefdb, a)
endfor
endfunction
function! s:GenericDbLdr.mParseDbHeader(gRdr)
let header = readfile(self.fDBName, "", a:gRdr.headerLines)
return a:gRdr.mParseDbHeader(header)
endfunction
" }}}
" {{{ Generic Disk DB Ldr
let s:XRefDiskDbLdr = {
\ 'class' : s:DBStorage.disk
\ }
function! s:XRefDiskDbLdr.mCreate(fname) dict
let gdb = s:GenericDbLdr.mCreate(a:fname)
if type(gdb) != type({})
return gdb
endif
let mdb = extend(gdb, deepcopy(s:XRefDiskDbLdr))
unlet mdb.mCreate
return mdb
endfunction
function! s:XRefDiskDbLdr.mLoadFileIntoXRefDb(xRefDb, gRdr) dict
call a:xRefDb.mSetLink(self.fDBName)
endfunction
"}}}
" {{{ Xref disk DB
let s:XRefDiskDb = {
\ 'link':'',
\ 'savedTags': '',
\ 'class' : s:DBStorage.disk
\ }
function! s:XRefDiskDb.mCreate() dict
let fdb = deepcopy(s:XRefDiskDb)
unlet fdb.mCreate
let fdb.maps = s:CCTreeGetXRefDbMaps('Uncompress', 'Numeric')
return fdb
endfunction
function! s:XRefDiskDb.mSetLink(filedb) dict
let self.link = a:filedb
" revisit, do parse header here
endfunction
function! s:XRefDiskDb.mClear() dict
" do nothing
endfunction
function! s:XRefDiskDb.mInitState() dict
let self.savedTags = &tags
let &tags = self.link
endfunction
function! s:XRefDiskDb.mRestoreState() dict
let &tags = self.savedTags
endfunction
function! s:XRefDiskDb.mDecodeTagEntry(tagentry) dict
let itms = split(a:tagentry.name, "#")
let a:tagentry.n = itms[1]
let a:tagentry.idx = itms[0]
" Vim taglist() drops empty fields, so need to protect
if has_key(a:tagentry, 'c')
let a:tagentry.c = self.maps.mTranslate(a:tagentry.c)
else
let a:tagentry.c = ''
endif
if has_key(a:tagentry, 'p')
let a:tagentry.p = self.maps.mTranslate(a:tagentry.p)
else
let a:tagentry.p = ''
endif
return a:tagentry
endfunction
function! s:XRefDiskDb.mGetSymbolIdFromName(symname) dict
let symtagline = taglist('\#'.a:symname.'$')
let g:xyz = symtagline
let asym = self.mDecodeTagEntry(symtagline[0])
return asym.idx
endfunction
function! s:XRefDiskDb.mGetSymbolFromId(symid) dict
let symtagline = taglist('^'.a:symid.'\#')
if empty(symtagline)
echomsg "Failed to locate ".a:symid
else
return self.mDecodeTagEntry(symtagline[0])
endif
return {}
endfunction
function! s:XRefDiskDb.mGetSymbolIds() dict
" illegal
let symtaglines = taglist('^.')
return keys(self.symidhash)
endfunction
function! s:XRefDiskDb.mGetSymbolNames(lead) dict
if empty(a:lead)
let symtaglines = taglist('^.')
else
let symtaglines = taglist('#'.a:lead)
endif
let alist = []
for atag in symtaglines
let acctreesym = self.mDecodeTagEntry(atag)
call add(alist, acctreesym.n)
endfor
return alist
endfunction
" }}}
" {{{ TagFile utils
let s:CCTreeTagDbRdr = {'class': 'CCTreeXrefDb',
\ 'headerLines' : 4,
\ 'compressed' : 0,
\ 'opts': ['v:val !~ "^[\!]"'],
\ 'perl_opts': "^[^\!]",
\ 'mapPreKeys': {'c':'','p':''},
\ 'mapPostKeys': {'c':'','p':''}
\ }
function! s:CCTreeTagDbRdr.mCreate(fname) dict
let cctxdbrdr = deepcopy(s:CCTreeTagDbRdr)
unlet cctxdbrdr.mCreate
return cctxdbrdr
endfunction
function! s:CCTreeTagDbRdr.mRequirePreProcessing() dict
return s:CCTreeRC.False
endfunction
function! s:CCTreeTagDbRdr.mRequirePostProcessing() dict
return s:CCTreeRC.True
endfunction
function! s:CCTreeTagDbRdr.mRequireCleanup() dict
" Clean-up all symbols [never]
return s:CCTreeRC.False
endfunction
function! s:CCTreeTagDbRdr.mGetPreProcessingMaps() dict
return s:CCTreeGetXRefDbMaps('Compress', 'Alpha')
endfunction
function! s:CCTreeTagDbRdr.mGetPostProcessingMaps() dict
return s:CCTreeGetXRefDbMaps('Uncompress', 'Alpha')
endfunction
function! s:CCTreeTagDbRdr.mParseDbHeader(hdr) dict
" just check line 3 for sanity
if a:hdr[2] =~ "CCTree"
return s:CCTreeRC.Success
endif
return s:CCTreeRC.Error
endfunction
function! s:CCTreeTagDbRdr.mProcessingStateInit() dict
endfunction
function! s:CCTreeTagDbRdr.mProcessingStateDone() dict
endfunction
function! s:CCTreeTagDbRdr.mReadLinesFromFile(vdbFile, filtercmds) dict
" Hard-coded assumptions here about format for performance
if empty(get(a:vdbFile.lines, 0)) != 1 && a:vdbFile.lines[0][0] == "!"
" filter out the first few lines starting with "!"
call remove(a:vdbFile.lines, 0, self.headerLines-1)
endif
return a:vdbFile.lines
endfunction
function! s:CCTreeTagDbRdr.mProcessSymbol(xrefdb, aline) dict
let cctreesym = self.mDecodeTagLine(a:aline)
call a:xrefdb.mInsertSym(cctreesym.idx, cctreesym)
" we really don't need idx any longer
unlet cctreesym.idx
endfunction
function! s:CCTreeTagDbRdr.mDecodeTagLine(tagline) dict
let items = split(a:tagline, "\t")
let newsym = s:CCTreeSym.mCreate("")
try
let [newsym.idx, newsym.n] = split(items[0], '#')
catch
echomsg "problem decoding ". a:tagline
endtry
"let newsym.idx = strpart(items[0], 0, idxBr)
"let newsym.n = items[0][ idxBr+1 : -2] "strpart(items[0], idxBr+1, strlen(items[0])-1)
if empty(get(items, 3)) != 1
let newsym.c = items[3][2:]
endif
if empty(get(items, 4)) != 1
let newsym.p = items[4][2:]
endif
return newsym
endfunction
" }}}
" {{{ Generic Db Serializer
let s:GenericDbSerializer = {}
function! s:GenericDbSerializer.mCreate(xrefdb) dict
let gDbSerializer = deepcopy(s:GenericDbSerializer)
let gDbSerializer.xrefdb = a:xrefdb
return gDbSerializer
endfunction
function! s:GenericDbSerializer.mWriteXRefDbToFile(fname,
\ gWriter) dict
call s:StatusLine.mInit()
try
call s:StatusLine.mSetInfo('Writing XRefDb')
let vDbFile = s:vFile.mCreate(a:fname, "w")
call vDbFile.mWriteList(a:gWriter.mBuildHeader())
call self.mWriteSymsToFile(vDbFile, a:gWriter)
finally
call vDbFile.mClose()
call s:StatusLine.mRestore()
endtry
endfunction
function! s:GenericDbSerializer.mWriteSymsToFile(dstVFile,
\ gWriter) dict
let pBar = s:ProgressBarNumeric.mCreate(self.xrefdb.mGetSymbolCount(),
\ "items")
call a:gWriter.mInitWriting()
" write syms
for asymid in sort(self.xrefdb.mGetSymbolIds())
let acctreesym = self.xrefdb.mGetSymbolFromId(asymid)
call a:dstVFile.mWriteLine(a:gWriter.mBuildTagLine(acctreesym,
\ asymid))
call pBar.mTick(1)
endfor
call pBar.mDone()
call a:gWriter.mDoneWriting()
endfunction
" }}}
" {{{ CCTreeTagDb Writer
let s:CCTreeTagDbWriter = {}
function! s:CCTreeTagDbWriter.mCreate(tmaps) dict
let dbwriter = deepcopy(s:CCTreeTagDbWriter)
unlet dbwriter.mCreate
let dbwriter.tmaps = a:tmaps
return dbwriter
endfunction
function! s:CCTreeTagDbWriter.mInitWriting() dict
call self.tmaps.mInitTranslator()
endfunction
function! s:CCTreeTagDbWriter.mDoneWriting() dict
call self.tmaps.mDoneTranslator()
endfunction
function! s:CCTreeTagDbWriter.mBuildHeader() dict
let hdr = []
call add(hdr, "!_TAG_FILE_FORMAT\t2\t/extended format; --format=1 will not append ;\" to lines/")
call add(hdr, "!_TAG_FILE_SORTED\t1\t/0=unsorted, 1=sorted, 2=foldcase/")
call add(hdr, "!_TAG_PROGRAM_NAME\t\tCCTree (Vim plugin)//")
call add(hdr, "!_TAG_PROGRAM_URL\thttp://vim.sourceforge.net/scripts/script.php?script_id=2368\t/site/")
return hdr
endfunction
function! s:CCTreeTagDbWriter.mBuildTagLine(sym, symid) dict
let basetag = a:symid .'#'. a:sym.n."\t"."\t"."/^\$/".";\""
let cm = self.tmaps.mTranslate(a:sym.c)
let pm = self.tmaps.mTranslate(a:sym.p)
let basetag .= "\tc:". self.tmaps.mTranslate(a:sym.c)
let basetag .= "\tp:". self.tmaps.mTranslate(a:sym.p)
return basetag
endfunction
" }}}
" {{{ CCTree constants
let s:CCTreeRC = {
\ 'Error' : -1,
\ 'True' : 1,
\ 'False' : 0,
\ 'Success' : 2
\ }
"}}}
" {{{ CCTree DB Obj
" Symbol definition
let s:CCTreeSym = {
\'k': "",
\'n': "",
\'c': "",
\'p': ""
\}
function! s:CCTreeSym.mCreate(name, kind)
let sym = deepcopy(s:CCTreeSym)
unlet sym.mCreate
let sym.n = a:name
let sym.k = a:kind
return sym
endfunction
" }}}
" {{{ GenericXref, XrefDb
let s:GenericXRef = {}
function! s:GenericXRef.mCreate(filedb) dict
let gxref = deepcopy(s:GenericXRef)
return gxref
endfunction
function! s:GenericXRef.mInitState() dict
endfunction
function! s:GenericXRef.mRestoreState() dict
endfunction
" {{{ XRef Database object
let s:xRefMemDb = {
\ 'symuniqid': 0,
\ 'symidhash' : {},
\ 'symnamehash' : {},
\ 'class' : s:DBStorage.memory
\}
function s:xRefMemDb.mCreate() dict
let dbObj = deepcopy(s:xRefMemDb)
unlet dbObj.mCreate
return dbObj
endfunction
function s:xRefMemDb.mInitState() dict
endfunction
function s:xRefMemDb.mRestoreState() dict
endfunction
function s:xRefMemDb.mClear() dict
let self.symidhash = {}
let self.symnamehash = {}
let self.symuniqid = 0
endfunction
function! s:xRefMemDb.mInsertSym(idx, cctreesym) dict
let self.symuniqid = max([self.symuniqid, a:idx])
let self.symidhash[a:idx] = a:cctreesym
let self.symnamehash[a:cctreesym.n] = a:idx
endfunction
function! s:xRefMemDb.mRemoveSymById(symidx) dict
call self.mRemoveSymByName(acctreesym.n)
call remove(self.symidhash, a:symidx)
endfunction
function! s:xRefMemDb.mRemoveSymByName(symname) dict
call remove(self.symnamehash, a:symname)
endfunction
function! s:xRefMemDb.mAddSym(name, kind) dict
if !has_key(self.symnamehash, a:name)
let self.symnamehash[a:name] = self.symuniqid
let self.symidhash[self.symuniqid] =
\s:CCTreeSym.mCreate(a:name, a:kind)
let self.symuniqid += 1
endif
let asymid = self.symnamehash[a:name]
if a:kind != ""
let asym = self.symidhash[asymid]
let asym.k = a:kind
endif
return asymid
endfunction
function! s:xRefMemDb.mMarkXRefSyms(funcentryidx, newfuncidx) dict
let self.symidhash[a:funcentryidx]['c'] .= (",". a:newfuncidx)
let self.symidhash[a:newfuncidx]['p'] .= (",". a:funcentryidx)
endfunction
function! s:xRefMemDb.mGetSymbolFromName(symname) dict
return self.symidhash[self.symnamehash[a:symname]]
endfunction
function! s:xRefMemDb.mGetSymbolIdFromName(symname) dict
if has_key(self.symnamehash, a:symname)
return self.symnamehash[a:symname]
else
return s:CCTreeRC.Error
endif
endfunction
function! s:xRefMemDb.mGetSymbolFromId(symid) dict
return self.symidhash[a:symid]
endfunction
function! s:xRefMemDb.mGetSymbolIds() dict
return keys(self.symidhash)
endfunction
function! s:xRefMemDb.mGetSymbolNames(lead) dict
let syms = keys(self.symnamehash)
if empty(a:lead) != 1
return filter(syms, 'v:val =~? a:lead')
endif
return syms
endfunction
function! s:xRefMemDb.mGetSymbolCount() dict
return len(self.symnamehash)
endfunction
function! s:xRefMemDb.mTranslateSymbols(map, tkeys) dict
call a:map.mInitTranslator()
let pBar = s:ProgressBarNumeric.mCreate(len(self.symnamehash), "items")
for asym in keys(self.symnamehash)
let idx = self.symnamehash[asym]
let val = self.symidhash[idx]
if has_key(a:tkeys, 'n')
let uncmpname = a:map.mTranslate(asym)
if (asym != uncmpname)
"Set up new entry
let self.symnamehash[uncmpname] = idx
" free the old entry
call remove(self.symnamehash, asym)
" Set uncompressed name
let val.n = uncmpname
endif
endif
if has_key(a:tkeys, 'p')
let val.p = a:map.mTranslate(val.p)
endif
if has_key(a:tkeys, 'c')
let val.c = a:map.mTranslate(val.c)
endif
call pBar.mTick(1)
endfor
call pBar.mDone()
call a:map.mDoneTranslator()
endfunction
function! s:xRefMemDb.mCleanSymbols () dict
let pBar = s:ProgressBarNumeric.mCreate(len(self.symnamehash), "items")
for asym in keys(self.symnamehash)
let idx = self.symnamehash[asym]
let val = self.symidhash[idx]
if empty(val.p) && empty(val.c)
call remove(self.symnamehash, asym)
call remove(self.symidhash, idx)
else
let val.p = s:CCTreeMakeCommaListUnique(val.p)
let val.c = s:CCTreeMakeCommaListUnique(val.c)
endif
call pBar.mTick(1)
endfor
call pBar.mDone()
endfunction
"}}}
"}}} End of Xref
" {{{ Tracer
let s:CallTree = {
\ 'symbol' : ""
\ }
function! s:CallTree.mCreate(name) dict
let ct = deepcopy(s:CallTree)
unlet ct.mCreate
let ct.symbol = a:name
return ct
endfunction
function! s:CallTree.mAddChildLink(childTree) dict
if !has_key(self, 'childlinks')
let self.childlinks = []
endif
call add(self.childlinks, a:childTree)
endfunction
let s:XRefTracer = {
\}
function! s:XRefTracer.mCreate(xrefdb) dict
let xreftracer = deepcopy(s:XRefTracer)
let xreftracer.xrefdb = a:xrefdb
return xreftracer
endfunction
function! s:XRefTracer.mInitTracing() dict
call self.xrefdb.mInitState()
endfunction
function! s:XRefTracer.mDoneTracing() dict
call self.xrefdb.mRestoreState()
endfunction
function! s:XRefTracer.mGetSymbolIdXRef(symid, direction) dict
let acctreesym = self.xrefdb.mGetSymbolFromId(a:symid)
let symidslist = split(
\s:CCTreeMakeCommaListUnique(acctreesym[a:direction]), ",")
return symidslist
endfunction
function! s:XRefTracer.mBuildForSymbol(symid, curdepth, maxdepth,
\ direction, pbar) dict
if (a:curdepth > a:maxdepth)
return {}
endif
call a:pbar.mSetDepth(a:curdepth)
let asym = self.xrefdb.mGetSymbolFromId(a:symid)
" revisit
if empty(asym)
return {}
endif
let rtree = s:CallTree.mCreate(asym['n'])
for entry in self.mGetSymbolIdXRef(a:symid, a:direction)
call a:pbar.mTick(1)
let ctree =
\self.mBuildForSymbol(entry, a:curdepth+1, a:maxdepth,
\a:direction, a:pbar)
call rtree.mAddChildLink(ctree)
endfor
return rtree
endfunction
" }}}
" {{{ Cscope Reader
let s:CscopeDbRdrState = {
\'curfuncidx': -1,
\'curfileidx': -1,
\'curmacroidx': -1,
\'curenumidx': -1,
\ }
function! s:CscopeDbRdrState.mCreate() dict
return deepcopy(s:CscopeDbRdrState)
endfunction
let s:CscopeDbRdrSymTags = {
\'func' : '$}',
\'macro' : '#\)',
\'file' : '@\~',
\'enum' : 'em',
\'global' : 'g',
\'typedef' : 't',
\}
let s:CscopeDbSymFilter = ['v:val =~ "^\t[#`$}@\~\)]"']
let s:CscopeDbSymEnhFilter = ['v:val =~ "^\t[emgt#`$}@~)]"',
\ 'v:val =~ "^\\a\\|^\t[)$}#]"']
let s:CscopeDbSymFilterPerl = ['^\t[\`\#\$\}\@\~\)]']
let s:CscopeDbSymEnhFilterPerl = ['^\t[\`\#\$\}\@\~\)emgt]',
\ '^[A-Za-z]|^\t[\#\$\}\)]']
let s:CscopeDbRdr = {
\ 'class': 'Cscope',
\ 'headerLines' : 1,
\ 'compressed' : 0,
\ 'opts': [],
\ 'perl_opts': '',
\ 'mapPreKeys': {'n':''},
\ 'mapPostKeys': {'n':''}
\}
function! s:CscopeDbRdr.mCreate(fname, enhanced) dict
let csdbrdr = deepcopy(s:CscopeDbRdr)
unlet csdbrdr.mCreate
if a:enhanced == 1
if g:CCTreeUsePerl == 1
let csdbrdr.opts = s:CscopeDbSymEnhFilterPerl
else
let csdbrdr.opts = s:CscopeDbSymEnhFilter
endif
else
if g:CCTreeUsePerl == 1
let csdbrdr.opts = s:CscopeDbSymFilterPerl
else
let csdbrdr.opts = s:CscopeDbSymFilter
endif
endif
return csdbrdr
endfunction
function! s:CscopeDbRdr.mProcessingStateInit() dict
let self.iState = s:CscopeDbRdrState.mCreate()
endfunction
function! s:CscopeDbRdr.mProcessingStateDone() dict
" discard state
unlet self.iState
endfunction
function! s:CscopeDbRdr.mReadLinesFromFile(vDbFile, filtercmds) dict
return s:CCTreeUtils.mFilter(a:vDbFile.lines, a:filtercmds)
endfunction
function! s:CscopeDbRdr.mParseDbHeader(dbHeader) dict
if a:dbHeader[0] =~ "cscope"
if (a:dbHeader[0] !~ "cscope.*\-c")
let self.compressed = s:CCTreeRC.True
else
let self.compressed = s:CCTreeRC.False
endif
return s:CCTreeRC.Success
endif
return s:CCTreeRC.Error
endfunction
function! s:CscopeDbRdr.mRequirePreProcessing() dict
return (self.compressed == 1)? s:CCTreeRC.True : s:CCTreeRC.False
endfunction
function! s:CscopeDbRdr.mRequirePostProcessing() dict
return (self.compressed == 1)? s:CCTreeRC.True : s:CCTreeRC.False
endfunction
function! s:CscopeDbRdr.mRequireCleanup() dict
" Clean-up all symbols [always]
return s:CCTreeRC.True
endfunction
function! s:CscopeDbRdr.mGetPreProcessingMaps() dict
return s:CCTreeGetCscopeMaps('Compress', 'Alpha')
endfunction
function! s:CscopeDbRdr.mGetPostProcessingMaps() dict
return s:CCTreeGetCscopeMaps('Uncompress', 'Alpha')
endfunction
function! s:CscopeDbRdr.mProcessSymbol(xrefdb, symbol) dict
try
if a:symbol[0] == "\t"
return self.mProcessTaggedSymbol(a:xrefdb, a:symbol)
else
return self.mProcessUnTaggedSymbol(a:xrefdb, a:symbol)
endif
catch
echomsg 'Problem with '. a:symbol
endtry
endfunction
function! s:CscopeDbRdr.mProcessUnTaggedSymbol(xrefdb, symbol) dict
let cursymidx = a:xrefdb.mGetSymbolIdFromName(a:symbol)
if cursymidx != s:CCTreeRC.Error
if self.iState.curfuncidx != -1
call a:xrefdb.mMarkXRefSyms(self.iState.curfuncidx, cursymidx)
elseif self.iState.curmacroidx != -1
call a:xrefdb.mMarkXRefSyms(self.iState.curmacroidx, cursymidx)
endif
endif
endfunction
function! s:CscopeDbRdr.mProcessTaggedSymbol(xrefdb, symbol) dict
if self.iState.curmacroidx != -1
if a:symbol[1] == "`"
call a:xrefdb.mMarkXRefSyms(self.iState.curmacroidx,
\ a:xrefdb.mAddSym(a:symbol[2:], ""))
elseif a:symbol[1] == ')'
let self.iState.curmacroidx = -1
endif
elseif self.iState.curfuncidx != -1
" inside function
if a:symbol[1] == "`"
call a:xrefdb.mMarkXRefSyms(self.iState.curfuncidx,
\ a:xrefdb.mAddSym(a:symbol[2:], ""))
elseif a:symbol[1] == "}"
let self.iState.curfuncidx = -1
elseif a:symbol[1] == "#"
let self.iState.curmacroidx = a:xrefdb.mAddSym(a:symbol[2:], 'm')
endif
elseif self.iState.curenumidx != -1
if a:symbol[1] == "m"
call a:xrefdb.mMarkXRefSyms(self.iState.curenumidx,
\ a:xrefdb.mAddSym(a:symbol[2:], "em"))
else
" just reprocess the symbol after changing state
let self.iState.curenumidx = -1
call self.mProcessTaggedSymbol(a:xrefdb, a:symbol)
endif
elseif a:symbol[1] == "$"
let self.iState.curfuncidx = a:xrefdb.mAddSym(a:symbol[2:], "f")
elseif a:symbol[1] == "#"
let self.iState.curmacroidx = a:xrefdb.mAddSym(a:symbol[2:], "d")
elseif a:symbol[1] == "~"
call a:xrefdb.mMarkXRefSyms(self.iState.curfileidx,
\a:xrefdb.mAddSym(a:symbol[3:], "i"))
elseif a:symbol[1] == "e"
let self.iState.curenumidx = a:xrefdb.mAddSym(a:symbol[2:], "e")
elseif a:symbol[1] == "g"
call a:xrefdb.mAddSym(a:symbol[2:], "g")
elseif a:symbol[1] == "@"
if a:symbol[2] != ""
let self.iState.curfileidx =
\a:xrefdb.mAddSym(a:symbol[2:], "F")
endif
endif
endfunction
" }}}
" {{{ CCTree helper library
let s:CCTreeUtils = {}
function! s:CCTreeUtils.mDetectDB(class)
if a:class == s:DBClasses.cctreexref
if filereadable(g:CCTreeDb)
return g:CCTreeDb
endif
elseif a:class == s:DBClasses.cscopeid
if filereadable(g:CCTreeCscopeDb)
return g:CCTreeCscopeDb
endif
endif
return ''
endfunction
function! s:CCTreeUtils.mFilter(lines, filtercmd) dict
let retlst = []
let progr = len(a:lines)/100
let pBar = s:ProgressBarNumeric.mCreate(len(a:lines), "items")
while len(a:lines) > 0
if progr <= len(a:lines)
let tmplist = remove(a:lines, 0, progr)
else
let tmplist = remove(a:lines, 0, len(a:lines)-1)
endif
call filter(tmplist, a:filtercmd)
call pBar.mTick(progr)
call extend(retlst, tmplist)
endwhile
call pBar.mDone()
return retlst
endfunction
function! s:CCTreeUtils.mWarningPrompt(msg) dict
echohl WarningMsg
let a = input(s:pluginname. ": ". a:msg)
echohl None
endfunction
function! s:CCTreeUtils.mWarningMsg(msg) dict
echohl WarningMsg
echomsg s:pluginname. ": ". a:msg
echohl None
endfunction
function! s:CCTreeUtils.mInfoMsg(msg) dict
echohl Title
echomsg s:pluginname. ": ". a:msg
echohl None
endfunction
function! s:CCTreeUtils.mWrite(msg) dict
echo s:pluginname. ": ". a:msg
endfunction
" }}}
" {{{ CCTree DB management
let s:CCTreeXrefDbEntry = {
\ 'type': '',
\ 'fname' : '',
\ 'fsize' : 0,
\ 'fdate' : 0
\}
function! s:CCTreeXrefDbEntry.mCreate(fname, type) dict
let xrefdbent = deepcopy(s:CCTreeXrefDbEntry)
unlet xrefdbent.mCreate
let xrefdbent.type = a:type
let xrefdbent.fname = simplify(getcwd().'/'.a:fname)
let xrefdbent.fsize = getfsize(a:fname)
let xrefdbent.fdate = strftime("%c", getftime(a:fname))
return xrefdbent
endfunction
let s:CCTreeDBList = {
\'loadedDBs' : []
\ }
function! s:CCTreeDBList.mCreate() dict
let dbList = deepcopy(s:CCTreeDBList)
unlet dbList.mCreate
return dbList
endfunction
function! s:CCTreeDBList.mShowLoaded() dict
let i = 1
call s:CCTreeUtils.mWrite(s:pluginname.": List of loaded cscope databases")
call s:CCTreeUtils.mWrite("---------------------------------------")
for aDBEnt in self.loadedDBs
call s:CCTreeUtils.mWrite(i." ".aDBEnt.fname. " ".
\ " (".aDBEnt.type.") ".
\ aDBEnt.fsize. " bytes ".
\ aDBEnt.fdate)
let i = i + 1
endfor
endfunction
function! s:CCTreeDBList.mClearAll() dict
let self.loadedDBs = []
endfunction
function! s:CCTreeDBList.mIsEmpty() dict
if empty(self.loadedDBs)
return s:CCTreeRC.True
endif
return s:CCTreeRC.False
endfunction
" Load the cscope db into the global cctree xref db
function! s:CCTreeDBList.mCreateDbLoaderAndReader(dbName, dbclass, storageclass) dict
let dbUser = s:CCTreeCmdLine.mInputDBName('Load', a:dbName, a:dbclass)
if dbUser == ''
call s:CCTreeUtils.mWarningMsg('Filename required')
"User cancel, do nothing
return
endif
" Create generic Db loader object
if a:storageclass == s:DBStorage.disk
let gDbLdr = s:XRefDiskDbLdr.mCreate(dbUser)
elseif a:storageclass == s:DBStorage.memory
let gDbLdr = s:XRefMemDbLdr.mCreate(dbUser)
endif
if type(gDbLdr) != type({})
call s:CCTreeUtils.mWarningMsg(a:dbclass.' database ' . a:dbName .
\ ' not found.')
return s:CCTreeRC.Error
endif
" Create new DB reader object
if a:storageclass == s:DBStorage.memory
if a:dbclass == s:DBClasses.cscopeid
let gDbRdr = s:CscopeDbRdr.mCreate(dbUser, g:CCTreeEnhancedSymbolProcessing)
elseif a:dbclass == s:DBClasses.cctreexref
let gDbRdr = s:CCTreeTagDbRdr.mCreate(dbUser)
else
return s:CCTreeRC.Error
endif
if gDbLdr.mParseDbHeader(gDbRdr) == s:CCTreeRC.Error
call s:CCTreeUtils.mWarningMsg(gDbRdr.class.' database ' . a:dbName .
\ ' format is not parseable.')
return s:CCTreeRC.Error
endif
else
let gDbRdr = {}
endif
return {'loader': gDbLdr, 'reader': gDbRdr}
endfunction
function! s:CCTreeDBList.mAddDbToList(dbName, type)
let aDBEnt = s:CCTreeXrefDbEntry.mCreate(a:dbName, a:type)
call add(self.loadedDBs, aDBEnt)
endfunction
" Merge the cscope db into the global cctree xref db
function! s:CCTreeDBList.mMerge(dbName, xRefDb, class)
" Check if merge can be supported
if self.loadedDBs[0].type == s:DBStorage.disk
call s:CCTreeUtils.mInfoMsg("Cannot merge with DBs traced from disk")
return
endif
" Create db loader, reader
let gObjs = self.mCreateDbLoaderAndReader(a:dbName, a:class, s:DBStorage.memory)
if type(gObjs) == type({})
" if Db is compressed, then we need to compress our symbols first
let swatch = s:StopWatch.mCreate()
if self.mLoadDB(gObjs.loader, a:xRefDb,
\ gObjs.reader) != s:CCTreeRC.Error
call self.mAddDbToList(gObjs.loader.fDBName, gObjs.loader.class)
let msg = "Done merging databases. xRef Symbol Count: "
\.a:xRefDb.mGetSymbolCount()
\.". Time taken: ".swatch.mGetText()." secs"
call s:CCTreeUtils.mInfoMsg(msg)
endif
" Load will auto decompress the symbols
endif
endfunction
" Load the cscope db into the global cctree xref db
function! s:CCTreeDBList.mAddNew(dbName, xRefDb, dbclass, storageclass)
" Create db loader, reader
let gObjs = self.mCreateDbLoaderAndReader(a:dbName, a:dbclass, a:storageclass)
if type(gObjs) == type({})
let swatch = s:StopWatch.mCreate()
if self.mLoadDB(gObjs.loader, a:xRefDb,
\ gObjs.reader) != s:CCTreeRC.Error
call self.mAddDbToList(gObjs.loader.fDBName, gObjs.loader.class)
call swatch.mSnapElapsed()
if a:storageclass == s:DBStorage.memory
let msg = "Done loading database. xRef Symbol Count: "
\.a:xRefDb.mGetSymbolCount()
\.". Time taken: ".swatch.mGetText()." secs"
else
let msg = "Disk Xref database loaded for tracing"
endif
call s:CCTreeUtils.mInfoMsg(msg)
endif
endif
endfunction
function! s:CCTreeDBList.mLoadDB(gDbLdr, xRefDb, gRdr)
let rc = s:CCTreeRC.Success
try
let swatch = s:StopWatch.mCreate()
call s:StatusLine.mInit()
" if compression, then we need to compress our symbols first
if !empty(a:gRdr) && a:gRdr.mRequirePreProcessing() == s:CCTreeRC.True
call s:StatusLine.mSetInfo('Pre-processing existing symbols')
call a:xRefDb.mTranslateSymbols(a:gRdr.mGetPreProcessingMaps(),
\ a:gRdr.mapPreKeys)
endif
call garbagecollect()
call s:StatusLine.mSetInfo('Loading database')
call a:gDbLdr.mLoadFileIntoXRefDb(a:xRefDb, a:gRdr)
if !empty(a:gRdr) && a:gRdr.mRequireCleanup() == s:CCTreeRC.True
call s:StatusLine.mSetInfo('Symbol clean-up')
call a:xRefDb.mCleanSymbols()
endif
call garbagecollect()
if !empty(a:gRdr) && a:gRdr.mRequirePostProcessing() == s:CCTreeRC.True
call s:StatusLine.mSetInfo('Post-processing loaded symbols')
call a:xRefDb.mTranslateSymbols(a:gRdr.mGetPostProcessingMaps(),
\ a:gRdr.mapPostKeys)
endif
call swatch.mSnapElapsed()
" restore normalcy
call garbagecollect()
redraw
catch /^Vim:Interrupt$/ " catch interrupts (CTRL-C)
call s:CCTreeUtils.mWarningMsg('Loading aborted.')
let rc = s:CCTreeRC.Error
finally
call s:StatusLine.mRestore()
endtry
return rc
endfunction
"}}}
" {{{ UI Input related
let s:CCTreeUI = {}
function! s:CCTreeUI.mInputDBName(dbName, class, action)
let dbUser = a:dbName
let dbUser = input(a:action. ' database ('. a:class. '): ', a:dbName, 'file')
return dbUser
endfunction
" }}}
" {{{ CCTree Markers
let s:TreeMarkers_UTF8 = {
\ 'splitT' : nr2char(0x251c),
\ 'arrowR' : nr2char(0x25c0),
\ 'arrowF' : nr2char(0x25B6),
\ 'extV' : nr2char(0x2502),
\ 'extH': nr2char(0x2500),
\ 'depth': nr2char(0x25BC)
\}
let s:TreeMarkers_Text = {
\ 'splitT' : '+',
\ 'arrowF' : '>',
\ 'arrowR' : '<',
\ 'extV' : '|',
\ 'extH': '-',
\ 'depth': 'depth:'
\}
let s:CCTreeMarkers = {
\ 'icons':{}
\ }
function! s:CCTreeMarkers.mCreate() dict
let treeMarkers = deepcopy(s:CCTreeMarkers)
if &encoding == 'utf-8' && g:CCTreeUseUTF8Symbols == 1
let treeMarkers.icons = deepcopy(s:TreeMarkers_UTF8)
else
" default choice
let treeMarkers.icons = deepcopy(s:TreeMarkers_Text)
endif
let treeMarkers.icons.arrowSyms = treeMarkers.icons.arrowF . treeMarkers.icons.arrowR
let treeMarkers.icons.vertSyms = treeMarkers.icons.splitT . treeMarkers.icons.extV
return treeMarkers
endfunction
function! s:CCTreeMarkers.mGetArrow(direction) dict
if a:direction == 'p'
return self.icons.arrowR
elseif a:direction == 'c'
return self.icons.arrowF
endif
return '?'
endfunction
" }}}
" {{{ User key mappings
let s:CCTreeKeyMappings = {
\ 'CTreeF': g:CCTreeKeyTraceForwardTree,
\ 'CTreeR': g:CCTreeKeyTraceReverseTree,
\ 'CTreeHilight': g:CCTreeKeyHilightTree,
\ 'CTreeWSave': g:CCTreeKeySaveWindow,
\ 'CTreeWToggle': g:CCTreeKeyToggleWindow,
\ 'CTreeCompress': g:CCTreeKeyCompressTree,
\ 'CTreeDepthMinus': g:CCTreeKeyDepthMinus,
\ 'CTreeDepthPlus': g:CCTreeKeyDepthPlus
\}
" }}}
" {{{ CCTreeWindow
let s:CCTreeWindow = {
\ 'hiKeyword': '',
\ 'hiKeywordLine':'',
\ 'lastbufname':'',
\ 'treeMarkers': s:CCTreeMarkers.mCreate()}
function! s:CCTreeWindow.mCreate() dict
let win = deepcopy(s:CCTreeWindow)
unlet win.mCreate
return win
endfunction
function! s:CCTreeWindow.mLeave()
call s:FindOpenWindow(self.lastbufname)
endfunction
" Definition of a keyword...
let s:CCTreeKeywordRegEx = '[A-Za-z0-9_\\\.\/]\+'
function! s:CCTreeWindow.mGetKeywordAtCursor() dict
let curline = line(".")
let self.hiKeyword = ''
if foldclosed(curline) == -1
let curkeyword = matchstr(getline("."), s:CCTreeKeywordRegEx)
if curkeyword != ''
if curkeyword != self.hiKeyword || curline != self.hiKeywordLine
let self.hiKeyword = curkeyword
let self.hiKeywordLine = line(".")
return s:CCTreeRC.Success
endif
else
return s:CCTreeRC.Error
endif
endif
if self.hiKeyword == ''
return s:CCTreeRC.Error
endif
return s:CCTreeRC.Success
endfunction
function! s:CCTreeWindow.mBuildStatusLine(pState, title, items)
let needcomma = 0
let rtitle = a:title. ' ('. a:pState.keyword
let rtitle .= '['
if has_key(a:items, "depth")
let rtitle .= self.treeMarkers.icons.depth
let rtitle .= a:pState.depth
let needcomma = 1
endif
if has_key(a:items, "direction")
if needcomma == 1
let rtitle .= ','
endif
let rtitle .= self.treeMarkers.mGetArrow(a:pState.direction)
endif
let rtitle .= '])'
return rtitle
endfunction
function! CCTreeWindowPreviewStatusLine()
" get global
" this is a hack
let pState = s:CCTreeGlobals.PreviewState
let tMarkers = s:CCTreeGlobals.Window.treeMarkers
return s:CCTreeGlobals.Window.mBuildStatusLine(
\ s:CCTreeGlobals.PreviewState,
\ s:windowtitle,
\ {'depth':''}
\)
endfunction
function! s:CCTreeWindow.mPreviewSave(savetitle) dict
if s:FindOpenWindow(s:windowtitle) == 1
setlocal modifiable
call self.mClearMarks(b:displayTree)
setlocal nomodifiable
setlocal statusline=%-F
silent! exec ":f ". a:savetitle
return s:CCTreeRC.Success
endif
return s:CCTreeRC.Error
endfunction
function! s:CCTreeWindow.mIsOpen() dict
if s:FindOpenBuffer(s:windowtitle) > 0
return s:CCTreeRC.True
endif
return s:CCTreeRC.False
endfunction
function! s:CCTreeWindow.mClose() dict
if s:FindOpenWindow(s:windowtitle) == 1
silent! q!
endif
endfunction
function! s:CCTreeWindow.mDisplayToggle() dict
if s:FindOpenWindow(s:windowtitle) == 1
silent! hide
else
let winbufnr = s:FindOpenBuffer(s:windowtitle)
if winbufnr > 0
call self.mEnter()
silent! exec "buf ".winbufnr
call self.mResize()
silent! wincmd p
else
call s:CCTreeUtils.mWarningMsg(" No active window found.")
endif
endif
endfunction
function! s:CCTreeWindow.mResize() dict
if g:CCTreeWindowVertical == 1
if g:CCTreeWindowWidth == -1
exec "vertical resize ". b:maxwindowlen
else
exec "vertical resize ". g:CCTreeWindowWidth
endif
else
if g:CCTreeWindowHeight != -1
let &winminheight = g:CCTreeWindowHeight
exec "resize".g:CCTreeWindowHeight
endif
endif
endfunction
function! s:CCTreeWindow.mDisplayTree(atree, direction) dict
let incctreewin = 1
if (bufname('%') != s:windowtitle)
let incctreewin = self.mEnter()
endif
setlocal modifiable
silent 1,$d
let b:maxwindowlen = g:CCTreeWindowMinWidth
let b:displayTree = s:DisplayTree.mCreate(a:atree,
\ a:direction, self.treeMarkers)
call s:CCTreeDisplay.mPopulateTreeInCurrentBuffer(b:displayTree)
exec "normal gg"
" Need to force this again
let &l:foldlevel=g:CCTreeMinVisibleDepth
setlocal nomodifiable
call self.mResize()
if (incctreewin == 0)
call s:CCTreeWindow.mLeave()
endif
endfunction
function! s:CCTreeWindow.mExtractTreeSymbols(dtree)
let symlist = {}
for aentry in a:dtree.entries
let symlist[aentry.symbol] = 0
endfor
return symlist
endfunction
function! s:CCTreeWindow.mEnter() dict
let self.lastbufname = bufname("%")
let foundWindow = s:FindOpenWindow(s:windowtitle)
if foundWindow == 0
if g:CCTreeWindowVertical == 1
exec g:CCTreeOrientation." vsplit ". s:windowtitle
set winfixwidth
else
exec g:CCTreeOrientation." split ". s:windowtitle
set winfixheight
endif
setlocal buftype=nofile
setlocal bufhidden=hide
setlocal noswapfile
setlocal nonumber
setlocal nowrap
setlocal nobuflisted
if s:CCTreeUseConceal == 1
setlocal cole=3
setlocal cocu=nv
endif
setlocal statusline=%=%{CCTreeWindowPreviewStatusLine()}
call self.mInitSyntax(self.treeMarkers.icons)
let cpo_save = &cpoptions
set cpoptions&vim
call s:CCTreeBufferKeyMappingsCreate(s:CCTreeKeyMappings)
command! -buffer -nargs=0 CCTreeWindowHiCallTree
\ call s:CCTreeGlobals.mCursorHoldHandleEvent()
exec 'nnoremap <buffer> <silent> '.s:CCTreeKeyMappings.CTreeHilight.
\' :CCTreeWindowHiCallTree<CR>'
exec 'nnoremap <buffer> <silent> '.s:CCTreeKeyMappings.CTreeCompress.
\ ' :2,.foldclose!<CR>zv'
nnoremap <buffer> <silent> <C-p> :CCTreePreviewBufferUsingTag<CR>
nnoremap <buffer> <silent> <CR> :CCTreeLoadBufferUsingTag<CR>
nnoremap <buffer> <silent> <2-LeftMouse> :CCTreeLoadBufferUsingTag<CR>
let &cpoptions = cpo_save
endif
setlocal foldmethod=expr
setlocal foldexpr=CCTreeFoldExpr(getline(v:lnum))
setlocal foldtext=CCTreeFoldText()
let &l:foldlevel=g:CCTreeMinVisibleDepth
return foundWindow
endfunction
" }}}
" {{{ Dynamic call-tree highlighting using
" syntax highlight tricks
"
" There are 3 types of lines, marked with the start character [\s, !, #]
" Also @ is used to mark the path that is going up
function! s:CCTreeWindow.mMarkCallTree(dtree, keyword) dict
let declevel = -1
let treelst = a:dtree.entries
let curLine = line(".")
let declevel = treelst[curLine-1].level
let targetlevel = declevel
for idx in range(curLine, 1, -1)
let aentry = treelst[idx-1]
" Find our keyword
let linemarker = 0
" Skip folds
if declevel != -1 && foldclosed(idx) == -1
if targetlevel == aentry.level
let linemarker = 1
let targetlevel -= 1
endif
let aline = a:dtree.mGetNotationalTxt(aentry.level, targetlevel+1, linemarker, 1)
\ . aentry.symbol
call setline(idx, aline)
endif
endfor
endfunction
function! s:CCTreeWindow.mClearMarks(dtree) dict
for idx in range(line(".")+1, line("$"))
let breakout = (getline(idx)[0] !~ "[!#]")
if breakout == 1
break
endif
let aentry = a:dtree.entries[idx-1]
let aline = a:dtree.mGetNotationalTxt(aentry.level, -1, 0, 0)
\ . aentry.symbol
call setline(idx, aline)
endfor
endfunction
function! s:CCTreeWindow.mInitSyntax(markers) dict
"syntax match CCTreePathMark /\s[|+]/ contained
exec 'syntax match CCTreePathMark /\s['. a:markers.vertSyms . ']/ contained'
"syntax match CCTreeArrow /-*[<>]/ contained
exec 'syntax match CCTreeArrow /'.a:markers.extH.'*['. a:markers.arrowSyms .']/ contained'
syntax match CCTreeSymbol / [A-Za-z0-9_\.\\\/]\+/ contained
syntax region CCTreeSymbolLine start="^\s" end="$" contains=CCTreeArrow,CCTreePathMark,CCTreeSymbol oneline
"syntax match CCTreeHiArrow /-*[<>]/ contained
exec 'syntax match CCTreeHiArrow /'. a:markers.extH .'*['. a:markers.arrowSyms .']/ contained'
syntax match CCTreeHiSymbol / [A-Za-z0-9_\.\\\/]\+/ contained
"syntax match CCTreeHiPathMark /\s[|+]/ contained
exec 'syntax match CCTreeHiPathMark /\s[' . a:markers.vertSyms . ']/ contained'
if s:CCTreeUseConceal == 1
syntax match CCTreeMarkExcl /^[!#]/ contained conceal
syntax match CCTreeMarkTilde /@/ contained conceal
else
syntax match CCTreeMarkExcl /^[!#]/ contained
syntax match CCTreeMarkTilde /@/ contained
endif
"syntax region CCTreeUpArrowBlock start="@" end=/[|+]/ contains=CCTreeMarkTilde contained oneline
exec 'syntax region CCTreeUpArrowBlock start="@" end=/['. a:markers.vertSyms .']/ contains=CCTreeMarkTilde contained oneline'
syntax region CCTreeHiSymbolLine start="!" end="$" contains=CCTreeMarkExcl,
\ CCTreeUpArrowBlock,
\ CCTreeHiSymbol,CCTreeHiArrow,CCTreeHiPathMark oneline
syntax region CCTreeMarkedSymbolLine start="#" end="$" contains=CCTreeMarkExcl,
\ CCTreeMarkTilde,CCTreePathMark,
\ CCTreeArrow,CCTreeSymbol,CCTreeUpArrowBlock oneline
endfunction
" }}}
" {{{ CCTreeDisplay
let s:CCTreeDisplay = {}
function! s:CCTreeDisplay.mPopulateTreeInCurrentBuffer(dtree)
let linelist = []
for aentry in a:dtree.entries
let aline = a:dtree.mGetNotationalTxt(aentry.level, -1, 0, 0)
\ . aentry.symbol
let len = s:Utils.mStrlenEx(aline)
let b:maxwindowlen = max([len+1, b:maxwindowlen])
call add(linelist, aline)
endfor
call setline(".", linelist)
endfunction
" }}}
" {{{ CCTree command line interface
let s:CCTreeCmdLine = {}
function! s:CCTreeCmdLine.mLoadDBFromDisk(dbName) dict
call s:CCTreeGlobals.mUnLoadDBs()
let s:CCTreeGlobals.XRefDb = s:XRefDiskDb.mCreate()
call s:CCTreeGlobals.DbList.mAddNew(a:dbName,
\ s:CCTreeGlobals.XRefDb, s:DBClasses.cctreexref, "Disk")
endfunction
" Unload current db's and load new one
" There is no selective unloading
function! s:CCTreeCmdLine.mLoadDB(db_name, class) dict
call s:CCTreeGlobals.mSetupEncodingChangeAutoCmd(0)
call s:CCTreeGlobals.mUnLoadDBs()
let s:CCTreeGlobals.XRefDb = s:xRefMemDb.mCreate()
call s:CCTreeGlobals.DbList.mAddNew(a:db_name,
\ s:CCTreeGlobals.XRefDb, a:class, s:DBStorage.memory)
call s:CCTreeGlobals.mSetupAutoCmds()
endfunction
function! s:CCTreeCmdLine.mInputDBName(action, dbName, class) dict
if a:dbName == ''
let dbUser = s:CCTreeUI.mInputDBName(
\ s:CCTreeUtils.mDetectDB(a:class),
\ a:class, a:action)
else
let dbUser = a:dbName
endif
return dbUser
endfunction
function! s:CCTreeCmdLine.mSaveDB(dbName, class) dict
let dbUser = self.mInputDBName('Save', a:dbName, a:class)
if dbUser == ''
call s:CCTreeUtils.mWarningMsg('Filename required')
return
endif
call s:CCTreeGlobals.Window.mClose()
call s:CCTreeGlobals.mSetupEncodingChangeAutoCmd(0)
call s:CCTreeGlobals.mWriteXRefDbToFile(dbUser)
call s:CCTreeGlobals.mSetupAutoCmds()
call s:CCTreeGlobals.mUpdateForCurrentSymbol()
endfunction
" Merge current db with new one
function! s:CCTreeCmdLine.mMergeDB(db_name, class) dict
"call s:CCTreeGlobals.Window.mClose()
call s:CCTreeGlobals.DbList.mMerge(a:db_name, s:CCTreeGlobals.XRefDb, a:class)
endfunction
" }}}
" {{{ CCTree Buffer mappings
function! s:CCTreeWindowGetHiKeyword()
let keyw = expand("<cword>")
let keyf = expand("<cfile>")
let syms = s:CCTreeGlobals.mGetPreviewTreeSymbols()
if keyw != keyf
if has_key(syms, keyf)
return keyf
elseif has_key(syms, keyw)
return keyw
endif
else
return keyw
endif
return ''
endfunction
" Keymappings used common to source files and CCTree window
function! s:CCTreeBufferKeyMappingsCreate(kmaps)
let func_expr = '<SNR>'.s:sid.'CCTreeWindowGetHiKeyword()'
exec 'nnoremap <buffer> <silent> '.a:kmaps.CTreeR.' :CCTreeTraceReverse <C-R>='.
\ func_expr.'<CR><CR>'
exec 'nnoremap <buffer> <silent> '.a:kmaps.CTreeF.' :CCTreeTraceForward <C-R>='
\ .func_expr.'<CR><CR>'
exec 'nnoremap <silent> '.a:kmaps.CTreeWSave. ' :CCTreeWindowSaveCopy<CR>'
exec 'nnoremap <silent> '.a:kmaps.CTreeWToggle. ' :CCTreeWindowToggle<CR>'
exec 'nnoremap <buffer> <silent> '.a:kmaps.CTreeDepthPlus.
\ ' :CCTreeRecurseDepthPlus<CR>'
exec 'nnoremap <buffer> <silent> '.a:kmaps.CTreeDepthMinus.
\ ' :CCTreeRecurseDepthMinus<CR>'
endfunction
augroup CCTreeMaps
au!
" Header files get detected as cpp?
" This is a bug in Vim 7.2, a patch needs to be applied to the runtime c
" syntax files
" For now, use this hack to make *.h files work
autocmd FileType * if &ft == 'c'|| &ft == 'cpp' |
\ call s:CCTreeBufferKeyMappingsCreate(s:CCTreeKeyMappings)|
\ endif
augroup END
" }}}
" {{{ Tree building
let s:DisplayTreeEntry = {
\ 'symbol': "",
\ 'level': -1
\ }
function! s:DisplayTreeEntry.mCreate(sym, level) dict
let te = deepcopy(s:DisplayTreeEntry)
let te.symbol = a:sym
let te.level = a:level
unlet te.mCreate
return te
endfunction
let s:calltreemaxdepth = 10
let s:DisplayTree = {
\ 'entries': [],
\ 'levelMaxLen': repeat([255], s:calltreemaxdepth),
\ 'notTxt': {}
\ }
function! s:DisplayTree.mCreate(calltree, direction, markers) dict
let dt = deepcopy(s:DisplayTree)
call dt.mBuildTreeForLevel(a:calltree, 0)
call dt.mBuildNotationalTxtMarkers(a:direction, a:markers.icons)
unlet dt.mBuildTreeForLevel
unlet dt.mCreate
return dt
endfunction
function! s:DisplayTree.mBuildTreeForLevel(ctree, level)
if !has_key(a:ctree, 'symbol')
return
endif
if g:CCTreeDisplayMode == 3
let curlevellen = strlen(a:ctree.symbol) + a:level + 2
let self.levelMaxLen[a:level] = min([self.levelMaxLen[a:level],
\ curlevellen])
endif
let aentry = s:DisplayTreeEntry.mCreate(a:ctree.symbol, a:level)
call add(self.entries, aentry)
if has_key(a:ctree, 'childlinks')
for alink in a:ctree['childlinks']
call self.mBuildTreeForLevel(alink, a:level+1)
endfor
endif
endfunction
function! s:DisplayTree.mBuildNotationalTxtMarkers(direction, markerSyms) dict
" REVISIT
if a:direction == 'p'
let directiontxt = a:markerSyms.arrowR . " "
elseif a:direction == 'c'
let directiontxt = a:markerSyms.arrowF . " "
endif
let self.notTxt.arrowHead = a:markerSyms.splitT
let self.notTxt.arrow = directiontxt
let self.notTxt.arrowLead = a:markerSyms.extH
let self.notTxt.sep = a:markerSyms.extV
if s:CCTreeUseConceal == 1
let concealspace = " "
else
let concealspace = ""
endif
let self.notTxt.symHighlighter= concealspace . "@"
let self.notTxt.hiSymbolMarker = "!".concealspace
let self.notTxt.hiBranchMarker = "#".concealspace
let self.notTxt.cache = {}
endfunction
function! s:DisplayTree.mGetNotationalTxt(depth, hiDepth, hiSym, hiPath) dict
let notkey = join(a:000, ":")
if has_key(self.notTxt.cache,notkey) == 1
return self.notTxt.cache[notkey]
else
return self.mBuildNotationalTxt(a:depth, a:hiDepth, a:hiSym, a:hiPath)
endif
endfunction
function! s:DisplayTree.mBuildNotationalTxt(depth, hiDepth, hiSym, hiPath) dict
let hiBranch = 0
let curDepth = a:depth
if 0
let Aspace = "A"
let Bspace = "B"
let Cspace = "C"
let Sspace = "S"
let Xspace = "X"
let Zspace = "Z"
let Fspace = "1"
else
let Aspace = " "
let Bspace = " "
let Cspace = " "
let Sspace = " "
let Xspace = " "
let Zspace = " "
let Fspace = " "
endif
if g:CCTreeDisplayMode == 1
let arrowLeads = self.notTxt.arrowLead
elseif g:CCTreeDisplayMode >= 2
let arrowLeads = repeat(self.notTxt.arrowLead, a:depth)
endif
let indentSpace = ""
if g:CCTreeDisplayMode == 2
if curDepth > 0
let indentSpace = repeat(Aspace, curDepth)
endif
elseif g:CCTreeDisplayMode == 3
if curDepth > 0
let indentSpace = repeat(Aspace, self.levelMaxLen[curDepth-1])
endif
endif
let notTxt = self.notTxt.arrowHead. arrowLeads . self.notTxt.arrow
if a:hiDepth == a:depth
let notTxt = indentSpace . self.notTxt.symHighlighter . notTxt
let hiBranch = 1
else
let notTxt = indentSpace. Cspace. notTxt
endif
let curDepth -= 1
let indentSpace = ""
while (curDepth > 0)
if g:CCTreeDisplayMode == 2
let indentSpace = repeat(Bspace, curDepth)
elseif g:CCTreeDisplayMode == 3
let indentSpace = repeat(Bspace, self.levelMaxLen[curDepth-1])
endif
let notTxt = self.notTxt.sep . notTxt
if a:hiDepth == curDepth && a:hiPath == 1
let notTxt = indentSpace . self.notTxt.symHighlighter . notTxt
let hiBranch = 1
else
let notTxt = indentSpace. Cspace. notTxt
endif
let curDepth -= 1
endwhile
if curDepth == 0
" curdepth is 0
if a:hiDepth == curDepth && a:hiPath == 1
let notTxt = self.notTxt.symHighlighter . notTxt
let hiBranch = 1
else
let notTxt = Fspace . notTxt
endif
let curDepth -= 1
endif
" adjust space
if a:depth > 0
let notTxt = Xspace . notTxt
endif
if hiBranch == 1
if a:hiSym == 1
let notTxt = self.notTxt.hiSymbolMarker . notTxt
else
let notTxt = self.notTxt.hiBranchMarker . notTxt
endif
else
let notTxt = Sspace . notTxt
endif
return notTxt
endfunction
"}}}
" {{{ Preview window Folding
function! CCTreeFoldExpr(line)
if !exists('b:displayTree') || v:lnum > len(b:displayTree.entries)
return 0
endif
let lvl = b:displayTree.entries[v:lnum-1].level
if lvl == 0
let lvl = 1
endif
return '>'.lvl
endfunction
function! CCTreeFoldText()
if s:CCTreeUseConceal == 1
let line = substitute(getline(v:foldstart), '[!@#]', '' , 'g')
else
let line = substitute(getline(v:foldstart), '[!@#]', ' ' , 'g')
endif
return line. " (+". (v:foldend - v:foldstart).
\ ')'. repeat(" ", winwidth(0))
endfunction
" }}}
" {{{ Syntax coloring definitions
"Standard display
highlight default link CCTreeSymbol Function
highlight default link CCTreeMarkers LineNr
highlight default link CCTreeArrow CCTreeMarkers
highlight default link CCTreePathMark CCTreeArrow
highlight default link CCTreeHiPathMark CCTreePathMark
" highlighted display
highlight default link CCTreeHiKeyword Macro
highlight default link CCTreeHiSymbol TODO
highlight default link CCTreeHiMarkers NonText
highlight default link CCTreeHiArrow CCTreeHiMarkers
highlight default link CCTreeUpArrowBlock CCTreeHiArrow
highlight default link CCTreeMarkExcl Ignore
highlight default link CCTreeMarkTilde Ignore
"}}}
" {{{ CCTree global state
let s:CCTreePreviewState = {
\ 'keyword':'',
\ 'direction': '',
\ 'depth' : ''
\}
function! s:CCTreePreviewState.mCreate()
let state = deepcopy(s:CCTreePreviewState)
unlet state.mCreate
return state
endfunction
function! s:CCTreePreviewState.mStore(symbol, direction)
let self.keyword = a:symbol
let self.direction = a:direction
endfunction
" }}}
" {{{ CCTree global objects
let s:CCTreeGlobals = {
\ 'XRefDb': {},
\ 'DbList': s:CCTreeDBList.mCreate(),
\ 'PreviewState': s:CCTreePreviewState.mCreate(),
\ 'Window': s:CCTreeWindow.mCreate()
\}
let g:CCTreeGlobals = s:CCTreeGlobals
function! s:CCTreeGlobals.mEnable(opt) dict
if (has_key(s:CCTreeOptions, a:opt))
call s:CCTreeOptions[a:opt](1)
else
call s:CCTreeUtils.mWarningMsg('Invalid option')
endif
endfunction
function! s:CCTreeGlobals.mDisable(opt) dict
if (has_key(s:CCTreeOptions, a:opt))
call s:CCTreeOptions[a:opt](0)
else
call s:CCTreeUtils.mWarningMsg('Invalid option')
endif
endfunction
function! s:CCTreeGlobals.mToggle(opt) dict
if (has_key(s:CCTreeOptions, a:opt))
call s:CCTreeOptions[a:opt](-1)
else
call s:CCTreeUtils.mWarningMsg('Invalid option')
endif
endfunction
function! s:CCTreeGlobals.mGetSymNames(lead) dict
call self.XRefDb.mInitState()
let syms = self.XRefDb.mGetSymbolNames(a:lead)
call self.XRefDb.mRestoreState()
return syms
endfunction
function! s:CCTreeGlobals.mGetCallsForSymbol(name, depth, direction) dict
let pbar = s:ProgressBarRoll.mCreate(['-','\','|','/'], '*')
call s:StatusLine.mSetInfo('Building ')
redrawstatus!
" Create tracer
let xtracer = s:XRefTracer.mCreate(self.XRefDb)
call xtracer.mInitTracing()
let symid = self.XRefDb.mGetSymbolIdFromName(a:name)
let xrefs = xtracer.mBuildForSymbol(symid,
\ a:depth, self.PreviewState.depth, a:direction, pbar)
call xtracer.mDoneTracing()
return xrefs
endfunction
function! s:CCTreeGlobals.mShowLoadedDBs() dict
call self.DbList.mShowLoaded()
endfunction
function! s:CCTreeGlobals.mUnLoadDBs() dict
call s:CCTreeGlobals.Window.mClose()
if !empty(s:CCTreeGlobals.XRefDb)
call s:CCTreeGlobals.XRefDb.mClear()
endif
call s:CCTreeGlobals.DbList.mClearAll()
endfunction
function! s:CCTreeGlobals.mSetPreviewState(name, depth, direction) dict
let self.PreviewState.keyword = a:name
let self.PreviewState.direction = a:direction
let self.PreviewState.depth = a:depth
endfunction
function! s:CCTreeGlobals.mUpdateForCurrentSymbol() dict
if self.DbList.mIsEmpty() == s:CCTreeRC.True
return s:CCTreeRC.Error
endif
if self.PreviewState.keyword != ''
let swatch = s:StopWatch.mCreate()
" Move this function to globals?
call s:StatusLine.mInit()
let atree = self.mGetCallsForSymbol(self.PreviewState.keyword,
\ 0,
\ self.PreviewState.direction)
call s:StatusLine.mRestore()
call self.Window.mDisplayTree(atree, self.PreviewState.direction)
call swatch.mSnapElapsed()
endif
endfunction
function! s:CCTreeGlobals.mGetPreviewTreeSymbols()
" REVIST
if exists('b:displayTree')
return self.Window.mExtractTreeSymbols(b:displayTree)
end
return {}
endfunction
function! s:CCTreeGlobals.mSanitizeCallDepth() dict
let error = 0
if self.PreviewState.depth >= s:calltreemaxdepth
self.PreviewState.depth = s:calltreemaxdepth
let error = 1
elseif self.PreviewState.depth < 1
let self.PreviewState.depth = 1
let error = 1
endif
if error == 1
call s:CCTreeUtils.mWarningMsg('Depth out of bounds')
endif
return error
endfunction
function! s:CCTreeGlobals.mRecursiveDepthIncrease() dict
let self.PreviewState.depth += 1
if self.mSanitizeCallDepth() == 0
call self.mUpdateForCurrentSymbol()
endif
endfunction
function! s:CCTreeGlobals.mRecursiveDepthDecrease() dict
let self.PreviewState.depth -= 1
if self.mSanitizeCallDepth() == 0
call self.mUpdateForCurrentSymbol()
endif
endfunction
function! s:CCTreeGlobals.mDisplayToggle() dict
call self.Window.mDisplayToggle()
endfunction
function! s:CCTreeGlobals.mSetupAutoCmds() dict
augroup CCTreeGeneral
au!
augroup END
call s:CCTreeGlobals.mSetupCursorMoveAutoCmd(g:CCTreeHilightCallTree)
call s:CCTreeGlobals.mSetupEncodingChangeAutoCmd(g:CCTreeUseUTF8Symbols)
endfunction
function! s:CCTreeGlobals.mSetupCursorMoveAutoCmd(enable) dict
if a:enable == 1
exec 'autocmd CCTreeGeneral CursorMoved '.s:windowtitle.' call s:CCTreeGlobals.mCursorHoldHandleEvent()'
else
exec 'autocmd! CCTreeGeneral CursorMoved '.s:windowtitle
endif
endfunction
function! s:CCTreeGlobals.mSetupEncodingChangeAutoCmd(enable) dict
return
if a:enable == 1
autocmd CCTreeGeneral EncodingChanged * call s:CCTreeGlobals.mEncodingChangedHandleEvent()
else
autocmd! CCTreeGeneral EncodingChanged *
endif
endfunction
function! s:CCTreeGlobals.mPreviewSave() dict
let rtitle = s:CCTreeGlobals.Window.mBuildStatusLine(
\ s:CCTreeGlobals.PreviewState,
\ s:windowsavetitle,
\ {'depth':'', 'direction':''}
\)
if self.Window.mPreviewSave(rtitle) == s:CCTreeRC.Success
call s:CCTreeUtils.mInfoMsg('Window saved as '. rtitle .
\ '. New window will be opened on next usage.')
else
call s:CCTreeUtils.mWarningMsg('No active window found to be saved.')
endif
endfunction
function! s:CCTreeGlobals.mWriteXRefDbToFile(fname) dict
" create db serializer and writer
let gDbSz = s:GenericDbSerializer.mCreate(self.XRefDb)
let gDbWriter = s:CCTreeTagDbWriter.mCreate(
\ s:CCTreeGetXRefDbMaps('Compress', 'Alpha'))
call gDbSz.mWriteXRefDbToFile(a:fname, gDbWriter)
endfunction
function! s:CCTreeGlobals.mReadToXRefDb(fname) dict
call s:StatusLine.mInit()
call s:StatusLine.mSetInfo('Reading XRefDb')
let vDbFile = s:vFile.mCreate(a:fname, "r")
if vDbFile.mIsLargeFile() == 1
call s:StatusLine.mSetExtraInfo('Xref DB '
\.' >'.g:CCTreeDbFileMaxSize .' bytes. Splitting '.
\'into smaller chunks... (this may take some time)')
endif
try
if vDbFile.mOpen() == 0
call s:TagFile.mReadToXRefDb(self.XRefDb, vDbFile)
endif
finally
call vDbFile.mClose()
call s:StatusLine.mRestore()
call self.DbList.mAddDbToList(a:fname, s:DBStorage.memory)
endtry
endfunction
function! s:CCTreeGlobals.mCursorHoldHandleEvent() dict
if self.Window.mGetKeywordAtCursor() != s:CCTreeRC.Error
setlocal modifiable
call self.Window.mClearMarks(b:displayTree)
call self.Window.mMarkCallTree(b:displayTree,
\ self.Window.hiKeyword)
setlocal nomodifiable
endif
endfunction
function! s:CCTreeGlobals.mEncodingChangedHandleEvent() dict
let self.Window.treeMarkers = s:CCTreeMarkers.mCreate()
if self.Window.mIsOpen() == s:CCTreeRC.True
call self.Window.mClose()
call self.mUpdateForCurrentSymbol()
endif
endfunction
function! s:CCTreeGlobals.mInit() dict
call self.mSetupAutoCmds()
endfunction
" }}}
" {{{ CCTree options
function! s:CCTreeSetUseCallTreeHiLights(val)
if a:val == -1
let g:CCTreeHilightCallTree = !g:CCTreeHilightCallTree
else
let g:CCTreeHilightCallTree = a:val
endif
call s:CCTreeGlobals.mSetupAutoCmds()
endfunction
function! s:CCTreeSetUseUtf8Symbols(val)
if a:val == -1
let g:CCTreeUseUTF8Symbols = !g:CCTreeUseUTF8Symbols
else
let g:CCTreeUseUTF8Symbols = a:val
endif
call s:CCTreeGlobals.mEncodingChangedHandleEvent()
endfunction
function! s:CCTreeSetUseConceal(val)
if a:val == -1
let s:CCTreeUseConceal = !s:CCTreeUseConceal
else
let s:CCTreeUseConceal = a:val
endif
if !has('conceal')
call s:CCTreeUtils.mWarningMsg('+conceal feature not available')
let s:CCTreeUseConceal = 0
endif
endfunction
function! s:CCTreeSetEnhancedSymbolProcessing(val)
if a:val == -1
let g:CCTreeEnhancedSymbolProcessing = !g:CCTreeEnhancedSymbolProcessing
else
let g:CCTreeEnhancedSymbolProcessing = a:val
endif
endfunction
function! s:CCTreeOptionsList(arglead, cmdline, cursorpos)
let opts = keys(s:CCTreeOptions)
if a:arglead == ''
return opts
else
return filter(opts, 'v:val =~? a:arglead')
endif
endfunction
let s:CCTreeOptions = {'UseUnicodeSymbols': function('s:CCTreeSetUseUtf8Symbols'),
\ 'DynamicTreeHiLights': function('s:CCTreeSetUseCallTreeHiLights'),
\ 'UseConceal': function('s:CCTreeSetUseConceal'),
\ 'EnhancedSymbolProcessing': function('s:CCTreeSetEnhancedSymbolProcessing')
\}
" }}}
" {{{ Vim tags interface
" CCTreeCompleteKwd
" Command line completion function to return names from the db
function! s:CCTreeCompleteKwd(arglead, cmdline, cursorpos)
let syms = s:CCTreeGlobals.mGetSymNames(a:arglead)
if a:arglead == ''
return syms
else
return filter(syms, 'v:val =~? a:arglead')
endif
endfunction
function! s:CCTreeTraceTreeForSymbol(sym_arg, direction)
if s:CCTreeGlobals.DbList.mIsEmpty() == s:CCTreeRC.True
call s:CCTreeUtils.mWarningMsg('No database loaded')
return
endif
let symbol = a:sym_arg
if symbol == ''
let symbol = input('Trace symbol: ', expand('<cword>'),
\ 'customlist,<SNR>' . s:sid . 'CCTreeCompleteKwd')
if symbol == ''
return
endif
endif
let symmatch = s:CCTreeGlobals.mGetSymNames(symbol)
if len(symmatch) > 0 && index(symmatch, symbol) >= 0
call s:CCTreeGlobals.mSetPreviewState(symbol,
\ g:CCTreeRecursiveDepth,
\ a:direction)
call s:CCTreeGlobals.mUpdateForCurrentSymbol()
else
call s:CCTreeUtils.mWarningMsg('Symbol not found')
endif
endfunction
function! s:CCTreeGlobals.mLoadBufferFromKeyword()
" REVISIT
if s:CCTreeGlobals.Window.mGetKeywordAtCursor() == s:CCTreeRC.Error
call s:CCTreeUtils.mWarningMsg('No keyword at cursor')
return
endif
let hiKeyword = s:CCTreeGlobals.Window.hiKeyword
try
wincmd p
catch
call s:CCTreeUtils.mWarningMsg('No buffer to load file')
finally
if (cscope_connection() > 0)
try
exec "cs find g ". hiKeyword
catch
" cheap hack
exec "cs find f ". hiKeyword
endtry
else
try
" Ctags is smart enough to figure the path
exec "tag ".fnamemodify(hiKeyword, ":t")
catch /^Vim\%((\a\+)\)\=:E433/
call s:CCTreeUtils.mWarningMsg('Tag file not found')
catch /^Vim\%((\a\+)\)\=:E426/
call s:CCTreeUtils.mWarningMsg('Tag '. hiKeyword .' not found')
wincmd p
endtry
endif
endtry
endfunction
function! s:CCTreeGlobals.mPreviewBufferFromKeyword()
if self.Window.mGetKeywordAtCursor() == s:CCTreeRC.Error
call s:CCTreeUtils.mWarningMsg('No keyword found')
return
endif
let hiKeyword = s:CCTreeGlobals.Window.hiKeyword
silent! wincmd P
if !&previewwindow
wincmd p
endif
try
exec "ptag ". hiKeyword
catch
call s:CCTreeUtils.mWarningMsg('Tag '.hiKeyword. ' not found')
endtry
endfunction
" }}}
" {{{ Define commands
command! -nargs=? -complete=file CCTreeLoadXRefDBFromDisk
\ call s:CCTreeCmdLine.mLoadDBFromDisk(<q-args>)
command! -nargs=? -complete=file CCTreeLoadDB call s:CCTreeCmdLine.mLoadDB(<q-args>, s:DBClasses.cscopeid)
command! -nargs=? -complete=file CCTreeLoadXRefDB call s:CCTreeCmdLine.mLoadDB(<q-args>, s:DBClasses.cctreexref)
command! -nargs=? -complete=file CCTreeSaveXRefDB call s:CCTreeCmdLine.mSaveDB(<q-args>, s:DBClasses.cctreexref)
command! -nargs=? -complete=file CCTreeAppendDB call s:CCTreeCmdLine.mMergeDB(<q-args>, s:DBClasses.cscopeid)
command! -nargs=0 CCTreeUnLoadDB call s:CCTreeGlobals.mUnLoadDBs()
command! -nargs=0 CCTreeShowLoadedDBs call s:CCTreeGlobals.mShowLoadedDBs()
command! -nargs=? -complete=customlist,s:CCTreeCompleteKwd
\ CCTreeTraceForward call s:CCTreeTraceTreeForSymbol(<q-args>, 'c')
command! -nargs=? -complete=customlist,s:CCTreeCompleteKwd CCTreeTraceReverse
\ call s:CCTreeTraceTreeForSymbol(<q-args>, 'p')
command! -nargs=0 CCTreeLoadBufferUsingTag call s:CCTreeGlobals.mLoadBufferFromKeyword()
command! -nargs=0 CCTreePreviewBufferUsingTag call s:CCTreeGlobals.mPreviewBufferFromKeyword()
command! -nargs=0 CCTreeRecurseDepthPlus call s:CCTreeGlobals.mRecursiveDepthIncrease()
command! -nargs=0 CCTreeRecurseDepthMinus call s:CCTreeGlobals.mRecursiveDepthDecrease()
" Preview Window
command! -nargs=0 CCTreeWindowToggle call s:CCTreeGlobals.mDisplayToggle()
command! -nargs=0 CCTreeWindowSaveCopy call s:CCTreeGlobals.mPreviewSave()
" Run-time dynamic options
command! -nargs=1 -complete=customlist,s:CCTreeOptionsList CCTreeOptsEnable call s:CCTreeGlobals.mEnable(<q-args>)
command! -nargs=1 -complete=customlist,s:CCTreeOptionsList CCTreeOptsDisable call s:CCTreeGlobals.mDisable(<q-args>)
command! -nargs=1 -complete=customlist,s:CCTreeOptionsList CCTreeOptsToggle call s:CCTreeGlobals.mToggle(<q-args>)
"}}}
" {{{ finish (and init)
call s:CCTreeGlobals.mInit()
" restore 'cpo'
let &cpoptions = s:cpo_save
unlet s:cpo_save
" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
" }}}
Reference in a new issue Copy permalink