+++ /dev/null
-" File: taglist-plus.vim
-" Authors: Jezreel Ng (jezreel AT gmail DOT com)
-" Yegappan Lakshmanan (yegappan AT yahoo DOT com)
-" Version: 1.0
- "Last Modified: March 16, 2011
- "Copyright: Copyright (C) 2011 Jezeel Ng
-" Copyright (C) 2002-2007 Yegappan Lakshmanan
-" Permission is hereby granted to use and distribute this code,
-" with or without modifications, provided that this copyright
-" notice is copied with it. Like anything else that's free,
-" taglist.vim is provided *as is* and comes with no warranty of any
-" kind, either expressed or implied. In no event will the copyright
-" holder be liable for any damamges resulting from the use of this
-" software.
-"
-" For more information about using this plugin, after installing the
-" taglist plugin, use the ":help taglist" command.
-"
-" Installation
-" ------------
-" 1. Download the taglist.zip file and unzip the files to the $HOME/.vim
-" or the $HOME/vimfiles or the $VIM/vimfiles directory. This should
-" unzip the following two files (the directory structure should be
-" preserved):
-"
-" plugin/taglist-plus.vim - main taglist plugin file
-" doc/taglist-plus.txt - documentation (help) file
-"
-" Refer to the 'add-plugin', 'add-global-plugin' and 'runtimepath'
-" Vim help pages for more details about installing Vim plugins.
-" 2. Change to the $HOME/.vim/doc or $HOME/vimfiles/doc or
-" $VIM/vimfiles/doc directory, start Vim and run the ":helptags ."
-" command to process the taglist help file.
-" 3. If the exuberant ctags utility is not present in your PATH, then set the
-" Tlist_Ctags_Cmd variable to point to the location of the exuberant ctags
-" utility (not to the directory) in the .vimrc file.
-" 4. If you are running a terminal/console version of Vim and the
-" terminal doesn't support changing the window width then set the
-" 'Tlist_Inc_Winwidth' variable to 0 in the .vimrc file.
-" 5. Restart Vim.
-" 6. You can now use the ":TlistToggle" command to open/close the taglist
-" window. You can use the ":help taglist" command to get more
-" information about using the taglist plugin.
-"
-" ****************** Do not modify after this line ************************
-
-" Line continuation used here
-let s:cpo_save = &cpo
-set cpo&vim
-
-if !exists('loaded_taglist')
- " First time loading the taglist plugin
- "
- " To speed up the loading of Vim, the taglist plugin uses autoload
- " mechanism to load the taglist functions.
- " Only define the configuration variables, user commands and some
- " auto-commands and finish sourcing the file
-
- " The taglist plugin requires the built-in Vim system() function. If this
- " function is not available, then don't load the plugin.
- if !exists('*system')
- echomsg 'Taglist: Vim system() built-in function is not available. ' .
- \ 'Plugin is not loaded.'
- let loaded_taglist = 'no'
- let &cpo = s:cpo_save
- finish
- endif
-
- " Location of the exuberant ctags tool
- if !exists('Tlist_Ctags_Cmd')
- if executable('exuberant-ctags')
- " On Debian Linux, exuberant ctags is installed
- " as exuberant-ctags
- let Tlist_Ctags_Cmd = 'exuberant-ctags'
- elseif executable('exctags')
- " On Free-BSD, exuberant ctags is installed as exctags
- let Tlist_Ctags_Cmd = 'exctags'
- elseif executable('ctags')
- let Tlist_Ctags_Cmd = 'ctags'
- elseif executable('ctags.exe')
- let Tlist_Ctags_Cmd = 'ctags.exe'
- elseif executable('tags')
- let Tlist_Ctags_Cmd = 'tags'
- else
- echomsg 'Taglist: Exuberant ctags (http://ctags.sf.net) ' .
- \ 'not found in PATH. Plugin is not loaded.'
- " Skip loading the plugin
- let loaded_taglist = 'no'
- let &cpo = s:cpo_save
- finish
- endif
- endif
-
-
- " Automatically open the taglist window on Vim startup
- if !exists('Tlist_Auto_Open')
- let Tlist_Auto_Open = 0
- endif
-
- " When the taglist window is toggle opened, move the cursor to the
- " taglist window
- if !exists('Tlist_GainFocus_On_ToggleOpen')
- let Tlist_GainFocus_On_ToggleOpen = 0
- endif
-
- " Process files even when the taglist window is not open
- if !exists('Tlist_Process_File_Always')
- let Tlist_Process_File_Always = 0
- endif
-
- if !exists('Tlist_Show_Menu')
- let Tlist_Show_Menu = 0
- endif
-
- " Tag listing sort type - 'name' or 'order'
- if !exists('Tlist_Sort_Type')
- let Tlist_Sort_Type = 'order'
- endif
-
- " Tag listing window split (horizontal/vertical) control
- if !exists('Tlist_Use_Horiz_Window')
- let Tlist_Use_Horiz_Window = 0
- endif
-
- " Open the vertically split taglist window on the left or on the right
- " side. This setting is relevant only if Tlist_Use_Horiz_Window is set to
- " zero (i.e. only for vertically split windows)
- if !exists('Tlist_Use_Right_Window')
- let Tlist_Use_Right_Window = 0
- endif
-
- " Increase Vim window width to display vertically split taglist window.
- " For MS-Windows version of Vim running in a MS-DOS window, this must be
- " set to 0 otherwise the system may hang due to a Vim limitation.
- if !exists('Tlist_Inc_Winwidth')
- if (has('win16') || has('win95')) && !has('gui_running')
- let Tlist_Inc_Winwidth = 0
- else
- let Tlist_Inc_Winwidth = 1
- endif
- endif
-
- " Vertically split taglist window width setting
- if !exists('Tlist_WinWidth')
- let Tlist_WinWidth = 30
- let s:auto_width = 0
- elseif Tlist_WinWidth == 'auto'
- let Tlist_WinWidth = 30
- let s:auto_width = 1
- endif
-
- " Horizontally split taglist window height setting
- if !exists('Tlist_WinHeight')
- let Tlist_WinHeight = 10
- endif
-
- " Display tag prototypes or tag names in the taglist window
- if !exists('Tlist_Display_Prototype')
- let Tlist_Display_Prototype = 0
- endif
-
- " Display tag scopes in the taglist window
- if !exists('Tlist_Display_Tag_Scope')
- let Tlist_Display_Tag_Scope = 1
- endif
-
- " Use single left mouse click to jump to a tag. By default this is disabled.
- " Only double click using the mouse will be processed.
- if !exists('Tlist_Use_SingleClick')
- let Tlist_Use_SingleClick = 0
- endif
-
- " Control whether additional help is displayed as part of the taglist or
- " not. Also, controls whether empty lines are used to separate the tag
- " tree.
- if !exists('Tlist_Compact_Format')
- let Tlist_Compact_Format = 0
- endif
-
- " Exit Vim if only the taglist window is currently open. By default, this is
- " set to zero.
- if !exists('Tlist_Exit_OnlyWindow')
- let Tlist_Exit_OnlyWindow = 0
- endif
-
- " Automatically close the folds for the non-active files in the taglist
- " window
- if !exists('Tlist_File_Fold_Auto_Close')
- let Tlist_File_Fold_Auto_Close = 0
- endif
-
- " Close the taglist window when a tag is selected
- if !exists('Tlist_Close_On_Select')
- let Tlist_Close_On_Select = 0
- endif
-
- " Automatically update the taglist window to display tags for newly
- " edited files
- if !exists('Tlist_Auto_Update')
- let Tlist_Auto_Update = 1
- endif
-
- " Automatically highlight the current tag
- if !exists('Tlist_Auto_Highlight_Tag')
- let Tlist_Auto_Highlight_Tag = 1
- endif
-
- " Automatically highlight the current tag on entering a buffer
- if !exists('Tlist_Highlight_Tag_On_BufEnter')
- let Tlist_Highlight_Tag_On_BufEnter = 1
- endif
-
- " Enable fold column to display the folding for the tag tree
- if !exists('Tlist_Enable_Fold_Column')
- let Tlist_Enable_Fold_Column = 1
- endif
-
- " Display the tags for only one file in the taglist window
- if !exists('Tlist_Show_One_File')
- let Tlist_Show_One_File = 0
- endif
-
- if !exists('Tlist_Max_Submenu_Items')
- let Tlist_Max_Submenu_Items = 20
- endif
-
- if !exists('Tlist_Max_Tag_Length')
- let Tlist_Max_Tag_Length = 10
- endif
-
- " Do not change the name of the taglist title variable. The winmanager
- " plugin relies on this name to determine the title for the taglist
- " plugin.
- let TagList_title = "__Tag_List__"
-
- " Taglist debug messages
- let s:tlist_msg = ''
-
- " Define the taglist autocommand to automatically open the taglist window
- " on Vim startup
- if g:Tlist_Auto_Open
- autocmd VimEnter * nested call s:Tlist_Window_Check_Auto_Open()
- endif
-
- " Refresh the taglist
- if g:Tlist_Process_File_Always
- autocmd BufEnter * call s:Tlist_Refresh()
- endif
-
- if g:Tlist_Show_Menu
- autocmd GUIEnter * call s:Tlist_Menu_Init()
- endif
-
- " When the taglist buffer is created when loading a Vim session file,
- " the taglist buffer needs to be initialized. The BufFilePost event
- " is used to handle this case.
- autocmd BufFilePost __Tag_List__ call s:Tlist_Vim_Session_Load()
-
- " Define the user commands to manage the taglist window
- command! -nargs=0 -bar TlistToggle call s:Tlist_Window_Toggle()
- command! -nargs=0 -bar TlistOpen call s:Tlist_Window_Open()
- " For backwards compatiblity define the Tlist command
- command! -nargs=0 -bar Tlist TlistToggle
- command! -nargs=+ -complete=file TlistAddFiles
- \ call s:Tlist_Add_Files(<f-args>)
- command! -nargs=+ -complete=dir TlistAddFilesRecursive
- \ call s:Tlist_Add_Files_Recursive(<f-args>)
- command! -nargs=0 -bar TlistClose call s:Tlist_Window_Close()
- command! -nargs=0 -bar TlistUpdate call s:Tlist_Update_Current_File()
- command! -nargs=0 -bar TlistHighlightTag call s:Tlist_Window_Highlight_Tag(
- \ fnamemodify(bufname('%'), ':p'), line('.'), 2, 1)
- " For backwards compatiblity define the TlistSync command
- command! -nargs=0 -bar TlistSync TlistHighlightTag
- command! -nargs=* -complete=buffer TlistShowPrototype
- \ echo Tlist_Get_Tag_Prototype_By_Line(<f-args>)
- command! -nargs=* -complete=buffer TlistShowTag
- \ echo Tlist_Get_Tagname_By_Line(<f-args>)
- command! -nargs=* -complete=file TlistSessionLoad
- \ call s:Tlist_Session_Load(<q-args>)
- command! -nargs=* -complete=file TlistSessionSave
- \ call s:Tlist_Session_Save(<q-args>)
- command! -bar TlistLock let Tlist_Auto_Update=0
- command! -bar TlistUnlock let Tlist_Auto_Update=1
-
- " Commands for enabling/disabling debug and to display debug messages
- command! -nargs=? -complete=file -bar TlistDebug
- \ call s:Tlist_Debug_Enable(<q-args>)
- command! -nargs=0 -bar TlistUndebug call s:Tlist_Debug_Disable()
- command! -nargs=0 -bar TlistMessages call s:Tlist_Debug_Show()
-
- " Define autocommands to autoload the taglist plugin when needed.
-
- " Trick to get the current script ID
- map <SID>xx <SID>xx
- let s:tlist_sid = substitute(maparg('<SID>xx'), '<SNR>\(\d\+_\)xx$',
- \ '\1', '')
- unmap <SID>xx
-
- exe 'autocmd FuncUndefined *' . s:tlist_sid . 'Tlist_* source ' .
- \ escape(expand('<sfile>'), ' ')
- exe 'autocmd FuncUndefined *' . s:tlist_sid . 'Tlist_Window_* source ' .
- \ escape(expand('<sfile>'), ' ')
- exe 'autocmd FuncUndefined *' . s:tlist_sid . 'Tlist_Menu_* source ' .
- \ escape(expand('<sfile>'), ' ')
- exe 'autocmd FuncUndefined Tlist_* source ' .
- \ escape(expand('<sfile>'), ' ')
- exe 'autocmd FuncUndefined TagList_* source ' .
- \ escape(expand('<sfile>'), ' ')
-
- let loaded_taglist = 'fast_load_done'
-
- if g:Tlist_Show_Menu && has('gui_running')
- call s:Tlist_Menu_Init()
- endif
-
- " restore 'cpo'
- let &cpo = s:cpo_save
- finish
-endif
-
-if !exists('s:tlist_sid')
- " Two or more versions of taglist plugin are installed. Don't
- " load this version of the plugin.
- finish
-endif
-
-unlet! s:tlist_sid
-
-if loaded_taglist != 'fast_load_done'
- " restore 'cpo'
- let &cpo = s:cpo_save
- finish
-endif
-
-" Taglist plugin functionality is available
-let loaded_taglist = 'available'
-
-"------------------- end of user configurable options --------------------
-
-" Default language specific settings for supported file types and tag types
-"
-" Variable name format:
-"
-" s:tlist_def_{vim_ftype}_settings
-"
-" vim_ftype - Filetype detected by Vim
-"
-" Value format:
-"
-" <ctags_ftype>;<flag>:<name>;<flag>:<name>;...
-"
-" ctags_ftype - File type supported by exuberant ctags
-" flag - Flag supported by exuberant ctags to generate a tag type
-" name - Name of the tag type used in the taglist window to display the
-" tags of this type
-"
-
-" assembly language
-let s:tlist_def_asm_settings = 'asm;d:define;l:label;m:macro;t:type'
-
-" aspperl language
-let s:tlist_def_aspperl_settings = 'asp;f:function;s:sub;v:variable'
-
-" aspvbs language
-let s:tlist_def_aspvbs_settings = 'asp;f:function;s:sub;v:variable'
-
-" awk language
-let s:tlist_def_awk_settings = 'awk;f:function'
-
-" beta language
-let s:tlist_def_beta_settings = 'beta;f:fragment;s:slot;v:pattern'
-
-" c language
-let s:tlist_def_c_settings = 'c;d:macro;g:enum;s:struct;u:union;t:typedef;' .
- \ 'v:variable;f:function'
-
-" c++ language
-let s:tlist_def_cpp_settings = 'c++;n:namespace;v:variable;d:macro;t:typedef;' .
- \ 'c:class;g:enum;s:struct;u:union;f:function'
-
-" c# language
-let s:tlist_def_cs_settings = 'c#;d:macro;t:typedef;n:namespace;c:class;' .
- \ 'E:event;g:enum;s:struct;i:interface;' .
- \ 'p:properties;m:method'
-
-" cobol language
-let s:tlist_def_cobol_settings = 'cobol;d:data;f:file;g:group;p:paragraph;' .
- \ 'P:program;s:section'
-
-" eiffel language
-let s:tlist_def_eiffel_settings = 'eiffel;c:class;f:feature'
-
-" erlang language
-let s:tlist_def_erlang_settings = 'erlang;d:macro;r:record;m:module;f:function'
-
-" expect (same as tcl) language
-let s:tlist_def_expect_settings = 'tcl;c:class;f:method;p:procedure'
-
-" fortran language
-let s:tlist_def_fortran_settings = 'fortran;p:program;b:block data;' .
- \ 'c:common;e:entry;i:interface;k:type;l:label;m:module;' .
- \ 'n:namelist;t:derived;v:variable;f:function;s:subroutine'
-
-" HTML language
-let s:tlist_def_html_settings = 'html;a:anchor;f:javascript function'
-
-" java language
-let s:tlist_def_java_settings = 'java;p:package;c:class;i:interface;' .
- \ 'f:field;m:method'
-
-" javascript language
-let s:tlist_def_javascript_settings = 'javascript;f:function;v:variable'
-if !exists('Tlist_javascript_Ctags_Cmd') && executable('jsctags')
- let Tlist_javascript_Ctags_Cmd = 'jsctags'
-endif
-let Tlist_javascript_Ctags_Allowed_Flags = ['-f', '--sort']
-
-" lisp language
-let s:tlist_def_lisp_settings = 'lisp;f:function'
-
-" lua language
-let s:tlist_def_lua_settings = 'lua;f:function'
-
-" makefiles
-let s:tlist_def_make_settings = 'make;m:macro'
-
-" pascal language
-let s:tlist_def_pascal_settings = 'pascal;f:function;p:procedure'
-
-" perl language
-let s:tlist_def_perl_settings = 'perl;c:constant;l:label;p:package;s:subroutine'
-
-" php language
-let s:tlist_def_php_settings = 'php;c:class;d:constant;v:variable;f:function'
-
-" python language
-let s:tlist_def_python_settings = 'python;c:class;m:member;f:function'
-
-" rexx language
-let s:tlist_def_rexx_settings = 'rexx;s:subroutine'
-
-" ruby language
-let s:tlist_def_ruby_settings = 'ruby;c:class;f:method;F:function;' .
- \ 'm:singleton method'
-
-" scheme language
-let s:tlist_def_scheme_settings = 'scheme;s:set;f:function'
-
-" shell language
-let s:tlist_def_sh_settings = 'sh;f:function'
-
-" C shell language
-let s:tlist_def_csh_settings = 'sh;f:function'
-
-" Z shell language
-let s:tlist_def_zsh_settings = 'sh;f:function'
-
-" slang language
-let s:tlist_def_slang_settings = 'slang;n:namespace;f:function'
-
-" sml language
-let s:tlist_def_sml_settings = 'sml;e:exception;c:functor;s:signature;' .
- \ 'r:structure;t:type;v:value;f:function'
-
-" sql language
-let s:tlist_def_sql_settings = 'sql;c:cursor;F:field;P:package;r:record;' .
- \ 's:subtype;t:table;T:trigger;v:variable;f:function;p:procedure'
-
-" tcl language
-let s:tlist_def_tcl_settings = 'tcl;c:class;f:method;m:method;p:procedure'
-
-" vera language
-let s:tlist_def_vera_settings = 'vera;c:class;d:macro;e:enumerator;' .
- \ 'f:function;g:enum;m:member;p:program;' .
- \ 'P:prototype;t:task;T:typedef;v:variable;' .
- \ 'x:externvar'
-
-"verilog language
-let s:tlist_def_verilog_settings = 'verilog;m:module;c:constant;P:parameter;' .
- \ 'e:event;r:register;t:task;w:write;p:port;v:variable;f:function'
-
-" vim language
-let s:tlist_def_vim_settings = 'vim;a:autocmds;v:variable;f:function'
-
-" yacc language
-let s:tlist_def_yacc_settings = 'yacc;l:label'
-
-"------------------- end of language specific options --------------------
-
-" Vim window size is changed by the taglist plugin or not
-let s:tlist_winsize_chgd = -1
-" Taglist window is maximized or not
-let s:tlist_win_maximized = 0
-" Name of files in the taglist
-let s:tlist_file_names=''
-" Number of files in the taglist
-let s:tlist_file_count = 0
-" Number of filetypes supported by taglist
-let s:tlist_ftype_count = 0
-" Is taglist part of other plugins like winmanager or cream?
-let s:tlist_app_name = "none"
-" Are we displaying brief help text
-let s:tlist_brief_help = 1
-" List of files removed on user request
-let s:tlist_removed_flist = ""
-" Index of current file displayed in the taglist window
-let s:tlist_cur_file_idx = -1
-" Taglist menu is empty or not
-let s:tlist_menu_empty = 1
-
-" An autocommand is used to refresh the taglist window when entering any
-" buffer. We don't want to refresh the taglist window if we are entering the
-" file window from one of the taglist functions. The 'Tlist_Skip_Refresh'
-" variable is used to skip the refresh of the taglist window and is set
-" and cleared appropriately.
-let s:Tlist_Skip_Refresh = 0
-
-" Tlist_Window_Display_Help()
-function! s:Tlist_Window_Display_Help()
- if s:tlist_app_name == "winmanager"
- " To handle a bug in the winmanager plugin, add a space at the
- " last line
- call setline('$', ' ')
- endif
-
- if s:tlist_brief_help
- " Add the brief help
- call append(0, '" Press <F1> to display help text')
- else
- " Add the extensive help
- call append(0, '" <enter> : Jump to tag definition')
- call append(1, '" o : Jump to tag definition in new window')
- call append(2, '" p : Preview the tag definition')
- call append(3, '" <space> : Display tag prototype')
- call append(4, '" u : Update tag list')
- call append(5, '" s : Select sort field')
- call append(6, '" d : Remove file from taglist')
- call append(7, '" x : Zoom-out/Zoom-in taglist window')
- call append(8, '" m : Toggle display of more tag info')
- call append(9, '" + : Open a fold')
- call append(10, '" - : Close a fold')
- call append(11, '" * : Open all folds')
- call append(12, '" = : Close all folds')
- call append(13, '" [[ : Move to the start of previous file')
- call append(14, '" ]] : Move to the start of next file')
- call append(15, '" q : Close the taglist window')
- call append(16, '" <F1> : Remove help text')
- endif
-endfunction
-
-" Tlist_Window_Toggle_Help_Text()
-" Toggle taglist plugin help text between the full version and the brief
-" version
-function! s:Tlist_Window_Toggle_Help_Text()
- if g:Tlist_Compact_Format
- " In compact display mode, do not display help
- return
- endif
-
- " Include the empty line displayed after the help text
- let brief_help_size = 1
- let full_help_size = 16
-
- setlocal modifiable
-
- " Set report option to a huge value to prevent informational messages
- " while deleting the lines
- let old_report = &report
- set report=99999
-
- " Remove the currently highlighted tag. Otherwise, the help text
- " might be highlighted by mistake
- match none
-
- " Toggle between brief and full help text
- if s:tlist_brief_help
- let s:tlist_brief_help = 0
-
- " Remove the previous help
- exe '1,' . brief_help_size . ' delete _'
-
- " Adjust the start/end line numbers for the files
- call s:Tlist_Window_Update_Line_Offsets(0, 1, full_help_size - brief_help_size)
- else
- let s:tlist_brief_help = 1
-
- " Remove the previous help
- exe '1,' . full_help_size . ' delete _'
-
- " Adjust the start/end line numbers for the files
- call s:Tlist_Window_Update_Line_Offsets(0, 0, full_help_size - brief_help_size)
- endif
-
- call s:Tlist_Window_Display_Help()
-
- " Restore the report option
- let &report = old_report
-
- setlocal nomodifiable
-endfunction
-
-" Taglist debug support
-let s:tlist_debug = 0
-
-" File for storing the debug messages
-let s:tlist_debug_file = ''
-
-" Tlist_Debug_Enable
-" Enable logging of taglist debug messages.
-function! s:Tlist_Debug_Enable(...)
- let s:tlist_debug = 1
-
- " Check whether a valid file name is supplied.
- if a:1 != ''
- let s:tlist_debug_file = fnamemodify(a:1, ':p')
-
- " Empty the log file
- exe 'redir! > ' . s:tlist_debug_file
- redir END
-
- " Check whether the log file is present/created
- if !filewritable(s:tlist_debug_file)
- call s:Tlist_Warning_Msg('Taglist: Unable to create log file '
- \ . s:tlist_debug_file)
- let s:tlist_debug_file = ''
- endif
- endif
-endfunction
-
-" Tlist_Debug_Disable
-" Disable logging of taglist debug messages.
-function! s:Tlist_Debug_Disable(...)
- let s:tlist_debug = 0
- let s:tlist_debug_file = ''
-endfunction
-
-" Tlist_Debug_Show
-" Display the taglist debug messages in a new window
-function! s:Tlist_Debug_Show()
- if s:tlist_msg == ''
- call s:Tlist_Warning_Msg('Taglist: No debug messages')
- return
- endif
-
- " Open a new window to display the taglist debug messages
- new taglist_debug.txt
- " Delete all the lines (if the buffer already exists)
- silent! %delete _
- " Add the messages
- silent! put =s:tlist_msg
- " Move the cursor to the first line
- normal! gg
-endfunction
-
-" Tlist_Log_Msg
-" Log the supplied debug message along with the time
-function! s:Tlist_Log_Msg(msg)
- if s:tlist_debug
- if s:tlist_debug_file != ''
- exe 'redir >> ' . s:tlist_debug_file
- silent echon strftime('%H:%M:%S') . ': ' . a:msg . "\n"
- redir END
- else
- " Log the message into a variable
- " Retain only the last 3000 characters
- let len = strlen(s:tlist_msg)
- if len > 3000
- let s:tlist_msg = strpart(s:tlist_msg, len - 3000)
- endif
- let s:tlist_msg = s:tlist_msg . strftime('%H:%M:%S') . ': ' .
- \ a:msg . "\n"
- endif
- endif
-endfunction
-
-" Tlist_Warning_Msg()
-" Display a message using WarningMsg highlight group
-function! s:Tlist_Warning_Msg(msg)
- echohl WarningMsg
- echomsg a:msg
- echohl None
-endfunction
-
-" Last returned file index for file name lookup.
-" Used to speed up file lookup
-let s:tlist_file_name_idx_cache = -1
-
-" Tlist_Get_File_Index()
-" Return the index of the specified filename
-function! s:Tlist_Get_File_Index(fname)
- if s:tlist_file_count == 0 || a:fname == ''
- return -1
- endif
-
- " If the new filename is same as the last accessed filename, then
- " return that index
- if s:tlist_file_name_idx_cache != -1 &&
- \ s:tlist_file_name_idx_cache < s:tlist_file_count
- if s:tlist_{s:tlist_file_name_idx_cache}_filename == a:fname
- " Same as the last accessed file
- return s:tlist_file_name_idx_cache
- endif
- endif
-
- " First, check whether the filename is present
- let s_fname = a:fname . "\n"
- let i = stridx(s:tlist_file_names, s_fname)
- if i == -1
- let s:tlist_file_name_idx_cache = -1
- return -1
- endif
-
- " Second, compute the file name index
- let nl_txt = substitute(strpart(s:tlist_file_names, 0, i), "[^\n]", '', 'g')
- let s:tlist_file_name_idx_cache = strlen(nl_txt)
- return s:tlist_file_name_idx_cache
-endfunction
-
-" Last returned file index for line number lookup.
-" Used to speed up file lookup
-let s:tlist_file_lnum_idx_cache = -1
-
-" Tlist_Window_Get_File_Index_By_Linenum()
-" Return the index of the filename present in the specified line number
-" Line number refers to the line number in the taglist window
-function! s:Tlist_Window_Get_File_Index_By_Linenum(lnum)
- call s:Tlist_Log_Msg('Tlist_Window_Get_File_Index_By_Linenum (' . a:lnum . ')')
-
- " First try to see whether the new line number is within the range
- " of the last returned file
- if s:tlist_file_lnum_idx_cache != -1 &&
- \ s:tlist_file_lnum_idx_cache < s:tlist_file_count
- if a:lnum >= s:tlist_{s:tlist_file_lnum_idx_cache}_start &&
- \ a:lnum <= s:tlist_{s:tlist_file_lnum_idx_cache}_end
- return s:tlist_file_lnum_idx_cache
- endif
- endif
-
- let fidx = -1
-
- if g:Tlist_Show_One_File
- " Displaying only one file in the taglist window. Check whether
- " the line is within the tags displayed for that file
- if s:tlist_cur_file_idx != -1
- if a:lnum >= s:tlist_{s:tlist_cur_file_idx}_start
- \ && a:lnum <= s:tlist_{s:tlist_cur_file_idx}_end
- let fidx = s:tlist_cur_file_idx
- endif
-
- endif
- else
- " Do a binary search in the taglist
- let left = 0
- let right = s:tlist_file_count - 1
-
- while left < right
- let mid = (left + right) / 2
-
- if a:lnum >= s:tlist_{mid}_start && a:lnum <= s:tlist_{mid}_end
- let s:tlist_file_lnum_idx_cache = mid
- return mid
- endif
-
- if a:lnum < s:tlist_{mid}_start
- let right = mid - 1
- else
- let left = mid + 1
- endif
- endwhile
-
- if left >= 0 && left < s:tlist_file_count
- \ && a:lnum >= s:tlist_{left}_start
- \ && a:lnum <= s:tlist_{left}_end
- let fidx = left
- endif
- endif
-
- let s:tlist_file_lnum_idx_cache = fidx
-
- return fidx
-endfunction
-
-" Tlist_Exe_Cmd_No_Acmds
-" Execute the specified Ex command after disabling autocommands
-function! s:Tlist_Exe_Cmd_No_Acmds(cmd)
- let old_eventignore = &eventignore
- set eventignore=all
- exe a:cmd
- let &eventignore = old_eventignore
-endfunction
-
-" Tlist_Skip_File()
-" Check whether tag listing is supported for the specified file
-function! s:Tlist_Skip_File(filename, ftype)
- " Skip buffers with no names and buffers with filetype not set
- if a:filename == '' || a:ftype == ''
- return 1
- endif
-
- " Skip files which are not supported by exuberant ctags
- " First check whether default settings for this filetype are available.
- " If it is not available, then check whether user specified settings are
- " available. If both are not available, then don't list the tags for this
- " filetype
- let var = 's:tlist_def_' . a:ftype . '_settings'
- if !exists(var)
- let var = 'g:tlist_' . a:ftype . '_settings'
- if !exists(var)
- return 1
- endif
- endif
-
- " Skip files which are not readable or files which are not yet stored
- " to the disk
- if !filereadable(a:filename)
- return 1
- endif
-
- return 0
-endfunction
-
-" Tlist_User_Removed_File
-" Returns 1 if a file is removed by a user from the taglist
-function! s:Tlist_User_Removed_File(filename)
- return stridx(s:tlist_removed_flist, a:filename . "\n") != -1
-endfunction
-
-" Tlist_Update_Remove_List
-" Update the list of user removed files from the taglist
-" add == 1, add the file to the removed list
-" add == 0, delete the file from the removed list
-function! s:Tlist_Update_Remove_List(filename, add)
- if a:add
- let s:tlist_removed_flist = s:tlist_removed_flist . a:filename . "\n"
- else
- let idx = stridx(s:tlist_removed_flist, a:filename . "\n")
- let text_before = strpart(s:tlist_removed_flist, 0, idx)
- let rem_text = strpart(s:tlist_removed_flist, idx)
- let next_idx = stridx(rem_text, "\n")
- let text_after = strpart(rem_text, next_idx + 1)
-
- let s:tlist_removed_flist = text_before . text_after
- endif
-endfunction
-
-" Tlist_FileType_Init
-" Initialize the ctags arguments and tag variable for the specified
-" file type
-function! s:Tlist_FileType_Init(ftype)
- call s:Tlist_Log_Msg('Tlist_FileType_Init (' . a:ftype . ')')
- " If the user didn't specify any settings, then use the default
- " ctags args. Otherwise, use the settings specified by the user
- let var = 'g:tlist_' . a:ftype . '_settings'
- if exists(var)
- " User specified ctags arguments
- let settings = {var} . ';'
- else
- " Default ctags arguments
- let var = 's:tlist_def_' . a:ftype . '_settings'
- if !exists(var)
- " No default settings for this file type. This filetype is
- " not supported
- return 0
- endif
- let settings = s:tlist_def_{a:ftype}_settings . ';'
- endif
-
- let msg = 'Taglist: Invalid ctags option setting - ' . settings
-
- " Format of the option that specifies the filetype and ctags arugments:
- "
- " <language_name>;flag1:name1;flag2:name2;flag3:name3
- "
-
- " Extract the file type to pass to ctags. This may be different from the
- " file type detected by Vim
- let pos = stridx(settings, ';')
- if pos == -1
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
- let ctags_ftype = strpart(settings, 0, pos)
- if ctags_ftype == ''
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
- " Make sure a valid filetype is supplied. If the user didn't specify a
- " valid filetype, then the ctags option settings may be treated as the
- " filetype
- if ctags_ftype =~ ':'
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
-
- " Remove the file type from settings
- let settings = strpart(settings, pos + 1)
- if settings == ''
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
-
- " Process all the specified ctags flags. The format is
- " flag1:name1;flag2:name2;flag3:name3
- let ctags_flags = ''
- let cnt = 0
- while settings != ''
- " Extract the flag
- let pos = stridx(settings, ':')
- if pos == -1
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
- let flag = strpart(settings, 0, pos)
- if flag == ''
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
- " Remove the flag from settings
- let settings = strpart(settings, pos + 1)
-
- " Extract the tag type name
- let pos = stridx(settings, ';')
- if pos == -1
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
- let name = strpart(settings, 0, pos)
- if name == ''
- call s:Tlist_Warning_Msg(msg)
- return 0
- endif
- let settings = strpart(settings, pos + 1)
-
- let cnt = cnt + 1
-
- let s:tlist_{a:ftype}_{cnt}_name = flag
- let s:tlist_{a:ftype}_{cnt}_fullname = name
- let ctags_flags = ctags_flags . flag
- endwhile
-
- let s:tlist_{a:ftype}_ctags_args = { '--language-force=': ctags_ftype,
- \ '--'.ctags_ftype.'-types=': ctags_flags }
- let s:tlist_{a:ftype}_count = cnt
- let s:tlist_{a:ftype}_ctags_flags = ctags_flags
-
- " Save the filetype name
- let s:tlist_ftype_{s:tlist_ftype_count}_name = a:ftype
- let s:tlist_ftype_count = s:tlist_ftype_count + 1
-
- return 1
-endfunction
-
-" Tlist_Detect_Filetype
-" Determine the filetype for the specified file using the filetypedetect
-" autocmd.
-function! s:Tlist_Detect_Filetype(fname)
- " Ignore the filetype autocommands
- let old_eventignore = &eventignore
- set eventignore=FileType
-
- " Save the 'filetype', as this will be changed temporarily
- let old_filetype = &filetype
-
- " Run the filetypedetect group of autocommands to determine
- " the filetype
- exe 'doautocmd filetypedetect BufRead ' . a:fname
-
- " Save the detected filetype
- let ftype = &filetype
-
- " Restore the previous state
- let &filetype = old_filetype
- let &eventignore = old_eventignore
-
- return ftype
-endfunction
-
-" Tlist_Get_Buffer_Filetype
-" Get the filetype for the specified buffer
-function! s:Tlist_Get_Buffer_Filetype(bnum)
- let buf_ft = getbufvar(a:bnum, '&filetype')
-
- if bufloaded(a:bnum)
- " For loaded buffers, the 'filetype' is already determined
- return buf_ft
- endif
-
- " For unloaded buffers, if the 'filetype' option is set, return it
- if buf_ft != ''
- return buf_ft
- endif
-
- " Skip non-existent buffers
- if !bufexists(a:bnum)
- return ''
- endif
-
- " For buffers whose filetype is not yet determined, try to determine
- " the filetype
- let bname = bufname(a:bnum)
-
- return s:Tlist_Detect_Filetype(bname)
-endfunction
-
-" Tlist_Discard_TagInfo
-" Discard the stored tag information for a file
-function! s:Tlist_Discard_TagInfo(fidx)
- call s:Tlist_Log_Msg('Tlist_Discard_TagInfo (' .
- \ s:tlist_{a:fidx}_filename . ')')
- let ftype = s:tlist_{a:fidx}_filetype
-
- " Discard information about the tags defined in the file
- let i = 1
- while i <= s:tlist_{a:fidx}_tag_count
- let fidx_i = 's:tlist_' . a:fidx . '_' . i
- unlet! {fidx_i}_tag
- unlet! {fidx_i}_tag_name
- unlet! {fidx_i}_tag_type
- unlet! {fidx_i}_ttype_idx
- unlet! {fidx_i}_tag_proto
- unlet! {fidx_i}_tag_searchpat
- unlet! {fidx_i}_tag_linenum
- let i = i + 1
- endwhile
-
- let s:tlist_{a:fidx}_tag_count = 0
-
- " Discard information about tag type groups
- let i = 1
- while i <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{i}_name
- if s:tlist_{a:fidx}_{ttype} != ''
- let fidx_ttype = 's:tlist_' . a:fidx . '_' . ttype
- let {fidx_ttype} = ''
- let {fidx_ttype}_offset = 0
- let cnt = {fidx_ttype}_count
- let {fidx_ttype}_count = 0
- let j = 1
- while j <= cnt
- unlet! {fidx_ttype}_{j}
- let j = j + 1
- endwhile
- endif
- let i = i + 1
- endwhile
-
- " Discard the stored menu command also
- let s:tlist_{a:fidx}_menu_cmd = ''
-endfunction
-
-" Tlist_Window_Update_Line_Offsets
-" Update the line offsets for tags for files starting from start_idx
-" and displayed in the taglist window by the specified offset
-function! s:Tlist_Window_Update_Line_Offsets(start_idx, increment, offset)
- let i = a:start_idx
-
- while i < s:tlist_file_count
- if s:tlist_{i}_visible
- " Update the start/end line number only if the file is visible
- if a:increment
- let s:tlist_{i}_start = s:tlist_{i}_start + a:offset
- let s:tlist_{i}_end = s:tlist_{i}_end + a:offset
- else
- let s:tlist_{i}_start = s:tlist_{i}_start - a:offset
- let s:tlist_{i}_end = s:tlist_{i}_end - a:offset
- endif
- endif
- let i = i + 1
- endwhile
-endfunction
-
-" Tlist_Discard_FileInfo
-" Discard the stored information for a file
-function! s:Tlist_Discard_FileInfo(fidx)
- call s:Tlist_Log_Msg('Tlist_Discard_FileInfo (' .
- \ s:tlist_{a:fidx}_filename . ')')
- call s:Tlist_Discard_TagInfo(a:fidx)
-
- let ftype = s:tlist_{a:fidx}_filetype
-
- let i = 1
- while i <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{i}_name
- unlet! s:tlist_{a:fidx}_{ttype}
- unlet! s:tlist_{a:fidx}_{ttype}_offset
- unlet! s:tlist_{a:fidx}_{ttype}_count
- let i = i + 1
- endwhile
-
- unlet! s:tlist_{a:fidx}_filename
- unlet! s:tlist_{a:fidx}_sort_type
- unlet! s:tlist_{a:fidx}_filetype
- unlet! s:tlist_{a:fidx}_mtime
- unlet! s:tlist_{a:fidx}_start
- unlet! s:tlist_{a:fidx}_end
- unlet! s:tlist_{a:fidx}_valid
- unlet! s:tlist_{a:fidx}_visible
- unlet! s:tlist_{a:fidx}_tag_count
- unlet! s:tlist_{a:fidx}_menu_cmd
-endfunction
-
-" Tlist_Window_Remove_File_From_Display
-" Remove the specified file from display
-function! s:Tlist_Window_Remove_File_From_Display(fidx)
- call s:Tlist_Log_Msg('Tlist_Window_Remove_File_From_Display (' .
- \ s:tlist_{a:fidx}_filename . ')')
- " If the file is not visible then no need to remove it
- if !s:tlist_{a:fidx}_visible
- return
- endif
-
- " Remove the tags displayed for the specified file from the window
- let start = s:tlist_{a:fidx}_start
- " Include the empty line after the last line also
- if g:Tlist_Compact_Format
- let end = s:tlist_{a:fidx}_end
- else
- let end = s:tlist_{a:fidx}_end + 1
- endif
-
- setlocal modifiable
- exe 'silent! ' . start . ',' . end . 'delete _'
- setlocal nomodifiable
-
- " Correct the start and end line offsets for all the files following
- " this file, as the tags for this file are removed
- call s:Tlist_Window_Update_Line_Offsets(a:fidx + 1, 0, end - start + 1)
-endfunction
-
-" Tlist_Remove_File
-" Remove the file under the cursor or the specified file index
-" user_request - User requested to remove the file from taglist
-function! s:Tlist_Remove_File(file_idx, user_request)
- let fidx = a:file_idx
-
- if fidx == -1
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(line('.'))
- if fidx == -1
- return
- endif
- endif
- call s:Tlist_Log_Msg('Tlist_Remove_File (' .
- \ s:tlist_{fidx}_filename . ', ' . a:user_request . ')')
-
- let save_winnr = winnr()
- let winnum = bufwinnr(g:TagList_title)
- if winnum != -1
- " Taglist window is open, remove the file from display
-
- if save_winnr != winnum
- let old_eventignore = &eventignore
- set eventignore=all
- exe winnum . 'wincmd w'
- endif
-
- call s:Tlist_Window_Remove_File_From_Display(fidx)
-
- if save_winnr != winnum
- exe save_winnr . 'wincmd w'
- let &eventignore = old_eventignore
- endif
- endif
-
- let fname = s:tlist_{fidx}_filename
-
- if a:user_request
- " As the user requested to remove the file from taglist,
- " add it to the removed list
- call s:Tlist_Update_Remove_List(fname, 1)
- endif
-
- " Remove the file name from the taglist list of filenames
- let idx = stridx(s:tlist_file_names, fname . "\n")
- let text_before = strpart(s:tlist_file_names, 0, idx)
- let rem_text = strpart(s:tlist_file_names, idx)
- let next_idx = stridx(rem_text, "\n")
- let text_after = strpart(rem_text, next_idx + 1)
- let s:tlist_file_names = text_before . text_after
-
- call s:Tlist_Discard_FileInfo(fidx)
-
- " Shift all the file variables by one index
- let i = fidx + 1
-
- while i < s:tlist_file_count
- let j = i - 1
-
- let s:tlist_{j}_filename = s:tlist_{i}_filename
- let s:tlist_{j}_sort_type = s:tlist_{i}_sort_type
- let s:tlist_{j}_filetype = s:tlist_{i}_filetype
- let s:tlist_{j}_mtime = s:tlist_{i}_mtime
- let s:tlist_{j}_start = s:tlist_{i}_start
- let s:tlist_{j}_end = s:tlist_{i}_end
- let s:tlist_{j}_valid = s:tlist_{i}_valid
- let s:tlist_{j}_visible = s:tlist_{i}_visible
- let s:tlist_{j}_tag_count = s:tlist_{i}_tag_count
- let s:tlist_{j}_menu_cmd = s:tlist_{i}_menu_cmd
-
- let k = 1
- while k <= s:tlist_{j}_tag_count
- let s:tlist_{j}_{k}_tag = s:tlist_{i}_{k}_tag
- let s:tlist_{j}_{k}_tag_name = s:tlist_{i}_{k}_tag_name
- let s:tlist_{j}_{k}_tag_type = s:Tlist_Get_Tag_Type_By_Tag(i, k)
- let s:tlist_{j}_{k}_ttype_idx = s:tlist_{i}_{k}_ttype_idx
- let s:tlist_{j}_{k}_tag_proto = s:Tlist_Get_Tag_Prototype(i, k)
- let s:tlist_{j}_{k}_tag_searchpat = s:Tlist_Get_Tag_SearchPat(i, k)
- let s:tlist_{j}_{k}_tag_linenum = s:Tlist_Get_Tag_Linenum(i, k)
- let k = k + 1
- endwhile
-
- let ftype = s:tlist_{i}_filetype
-
- let k = 1
- while k <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{k}_name
- let s:tlist_{j}_{ttype} = s:tlist_{i}_{ttype}
- let s:tlist_{j}_{ttype}_offset = s:tlist_{i}_{ttype}_offset
- let s:tlist_{j}_{ttype}_count = s:tlist_{i}_{ttype}_count
- if s:tlist_{j}_{ttype} != ''
- let l = 1
- while l <= s:tlist_{j}_{ttype}_count
- let s:tlist_{j}_{ttype}_{l} = s:tlist_{i}_{ttype}_{l}
- let l = l + 1
- endwhile
- endif
- let k = k + 1
- endwhile
-
- " As the file and tag information is copied to the new index,
- " discard the previous information
- call s:Tlist_Discard_FileInfo(i)
-
- let i = i + 1
- endwhile
-
- " Reduce the number of files displayed
- let s:tlist_file_count = s:tlist_file_count - 1
-
- if g:Tlist_Show_One_File
- " If the tags for only one file is displayed and if we just
- " now removed that file, then invalidate the current file idx
- if s:tlist_cur_file_idx == fidx
- let s:tlist_cur_file_idx = -1
- endif
- endif
-endfunction
-
-" Tlist_Window_Goto_Window
-" Goto the taglist window
-function! s:Tlist_Window_Goto_Window()
- let winnum = bufwinnr(g:TagList_title)
- if winnum != -1
- if winnr() != winnum
- call s:Tlist_Exe_Cmd_No_Acmds(winnum . 'wincmd w')
- endif
- endif
-endfunction
-
-" Tlist_Window_Create
-" Create a new taglist window. If it is already open, jump to it
-function! s:Tlist_Window_Create()
- call s:Tlist_Log_Msg('Tlist_Window_Create()')
- " If the window is open, jump to it
- let winnum = bufwinnr(g:TagList_title)
- if winnum != -1
- " Jump to the existing window
- if winnr() != winnum
- exe winnum . 'wincmd w'
- endif
- return
- endif
-
- " If used with winmanager don't open windows. Winmanager will handle
- " the window/buffer management
- if s:tlist_app_name == "winmanager"
- return
- endif
-
- " Create a new window. If user prefers a horizontal window, then open
- " a horizontally split window. Otherwise open a vertically split
- " window
- if g:Tlist_Use_Horiz_Window
- " Open a horizontally split window
- let win_dir = 'botright'
- " Horizontal window height
- let win_size = g:Tlist_WinHeight
- else
- if s:tlist_winsize_chgd == -1
- " Open a vertically split window. Increase the window size, if
- " needed, to accomodate the new window
- if g:Tlist_Inc_Winwidth &&
- \ &columns < (80 + g:Tlist_WinWidth)
- " Save the original window position
- let s:tlist_pre_winx = getwinposx()
- let s:tlist_pre_winy = getwinposy()
-
- " one extra column is needed to include the vertical split
- let &columns= &columns + g:Tlist_WinWidth + 1
-
- let s:tlist_winsize_chgd = 1
- else
- let s:tlist_winsize_chgd = 0
- endif
- endif
-
- if g:Tlist_Use_Right_Window
- " Open the window at the rightmost place
- let win_dir = 'botright vertical'
- else
- " Open the window at the leftmost place
- let win_dir = 'topleft vertical'
- endif
- let win_size = g:Tlist_WinWidth
- endif
-
- " If the tag listing temporary buffer already exists, then reuse it.
- " Otherwise create a new buffer
- let bufnum = bufnr(g:TagList_title)
- if bufnum == -1
- " Create a new buffer
- let wcmd = g:TagList_title
- else
- " Edit the existing buffer
- let wcmd = '+buffer' . bufnum
- endif
-
- " Create the taglist window
- exe 'silent! ' . win_dir . ' ' . win_size . 'split ' . wcmd
-
- " Save the new window position
- let s:tlist_winx = getwinposx()
- let s:tlist_winy = getwinposy()
-
- " Initialize the taglist window
- call s:Tlist_Window_Init()
-endfunction
-
-" Tlist_Window_Zoom
-" Zoom (maximize/minimize) the taglist window
-function! s:Tlist_Window_Zoom()
- if s:tlist_win_maximized
- " Restore the window back to the previous size
- if g:Tlist_Use_Horiz_Window
- exe 'resize ' . g:Tlist_WinHeight
- else
- exe 'vert resize ' . g:Tlist_WinWidth
- endif
- let s:tlist_win_maximized = 0
- else
- " Set the window size to the maximum possible without closing other
- " windows
- if g:Tlist_Use_Horiz_Window
- resize
- else
- vert resize
- endif
- let s:tlist_win_maximized = 1
- endif
-endfunction
-
-" Tlist_Ballon_Expr
-" When the mouse cursor is over a tag in the taglist window, display the
-" tag prototype (balloon)
-function! Tlist_Ballon_Expr()
- " Get the file index
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(v:beval_lnum)
- if fidx == -1
- return ''
- endif
-
- " Get the tag output line for the current tag
- let tidx = s:Tlist_Window_Get_Tag_Index(fidx, v:beval_lnum)
- if tidx == 0
- return ''
- endif
-
- " Get the tag search pattern and display it
- return s:Tlist_Get_Tag_Prototype(fidx, tidx)
-endfunction
-
-" Tlist_Window_Check_Width
-" Check the width of the taglist window. For horizontally split windows, the
-" 'winfixheight' option is used to fix the height of the window. For
-" vertically split windows, Vim doesn't support the 'winfixwidth' option. So
-" need to handle window width changes from this function.
-function! s:Tlist_Window_Check_Width()
- let tlist_winnr = bufwinnr(g:TagList_title)
- if tlist_winnr == -1
- return
- endif
-
- let width = winwidth(tlist_winnr)
- if width != g:Tlist_WinWidth
- call s:Tlist_Log_Msg("Tlist_Window_Check_Width: Changing window " .
- \ "width from " . width . " to " . g:Tlist_WinWidth)
- let save_winnr = winnr()
- if save_winnr != tlist_winnr
- call s:Tlist_Exe_Cmd_No_Acmds(tlist_winnr . 'wincmd w')
- endif
- exe 'vert resize ' . g:Tlist_WinWidth
- if save_winnr != tlist_winnr
- call s:Tlist_Exe_Cmd_No_Acmds('wincmd p')
- endif
- endif
-endfunction
-
-" Tlist_Window_Exit_Only_Window
-" If the 'Tlist_Exit_OnlyWindow' option is set, then exit Vim if only the
-" taglist window is present.
-function! s:Tlist_Window_Exit_Only_Window()
- " Before quitting Vim, delete the taglist buffer so that
- " the '0 mark is correctly set to the previous buffer.
- if v:version < 700
- if winbufnr(2) == -1
- bdelete
- quit
- endif
- else
- if winbufnr(2) == -1
- if tabpagenr('$') == 1
- " Only one tag page is present
- bdelete
- quit
- else
- " More than one tab page is present. Close only the current
- " tab page
- close
- endif
- endif
- endif
-endfunction
-
-" Tlist_Window_Init
-" Set the default options for the taglist window
-function! s:Tlist_Window_Init()
- call s:Tlist_Log_Msg('Tlist_Window_Init()')
-
- " The 'readonly' option should not be set for the taglist buffer.
- " If Vim is started as "view/gview" or if the ":view" command is
- " used, then the 'readonly' option is set for all the buffers.
- " Unset it for the taglist buffer
- setlocal noreadonly
-
- " Set the taglist buffer filetype to taglist
- setlocal filetype=taglist
-
- " Define taglist window element highlighting
- syntax match TagListComment '^" .*'
- syntax match TagListFileName '^[^" ].*$'
- syntax match TagListTitle '^ \S.*$'
- syntax region TagListTagScope1 start='\[' end='\]' contains=TagListTagScope1 nextgroup=TagListTagScope2 skipwhite
- syntax region TagListTagScope2 start='\[' end='\]' contained contains=TaglistTagScope2
-
- " Define the highlighting only if colors are supported
- if has('gui_running') || &t_Co > 2
- " Colors to highlight various taglist window elements
- " If user defined highlighting group exists, then use them.
- " Otherwise, use default highlight groups.
- if hlexists('MyTagListTagName')
- highlight link TagListTagName MyTagListTagName
- else
- highlight default link TagListTagName Search
- endif
- " Colors to highlight comments and titles
- if hlexists('MyTagListComment')
- highlight link TagListComment MyTagListComment
- else
- highlight clear TagListComment
- highlight default link TagListComment Comment
- endif
- if hlexists('MyTagListTitle')
- highlight link TagListTitle MyTagListTitle
- else
- highlight clear TagListTitle
- highlight default link TagListTitle Title
- endif
- if hlexists('MyTagListFileName')
- highlight link TagListFileName MyTagListFileName
- else
- highlight clear TagListFileName
- highlight default TagListFileName guibg=Grey ctermbg=darkgray
- \ guifg=white ctermfg=white
- endif
- if hlexists('MyTagListTagScope')
- highlight link TagListTagScope1 MyTagListTagScope
- else
- highlight clear TagListTagScope1
- highlight clear TagListTagScope2
- highlight default link TagListTagScope1 Identifier
- highlight default link TagListTagScope2 Keyword
- endif
- else
- highlight default TagListTagName term=reverse cterm=reverse
- endif
-
- " Folding related settings
- setlocal foldenable
- setlocal foldminlines=0
- setlocal foldmethod=manual
- setlocal foldlevel=9999
- if g:Tlist_Enable_Fold_Column
- setlocal foldcolumn=3
- else
- setlocal foldcolumn=0
- endif
- setlocal foldtext=v:folddashes.getline(v:foldstart)
-
- if s:tlist_app_name != "winmanager"
- " Mark buffer as scratch
- silent! setlocal buftype=nofile
- if s:tlist_app_name == "none"
- silent! setlocal bufhidden=delete
- endif
- silent! setlocal noswapfile
- " Due to a bug in Vim 6.0, the winbufnr() function fails for unlisted
- " buffers. So if the taglist buffer is unlisted, multiple taglist
- " windows will be opened. This bug is fixed in Vim 6.1 and above
- if v:version >= 601
- silent! setlocal nobuflisted
- endif
- endif
-
- silent! setlocal nowrap
-
- " If the 'number' option is set in the source window, it will affect the
- " taglist window. So forcefully disable 'number' option for the taglist
- " window
- silent! setlocal nonumber
-
- " Use fixed height when horizontally split window is used
- if g:Tlist_Use_Horiz_Window
- if v:version >= 602
- set winfixheight
- endif
- endif
- if !g:Tlist_Use_Horiz_Window && v:version >= 700
- set winfixwidth
- endif
-
- " Setup balloon evaluation to display tag prototype
- if v:version >= 700 && has('balloon_eval')
- setlocal balloonexpr=Tlist_Ballon_Expr()
- set ballooneval
- endif
-
- " Setup the cpoptions properly for the maps to work
- let old_cpoptions = &cpoptions
- set cpoptions&vim
-
- " Create buffer local mappings for jumping to the tags and sorting the list
- nnoremap <buffer> <silent> <CR>
- \ :call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
- " If more languages are required, generate this from a list of options
- nnoremap <buffer> <silent> m
- \ :call <SID>Tlist_Window_Toggle_Extra('javascript', 'type')<CR>
- nnoremap <buffer> <silent> o
- \ :call <SID>Tlist_Window_Jump_To_Tag('newwin')<CR>
- nnoremap <buffer> <silent> p
- \ :call <SID>Tlist_Window_Jump_To_Tag('preview')<CR>
- nnoremap <buffer> <silent> P
- \ :call <SID>Tlist_Window_Jump_To_Tag('prevwin')<CR>
- if v:version >= 700
- nnoremap <buffer> <silent> t
- \ :call <SID>Tlist_Window_Jump_To_Tag('checktab')<CR>
- nnoremap <buffer> <silent> <C-t>
- \ :call <SID>Tlist_Window_Jump_To_Tag('newtab')<CR>
- endif
- nnoremap <buffer> <silent> <2-LeftMouse>
- \ :call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
- nnoremap <buffer> <silent> s
- \ :call <SID>Tlist_Change_Sort('cmd', 'toggle', '')<CR>
- nnoremap <buffer> <silent> + :silent! foldopen<CR>
- nnoremap <buffer> <silent> - :silent! foldclose<CR>
- nnoremap <buffer> <silent> * :silent! %foldopen!<CR>
- nnoremap <buffer> <silent> = :silent! %foldclose<CR>
- nnoremap <buffer> <silent> <kPlus> :silent! foldopen<CR>
- nnoremap <buffer> <silent> <kMinus> :silent! foldclose<CR>
- nnoremap <buffer> <silent> <kMultiply> :silent! %foldopen!<CR>
- nnoremap <buffer> <silent> <Space> :call <SID>Tlist_Window_Show_Info()<CR>
- nnoremap <buffer> <silent> u :call <SID>Tlist_Window_Update_File()<CR>
- nnoremap <buffer> <silent> d :call <SID>Tlist_Remove_File(-1, 1)<CR>
- nnoremap <buffer> <silent> x :call <SID>Tlist_Window_Zoom()<CR>
- nnoremap <buffer> <silent> [[ :call <SID>Tlist_Window_Move_To_File(-1)<CR>
- nnoremap <buffer> <silent> <BS> :call <SID>Tlist_Window_Move_To_File(-1)<CR>
- nnoremap <buffer> <silent> ]] :call <SID>Tlist_Window_Move_To_File(1)<CR>
- nnoremap <buffer> <silent> <Tab> :call <SID>Tlist_Window_Move_To_File(1)<CR>
- nnoremap <buffer> <silent> <F1> :call <SID>Tlist_Window_Toggle_Help_Text()<CR>
- nnoremap <buffer> <silent> q :close<CR>
-
- " Insert mode mappings
- inoremap <buffer> <silent> <CR>
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
- " Windows needs return
- inoremap <buffer> <silent> <Return>
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
- inoremap <buffer> <silent> o
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('newwin')<CR>
- inoremap <buffer> <silent> p
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('preview')<CR>
- inoremap <buffer> <silent> P
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('prevwin')<CR>
- if v:version >= 700
- inoremap <buffer> <silent> t
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('checktab')<CR>
- inoremap <buffer> <silent> <C-t>
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('newtab')<CR>
- endif
- inoremap <buffer> <silent> <2-LeftMouse>
- \ <C-o>:call <SID>Tlist_Window_Jump_To_Tag('useopen')<CR>
- inoremap <buffer> <silent> s
- \ <C-o>:call <SID>Tlist_Change_Sort('cmd', 'toggle', '')<CR>
- inoremap <buffer> <silent> + <C-o>:silent! foldopen<CR>
- inoremap <buffer> <silent> - <C-o>:silent! foldclose<CR>
- inoremap <buffer> <silent> * <C-o>:silent! %foldopen!<CR>
- inoremap <buffer> <silent> = <C-o>:silent! %foldclose<CR>
- inoremap <buffer> <silent> <kPlus> <C-o>:silent! foldopen<CR>
- inoremap <buffer> <silent> <kMinus> <C-o>:silent! foldclose<CR>
- inoremap <buffer> <silent> <kMultiply> <C-o>:silent! %foldopen!<CR>
- inoremap <buffer> <silent> <Space> <C-o>:call
- \ <SID>Tlist_Window_Show_Info()<CR>
- inoremap <buffer> <silent> u
- \ <C-o>:call <SID>Tlist_Window_Update_File()<CR>
- inoremap <buffer> <silent> d <C-o>:call <SID>Tlist_Remove_File(-1, 1)<CR>
- inoremap <buffer> <silent> x <C-o>:call <SID>Tlist_Window_Zoom()<CR>
- inoremap <buffer> <silent> [[ <C-o>:call <SID>Tlist_Window_Move_To_File(-1)<CR>
- inoremap <buffer> <silent> <BS> <C-o>:call <SID>Tlist_Window_Move_To_File(-1)<CR>
- inoremap <buffer> <silent> ]] <C-o>:call <SID>Tlist_Window_Move_To_File(1)<CR>
- inoremap <buffer> <silent> <Tab> <C-o>:call <SID>Tlist_Window_Move_To_File(1)<CR>
- inoremap <buffer> <silent> <F1> <C-o>:call <SID>Tlist_Window_Toggle_Help_Text()<CR>
- inoremap <buffer> <silent> q <C-o>:close<CR>
-
- " Map single left mouse click if the user wants this functionality
- if g:Tlist_Use_SingleClick == 1
- " Contributed by Bindu Wavell
- " attempt to perform single click mapping, it would be much
- " nicer if we could nnoremap <buffer> ... however vim does
- " not fire the <buffer> <leftmouse> when you use the mouse
- " to enter a buffer.
- let clickmap = ':if bufname("%") =~ "__Tag_List__" <bar> ' .
- \ 'call <SID>Tlist_Window_Jump_To_Tag("useopen") ' .
- \ '<bar> endif <CR>'
- if maparg('<leftmouse>', 'n') == ''
- " no mapping for leftmouse
- exe ':nnoremap <silent> <leftmouse> <leftmouse>' . clickmap
- else
- " we have a mapping
- let mapcmd = ':nnoremap <silent> <leftmouse> <leftmouse>'
- let mapcmd = mapcmd . substitute(substitute(
- \ maparg('<leftmouse>', 'n'), '|', '<bar>', 'g'),
- \ '\c^<leftmouse>', '', '')
- let mapcmd = mapcmd . clickmap
- exe mapcmd
- endif
- endif
-
- " Define the taglist autocommands
- augroup TagListAutoCmds
- autocmd!
- " Display the tag prototype for the tag under the cursor.
- autocmd CursorHold __Tag_List__ call s:Tlist_Window_Show_Info()
- " Highlight the current tag periodically
- autocmd CursorHold * silent call s:Tlist_Window_Highlight_Tag(
- \ fnamemodify(bufname('%'), ':p'), line('.'), 1, 0)
-
- " Adjust the Vim window width when taglist window is closed
- autocmd BufUnload __Tag_List__ call s:Tlist_Post_Close_Cleanup()
- " Close the fold for this buffer when leaving the buffer
- if g:Tlist_File_Fold_Auto_Close
- autocmd BufEnter * silent
- \ call s:Tlist_Window_Open_File_Fold(expand('<abuf>'))
- endif
- " Exit Vim itself if only the taglist window is present (optional)
- if g:Tlist_Exit_OnlyWindow
- autocmd BufEnter __Tag_List__ nested
- \ call s:Tlist_Window_Exit_Only_Window()
- endif
- if s:tlist_app_name != "winmanager" &&
- \ !g:Tlist_Process_File_Always &&
- \ (!has('gui_running') || !g:Tlist_Show_Menu)
- " Auto refresh the taglist window
- autocmd BufEnter * call s:Tlist_Refresh()
- endif
-
- if !g:Tlist_Use_Horiz_Window
- if v:version < 700
- autocmd WinEnter * call s:Tlist_Window_Check_Width()
- endif
- endif
- if v:version >= 700
- autocmd TabEnter * silent call s:Tlist_Refresh_Folds()
- endif
- augroup end
-
- " Restore the previous cpoptions settings
- let &cpoptions = old_cpoptions
-endfunction
-
-" Tlist_Window_Refresh
-" Display the tags for all the files in the taglist window
-function! s:Tlist_Window_Refresh()
- call s:Tlist_Log_Msg('Tlist_Window_Refresh()')
- " Set report option to a huge value to prevent informational messages
- " while deleting the lines
- let old_report = &report
- set report=99999
-
- " Mark the buffer as modifiable
- setlocal modifiable
-
- " Delete the contents of the buffer to the black-hole register
- silent! %delete _
-
- " As we have cleared the taglist window, mark all the files
- " as not visible
- let i = 0
- while i < s:tlist_file_count
- let s:tlist_{i}_visible = 0
- let i = i + 1
- endwhile
-
- if g:Tlist_Compact_Format == 0
- " Display help in non-compact mode
- call s:Tlist_Window_Display_Help()
- endif
-
- " Mark the buffer as not modifiable
- setlocal nomodifiable
-
- " Restore the report option
- let &report = old_report
-
- " If the tags for only one file should be displayed in the taglist
- " window, then no need to add the tags here. The bufenter autocommand
- " will add the tags for that file.
- if g:Tlist_Show_One_File
- return
- endif
-
- " List all the tags for the previously processed files
- " Do this only if taglist is configured to display tags for more than
- " one file. Otherwise, when Tlist_Show_One_File is configured,
- " tags for the wrong file will be displayed.
- let i = 0
- while i < s:tlist_file_count
- call s:Tlist_Window_Refresh_File(s:tlist_{i}_filename,
- \ s:tlist_{i}_filetype)
- let i = i + 1
- endwhile
-
- if g:Tlist_Auto_Update
- " Add and list the tags for all buffers in the Vim buffer list
- let i = 1
- let last_bufnum = bufnr('$')
- while i <= last_bufnum
- if buflisted(i)
- let fname = fnamemodify(bufname(i), ':p')
- let ftype = s:Tlist_Get_Buffer_Filetype(i)
- " If the file doesn't support tag listing, skip it
- if !s:Tlist_Skip_File(fname, ftype)
- call s:Tlist_Window_Refresh_File(fname, ftype)
- endif
- endif
- let i = i + 1
- endwhile
- endif
-
- " If Tlist_File_Fold_Auto_Close option is set, then close all the folds
- if g:Tlist_File_Fold_Auto_Close
- " Close all the folds
- silent! %foldclose
- endif
-
- if !g:Tlist_Use_Horiz_Window && s:auto_width
- exe 'vertical resize '.g:Tlist_WinWidth
- endif
-
- " Move the cursor to the top of the taglist window
- normal! gg
-endfunction
-
-" Tlist_Post_Close_Cleanup()
-" Close the taglist window and adjust the Vim window width
-function! s:Tlist_Post_Close_Cleanup()
- call s:Tlist_Log_Msg('Tlist_Post_Close_Cleanup()')
- " Mark all the files as not visible
- let i = 0
- while i < s:tlist_file_count
- let s:tlist_{i}_visible = 0
- let i = i + 1
- endwhile
-
- " Remove the taglist autocommands
- silent! autocmd! TagListAutoCmds
-
- " Clear all the highlights
- match none
-
- silent! syntax clear TagListTitle
- silent! syntax clear TagListComment
- silent! syntax clear TagListTagScope
-
- " Remove the left mouse click mapping if it was setup initially
- if g:Tlist_Use_SingleClick
- if hasmapto('<LeftMouse>')
- nunmap <LeftMouse>
- endif
- endif
-
- if s:tlist_app_name != "winmanager"
- if g:Tlist_Use_Horiz_Window || g:Tlist_Inc_Winwidth == 0 ||
- \ s:tlist_winsize_chgd != 1 ||
- \ &columns < (80 + g:Tlist_WinWidth)
- " No need to adjust window width if using horizontally split taglist
- " window or if columns is less than 101 or if the user chose not to
- " adjust the window width
- else
- " If the user didn't manually move the window, then restore the window
- " position to the pre-taglist position
- if s:tlist_pre_winx != -1 && s:tlist_pre_winy != -1 &&
- \ getwinposx() == s:tlist_winx &&
- \ getwinposy() == s:tlist_winy
- exe 'winpos ' . s:tlist_pre_winx . ' ' . s:tlist_pre_winy
- endif
-
- " Adjust the Vim window width
- let &columns= &columns - (g:Tlist_WinWidth + 1)
- endif
- endif
-
- let s:tlist_winsize_chgd = -1
-
- " Reset taglist state variables
- if s:tlist_app_name == "winmanager"
- let s:tlist_app_name = "none"
- endif
- let s:tlist_window_initialized = 0
-endfunction
-
-" Tlist_Window_Refresh_File()
-" List the tags defined in the specified file in a Vim window
-function! s:Tlist_Window_Refresh_File(filename, ftype)
- call s:Tlist_Log_Msg('Tlist_Window_Refresh_File (' . a:filename . ')')
- " First check whether the file already exists
- let fidx = s:Tlist_Get_File_Index(a:filename)
- if fidx != -1
- let file_listed = 1
- else
- let file_listed = 0
- endif
-
- if !file_listed
- " Check whether this file is removed based on user request
- " If it is, then don't display the tags for this file
- if s:Tlist_User_Removed_File(a:filename)
- return
- endif
- endif
-
- if file_listed && s:tlist_{fidx}_visible
- " Check whether the file tags are currently valid
- if s:tlist_{fidx}_valid
- " Goto the first line in the file
- exe s:tlist_{fidx}_start
-
- " If the line is inside a fold, open the fold
- if foldclosed('.') != -1
- exe "silent! " . s:tlist_{fidx}_start . "," .
- \ s:tlist_{fidx}_end . "foldopen!"
- endif
- return
- endif
-
- " Discard and remove the tags for this file from display
- call s:Tlist_Discard_TagInfo(fidx)
- call s:Tlist_Window_Remove_File_From_Display(fidx)
- endif
-
- " Process and generate a list of tags defined in the file
- if !file_listed || !s:tlist_{fidx}_valid
- let ret_fidx = s:Tlist_Process_File(a:filename, a:ftype)
- if ret_fidx == -1
- return
- endif
- let fidx = ret_fidx
- endif
-
- " Set report option to a huge value to prevent informational messages
- " while adding lines to the taglist window
- let old_report = &report
- set report=99999
-
- if g:Tlist_Show_One_File
- " Remove the previous file
- if s:tlist_cur_file_idx != -1
- call s:Tlist_Window_Remove_File_From_Display(s:tlist_cur_file_idx)
- let s:tlist_{s:tlist_cur_file_idx}_visible = 0
- let s:tlist_{s:tlist_cur_file_idx}_start = 0
- let s:tlist_{s:tlist_cur_file_idx}_end = 0
- endif
- let s:tlist_cur_file_idx = fidx
- endif
-
- " Mark the buffer as modifiable
- setlocal modifiable
-
- " Add new files to the end of the window. For existing files, add them at
- " the same line where they were previously present. If the file is not
- " visible, then add it at the end
- if s:tlist_{fidx}_start == 0 || !s:tlist_{fidx}_visible
- if g:Tlist_Compact_Format
- let s:tlist_{fidx}_start = line('$')
- else
- let s:tlist_{fidx}_start = line('$') + 1
- endif
- endif
-
- let s:tlist_{fidx}_visible = 1
-
- " Goto the line where this file should be placed
- if g:Tlist_Compact_Format
- exe s:tlist_{fidx}_start
- else
- exe s:tlist_{fidx}_start - 1
- endif
-
- let txt = fnamemodify(s:tlist_{fidx}_filename, ':t') . ' (' .
- \ fnamemodify(s:tlist_{fidx}_filename, ':p:h') . ')'
- if g:Tlist_Compact_Format == 0
- silent! put =txt
- else
- silent! put! =txt
- " Move to the next line
- exe line('.') + 1
- endif
- let file_start = s:tlist_{fidx}_start
-
- " Add the tag names grouped by tag type to the buffer with a title
- let i = 1
- let ttype_cnt = s:tlist_{a:ftype}_count
- while i <= ttype_cnt
- let ttype = s:tlist_{a:ftype}_{i}_name
- " Add the tag type only if there are tags for that type
- let fidx_ttype = 's:tlist_' . fidx . '_' . ttype
- let ttype_txt = {fidx_ttype}
- if ttype_txt != ''
- let txt = ' ' . s:tlist_{a:ftype}_{i}_fullname
- if g:Tlist_Compact_Format == 0
- let ttype_start_lnum = line('.') + 1
- silent! put =txt
- else
- let ttype_start_lnum = line('.')
- silent! put! =txt
- endif
- silent! put =ttype_txt
-
- let {fidx_ttype}_offset = ttype_start_lnum - file_start
-
- " create a fold for this tag type
- let fold_start = ttype_start_lnum
- let fold_end = fold_start + {fidx_ttype}_count
- exe fold_start . ',' . fold_end . 'fold'
-
- " Adjust the cursor position
- if g:Tlist_Compact_Format == 0
- exe ttype_start_lnum + {fidx_ttype}_count
- else
- exe ttype_start_lnum + {fidx_ttype}_count + 1
- endif
-
- if g:Tlist_Compact_Format == 0
- " Separate the tag types by a empty line
- silent! put =''
- endif
- endif
- let i = i + 1
- endwhile
-
- if s:tlist_{fidx}_tag_count == 0
- if g:Tlist_Compact_Format == 0
- silent! put =''
- endif
- endif
-
- let s:tlist_{fidx}_end = line('.') - 1
-
- " Create a fold for the entire file
- exe s:tlist_{fidx}_start . ',' . s:tlist_{fidx}_end . 'fold'
- exe 'silent! ' . s:tlist_{fidx}_start . ',' .
- \ s:tlist_{fidx}_end . 'foldopen!'
-
- " Goto the starting line for this file,
- exe s:tlist_{fidx}_start
-
- if s:tlist_app_name == "winmanager"
- " To handle a bug in the winmanager plugin, add a space at the
- " last line
- call setline('$', ' ')
- endif
-
- " Mark the buffer as not modifiable
- setlocal nomodifiable
-
- " Restore the report option
- let &report = old_report
-
- " Update the start and end line numbers for all the files following this
- " file
- let start = s:tlist_{fidx}_start
- " include the empty line after the last line
- if g:Tlist_Compact_Format
- let end = s:tlist_{fidx}_end
- else
- let end = s:tlist_{fidx}_end + 1
- endif
- call s:Tlist_Window_Update_Line_Offsets(fidx + 1, 1, end - start + 1)
-
- if !g:Tlist_Use_Horiz_Window && s:auto_width
- exe 'vertical resize '.g:Tlist_WinWidth
- endif
-
- " Now that we have updated the taglist window, update the tags
- " menu (if present)
- if g:Tlist_Show_Menu
- call s:Tlist_Menu_Update_File(1)
- endif
-endfunction
-
-" Tlist_Init_File
-" Initialize the variables for a new file
-function! s:Tlist_Init_File(filename, ftype)
- call s:Tlist_Log_Msg('Tlist_Init_File (' . a:filename . ')')
- " Add new files at the end of the list
- let fidx = s:tlist_file_count
- let s:tlist_file_count = s:tlist_file_count + 1
- " Add the new file name to the taglist list of file names
- let s:tlist_file_names = s:tlist_file_names . a:filename . "\n"
-
- " Initialize the file variables
- let s:tlist_{fidx}_filename = a:filename
- let s:tlist_{fidx}_sort_type = g:Tlist_Sort_Type
- let s:tlist_{fidx}_filetype = a:ftype
- let s:tlist_{fidx}_mtime = -1
- let s:tlist_{fidx}_start = 0
- let s:tlist_{fidx}_end = 0
- let s:tlist_{fidx}_valid = 0
- let s:tlist_{fidx}_visible = 0
- let s:tlist_{fidx}_tag_count = 0
- let s:tlist_{fidx}_menu_cmd = ''
-
- " Initialize the tag type variables
- let i = 1
- while i <= s:tlist_{a:ftype}_count
- let ttype = s:tlist_{a:ftype}_{i}_name
- let s:tlist_{fidx}_{ttype} = ''
- let s:tlist_{fidx}_{ttype}_offset = 0
- let s:tlist_{fidx}_{ttype}_count = 0
- let i = i + 1
- endwhile
-
- return fidx
-endfunction
-
-" Tlist_Get_Tag_Type_By_Tag
-" Return the tag type for the specified tag index
-function! s:Tlist_Get_Tag_Type_By_Tag(fidx, tidx)
- let ttype_var = 's:tlist_' . a:fidx . '_' . a:tidx . '_tag_type'
-
- " Already parsed and have the tag name
- if exists(ttype_var)
- return {ttype_var}
- endif
-
- let tag_line = s:tlist_{a:fidx}_{a:tidx}_tag
- let {ttype_var} = s:Tlist_Extract_Tagtype(tag_line)
-
- return {ttype_var}
-endfunction
-
-" Tlist_Get_Tag_Prototype
-function! s:Tlist_Get_Tag_Prototype(fidx, tidx)
- let tproto_var = 's:tlist_' . a:fidx . '_' . a:tidx . '_tag_proto'
-
- " Already parsed and have the tag prototype
- if exists(tproto_var)
- return {tproto_var}
- endif
-
- " Parse and extract the tag prototype
- let tag_line = s:tlist_{a:fidx}_{a:tidx}_tag
- let start = stridx(tag_line, '/^') + 2
- let end = stridx(tag_line, '/;"' . "\t")
- if tag_line[end - 1] == '$'
- let end = end -1
- endif
- let tag_proto = strpart(tag_line, start, end - start)
- let {tproto_var} = substitute(tag_proto, '\s*', '', '')
-
- return {tproto_var}
-endfunction
-
-" Tlist_Get_Tag_SearchPat
-function! s:Tlist_Get_Tag_SearchPat(fidx, tidx)
- let tpat_var = 's:tlist_' . a:fidx . '_' . a:tidx . '_tag_searchpat'
-
- " Already parsed and have the tag search pattern
- if exists(tpat_var)
- return {tpat_var}
- endif
-
- " Parse and extract the tag search pattern
- let tag_line = s:tlist_{a:fidx}_{a:tidx}_tag
- let start = stridx(tag_line, '/^') + 2
- let end = stridx(tag_line, '/;"' . "\t")
- if tag_line[end - 1] == '$'
- let end = end -1
- endif
- let {tpat_var} = '\V\^' . strpart(tag_line, start, end - start) .
- \ (tag_line[end] == '$' ? '\$' : '')
-
- return {tpat_var}
-endfunction
-
-" Tlist_Get_Tag_Linenum
-" Return the tag line number, given the tag index
-function! s:Tlist_Get_Tag_Linenum(fidx, tidx)
- let tline_var = 's:tlist_' . a:fidx . '_' . a:tidx . '_tag_linenum'
-
- " Already parsed and have the tag line number
- if exists(tline_var)
- return {tline_var}
- endif
-
- " Parse and extract the tag line number
- let tag_line = s:tlist_{a:fidx}_{a:tidx}_tag
- let start = match(tag_line, 'line\(no\)\?:')
- let start = stridx(tag_line, ':', start) + 1
- let end = stridx(tag_line, "\t", start)
-
- if end < start
- let {tline_var} = strpart(tag_line, start) + 0
- else
- let {tline_var} = strpart(tag_line, start, end - start) + 0
- endif
-
- return {tline_var}
-endfunction
-
-" Tlist_Parse_Tagline
-" Parse a tag line from the ctags output. Separate the tag output based on the
-" tag type and store it in the tag type variable.
-" The format of each line in the ctags output is:
-"
-" tag_name<TAB>file_name<TAB>ex_cmd;"<TAB>extension_fields
-"
-function! s:Tlist_Parse_Tagline(tag_line,ftype)
- if a:tag_line == ''
- " Skip empty lines
- return
- endif
-
- " Extract the tag type
- let ttype = s:Tlist_Extract_Tagtype(a:tag_line)
-
- " Make sure the tag type is a valid and supported one
- if ttype == '' || stridx(s:ctags_flags, ttype) == -1
- " Line is not in proper tags format or Tag type is not supported
- return
- endif
-
- " Update the total tag count
- let s:tidx = s:tidx + 1
-
- " The following variables are used to optimize this code. Vim is slow in
- " using curly brace names. To reduce the amount of processing needed, the
- " curly brace variables are pre-processed here
- let fidx_tidx = 's:tlist_' . s:fidx . '_' . s:tidx
- let fidx_ttype = 's:tlist_' . s:fidx . '_' . ttype
-
- " Update the count of this tag type
- let ttype_idx = {fidx_ttype}_count + 1
- let {fidx_ttype}_count = ttype_idx
-
- " Store the ctags output for this tag
- let {fidx_tidx}_tag = a:tag_line
-
- " Store the tag index and the tag type index (back pointers)
- let {fidx_ttype}_{ttype_idx} = s:tidx
- let {fidx_tidx}_ttype_idx = ttype_idx
-
- " Extract the tag name
- let tag_name = strpart(a:tag_line, 0, stridx(a:tag_line, "\t"))
-
- " Extract the tag scope/prototype
- if g:Tlist_Display_Prototype
- let ttxt = ' ' . s:Tlist_Get_Tag_Prototype(s:fidx, s:tidx)
- else
- let ttxt = ' ' . tag_name
-
- " Add the tag scope, if it is available and is configured. Tag
- " scope is the last field after the 'line:<num>\t' field
- if g:Tlist_Display_Tag_Scope
- let ttxt .= s:Tlist_Get_Scope_String(a:tag_line, a:ftype)
- endif
- endif
-
- if !g:Tlist_Use_Horiz_Window && s:auto_width
- " Add 3 for the fold columns
- let g:Tlist_WinWidth = max([g:Tlist_WinWidth, strlen(ttxt)+3])
- endif
-
- " Add this tag to the tag type variable
- let {fidx_ttype} = {fidx_ttype} . ttxt . "\n"
-
- " Save the tag name
- let {fidx_tidx}_tag_name = tag_name
-endfunction
-
-function! s:Tlist_Get_Scope_String(tag_line, ftype)
- let ttxt = ''
- let tag_scopes = s:Tlist_Extract_Tag_Scope(a:tag_line)
- for [extradata_name, extradata_content] in items(tag_scopes)
- if !exists('g:Tlist_{a:ftype}_Hide_Extras') || match(g:Tlist_{a:ftype}_Hide_Extras, extradata_name) == -1
- let ttxt = ttxt . ' [' . extradata_content . ']'
- endif
- endfor
- return ttxt
-endfunction
-
-" Tlist_Process_File
-" Get the list of tags defined in the specified file and store them
-" in Vim variables. Returns the file index where the tags are stored.
-function! s:Tlist_Process_File(filename, ftype)
- call s:Tlist_Log_Msg('Tlist_Process_File (' . a:filename . ', ' .
- \ a:ftype . ')')
- " Check whether this file is supported
- if s:Tlist_Skip_File(a:filename, a:ftype)
- return -1
- endif
-
- " If the tag types for this filetype are not yet created, then create
- " them now
- let var = 's:tlist_' . a:ftype . '_count'
- if !exists(var)
- if s:Tlist_FileType_Init(a:ftype) == 0
- return -1
- endif
- endif
-
- " If this file is already processed, then use the cached values
- let fidx = s:Tlist_Get_File_Index(a:filename)
- if fidx == -1
- " First time, this file is loaded
- let fidx = s:Tlist_Init_File(a:filename, a:ftype)
- else
- " File was previously processed. Discard the tag information
- call s:Tlist_Discard_TagInfo(fidx)
- endif
-
- let s:tlist_{fidx}_valid = 1
-
- " Exuberant ctags arguments to generate a tag list
- let ctags_args = { '-f': ' -', '--format=': '2', '--excmd=': 'pattern', '--fields=': 'nks' }
-
- " Form the ctags argument depending on the sort type
- if s:tlist_{fidx}_sort_type == 'name'
- let ctags_args['--sort'] = '=yes'
- else
- let ctags_args['--sort'] = '=no'
- endif
-
- " Add the filetype specific arguments
- call extend(ctags_args, s:tlist_{a:ftype}_ctags_args)
-
- " Ctags command to produce output with regexp for locating the tags
- if exists('g:Tlist_{a:ftype}_Ctags_Cmd')
- let ctags_cmd = g:Tlist_{a:ftype}_Ctags_Cmd
- let ctags_args = filter(ctags_args, 'match(g:Tlist_javascript_Ctags_Allowed_Flags, "^".v:key."$") != -1')
- else
- let ctags_cmd = g:Tlist_Ctags_Cmd
- endif
- let ctags_cmd = ctags_cmd . ' ' . join(values(map(ctags_args, 'v:key . v:val')))
- let ctags_cmd = ctags_cmd . ' "' . a:filename . '"'
-
- if &shellxquote == '"'
- " Double-quotes within double-quotes will not work in the
- " command-line.If the 'shellxquote' option is set to double-quotes,
- " then escape the double-quotes in the ctags command-line.
- let ctags_cmd = escape(ctags_cmd, '"')
- endif
-
- " In Windows 95, if not using cygwin, disable the 'shellslash'
- " option. Otherwise, this will cause problems when running the
- " ctags command.
- if has('win95') && !has('win32unix')
- let old_shellslash = &shellslash
- set noshellslash
- endif
-
- if has('win32') && !has('win32unix') && !has('win95')
- \ && (&shell =~ 'cmd.exe')
- " Windows does not correctly deal with commands that have more than 1
- " set of double quotes. It will strip them all resulting in:
- " 'C:\Program' is not recognized as an internal or external command
- " operable program or batch file. To work around this, place the
- " command inside a batch file and call the batch file.
- " Do this only on Win2K, WinXP and above.
- " Contributed by: David Fishburn.
- let s:taglist_tempfile = fnamemodify(tempname(), ':h') .
- \ '\taglist.cmd'
- exe 'redir! > ' . s:taglist_tempfile
- silent echo ctags_cmd
- redir END
-
- call s:Tlist_Log_Msg('Cmd inside batch file: ' . ctags_cmd)
- let ctags_cmd = '"' . s:taglist_tempfile . '"'
- endif
-
- call s:Tlist_Log_Msg('Cmd: ' . ctags_cmd)
-
- " Run ctags and get the tag list
- let cmd_output = system(ctags_cmd)
-
- " Restore the value of the 'shellslash' option.
- if has('win95') && !has('win32unix')
- let &shellslash = old_shellslash
- endif
-
- if exists('s:taglist_tempfile')
- " Delete the temporary cmd file created on MS-Windows
- call delete(s:taglist_tempfile)
- endif
-
- " Handle errors
- if v:shell_error
- let msg = "Taglist: Failed to generate tags for " . a:filename
- call s:Tlist_Warning_Msg(msg)
- if cmd_output != ''
- call s:Tlist_Warning_Msg(cmd_output)
- endif
- return fidx
- endif
-
- " Store the modification time for the file
- let s:tlist_{fidx}_mtime = getftime(a:filename)
-
- " No tags for current file
- if cmd_output == ''
- call s:Tlist_Log_Msg('No tags defined in ' . a:filename)
- return fidx
- endif
-
- call s:Tlist_Log_Msg('Generated tags information for ' . a:filename)
-
- if v:version > 601
- " The following script local variables are used by the
- " Tlist_Parse_Tagline() function.
- let s:ctags_flags = s:tlist_{a:ftype}_ctags_flags
- let s:fidx = fidx
- let s:tidx = 0
-
- " Tlist_Parse_Tagline will adjust this accordingly
- if !g:Tlist_Use_Horiz_Window && s:auto_width
- let g:Tlist_WinWidth = 0
- endif
-
- " Process the ctags output one line at a time. The substitute()
- " command is used to parse the tag lines instead of using the
- " matchstr()/stridx()/strpart() functions for performance reason
- call substitute(cmd_output, "\\([^\n]\\+\\)\n",
- \ '\=s:Tlist_Parse_Tagline(submatch(1),a:ftype)', 'g')
-
- " Save the number of tags for this file
- let s:tlist_{fidx}_tag_count = s:tidx
-
- " The following script local variables are no longer needed
- unlet! s:ctags_flags
- unlet! s:tidx
- unlet! s:fidx
- else
- " Due to a bug in Vim earlier than version 6.1,
- " we cannot use substitute() to parse the ctags output.
- " Instead the slow str*() functions are used
- let ctags_flags = s:tlist_{a:ftype}_ctags_flags
- let tidx = 0
-
- while cmd_output != ''
- " Extract one line at a time
- let idx = stridx(cmd_output, "\n")
- let one_line = strpart(cmd_output, 0, idx)
- " Remove the line from the tags output
- let cmd_output = strpart(cmd_output, idx + 1)
-
- if one_line == ''
- " Line is not in proper tags format
- continue
- endif
-
- " Extract the tag type
- let ttype = s:Tlist_Extract_Tagtype(one_line)
-
- " Make sure the tag type is a valid and supported one
- if ttype == '' || stridx(ctags_flags, ttype) == -1
- " Line is not in proper tags format or Tag type is not
- " supported
- continue
- endif
-
- " Update the total tag count
- let tidx = tidx + 1
-
- " The following variables are used to optimize this code. Vim is
- " slow in using curly brace names. To reduce the amount of
- " processing needed, the curly brace variables are pre-processed
- " here
- let fidx_tidx = 's:tlist_' . fidx . '_' . tidx
- let fidx_ttype = 's:tlist_' . fidx . '_' . ttype
-
- " Update the count of this tag type
- let ttype_idx = {fidx_ttype}_count + 1
- let {fidx_ttype}_count = ttype_idx
-
- " Store the ctags output for this tag
- let {fidx_tidx}_tag = one_line
-
- " Store the tag index and the tag type index (back pointers)
- let {fidx_ttype}_{ttype_idx} = tidx
- let {fidx_tidx}_ttype_idx = ttype_idx
-
- " Extract the tag name
- let tag_name = strpart(one_line, 0, stridx(one_line, "\t"))
-
- " Extract the tag scope/prototype
- if g:Tlist_Display_Prototype
- let ttxt = ' ' . s:Tlist_Get_Tag_Prototype(fidx, tidx)
- else
- let ttxt = ' ' . tag_name
-
- " Add the tag scope, if it is available and is configured. Tag
- " scope is the last field after the 'line:<num>\t' field
- if g:Tlist_Display_Tag_Scope
- let ttxt .= s:Tlist_Get_Scope_String(a:tag_line, a:ftype)
- endif
- endif
-
- " Add this tag to the tag type variable
- let {fidx_ttype} = {fidx_ttype} . ttxt . "\n"
-
- " Save the tag name
- let {fidx_tidx}_tag_name = tag_name
- endwhile
-
- " Save the number of tags for this file
- let s:tlist_{fidx}_tag_count = tidx
- endif
-
- call s:Tlist_Log_Msg('Processed ' . s:tlist_{fidx}_tag_count .
- \ ' tags in ' . a:filename)
-
- return fidx
-endfunction
-
-" Tlist_Update_File
-" Update the tags for a file (if needed)
-function! Tlist_Update_File(filename, ftype)
- call s:Tlist_Log_Msg('Tlist_Update_File (' . a:filename . ')')
- " If the file doesn't support tag listing, skip it
- if s:Tlist_Skip_File(a:filename, a:ftype)
- return
- endif
-
- " Convert the file name to a full path
- let fname = fnamemodify(a:filename, ':p')
-
- " First check whether the file already exists
- let fidx = s:Tlist_Get_File_Index(fname)
-
- if fidx != -1 && s:tlist_{fidx}_valid
- " File exists and the tags are valid
- " Check whether the file was modified after the last tags update
- " If it is modified, then update the tags
- if s:tlist_{fidx}_mtime == getftime(fname)
- return
- endif
- else
- " If the tags were removed previously based on a user request,
- " as we are going to update the tags (based on the user request),
- " remove the filename from the deleted list
- call s:Tlist_Update_Remove_List(fname, 0)
- endif
-
- " If the taglist window is opened, update it
- let winnum = bufwinnr(g:TagList_title)
- if winnum == -1
- " Taglist window is not present. Just update the taglist
- " and return
- call s:Tlist_Process_File(fname, a:ftype)
- else
- if g:Tlist_Show_One_File && s:tlist_cur_file_idx != -1
- " If tags for only one file are displayed and we are not
- " updating the tags for that file, then no need to
- " refresh the taglist window. Otherwise, the taglist
- " window should be updated.
- if s:tlist_{s:tlist_cur_file_idx}_filename != fname
- call s:Tlist_Process_File(fname, a:ftype)
- return
- endif
- endif
-
- " Save the current window number
- let save_winnr = winnr()
-
- " Goto the taglist window
- call s:Tlist_Window_Goto_Window()
-
- " Save the cursor position
- let save_line = line('.')
- let save_col = col('.')
-
- " Update the taglist window
- call s:Tlist_Window_Refresh_File(fname, a:ftype)
-
- " Restore the cursor position
- if v:version >= 601
- call cursor(save_line, save_col)
- else
- exe save_line
- exe 'normal! ' . save_col . '|'
- endif
-
- if winnr() != save_winnr
- " Go back to the original window
- call s:Tlist_Exe_Cmd_No_Acmds(save_winnr . 'wincmd w')
- endif
- endif
-
- " Update the taglist menu
- if g:Tlist_Show_Menu
- call s:Tlist_Menu_Update_File(1)
- endif
-endfunction
-
-" Tlist_Window_Close
-" Close the taglist window
-function! s:Tlist_Window_Close()
- call s:Tlist_Log_Msg('Tlist_Window_Close()')
- " Make sure the taglist window exists
- let winnum = bufwinnr(g:TagList_title)
- if winnum == -1
- call s:Tlist_Warning_Msg('Error: Taglist window is not open')
- return
- endif
-
- if winnr() == winnum
- " Already in the taglist window. Close it and return.
- " Store the buffer that was selected prior to the taglist buffer
- let prev_buf = bufnr('#')
- if winbufnr(2) != -1
- " If a window other than the taglist window is open,
- " then only close the taglist window.
- close
- call s:Tlist_Exe_Cmd_No_Acmds(bufwinnr(prev_buf) . 'wincmd w')
- endif
- else
- " Goto the taglist window, close it and then come back to the
- " original window
- let curbufnr = bufnr('%')
- exe winnum . 'wincmd w'
- close
- " Need to jump back to the original window only if we are not
- " already in that window
- let winnum = bufwinnr(curbufnr)
- if winnr() != winnum
- exe winnum . 'wincmd w'
- endif
- endif
-endfunction
-
-" Tlist_Window_Mark_File_Window
-" Mark the current window as the file window to use when jumping to a tag.
-" Only if the current window is a non-plugin, non-preview and non-taglist
-" window
-function! s:Tlist_Window_Mark_File_Window()
- if getbufvar('%', '&buftype') == '' && !&previewwindow
- let w:tlist_file_window = "yes"
- endif
-endfunction
-
-" Tlist_Window_Open
-" Open and refresh the taglist window
-function! s:Tlist_Window_Open()
- call s:Tlist_Log_Msg('Tlist_Window_Open()')
- " If the window is open, jump to it
- let winnum = bufwinnr(g:TagList_title)
- if winnum != -1
- " Jump to the existing window
- if winnr() != winnum
- exe winnum . 'wincmd w'
- endif
- return
- endif
-
- if s:tlist_app_name == "winmanager"
- " Taglist plugin is no longer part of the winmanager app
- let s:tlist_app_name = "none"
- endif
-
- " Get the filename and filetype for the specified buffer
- let curbuf_name = fnamemodify(bufname('%'), ':p')
- let curbuf_ftype = s:Tlist_Get_Buffer_Filetype('%')
- let cur_lnum = line('.')
-
- " Mark the current window as the desired window to open a file when a tag
- " is selected.
- call s:Tlist_Window_Mark_File_Window()
-
- " Open the taglist window
- call s:Tlist_Window_Create()
-
- call s:Tlist_Window_Refresh()
-
- if g:Tlist_Show_One_File
- " Add only the current buffer and file
- "
- " If the file doesn't support tag listing, skip it
- if !s:Tlist_Skip_File(curbuf_name, curbuf_ftype)
- call s:Tlist_Window_Refresh_File(curbuf_name, curbuf_ftype)
- endif
- endif
-
- if g:Tlist_File_Fold_Auto_Close
- " Open the fold for the current file, as all the folds in
- " the taglist window are closed
- let fidx = s:Tlist_Get_File_Index(curbuf_name)
- if fidx != -1
- exe "silent! " . s:tlist_{fidx}_start . "," .
- \ s:tlist_{fidx}_end . "foldopen!"
- endif
- endif
-
- " Highlight the current tag
- call s:Tlist_Window_Highlight_Tag(curbuf_name, cur_lnum, 1, 1)
-endfunction
-
-" Tlist_Window_Toggle()
-" Open or close a taglist window
-function! s:Tlist_Window_Toggle()
- call s:Tlist_Log_Msg('Tlist_Window_Toggle()')
- " If taglist window is open then close it.
- let winnum = bufwinnr(g:TagList_title)
- if winnum != -1
- call s:Tlist_Window_Close()
- return
- endif
-
- " Store the current buffer
- let current_buf = winbufnr(0)
- call s:Tlist_Window_Open()
-
- " Go back to the original window, if Tlist_GainFocus_On_ToggleOpen is not
- " set
- if !g:Tlist_GainFocus_On_ToggleOpen
- let prev_win = bufwinnr(current_buf)
- call s:Tlist_Exe_Cmd_No_Acmds(prev_win . 'wincmd w')
- endif
-
- " Update the taglist menu
- if g:Tlist_Show_Menu
- call s:Tlist_Menu_Update_File(0)
- endif
-endfunction
-
-" Tlist_Process_Filelist
-" Process multiple files. Each filename is separated by "\n"
-" Returns the number of processed files
-function! s:Tlist_Process_Filelist(file_names)
- let flist = a:file_names
-
- " Enable lazy screen updates
- let old_lazyredraw = &lazyredraw
- set lazyredraw
-
- " Keep track of the number of processed files
- let fcnt = 0
-
- " Process one file at a time
- while flist != ''
- let nl_idx = stridx(flist, "\n")
- let one_file = strpart(flist, 0, nl_idx)
-
- " Remove the filename from the list
- let flist = strpart(flist, nl_idx + 1)
-
- if one_file == ''
- continue
- endif
-
- " Skip directories
- if isdirectory(one_file)
- continue
- endif
-
- let ftype = s:Tlist_Detect_Filetype(one_file)
-
- echon "\r "
- echon "\rProcessing tags for " . fnamemodify(one_file, ':p:t')
-
- let fcnt = fcnt + 1
-
- call Tlist_Update_File(one_file, ftype)
- endwhile
-
- " Clear the displayed informational messages
- echon "\r "
-
- " Restore the previous state
- let &lazyredraw = old_lazyredraw
-
- return fcnt
-endfunction
-
-" Tlist_Process_Dir
-" Process the files in a directory matching the specified pattern
-function! s:Tlist_Process_Dir(dir_name, pat)
- let flist = glob(a:dir_name . '/' . a:pat) . "\n"
-
- let fcnt = s:Tlist_Process_Filelist(flist)
-
- let len = strlen(a:dir_name)
- if a:dir_name[len - 1] == '\' || a:dir_name[len - 1] == '/'
- let glob_expr = a:dir_name . '*'
- else
- let glob_expr = a:dir_name . '/*'
- endif
- let all_files = glob(glob_expr) . "\n"
-
- while all_files != ''
- let nl_idx = stridx(all_files, "\n")
- let one_file = strpart(all_files, 0, nl_idx)
-
- let all_files = strpart(all_files, nl_idx + 1)
- if one_file == ''
- continue
- endif
-
- " Skip non-directory names
- if !isdirectory(one_file)
- continue
- endif
-
- echon "\r "
- echon "\rProcessing files in directory " . fnamemodify(one_file, ':t')
- let fcnt = fcnt + s:Tlist_Process_Dir(one_file, a:pat)
- endwhile
-
- return fcnt
-endfunction
-
-" Tlist_Add_Files_Recursive
-" Add files recursively from a directory
-function! s:Tlist_Add_Files_Recursive(dir, ...)
- let dir_name = fnamemodify(a:dir, ':p')
- if !isdirectory(dir_name)
- call s:Tlist_Warning_Msg('Error: ' . dir_name . ' is not a directory')
- return
- endif
-
- if a:0 == 1
- " User specified file pattern
- let pat = a:1
- else
- " Default file pattern
- let pat = '*'
- endif
-
- echon "\r "
- echon "\rProcessing files in directory " . fnamemodify(dir_name, ':t')
- let fcnt = s:Tlist_Process_Dir(dir_name, pat)
-
- echon "\rAdded " . fcnt . " files to the taglist"
-endfunction
-
-" Tlist_Add_Files
-" Add the specified list of files to the taglist
-function! s:Tlist_Add_Files(...)
- let flist = ''
- let i = 1
-
- " Get all the files matching the file patterns supplied as argument
- while i <= a:0
- let flist = flist . glob(a:{i}) . "\n"
- let i = i + 1
- endwhile
-
- if flist == ''
- call s:Tlist_Warning_Msg('Error: No matching files are found')
- return
- endif
-
- let fcnt = s:Tlist_Process_Filelist(flist)
- echon "\rAdded " . fcnt . " files to the taglist"
-endfunction
-
-" Tlist_Extract_Tagtype
-" Extract the tag type from the tag text
-function! s:Tlist_Extract_Tagtype(tag_line)
- " The tag type is after the tag prototype field. The prototype field
- " ends with the /;"\t string. We add 4 at the end to skip the characters
- " in this special string..
- let start = strridx(a:tag_line, '/;"' . "\t") + 4
- let end = match(a:tag_line, 'line\(no\)\?:') - 1
- let ttype = strpart(a:tag_line, start, end - start)
-
- return ttype
-endfunction
-
-" Tlist_Extract_Tag_Scope
-" Extract the tag scope from the tag text
-function! s:Tlist_Extract_Tag_Scope(tag_line)
- let start = match(a:tag_line, 'line\(no\)\?:')
- let end = stridx(a:tag_line, "\t", start)
- if end <= start
- return {}
- endif
-
- let tag_extras = {}
-
- let tag_extra = strpart(a:tag_line, end + 1)
- while tag_extra != ''
- let tag_extra_separator_start = stridx(tag_extra, ':')
- let tag_extra_content_start = tag_extra_separator_start + 1
- let tag_extra_content_end = stridx(tag_extra, "\t")
- if tag_extra_content_end == -1
- let tag_extra_content_end = strlen(tag_extra)
- endif
- let tag_extra_name = strpart(tag_extra, 0, tag_extra_separator_start)
- let tag_extra_content = strpart(tag_extra, tag_extra_content_start, tag_extra_content_end - tag_extra_content_start)
- let tag_extras[tag_extra_name] = tag_extra_content
- let tag_extra = strpart(tag_extra, tag_extra_content_end + 1)
- endwhile
-
- return tag_extras
-endfunction
-
-function! s:Tlist_Window_Toggle_Extra(ftype, extra_name)
- if !exists('g:Tlist_{a:ftype}_Hide_Extras')
- return
- endif
- let index = index(g:Tlist_{a:ftype}_Hide_Extras, a:extra_name)
- if index == -1
- call add(g:Tlist_{a:ftype}_Hide_Extras, a:extra_name)
- else
- unlet g:Tlist_{a:ftype}_Hide_Extras[index]
- endif
- if s:auto_width
- let g:Tlist_WinWidth = 30
- endif
-
- let cur_lnum = line('.')
- let cur_col = col('.')
- call s:Tlist_Window_Update_File()
- call s:Tlist_Window_Check_Width()
- call cursor(cur_lnum, cur_col)
-endfunction
-
-" Tlist_Refresh()
-" Refresh the taglist
-function! s:Tlist_Refresh()
- call s:Tlist_Log_Msg('Tlist_Refresh (Skip_Refresh = ' .
- \ s:Tlist_Skip_Refresh . ', ' . bufname('%') . ')')
- " If we are entering the buffer from one of the taglist functions, then
- " no need to refresh the taglist window again.
- if s:Tlist_Skip_Refresh
- " We still need to update the taglist menu
- if g:Tlist_Show_Menu
- call s:Tlist_Menu_Update_File(0)
- endif
- return
- endif
-
- " If part of the winmanager plugin and not configured to process
- " tags always and not configured to display the tags menu, then return
- if (s:tlist_app_name == 'winmanager') && !g:Tlist_Process_File_Always
- \ && !g:Tlist_Show_Menu
- return
- endif
-
- " Skip buffers with 'buftype' set to nofile, nowrite, quickfix or help
- if &buftype != ''
- return
- endif
-
- let filename = fnamemodify(bufname('%'), ':p')
- let ftype = s:Tlist_Get_Buffer_Filetype('%')
-
- " If the file doesn't support tag listing, skip it
- if s:Tlist_Skip_File(filename, ftype)
- return
- endif
-
- let tlist_win = bufwinnr(g:TagList_title)
-
- " If the taglist window is not opened and not configured to process
- " tags always and not displaying the tags menu, then return
- if tlist_win == -1 && !g:Tlist_Process_File_Always && !g:Tlist_Show_Menu
- return
- endif
-
- let fidx = s:Tlist_Get_File_Index(filename)
- if fidx == -1
- " Check whether this file is removed based on user request
- " If it is, then don't display the tags for this file
- if s:Tlist_User_Removed_File(filename)
- return
- endif
-
- " If the taglist should not be auto updated, then return
- if !g:Tlist_Auto_Update
- return
- endif
- endif
-
- let cur_lnum = line('.')
-
- if fidx == -1
- " Update the tags for the file
- let fidx = s:Tlist_Process_File(filename, ftype)
- else
- let mtime = getftime(filename)
- if s:tlist_{fidx}_mtime != mtime
- " Invalidate the tags listed for this file
- let s:tlist_{fidx}_valid = 0
-
- " Update the taglist and the window
- call Tlist_Update_File(filename, ftype)
-
- " Store the new file modification time
- let s:tlist_{fidx}_mtime = mtime
- endif
- endif
-
- " Update the taglist window
- if tlist_win != -1
- " Disable screen updates
- let old_lazyredraw = &lazyredraw
- set nolazyredraw
-
- " Save the current window number
- let save_winnr = winnr()
-
- " Goto the taglist window
- call s:Tlist_Window_Goto_Window()
-
- if !g:Tlist_Auto_Highlight_Tag || !g:Tlist_Highlight_Tag_On_BufEnter
- " Save the cursor position
- let save_line = line('.')
- let save_col = col('.')
- endif
-
- " Update the taglist window
- call s:Tlist_Window_Refresh_File(filename, ftype)
-
- " Open the fold for the file
- exe "silent! " . s:tlist_{fidx}_start . "," .
- \ s:tlist_{fidx}_end . "foldopen!"
-
- if g:Tlist_Highlight_Tag_On_BufEnter && g:Tlist_Auto_Highlight_Tag
- if g:Tlist_Show_One_File && s:tlist_cur_file_idx != fidx
- " If displaying tags for only one file in the taglist
- " window and about to display the tags for a new file,
- " then center the current tag line for the new file
- let center_tag_line = 1
- else
- let center_tag_line = 0
- endif
-
- " Highlight the current tag
- call s:Tlist_Window_Highlight_Tag(filename, cur_lnum, 1, center_tag_line)
- else
- " Restore the cursor position
- if v:version >= 601
- call cursor(save_line, save_col)
- else
- exe save_line
- exe 'normal! ' . save_col . '|'
- endif
- endif
-
- " Jump back to the original window
- if save_winnr != winnr()
- call s:Tlist_Exe_Cmd_No_Acmds(save_winnr . 'wincmd w')
- endif
-
- " Restore screen updates
- let &lazyredraw = old_lazyredraw
- endif
-
- " Update the taglist menu
- if g:Tlist_Show_Menu
- call s:Tlist_Menu_Update_File(0)
- endif
-endfunction
-
-" Tlist_Change_Sort()
-" Change the sort order of the tag listing
-" caller == 'cmd', command used in the taglist window
-" caller == 'menu', taglist menu
-" action == 'toggle', toggle sort from name to order and vice versa
-" action == 'set', set the sort order to sort_type
-function! s:Tlist_Change_Sort(caller, action, sort_type)
- call s:Tlist_Log_Msg('Tlist_Change_Sort (caller = ' . a:caller .
- \ ', action = ' . a:action . ', sort_type = ' . a:sort_type . ')')
- if a:caller == 'cmd'
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(line('.'))
- if fidx == -1
- return
- endif
-
- " Remove the previous highlighting
- match none
- elseif a:caller == 'menu'
- let fidx = s:Tlist_Get_File_Index(fnamemodify(bufname('%'), ':p'))
- if fidx == -1
- return
- endif
- endif
-
- if a:action == 'toggle'
- let sort_type = s:tlist_{fidx}_sort_type
-
- " Toggle the sort order from 'name' to 'order' and vice versa
- if sort_type == 'name'
- let s:tlist_{fidx}_sort_type = 'order'
- else
- let s:tlist_{fidx}_sort_type = 'name'
- endif
- else
- let s:tlist_{fidx}_sort_type = a:sort_type
- endif
-
- " Invalidate the tags listed for this file
- let s:tlist_{fidx}_valid = 0
-
- if a:caller == 'cmd'
- " Save the current line for later restoration
- let curline = '\V\^' . getline('.') . '\$'
-
- call s:Tlist_Window_Refresh_File(s:tlist_{fidx}_filename,
- \ s:tlist_{fidx}_filetype)
-
- exe s:tlist_{fidx}_start . ',' . s:tlist_{fidx}_end . 'foldopen!'
-
- " Go back to the cursor line before the tag list is sorted
- call search(curline, 'w')
-
- call s:Tlist_Menu_Update_File(1)
- else
- call s:Tlist_Menu_Remove_File()
-
- call s:Tlist_Refresh()
- endif
-endfunction
-
-" Tlist_Update_Current_File()
-" Update taglist for the current buffer by regenerating the tag list
-" Contributed by WEN Guopeng.
-function! s:Tlist_Update_Current_File()
- call s:Tlist_Log_Msg('Tlist_Update_Current_File()')
- if winnr() == bufwinnr(g:TagList_title)
- " In the taglist window. Update the current file
- call s:Tlist_Window_Update_File()
- else
- " Not in the taglist window. Update the current buffer
- let filename = fnamemodify(bufname('%'), ':p')
- let fidx = s:Tlist_Get_File_Index(filename)
- if fidx != -1
- let s:tlist_{fidx}_valid = 0
- endif
- let ft = s:Tlist_Get_Buffer_Filetype('%')
- call Tlist_Update_File(filename, ft)
- endif
-endfunction
-
-" Tlist_Window_Update_File()
-" Update the tags displayed in the taglist window
-function! s:Tlist_Window_Update_File()
- call s:Tlist_Log_Msg('Tlist_Window_Update_File()')
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(line('.'))
- if fidx == -1
- return
- endif
-
- " Remove the previous highlighting
- match none
-
- " Save the current line for later restoration
- let curline = '\V\^' . getline('.') . '\$'
-
- let s:tlist_{fidx}_valid = 0
-
- " Update the taglist window
- call s:Tlist_Window_Refresh_File(s:tlist_{fidx}_filename,
- \ s:tlist_{fidx}_filetype)
-
- exe s:tlist_{fidx}_start . ',' . s:tlist_{fidx}_end . 'foldopen!'
-
- " Go back to the tag line before the list is updated
- call search(curline, 'w')
-endfunction
-
-" Tlist_Window_Get_Tag_Type_By_Linenum()
-" Return the tag type index for the specified line in the taglist window
-function! s:Tlist_Window_Get_Tag_Type_By_Linenum(fidx, lnum)
- let ftype = s:tlist_{a:fidx}_filetype
-
- " Determine to which tag type the current line number belongs to using the
- " tag type start line number and the number of tags in a tag type
- let i = 1
- while i <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{i}_name
- let start_lnum =
- \ s:tlist_{a:fidx}_start + s:tlist_{a:fidx}_{ttype}_offset
- let end = start_lnum + s:tlist_{a:fidx}_{ttype}_count
- if a:lnum >= start_lnum && a:lnum <= end
- break
- endif
- let i = i + 1
- endwhile
-
- " Current line doesn't belong to any of the displayed tag types
- if i > s:tlist_{ftype}_count
- return ''
- endif
-
- return ttype
-endfunction
-
-" Tlist_Window_Get_Tag_Index()
-" Return the tag index for the specified line in the taglist window
-function! s:Tlist_Window_Get_Tag_Index(fidx, lnum)
- let ttype = s:Tlist_Window_Get_Tag_Type_By_Linenum(a:fidx, a:lnum)
-
- " Current line doesn't belong to any of the displayed tag types
- if ttype == ''
- return 0
- endif
-
- " Compute the index into the displayed tags for the tag type
- let ttype_lnum = s:tlist_{a:fidx}_start + s:tlist_{a:fidx}_{ttype}_offset
- let tidx = a:lnum - ttype_lnum
- if tidx == 0
- return 0
- endif
-
- " Get the corresponding tag line and return it
- return s:tlist_{a:fidx}_{ttype}_{tidx}
-endfunction
-
-" Tlist_Window_Highlight_Line
-" Highlight the current line
-function! s:Tlist_Window_Highlight_Line()
- " Clear previously selected name
- match none
-
- " Highlight the current line
- if g:Tlist_Display_Prototype == 0
- let pat = '/\%' . line('.') . 'l\s\+\zs.*/'
- else
- let pat = '/\%' . line('.') . 'l.*/'
- endif
-
- exe 'match TagListTagName ' . pat
-endfunction
-
-" Tlist_Window_Open_File
-" Open the specified file in either a new window or an existing window
-" and place the cursor at the specified tag pattern
-function! s:Tlist_Window_Open_File(win_ctrl, filename, tagpat)
- call s:Tlist_Log_Msg('Tlist_Window_Open_File (' . a:filename . ',' .
- \ a:win_ctrl . ')')
- let prev_Tlist_Skip_Refresh = s:Tlist_Skip_Refresh
- let s:Tlist_Skip_Refresh = 1
-
- if s:tlist_app_name == "winmanager"
- " Let the winmanager edit the file
- call WinManagerFileEdit(a:filename, a:win_ctrl == 'newwin')
- else
-
- if a:win_ctrl == 'newtab'
- " Create a new tab
- exe 'tabnew ' . escape(a:filename, ' ')
- " Open the taglist window in the new tab
- call s:Tlist_Window_Open()
- endif
-
- if a:win_ctrl == 'checktab'
- " Check whether the file is present in any of the tabs.
- " If the file is present in the current tab, then use the
- " current tab.
- if bufwinnr(a:filename) != -1
- let file_present_in_tab = 1
- let i = tabpagenr()
- else
- let i = 1
- let bnum = bufnr(a:filename)
- let file_present_in_tab = 0
- while i <= tabpagenr('$')
- if index(tabpagebuflist(i), bnum) != -1
- let file_present_in_tab = 1
- break
- endif
- let i += 1
- endwhile
- endif
-
- if file_present_in_tab
- " Goto the tab containing the file
- exe 'tabnext ' . i
- else
- " Open a new tab
- exe 'tabnew ' . escape(a:filename, ' ')
-
- " Open the taglist window
- call s:Tlist_Window_Open()
- endif
- endif
-
- let winnum = -1
- if a:win_ctrl == 'prevwin'
- " Open the file in the previous window, if it is usable
- let cur_win = winnr()
- wincmd p
- if &buftype == '' && !&previewwindow
- exe "edit " . escape(a:filename, ' ')
- let winnum = winnr()
- else
- " Previous window is not usable
- exe cur_win . 'wincmd w'
- endif
- endif
-
- " Goto the window containing the file. If the window is not there, open a
- " new window
- if winnum == -1
- let winnum = bufwinnr(a:filename)
- endif
-
- if winnum == -1
- " Locate the previously used window for opening a file
- let fwin_num = 0
- let first_usable_win = 0
-
- let i = 1
- let bnum = winbufnr(i)
- while bnum != -1
- if getwinvar(i, 'tlist_file_window') == 'yes'
- let fwin_num = i
- break
- endif
- if first_usable_win == 0 &&
- \ getbufvar(bnum, '&buftype') == '' &&
- \ !getwinvar(i, '&previewwindow')
- " First non-taglist, non-plugin and non-preview window
- let first_usable_win = i
- endif
- let i = i + 1
- let bnum = winbufnr(i)
- endwhile
-
- " If a previously used window is not found, then use the first
- " non-taglist window
- if fwin_num == 0
- let fwin_num = first_usable_win
- endif
-
- if fwin_num != 0
- " Jump to the file window
- exe fwin_num . "wincmd w"
-
- " If the user asked to jump to the tag in a new window, then split
- " the existing window into two.
- if a:win_ctrl == 'newwin'
- split
- endif
- exe "edit " . escape(a:filename, ' ')
- else
- " Open a new window
- if g:Tlist_Use_Horiz_Window
- exe 'leftabove split ' . escape(a:filename, ' ')
- else
- if winbufnr(2) == -1
- " Only the taglist window is present
- if g:Tlist_Use_Right_Window
- exe 'leftabove vertical split ' .
- \ escape(a:filename, ' ')
- else
- exe 'rightbelow vertical split ' .
- \ escape(a:filename, ' ')
- endif
-
- " Go to the taglist window to change the window size to
- " the user configured value
- call s:Tlist_Exe_Cmd_No_Acmds('wincmd p')
- if g:Tlist_Use_Horiz_Window
- exe 'resize ' . g:Tlist_WinHeight
- else
- exe 'vertical resize ' . g:Tlist_WinWidth
- endif
- " Go back to the file window
- call s:Tlist_Exe_Cmd_No_Acmds('wincmd p')
- else
- " A plugin or help window is also present
- wincmd w
- exe 'leftabove split ' . escape(a:filename, ' ')
- endif
- endif
- endif
- " Mark the window, so that it can be reused.
- call s:Tlist_Window_Mark_File_Window()
- else
- if v:version >= 700
- " If the file is opened in more than one window, then check
- " whether the last accessed window has the selected file.
- " If it does, then use that window.
- let lastwin_bufnum = winbufnr(winnr('#'))
- if bufnr(a:filename) == lastwin_bufnum
- let winnum = winnr('#')
- endif
- endif
- exe winnum . 'wincmd w'
-
- " If the user asked to jump to the tag in a new window, then split the
- " existing window into two.
- if a:win_ctrl == 'newwin'
- split
- endif
- endif
- endif
-
- " Jump to the tag
- if a:tagpat != ''
- " Add the current cursor position to the jump list, so that user can
- " jump back using the ' and ` marks.
- mark '
- silent call search(a:tagpat, 'w')
-
- " Bring the line to the middle of the window
- normal! z.
-
- " If the line is inside a fold, open the fold
- if foldclosed('.') != -1
- .foldopen
- endif
- endif
-
- " If the user selects to preview the tag then jump back to the
- " taglist window
- if a:win_ctrl == 'preview'
- " Go back to the taglist window
- let winnum = bufwinnr(g:TagList_title)
- exe winnum . 'wincmd w'
- else
- " If the user has selected to close the taglist window, when a
- " tag is selected, close the taglist window
- if g:Tlist_Close_On_Select
- call s:Tlist_Window_Goto_Window()
- close
-
- " Go back to the window displaying the selected file
- let wnum = bufwinnr(a:filename)
- if wnum != -1 && wnum != winnr()
- call s:Tlist_Exe_Cmd_No_Acmds(wnum . 'wincmd w')
- endif
- endif
- endif
-
- let s:Tlist_Skip_Refresh = prev_Tlist_Skip_Refresh
-endfunction
-
-" Tlist_Window_Jump_To_Tag()
-" Jump to the location of the current tag
-" win_ctrl == useopen - Reuse the existing file window
-" win_ctrl == newwin - Open a new window
-" win_ctrl == preview - Preview the tag
-" win_ctrl == prevwin - Open in previous window
-" win_ctrl == newtab - Open in new tab
-function! s:Tlist_Window_Jump_To_Tag(win_ctrl)
- call s:Tlist_Log_Msg('Tlist_Window_Jump_To_Tag(' . a:win_ctrl . ')')
- " Do not process comment lines and empty lines
- let curline = getline('.')
- if curline =~ '^\s*$' || curline[0] == '"'
- return
- endif
-
- " If inside a closed fold, then use the first line of the fold
- " and jump to the file.
- let lnum = foldclosed('.')
- if lnum == -1
- " Jump to the selected tag or file
- let lnum = line('.')
- else
- " Open the closed fold
- .foldopen!
- endif
-
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(lnum)
- if fidx == -1
- return
- endif
-
- " Get the tag output for the current tag
- let tidx = s:Tlist_Window_Get_Tag_Index(fidx, lnum)
- if tidx != 0
- let tagpat = s:Tlist_Get_Tag_SearchPat(fidx, tidx)
-
- " Highlight the tagline
- call s:Tlist_Window_Highlight_Line()
- else
- " Selected a line which is not a tag name. Just edit the file
- let tagpat = ''
- endif
-
- call s:Tlist_Window_Open_File(a:win_ctrl, s:tlist_{fidx}_filename, tagpat)
-endfunction
-
-" Tlist_Window_Show_Info()
-" Display information about the entry under the cursor
-function! s:Tlist_Window_Show_Info()
- call s:Tlist_Log_Msg('Tlist_Window_Show_Info()')
-
- " Clear the previously displayed line
- echo
-
- " Do not process comment lines and empty lines
- let curline = getline('.')
- if curline =~ '^\s*$' || curline[0] == '"'
- return
- endif
-
- " If inside a fold, then don't display the prototype
- if foldclosed('.') != -1
- return
- endif
-
- let lnum = line('.')
-
- " Get the file index
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(lnum)
- if fidx == -1
- return
- endif
-
- if lnum == s:tlist_{fidx}_start
- " Cursor is on a file name
- let fname = s:tlist_{fidx}_filename
- if strlen(fname) > 50
- let fname = fnamemodify(fname, ':t')
- endif
- echo fname . ', Filetype=' . s:tlist_{fidx}_filetype .
- \ ', Tag count=' . s:tlist_{fidx}_tag_count
- return
- endif
-
- " Get the tag output line for the current tag
- let tidx = s:Tlist_Window_Get_Tag_Index(fidx, lnum)
- if tidx == 0
- " Cursor is on a tag type
- let ttype = s:Tlist_Window_Get_Tag_Type_By_Linenum(fidx, lnum)
- if ttype == ''
- return
- endif
-
- let ttype_name = ''
-
- let ftype = s:tlist_{fidx}_filetype
- let i = 1
- while i <= s:tlist_{ftype}_count
- if ttype == s:tlist_{ftype}_{i}_name
- let ttype_name = s:tlist_{ftype}_{i}_fullname
- break
- endif
- let i = i + 1
- endwhile
-
- echo 'Tag type=' . ttype_name .
- \ ', Tag count=' . s:tlist_{fidx}_{ttype}_count
- return
- endif
-
- " Get the tag search pattern and display it
- echo s:Tlist_Get_Tag_Prototype(fidx, tidx)
-endfunction
-
-" Tlist_Find_Nearest_Tag_Idx
-" Find the tag idx nearest to the supplied line number
-" Returns -1, if a tag couldn't be found for the specified line number
-function! s:Tlist_Find_Nearest_Tag_Idx(fidx, linenum)
- let sort_type = s:tlist_{a:fidx}_sort_type
-
- let left = 1
- let right = s:tlist_{a:fidx}_tag_count
-
- if sort_type == 'order'
- " Tags sorted by order, use a binary search.
- " The idea behind this function is taken from the ctags.vim script (by
- " Alexey Marinichev) available at the Vim online website.
-
- " If the current line is the less than the first tag, then no need to
- " search
- let first_lnum = s:Tlist_Get_Tag_Linenum(a:fidx, 1)
-
- if a:linenum < first_lnum
- return -1
- endif
-
- while left < right
- let middle = (right + left + 1) / 2
- let middle_lnum = s:Tlist_Get_Tag_Linenum(a:fidx, middle)
-
- if middle_lnum == a:linenum
- let left = middle
- break
- endif
-
- if middle_lnum > a:linenum
- let right = middle - 1
- else
- let left = middle
- endif
- endwhile
- else
- " Tags sorted by name, use a linear search. (contributed by Dave
- " Eggum).
- " Look for a tag with a line number less than or equal to the supplied
- " line number. If multiple tags are found, then use the tag with the
- " line number closest to the supplied line number. IOW, use the tag
- " with the highest line number.
- let closest_lnum = 0
- let final_left = 0
- while left <= right
- let lnum = s:Tlist_Get_Tag_Linenum(a:fidx, left)
-
- if lnum < a:linenum && lnum > closest_lnum
- let closest_lnum = lnum
- let final_left = left
- elseif lnum == a:linenum
- let closest_lnum = lnum
- let final_left = left
- break
- else
- let left = left + 1
- endif
- endwhile
- if closest_lnum == 0
- return -1
- endif
- if left >= right
- let left = final_left
- endif
- endif
-
- return left
-endfunction
-
-" Tlist_Window_Highlight_Tag()
-" Highlight the current tag
-" cntx == 1, Called by the taglist plugin itself
-" cntx == 2, Forced by the user through the TlistHighlightTag command
-" center = 1, move the tag line to the center of the taglist window
-function! s:Tlist_Window_Highlight_Tag(filename, cur_lnum, cntx, center)
- " Highlight the current tag only if the user configured the
- " taglist plugin to do so or if the user explictly invoked the
- " command to highlight the current tag.
- if !g:Tlist_Auto_Highlight_Tag && a:cntx == 1
- return
- endif
-
- if a:filename == ''
- return
- endif
-
- " Make sure the taglist window is present
- let winnum = bufwinnr(g:TagList_title)
- if winnum == -1
- call s:Tlist_Warning_Msg('Error: Taglist window is not open')
- return
- endif
-
- let fidx = s:Tlist_Get_File_Index(a:filename)
- if fidx == -1
- return
- endif
-
- " If the file is currently not displayed in the taglist window, then retrn
- if !s:tlist_{fidx}_visible
- return
- endif
-
- " If there are no tags for this file, then no need to proceed further
- if s:tlist_{fidx}_tag_count == 0
- return
- endif
-
- " Ignore all autocommands
- let old_ei = &eventignore
- set eventignore=all
-
- " Save the original window number
- let org_winnr = winnr()
-
- if org_winnr == winnum
- let in_taglist_window = 1
- else
- let in_taglist_window = 0
- endif
-
- " Go to the taglist window
- if !in_taglist_window
- exe winnum . 'wincmd w'
- endif
-
- " Clear previously selected name
- match none
-
- let tidx = s:Tlist_Find_Nearest_Tag_Idx(fidx, a:cur_lnum)
- if tidx == -1
- " Make sure the current tag line is visible in the taglist window.
- " Calling the winline() function makes the line visible. Don't know
- " of a better way to achieve this.
- let lnum = line('.')
-
- if lnum < s:tlist_{fidx}_start || lnum > s:tlist_{fidx}_end
- " Move the cursor to the beginning of the file
- exe s:tlist_{fidx}_start
- endif
-
- if foldclosed('.') != -1
- .foldopen
- endif
-
- call winline()
-
- if !in_taglist_window
- exe org_winnr . 'wincmd w'
- endif
-
- " Restore the autocommands
- let &eventignore = old_ei
- return
- endif
-
- " Extract the tag type
- let ttype = s:Tlist_Get_Tag_Type_By_Tag(fidx, tidx)
-
- " Compute the line number
- " Start of file + Start of tag type + offset
- let lnum = s:tlist_{fidx}_start + s:tlist_{fidx}_{ttype}_offset +
- \ s:tlist_{fidx}_{tidx}_ttype_idx
-
- " Goto the line containing the tag
- exe lnum
-
- " Open the fold
- if foldclosed('.') != -1
- .foldopen
- endif
-
- if a:center
- " Move the tag line to the center of the taglist window
- normal! z.
- else
- " Make sure the current tag line is visible in the taglist window.
- " Calling the winline() function makes the line visible. Don't know
- " of a better way to achieve this.
- call winline()
- endif
-
- " Highlight the tag name
- call s:Tlist_Window_Highlight_Line()
-
- " Go back to the original window
- if !in_taglist_window
- exe org_winnr . 'wincmd w'
- endif
-
- " Restore the autocommands
- let &eventignore = old_ei
- return
-endfunction
-
-" Tlist_Get_Tag_Prototype_By_Line
-" Get the prototype for the tag on or before the specified line number in the
-" current buffer
-function! Tlist_Get_Tag_Prototype_By_Line(...)
- if a:0 == 0
- " Arguments are not supplied. Use the current buffer name
- " and line number
- let filename = bufname('%')
- let linenr = line('.')
- elseif a:0 == 2
- " Filename and line number are specified
- let filename = a:1
- let linenr = a:2
- if linenr !~ '\d\+'
- " Invalid line number
- return ""
- endif
- else
- " Sufficient arguments are not supplied
- let msg = 'Usage: Tlist_Get_Tag_Prototype_By_Line <filename> ' .
- \ '<line_number>'
- call s:Tlist_Warning_Msg(msg)
- return ""
- endif
-
- " Expand the file to a fully qualified name
- let filename = fnamemodify(filename, ':p')
- if filename == ''
- return ""
- endif
-
- let fidx = s:Tlist_Get_File_Index(filename)
- if fidx == -1
- return ""
- endif
-
- " If there are no tags for this file, then no need to proceed further
- if s:tlist_{fidx}_tag_count == 0
- return ""
- endif
-
- " Get the tag text using the line number
- let tidx = s:Tlist_Find_Nearest_Tag_Idx(fidx, linenr)
- if tidx == -1
- return ""
- endif
-
- return s:Tlist_Get_Tag_Prototype(fidx, tidx)
-endfunction
-
-" Tlist_Get_Tagname_By_Line
-" Get the tag name on or before the specified line number in the
-" current buffer
-function! Tlist_Get_Tagname_By_Line(...)
- if a:0 == 0
- " Arguments are not supplied. Use the current buffer name
- " and line number
- let filename = bufname('%')
- let linenr = line('.')
- elseif a:0 == 2
- " Filename and line number are specified
- let filename = a:1
- let linenr = a:2
- if linenr !~ '\d\+'
- " Invalid line number
- return ""
- endif
- else
- " Sufficient arguments are not supplied
- let msg = 'Usage: Tlist_Get_Tagname_By_Line <filename> <line_number>'
- call s:Tlist_Warning_Msg(msg)
- return ""
- endif
-
- " Make sure the current file has a name
- let filename = fnamemodify(filename, ':p')
- if filename == ''
- return ""
- endif
-
- let fidx = s:Tlist_Get_File_Index(filename)
- if fidx == -1
- return ""
- endif
-
- " If there are no tags for this file, then no need to proceed further
- if s:tlist_{fidx}_tag_count == 0
- return ""
- endif
-
- " Get the tag name using the line number
- let tidx = s:Tlist_Find_Nearest_Tag_Idx(fidx, linenr)
- if tidx == -1
- return ""
- endif
-
- return s:tlist_{fidx}_{tidx}_tag_name
-endfunction
-
-" Tlist_Window_Move_To_File
-" Move the cursor to the beginning of the current file or the next file
-" or the previous file in the taglist window
-" dir == -1, move to start of current or previous function
-" dir == 1, move to start of next function
-function! s:Tlist_Window_Move_To_File(dir)
- if foldlevel('.') == 0
- " Cursor is on a non-folded line (it is not in any of the files)
- " Move it to a folded line
- if a:dir == -1
- normal! zk
- else
- " While moving down to the start of the next fold,
- " no need to do go to the start of the next file.
- normal! zj
- return
- endif
- endif
-
- let fidx = s:Tlist_Window_Get_File_Index_By_Linenum(line('.'))
- if fidx == -1
- return
- endif
-
- let cur_lnum = line('.')
-
- if a:dir == -1
- if cur_lnum > s:tlist_{fidx}_start
- " Move to the beginning of the current file
- exe s:tlist_{fidx}_start
- return
- endif
-
- if fidx != 0
- " Move to the beginning of the previous file
- let fidx = fidx - 1
- else
- " Cursor is at the first file, wrap around to the last file
- let fidx = s:tlist_file_count - 1
- endif
-
- exe s:tlist_{fidx}_start
- return
- else
- " Move to the beginning of the next file
- let fidx = fidx + 1
-
- if fidx >= s:tlist_file_count
- " Cursor is at the last file, wrap around to the first file
- let fidx = 0
- endif
-
- if s:tlist_{fidx}_start != 0
- exe s:tlist_{fidx}_start
- endif
- return
- endif
-endfunction
-
-" Tlist_Session_Load
-" Load a taglist session (information about all the displayed files
-" and the tags) from the specified file
-function! s:Tlist_Session_Load(...)
- if a:0 == 0 || a:1 == ''
- call s:Tlist_Warning_Msg('Usage: TlistSessionLoad <filename>')
- return
- endif
-
- let sessionfile = a:1
-
- if !filereadable(sessionfile)
- let msg = 'Taglist: Error - Unable to open file ' . sessionfile
- call s:Tlist_Warning_Msg(msg)
- return
- endif
-
- " Mark the current window as the file window
- call s:Tlist_Window_Mark_File_Window()
-
- " Source the session file
- exe 'source ' . sessionfile
-
- let new_file_count = g:tlist_file_count
- unlet! g:tlist_file_count
-
- let i = 0
- while i < new_file_count
- let ftype = g:tlist_{i}_filetype
- unlet! g:tlist_{i}_filetype
-
- if !exists('s:tlist_' . ftype . '_count')
- if s:Tlist_FileType_Init(ftype) == 0
- let i = i + 1
- continue
- endif
- endif
-
- let fname = g:tlist_{i}_filename
- unlet! g:tlist_{i}_filename
-
- let fidx = s:Tlist_Get_File_Index(fname)
- if fidx != -1
- let s:tlist_{fidx}_visible = 0
- let i = i + 1
- continue
- else
- " As we are loading the tags from the session file, if this
- " file was previously deleted by the user, now we need to
- " add it back. So remove the file from the deleted list.
- call s:Tlist_Update_Remove_List(fname, 0)
- endif
-
- let fidx = s:Tlist_Init_File(fname, ftype)
-
- let s:tlist_{fidx}_filename = fname
-
- let s:tlist_{fidx}_sort_type = g:tlist_{i}_sort_type
- unlet! g:tlist_{i}_sort_type
-
- let s:tlist_{fidx}_filetype = ftype
- let s:tlist_{fidx}_mtime = getftime(fname)
-
- let s:tlist_{fidx}_start = 0
- let s:tlist_{fidx}_end = 0
-
- let s:tlist_{fidx}_valid = 1
-
- let s:tlist_{fidx}_tag_count = g:tlist_{i}_tag_count
- unlet! g:tlist_{i}_tag_count
-
- let j = 1
- while j <= s:tlist_{fidx}_tag_count
- let s:tlist_{fidx}_{j}_tag = g:tlist_{i}_{j}_tag
- let s:tlist_{fidx}_{j}_tag_name = g:tlist_{i}_{j}_tag_name
- let s:tlist_{fidx}_{j}_ttype_idx = g:tlist_{i}_{j}_ttype_idx
- unlet! g:tlist_{i}_{j}_tag
- unlet! g:tlist_{i}_{j}_tag_name
- unlet! g:tlist_{i}_{j}_ttype_idx
- let j = j + 1
- endwhile
-
- let j = 1
- while j <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{j}_name
-
- if exists('g:tlist_' . i . '_' . ttype)
- let s:tlist_{fidx}_{ttype} = g:tlist_{i}_{ttype}
- unlet! g:tlist_{i}_{ttype}
- let s:tlist_{fidx}_{ttype}_offset = 0
- let s:tlist_{fidx}_{ttype}_count = g:tlist_{i}_{ttype}_count
- unlet! g:tlist_{i}_{ttype}_count
-
- let k = 1
- while k <= s:tlist_{fidx}_{ttype}_count
- let s:tlist_{fidx}_{ttype}_{k} = g:tlist_{i}_{ttype}_{k}
- unlet! g:tlist_{i}_{ttype}_{k}
- let k = k + 1
- endwhile
- else
- let s:tlist_{fidx}_{ttype} = ''
- let s:tlist_{fidx}_{ttype}_offset = 0
- let s:tlist_{fidx}_{ttype}_count = 0
- endif
-
- let j = j + 1
- endwhile
-
- let i = i + 1
- endwhile
-
- " If the taglist window is open, then update it
- let winnum = bufwinnr(g:TagList_title)
- if winnum != -1
- let save_winnr = winnr()
-
- " Goto the taglist window
- call s:Tlist_Window_Goto_Window()
-
- " Refresh the taglist window
- call s:Tlist_Window_Refresh()
-
- " Go back to the original window
- if save_winnr != winnr()
- call s:Tlist_Exe_Cmd_No_Acmds('wincmd p')
- endif
- endif
-endfunction
-
-" Tlist_Session_Save
-" Save a taglist session (information about all the displayed files
-" and the tags) into the specified file
-function! s:Tlist_Session_Save(...)
- if a:0 == 0 || a:1 == ''
- call s:Tlist_Warning_Msg('Usage: TlistSessionSave <filename>')
- return
- endif
-
- let sessionfile = a:1
-
- if s:tlist_file_count == 0
- " There is nothing to save
- call s:Tlist_Warning_Msg('Warning: Taglist is empty. Nothing to save.')
- return
- endif
-
- if filereadable(sessionfile)
- let ans = input('Do you want to overwrite ' . sessionfile . ' (Y/N)?')
- if ans !=? 'y'
- return
- endif
-
- echo "\n"
- endif
-
- let old_verbose = &verbose
- set verbose&vim
-
- exe 'redir! > ' . sessionfile
-
- silent! echo '" Taglist session file. This file is auto-generated.'
- silent! echo '" File information'
- silent! echo 'let tlist_file_count = ' . s:tlist_file_count
-
- let i = 0
-
- while i < s:tlist_file_count
- " Store information about the file
- silent! echo 'let tlist_' . i . "_filename = '" .
- \ s:tlist_{i}_filename . "'"
- silent! echo 'let tlist_' . i . '_sort_type = "' .
- \ s:tlist_{i}_sort_type . '"'
- silent! echo 'let tlist_' . i . '_filetype = "' .
- \ s:tlist_{i}_filetype . '"'
- silent! echo 'let tlist_' . i . '_tag_count = ' .
- \ s:tlist_{i}_tag_count
- " Store information about all the tags
- let j = 1
- while j <= s:tlist_{i}_tag_count
- let txt = escape(s:tlist_{i}_{j}_tag, '"\\')
- silent! echo 'let tlist_' . i . '_' . j . '_tag = "' . txt . '"'
- silent! echo 'let tlist_' . i . '_' . j . '_tag_name = "' .
- \ s:tlist_{i}_{j}_tag_name . '"'
- silent! echo 'let tlist_' . i . '_' . j . '_ttype_idx' . ' = ' .
- \ s:tlist_{i}_{j}_ttype_idx
- let j = j + 1
- endwhile
-
- " Store information about all the tags grouped by their type
- let ftype = s:tlist_{i}_filetype
- let j = 1
- while j <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{j}_name
- if s:tlist_{i}_{ttype}_count != 0
- let txt = escape(s:tlist_{i}_{ttype}, '"\')
- let txt = substitute(txt, "\n", "\\\\n", 'g')
- silent! echo 'let tlist_' . i . '_' . ttype . ' = "' .
- \ txt . '"'
- silent! echo 'let tlist_' . i . '_' . ttype . '_count = ' .
- \ s:tlist_{i}_{ttype}_count
- let k = 1
- while k <= s:tlist_{i}_{ttype}_count
- silent! echo 'let tlist_' . i . '_' . ttype . '_' . k .
- \ ' = ' . s:tlist_{i}_{ttype}_{k}
- let k = k + 1
- endwhile
- endif
- let j = j + 1
- endwhile
-
- silent! echo
-
- let i = i + 1
- endwhile
-
- redir END
-
- let &verbose = old_verbose
-endfunction
-
-" Tlist_Buffer_Removed
-" A buffer is removed from the Vim buffer list. Remove the tags defined
-" for that file
-function! s:Tlist_Buffer_Removed(filename)
- call s:Tlist_Log_Msg('Tlist_Buffer_Removed (' . a:filename . ')')
-
- " Make sure a valid filename is supplied
- if a:filename == ''
- return
- endif
-
- " Get tag list index of the specified file
- let fidx = s:Tlist_Get_File_Index(a:filename)
- if fidx == -1
- " File not present in the taglist
- return
- endif
-
- " Remove the file from the list
- call s:Tlist_Remove_File(fidx, 0)
-endfunction
-
-" When a buffer is deleted, remove the file from the taglist
-autocmd BufDelete * silent call s:Tlist_Buffer_Removed(expand('<afile>:p'))
-
-" Tlist_Window_Open_File_Fold
-" Open the fold for the specified file and close the fold for all the
-" other files
-function! s:Tlist_Window_Open_File_Fold(acmd_bufnr)
- call s:Tlist_Log_Msg('Tlist_Window_Open_File_Fold (' . a:acmd_bufnr . ')')
-
- " Make sure the taglist window is present
- let winnum = bufwinnr(g:TagList_title)
- if winnum == -1
- call s:Tlist_Warning_Msg('Taglist: Error - Taglist window is not open')
- return
- endif
-
- " Save the original window number
- let org_winnr = winnr()
- if org_winnr == winnum
- let in_taglist_window = 1
- else
- let in_taglist_window = 0
- endif
-
- if in_taglist_window
- " When entering the taglist window, no need to update the folds
- return
- endif
-
- " Go to the taglist window
- if !in_taglist_window
- call s:Tlist_Exe_Cmd_No_Acmds(winnum . 'wincmd w')
- endif
-
- " Close all the folds
- silent! %foldclose
-
- " Get tag list index of the specified file
- let fname = fnamemodify(bufname(a:acmd_bufnr + 0), ':p')
- if filereadable(fname)
- let fidx = s:Tlist_Get_File_Index(fname)
- if fidx != -1
- " Open the fold for the file
- exe "silent! " . s:tlist_{fidx}_start . "," .
- \ s:tlist_{fidx}_end . "foldopen"
- endif
- endif
-
- " Go back to the original window
- if !in_taglist_window
- call s:Tlist_Exe_Cmd_No_Acmds(org_winnr . 'wincmd w')
- endif
-endfunction
-
-" Tlist_Window_Check_Auto_Open
-" Open the taglist window automatically on Vim startup.
-" Open the window only when files present in any of the Vim windows support
-" tags.
-function! s:Tlist_Window_Check_Auto_Open()
- let open_window = 0
-
- let i = 1
- let buf_num = winbufnr(i)
- while buf_num != -1
- let filename = fnamemodify(bufname(buf_num), ':p')
- let ft = s:Tlist_Get_Buffer_Filetype(buf_num)
- if !s:Tlist_Skip_File(filename, ft)
- let open_window = 1
- break
- endif
- let i = i + 1
- let buf_num = winbufnr(i)
- endwhile
-
- if open_window
- call s:Tlist_Window_Toggle()
- endif
-endfunction
-
-" Tlist_Refresh_Folds
-" Remove and create the folds for all the files displayed in the taglist
-" window. Used after entering a tab. If this is not done, then the folds
-" are not properly created for taglist windows displayed in multiple tabs.
-function! s:Tlist_Refresh_Folds()
- let winnum = bufwinnr(g:TagList_title)
- if winnum == -1
- return
- endif
-
- let save_wnum = winnr()
- exe winnum . 'wincmd w'
-
- " First remove all the existing folds
- normal! zE
-
- " Create the folds for each in the tag list
- let fidx = 0
- while fidx < s:tlist_file_count
- let ftype = s:tlist_{fidx}_filetype
-
- " Create the folds for each tag type in a file
- let j = 1
- while j <= s:tlist_{ftype}_count
- let ttype = s:tlist_{ftype}_{j}_name
- if s:tlist_{fidx}_{ttype}_count
- let s = s:tlist_{fidx}_start + s:tlist_{fidx}_{ttype}_offset
- let e = s + s:tlist_{fidx}_{ttype}_count
- exe s . ',' . e . 'fold'
- endif
- let j = j + 1
- endwhile
-
- exe s:tlist_{fidx}_start . ',' . s:tlist_{fidx}_end . 'fold'
- exe 'silent! ' . s:tlist_{fidx}_start . ',' .
- \ s:tlist_{fidx}_end . 'foldopen!'
- let fidx = fidx + 1
- endwhile
-
- exe save_wnum . 'wincmd w'
-endfunction
-
-function! s:Tlist_Menu_Add_Base_Menu()
- call s:Tlist_Log_Msg('Adding the base menu')
-
- " Add the menu
- anoremenu <silent> T&ags.Refresh\ menu :call <SID>Tlist_Menu_Refresh()<CR>
- anoremenu <silent> T&ags.Sort\ menu\ by.Name
- \ :call <SID>Tlist_Change_Sort('menu', 'set', 'name')<CR>
- anoremenu <silent> T&ags.Sort\ menu\ by.Order
- \ :call <SID>Tlist_Change_Sort('menu', 'set', 'order')<CR>
- anoremenu T&ags.-SEP1- :
-
- if &mousemodel =~ 'popup'
- anoremenu <silent> PopUp.T&ags.Refresh\ menu
- \ :call <SID>Tlist_Menu_Refresh()<CR>
- anoremenu <silent> PopUp.T&ags.Sort\ menu\ by.Name
- \ :call <SID>Tlist_Change_Sort('menu', 'set', 'name')<CR>
- anoremenu <silent> PopUp.T&ags.Sort\ menu\ by.Order
- \ :call <SID>Tlist_Change_Sort('menu', 'set', 'order')<CR>
- anoremenu PopUp.T&ags.-SEP1- :
- endif
-endfunction
-
-let s:menu_char_prefix =
- \ '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-" Tlist_Menu_Get_Tag_Type_Cmd
-" Get the menu command for the specified tag type
-" fidx - File type index
-" ftype - File Type
-" add_ttype_name - To add or not to add the tag type name to the menu entries
-" ttype_idx - Tag type index
-function! s:Tlist_Menu_Get_Tag_Type_Cmd(fidx, ftype, add_ttype_name, ttype_idx)
- " Curly brace variable name optimization
- let ftype_ttype_idx = a:ftype . '_' . a:ttype_idx
-
- let ttype = s:tlist_{ftype_ttype_idx}_name
- if a:add_ttype_name
- " If the tag type name contains space characters, escape it. This
- " will be used to create the menu entries.
- let ttype_fullname = escape(s:tlist_{ftype_ttype_idx}_fullname, ' ')
- endif
-
- " Curly brace variable name optimization
- let fidx_ttype = a:fidx . '_' . ttype
-
- " Number of tag entries for this tag type
- let tcnt = s:tlist_{fidx_ttype}_count
- if tcnt == 0 " No entries for this tag type
- return ''
- endif
-
- let mcmd = ''
-
- " Create the menu items for the tags.
- " Depending on the number of tags of this type, split the menu into
- " multiple sub-menus, if needed.
- if tcnt > g:Tlist_Max_Submenu_Items
- let j = 1
- while j <= tcnt
- let final_index = j + g:Tlist_Max_Submenu_Items - 1
- if final_index > tcnt
- let final_index = tcnt
- endif
-
- " Extract the first and last tag name and form the
- " sub-menu name
- let tidx = s:tlist_{fidx_ttype}_{j}
- let first_tag = s:tlist_{a:fidx}_{tidx}_tag_name
-
- let tidx = s:tlist_{fidx_ttype}_{final_index}
- let last_tag = s:tlist_{a:fidx}_{tidx}_tag_name
-
- " Truncate the names, if they are greater than the
- " max length
- let first_tag = strpart(first_tag, 0, g:Tlist_Max_Tag_Length)
- let last_tag = strpart(last_tag, 0, g:Tlist_Max_Tag_Length)
-
- " Form the menu command prefix
- let m_prefix = 'anoremenu <silent> T\&ags.'
- if a:add_ttype_name
- let m_prefix = m_prefix . ttype_fullname . '.'
- endif
- let m_prefix = m_prefix . first_tag . '\.\.\.' . last_tag . '.'
-
- " Character prefix used to number the menu items (hotkey)
- let m_prefix_idx = 0
-
- while j <= final_index
- let tidx = s:tlist_{fidx_ttype}_{j}
-
- let tname = s:tlist_{a:fidx}_{tidx}_tag_name
-
- let mcmd = mcmd . m_prefix . '\&' .
- \ s:menu_char_prefix[m_prefix_idx] . '\.' .
- \ tname . ' :call <SID>Tlist_Menu_Jump_To_Tag(' .
- \ tidx . ')<CR>|'
-
- let m_prefix_idx = m_prefix_idx + 1
- let j = j + 1
- endwhile
- endwhile
- else
- " Character prefix used to number the menu items (hotkey)
- let m_prefix_idx = 0
-
- let m_prefix = 'anoremenu <silent> T\&ags.'
- if a:add_ttype_name
- let m_prefix = m_prefix . ttype_fullname . '.'
- endif
- let j = 1
- while j <= tcnt
- let tidx = s:tlist_{fidx_ttype}_{j}
-
- let tname = s:tlist_{a:fidx}_{tidx}_tag_name
-
- let mcmd = mcmd . m_prefix . '\&' .
- \ s:menu_char_prefix[m_prefix_idx] . '\.' .
- \ tname . ' :call <SID>Tlist_Menu_Jump_To_Tag(' . tidx
- \ . ')<CR>|'
-
- let m_prefix_idx = m_prefix_idx + 1
- let j = j + 1
- endwhile
- endif
-
- return mcmd
-endfunction
-
-" Update the taglist menu with the tags for the specified file
-function! s:Tlist_Menu_File_Refresh(fidx)
- call s:Tlist_Log_Msg('Refreshing the tag menu for ' . s:tlist_{a:fidx}_filename)
- " The 'B' flag is needed in the 'cpoptions' option
- let old_cpoptions = &cpoptions
- set cpoptions&vim
-
- exe s:tlist_{a:fidx}_menu_cmd
-
- " Update the popup menu (if enabled)
- if &mousemodel =~ 'popup'
- let cmd = substitute(s:tlist_{a:fidx}_menu_cmd, ' T\\&ags\.',
- \ ' PopUp.T\\\&ags.', "g")
- exe cmd
- endif
-
- " The taglist menu is not empty now
- let s:tlist_menu_empty = 0
-
- " Restore the 'cpoptions' settings
- let &cpoptions = old_cpoptions
-endfunction
-
-" Tlist_Menu_Update_File
-" Add the taglist menu
-function! s:Tlist_Menu_Update_File(clear_menu)
- if !has('gui_running')
- " Not running in GUI mode
- return
- endif
-
- call s:Tlist_Log_Msg('Updating the tag menu, clear_menu = ' . a:clear_menu)
-
- " Remove the tags menu
- if a:clear_menu
- call s:Tlist_Menu_Remove_File()
-
- endif
-
- " Skip buffers with 'buftype' set to nofile, nowrite, quickfix or help
- if &buftype != ''
- return
- endif
-
- let filename = fnamemodify(bufname('%'), ':p')
- let ftype = s:Tlist_Get_Buffer_Filetype('%')
-
- " If the file doesn't support tag listing, skip it
- if s:Tlist_Skip_File(filename, ftype)
- return
- endif
-
- let fidx = s:Tlist_Get_File_Index(filename)
- if fidx == -1 || !s:tlist_{fidx}_valid
- " Check whether this file is removed based on user request
- " If it is, then don't display the tags for this file
- if s:Tlist_User_Removed_File(filename)
- return
- endif
-
- " Process the tags for the file
- let fidx = s:Tlist_Process_File(filename, ftype)
- if fidx == -1
- return
- endif
- endif
-
- let fname = escape(fnamemodify(bufname('%'), ':t'), '.')
- if fname != ''
- exe 'anoremenu T&ags.' . fname . ' <Nop>'
- anoremenu T&ags.-SEP2- :
- endif
-
- if !s:tlist_{fidx}_tag_count
- return
- endif
-
- if s:tlist_{fidx}_menu_cmd != ''
- " Update the menu with the cached command
- call s:Tlist_Menu_File_Refresh(fidx)
-
- return
- endif
-
- " We are going to add entries to the tags menu, so the menu won't be
- " empty
- let s:tlist_menu_empty = 0
-
- let cmd = ''
-
- " Determine whether the tag type name needs to be added to the menu
- " If more than one tag type is present in the taglisting for a file,
- " then the tag type name needs to be present
- let add_ttype_name = -1
- let i = 1
- while i <= s:tlist_{ftype}_count && add_ttype_name < 1
- let ttype = s:tlist_{ftype}_{i}_name
- if s:tlist_{fidx}_{ttype}_count
- let add_ttype_name = add_ttype_name + 1
- endif
- let i = i + 1
- endwhile
-
- " Process the tags by the tag type and get the menu command
- let i = 1
- while i <= s:tlist_{ftype}_count
- let mcmd = s:Tlist_Menu_Get_Tag_Type_Cmd(fidx, ftype, add_ttype_name, i)
- if mcmd != ''
- let cmd = cmd . mcmd
- endif
-
- let i = i + 1
- endwhile
-
- " Cache the menu command for reuse
- let s:tlist_{fidx}_menu_cmd = cmd
-
- " Update the menu
- call s:Tlist_Menu_File_Refresh(fidx)
-endfunction
-
-" Tlist_Menu_Remove_File
-" Remove the tags displayed in the tags menu
-function! s:Tlist_Menu_Remove_File()
- if !has('gui_running') || s:tlist_menu_empty
- return
- endif
-
- call s:Tlist_Log_Msg('Removing the tags menu for a file')
-
- " Cleanup the Tags menu
- silent! unmenu T&ags
- if &mousemodel =~ 'popup'
- silent! unmenu PopUp.T&ags
- endif
-
- " Add a dummy menu item to retain teared off menu
- noremenu T&ags.Dummy l
-
- silent! unmenu! T&ags
- if &mousemodel =~ 'popup'
- silent! unmenu! PopUp.T&ags
- endif
-
- call s:Tlist_Menu_Add_Base_Menu()
-
- " Remove the dummy menu item
- unmenu T&ags.Dummy
-
- let s:tlist_menu_empty = 1
-endfunction
-
-" Tlist_Menu_Refresh
-" Refresh the taglist menu
-function! s:Tlist_Menu_Refresh()
- call s:Tlist_Log_Msg('Refreshing the tags menu')
- let fidx = s:Tlist_Get_File_Index(fnamemodify(bufname('%'), ':p'))
- if fidx != -1
- " Invalidate the cached menu command
- let s:tlist_{fidx}_menu_cmd = ''
- endif
-
- " Update the taglist, menu and window
- call s:Tlist_Update_Current_File()
-endfunction
-
-" Tlist_Menu_Jump_To_Tag
-" Jump to the selected tag
-function! s:Tlist_Menu_Jump_To_Tag(tidx)
- let fidx = s:Tlist_Get_File_Index(fnamemodify(bufname('%'), ':p'))
- if fidx == -1
- return
- endif
-
- let tagpat = s:Tlist_Get_Tag_SearchPat(fidx, a:tidx)
- if tagpat == ''
- return
- endif
-
- " Add the current cursor position to the jump list, so that user can
- " jump back using the ' and ` marks.
- mark '
-
- silent call search(tagpat, 'w')
-
- " Bring the line to the middle of the window
- normal! z.
-
- " If the line is inside a fold, open the fold
- if foldclosed('.') != -1
- .foldopen
- endif
-endfunction
-
-" Tlist_Menu_Init
-" Initialize the taglist menu
-function! s:Tlist_Menu_Init()
- call s:Tlist_Menu_Add_Base_Menu()
-
- " Automatically add the tags defined in the current file to the menu
- augroup TagListMenuCmds
- autocmd!
-
- if !g:Tlist_Process_File_Always
- autocmd BufEnter * call s:Tlist_Refresh()
- endif
- autocmd BufLeave * call s:Tlist_Menu_Remove_File()
- augroup end
-
- call s:Tlist_Menu_Update_File(0)
-endfunction
-
-" Tlist_Vim_Session_Load
-" Initialize the taglist window/buffer, which is created when loading
-" a Vim session file.
-function! s:Tlist_Vim_Session_Load()
- call s:Tlist_Log_Msg('Tlist_Vim_Session_Load')
-
- " Initialize the taglist window
- call s:Tlist_Window_Init()
-
- " Refresh the taglist window
- call s:Tlist_Window_Refresh()
-endfunction
-
-" Tlist_Set_App
-" Set the name of the external plugin/application to which taglist
-" belongs.
-" Taglist plugin is part of another plugin like cream or winmanager.
-function! Tlist_Set_App(name)
- if a:name == ""
- return
- endif
-
- let s:tlist_app_name = a:name
-endfunction
-
-" Winmanager integration
-
-" Initialization required for integration with winmanager
-function! TagList_Start()
- " If current buffer is not taglist buffer, then don't proceed
- if bufname('%') != '__Tag_List__'
- return
- endif
-
- call Tlist_Set_App('winmanager')
-
- " Get the current filename from the winmanager plugin
- let bufnum = WinManagerGetLastEditedFile()
- if bufnum != -1
- let filename = fnamemodify(bufname(bufnum), ':p')
- let ftype = s:Tlist_Get_Buffer_Filetype(bufnum)
- endif
-
- " Initialize the taglist window, if it is not already initialized
- if !exists('s:tlist_window_initialized') || !s:tlist_window_initialized
- call s:Tlist_Window_Init()
- call s:Tlist_Window_Refresh()
- let s:tlist_window_initialized = 1
- endif
-
- " Update the taglist window
- if bufnum != -1
- if !s:Tlist_Skip_File(filename, ftype) && g:Tlist_Auto_Update
- call s:Tlist_Window_Refresh_File(filename, ftype)
- endif
- endif
-endfunction
-
-function! TagList_IsValid()
- return 0
-endfunction
-
-function! TagList_WrapUp()
- return 0
-endfunction
-
-" restore 'cpo'
-let &cpo = s:cpo_save
-unlet s:cpo_save
-
v.licheni.net / stack / conf / vim.git / blobdiff