3398 lines
107 KiB
VimL
3398 lines
107 KiB
VimL
" 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
|
|
" }}}
|