summaryrefslogtreecommitdiffstats
path: root/vim
diff options
context:
space:
mode:
authorJesse Luehrs <doy@tozt.net>2010-01-16 00:45:13 -0600
committerJesse Luehrs <doy@tozt.net>2010-01-16 00:45:13 -0600
commit0e61767e9563d1525d0a75d49a90a9b0e1d6f7f8 (patch)
tree8020880f2c880a0d73a71083a470f02b09df7c30 /vim
parentee5352fe877c07eadd14f5f55765c59d17853e43 (diff)
downloadconf-0e61767e9563d1525d0a75d49a90a9b0e1d6f7f8.tar.gz
conf-0e61767e9563d1525d0a75d49a90a9b0e1d6f7f8.zip
remove unused vim plugins
Diffstat (limited to 'vim')
-rw-r--r--vim/doc/NERD_tree.txt1329
-rw-r--r--vim/doc/fugitive.txt190
-rw-r--r--vim/doc/surround.txt218
-rw-r--r--vim/doc/taglist.txt1501
-rw-r--r--vim/doc/tags186
-rw-r--r--vim/plugin/NERD_tree.vim3733
-rw-r--r--vim/plugin/fugitive.vim1351
-rw-r--r--vim/plugin/surround.vim628
-rw-r--r--vim/plugin/taglist.vim4546
9 files changed, 0 insertions, 13682 deletions
diff --git a/vim/doc/NERD_tree.txt b/vim/doc/NERD_tree.txt
deleted file mode 100644
index bc07ae4..0000000
--- a/vim/doc/NERD_tree.txt
+++ /dev/null
@@ -1,1329 +0,0 @@
-*NERD_tree.txt* A tree explorer plugin that owns your momma!
-
-
-
- omg its ... ~
-
- ________ ________ _ ____________ ____ __________ ____________~
- /_ __/ / / / ____/ / | / / ____/ __ \/ __ \ /_ __/ __ \/ ____/ ____/~
- / / / /_/ / __/ / |/ / __/ / /_/ / / / / / / / /_/ / __/ / __/ ~
- / / / __ / /___ / /| / /___/ _, _/ /_/ / / / / _, _/ /___/ /___ ~
- /_/ /_/ /_/_____/ /_/ |_/_____/_/ |_/_____/ /_/ /_/ |_/_____/_____/ ~
-
-
- Reference Manual~
-
-
-
-
-==============================================================================
-CONTENTS *NERDTree-contents*
-
- 1.Intro...................................|NERDTree|
- 2.Functionality provided..................|NERDTreeFunctionality|
- 2.1 Global commands...................|NERDTreeGlobalCommands|
- 2.2 Bookmarks.........................|NERDTreeBookmarks|
- 2.2.1 The bookmark table..........|NERDTreeBookmarkTable|
- 2.2.2 Bookmark commands...........|NERDTreeBookmarkCommands|
- 2.2.3 Invalid bookmarks...........|NERDTreeInvalidBookmarks|
- 2.3 NERD tree mappings................|NERDTreeMappings|
- 2.4 The filesystem menu...............|NERDTreeFilesysMenu|
- 3.Options.................................|NERDTreeOptions|
- 3.1 Option summary....................|NERDTreeOptionSummary|
- 3.2 Option details....................|NERDTreeOptionDetails|
- 4.Hacking the NERD tree...................|NERDTreeHacking|
- 5.TODO list...............................|NERDTreeTodo|
- 6.The Author..............................|NERDTreeAuthor|
- 7.Changelog...............................|NERDTreeChangelog|
- 8.Credits.................................|NERDTreeCredits|
- 9.License.................................|NERDTreeLicense|
-
-==============================================================================
-1. Intro *NERDTree*
-
-What is this "NERD tree"??
-
-The NERD tree allows you to explore your filesystem and to open files and
-directories. It presents the filesystem to you in the form of a tree which you
-manipulate with the keyboard and/or mouse. It also allows you to perform
-simple filesystem operations.
-
-The following features and functionality are provided by the NERD tree:
- * Files and directories are displayed in a hierarchical tree structure
- * Different highlighting is provided for the following types of nodes:
- * files
- * directories
- * sym-links
- * windows .lnk files
- * read-only files
- * executable files
- * Many (customisable) mappings are provided to manipulate the tree:
- * Mappings to open/close/explore directory nodes
- * Mappings to open files in new/existing windows/tabs
- * Mappings to change the current root of the tree
- * Mappings to navigate around the tree
- * ...
- * Directories and files can be bookmarked.
- * Most NERD tree navigation can also be done with the mouse
- * Filtering of tree content (can be toggled at runtime)
- * custom file filters to prevent e.g. vim backup files being displayed
- * optional displaying of hidden files (. files)
- * files can be "turned off" so that only directories are displayed
- * A textual filesystem menu is provided which allows you to
- create/delete/move file and directory nodes as well as copy (for
- supported OSs)
- * The position and size of the NERD tree window can be customised
- * The order in which the nodes in the tree are listed can be customised.
- * A model of your filesystem is created/maintained as you explore it. This
- has several advantages:
- * All filesystem information is cached and is only re-read on demand
- * If you revisit a part of the tree that you left earlier in your
- session, the directory nodes will be opened/closed as you left them
- * The script remembers the cursor position and window position in the NERD
- tree so you can toggle it off (or just close the tree window) and then
- reopen it (with NERDTreeToggle) the NERD tree window will appear exactly
- as you left it
- * You can have a separate NERD tree for each tab, share trees across tabs,
- or a mix of both.
- * By default the script overrides the default file browser (netw), so if
- you :edit a directory a (slighly modified) NERD tree will appear in the
- current window
-
-==============================================================================
-2. Functionality provided *NERDTreeFunctionality*
-
-------------------------------------------------------------------------------
-2.1. Global Commands *NERDTreeGlobalCommands*
-
-:NERDTree [<start-directory> | <bookmark>] *:NERDTree*
- Opens a fresh NERD tree. The root of the tree depends on the argument
- given. There are 3 cases: If no argument is given, the current directory
- will be used. If a directory is given, that will be used. If a bookmark
- name is given, the corresponding directory will be used. For example: >
- :NERDTree /home/marty/vim7/src
- :NERDTree foo (foo is the name of a bookmark)
-<
-:NERDTreeFromBookmark <bookmark> *:NERDTreeFromBookmark*
- Opens a fresh NERD tree with the root initialized to the dir for
- <bookmark>. This only reason to use this command over :NERDTree is for
- the completion (which is for bookmarks rather than directories).
-
-:NERDTreeToggle [<start-directory> | <bookmark>] *:NERDTreeToggle*
- If a NERD tree already exists for this tab, it is reopened and rendered
- again. If no NERD tree exists for this tab then this command acts the
- same as the |:NERDTree| command.
-
-:NERDTreeMirror *:NERDTreeMirror*
- Shares an existing NERD tree, from another tab, in the current tab.
- Changes made to one tree are reflected in both as they are actually the
- same buffer.
-
- If only one other NERD tree exists, that tree is automatically mirrored. If
- more than one exists, the script will ask which tree to mirror.
-
-:NERDTreeClose *:NERDTreeClose*
- Close the NERD tree in this tab.
-
-------------------------------------------------------------------------------
-2.2. Bookmarks *NERDTreeBookmarks*
-
-Bookmarks in the NERD tree are a way to tag files or directories of interest.
-For example, you could use bookmarks to tag all of your project directories.
-
-------------------------------------------------------------------------------
-2.2.1. The Bookmark Table *NERDTreeBookmarkTable*
-
-If the bookmark table is active (see |NERDTree-B| and
-|'NERDTreeShowBookmarks'|), it will be rendered above the tree. You can double
-click bookmarks or use the |NERDTree-o| mapping to activate them. See also,
-|NERDTree-t| and |NERDTree-T|
-
-------------------------------------------------------------------------------
-2.2.2. Bookmark commands *NERDTreeBookmarkCommands*
-
-Note that the following commands are only available in the NERD tree buffer.
-
-:Bookmark <name>
- Bookmark the current node as <name>. If there is already a <name>
- bookmark, it is overwritten. <name> must not contain spaces.
-
-:BookmarkToRoot <bookmark>
- Make the directory corresponding to <bookmark> the new root. If a treenode
- corresponding to <bookmark> is already cached somewhere in the tree then
- the current tree will be used, otherwise a fresh tree will be opened.
- Note that if <bookmark> points to a file then its parent will be used
- instead.
-
-:RevealBookmark <bookmark>
- If the node is cached under the current root then it will be revealed
- (i.e. directory nodes above it will be opened) and the cursor will be
- placed on it.
-
-:OpenBookmark <bookmark>
- <bookmark> must point to a file. The file is opened as though |NERDTree-o|
- was applied. If the node is cached under the current root then it will be
- revealed and the cursor will be placed on it.
-
-:ClearBookmarks [<bookmarks>]
- Remove all the given bookmarks. If no bookmarks are given then remove all
- bookmarks on the current node.
-
-:ClearAllBookmarks
- Remove all bookmarks.
-
-:ReadBookmarks
- Re-read the bookmarks in the |'NERDTreeBookmarksFile'|.
-
-See also |:NERDTree| and |:NERDTreeFromBookmark|.
-
-------------------------------------------------------------------------------
-2.2.3. Invalid Bookmarks *NERDTreeInvalidBookmarks*
-
-If invalid bookmarks are detected, the script will issue an error message and
-the invalid bookmarks will become unavailable for use.
-
-These bookmarks will still be stored in the bookmarks file (see
-|'NERDTreeBookmarksFile'|), down the bottom. There will always be a blank line
-after the valid bookmarks but before the invalid ones.
-
-Each line in the bookmarks file represents one bookmark. The proper format is:
-<bookmark name><space><full path to the bookmark location>
-
-After you have corrected any invalid bookmarks, either restart vim, or go
-:ReadBookmarks from the NERD tree window.
-
-------------------------------------------------------------------------------
-2.3. NERD tree Mappings *NERDTreeMappings*
-
-Default Description~ help-tag~
-Key~
-
-o.......Open files, directories and bookmarks....................|NERDTree-o|
-go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go|
-t.......Open selected node/bookmark in a new tab.................|NERDTree-t|
-T.......Same as 't' but keep the focus on the current tab........|NERDTree-T|
-i.......Open selected file in a split window.....................|NERDTree-i|
-gi......Same as i, but leave the cursor on the NERDTree..........|NERDTree-i|
-!.......Execute the current file.................................|NERDTree-!|
-O.......Recursively open the selected directory..................|NERDTree-O|
-x.......Close the current nodes parent...........................|NERDTree-x|
-X.......Recursively close all children of the current node.......|NERDTree-X|
-e.......Edit the current dif.....................................|NERDTree-e|
-
-double-click.......same as the |NERDTree-o| map.
-middle-click.......same as |NERDTree-i| for files, same as
- |NERDTree-e| for dirs.
-
-D.......Delete the current bookmark .............................|NERDTree-D|
-
-P.......Jump to the root node....................................|NERDTree-P|
-p.......Jump to current nodes parent.............................|NERDTree-p|
-K.......Jump up inside directories at the current tree depth.....|NERDTree-K|
-J.......Jump down inside directories at the current tree depth...|NERDTree-J|
-<C-j>...Jump down to the next sibling of the current directory...|NERDTree-c-j|
-<C-k>...Jump up to the previous sibling of the current directory.|NERDTree-c-k|
-
-C.......Change the tree root to the selected dir.................|NERDTree-C|
-u.......Move the tree root up one directory......................|NERDTree-u|
-U.......Same as 'u' except the old root node is left open........|NERDTree-U|
-r.......Recursively refresh the current directory................|NERDTree-r|
-R.......Recursively refresh the current root.....................|NERDTree-R|
-m.......Display the filesystem menu..............................|NERDTree-m|
-cd......Change the CWD to the dir of the selected node...........|NERDTree-cd|
-
-I.......Toggle whether hidden files displayed....................|NERDTree-I|
-f.......Toggle whether the file filters are used.................|NERDTree-f|
-F.......Toggle whether files are displayed.......................|NERDTree-F|
-B.......Toggle whether the bookmark table is displayed...........|NERDTree-B|
-
-q.......Close the NERDTree window................................|NERDTree-q|
-?.......Toggle the display of the quick help.....................|NERDTree-?|
-
-------------------------------------------------------------------------------
- *NERDTree-o*
-Default key: o
-Map option: NERDTreeMapActivateNode
-Applies to: files and directories.
-
-If a file node is selected, it is opened in the previous window.
-
-If a directory is selected it is opened or closed depending on its current
-state.
-
-If a bookmark that links to a directory is selected then that directory
-becomes the new root.
-
-If a bookmark that links to a file is selected then that file is opened in the
-previous window.
-
-------------------------------------------------------------------------------
- *NERDTree-go*
-Default key: go
-Map option: None
-Applies to: files.
-
-If a file node is selected, it is opened in the previous window, but the
-cursor does not move.
-
-The key combo for this mapping is always "g" + NERDTreeMapActivateNode (see
-|NERDTree-o|).
-
-------------------------------------------------------------------------------
- *NERDTree-t*
-Default key: t
-Map option: NERDTreeMapOpenInTab
-Applies to: files and directories.
-
-Opens the selected file in a new tab. If a directory is selected, a fresh
-NERD Tree for that directory is opened in a new tab.
-
-If a bookmark which points to a directory is selected, open a NERD tree for
-that directory in a new tab. If the bookmark points to a file, open that file
-in a new tab.
-
-------------------------------------------------------------------------------
- *NERDTree-T*
-Default key: T
-Map option: NERDTreeMapOpenInTabSilent
-Applies to: files and directories.
-
-The same as |NERDTree-t| except that the focus is kept in the current tab.
-
-------------------------------------------------------------------------------
- *NERDTree-i*
-Default key: i
-Map option: NERDTreeMapOpenSplit
-Applies to: files.
-
-Opens the selected file in a new split window and puts the cursor in the new
-window.
-
-------------------------------------------------------------------------------
- *NERDTree-gi*
-Default key: gi
-Map option: None
-Applies to: files.
-
-The same as |NERDTree-i| except that the cursor is not moved.
-
-The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see
-|NERDTree-i|).
-
-------------------------------------------------------------------------------
- *NERDTree-!*
-Default key: !
-Map option: NERDTreeMapExecute
-Applies to: files.
-
-Executes the selected file, prompting for arguments first.
-
-------------------------------------------------------------------------------
- *NERDTree-O*
-Default key: O
-Map option: NERDTreeMapOpenRecursively
-Applies to: directories.
-
-Recursively opens the selelected directory.
-
-All files and directories are cached, but if a directory would not be
-displayed due to file filters (see |'NERDTreeIgnore'| |NERDTree-f|) or the
-hidden file filter (see |'NERDTreeShowHidden'|) then its contents are not
-cached. This is handy, especially if you have .svn directories.
-
-------------------------------------------------------------------------------
- *NERDTree-x*
-Default key: x
-Map option: NERDTreeMapCloseDir
-Applies to: files and directories.
-
-Closes the parent of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-X*
-Default key: X
-Map option: NERDTreeMapCloseChildren
-Applies to: directories.
-
-Recursively closes all children of the selected directory.
-
-Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping.
-
-------------------------------------------------------------------------------
- *NERDTree-e*
-Default key: e
-Map option: NERDTreeMapOpenExpl
-Applies to: files and directories.
-
-|:edit|s the selected directory, or the selected file's directory. This could
-result in a NERD tree or a netrw being opened, depending on
-|'NERDTreeHijackNetrw'|.
-
-------------------------------------------------------------------------------
- *NERDTree-D*
-Default key: D
-Map option: NERDTreeMapDeleteBookmark
-Applies to: lines in the bookmarks table
-
-Deletes the currently selected bookmark.
-
-------------------------------------------------------------------------------
- *NERDTree-P*
-Default key: P
-Map option: NERDTreeMapJumpRoot
-Applies to: no restrictions.
-
-Jump to the tree root.
-
-------------------------------------------------------------------------------
- *NERDTree-p*
-Default key: p
-Map option: NERDTreeMapJumpParent
-Applies to: files and directories.
-
-Jump to the parent node of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-K*
-Default key: K
-Map option: NERDTreeMapJumpFirstChild
-Applies to: files and directories.
-
-Jump to the first child of the current nodes parent.
-
-If the cursor is already on the first node then do the following:
- * loop back thru the siblings of the current nodes parent until we find an
- open dir with children
- * go to the first child of that node
-
-------------------------------------------------------------------------------
- *NERDTree-J*
-Default key: J
-Map option: NERDTreeMapJumpLastChild
-Applies to: files and directories.
-
-Jump to the last child of the current nodes parent.
-
-If the cursor is already on the last node then do the following:
- * loop forward thru the siblings of the current nodes parent until we find
- an open dir with children
- * go to the last child of that node
-
-------------------------------------------------------------------------------
- *NERDTree-c-j*
-Default key: <C-j>
-Map option: NERDTreeMapJumpNextSibling
-Applies to: files and directories.
-
-Jump to the next sibling of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-c-k*
-Default key: <C-k>
-Map option: NERDTreeMapJumpPrevSibling
-Applies to: files and directories.
-
-Jump to the previous sibling of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-C*
-Default key: C
-Map option: NERDTreeMapChdir
-Applies to: directories.
-
-Make the selected directory node the new tree root. If a file is selected, its
-parent is used.
-
-------------------------------------------------------------------------------
- *NERDTree-u*
-Default key: u
-Map option: NERDTreeMapUpdir
-Applies to: no restrictions.
-
-Move the tree root up a dir (like doing a "cd ..").
-
-------------------------------------------------------------------------------
- *NERDTree-U*
-Default key: U
-Map option: NERDTreeMapUpdirKeepOpen
-Applies to: no restrictions.
-
-Like |NERDTree-u| except that the old tree root is kept open.
-
-------------------------------------------------------------------------------
- *NERDTree-r*
-Default key: r
-Map option: NERDTreeMapRefresh
-Applies to: files and directories.
-
-If a dir is selected, recursively refresh that dir, i.e. scan the filesystem
-for changes and represent them in the tree.
-
-If a file node is selected then the above is done on it's parent.
-
-------------------------------------------------------------------------------
- *NERDTree-R*
-Default key: R
-Map option: NERDTreeMapRefreshRoot
-Applies to: no restrictions.
-
-Recursively refresh the tree root.
-
-------------------------------------------------------------------------------
- *NERDTree-m*
-Default key: m
-Map option: NERDTreeMapFilesystemMenu
-Applies to: files and directories.
-
-Display the filesystem menu. See |NERDTreeFilesysMenu| for details.
-
-------------------------------------------------------------------------------
- *NERDTree-I*
-Default key: I
-Map option: NERDTreeMapToggleHidden
-Applies to: no restrictions.
-
-Toggles whether hidden files (i.e. "dot files") are displayed.
-
-------------------------------------------------------------------------------
- *NERDTree-f*
-Default key: f
-Map option: NERDTreeMapToggleFilters
-Applies to: no restrictions.
-
-Toggles whether file filters are used. See |'NERDTreeIgnore'| for details.
-
-------------------------------------------------------------------------------
- *NERDTree-F*
-Default key: F
-Map option: NERDTreeMapToggleFiles
-Applies to: no restrictions.
-
-Toggles whether file nodes are displayed.
-
-------------------------------------------------------------------------------
- *NERDTree-B*
-Default key: B
-Map option: NERDTreeMapToggleBookmarks
-Applies to: no restrictions.
-
-Toggles whether the bookmarks table is displayed.
-
-------------------------------------------------------------------------------
- *NERDTree-q*
-Default key: q
-Map option: NERDTreeMapQuit
-Applies to: no restrictions.
-
-Closes the NERDtree window.
-
-------------------------------------------------------------------------------
- *NERDTree-?*
-Default key: ?
-Map option: NERDTreeMapHelp
-Applies to: no restrictions.
-
-Toggles whether the quickhelp is displayed.
-
-------------------------------------------------------------------------------
-2.3. The filesystem menu *NERDTreeFilesysMenu*
-
-The purpose of the filesystem menu is to allow you to perform basic filesystem
-operations quickly from the NERD tree rather than the console.
-
-The filesystem menu can be accessed with 'm' mapping and has four supported
-operations: >
- 1. Adding nodes.
- 2. Move nodes.
- 3. Deleting nodes.
- 3. Copying nodes.
-<
-1. Adding nodes:
-To add a node move the cursor onto (or anywhere inside) the directory you wish
-to create the new node inside. Select the 'add node' option from the
-filesystem menu and type a filename. If the filename you type ends with a '/'
-character then a directory will be created. Once the operation is completed,
-the cursor is placed on the new node.
-
-2. Move nodes:
-To move/rename a node, put the cursor on it and select the 'move' option from
-the filesystem menu. Enter the new location for the node and it will be
-moved. If the old file is open in a buffer, you will be asked if you wish to
-delete that buffer. Once the operation is complete the cursor will be placed
-on the renamed node.
-
-3. Deleting nodes:
-To delete a node put the cursor on it and select the 'delete' option from the
-filesystem menu. After confirmation the node will be deleted. If a file is
-deleted but still exists as a buffer you will be given the option to delete
-that buffer.
-
-4. Copying nodes:
-To copy a node put the cursor on it and select the 'copy' option from the
-filesystem menu. Enter the new location and you're done. Note: copying is
-currently only supported for *nix operating systems. If someone knows a
-one line copying command for windows that doesnt require user confirmation
-then id be grateful if you'd email me.
-
-==============================================================================
-3. Customisation *NERDTreeOptions*
-
-
-------------------------------------------------------------------------------
-3.1. Customisation summary *NERDTreeOptionSummary*
-
-The script provides the following options that can customise the behaviour the
-NERD tree. These options should be set in your vimrc.
-
-|'loaded_nerd_tree'| Turns off the script.
-
-|'NERDChristmasTree'| Tells the NERD tree to make itself colourful
- and pretty.
-
-|'NERDTreeAutoCenter'| Controls whether the NERD tree window centers
- when the cursor moves within a specified
- distance to the top/bottom of the window.
-|'NERDTreeAutoCenterThreshold'| Controls the sensitivity of autocentering.
-
-|'NERDTreeCaseSensitiveSort'| Tells the NERD tree whether to be case
- sensitive or not when sorting nodes.
-
-|'NERDTreeChDirMode'| Tells the NERD tree if/when it should change
- vim's current working directory.
-
-|'NERDTreeHighlightCursorline'| Tell the NERD tree whether to highlight the
- current cursor line.
-
-|'NERDTreeHijackNetrw'| Tell the NERD tree whether to replace the netrw
- autocommands for exploring local directories.
-
-|'NERDTreeIgnore'| Tells the NERD tree which files to ignore.
-
-|'NERDTreeBookmarksFile'| Where the bookmarks are stored.
-
-|'NERDTreeMouseMode'| Tells the NERD tree how to handle mouse
- clicks.
-
-|'NERDTreeQuitOnOpen'| Closes the tree window after opening a file.
-
-|'NERDTreeShowBookmarks'| Tells the NERD tree whether to display the
- bookmarks table on startup.
-
-|'NERDTreeShowFiles'| Tells the NERD tree whether to display files
- in the tree on startup.
-
-|'NERDTreeShowHidden'| Tells the NERD tree whether to display hidden
- files on startup.
-
-|'NERDTreeShowLineNumbers'| Tells the NERD tree whether to display line
- numbers in the tree window.
-
-|'NERDTreeSortOrder'| Tell the NERD tree how to sort the nodes in
- the tree.
-
-|'NERDTreeWinPos'| Tells the script where to put the NERD tree
- window.
-
-|'NERDTreeWinSize'| Sets the window size when the NERD tree is
- opened.
-
-------------------------------------------------------------------------------
-3.2. Customisation details *NERDTreeOptionDetails*
-
-To enable any of the below options you should put the given line in your
-~/.vimrc
-
- *'loaded_nerd_tree'*
-If this plugin is making you feel homicidal, it may be a good idea to turn it
-off with this line in your vimrc: >
- let loaded_nerd_tree=1
-<
-------------------------------------------------------------------------------
- *'NERDChristmasTree'*
-Values: 0 or 1.
-Default: 1.
-
-If this option is set to 1 then some extra syntax highlighting elements are
-added to the nerd tree to make it more colourful.
-
-Set it to 0 for a more vanilla looking tree.
-
-------------------------------------------------------------------------------
- *'NERDTreeAutoCenter'*
-Values: 0 or 1.
-Default: 1
-
-If set to 1, the NERD tree window will center around the cursor if it moves to
-within |'NERDTreeAutoCenterThreshold'| lines of the top/bottom of the window.
-
-This is ONLY done in response to tree navigation mappings,
-i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-c-K| |NERDTree-p|
-|NERDTree-P|
-
-The centering is done with a |zz| operation.
-
-------------------------------------------------------------------------------
- *'NERDTreeAutoCenterThreshold'*
-Values: Any natural number.
-Default: 3
-
-This option controls the "sensitivity" of the NERD tree auto centering. See
-|'NERDTreeAutoCenter'| for details.
-
-------------------------------------------------------------------------------
- *'NERDTreeCaseSensitiveSort'*
-Values: 0 or 1.
-Default: 0.
-
-By default the NERD tree does not sort nodes case sensitively, i.e. nodes
-could appear like this: >
- bar.c
- Baz.c
- blarg.c
- boner.c
- Foo.c
-<
-But, if you set this option to 1 then the case of the nodes will be taken into
-account. The above nodes would then be sorted like this: >
- Baz.c
- Foo.c
- bar.c
- blarg.c
- boner.c
-<
-------------------------------------------------------------------------------
- *'NERDTreeChDirMode'*
-
-Values: 0, 1 or 2.
-Default: 0.
-
-Use this option to tell the script when (if at all) to change the current
-working directory (CWD) for vim.
-
-If it is set to 0 then the CWD is never changed by the NERD tree.
-
-If set to 1 then the CWD is changed when the NERD tree is first loaded to the
-directory it is initialized in. For example, if you start the NERD tree with >
- :NERDTree /home/marty/foobar
-<
-then the CWD will be changed to /home/marty/foobar and will not be changed
-again unless you init another NERD tree with a similar command.
-
-If the option is set to 2 then it behaves the same as if set to 1 except that
-the CWD is changed whenever the tree root is changed. For example, if the CWD
-is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new
-root then the CWD will become /home/marty/foobar/baz.
-
-------------------------------------------------------------------------------
- *'NERDTreeHighlightCursorline'*
-Values: 0 or 1.
-Default: 1.
-
-If set to 1, the current cursor line in the NERD tree buffer will be
-highlighted. This is done using the |cursorline| option.
-
-------------------------------------------------------------------------------
- *'NERDTreeHijackNetrw'*
-Values: 0 or 1.
-Default: 1.
-
-If set to 1, doing a >
- :edit <some directory>
-<
-will open up a "secondary" NERD tree instead of a netrw in the target window.
-
-Secondary NERD trees behaves slighly different from a regular trees in the
-following respects:
- 1. 'o' will open the selected file in the same window as the tree,
- replacing it.
- 2. you can have as many secondary tree as you want in the same tab.
-
-------------------------------------------------------------------------------
- *'NERDTreeIgnore'*
-Values: a list of regular expressions.
-Default: ['\~$'].
-
-This option is used to specify which files the NERD tree should ignore. It
-must be a list of regular expressions. When the NERD tree is rendered, any
-files/dirs that match any of the regex's in 'NERDTreeIgnore' wont be
-displayed.
-
-For example if you put the following line in your vimrc: >
- let NERDTreeIgnore=['\.vim$', '\~$']
-<
-then all files ending in .vim or ~ will be ignored.
-
-Note: to tell the NERD tree not to ignore any files you must use the following
-line: >
- let NERDTreeIgnore=[]
-<
-
-The file filters can be turned on and off dynamically with the |NERDTree-f|
-mapping.
-
-------------------------------------------------------------------------------
- *'NERDTreeBookmarksFile'*
-Values: a path
-Default: $HOME/.NERDTreeBookmarks
-
-This is where bookmarks are saved. See |NERDTreeBookmarkCommands|.
-
-------------------------------------------------------------------------------
- *'NERDTreeMouseMode'*
-Values: 1, 2 or 3.
-Default: 1.
-
-If set to 1 then a double click on a node is required to open it.
-If set to 2 then a single click will open directory nodes, while a double
-click will still be required for file nodes.
-If set to 3 then a single click will open any node.
-
-Note: a double click anywhere on a line that a tree node is on will
-activate it, but all single-click activations must be done on name of the node
-itself. For example, if you have the following node: >
- | | |-application.rb
-<
-then (to single click activate it) you must click somewhere in
-'application.rb'.
-
-------------------------------------------------------------------------------
- *'NERDTreeQuitOnOpen'*
-
-Values: 0 or 1.
-Default: 0
-
-If set to 1, the NERD tree window will close after opening a file with the
-|NERDTree-o| or |NERDTree-i| mappings.
-
-------------------------------------------------------------------------------
- *'NERDTreeShowBookmarks'*
-Values: 0 or 1.
-Default: 0.
-
-If this option is set to 1 then the bookmarks table will be displayed.
-
-This option can be toggled dynamically, per tree, with the |NERDTree-B|
-mapping.
-
-------------------------------------------------------------------------------
- *'NERDTreeShowFiles'*
-Values: 0 or 1.
-Default: 1.
-
-If this option is set to 1 then files are displayed in the NERD tree. If it is
-set to 0 then only directories are displayed.
-
-This option can be toggled dynamically, per tree, with the |NERDTree-F|
-mapping and is useful for drastically shrinking the tree when you are
-navigating to a different part of the tree.
-
-------------------------------------------------------------------------------
- *'NERDTreeShowHidden'*
-Values: 0 or 1.
-Default: 0.
-
-This option tells vim whether to display hidden files by default. This option
-can be dynamically toggled, per tree, with the |NERDTree-I| mapping. Use one
-of the follow lines to set this option: >
- let NERDTreeShowHidden=0
- let NERDTreeShowHidden=1
-<
-
-------------------------------------------------------------------------------
- *'NERDTreeShowLineNumbers'*
-Values: 0 or 1.
-Default: 0.
-
-This option tells vim whether to display line numbers for the NERD tree
-window. Use one of the follow lines to set this option: >
- let NERDTreeShowLineNumbers=0
- let NERDTreeShowLineNumbers=1
-<
-
-------------------------------------------------------------------------------
- *'NERDTreeSortOrder'*
-Values: a list of regular expressions.
-Default: ['\/$', '*', '\.swp$', '\.bak$', '\~$']
-
-This option is set to a list of regular expressions which are used to
-specify the order of nodes under their parent.
-
-For example, if the option is set to: >
- ['\.vim$', '\.c$', '\.h$', '*', 'foobar']
-<
-then all .vim files will be placed at the top, followed by all .c files then
-all .h files. All files containing the string 'foobar' will be placed at the
-end. The star is a special flag: it tells the script that every node that
-doesnt match any of the other regexps should be placed here.
-
-If no star is present in 'NERDTreeSortOrder' then one is automatically
-appended to the array.
-
-The regex '\/$' should be used to match directory nodes.
-
-After this sorting is done, the files in each group are sorted alphabetically.
-
-Other examples: >
- (1) ['*', '\/$']
- (2) []
- (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$', '\.bak$', '\~$']
-<
-1. Directories will appear last, everything else will appear above.
-2. Everything will simply appear in alphabetical order.
-3. Dirs will appear first, then ruby and php. Swap files, bak files and vim
- backup files will appear last with everything else preceding them.
-
-------------------------------------------------------------------------------
- *'NERDTreeWinPos'*
-Values: "left" or "right"
-Default: "left".
-
-This option is used to determine where NERD tree window is placed on the
-screen.
-
-This option is makes it possible to use two different explorer type
-plugins simultaneously. For example, you could have the taglist plugin on the
-left of the window and the NERD tree on the right.
-
-------------------------------------------------------------------------------
- *'NERDTreeWinSize'*
-Values: a positive integer.
-Default: 31.
-
-This option is used to change the size of the NERD tree when it is loaded.
-
-==============================================================================
-4. Hacking the NERD tree *NERDTreeHacking*
-
-Public functions ~
-
-The script provides 2 public functions for your hacking pleasure. Their
-signatures are: >
- function! NERDTreeGetCurrentNode()
- function! NERDTreeGetCurrentPath()
-<
-The first returns the node object that the cursor is currently on, while the
-second returns the corresponding path object.
-
-This is probably a good time to mention that the script implements prototype
-style OO. To see the functions that each class provides you can read look at
-the code.
-
-Use the node objects to manipulate the structure of the tree. Use the path
-objects to access the files/directories the tree nodes represent.
-
-The NERD tree filetype ~
-
-NERD tree buffers have a filetype of "nerdtree". You can use this to hack the
-NERD tree via autocommands (on |FileType|) or via an ftplugin.
-
-For example, putting this code in ~/.vim/ftplugin/nerdtree.vim would override
-the o mapping, making it open the selected node in a new gvim instance. >
-
- nnoremap <silent> <buffer> o :call <sid>openInNewVimInstance()<cr>
- function! s:openInNewVimInstance()
- let p = NERDTreeGetCurrentPath()
- if p != {}
- silent exec "!gvim " . p.strForOS(1) . "&"
- endif
- endfunction
-<
-This way you can add new mappings or :commands or override any existing
-mapping.
-
-==============================================================================
-5. TODO list *NERDTreeTodo*
-
-Window manager integration?
-
-==============================================================================
-6. The Author *NERDTreeAuthor*
-
-The author of the NERD tree is a terrible terrible monster called Martyzilla
-who gobbles up small children with milk and sugar for breakfast.
-
-He can be reached at martin_grenfell at msn.com. He would love to hear from
-you, so feel free to send him suggestions and/or comments about this plugin.
-Don't be shy --- the worst he can do is slaughter you and stuff you in the
-fridge for later ;)
-
-==============================================================================
-7. Changelog *NERDTreeChangelog*
-
-3.0.0
- - hijack netrw so that doing an :edit <directory> will put a NERD tree in
- the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw'
- - allow sharing of trees across tabs, see :help :NERDTreeMirror
- - remove "top" and "bottom" as valid settings for NERDTreeWinPos
- - change the '<tab>' mapping to 'i'
- - change the 'H' mapping to 'I'
- - lots of refactoring
-
-2.14.3
- Thanks to tpope for the following:
- - use relative paths when doing edit commands if possible (useful if you
- have %f on your statusline for example)
- - allow relative paths for :NERDTree commands, eg ":NERDTree ../foo"
- - fix a bug where the script used the directory of the current buffer
- instead of vims cwd for the :NERDTree command
- - bugfix for read only node highlighting
-
-2.14.2
- - when opening a file (with 'o' or double click) dont split the window
- unless we absolutely have to. This should make the script work better
- with other explorer plugins. Thanks to Ryan Penn, Simon Peter Nicholls
- and Michael
- - fix a bug where directories starting with a '+' char could not be opened.
- Thanks to Tomasz Chomiuk.
- - fix a bug where closing vim with :qa with a tree open in another tab
- would break, thanks to Denis Pokataev.
- - compatibility bugfix for older versions of vim, thanks to knekk for
- helping me track it down and to Sean Chou.
-
-2.14.1
- - dont clobber &cpo. Thanks to godlygeek for the bug report.
-
-2.14.0
- - fix a bug where the <c-w>o mapping would cause the tree window to be
- incorrectly sized when reopened.
- - add keymapping to delete bookmarks from the bookmarks table, see
- :help NERDTree-D
- - lots of refactoring
-2.13.0
- - make NERDTreeChDir option default to 0 (i.e. never change vims current
- working dir by default)
- - when moving/deleting nodes with the filesystem menu, move/delete any
- associated bookmarks
- - make the t/T on directory nodes open a fresh NERD tree for the selected
- dir in a new tab, rather than a netrw.
- - place the cursor at the top of the bookmarks table when opening it with B
- - make NERDTreeQuitOnOpen option work with the g<tab> and go mappings,
- thanks to Maxim Kim for the bug report
- - change how invalid bookmarks are handled. Now they are not deleted. If a
- bookmark is malformed (in the bookmarks file) or points to an
- invalid/nonexisting location then print an error and place the offending
- bookmarks at the bottom of the bookmarks file. See :help
- |NERDTreeInvalidBookmarks| for info. Thanks to Zhang Shuhan for the
- suggestion and the testing.
- - fix a bug with the 'o' mapping that occurred when opening a new buffer
- for a file whose name was a substring of an already open file. Thanks to
- Charlton Wang for the report.
- - stop the script from going into an infinite loop when it tries to cache
- a named pipe. Thanks to Charlton Wang for the report.
-
-2.12.0
- - added a UI for bookmarks. See :help NERDTreeBookmarkTable for details.
- Thanks to Zhang Shuhan for testing and bug reports.
- - relaxed the restrictions on bookmark names, now the only restriction is
- that they cant contain spaces. This allows for e.g. Chinese bookmark
- names. Thanks to Zhang Shuhan for the suggestion.
- - combined the NERDTreeWinPos and NERDTreeSplitVertical options. See :help
- NERDTreeWinPos.
- - applied a patch from Matan Nassau to add the NERDTreeQuitOnOpen option
- which closes the tree window after opening a file. See :help
- NERDTreeQuitOnOpen.
- - optimised the nerd tree rendering. Now it takes just over 1/3 of the
- time it previously took to render.
- - now the tree filter mappings toggle the filters "per tree" rather than
- globally. The global filter variables are used to set the initial filter
- settings for each new NERD tree.
- - fix to window resizing when opening a file when NERD tree is the only
- window open
- - other fixes
-
-2.11.0
- - changes to the 'o' mapping when opening files:
- - dont clobber "special" windows (eg taglist/quickfix/etc). This should
- make the NERD tree play nicer with other explorer plugins. Thanks to
- Yuan Jiang for the suggestion.
- - if the file is already open in the current tab, just move the cursor
- to that window
- - highlight executable files, made some slight changes to other
- highlighting
- - if the user resizes the tree window, keep that new size. Dont reset to
- the default during the <tab> mapping, or :NERDTreeToggle command. Only
- reset the size if a fresh tree is started with :NERDTree.
- - remove the "magic" functionality from the <c-j>/<c-k> mappings (it was
- more confusing than helpful)
- - other minor fixes
-
-2.10.0
- - added bookmarks, see :help NERDTreeBookmarkCommands for details. Thanks
- to Piotr Czachur for all his testing and suggestions.
- - fixed screen jumping bug with when &scrolloff != 0
- - fixed some bugs with copying nodes
- - other random fixes
- - change license to wtfpl
-
-2.9.0
-
- - path handling improvements, thanks to Zhang Shuhan for heaps of
- testing/bug reports
- * improved how paths are stored, now the script will no longer get
- confused about drives on MF Windows
- * made the script way better at handling paths with strange characters
- in them (eg '$@; etc)
- - applied a patch from Cory Echols
- * add the command :NERDTreeClose to close the tree for the current tab
- * set the filetype for the NERD tree buffer to "nerdtree"
-
-2.8.0
- - added an option to enable/disable line numbers in the NERD tree window,
- thanks to Olivier Yiptong for the email.
-
-2.7.1
- - Changed the keys for the filesystem menu to be mnemonic rather than
- arbitrary integers
- - Documented the copying functionality in the filesystem menu
-
-2.7.0
- - Bug fix: Now when you have the tree on the right and you open it with
- multiple windows stacked, it will take up the full height of the vim
- window.
- - Now line numbers always turned off in the tree by default
- - Implemented copying of nodes (via the filesystem menu) for *nix/macosx
- - took the help doc out of the script and repackaged the whole thing as a
- zip
-
-2.6.2
- - Now when you try to open a file node into a window that is modified, the
- window is not split if the &hidden option is set. Thanks to Niels Aan
- de Brugh for this suggestion.
-
-2.6.1
- - Fixed a major bug with the <tab> mapping. Thanks to Zhang Weiwu for
- emailing me.
-
-2.6.0
- - Extended the behaviour of <c-j/k>. Now if the cursor is on a file node
- and you use <c-j/k> the cursor will jump to its PARENTS next/previous
- sibling. Go :help NERDTree-c-j and :help NERDTree-c-k for info.
- - Extended the behaviour of the J/K mappings. Now if the cursor is on the
- last child of a node and you push J/K it will jump down to the last
- child of the next/prev of its parents siblings that is open and has
- children. Go :help NERDTree-J and :help NERDTree-K for info.
- - The goal of these changes is to make tree navigation faster.
- - Reorganised the help page a bit.
- - Removed the E mapping.
- - bugfixes
-
-2.5.0
- - Added an option to enforce case sensitivity when sorting tree nodes.
- Read :help NERDTreeCaseSensitiveSort for details. (thanks to Michael
- Madsen for emailing me about this). Case sensitivity defaults to off.
- - Made the script echo a "please wait" style message when opening large
- directories. Thanks to AOYAMA Shotaro for this suggestion.
- - Added 2 public functions that can be used to retrieve the treenode and
- path that the cursor is on. Read :help NERDTreePublicFunctions for
- details (thanks again to AOYAMA Shotaro for the idea :).
- - added 2 new mappings for file nodes: "g<tab>" and "go". These are the
- same as the "<tab>" and "o" maps except that the cursor stays in the
- NERDTree. Note: these maps are slaved to the o and <tab> mappings, so if
- eg you remap "<tab>" to "i" then the "g<tab>" map will also be changed
- to "gi".
- - Renamed many of the help tags to be simpler.
- - Simplified the ascii "graphics" for the filesystem menu
- - Fixed bugs.
- - Probably created bugs.
- - Refactoring.
-
-2.4.0
- - Added the P mapping to jump to the tree root.
- - Added window centering functionality that can be triggered when doing
- using any of the tree nav mappings. Essentially, if the cursor comes
- within a certain distance of the top/bottom of the window then a zz is
- done in the window. Two related options were added: NERDTreeAutoCenter
- to turn this functionality on/off, and NERDTreeAutoCenterThreshold to
- control how close the cursor has to be to the window edge to trigger the
- centering.
-
-2.3.0
- - Tree navigation changes:
- - Added J and K mappings to jump to last/first child of the current dir.
- Options to customise these mappings have also been added.
- - Remapped the jump to next/prev sibling commands to be <C-j> and <C-k>
- by default.
- These changes should hopefully make tree navigation mappings easier to
- remember and use as the j and k keys are simply reused 3 times (twice
- with modifier keys).
-
- - Made it so that, when any of the tree filters are toggled, the cursor
- stays with the selected node (or goes to its parent/grandparent/... if
- that node is no longer visible)
- - Fixed an error in the doc for the mouse mode option.
- - Made the quickhelp correctly display the current single/double click
- mappings for opening nodes as specified by the NERDTreeMouseMode option.
- - Fixed a bug where the script was spazzing after prompting you to delete
- a modified buffer when using the filesystem menu.
- - Refactoring
-2.2.3
- - Refactored the :echo output from the script.
- - Fixed some minor typos in the doc.
- - Made some minor changes to the output of the 'Tree filtering mappings'
- part of the quickhelp
-
-2.2.2
- - More bugfixes... doh.
-
-2.2.1
- - Bug fix that was causing an exception when closing the nerd tree. Thanks
- to Tim carey-smith and Yu Jun for pointing this out.
-
-2.2.0
- - Now 'cursorline' is set in the NERD tree buffer by default. See :help
- NERDTreeHighlightCursorline for how to disable it.
-
-2.1.2
- - Stopped the script from clobbering the 1,2,3 .. 9 registers.
- - Made it "silent!"ly delete buffers when renaming/deleting file nodes.
- - Minor correction to the doc
- - Fixed a bug when refreshing that was occurring when the node you
- refreshed had been deleted externally.
- - Fixed a bug that was occurring when you open a file that is already open
- and modified.
-
-2.1.1
- - Added a bit more info about the buffers you are prompted to delete when
- renaming/deleting nodes from the filesystem menu that are already loaded
- into buffers.
- - Refactoring and bugfixes
-
-2.1.0
- - Finally removed the blank line that always appears at the top of the
- NERDTree buffer
- - Added NERDTreeMouseMode option. If set to 1, then a double click is
- required to activate all nodes, if set to 2 then a single click will
- activate directory nodes, if set to 3 then a single click will activate
- all nodes.
- - Now if you delete a file node and have it open in a buffer you are given
- the option to delete that buffer as well. Similarly if you rename a file
- you are given the option to delete any buffers containing the old file
- (if any exist)
- - When you rename or create a node, the cursor is now put on the new node,
- this makes it easy immediately edit the new file.
- - Fixed a bug with the ! mapping that was occurring on windows with paths
- containing spaces.
- - Made all the mappings customisable. See |NERD_tree-mappings| for
- details. A side effect is that a lot of the "double mappings" have
- disappeared. E.g 'o' is now the key that is used to activate a node,
- <CR> is no longer mapped to the same.
- - Made the script echo warnings in some places rather than standard echos
- - Insane amounts of refactoring all over the place.
-
-2.0.0
- - Added two new NERDChristmasTree decorations. First person to spot them
- and email me gets a free copy of the NERDTree.
- - Made it so that when you jump around the tree (with the p, s and S
- mappings) it is counted as a jump by vim. This means if you, eg, push
- 'p' one too many times then you can go `` or ctrl-o.
- - Added a new option called NERDTreeSortOrder which takes an array of
- regexs and is used to determine the order that the treenodes are listed
- in. Go :help NERDTreeSortOrder for details.
- - Removed the NERDTreeSortDirs option because it is consumed by
- NERDTreeSortOrder
- - Added the 'i' mapping which is the same as <tab> but requires less
- effort to reach.
- - Added the ! mapping which is used to execute file in the tree (after it
- prompts you for arguments etc)
-
-
-==============================================================================
-8. Credits *NERDTreeCredits*
-
-Thanks to Tim Carey-Smith for testing/using the NERD tree from the first
-pre-beta version, for his many suggestions and for his constant stream of bug
-complaints.
-
-Thanks to Vigil for trying it out before the first release :) and suggesting
-that mappings to open files in new tabs should be implemented.
-
-Thanks to Nick Brettell for testing, fixing my spelling and suggesting i put a
- .. (up a directory)
-line in the gui.
-
-Thanks to Thomas Scott Urban - the author of the vtreeexplorer plugin - whose
-gui code i borrowed from.
-
-Thanks to Terrance Cohen for pointing out a bug where the script was changing
-vims CWD all over the show.
-
-Thanks to Yegappan Lakshmanan (author of Taglist and other orgasmically
-wonderful plugins) for telling me how to fix a bug that was causing vim to go
-into visual mode everytime you double clicked a node :)
-
-Thanks to Jason Mills for sending me a fix that allows windows paths to use
-forward slashes as well as backward.
-
-Thanks to Michael Geddes (frogonwheels on #vim at freenode) for giving me some
-tips about syntax highlighting when i was doing highlighting for the
-quickhelp.
-
-Thanks to Yu Jun for emailing me about a bug that was occurring when closing
-the tree.
-
-Thanks to Michael Madsen for emailing me about making case sensitivity
-optional when sorting nodes.
-
-Thanks to AOYAMA Shotaro for suggesting that i echo a "please wait" message
-when opening large directories.
-
-Thanks to Michael Madsen for requesting the NERDTreeCaseSensitiveSort option.
-
-Thanks to AOYAMA Shotaro for suggesting that a "please wait" style message be
-echoed when opening large directories. Also, thanks for the suggestion of
-having public functions in the script to access the internal data :D
-
-Thanks to Zhang Weiwu for emailing me about a bug with the the <tab> mapping
-in 2.6.0
-
-Thanks to Niels Aan de Brugh for the suggestion that the script now split the
-window if you try to open a file in a window containing a modified buffer when
-the &hidden option is set.
-
-Thanks to Olivier Yiptong for prompting me to make line numbers in the
-NERD tree window optional.
-
-Thanks to Zhang Shuhan for all of his emails and testing to help improve the
-NERD tree path handling. Thanks also for suggesting the bookmarks gui, and for
-testing and his many suggestions and bugreports about bookmarks.
-
-Thanks to Cory Echols for sending a patch to add the :NERDTreeClose command and
-set the NERD tree buffers filetype to 'nerdtree'
-
-Thanks to Piotr Czachur for all his suggestions and testing for the bookmarks
-feature.
-
-Thanks to Yuan Jiang for suggesting the "o" mapping shouldnt clobber "special"
-windows, like taglist.
-
-Thanks to Matan Nassau for the patch to add the NERDTreeQuitOnOpen option.
-
-Thanks to Maxim Kim for reporting a bug with g<tab> and go mappings when
-NERDTreeQuitOnOpen was set.
-
-Thanks to Charlton Wang for reporting bugs with the 'o' mapping and with
-handling named pipes.
-
-Chur to godlygeek for reporting a bug where &cpo was getting clobbered.
-
-Cheers to knekk for helping me track down a bug when overwriting dictionary
-keys that only occurred in some versions of vim.
-
-Thanks also to Sean Chou for the bug report about the above bug.
-
-Thanks to Ryan Penn, Simon Peter Nicholls and Michael for pointing out an issue
-where the script was splitting constantly when using the 'o' mapping while
-other explorers were open.
-
-Thanks to Tomasz Chomiuk for the bug report about the script failing when dir
-names began with a +.
-
-Thanks to Denis Pokataev for the bug report about the script failing when
-closing vim with :qa with a tree open in another tab.
-
-Thanks to tpope for his dope bug reporting.
-
-==============================================================================
-9. License *NERDTreeLicense*
-
-The NERD tree is released under the wtfpl.
-See http://sam.zoy.org/wtfpl/COPYING.
diff --git a/vim/doc/fugitive.txt b/vim/doc/fugitive.txt
deleted file mode 100644
index 1e4d66c..0000000
--- a/vim/doc/fugitive.txt
+++ /dev/null
@@ -1,190 +0,0 @@
-*fugitive.txt* a Git wrapper so awesome, it should be illegal
-
-Author: Tim Pope <vimNOSPAM@tpope.info> *fugitive-author*
-License: Same terms as Vim itself (see |license|)
-
-This plugin is only available if 'compatible' is not set.
-
-==============================================================================
-INTRODUCTION *fugitive*
-
-Install in ~/.vim, or in ~\vimfiles if you're on Windows and feeling lucky.
-Vim 7.2 is recommended as it ships with syntax highlighting for many Git file
-types.
-
-If you're in a hurry to get started, here are some things to try:
-
-In any file in your repository, run |:Gedit| HEAD. Press <CR> to jump to the
-current branch. Press <CR> again to jump to the top most commit. Keep using
-<CR> to explore parent commits, trees, and blobs. Use C in a tree or blob to
-get back to the commit.
-
-Edit a file in the work tree and make some changes. Use |:Gdiff| to open up
-the indexed version. Use |do| and |dp| on various hunks to bring the files in
-sync, or use |:Gread!| to pull in all changes. Write the indexed version to
-stage the file.
-
-Run |:Gblame| in a work tree file to see a blame in a vertical split. Press
-<CR> on any line to reopen and reblame that file as it stood in that commit.
-Press o or O on any line to inspect that commit in a split or a tab.
-
-Run |:Ggrep| to search the work tree or history. Run |:Gmove| to rename a
-file. Run |:Gremove| to delete a file.
-
-==============================================================================
-COMMANDS *fugitive-commands*
-
-These commands are local to the buffers in which they work (generally, buffers
-that are part of Git repositories).
-
- *fugitive-:Git*
-:Git [args] Run an arbitrary git command. Similar to :!git [args]
- but chdir to the repository tree first.
-
- *fugitive-:Gcd*
-:Gcd [directory] |:cd| relative to the repository.
-
- *fugitive-:Glcd*
-:Glcd [directory] |:lcd| relative to the repository.
-
- *fugitive-:Gstatus*
-:Gstatus Bring up the output of git status in the preview
- window. Press - to stage or unstage the file on the
- cursor line.
-
- *fugitive-:Ggrep*
-:Ggrep [args] |:grep| with git-grep as 'grepprg'.
-
- *fugitive-:Glog*
-:Glog Load all commits that touched the current file into
- the quickfix list.
-
- *fugitive-:Gedit* *fugitive-:Ge*
-:Gedit [revision] |:edit| a |fugitive-revision|.
-
- *fugitive-:Gsplit*
-:Gsplit [revision] |:split| a |fugitive-revision|.
-
- *fugitive-:Gvsplit*
-:Gvsplit [revision] |:vsplit| a |fugitive-revision|.
-
- *fugitive-:Gtabedit*
-:Gtabedit [revision] |:tabedit| a |fugitive-revision|
-
- *fugitive-:Gpedit*
-:Gpedit [revision] |:pedit| a |fugitive-revision|
-
- *fugitive-:Gread*
-:Gread [revision] |:read| a |fugitive-revision|
-
- *fugitive-:Gread!*
-:Gread! [revision] Empty the buffer and |:read| a |fugitive-revision|.
- This is similar to git checkout on a work tree file or
- git add on a stage file, but without writing anything
- to disk.
-
- *fugitive-:Gwrite*
-:Gwrite Write to the current file's path and stage the results.
- When run in a work tree file, it is effectively git
- add. Elsewhere, it is effectively git checkout. A
- great deal of effort is expended to behave sensibly
- when the work tree or index version of the file is
- open in another buffer.
-
-:Gwrite {path} You can give |:Gwrite| an explicit path of where in
- the work tree to write. You can also give a path like
- :0:foo.txt or even :0 to write to just that stage in
- the index.
-
- *fugitive-:Gdiff*
-:Gdiff [revision] Perform a |vimdiff| against the current file in the
- given revision. With no argument, the version in the
- index is used (which means a three-way diff during a
- merge conflict, making it a git mergetool
- alternative). Use |do| and |dp| and write to the
- index file to simulate git add -p.
-
- *fugitive-:Gmove*
-:Gmove {destination} Wrapper around git-mv that renames the buffer
- afterward. The destination is relative to the current
- directory except when started with a /, in which case
- it is relative to the work tree. Add a ! to pass -f.
-
- *fugitive-:Gremove*
-:Gremove Wrapper around git-rm that deletes the buffer
- afterward. When invoked in an index file, --cached is
- passed. Add a ! to pass -f and forcefully discard the
- buffer.
-
- *fugitive-:Gblame*
-:Gblame Run git-blame on the file and open the results in a
- scroll bound vertical split. Press enter on a line to
- reblame the file as it was in that commit.
-
-:[range]Gblame Run git-blame on the given range.
-
-==============================================================================
-MAPPINGS *fugitive-mappings*
-
-These maps are available in Git objects.
-
- *fugitive-<CR>*
-<CR> Jump to the revision under the cursor.
-
- *fugitive-o*
-o Jump to the revision under the cursor in a new split.
-
- *fugitive-O*
-O Jump to the revision under the cursor in a new tab.
-
- *fugitive-~*
-~ Go to the current file in the [count]th first
- ancestor.
-
- *fugitive-P*
-P Go to the current file in the [count]th parent.
-
- *fugitive-C*
-C Go to the commit containing the current file.
-
- *fugitive-a*
-a Show the current tag, commit, or tree in an alternate
- format.
-
-==============================================================================
-SPECIFYING REVISIONS *fugitive-revision*
-
-Fugitive revisions are similar to Git revisions as defined in the "SPECIFYING
-REVISIONS" section in the git-rev-parse man page. For commands that accept an
-optional revision, the default is the file in the index for work tree files
-and the work tree file for everything else. Example revisions follow.
-
-Revision Meaning ~
-HEAD .git/HEAD
-master .git/refs/heads/master
-HEAD^{} The commit referenced by HEAD
-HEAD^ The parent of the commit referenced by HEAD
-HEAD: The tree referenced by HEAD
-/HEAD The file named HEAD in the work tree
-Makefile The file named Makefile in the work tree
-HEAD^:Makefile The file named Makefile in the parent of HEAD
-:Makefile The file named Makefile in the index (writable)
-- The current file in HEAD
-^ The current file in the previous commit
-~3 The current file 3 commits ago
-: .git/index (Same as |:Gstatus|)
-:0 The current file in the index
-:1 The current file's common ancestor during a conflict
-:2 The current file in the target branch during a conflict
-:3 The current file in the merged branch during a conflict
-:/foo The most recent commit with "foo" in the message
-
-==============================================================================
-ABOUT *fugitive-about*
-
-Grab the latest version or report a bug on Github:
-
-http://github.com/tpope/vim-fugitive
-
-==============================================================================
- vim:tw=78:et:ft=help:norl:
diff --git a/vim/doc/surround.txt b/vim/doc/surround.txt
deleted file mode 100644
index fec64a2..0000000
--- a/vim/doc/surround.txt
+++ /dev/null
@@ -1,218 +0,0 @@
-*surround.txt* Plugin for deleting, changing, and adding "surroundings"
-
-Author: Tim Pope <vimNOSPAM@tpope.info> *surround-author*
-License: Same terms as Vim itself (see |license|)
-
-This plugin is only available if 'compatible' is not set.
-
-INTRODUCTION *surround*
-
-This plugin is a tool for dealing with pairs of "surroundings." Examples
-of surroundings include parentheses, quotes, and HTML tags. They are
-closely related to what Vim refers to as |text-objects|. Provided
-are mappings to allow for removing, changing, and adding surroundings.
-
-Details follow on the exact semantics, but first, consider the following
-examples. An asterisk (*) is used to denote the cursor position.
-
- Old text Command New text ~
- "Hello *world!" ds" Hello world!
- [123+4*56]/2 cs]) (123+456)/2
- "Look ma, I'm *HTML!" cs"<q> <q>Look ma, I'm HTML!</q>
- if *x>3 { ysW( if ( x>3 ) {
- my $str = *whee!; vlllls' my $str = 'whee!';
-
-While a few features of this plugin will work in older versions of Vim,
-Vim 7 is recommended for full functionality.
-
-MAPPINGS *surround-mappings*
-
-Delete surroundings is *ds* . The next character given determines the target
-to delete. The exact nature of the target are explained in |surround-targets|
-but essentially it is the last character of a |text-object|. This mapping
-deletes the difference between the "inner" object and "an" object. This is
-easiest to understand with some examples:
-
- Old text Command New text ~
- "Hello *world!" ds" Hello world!
- (123+4*56)/2 ds) 123+456/2
- <div>Yo!*</div> dst Yo!
-
-Change surroundings is *cs* . It takes two arguments, a target like with
-|ds|, and a replacement. Details about the second argument can be found
-below in |surround-replacements|. Once again, examples are in order.
-
- Old text Command New text ~
- "Hello *world!" cs"' 'Hello world!'
- "Hello *world!" cs"<q> <q>Hello world!</q>
- (123+4*56)/2 cs)] [123+456]/2
- (123+4*56)/2 cs)[ [ 123+456 ]/2
- <div>Yo!*</div> cst<p> <p>Yo!</p>
-
-*ys* takes an valid Vim motion or text object as the first object, and wraps
-it using the second argument as with |cs|. (Unfortunately there's no good
-mnemonic for "ys".)
-
- Old text Command New text ~
- Hello w*orld! ysiw) Hello (world)!
-
-As a special case, *yss* operates on the current line, ignoring leading
-whitespace.
-
- Old text Command New text ~
- Hello w*orld! yssB {Hello world!}
-
-There is also *yS* and *ySS* which indent the surrounded text and place it
-on a line of its own.
-
-In visual mode, a simple "s" with an argument wraps the selection. This is
-referred to as the *vs* mapping, although ordinarily there will be
-additional keystrokes between the v and s. In linewise visual mode, the
-surroundings are placed on separate lines. In blockwise visual mode, each
-line is surrounded.
-
-An "S" in visual mode (*vS*) behaves similarly but always places the
-surroundings on separate lines. Additionally, the surrounded text is
-indented. In blockwise visual mode, using "S" instead of "s" instead skips
-trailing whitespace.
-
-Note that "s" and "S" already have valid meaning in visual mode, but it is
-identical to "c". If you have muscle memory for "s" and would like to use a
-different key, add your own mapping and the existing one will be disabled.
->
- vmap <Leader>s <Plug>Vsurround
- vmap <Leader>S <Plug>VSurround
-<
- *i_CTRL-G_s* *i_CTRL-G_S*
-Finally, there is an experimental insert mode mapping on <C-G>s and <C-S>.
-Beware that the latter won't work on terminals with flow control (if you
-accidentally freeze your terminal, use <C-Q> to unfreeze it). The mapping
-inserts the specified surroundings and puts the cursor between them. If,
-immediately after the mapping and before the replacement, a second <C-S> or
-carriage return is pressed, the prefix, cursor, and suffix will be placed on
-three separate lines. <C-G>S (not <C-G>s) also exhibits this behavior.
-
-TARGETS *surround-targets*
-
-The |ds| and |cs| commands both take a target as their first argument. The
-possible targets are based closely on the |text-objects| provided by Vim.
-In order for a target to work, the corresponding text object must be
-supported in the version of Vim used (Vim 7 adds several text objects, and
-thus is highly recommended). All targets are currently just one character.
-
-Eight punctuation marks, (, ), {, }, [, ], <, and >, represent themselves
-and their counterpart. If the opening mark is used, contained whitespace is
-also trimmed. The targets b, B, r, and a are aliases for ), }, ], and >
-(the first two mirror Vim; the second two are completely arbitrary and
-subject to change).
-
-Three quote marks, ', ", `, represent themselves, in pairs. They are only
-searched for on the current line.
-
-A t is a pair of HTML or XML tags. See |tag-blocks| for details. Remember
-that you can specify a numerical argument if you want to get to a tag other
-than the innermost one.
-
-The letters w, W, and s correspond to a |word|, a |WORD|, and a |sentence|,
-respectively. These are special in that they have nothing to delete, and
-used with |ds| they are a no-op. With |cs|, one could consider them a
-slight shortcut for ysi (cswb == ysiwb, more or less).
-
-A p represents a |paragraph|. This behaves similarly to w, W, and s above;
-however, newlines are sometimes added and/or removed.
-
-REPLACEMENTS *surround-replacements*
-
-A replacement argument is a single character, and is required by |cs|, |ys|,
-and |vs|. Undefined replacement characters (with the exception of alphabetic
-characters) default to placing themselves at the beginning and end of the
-destination, which can be useful for characters like / and |.
-
-If either ), }, ], or > is used, the text is wrapped in the appropriate pair
-of characters. Similar behavior can be found with (, {, and [ (but not <),
-which append an additional space to the inside. Like with the targets above,
-b, B, r, and a are aliases for ), }, ], and >. To fulfill the common need for
-code blocks in C-style languages, <C-}> (which is really <C-]>) adds braces on
-lines separate from the content.
-
-If t or < is used, Vim prompts for an HTML/XML tag to insert. You may specify
-attributes here and they will be stripped from the closing tag. End your
-input by pressing <CR> or >. If <C-T> is used, the tags will appear on lines
-by themselves.
-
-A deprecated replacement of a LaTeX environment is provided on \ and l. The
-name of the environment and any arguments will be input from a prompt. This
-will be removed once a more fully functional customization system is
-implemented. The following shows the resulting environment from
-csp\tabular}{lc<CR>
->
- \begin{tabular}{lc}
- \end{tabular}
-<
-CUSTOMIZING *surround-customizing*
-
-The following adds a potential replacement on "-" (ASCII 45) in PHP files.
-(To determine the ASCII code to use, :echo char2nr("-")). The carriage
-return will be replaced by the original text.
->
- autocmd FileType php let b:surround_45 = "<?php \r ?>"
-<
-This can be used in a PHP file as in the following example.
-
- Old text Command New text ~
- print "Hello *world!" yss- <?php print "Hello world!" ?>
-
-Additionally, one can use a global variable for globally available
-replacements.
->
- let g:surround_45 = "<% \r %>"
- let g:surround_61 = "<%= \r %>"
-<
-Advanced, experimental, and subject to change: One can also prompt for
-replacement text. The syntax for this is to surround the replacement in pairs
-of low numbered control characters. If this sounds confusing, that's because
-it is (but it makes the parsing easy). Consider the following example for a
-LaTeX environment on the "l" replacement.
->
- let g:surround_108 = "\\begin{\1environment: \1}\r\\end{\1\1}"
-<
-When this replacement is used, the user is prompted with an "environment: "
-prompt for input. This input is inserted between each set of \1's.
-Additional inputs up to \7 can be used.
-
-Furthermore, one can specify a regular expression substitution to apply.
->
- let g:surround_108 = "\\begin{\1environment: \1}\r\\end{\1\r}.*\r\1}"
-<
-This will remove anything after the first } in the input when the text is
-placed within the \end{} slot. The first \r marks where the pattern begins,
-and the second where the replacement text begins.
-
-Here's a second example for creating an HTML <div>. The substitution cleverly
-prompts for an id, but only adds id="" if it is non-blank. You may have to
-read this one a few times slowly before you understand it.
->
- let g:surround_{char2nr("d")} = "<div\1id: \r..*\r id=\"&\"\1>\r</div>"
-<
-Inputting text replacements is a proof of concept at this point. The ugly,
-unintuitive interface and the brevity of the documentation reflect this.
-
-Finally, It is possible to always append a string to surroundings in insert
-mode (and only insert mode). This is useful with certain plugins and mappings
-that allow you to jump to such markings.
->
- let g:surround_insert_tail = "<++>"
-<
-ISSUES *surround-issues*
-
-Vim could potentially get confused when deleting/changing occurs at the very
-end of the line. Please report any repeatable instances of this.
-
-Do we need to use |inputsave()|/|inputrestore()| with the tag replacement?
-
-Indenting is handled haphazardly. Need to decide the most appropriate
-behavior and implement it. Right now one can do :let b:surround_indent = 1
-(or the global equivalent) to enable automatic re-indenting by Vim via |=|;
-should this be the default?
-
- vim:tw=78:ts=8:ft=help:norl:
diff --git a/vim/doc/taglist.txt b/vim/doc/taglist.txt
deleted file mode 100644
index 6a62b39..0000000
--- a/vim/doc/taglist.txt
+++ /dev/null
@@ -1,1501 +0,0 @@
-*taglist.txt* Plugin for browsing source code
-
-Author: Yegappan Lakshmanan (yegappan AT yahoo DOT com)
-For Vim version 6.0 and above
-Last change: 2007 May 24
-
-1. Overview |taglist-intro|
-2. Taglist on the internet |taglist-internet|
-3. Requirements |taglist-requirements|
-4. Installation |taglist-install|
-5. Usage |taglist-using|
-6. Options |taglist-options|
-7. Commands |taglist-commands|
-8. Global functions |taglist-functions|
-9. Extending |taglist-extend|
-10. FAQ |taglist-faq|
-11. License |taglist-license|
-12. Todo |taglist-todo|
-
-==============================================================================
- *taglist-intro*
-1. Overview~
-
-The "Tag List" plugin is a source code browser plugin for Vim. This plugin
-allows you to efficiently browse through source code files for different
-programming languages. The "Tag List" plugin provides the following features:
-
- * Displays the tags (functions, classes, structures, variables, etc.)
- defined in a file in a vertically or horizontally split Vim window.
- * In GUI Vim, optionally displays the tags in the Tags drop-down menu and
- in the popup menu.
- * Automatically updates the taglist window as you switch between
- files/buffers. As you open new files, the tags defined in the new files
- are added to the existing file list and the tags defined in all the
- files are displayed grouped by the filename.
- * When a tag name is selected from the taglist window, positions the
- cursor at the definition of the tag in the source file.
- * Automatically highlights the current tag name.
- * Groups the tags by their type and displays them in a foldable tree.
- * Can display the prototype and scope of a tag.
- * Can optionally display the tag prototype instead of the tag name in the
- taglist window.
- * The tag list can be sorted either by name or by chronological order.
- * Supports the following language files: Assembly, ASP, Awk, Beta, C,
- C++, C#, Cobol, Eiffel, Erlang, Fortran, HTML, Java, Javascript, Lisp,
- Lua, Make, Pascal, Perl, PHP, Python, Rexx, Ruby, Scheme, Shell, Slang,
- SML, Sql, TCL, Verilog, Vim and Yacc.
- * Can be easily extended to support new languages. Support for
- existing languages can be modified easily.
- * Provides functions to display the current tag name in the Vim status
- line or the window title bar.
- * The list of tags and files in the taglist can be saved and
- restored across Vim sessions.
- * Provides commands to get the name and prototype of the current tag.
- * Runs in both console/terminal and GUI versions of Vim.
- * Works with the winmanager plugin. Using the winmanager plugin, you
- can use Vim plugins like the file explorer, buffer explorer and the
- taglist plugin at the same time like an IDE.
- * Can be used in both Unix and MS-Windows systems.
-
-==============================================================================
- *taglist-internet*
-2. Taglist on the internet~
-
-The home page of the taglist plugin is at:
->
- http://vim-taglist.sourceforge.net/
-<
-You can subscribe to the taglist mailing list to post your questions or
-suggestions for improvement or to send bug reports. Visit the following page
-for subscribing to the mailing list:
->
- http://groups.yahoo.com/group/taglist
-<
-==============================================================================
- *taglist-requirements*
-3. Requirements~
-
-The taglist plugin requires the following:
-
- * Vim version 6.0 and above
- * Exuberant ctags 5.0 and above
-
-The taglist plugin will work on all the platforms where the exuberant ctags
-utility and Vim are supported (this includes MS-Windows and Unix based
-systems).
-
-The taglist plugin relies on the exuberant ctags utility to dynamically
-generate the tag listing. The exuberant ctags utility must be installed in
-your system to use this plugin. The exuberant ctags utility is shipped with
-most of the Linux distributions. You can download the exuberant ctags utility
-from
->
- http://ctags.sourceforge.net
-<
-The taglist plugin doesn't use or create a tags file and there is no need to
-create a tags file to use this plugin. The taglist plugin will not work with
-the GNU ctags or the Unix ctags utility.
-
-This plugin relies on the Vim "filetype" detection mechanism to determine the
-type of the current file. You have to turn on the Vim filetype detection by
-adding the following line to your .vimrc file:
->
- filetype on
-<
-The taglist plugin will not work if you run Vim in the restricted mode (using
-the -Z command-line argument).
-
-The taglist plugin uses the Vim system() function to invoke the exuberant
-ctags utility. If Vim is compiled without the system() function then you
-cannot use the taglist plugin. Some of the Linux distributions (Suse) compile
-Vim without the system() function for security reasons.
-
-==============================================================================
- *taglist-install*
-4. Installation~
-
-1. Download the taglist.zip file and unzip the files to the $HOME/.vim or the
- $HOME/vimfiles or the $VIM/vimfiles directory. After this step, you should
- have the following two files (the directory structure should be preserved):
-
- plugin/taglist.vim - main taglist plugin file
- doc/taglist.txt - documentation (help) file
-
- Refer to the |add-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. Without this step, you cannot jump to the taglist help
- topics.
-3. If the exuberant ctags utility is not present in one of the directories in
- the PATH environment variable, 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.
-
-To uninstall the taglist plugin, remove the plugin/taglist.vim and
-doc/taglist.txt files from the $HOME/.vim or $HOME/vimfiles directory.
-
-==============================================================================
- *taglist-using*
-5. Usage~
-
-The taglist plugin can be used in several different ways.
-
-1. You can keep the taglist window open during the entire editing session. On
- opening the taglist window, the tags defined in all the files in the Vim
- buffer list will be displayed in the taglist window. As you edit files, the
- tags defined in them will be added to the taglist window. You can select a
- tag from the taglist window and jump to it. The current tag will be
- highlighted in the taglist window. You can close the taglist window when
- you no longer need the window.
-2. You can configure the taglist plugin to process the tags defined in all the
- edited files always. In this configuration, even if the taglist window is
- closed and the taglist menu is not displayed, the taglist plugin will
- processes the tags defined in newly edited files. You can then open the
- taglist window only when you need to select a tag and then automatically
- close the taglist window after selecting the tag.
-3. You can configure the taglist plugin to display only the tags defined in
- the current file in the taglist window. By default, the taglist plugin
- displays the tags defined in all the files in the Vim buffer list. As you
- switch between files, the taglist window will be refreshed to display only
- the tags defined in the current file.
-4. In GUI Vim, you can use the Tags pull-down and popup menu created by the
- taglist plugin to display the tags defined in the current file and select a
- tag to jump to it. You can use the menu without opening the taglist window.
- By default, the Tags menu is disabled.
-5. You can configure the taglist plugin to display the name of the current tag
- in the Vim window status line or in the Vim window title bar. For this to
- work without the taglist window or menu, you need to configure the taglist
- plugin to process the tags defined in a file always.
-6. You can save the tags defined in multiple files to a taglist session file
- and load it when needed. You can also configure the taglist plugin to not
- update the taglist window when editing new files. You can then manually add
- files to the taglist window.
-
-Opening the taglist window~
-You can open the taglist window using the ":TlistOpen" or the ":TlistToggle"
-commands. The ":TlistOpen" command opens the taglist window and jumps to it.
-The ":TlistToggle" command opens or closes (toggle) the taglist window and the
-cursor remains in the current window. If the 'Tlist_GainFocus_On_ToggleOpen'
-variable is set to 1, then the ":TlistToggle" command opens the taglist window
-and moves the cursor to the taglist window.
-
-You can map a key to invoke these commands. For example, the following command
-creates a normal mode mapping for the <F8> key to toggle the taglist window.
->
- nnoremap <silent> <F8> :TlistToggle<CR>
-<
-Add the above mapping to your ~/.vimrc or $HOME/_vimrc file.
-
-To automatically open the taglist window on Vim startup, set the
-'Tlist_Auto_Open' variable to 1.
-
-You can also open the taglist window on startup using the following command
-line:
->
- $ vim +TlistOpen
-<
-Closing the taglist window~
-You can close the taglist window from the taglist window by pressing 'q' or
-using the Vim ":q" command. You can also use any of the Vim window commands to
-close the taglist window. Invoking the ":TlistToggle" command when the taglist
-window is opened, closes the taglist window. You can also use the
-":TlistClose" command to close the taglist window.
-
-To automatically close the taglist window when a tag or file is selected, you
-can set the 'Tlist_Close_On_Select' variable to 1. To exit Vim when only the
-taglist window is present, set the 'Tlist_Exit_OnlyWindow' variable to 1.
-
-Jumping to a tag or a file~
-You can select a tag in the taglist window either by pressing the <Enter> key
-or by double clicking the tag name using the mouse. To jump to a tag on a
-single mouse click set the 'Tlist_Use_SingleClick' variable to 1.
-
-If the selected file is already opened in a window, then the cursor is moved
-to that window. If the file is not currently opened in a window then the file
-is opened in the window used by the taglist plugin to show the previously
-selected file. If there are no usable windows, then the file is opened in a
-new window. The file is not opened in special windows like the quickfix
-window, preview window and windows containing buffer with the 'buftype' option
-set.
-
-To jump to the tag in a new window, press the 'o' key. To open the file in the
-previous window (Ctrl-W_p) use the 'P' key. You can press the 'p' key to jump
-to the tag but still keep the cursor in the taglist window (preview).
-
-To open the selected file in a tab, use the 't' key. If the file is already
-present in a tab then the cursor is moved to that tab otherwise the file is
-opened in a new tab. To jump to a tag in a new tab press Ctrl-t. The taglist
-window is automatically opened in the newly created tab.
-
-Instead of jumping to a tag, you can open a file by pressing the <Enter> key
-or by double clicking the file name using the mouse.
-
-In the taglist window, you can use the [[ or <Backspace> key to jump to the
-beginning of the previous file. You can use the ]] or <Tab> key to jump to the
-beginning of the next file. When you reach the first or last file, the search
-wraps around and the jumps to the next/previous file.
-
-Highlighting the current tag~
-The taglist plugin automatically highlights the name of the current tag in the
-taglist window. The Vim |CursorHold| autocmd event is used for this. If the
-current tag name is not visible in the taglist window, then the taglist window
-contents are scrolled to make that tag name visible. You can also use the
-":TlistHighlightTag" command to force the highlighting of the current tag.
-
-The tag name is highlighted if no activity is performed for |'updatetime'|
-milliseconds. The default value for this Vim option is 4 seconds. To avoid
-unexpected problems, you should not set the |'updatetime'| option to a very
-low value.
-
-To disable the automatic highlighting of the current tag name in the taglist
-window, set the 'Tlist_Auto_Highlight_Tag' variable to zero.
-
-When entering a Vim buffer/window, the taglist plugin automatically highlights
-the current tag in that buffer/window. If you like to disable the automatic
-highlighting of the current tag when entering a buffer, set the
-'Tlist_Highlight_Tag_On_BufEnter' variable to zero.
-
-Adding files to the taglist~
-When the taglist window is opened, all the files in the Vim buffer list are
-processed and the supported files are added to the taglist. When you edit a
-file in Vim, the taglist plugin automatically processes this file and adds it
-to the taglist. If you close the taglist window, the tag information in the
-taglist is retained.
-
-To process files even when the taglist window is not open, set the
-'Tlist_Process_File_Always' variable to 1.
-
-You can manually add multiple files to the taglist without opening them using
-the ":TlistAddFiles" and the ":TlistAddFilesRecursive" commands.
-
-For example, to add all the C files in the /my/project/dir directory to the
-taglist, you can use the following command:
->
- :TlistAddFiles /my/project/dir/*.c
-<
-Note that when adding several files with a large number of tags or a large
-number of files, it will take several seconds to several minutes for the
-taglist plugin to process all the files. You should not interrupt the taglist
-plugin by pressing <CTRL-C>.
-
-You can recursively add multiple files from a directory tree using the
-":TlistAddFilesRecursive" command:
->
- :TlistAddFilesRecursive /my/project/dir *.c
-<
-This command takes two arguments. The first argument specifies the directory
-from which to recursively add the files. The second optional argument
-specifies the wildcard matching pattern for selecting the files to add. The
-default pattern is * and all the files are added.
-
-Displaying tags for only one file~
-The taglist window displays the tags for all the files in the Vim buffer list
-and all the manually added files. To display the tags for only the current
-active buffer, set the 'Tlist_Show_One_File' variable to 1.
-
-Removing files from the taglist~
-You can remove a file from the taglist window, by pressing the 'd' key when the
-cursor is on one of the tags listed for the file in the taglist window. The
-removed file will no longer be displayed in the taglist window in the current
-Vim session. To again display the tags for the file, open the file in a Vim
-window and then use the ":TlistUpdate" command or use ":TlistAddFiles" command
-to add the file to the taglist.
-
-When a buffer is removed from the Vim buffer list using the ":bdelete" or the
-":bwipeout" command, the taglist is updated to remove the stored information
-for this buffer.
-
-Updating the tags displayed for a file~
-The taglist plugin keeps track of the modification time of a file. When the
-modification time changes (the file is modified), the taglist plugin
-automatically updates the tags listed for that file. The modification time of
-a file is checked when you enter a window containing that file or when you
-load that file.
-
-You can also update or refresh the tags displayed for a file by pressing the
-"u" key in the taglist window. If an existing file is modified, after the file
-is saved, the taglist plugin automatically updates the tags displayed for the
-file.
-
-You can also use the ":TlistUpdate" command to update the tags for the current
-buffer after you made some changes to it. You should save the modified buffer
-before you update the taglist window. Otherwise the listed tags will not
-include the new tags created in the buffer.
-
-If you have deleted the tags displayed for a file in the taglist window using
-the 'd' key, you can again display the tags for that file using the
-":TlistUpdate" command.
-
-Controlling the taglist updates~
-To disable the automatic processing of new files or modified files, you can
-set the 'Tlist_Auto_Update' variable to zero. When this variable is set to
-zero, the taglist is updated only when you use the ":TlistUpdate" command or
-the ":TlistAddFiles" or the ":TlistAddFilesRecursive" commands. You can use
-this option to control which files are added to the taglist.
-
-You can use the ":TlistLock" command to lock the taglist contents. After this
-command is executed, new files are not automatically added to the taglist.
-When the taglist is locked, you can use the ":TlistUpdate" command to add the
-current file or the ":TlistAddFiles" or ":TlistAddFilesRecursive" commands to
-add new files to the taglist. To unlock the taglist, use the ":TlistUnlock"
-command.
-
-Displaying the tag prototype~
-To display the prototype of the tag under the cursor in the taglist window,
-press the space bar. If you place the cursor on a tag name in the taglist
-window, then the tag prototype is displayed at the Vim status line after
-|'updatetime'| milliseconds. The default value for the |'updatetime'| Vim
-option is 4 seconds.
-
-You can get the name and prototype of a tag without opening the taglist window
-and the taglist menu using the ":TlistShowTag" and the ":TlistShowPrototype"
-commands. These commands will work only if the current file is already present
-in the taglist. To use these commands without opening the taglist window, set
-the 'Tlist_Process_File_Always' variable to 1.
-
-You can use the ":TlistShowTag" command to display the name of the tag at or
-before the specified line number in the specified file. If the file name and
-line number are not supplied, then this command will display the name of the
-current tag. For example,
->
- :TlistShowTag
- :TlistShowTag myfile.java 100
-<
-You can use the ":TlistShowPrototype" command to display the prototype of the
-tag at or before the specified line number in the specified file. If the file
-name and the line number are not supplied, then this command will display the
-prototype of the current tag. For example,
->
- :TlistShowPrototype
- :TlistShowPrototype myfile.c 50
-<
-In the taglist window, when the mouse is moved over a tag name, the tag
-prototype is displayed in a balloon. This works only in GUI versions where
-balloon evaluation is supported.
-
-Taglist window contents~
-The taglist window contains the tags defined in various files in the taglist
-grouped by the filename and by the tag type (variable, function, class, etc.).
-For tags with scope information (like class members, structures inside
-structures, etc.), the scope information is displayed in square brackets "[]"
-after the tag name.
-
-The contents of the taglist buffer/window are managed by the taglist plugin.
-The |'filetype'| for the taglist buffer is set to 'taglist'. The Vim
-|'modifiable'| option is turned off for the taglist buffer. You should not
-manually edit the taglist buffer, by setting the |'modifiable'| flag. If you
-manually edit the taglist buffer contents, then the taglist plugin will be out
-of sync with the taglist buffer contents and the plugin will no longer work
-correctly. To redisplay the taglist buffer contents again, close the taglist
-window and reopen it.
-
-Opening and closing the tag and file tree~
-In the taglist window, the tag names are displayed as a foldable tree using
-the Vim folding support. You can collapse the tree using the '-' key or using
-the Vim |zc| fold command. You can open the tree using the '+' key or using
-the Vim |zo| fold command. You can open all the folds using the '*' key or
-using the Vim |zR| fold command. You can also use the mouse to open/close the
-folds. You can close all the folds using the '=' key. You should not manually
-create or delete the folds in the taglist window.
-
-To automatically close the fold for the inactive files/buffers and open only
-the fold for the current buffer in the taglist window, set the
-'Tlist_File_Fold_Auto_Close' variable to 1.
-
-Sorting the tags for a file~
-The tags displayed in the taglist window can be sorted either by their name or
-by their chronological order. The default sorting method is by the order in
-which the tags appear in a file. You can change the default sort method by
-setting the 'Tlist_Sort_Type' variable to either "name" or "order". You can
-sort the tags by their name by pressing the "s" key in the taglist window. You
-can again sort the tags by their chronological order using the "s" key. Each
-file in the taglist window can be sorted using different order.
-
-Zooming in and out of the taglist window~
-You can press the 'x' key in the taglist window to maximize the taglist
-window width/height. The window will be maximized to the maximum possible
-width/height without closing the other existing windows. You can again press
-'x' to restore the taglist window to the default width/height.
-
- *taglist-session*
-Taglist Session~
-A taglist session refers to the group of files and their tags stored in the
-taglist in a Vim session.
-
-You can save and restore a taglist session (and all the displayed tags) using
-the ":TlistSessionSave" and ":TlistSessionLoad" commands.
-
-To save the information about the tags and files in the taglist to a file, use
-the ":TlistSessionSave" command and specify the filename:
->
- :TlistSessionSave <file name>
-<
-To load a saved taglist session, use the ":TlistSessionLoad" command: >
-
- :TlistSessionLoad <file name>
-<
-When you load a taglist session file, the tags stored in the file will be
-added to the tags already stored in the taglist.
-
-The taglist session feature can be used to save the tags for large files or a
-group of frequently used files (like a project). By using the taglist session
-file, you can minimize the amount to time it takes to load/refresh the taglist
-for multiple files.
-
-You can create more than one taglist session file for multiple groups of
-files.
-
-Displaying the tag name in the Vim status line or the window title bar~
-You can use the Tlist_Get_Tagname_By_Line() function provided by the taglist
-plugin to display the current tag name in the Vim status line or the window
-title bar. Similarly, you can use the Tlist_Get_Tag_Prototype_By_Line()
-function to display the current tag prototype in the Vim status line or the
-window title bar.
-
-For example, the following command can be used to display the current tag name
-in the status line:
->
- :set statusline=%<%f%=%([%{Tlist_Get_Tagname_By_Line()}]%)
-<
-The following command can be used to display the current tag name in the
-window title bar:
->
- :set title titlestring=%<%f\ %([%{Tlist_Get_Tagname_By_Line()}]%)
-<
-Note that the current tag name can be displayed only after the file is
-processed by the taglist plugin. For this, you have to either set the
-'Tlist_Process_File_Always' variable to 1 or open the taglist window or use
-the taglist menu. For more information about configuring the Vim status line,
-refer to the documentation for the Vim |'statusline'| option.
-
-Changing the taglist window highlighting~
-The following Vim highlight groups are defined and used to highlight the
-various entities in the taglist window:
-
- TagListTagName - Used for tag names
- TagListTagScope - Used for tag scope
- TagListTitle - Used for tag titles
- TagListComment - Used for comments
- TagListFileName - Used for filenames
-
-By default, these highlight groups are linked to the standard Vim highlight
-groups. If you want to change the colors used for these highlight groups,
-prefix the highlight group name with 'My' and define it in your .vimrc or
-.gvimrc file: MyTagListTagName, MyTagListTagScope, MyTagListTitle,
-MyTagListComment and MyTagListFileName. For example, to change the colors
-used for tag names, you can use the following command:
->
- :highlight MyTagListTagName guifg=blue ctermfg=blue
-<
-Controlling the taglist window~
-To use a horizontally split taglist window, instead of a vertically split
-window, set the 'Tlist_Use_Horiz_Window' variable to 1.
-
-To use a vertically split taglist window on the rightmost side of the Vim
-window, set the 'Tlist_Use_Right_Window' variable to 1.
-
-You can specify the width of the vertically split taglist window, by setting
-the 'Tlist_WinWidth' variable. You can specify the height of the horizontally
-split taglist window, by setting the 'Tlist_WinHeight' variable.
-
-When opening a vertically split taglist window, the Vim window width is
-increased to accommodate the new taglist window. When the taglist window is
-closed, the Vim window is reduced. To disable this, set the
-'Tlist_Inc_Winwidth' variable to zero.
-
-To reduce the number of empty lines in the taglist window, set the
-'Tlist_Compact_Format' variable to 1.
-
-To not display the Vim fold column in the taglist window, set the
-'Tlist_Enable_Fold_Column' variable to zero.
-
-To display the tag prototypes instead of the tag names in the taglist window,
-set the 'Tlist_Display_Prototype' variable to 1.
-
-To not display the scope of the tags next to the tag names, set the
-'Tlist_Display_Tag_Scope' variable to zero.
-
- *taglist-keys*
-Taglist window key list~
-The following table lists the description of the keys that can be used
-in the taglist window.
-
- Key Description~
-
- <CR> Jump to the location where the tag under cursor is
- defined.
- o Jump to the location where the tag under cursor is
- defined in a new window.
- P Jump to the tag in the previous (Ctrl-W_p) window.
- p Display the tag definition in the file window and
- keep the cursor in the taglist window itself.
- t Jump to the tag in a new tab. If the file is already
- opened in a tab, move to that tab.
- Ctrl-t Jump to the tag in a new tab.
- <Space> Display the prototype of the tag under the cursor.
- For file names, display the full path to the file,
- file type and the number of tags. For tag types, display the
- tag type and the number of tags.
- u Update the tags listed in the taglist window
- s Change the sort order of the tags (by name or by order)
- d Remove the tags for the file under the cursor
- x Zoom-in or Zoom-out the taglist window
- + Open a fold
- - Close a fold
- * Open all folds
- = Close all folds
- [[ Jump to the beginning of the previous file
- <Backspace> Jump to the beginning of the previous file
- ]] Jump to the beginning of the next file
- <Tab> Jump to the beginning of the next file
- q Close the taglist window
- <F1> Display help
-
-The above keys will work in both the normal mode and the insert mode.
-
- *taglist-menu*
-Taglist menu~
-When using GUI Vim, the taglist plugin can display the tags defined in the
-current file in the drop-down menu and the popup menu. By default, this
-feature is turned off. To turn on this feature, set the 'Tlist_Show_Menu'
-variable to 1.
-
-You can jump to a tag by selecting the tag name from the menu. You can use the
-taglist menu independent of the taglist window i.e. you don't need to open the
-taglist window to get the taglist menu.
-
-When you switch between files/buffers, the taglist menu is automatically
-updated to display the tags defined in the current file/buffer.
-
-The tags are grouped by their type (variables, functions, classes, methods,
-etc.) and displayed as a separate sub-menu for each type. If all the tags
-defined in a file are of the same type (e.g. functions), then the sub-menu is
-not used.
-
-If the number of items in a tag type submenu exceeds the value specified by
-the 'Tlist_Max_Submenu_Items' variable, then the submenu will be split into
-multiple submenus. The default setting for 'Tlist_Max_Submenu_Items' is 25.
-The first and last tag names in the submenu are used to form the submenu name.
-The menu items are prefixed by alpha-numeric characters for easy selection by
-keyboard.
-
-If the popup menu support is enabled (the |'mousemodel'| option contains
-"popup"), then the tags menu is added to the popup menu. You can access
-the popup menu by right clicking on the GUI window.
-
-You can regenerate the tags menu by selecting the 'Tags->Refresh menu' entry.
-You can sort the tags listed in the menu either by name or by order by
-selecting the 'Tags->Sort menu by->Name/Order' menu entry.
-
-You can tear-off the Tags menu and keep it on the side of the Vim window
-for quickly locating the tags.
-
-Using the taglist plugin with the winmanager plugin~
-You can use the taglist plugin with the winmanager plugin. This will allow you
-to use the file explorer, buffer explorer and the taglist plugin at the same
-time in different windows. To use the taglist plugin with the winmanager
-plugin, set 'TagList' in the 'winManagerWindowLayout' variable. For example,
-to use the file explorer plugin and the taglist plugin at the same time, use
-the following setting: >
-
- let winManagerWindowLayout = 'FileExplorer|TagList'
-<
-Getting help~
-If you have installed the taglist help file (this file), then you can use the
-Vim ":help taglist-<keyword>" command to get help on the various taglist
-topics.
-
-You can press the <F1> key in the taglist window to display the help
-information about using the taglist window. If you again press the <F1> key,
-the help information is removed from the taglist window.
-
- *taglist-debug*
-Debugging the taglist plugin~
-You can use the ":TlistDebug" command to enable logging of the debug messages
-from the taglist plugin. To display the logged debug messages, you can use the
-":TlistMessages" command. To disable the logging of the debug messages, use
-the ":TlistUndebug" command.
-
-You can specify a file name to the ":TlistDebug" command to log the debug
-messages to a file. Otherwise, the debug messages are stored in a script-local
-variable. In the later case, to minimize memory usage, only the last 3000
-characters from the debug messages are stored.
-
-==============================================================================
- *taglist-options*
-6. Options~
-
-A number of Vim variables control the behavior of the taglist plugin. These
-variables are initialized to a default value. By changing these variables you
-can change the behavior of the taglist plugin. You need to change these
-settings only if you want to change the behavior of the taglist plugin. You
-should use the |:let| command in your .vimrc file to change the setting of any
-of these variables.
-
-The configurable taglist variables are listed below. For a detailed
-description of these variables refer to the text below this table.
-
-|'Tlist_Auto_Highlight_Tag'| Automatically highlight the current tag in the
- taglist.
-|'Tlist_Auto_Open'| Open the taglist window when Vim starts.
-|'Tlist_Auto_Update'| Automatically update the taglist to include
- newly edited files.
-|'Tlist_Close_On_Select'| Close the taglist window when a file or tag is
- selected.
-|'Tlist_Compact_Format'| Remove extra information and blank lines from
- the taglist window.
-|'Tlist_Ctags_Cmd'| Specifies the path to the ctags utility.
-|'Tlist_Display_Prototype'| Show prototypes and not tags in the taglist
- window.
-|'Tlist_Display_Tag_Scope'| Show tag scope next to the tag name.
-|'Tlist_Enable_Fold_Column'| Show the fold indicator column in the taglist
- window.
-|'Tlist_Exit_OnlyWindow'| Close Vim if the taglist is the only window.
-|'Tlist_File_Fold_Auto_Close'| Close tag folds for inactive buffers.
-|'Tlist_GainFocus_On_ToggleOpen'|
- Jump to taglist window on open.
-|'Tlist_Highlight_Tag_On_BufEnter'|
- On entering a buffer, automatically highlight
- the current tag.
-|'Tlist_Inc_Winwidth'| Increase the Vim window width to accommodate
- the taglist window.
-|'Tlist_Max_Submenu_Items'| Maximum number of items in a tags sub-menu.
-|'Tlist_Max_Tag_Length'| Maximum tag length used in a tag menu entry.
-|'Tlist_Process_File_Always'| Process files even when the taglist window is
- closed.
-|'Tlist_Show_Menu'| Display the tags menu.
-|'Tlist_Show_One_File'| Show tags for the current buffer only.
-|'Tlist_Sort_Type'| Sort method used for arranging the tags.
-|'Tlist_Use_Horiz_Window'| Use a horizontally split window for the
- taglist window.
-|'Tlist_Use_Right_Window'| Place the taglist window on the right side.
-|'Tlist_Use_SingleClick'| Single click on a tag jumps to it.
-|'Tlist_WinHeight'| Horizontally split taglist window height.
-|'Tlist_WinWidth'| Vertically split taglist window width.
-
- *'Tlist_Auto_Highlight_Tag'*
-Tlist_Auto_Highlight_Tag~
-The taglist plugin will automatically highlight the current tag in the taglist
-window. If you want to disable this, then you can set the
-'Tlist_Auto_Highlight_Tag' variable to zero. Note that even though the current
-tag highlighting is disabled, the tags for a new file will still be added to
-the taglist window.
->
- let Tlist_Auto_Highlight_Tag = 0
-<
-With the above variable set to 1, you can use the ":TlistHighlightTag" command
-to highlight the current tag.
-
- *'Tlist_Auto_Open'*
-Tlist_Auto_Open~
-To automatically open the taglist window, when you start Vim, you can set the
-'Tlist_Auto_Open' variable to 1. By default, this variable is set to zero and
-the taglist window will not be opened automatically on Vim startup.
->
- let Tlist_Auto_Open = 1
-<
-The taglist window is opened only when a supported type of file is opened on
-Vim startup. For example, if you open text files, then the taglist window will
-not be opened.
-
- *'Tlist_Auto_Update'*
-Tlist_Auto_Update~
-When a new file is edited, the tags defined in the file are automatically
-processed and added to the taglist. To stop adding new files to the taglist,
-set the 'Tlist_Auto_Update' variable to zero. By default, this variable is set
-to 1.
->
- let Tlist_Auto_Update = 0
-<
-With the above variable set to 1, you can use the ":TlistUpdate" command to
-add the tags defined in the current file to the taglist.
-
- *'Tlist_Close_On_Select'*
-Tlist_Close_On_Select~
-If you want to close the taglist window when a file or tag is selected, then
-set the 'Tlist_Close_On_Select' variable to 1. By default, this variable is
-set zero and when you select a tag or file from the taglist window, the window
-is not closed.
->
- let Tlist_Close_On_Select = 1
-<
- *'Tlist_Compact_Format'*
-Tlist_Compact_Format~
-By default, empty lines are used to separate different tag types displayed for
-a file and the tags displayed for different files in the taglist window. If
-you want to display as many tags as possible in the taglist window, you can
-set the 'Tlist_Compact_Format' variable to 1 to get a compact display.
->
- let Tlist_Compact_Format = 1
-<
- *'Tlist_Ctags_Cmd'*
-Tlist_Ctags_Cmd~
-The 'Tlist_Ctags_Cmd' variable specifies the location (path) of the exuberant
-ctags utility. If exuberant ctags is present in any one of the directories in
-the PATH environment variable, then there is no need to set this variable.
-
-The exuberant ctags tool can be installed under different names. When the
-taglist plugin starts up, if the 'Tlist_Ctags_Cmd' variable is not set, it
-checks for the names exuberant-ctags, exctags, ctags, ctags.exe and tags in
-the PATH environment variable. If any one of the named executable is found,
-then the Tlist_Ctags_Cmd variable is set to that name.
-
-If exuberant ctags is not present in one of the directories specified in the
-PATH environment variable, then set this variable to point to the location of
-the ctags utility in your system. Note that this variable should point to the
-fully qualified exuberant ctags location and NOT to the directory in which
-exuberant ctags is installed. If the exuberant ctags tool is not found in
-either PATH or in the specified location, then the taglist plugin will not be
-loaded. Examples:
->
- let Tlist_Ctags_Cmd = 'd:\tools\ctags.exe'
- let Tlist_Ctags_Cmd = '/usr/local/bin/ctags'
-<
- *'Tlist_Display_Prototype'*
-Tlist_Display_Prototype~
-By default, only the tag name will be displayed in the taglist window. If you
-like to see tag prototypes instead of names, set the 'Tlist_Display_Prototype'
-variable to 1. By default, this variable is set to zero and only tag names
-will be displayed.
->
- let Tlist_Display_Prototype = 1
-<
- *'Tlist_Display_Tag_Scope'*
-Tlist_Display_Tag_Scope~
-By default, the scope of a tag (like a C++ class) will be displayed in
-square brackets next to the tag name. If you don't want the tag scopes
-to be displayed, then set the 'Tlist_Display_Tag_Scope' to zero. By default,
-this variable is set to 1 and the tag scopes will be displayed.
->
- let Tlist_Display_Tag_Scope = 0
-<
- *'Tlist_Enable_Fold_Column'*
-Tlist_Enable_Fold_Column~
-By default, the Vim fold column is enabled and displayed in the taglist
-window. If you wish to disable this (for example, when you are working with a
-narrow Vim window or terminal), you can set the 'Tlist_Enable_Fold_Column'
-variable to zero.
->
- let Tlist_Enable_Fold_Column = 1
-<
- *'Tlist_Exit_OnlyWindow'*
-Tlist_Exit_OnlyWindow~
-If you want to exit Vim if only the taglist window is currently opened, then
-set the 'Tlist_Exit_OnlyWindow' variable to 1. By default, this variable is
-set to zero and the Vim instance will not be closed if only the taglist window
-is present.
->
- let Tlist_Exit_OnlyWindow = 1
-<
- *'Tlist_File_Fold_Auto_Close'*
-Tlist_File_Fold_Auto_Close~
-By default, the tags tree displayed in the taglist window for all the files is
-opened. You can close/fold the tags tree for the files manually. To
-automatically close the tags tree for inactive files, you can set the
-'Tlist_File_Fold_Auto_Close' variable to 1. When this variable is set to 1,
-the tags tree for the current buffer is automatically opened and for all the
-other buffers is closed.
->
- let Tlist_File_Fold_Auto_Close = 1
-<
- *'Tlist_GainFocus_On_ToggleOpen'*
-Tlist_GainFocus_On_ToggleOpen~
-When the taglist window is opened using the ':TlistToggle' command, this
-option controls whether the cursor is moved to the taglist window or remains
-in the current window. By default, this option is set to 0 and the cursor
-remains in the current window. When this variable is set to 1, the cursor
-moves to the taglist window after opening the taglist window.
->
- let Tlist_GainFocus_On_ToggleOpen = 1
-<
- *'Tlist_Highlight_Tag_On_BufEnter'*
-Tlist_Highlight_Tag_On_BufEnter~
-When you enter a Vim buffer/window, the current tag in that buffer/window is
-automatically highlighted in the taglist window. If the current tag name is
-not visible in the taglist window, then the taglist window contents are
-scrolled to make that tag name visible. If you like to disable the automatic
-highlighting of the current tag when entering a buffer, you can set the
-'Tlist_Highlight_Tag_On_BufEnter' variable to zero. The default setting for
-this variable is 1.
->
- let Tlist_Highlight_Tag_On_BufEnter = 0
-<
- *'Tlist_Inc_Winwidth'*
-Tlist_Inc_Winwidth~
-By default, when the width of the window is less than 100 and a new taglist
-window is opened vertically, then the window width is increased by the value
-set in the 'Tlist_WinWidth' variable to accommodate the new window. The value
-of this variable is used only if you are using a vertically split taglist
-window.
-
-If your terminal doesn't support changing the window width from Vim (older
-version of xterm running in a Unix system) or if you see any weird problems in
-the screen due to the change in the window width or if you prefer not to
-adjust the window width then set the 'Tlist_Inc_Winwidth' variable to zero.
-CAUTION: If you are using the MS-Windows version of Vim in a MS-DOS command
-window then you must set this variable to zero, otherwise the system may hang
-due to a Vim limitation (explained in :help win32-problems)
->
- let Tlist_Inc_Winwidth = 0
-<
- *'Tlist_Max_Submenu_Items'*
-Tlist_Max_Submenu_Items~
-If a file contains too many tags of a particular type (function, variable,
-class, etc.), greater than that specified by the 'Tlist_Max_Submenu_Items'
-variable, then the menu for that tag type will be split into multiple
-sub-menus. The default setting for the 'Tlist_Max_Submenu_Items' variable is
-25. This can be changed by setting the 'Tlist_Max_Submenu_Items' variable:
->
- let Tlist_Max_Submenu_Items = 20
-<
-The name of the submenu is formed using the names of the first and the last
-tag entries in that submenu.
-
- *'Tlist_Max_Tag_Length'*
-Tlist_Max_Tag_Length~
-Only the first 'Tlist_Max_Tag_Length' characters from the tag names will be
-used to form the tag type submenu name. The default value for this variable is
-10. Change the 'Tlist_Max_Tag_Length' setting if you want to include more or
-less characters:
->
- let Tlist_Max_Tag_Length = 10
-<
- *'Tlist_Process_File_Always'*
-Tlist_Process_File_Always~
-By default, the taglist plugin will generate and process the tags defined in
-the newly opened files only when the taglist window is opened or when the
-taglist menu is enabled. When the taglist window is closed, the taglist plugin
-will stop processing the tags for newly opened files.
-
-You can set the 'Tlist_Process_File_Always' variable to 1 to generate the list
-of tags for new files even when the taglist window is closed and the taglist
-menu is disabled.
->
- let Tlist_Process_File_Always = 1
-<
-To use the ":TlistShowTag" and the ":TlistShowPrototype" commands without the
-taglist window and the taglist menu, you should set this variable to 1.
-
- *'Tlist_Show_Menu'*
-Tlist_Show_Menu~
-When using GUI Vim, you can display the tags defined in the current file in a
-menu named "Tags". By default, this feature is turned off. To turn on this
-feature, set the 'Tlist_Show_Menu' variable to 1:
->
- let Tlist_Show_Menu = 1
-<
- *'Tlist_Show_One_File'*
-Tlist_Show_One_File~
-By default, the taglist plugin will display the tags defined in all the loaded
-buffers in the taglist window. If you prefer to display the tags defined only
-in the current buffer, then you can set the 'Tlist_Show_One_File' to 1. When
-this variable is set to 1, as you switch between buffers, the taglist window
-will be refreshed to display the tags for the current buffer and the tags for
-the previous buffer will be removed.
->
- let Tlist_Show_One_File = 1
-<
- *'Tlist_Sort_Type'*
-Tlist_Sort_Type~
-The 'Tlist_Sort_Type' variable specifies the sort order for the tags in the
-taglist window. The tags can be sorted either alphabetically by their name or
-by the order of their appearance in the file (chronological order). By
-default, the tag names will be listed by the order in which they are defined
-in the file. You can change the sort type (from name to order or from order to
-name) by pressing the "s" key in the taglist window. You can also change the
-default sort order by setting 'Tlist_Sort_Type' to "name" or "order":
->
- let Tlist_Sort_Type = "name"
-<
- *'Tlist_Use_Horiz_Window'*
-Tlist_Use_Horiz_Window~
-Be default, the tag names are displayed in a vertically split window. If you
-prefer a horizontally split window, then set the 'Tlist_Use_Horiz_Window'
-variable to 1. If you are running MS-Windows version of Vim in a MS-DOS
-command window, then you should use a horizontally split window instead of a
-vertically split window. Also, if you are using an older version of xterm in a
-Unix system that doesn't support changing the xterm window width, you should
-use a horizontally split window.
->
- let Tlist_Use_Horiz_Window = 1
-<
- *'Tlist_Use_Right_Window'*
-Tlist_Use_Right_Window~
-By default, the vertically split taglist window will appear on the left hand
-side. If you prefer to open the window on the right hand side, you can set the
-'Tlist_Use_Right_Window' variable to 1:
->
- let Tlist_Use_Right_Window = 1
-<
- *'Tlist_Use_SingleClick'*
-Tlist_Use_SingleClick~
-By default, when you double click on the tag name using the left mouse
-button, the cursor will be positioned at the definition of the tag. You
-can set the 'Tlist_Use_SingleClick' variable to 1 to jump to a tag when
-you single click on the tag name using the mouse. By default this variable
-is set to zero.
->
- let Tlist_Use_SingleClick = 1
-<
-Due to a bug in Vim, if you set 'Tlist_Use_SingleClick' to 1 and try to resize
-the taglist window using the mouse, then Vim will crash. This problem is fixed
-in Vim 6.3 and above. In the meantime, instead of resizing the taglist window
-using the mouse, you can use normal Vim window resizing commands to resize the
-taglist window.
-
- *'Tlist_WinHeight'*
-Tlist_WinHeight~
-The default height of the horizontally split taglist window is 10. This can be
-changed by modifying the 'Tlist_WinHeight' variable:
->
- let Tlist_WinHeight = 20
-<
-The |'winfixheight'| option is set for the taglist window, to maintain the
-height of the taglist window, when new Vim windows are opened and existing
-windows are closed.
-
- *'Tlist_WinWidth'*
-Tlist_WinWidth~
-The default width of the vertically split taglist window is 30. This can be
-changed by modifying the 'Tlist_WinWidth' variable:
->
- let Tlist_WinWidth = 20
-<
-Note that the value of the |'winwidth'| option setting determines the minimum
-width of the current window. If you set the 'Tlist_WinWidth' variable to a
-value less than that of the |'winwidth'| option setting, then Vim will use the
-value of the |'winwidth'| option.
-
-When new Vim windows are opened and existing windows are closed, the taglist
-plugin will try to maintain the width of the taglist window to the size
-specified by the 'Tlist_WinWidth' variable.
-
-==============================================================================
- *taglist-commands*
-7. Commands~
-
-The taglist plugin provides the following ex-mode commands:
-
-|:TlistAddFiles| Add multiple files to the taglist.
-|:TlistAddFilesRecursive|
- Add files recursively to the taglist.
-|:TlistClose| Close the taglist window.
-|:TlistDebug| Start logging of taglist debug messages.
-|:TlistLock| Stop adding new files to the taglist.
-|:TlistMessages| Display the logged taglist plugin debug messages.
-|:TlistOpen| Open and jump to the taglist window.
-|:TlistSessionSave| Save the information about files and tags in the
- taglist to a session file.
-|:TlistSessionLoad| Load the information about files and tags stored
- in a session file to taglist.
-|:TlistShowPrototype| Display the prototype of the tag at or before the
- specified line number.
-|:TlistShowTag| Display the name of the tag defined at or before the
- specified line number.
-|:TlistHighlightTag| Highlight the current tag in the taglist window.
-|:TlistToggle| Open or close (toggle) the taglist window.
-|:TlistUndebug| Stop logging of taglist debug messages.
-|:TlistUnlock| Start adding new files to the taglist.
-|:TlistUpdate| Update the tags for the current buffer.
-
- *:TlistAddFiles*
-:TlistAddFiles {file(s)} [file(s) ...]
- Add one or more specified files to the taglist. You can
- specify multiple filenames using wildcards. To specify a
- file name with space character, you should escape the space
- character with a backslash.
- Examples:
->
- :TlistAddFiles *.c *.cpp
- :TlistAddFiles file1.html file2.html
-<
- If you specify a large number of files, then it will take some
- time for the taglist plugin to process all of them. The
- specified files will not be edited in a Vim window and will
- not be added to the Vim buffer list.
-
- *:TlistAddFilesRecursive*
-:TlistAddFilesRecursive {directory} [ {pattern} ]
- Add files matching {pattern} recursively from the specified
- {directory} to the taglist. If {pattern} is not specified,
- then '*' is assumed. To specify the current directory, use "."
- for {directory}. To specify a directory name with space
- character, you should escape the space character with a
- backslash.
- Examples:
->
- :TlistAddFilesRecursive myproject *.java
- :TlistAddFilesRecursive smallproject
-<
- If large number of files are present in the specified
- directory tree, then it will take some time for the taglist
- plugin to process all of them.
-
- *:TlistClose*
-:TlistClose Close the taglist window. This command can be used from any
- one of the Vim windows.
-
- *:TlistDebug*
-:TlistDebug [filename]
- Start logging of debug messages from the taglist plugin.
- If {filename} is specified, then the debug messages are stored
- in the specified file. Otherwise, the debug messages are
- stored in a script local variable. If the file {filename} is
- already present, then it is overwritten.
-
- *:TlistLock*
-:TlistLock
- Lock the taglist and don't process new files. After this
- command is executed, newly edited files will not be added to
- the taglist.
-
- *:TlistMessages*
-:TlistMessages
- Display the logged debug messages from the taglist plugin
- in a window. This command works only when logging to a
- script-local variable.
-
- *:TlistOpen*
-:TlistOpen Open and jump to the taglist window. Creates the taglist
- window, if the window is not opened currently. After executing
- this command, the cursor is moved to the taglist window. When
- the taglist window is opened for the first time, all the files
- in the buffer list are processed and the tags defined in them
- are displayed in the taglist window.
-
- *:TlistSessionSave*
-:TlistSessionSave {filename}
- Saves the information about files and tags in the taglist to
- the specified file. This command can be used to save and
- restore the taglist contents across Vim sessions.
-
- *:TlistSessionLoad*
-:TlistSessionLoad {filename}
- Load the information about files and tags stored in the
- specified session file to the taglist.
-
- *:TlistShowPrototype*
-:TlistShowPrototype [filename] [linenumber]
- Display the prototype of the tag at or before the specified
- line number. If the file name and the line number are not
- specified, then the current file name and line number are
- used. A tag spans multiple lines starting from the line where
- it is defined to the line before the next tag. This command
- displays the prototype for the tag for any line number in this
- range.
-
- *:TlistShowTag*
-:TlistShowTag [filename] [linenumber]
- Display the name of the tag defined at or before the specified
- line number. If the file name and the line number are not
- specified, then the current file name and line number are
- used. A tag spans multiple lines starting from the line where
- it is defined to the line before the next tag. This command
- displays the tag name for any line number in this range.
-
- *:TlistHighlightTag*
-:TlistHighlightTag
- Highlight the current tag in the taglist window. By default,
- the taglist plugin periodically updates the taglist window to
- highlight the current tag. This command can be used to force
- the taglist plugin to highlight the current tag.
-
- *:TlistToggle*
-:TlistToggle Open or close (toggle) the taglist window. Opens the taglist
- window, if the window is not opened currently. Closes the
- taglist window, if the taglist window is already opened. When
- the taglist window is opened for the first time, all the files
- in the buffer list are processed and the tags are displayed in
- the taglist window. After executing this command, the cursor
- is not moved from the current window to the taglist window.
-
- *:TlistUndebug*
-:TlistUndebug
- Stop logging of debug messages from the taglist plugin.
-
- *:TlistUnlock*
-:TlistUnlock
- Unlock the taglist and start processing newly edited files.
-
- *:TlistUpdate*
-:TlistUpdate Update the tags information for the current buffer. This
- command can be used to re-process the current file/buffer and
- get the tags information. As the taglist plugin uses the file
- saved in the disk (instead of the file displayed in a Vim
- buffer), you should save a modified buffer before you update
- the taglist. Otherwise the listed tags will not include the
- new tags created in the buffer. You can use this command even
- when the taglist window is not opened.
-
-==============================================================================
- *taglist-functions*
-8. Global functions~
-
-The taglist plugin provides several global functions that can be used from
-other Vim plugins to interact with the taglist plugin. These functions are
-described below.
-
-|Tlist_Update_File_Tags()| Update the tags for the specified file
-|Tlist_Get_Tag_Prototype_By_Line()| Return the prototype of the tag at or
- before the specified line number in the
- specified file.
-|Tlist_Get_Tagname_By_Line()| Return the name of the tag at or
- before the specified line number in
- the specified file.
-|Tlist_Set_App()| Set the name of the application
- controlling the taglist window.
-
- *Tlist_Update_File_Tags()*
-Tlist_Update_File_Tags({filename}, {filetype})
- Update the tags for the file {filename}. The second argument
- specifies the Vim filetype for the file. If the taglist plugin
- has not processed the file previously, then the exuberant
- ctags tool is invoked to generate the tags for the file.
-
- *Tlist_Get_Tag_Prototype_By_Line()*
-Tlist_Get_Tag_Prototype_By_Line([{filename}, {linenumber}])
- Return the prototype of the tag at or before the specified
- line number in the specified file. If the filename and line
- number are not specified, then the current buffer name and the
- current line number are used.
-
- *Tlist_Get_Tagname_By_Line()*
-Tlist_Get_Tagname_By_Line([{filename}, {linenumber}])
- Return the name of the tag at or before the specified line
- number in the specified file. If the filename and line number
- are not specified, then the current buffer name and the
- current line number are used.
-
- *Tlist_Set_App()*
-Tlist_Set_App({appname})
- Set the name of the plugin that controls the taglist plugin
- window and buffer. This can be used to integrate the taglist
- plugin with other Vim plugins.
-
- For example, the winmanager plugin and the Cream package use
- this function and specify the appname as "winmanager" and
- "cream" respectively.
-
- By default, the taglist plugin is a stand-alone plugin and
- controls the taglist window and buffer. If the taglist window
- is controlled by an external plugin, then the appname should
- be set appropriately.
-
-==============================================================================
- *taglist-extend*
-9. Extending~
-
-The taglist plugin supports all the languages supported by the exuberant ctags
-tool, which includes the following languages: Assembly, ASP, Awk, Beta, C,
-C++, C#, Cobol, Eiffel, Erlang, Fortran, HTML, Java, Javascript, Lisp, Lua,
-Make, Pascal, Perl, PHP, Python, Rexx, Ruby, Scheme, Shell, Slang, SML, Sql,
-TCL, Verilog, Vim and Yacc.
-
-You can extend the taglist plugin to add support for new languages and also
-modify the support for the above listed languages.
-
-You should NOT make modifications to the taglist plugin script file to add
-support for new languages. You will lose these changes when you upgrade to the
-next version of the taglist plugin. Instead you should follow the below
-described instructions to extend the taglist plugin.
-
-You can extend the taglist plugin by setting variables in the .vimrc or _vimrc
-file. The name of these variables depends on the language name and is
-described below.
-
-Modifying support for an existing language~
-To modify the support for an already supported language, you have to set the
-tlist_xxx_settings variable in the ~/.vimrc or $HOME/_vimrc file. Replace xxx
-with the Vim filetype name for the language file. For example, to modify the
-support for the perl language files, you have to set the tlist_perl_settings
-variable. To modify the support for java files, you have to set the
-tlist_java_settings variable.
-
-To determine the filetype name used by Vim for a file, use the following
-command in the buffer containing the file:
-
- :set filetype
-
-The above command will display the Vim filetype for the current buffer.
-
-The format of the value set in the tlist_xxx_settings variable is
-
- <language_name>;flag1:name1;flag2:name2;flag3:name3
-
-The different fields in the value are separated by the ';' character.
-
-The first field 'language_name' is the name used by exuberant ctags to refer
-to this language file. This name can be different from the file type name used
-by Vim. For example, for C++, the language name used by ctags is 'c++' but the
-filetype name used by Vim is 'cpp'. To get the list of language names
-supported by exuberant ctags, use the following command:
-
- $ ctags --list-maps=all
-
-The remaining fields follow the format "flag:name". The sub-field 'flag' is
-the language specific flag used by exuberant ctags to generate the
-corresponding tags. For example, for the C language, to list only the
-functions, the 'f' flag is used. To get the list of flags supported by
-exuberant ctags for the various languages use the following command:
-
- $ ctags --list-kinds=all
-
-The sub-field 'name' specifies the title text to use for displaying the tags
-of a particular type. For example, 'name' can be set to 'functions'. This
-field can be set to any text string name.
-
-For example, to list only the classes and functions defined in a C++ language
-file, add the following line to your .vimrc file:
-
- let tlist_cpp_settings = 'c++;c:class;f:function'
-
-In the above setting, 'cpp' is the Vim filetype name and 'c++' is the name
-used by the exuberant ctags tool. 'c' and 'f' are the flags passed to
-exuberant ctags to list C++ classes and functions and 'class' is the title
-used for the class tags and 'function' is the title used for the function tags
-in the taglist window.
-
-For example, to display only functions defined in a C file and to use "My
-Functions" as the title for the function tags, use
-
- let tlist_c_settings = 'c;f:My Functions'
-
-When you set the tlist_xxx_settings variable, you will override the default
-setting used by the taglist plugin for the 'xxx' language. You cannot add to
-the default options used by the taglist plugin for a particular file type. To
-add to the options used by the taglist plugin for a language, copy the option
-values from the taglist plugin file to your .vimrc file and modify it.
-
-Adding support for a new language~
-If you want to add support for a new language to the taglist plugin, you need
-to first extend the exuberant ctags tool. For more information about extending
-exuberant ctags, visit the following page:
-
- http://ctags.sourceforge.net/EXTENDING.html
-
-To add support for a new language, set the tlist_xxx_settings variable in the
-~/.vimrc file appropriately as described above. Replace 'xxx' in the variable
-name with the Vim filetype name for the new language.
-
-For example, to extend the taglist plugin to support the latex language, you
-can use the following line (assuming, you have already extended exuberant
-ctags to support the latex language):
-
- let tlist_tex_settings='latex;b:bibitem;c:command;l:label'
-
-With the above line, when you edit files of filetype "tex" in Vim, the taglist
-plugin will invoke the exuberant ctags tool passing the "latex" filetype and
-the flags b, c and l to generate the tags. The text heading 'bibitem',
-'command' and 'label' will be used in the taglist window for the tags which
-are generated for the flags b, c and l respectively.
-
-==============================================================================
- *taglist-faq*
-10. Frequently Asked Questions~
-
-Q. The taglist plugin doesn't work. The taglist window is empty and the tags
- defined in a file are not displayed.
-A. Are you using Vim version 6.0 and above? The taglist plugin relies on the
- features supported by Vim version 6.0 and above. You can use the following
- command to get the Vim version:
->
- $ vim --version
-<
- Are you using exuberant ctags version 5.0 and above? The taglist plugin
- relies on the features supported by exuberant ctags and will not work with
- GNU ctags or the Unix ctags utility. You can use the following command to
- determine whether the ctags installed in your system is exuberant ctags:
->
- $ ctags --version
-<
- Is exuberant ctags present in one of the directories in your PATH? If not,
- you need to set the Tlist_Ctags_Cmd variable to point to the location of
- exuberant ctags. Use the following Vim command to verify that this is setup
- correctly:
->
- :echo system(Tlist_Ctags_Cmd . ' --version')
-<
- The above command should display the version information for exuberant
- ctags.
-
- Did you turn on the Vim filetype detection? The taglist plugin relies on
- the filetype detected by Vim and passes the filetype to the exuberant ctags
- utility to parse the tags. Check the output of the following Vim command:
->
- :filetype
-<
- The output of the above command should contain "filetype detection:ON".
- To turn on the filetype detection, add the following line to the .vimrc or
- _vimrc file:
->
- filetype on
-<
- Is your version of Vim compiled with the support for the system() function?
- The following Vim command should display 1:
->
- :echo exists('*system')
-<
- In some Linux distributions (particularly Suse Linux), the default Vim
- installation is built without the support for the system() function. The
- taglist plugin uses the system() function to invoke the exuberant ctags
- utility. You need to rebuild Vim after enabling the support for the
- system() function. If you use the default build options, the system()
- function will be supported.
-
- Do you have the |'shellslash'| option set? You can try disabling the
- |'shellslash'| option. When the taglist plugin invokes the exuberant ctags
- utility with the path to the file, if the incorrect slashes are used, then
- you will see errors.
-
- Check the shell related Vim options values using the following command:
->
- :set shell? shellcmdflag? shellpipe?
- :set shellquote? shellredir? shellxquote?
-<
- If these options are set in your .vimrc or _vimrc file, try removing those
- lines.
-
- Are you using a Unix shell in a MS-Windows environment? For example,
- the Unix shell from the MKS-toolkit. Do you have the SHELL environment
- set to point to this shell? You can try resetting the SHELL environment
- variable.
-
- If you are using a Unix shell on MS-Windows, you should try to use
- exuberant ctags that is compiled for Unix-like environments so that
- exuberant ctags will understand path names with forward slash characters.
-
- Is your filetype supported by the exuberant ctags utility? The file types
- supported by the exuberant ctags utility are listed in the ctags help. If a
- file type is not supported, you have to extend exuberant ctags. You can use
- the following command to list the filetypes supported by exuberant ctags:
->
- ctags --list-languages
-<
- Run the following command from the shell prompt and check whether the tags
- defined in your file are listed in the output from exuberant ctags:
->
- ctags -f - --format=2 --excmd=pattern --fields=nks <filename>
-<
- If you see your tags in the output from the above command, then the
- exuberant ctags utility is properly parsing your file.
-
- Do you have the .ctags or _ctags or the ctags.cnf file in your home
- directory for specifying default options or for extending exuberant ctags?
- If you do have this file, check the options in this file and make sure
- these options are not interfering with the operation of the taglist plugin.
-
- If you are using MS-Windows, check the value of the TEMP and TMP
- environment variables. If these environment variables are set to a path
- with space characters in the name, then try using the DOS 8.3 short name
- for the path or set them to a path without the space characters in the
- name. For example, if the temporary directory name is "C:\Documents and
- Settings\xyz\Local Settings\Temp", then try setting the TEMP variable to
- the following:
->
- set TEMP=C:\DOCUMEN~1\xyz\LOCALS~1\Temp
-<
- If exuberant ctags is installed in a directory with space characters in the
- name, then try adding the directory to the PATH environment variable or try
- setting the 'Tlist_Ctags_Cmd' variable to the shortest path name to ctags
- or try copying the exuberant ctags to a path without space characters in
- the name. For example, if exuberant ctags is installed in the directory
- "C:\Program Files\Ctags", then try setting the 'Tlist_Ctags_Cmd' variable
- as below:
->
- let Tlist_Ctags_Cmd='C:\Progra~1\Ctags\ctags.exe'
-<
- If you are using a cygwin compiled version of exuberant ctags on MS-Windows,
- make sure that either you have the cygwin compiled sort utility installed
- and available in your PATH or compile exuberant ctags with internal sort
- support. Otherwise, when exuberant ctags sorts the tags output by invoking
- the sort utility, it may end up invoking the MS-Windows version of
- sort.exe, thereby resulting in failure.
-
-Q. When I try to open the taglist window, I am seeing the following error
- message. How do I fix this problem?
-
- Taglist: Failed to generate tags for /my/path/to/file
- ctags: illegal option -- -^@usage: ctags [-BFadtuwvx] [-f tagsfile] file ...
-
-A. The taglist plugin will work only with the exuberant ctags tool. You
- cannot use the GNU ctags or the Unix ctags program with the taglist plugin.
- You will see an error message similar to the one shown above, if you try
- use a non-exuberant ctags program with Vim. To fix this problem, either add
- the exuberant ctags tool location to the PATH environment variable or set
- the 'Tlist_Ctags_Cmd' variable.
-
-Q. A file has more than one tag with the same name. When I select a tag name
- from the taglist window, the cursor is positioned at the incorrect tag
- location.
-A. The taglist plugin uses the search pattern generated by the exuberant ctags
- utility to position the cursor at the location of a tag definition. If a
- file has more than one tag with the same name and same prototype, then the
- search pattern will be the same. In this case, when searching for the tag
- pattern, the cursor may be positioned at the incorrect location.
-
-Q. I have made some modifications to my file and introduced new
- functions/classes/variables. I have not yet saved my file. The taglist
- plugin is not displaying the new tags when I update the taglist window.
-A. The exuberant ctags utility will process only files that are present in the
- disk. To list the tags defined in a file, you have to save the file and
- then update the taglist window.
-
-Q. I have created a ctags file using the exuberant ctags utility for my source
- tree. How do I configure the taglist plugin to use this tags file?
-A. The taglist plugin doesn't use a tags file stored in disk. For every opened
- file, the taglist plugin invokes the exuberant ctags utility to get the
- list of tags dynamically. The Vim system() function is used to invoke
- exuberant ctags and get the ctags output. This function internally uses a
- temporary file to store the output. This file is deleted after the output
- from the command is read. So you will never see the file that contains the
- output of exuberant ctags.
-
-Q. When I set the |'updatetime'| option to a low value (less than 1000) and if
- I keep pressing a key with the taglist window open, the current buffer
- contents are changed. Why is this?
-A. The taglist plugin uses the |CursorHold| autocmd to highlight the current
- tag. The CursorHold autocmd triggers for every |'updatetime'| milliseconds.
- If the |'updatetime'| option is set to a low value, then the CursorHold
- autocmd will be triggered frequently. As the taglist plugin changes
- the focus to the taglist window to highlight the current tag, this could
- interfere with the key movement resulting in changing the contents of
- the current buffer. The workaround for this problem is to not set the
- |'updatetime'| option to a low value.
-
-==============================================================================
- *taglist-license*
-11. License~
-Permission is hereby granted to use and distribute the taglist plugin, 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.
-
-==============================================================================
- *taglist-todo*
-12. Todo~
-
-1. Group tags according to the scope and display them. For example,
- group all the tags belonging to a C++/Java class
-2. Support for displaying tags in a modified (not-yet-saved) file.
-3. Automatically open the taglist window only for selected filetypes.
- For other filetypes, close the taglist window.
-4. When using the shell from the MKS toolkit, the taglist plugin
- doesn't work.
-5. The taglist plugin doesn't work with files edited remotely using the
- netrw plugin. The exuberant ctags utility cannot process files over
- scp/rcp/ftp, etc.
-
-==============================================================================
-
-vim:tw=78:ts=8:noet:ft=help:
diff --git a/vim/doc/tags b/vim/doc/tags
index 3acbc55..7bf5699 100644
--- a/vim/doc/tags
+++ b/vim/doc/tags
@@ -1,72 +1,7 @@
-'NERDChristmasTree' NERD_tree.txt /*'NERDChristmasTree'*
-'NERDTreeAutoCenter' NERD_tree.txt /*'NERDTreeAutoCenter'*
-'NERDTreeAutoCenterThreshold' NERD_tree.txt /*'NERDTreeAutoCenterThreshold'*
-'NERDTreeBookmarksFile' NERD_tree.txt /*'NERDTreeBookmarksFile'*
-'NERDTreeCaseSensitiveSort' NERD_tree.txt /*'NERDTreeCaseSensitiveSort'*
-'NERDTreeChDirMode' NERD_tree.txt /*'NERDTreeChDirMode'*
-'NERDTreeHighlightCursorline' NERD_tree.txt /*'NERDTreeHighlightCursorline'*
-'NERDTreeHijackNetrw' NERD_tree.txt /*'NERDTreeHijackNetrw'*
-'NERDTreeIgnore' NERD_tree.txt /*'NERDTreeIgnore'*
-'NERDTreeMouseMode' NERD_tree.txt /*'NERDTreeMouseMode'*
-'NERDTreeQuitOnOpen' NERD_tree.txt /*'NERDTreeQuitOnOpen'*
-'NERDTreeShowBookmarks' NERD_tree.txt /*'NERDTreeShowBookmarks'*
-'NERDTreeShowFiles' NERD_tree.txt /*'NERDTreeShowFiles'*
-'NERDTreeShowHidden' NERD_tree.txt /*'NERDTreeShowHidden'*
-'NERDTreeShowLineNumbers' NERD_tree.txt /*'NERDTreeShowLineNumbers'*
-'NERDTreeSortOrder' NERD_tree.txt /*'NERDTreeSortOrder'*
-'NERDTreeWinPos' NERD_tree.txt /*'NERDTreeWinPos'*
-'NERDTreeWinSize' NERD_tree.txt /*'NERDTreeWinSize'*
-'Tlist_Auto_Highlight_Tag' taglist.txt /*'Tlist_Auto_Highlight_Tag'*
-'Tlist_Auto_Open' taglist.txt /*'Tlist_Auto_Open'*
-'Tlist_Auto_Update' taglist.txt /*'Tlist_Auto_Update'*
-'Tlist_Close_On_Select' taglist.txt /*'Tlist_Close_On_Select'*
-'Tlist_Compact_Format' taglist.txt /*'Tlist_Compact_Format'*
-'Tlist_Ctags_Cmd' taglist.txt /*'Tlist_Ctags_Cmd'*
-'Tlist_Display_Prototype' taglist.txt /*'Tlist_Display_Prototype'*
-'Tlist_Display_Tag_Scope' taglist.txt /*'Tlist_Display_Tag_Scope'*
-'Tlist_Enable_Fold_Column' taglist.txt /*'Tlist_Enable_Fold_Column'*
-'Tlist_Exit_OnlyWindow' taglist.txt /*'Tlist_Exit_OnlyWindow'*
-'Tlist_File_Fold_Auto_Close' taglist.txt /*'Tlist_File_Fold_Auto_Close'*
-'Tlist_GainFocus_On_ToggleOpen' taglist.txt /*'Tlist_GainFocus_On_ToggleOpen'*
-'Tlist_Highlight_Tag_On_BufEnter' taglist.txt /*'Tlist_Highlight_Tag_On_BufEnter'*
-'Tlist_Inc_Winwidth' taglist.txt /*'Tlist_Inc_Winwidth'*
-'Tlist_Max_Submenu_Items' taglist.txt /*'Tlist_Max_Submenu_Items'*
-'Tlist_Max_Tag_Length' taglist.txt /*'Tlist_Max_Tag_Length'*
-'Tlist_Process_File_Always' taglist.txt /*'Tlist_Process_File_Always'*
-'Tlist_Show_Menu' taglist.txt /*'Tlist_Show_Menu'*
-'Tlist_Show_One_File' taglist.txt /*'Tlist_Show_One_File'*
-'Tlist_Sort_Type' taglist.txt /*'Tlist_Sort_Type'*
-'Tlist_Use_Horiz_Window' taglist.txt /*'Tlist_Use_Horiz_Window'*
-'Tlist_Use_Right_Window' taglist.txt /*'Tlist_Use_Right_Window'*
-'Tlist_Use_SingleClick' taglist.txt /*'Tlist_Use_SingleClick'*
-'Tlist_WinHeight' taglist.txt /*'Tlist_WinHeight'*
-'Tlist_WinWidth' taglist.txt /*'Tlist_WinWidth'*
-'loaded_nerd_tree' NERD_tree.txt /*'loaded_nerd_tree'*
'snippets' snipMate.txt /*'snippets'*
.snippet snipMate.txt /*.snippet*
.snippets snipMate.txt /*.snippets*
:MatchDebug matchit.txt /*:MatchDebug*
-:NERDTree NERD_tree.txt /*:NERDTree*
-:NERDTreeClose NERD_tree.txt /*:NERDTreeClose*
-:NERDTreeFromBookmark NERD_tree.txt /*:NERDTreeFromBookmark*
-:NERDTreeMirror NERD_tree.txt /*:NERDTreeMirror*
-:NERDTreeToggle NERD_tree.txt /*:NERDTreeToggle*
-:TlistAddFiles taglist.txt /*:TlistAddFiles*
-:TlistAddFilesRecursive taglist.txt /*:TlistAddFilesRecursive*
-:TlistClose taglist.txt /*:TlistClose*
-:TlistDebug taglist.txt /*:TlistDebug*
-:TlistHighlightTag taglist.txt /*:TlistHighlightTag*
-:TlistLock taglist.txt /*:TlistLock*
-:TlistMessages taglist.txt /*:TlistMessages*
-:TlistOpen taglist.txt /*:TlistOpen*
-:TlistSessionLoad taglist.txt /*:TlistSessionLoad*
-:TlistSessionSave taglist.txt /*:TlistSessionSave*
-:TlistShowPrototype taglist.txt /*:TlistShowPrototype*
-:TlistShowTag taglist.txt /*:TlistShowTag*
-:TlistToggle taglist.txt /*:TlistToggle*
-:TlistUndebug taglist.txt /*:TlistUndebug*
-:TlistUnlock taglist.txt /*:TlistUnlock*
-:TlistUpdate taglist.txt /*:TlistUpdate*
EnhComm-Bugs EnhancedCommentify.txt /*EnhComm-Bugs*
EnhComm-Credits EnhancedCommentify.txt /*EnhComm-Credits*
EnhComm-EnhCommentify EnhancedCommentify.txt /*EnhComm-EnhCommentify*
@@ -81,61 +16,7 @@ ExtractSnips() snipMate.txt /*ExtractSnips()*
ExtractSnipsFile() snipMate.txt /*ExtractSnipsFile()*
Filename() snipMate.txt /*Filename()*
MatchError matchit.txt /*MatchError*
-NERDTree NERD_tree.txt /*NERDTree*
-NERDTree-! NERD_tree.txt /*NERDTree-!*
-NERDTree-? NERD_tree.txt /*NERDTree-?*
-NERDTree-B NERD_tree.txt /*NERDTree-B*
-NERDTree-C NERD_tree.txt /*NERDTree-C*
-NERDTree-D NERD_tree.txt /*NERDTree-D*
-NERDTree-F NERD_tree.txt /*NERDTree-F*
-NERDTree-I NERD_tree.txt /*NERDTree-I*
-NERDTree-J NERD_tree.txt /*NERDTree-J*
-NERDTree-K NERD_tree.txt /*NERDTree-K*
-NERDTree-O NERD_tree.txt /*NERDTree-O*
-NERDTree-P NERD_tree.txt /*NERDTree-P*
-NERDTree-R NERD_tree.txt /*NERDTree-R*
-NERDTree-T NERD_tree.txt /*NERDTree-T*
-NERDTree-U NERD_tree.txt /*NERDTree-U*
-NERDTree-X NERD_tree.txt /*NERDTree-X*
-NERDTree-c-j NERD_tree.txt /*NERDTree-c-j*
-NERDTree-c-k NERD_tree.txt /*NERDTree-c-k*
-NERDTree-contents NERD_tree.txt /*NERDTree-contents*
-NERDTree-e NERD_tree.txt /*NERDTree-e*
-NERDTree-f NERD_tree.txt /*NERDTree-f*
-NERDTree-gi NERD_tree.txt /*NERDTree-gi*
-NERDTree-go NERD_tree.txt /*NERDTree-go*
-NERDTree-i NERD_tree.txt /*NERDTree-i*
-NERDTree-m NERD_tree.txt /*NERDTree-m*
-NERDTree-o NERD_tree.txt /*NERDTree-o*
-NERDTree-p NERD_tree.txt /*NERDTree-p*
-NERDTree-q NERD_tree.txt /*NERDTree-q*
-NERDTree-r NERD_tree.txt /*NERDTree-r*
-NERDTree-t NERD_tree.txt /*NERDTree-t*
-NERDTree-u NERD_tree.txt /*NERDTree-u*
-NERDTree-x NERD_tree.txt /*NERDTree-x*
-NERDTreeAuthor NERD_tree.txt /*NERDTreeAuthor*
-NERDTreeBookmarkCommands NERD_tree.txt /*NERDTreeBookmarkCommands*
-NERDTreeBookmarkTable NERD_tree.txt /*NERDTreeBookmarkTable*
-NERDTreeBookmarks NERD_tree.txt /*NERDTreeBookmarks*
-NERDTreeChangelog NERD_tree.txt /*NERDTreeChangelog*
-NERDTreeCredits NERD_tree.txt /*NERDTreeCredits*
-NERDTreeFilesysMenu NERD_tree.txt /*NERDTreeFilesysMenu*
-NERDTreeFunctionality NERD_tree.txt /*NERDTreeFunctionality*
-NERDTreeGlobalCommands NERD_tree.txt /*NERDTreeGlobalCommands*
-NERDTreeHacking NERD_tree.txt /*NERDTreeHacking*
-NERDTreeInvalidBookmarks NERD_tree.txt /*NERDTreeInvalidBookmarks*
-NERDTreeLicense NERD_tree.txt /*NERDTreeLicense*
-NERDTreeMappings NERD_tree.txt /*NERDTreeMappings*
-NERDTreeOptionDetails NERD_tree.txt /*NERDTreeOptionDetails*
-NERDTreeOptionSummary NERD_tree.txt /*NERDTreeOptionSummary*
-NERDTreeOptions NERD_tree.txt /*NERDTreeOptions*
-NERDTreeTodo NERD_tree.txt /*NERDTreeTodo*
-NERD_tree.txt NERD_tree.txt /*NERD_tree.txt*
ResetSnippets() snipMate.txt /*ResetSnippets()*
-Tlist_Get_Tag_Prototype_By_Line() taglist.txt /*Tlist_Get_Tag_Prototype_By_Line()*
-Tlist_Get_Tagname_By_Line() taglist.txt /*Tlist_Get_Tagname_By_Line()*
-Tlist_Set_App() taglist.txt /*Tlist_Set_App()*
-Tlist_Update_File_Tags() taglist.txt /*Tlist_Update_File_Tags()*
[% matchit.txt /*[%*
]% matchit.txt /*]%*
b:match_col matchit.txt /*b:match_col*
@@ -151,47 +32,10 @@ b:match_tail matchit.txt /*b:match_tail*
b:match_wholeBR matchit.txt /*b:match_wholeBR*
b:match_word matchit.txt /*b:match_word*
b:match_words matchit.txt /*b:match_words*
-cs surround.txt /*cs*
-ds surround.txt /*ds*
ft-gitcommit-plugin ft-gitcommit-plugin.txt /*ft-gitcommit-plugin*
-fugitive fugitive.txt /*fugitive*
-fugitive-:Gblame fugitive.txt /*fugitive-:Gblame*
-fugitive-:Gcd fugitive.txt /*fugitive-:Gcd*
-fugitive-:Gdiff fugitive.txt /*fugitive-:Gdiff*
-fugitive-:Ge fugitive.txt /*fugitive-:Ge*
-fugitive-:Gedit fugitive.txt /*fugitive-:Gedit*
-fugitive-:Ggrep fugitive.txt /*fugitive-:Ggrep*
-fugitive-:Git fugitive.txt /*fugitive-:Git*
-fugitive-:Glcd fugitive.txt /*fugitive-:Glcd*
-fugitive-:Glog fugitive.txt /*fugitive-:Glog*
-fugitive-:Gmove fugitive.txt /*fugitive-:Gmove*
-fugitive-:Gpedit fugitive.txt /*fugitive-:Gpedit*
-fugitive-:Gread fugitive.txt /*fugitive-:Gread*
-fugitive-:Gread! fugitive.txt /*fugitive-:Gread!*
-fugitive-:Gremove fugitive.txt /*fugitive-:Gremove*
-fugitive-:Gsplit fugitive.txt /*fugitive-:Gsplit*
-fugitive-:Gstatus fugitive.txt /*fugitive-:Gstatus*
-fugitive-:Gtabedit fugitive.txt /*fugitive-:Gtabedit*
-fugitive-:Gvsplit fugitive.txt /*fugitive-:Gvsplit*
-fugitive-:Gwrite fugitive.txt /*fugitive-:Gwrite*
-fugitive-<CR> fugitive.txt /*fugitive-<CR>*
-fugitive-C fugitive.txt /*fugitive-C*
-fugitive-O fugitive.txt /*fugitive-O*
-fugitive-P fugitive.txt /*fugitive-P*
-fugitive-a fugitive.txt /*fugitive-a*
-fugitive-about fugitive.txt /*fugitive-about*
-fugitive-author fugitive.txt /*fugitive-author*
-fugitive-commands fugitive.txt /*fugitive-commands*
-fugitive-mappings fugitive.txt /*fugitive-mappings*
-fugitive-o fugitive.txt /*fugitive-o*
-fugitive-revision fugitive.txt /*fugitive-revision*
-fugitive-~ fugitive.txt /*fugitive-~*
-fugitive.txt fugitive.txt /*fugitive.txt*
g% matchit.txt /*g%*
g:snippets_dir snipMate.txt /*g:snippets_dir*
g:snips_author snipMate.txt /*g:snips_author*
-i_CTRL-G_S surround.txt /*i_CTRL-G_S*
-i_CTRL-G_s surround.txt /*i_CTRL-G_s*
i_CTRL-R_<Tab> snipMate.txt /*i_CTRL-R_<Tab>*
list-snippets snipMate.txt /*list-snippets*
matchit matchit.txt /*matchit*
@@ -244,37 +88,7 @@ snipMate.txt snipMate.txt /*snipMate.txt*
snippet snipMate.txt /*snippet*
snippet-syntax snipMate.txt /*snippet-syntax*
snippets snipMate.txt /*snippets*
-surround surround.txt /*surround*
-surround-author surround.txt /*surround-author*
-surround-customizing surround.txt /*surround-customizing*
-surround-issues surround.txt /*surround-issues*
-surround-mappings surround.txt /*surround-mappings*
-surround-replacements surround.txt /*surround-replacements*
-surround-targets surround.txt /*surround-targets*
-surround.txt surround.txt /*surround.txt*
-taglist-commands taglist.txt /*taglist-commands*
-taglist-debug taglist.txt /*taglist-debug*
-taglist-extend taglist.txt /*taglist-extend*
-taglist-faq taglist.txt /*taglist-faq*
-taglist-functions taglist.txt /*taglist-functions*
-taglist-install taglist.txt /*taglist-install*
-taglist-internet taglist.txt /*taglist-internet*
-taglist-intro taglist.txt /*taglist-intro*
-taglist-keys taglist.txt /*taglist-keys*
-taglist-license taglist.txt /*taglist-license*
-taglist-menu taglist.txt /*taglist-menu*
-taglist-options taglist.txt /*taglist-options*
-taglist-requirements taglist.txt /*taglist-requirements*
-taglist-session taglist.txt /*taglist-session*
-taglist-todo taglist.txt /*taglist-todo*
-taglist-using taglist.txt /*taglist-using*
-taglist.txt taglist.txt /*taglist.txt*
v_[% matchit.txt /*v_[%*
v_]% matchit.txt /*v_]%*
v_a% matchit.txt /*v_a%*
v_g% matchit.txt /*v_g%*
-vs surround.txt /*vs*
-yS surround.txt /*yS*
-ySS surround.txt /*ySS*
-ys surround.txt /*ys*
-yss surround.txt /*yss*
diff --git a/vim/plugin/NERD_tree.vim b/vim/plugin/NERD_tree.vim
deleted file mode 100644
index 67d2a80..0000000
--- a/vim/plugin/NERD_tree.vim
+++ /dev/null
@@ -1,3733 +0,0 @@
-" ============================================================================
-" File: NERD_tree.vim
-" Description: vim global plugin that provides a nice tree explorer
-" Maintainer: Martin Grenfell <martin_grenfell at msn dot com>
-" Last Change: 29 December, 2008
-" License: This program is free software. It comes without any warranty,
-" to the extent permitted by applicable law. You can redistribute
-" it and/or modify it under the terms of the Do What The Fuck You
-" Want To Public License, Version 2, as published by Sam Hocevar.
-" See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" ============================================================================
-let s:NERD_tree_version = '3.0.0'
-
-" SECTION: Script init stuff {{{1
-"============================================================
-if exists("loaded_nerd_tree")
- finish
-endif
-if v:version < 700
- echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!"
- finish
-endif
-let loaded_nerd_tree = 1
-
-"for line continuation - i.e dont want C in &cpo
-let s:old_cpo = &cpo
-set cpo&vim
-
-"Function: s:initVariable() function {{{2
-"This function is used to initialise a given variable to a given value. The
-"variable is only initialised if it does not exist prior
-"
-"Args:
-"var: the name of the var to be initialised
-"value: the value to initialise var to
-"
-"Returns:
-"1 if the var is set, 0 otherwise
-function! s:initVariable(var, value)
- if !exists(a:var)
- exec 'let ' . a:var . ' = ' . "'" . a:value . "'"
- return 1
- endif
- return 0
-endfunction
-
-"SECTION: Init variable calls and other random constants {{{2
-call s:initVariable("g:NERDChristmasTree", 1)
-call s:initVariable("g:NERDTreeAutoCenter", 1)
-call s:initVariable("g:NERDTreeAutoCenterThreshold", 3)
-call s:initVariable("g:NERDTreeCaseSensitiveSort", 0)
-call s:initVariable("g:NERDTreeChDirMode", 0)
-if !exists("g:NERDTreeIgnore")
- let g:NERDTreeIgnore = ['\~$']
-endif
-call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
-call s:initVariable("g:NERDTreeHighlightCursorline", 1)
-call s:initVariable("g:NERDTreeHijackNetrw", 1)
-call s:initVariable("g:NERDTreeMouseMode", 1)
-call s:initVariable("g:NERDTreeNotificationThreshold", 100)
-call s:initVariable("g:NERDTreeQuitOnOpen", 0)
-call s:initVariable("g:NERDTreeShowBookmarks", 0)
-call s:initVariable("g:NERDTreeShowFiles", 1)
-call s:initVariable("g:NERDTreeShowHidden", 0)
-call s:initVariable("g:NERDTreeShowLineNumbers", 0)
-call s:initVariable("g:NERDTreeSortDirs", 1)
-
-if !exists("g:NERDTreeSortOrder")
- let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$', '\.bak$', '\~$']
-else
- "if there isnt a * in the sort sequence then add one
- if count(g:NERDTreeSortOrder, '*') < 1
- call add(g:NERDTreeSortOrder, '*')
- endif
-endif
-
-"we need to use this number many times for sorting... so we calculate it only
-"once here
-let s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*')
-
-call s:initVariable("g:NERDTreeWinPos", "left")
-call s:initVariable("g:NERDTreeWinSize", 31)
-
-let s:running_windows = has("win16") || has("win32") || has("win64")
-
-"init the shell commands that will be used to copy nodes, and remove dir trees
-"
-"Note: the space after the command is important
-if s:running_windows
- call s:initVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
-else
- call s:initVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
- call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ')
-endif
-
-
-"SECTION: Init variable calls for key mappings {{{2
-call s:initVariable("g:NERDTreeMapActivateNode", "o")
-call s:initVariable("g:NERDTreeMapChangeRoot", "C")
-call s:initVariable("g:NERDTreeMapChdir", "cd")
-call s:initVariable("g:NERDTreeMapCloseChildren", "X")
-call s:initVariable("g:NERDTreeMapCloseDir", "x")
-call s:initVariable("g:NERDTreeMapDeleteBookmark", "D")
-call s:initVariable("g:NERDTreeMapExecute", "!")
-call s:initVariable("g:NERDTreeMapFilesystemMenu", "m")
-call s:initVariable("g:NERDTreeMapHelp", "?")
-call s:initVariable("g:NERDTreeMapJumpFirstChild", "K")
-call s:initVariable("g:NERDTreeMapJumpLastChild", "J")
-call s:initVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
-call s:initVariable("g:NERDTreeMapJumpParent", "p")
-call s:initVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
-call s:initVariable("g:NERDTreeMapJumpRoot", "P")
-call s:initVariable("g:NERDTreeMapOpenExpl", "e")
-call s:initVariable("g:NERDTreeMapOpenInTab", "t")
-call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T")
-call s:initVariable("g:NERDTreeMapOpenRecursively", "O")
-call s:initVariable("g:NERDTreeMapOpenSplit", "i")
-call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
-call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
-call s:initVariable("g:NERDTreeMapQuit", "q")
-call s:initVariable("g:NERDTreeMapRefresh", "r")
-call s:initVariable("g:NERDTreeMapRefreshRoot", "R")
-call s:initVariable("g:NERDTreeMapToggleBookmarks", "B")
-call s:initVariable("g:NERDTreeMapToggleFiles", "F")
-call s:initVariable("g:NERDTreeMapToggleFilters", "f")
-call s:initVariable("g:NERDTreeMapToggleHidden", "I")
-call s:initVariable("g:NERDTreeMapUpdir", "u")
-call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
-
-"SECTION: Script level variable declaration{{{2
-let s:escape_chars = " \\`\|\"#%&,?()\*^<>"
-let s:NERDTreeBufName = 'NERD_tree_'
-
-let s:tree_wid = 2
-let s:tree_markup_reg = '^[ `|]*[\-+~]'
-let s:tree_up_dir_line = '.. (up a dir)'
-
-let s:os_slash = '/'
-if s:running_windows
- let s:os_slash = '\'
-endif
-
-"the number to add to the nerd tree buffer name to make the buf name unique
-let s:next_buffer_number = 1
-
-" SECTION: Commands {{{1
-"============================================================
-"init the command that users start the nerd tree with
-command! -n=? -complete=dir NERDTree :call s:initNerdTree('<args>')
-command! -n=? -complete=dir NERDTreeToggle :call s:toggle('<args>')
-command! -n=0 NERDTreeClose :call s:closeTreeIfOpen()
-command! -n=1 -complete=customlist,s:completeBookmarks NERDTreeFromBookmark call s:initNerdTree('<args>')
-command! -n=0 -complete=customlist,s:completeNERDTreeMirrors NERDTreeMirror call s:initNerdTreeMirror()
-" SECTION: Auto commands {{{1
-"============================================================
-augroup NERDTree
- "Save the cursor position whenever we close the nerd tree
- exec "autocmd BufWinLeave *". s:NERDTreeBufName ." call <SID>saveScreenState()"
- "cache bookmarks when vim loads
- autocmd VimEnter * call s:Bookmark.CacheBookmarks(0)
-augroup END
-
-if g:NERDTreeHijackNetrw
- augroup NERDTreeHijackNetrw
- autocmd VimEnter * silent! autocmd! FileExplorer
- au BufEnter * call s:checkForBrowse(expand("<amatch>"))
- augroup END
-endif
-
-"SECTION: Classes {{{1
-"============================================================
-"CLASS: Bookmark {{{2
-"============================================================
-let s:Bookmark = {}
-" FUNCTION: Bookmark.AddBookmark(name, path) {{{3
-" Class method to add a new bookmark to the list, if a previous bookmark exists
-" with the same name, just update the path for that bookmark
-function! s:Bookmark.AddBookmark(name, path)
- for i in s:Bookmark.Bookmarks()
- if i.name == a:name
- let i.path = a:path
- return
- endif
- endfor
- call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path))
- call s:Bookmark.Sort()
-endfunction
-" Function: Bookmark.Bookmarks() {{{3
-" Class method to get all bookmarks. Lazily initializes the bookmarks global
-" variable
-function! s:Bookmark.Bookmarks()
- if !exists("g:NERDTreeBookmarks")
- let g:NERDTreeBookmarks = []
- endif
- return g:NERDTreeBookmarks
-endfunction
-" Function: Bookmark.BookmarkExistsFor(name) {{{3
-" class method that returns 1 if a bookmark with the given name is found, 0
-" otherwise
-function! s:Bookmark.BookmarkExistsFor(name)
- try
- call s:Bookmark.BookmarkFor(a:name)
- return 1
- catch /^NERDTree.BookmarkNotFoundError/
- return 0
- endtry
-endfunction
-" Function: Bookmark.BookmarkFor(name) {{{3
-" Class method to get the bookmark that has the given name. {} is return if no
-" bookmark is found
-function! s:Bookmark.BookmarkFor(name)
- for i in s:Bookmark.Bookmarks()
- if i.name == a:name
- return i
- endif
- endfor
- throw "NERDTree.BookmarkNotFoundError: no bookmark found for name: \"". a:name .'"'
-endfunction
-" Function: Bookmark.BookmarkNames() {{{3
-" Class method to return an array of all bookmark names
-function! s:Bookmark.BookmarkNames()
- let names = []
- for i in s:Bookmark.Bookmarks()
- call add(names, i.name)
- endfor
- return names
-endfunction
-" FUNCTION: Bookmark.CacheBookmarks(silent) {{{3
-" Class method to read all bookmarks from the bookmarks file intialize
-" bookmark objects for each one.
-"
-" Args:
-" silent - dont echo an error msg if invalid bookmarks are found
-function! s:Bookmark.CacheBookmarks(silent)
- if filereadable(g:NERDTreeBookmarksFile)
- let g:NERDTreeBookmarks = []
- let g:NERDTreeInvalidBookmarks = []
- let bookmarkStrings = readfile(g:NERDTreeBookmarksFile)
- let invalidBookmarksFound = 0
- for i in bookmarkStrings
-
- "ignore blank lines
- if i != ''
-
- let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
- let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
-
- try
- let bookmark = s:Bookmark.New(name, s:Path.New(path))
- call add(g:NERDTreeBookmarks, bookmark)
- catch /^NERDTree.InvalidArgumentsError/
- call add(g:NERDTreeInvalidBookmarks, i)
- let invalidBookmarksFound += 1
- endtry
- endif
- endfor
- if invalidBookmarksFound
- call s:Bookmark.Write()
- if !a:silent
- call s:echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.")
- endif
- endif
- call s:Bookmark.Sort()
- endif
-endfunction
-" FUNCTION: Bookmark.compareTo(otherbookmark) {{{3
-" Compare these two bookmarks for sorting purposes
-function! s:Bookmark.compareTo(otherbookmark)
- return a:otherbookmark.name < self.name
-endfunction
-" FUNCTION: Bookmark.ClearAll() {{{3
-" Class method to delete all bookmarks.
-function! s:Bookmark.ClearAll()
- for i in s:Bookmark.Bookmarks()
- call i.delete()
- endfor
- call s:Bookmark.Write()
-endfunction
-" FUNCTION: Bookmark.delete() {{{3
-" Delete this bookmark. If the node for this bookmark is under the current
-" root, then recache bookmarks for its Path object
-function! s:Bookmark.delete()
- let node = {}
- try
- let node = self.getNode(1)
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- endtry
- call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self))
- if !empty(node)
- call node.path.cacheDisplayString()
- endif
- call s:Bookmark.Write()
-endfunction
-" FUNCTION: Bookmark.getNode(searchFromAbsoluteRoot) {{{3
-" Gets the treenode for this bookmark
-"
-" Args:
-" searchFromAbsoluteRoot: specifies whether we should search from the current
-" tree root, or the highest cached node
-function! s:Bookmark.getNode(searchFromAbsoluteRoot)
- let searchRoot = a:searchFromAbsoluteRoot ? s:TreeDirNode.AbsoluteTreeRoot() : b:NERDTreeRoot
- let targetNode = searchRoot.findNode(self.path)
- if empty(targetNode)
- throw "NERDTree.BookmarkedNodeNotFoundError: no node was found for bookmark: " . self.name
- endif
- return targetNode
-endfunction
-" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{3
-" Class method that finds the bookmark with the given name and returns the
-" treenode for it.
-function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot)
- let bookmark = s:Bookmark.BookmarkFor(a:name)
- return bookmark.getNode(a:searchFromAbsoluteRoot)
-endfunction
-" Function: Bookmark.InvalidBookmarks() {{{3
-" Class method to get all invalid bookmark strings read from the bookmarks
-" file
-function! s:Bookmark.InvalidBookmarks()
- if !exists("g:NERDTreeInvalidBookmarks")
- let g:NERDTreeInvalidBookmarks = []
- endif
- return g:NERDTreeInvalidBookmarks
-endfunction
-" FUNCTION: Bookmark.mustExist() {{{3
-function! s:Bookmark.mustExist()
- if !self.path.exists()
- call s:Bookmark.CacheBookmarks(1)
- throw "NERDTree.BookmarkPointsToInvalidLocationError: the bookmark \"".
- \ self.name ."\" points to a non existing location: \"". self.path.strForOS(0)
- endif
-endfunction
-" FUNCTION: Bookmark.New(name, path) {{{3
-" Create a new bookmark object with the given name and path object
-function! s:Bookmark.New(name, path)
- if a:name =~ ' '
- throw "NERDTree.IllegalBookmarkNameError: illegal name:" . a:name
- endif
-
- let newBookmark = copy(self)
- let newBookmark.name = a:name
- let newBookmark.path = a:path
- return newBookmark
-endfunction
-" Function: Bookmark.setPath(path) {{{3
-" makes this bookmark point to the given path
-function! s:Bookmark.setPath(path)
- let self.path = a:path
-endfunction
-" Function: Bookmark.Sort() {{{3
-" Class method that sorts all bookmarks
-function! s:Bookmark.Sort()
- let CompareFunc = function("s:compareBookmarks")
- call sort(s:Bookmark.Bookmarks(), CompareFunc)
-endfunction
-" Function: Bookmark.str() {{{3
-" Get the string that should be rendered in the view for this bookmark
-function! s:Bookmark.str()
- let pathStrMaxLen = winwidth(s:getTreeWinNum()) - 4 - len(self.name)
- if &nu
- let pathStrMaxLen = pathStrMaxLen - &numberwidth
- endif
-
- let pathStr = self.path.strForOS(0)
- if len(pathStr) > pathStrMaxLen
- let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen)
- endif
- return '>' . self.name . ' ' . pathStr
-endfunction
-" FUNCTION: Bookmark.toRoot() {{{3
-" Make the node for this bookmark the new tree root
-function! s:Bookmark.toRoot()
- if self.validate()
- try
- let targetNode = self.getNode(1)
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- let targetNode = s:TreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path)
- endtry
- call targetNode.makeRoot()
- call s:renderView()
- call s:putCursorOnNode(targetNode, 0, 0)
- endif
-endfunction
-" FUNCTION: Bookmark.ToRoot(name) {{{3
-" Make the node for this bookmark the new tree root
-function! s:Bookmark.ToRoot(name)
- let bookmark = s:Bookmark.BookmarkFor(a:name)
- call bookmark.toRoot()
-endfunction
-
-
-"FUNCTION: Bookmark.validate() {{{3
-function! s:Bookmark.validate()
- if self.path.exists()
- return 1
- else
- call s:Bookmark.CacheBookmarks(1)
- call s:renderView()
- call s:echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.")
- return 0
- endif
-endfunction
-
-" Function: Bookmark.Write() {{{3
-" Class method to write all bookmarks to the bookmarks file
-function! s:Bookmark.Write()
- let bookmarkStrings = []
- for i in s:Bookmark.Bookmarks()
- call add(bookmarkStrings, i.name . ' ' . i.path.strForOS(0))
- endfor
-
- "add a blank line before the invalid ones
- call add(bookmarkStrings, "")
-
- for j in s:Bookmark.InvalidBookmarks()
- call add(bookmarkStrings, j)
- endfor
- call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
-endfunction
-"CLASS: TreeFileNode {{{2
-"This class is the parent of the TreeDirNode class and constitures the
-"'Component' part of the composite design pattern between the treenode
-"classes.
-"============================================================
-let s:TreeFileNode = {}
-"FUNCTION: TreeFileNode.bookmark(name) {{{3
-"bookmark this node with a:name
-function! s:TreeFileNode.bookmark(name)
- try
- let oldMarkedNode = s:Bookmark.GetNodeForName(a:name, 1)
- call oldMarkedNode.path.cacheDisplayString()
- catch /^NERDTree.BookmarkNotFoundError/
- endtry
-
- call s:Bookmark.AddBookmark(a:name, self.path)
- call self.path.cacheDisplayString()
- call s:Bookmark.Write()
-endfunction
-"FUNCTION: TreeFileNode.cacheParent() {{{3
-"initializes self.parent if it isnt already
-function! s:TreeFileNode.cacheParent()
- if empty(self.parent)
- let parentPath = self.path.getParent()
- if parentPath.equals(self.path)
- throw "NERDTree.CannotCacheParentError: already at root"
- endif
- let self.parent = s:TreeFileNode.New(parentPath)
- endif
-endfunction
-"FUNCTION: TreeFileNode.compareNodes {{{3
-"This is supposed to be a class level method but i cant figure out how to
-"get func refs to work from a dict..
-"
-"A class level method that compares two nodes
-"
-"Args:
-"n1, n2: the 2 nodes to compare
-function! s:compareNodes(n1, n2)
- return a:n1.path.compareTo(a:n2.path)
-endfunction
-
-"FUNCTION: TreeFileNode.clearBoomarks() {{{3
-function! s:TreeFileNode.clearBoomarks()
- for i in s:Bookmark.Bookmarks()
- if i.path.equals(self.path)
- call i.delete()
- end
- endfor
- call self.path.cacheDisplayString()
-endfunction
-"FUNCTION: TreeFileNode.copy(dest) {{{3
-function! s:TreeFileNode.copy(dest)
- call self.path.copy(a:dest)
- let newPath = s:Path.New(a:dest)
- let parent = b:NERDTreeRoot.findNode(newPath.getParent())
- if !empty(parent)
- call parent.refresh()
- endif
- return parent.findNode(newPath)
-endfunction
-
-"FUNCTION: TreeFileNode.delete {{{3
-"Removes this node from the tree and calls the Delete method for its path obj
-function! s:TreeFileNode.delete()
- call self.path.delete()
- call self.parent.removeChild(self)
-endfunction
-
-"FUNCTION: TreeFileNode.equals(treenode) {{{3
-"
-"Compares this treenode to the input treenode and returns 1 if they are the
-"same node.
-"
-"Use this method instead of == because sometimes when the treenodes contain
-"many children, vim seg faults when doing ==
-"
-"Args:
-"treenode: the other treenode to compare to
-function! s:TreeFileNode.equals(treenode)
- return self.path.str(1) == a:treenode.path.str(1)
-endfunction
-
-"FUNCTION: TreeFileNode.findNode(path) {{{3
-"Returns self if this node.path.Equals the given path.
-"Returns {} if not equal.
-"
-"Args:
-"path: the path object to compare against
-function! s:TreeFileNode.findNode(path)
- if a:path.equals(self.path)
- return self
- endif
- return {}
-endfunction
-"FUNCTION: TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) {{{3
-"
-"Finds the next sibling for this node in the indicated direction. This sibling
-"must be a directory and may/may not have children as specified.
-"
-"Args:
-"direction: 0 if you want to find the previous sibling, 1 for the next sibling
-"
-"Return:
-"a treenode object or {} if no appropriate sibling could be found
-function! s:TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction)
- "if we have no parent then we can have no siblings
- if self.parent != {}
- let nextSibling = self.findSibling(a:direction)
-
- while nextSibling != {}
- if nextSibling.path.isDirectory && nextSibling.hasVisibleChildren() && nextSibling.isOpen
- return nextSibling
- endif
- let nextSibling = nextSibling.findSibling(a:direction)
- endwhile
- endif
-
- return {}
-endfunction
-"FUNCTION: TreeFileNode.findSibling(direction) {{{3
-"
-"Finds the next sibling for this node in the indicated direction
-"
-"Args:
-"direction: 0 if you want to find the previous sibling, 1 for the next sibling
-"
-"Return:
-"a treenode object or {} if no sibling could be found
-function! s:TreeFileNode.findSibling(direction)
- "if we have no parent then we can have no siblings
- if self.parent != {}
-
- "get the index of this node in its parents children
- let siblingIndx = self.parent.getChildIndex(self.path)
-
- if siblingIndx != -1
- "move a long to the next potential sibling node
- let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
-
- "keep moving along to the next sibling till we find one that is valid
- let numSiblings = self.parent.getChildCount()
- while siblingIndx >= 0 && siblingIndx < numSiblings
-
- "if the next node is not an ignored node (i.e. wont show up in the
- "view) then return it
- if self.parent.children[siblingIndx].path.ignore() == 0
- return self.parent.children[siblingIndx]
- endif
-
- "go to next node
- let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
- endwhile
- endif
- endif
-
- return {}
-endfunction
-
-"FUNCTION: TreeFileNode.isVisible() {{{3
-"returns 1 if this node should be visible according to the tree filters and
-"hidden file filters (and their on/off status)
-function! s:TreeFileNode.isVisible()
- return !self.path.ignore()
-endfunction
-
-
-"FUNCTION: TreeFileNode.isRoot() {{{3
-"returns 1 if this node is b:NERDTreeRoot
-function! s:TreeFileNode.isRoot()
- if !s:treeExistsForBuf()
- throw "NERDTree.NoTreeError: No tree exists for the current buffer"
- endif
-
- return self.equals(b:NERDTreeRoot)
-endfunction
-
-"FUNCTION: TreeFileNode.makeRoot() {{{3
-"Make this node the root of the tree
-function! s:TreeFileNode.makeRoot()
- if self.path.isDirectory
- let b:NERDTreeRoot = self
- else
- call self.cacheParent()
- let b:NERDTreeRoot = self.parent
- endif
-
- call b:NERDTreeRoot.open()
-
- "change dir to the dir of the new root if instructed to
- if g:NERDTreeChDirMode == 2
- exec "cd " . b:NERDTreeRoot.path.strForEditCmd()
- endif
-endfunction
-"FUNCTION: TreeFileNode.New(path) {{{3
-"Returns a new TreeNode object with the given path and parent
-"
-"Args:
-"path: a path object representing the full filesystem path to the file/dir that the node represents
-function! s:TreeFileNode.New(path)
- if a:path.isDirectory
- return s:TreeDirNode.New(a:path)
- else
- let newTreeNode = {}
- let newTreeNode = copy(self)
- let newTreeNode.path = a:path
- let newTreeNode.parent = {}
- return newTreeNode
- endif
-endfunction
-
-"FUNCTION: TreeFileNode.refresh() {{{3
-function! s:TreeFileNode.refresh()
- call self.path.refresh()
-endfunction
-"FUNCTION: TreeFileNode.rename() {{{3
-"Calls the rename method for this nodes path obj
-function! s:TreeFileNode.rename(newName)
- let newName = substitute(a:newName, '\(\\\|\/\)$', '', '')
- call self.path.rename(newName)
- call self.parent.removeChild(self)
-
- let parentPath = self.path.getPathTrunk()
- let newParent = b:NERDTreeRoot.findNode(parentPath)
-
- if newParent != {}
- call newParent.createChild(self.path, 1)
- call newParent.refresh()
- endif
-endfunction
-"FUNCTION: TreeFileNode.strDisplay() {{{3
-"
-"Returns a string that specifies how the node should be represented as a
-"string
-"
-"Return:
-"a string that can be used in the view to represent this node
-function! s:TreeFileNode.strDisplay()
- return self.path.strDisplay()
-endfunction
-
-"CLASS: TreeDirNode {{{2
-"This class is a child of the TreeFileNode class and constitutes the
-"'Composite' part of the composite design pattern between the treenode
-"classes.
-"============================================================
-let s:TreeDirNode = copy(s:TreeFileNode)
-"FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{3
-"class method that returns the highest cached ancestor of the current root
-function! s:TreeDirNode.AbsoluteTreeRoot()
- let currentNode = b:NERDTreeRoot
- while currentNode.parent != {}
- let currentNode = currentNode.parent
- endwhile
- return currentNode
-endfunction
-"FUNCTION: TreeDirNode.addChild(treenode, inOrder) {{{3
-"Adds the given treenode to the list of children for this node
-"
-"Args:
-"-treenode: the node to add
-"-inOrder: 1 if the new node should be inserted in sorted order
-function! s:TreeDirNode.addChild(treenode, inOrder)
- call add(self.children, a:treenode)
- let a:treenode.parent = self
-
- if a:inOrder
- call self.sortChildren()
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.close() {{{3
-"Closes this directory
-function! s:TreeDirNode.close()
- let self.isOpen = 0
-endfunction
-
-"FUNCTION: TreeDirNode.closeChildren() {{{3
-"Closes all the child dir nodes of this node
-function! s:TreeDirNode.closeChildren()
- for i in self.children
- if i.path.isDirectory
- call i.close()
- call i.closeChildren()
- endif
- endfor
-endfunction
-
-"FUNCTION: TreeDirNode.createChild(path, inOrder) {{{3
-"Instantiates a new child node for this node with the given path. The new
-"nodes parent is set to this node.
-"
-"Args:
-"path: a Path object that this node will represent/contain
-"inOrder: 1 if the new node should be inserted in sorted order
-"
-"Returns:
-"the newly created node
-function! s:TreeDirNode.createChild(path, inOrder)
- let newTreeNode = s:TreeFileNode.New(a:path)
- call self.addChild(newTreeNode, a:inOrder)
- return newTreeNode
-endfunction
-
-"FUNCTION: TreeDirNode.findNode(path) {{{3
-"Will find one of the children (recursively) that has the given path
-"
-"Args:
-"path: a path object
-unlet s:TreeDirNode.findNode
-function! s:TreeDirNode.findNode(path)
- if a:path.equals(self.path)
- return self
- endif
- if stridx(a:path.str(1), self.path.str(1), 0) == -1
- return {}
- endif
-
- if self.path.isDirectory
- for i in self.children
- let retVal = i.findNode(a:path)
- if retVal != {}
- return retVal
- endif
- endfor
- endif
- return {}
-endfunction
-"FUNCTION: TreeDirNode.getChildCount() {{{3
-"Returns the number of children this node has
-function! s:TreeDirNode.getChildCount()
- return len(self.children)
-endfunction
-
-"FUNCTION: TreeDirNode.getChild(path) {{{3
-"Returns child node of this node that has the given path or {} if no such node
-"exists.
-"
-"This function doesnt not recurse into child dir nodes
-"
-"Args:
-"path: a path object
-function! s:TreeDirNode.getChild(path)
- if stridx(a:path.str(1), self.path.str(1), 0) == -1
- return {}
- endif
-
- let index = self.getChildIndex(a:path)
- if index == -1
- return {}
- else
- return self.children[index]
- endif
-
-endfunction
-
-"FUNCTION: TreeDirNode.getChildByIndex(indx, visible) {{{3
-"returns the child at the given index
-"Args:
-"indx: the index to get the child from
-"visible: 1 if only the visible children array should be used, 0 if all the
-"children should be searched.
-function! s:TreeDirNode.getChildByIndex(indx, visible)
- let array_to_search = a:visible? self.getVisibleChildren() : self.children
- if a:indx > len(array_to_search)
- throw "NERDTree.InvalidArgumentsError: Index is out of bounds."
- endif
- return array_to_search[a:indx]
-endfunction
-
-"FUNCTION: TreeDirNode.getChildIndex(path) {{{3
-"Returns the index of the child node of this node that has the given path or
-"-1 if no such node exists.
-"
-"This function doesnt not recurse into child dir nodes
-"
-"Args:
-"path: a path object
-function! s:TreeDirNode.getChildIndex(path)
- if stridx(a:path.str(1), self.path.str(1), 0) == -1
- return -1
- endif
-
- "do a binary search for the child
- let a = 0
- let z = self.getChildCount()
- while a < z
- let mid = (a+z)/2
- let diff = a:path.compareTo(self.children[mid].path)
-
- if diff == -1
- let z = mid
- elseif diff == 1
- let a = mid+1
- else
- return mid
- endif
- endwhile
- return -1
-endfunction
-
-"FUNCTION: TreeDirNode.getVisibleChildCount() {{{3
-"Returns the number of visible children this node has
-function! s:TreeDirNode.getVisibleChildCount()
- return len(self.getVisibleChildren())
-endfunction
-
-"FUNCTION: TreeDirNode.getVisibleChildren() {{{3
-"Returns a list of children to display for this node, in the correct order
-"
-"Return:
-"an array of treenodes
-function! s:TreeDirNode.getVisibleChildren()
- let toReturn = []
- for i in self.children
- if i.path.ignore() == 0
- call add(toReturn, i)
- endif
- endfor
- return toReturn
-endfunction
-
-"FUNCTION: TreeDirNode.hasVisibleChildren() {{{3
-"returns 1 if this node has any childre, 0 otherwise..
-function! s:TreeDirNode.hasVisibleChildren()
- return self.getVisibleChildCount() != 0
-endfunction
-
-"FUNCTION: TreeDirNode._initChildren() {{{3
-"Removes all childen from this node and re-reads them
-"
-"Args:
-"silent: 1 if the function should not echo any "please wait" messages for
-"large directories
-"
-"Return: the number of child nodes read
-function! s:TreeDirNode._initChildren(silent)
- "remove all the current child nodes
- let self.children = []
-
- "get an array of all the files in the nodes dir
- let dir = self.path
- let filesStr = globpath(dir.strForGlob(), '*') . "\n" . globpath(dir.strForGlob(), '.*')
- let files = split(filesStr, "\n")
-
- if !a:silent && len(files) > g:NERDTreeNotificationThreshold
- call s:echo("Please wait, caching a large dir ...")
- endif
-
- let invalidFilesFound = 0
- for i in files
-
- "filter out the .. and . directories
- "Note: we must match .. AND ../ cos sometimes the globpath returns
- "../ for path with strange chars (eg $)
- if i !~ '\.\.\/\?$' && i !~ '\.\/\?$'
-
- "put the next file in a new node and attach it
- try
- let path = s:Path.New(i)
- call self.createChild(path, 0)
- catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/
- let invalidFilesFound += 1
- endtry
- endif
- endfor
-
- call self.sortChildren()
-
- if !a:silent && len(files) > g:NERDTreeNotificationThreshold
- call s:echo("Please wait, caching a large dir ... DONE (". self.getChildCount() ." nodes cached).")
- endif
-
- if invalidFilesFound
- call s:echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree")
- endif
- return self.getChildCount()
-endfunction
-"FUNCTION: TreeDirNode.New(path) {{{3
-"Returns a new TreeNode object with the given path and parent
-"
-"Args:
-"path: a path object representing the full filesystem path to the file/dir that the node represents
-unlet s:TreeDirNode.New
-function! s:TreeDirNode.New(path)
- if a:path.isDirectory != 1
- throw "NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object."
- endif
-
- let newTreeNode = copy(self)
- let newTreeNode.path = a:path
-
- let newTreeNode.isOpen = 0
- let newTreeNode.children = []
-
- let newTreeNode.parent = {}
-
- return newTreeNode
-endfunction
-"FUNCTION: TreeDirNode.open() {{{3
-"Reads in all this nodes children
-"
-"Return: the number of child nodes read
-function! s:TreeDirNode.open()
- let self.isOpen = 1
- if self.children == []
- return self._initChildren(0)
- else
- return 0
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.openRecursively() {{{3
-"Opens this treenode and all of its children whose paths arent 'ignored'
-"because of the file filters.
-"
-"This method is actually a wrapper for the OpenRecursively2 method which does
-"the work.
-function! s:TreeDirNode.openRecursively()
- call self._openRecursively2(1)
-endfunction
-
-"FUNCTION: TreeDirNode._openRecursively2() {{{3
-"Opens this all children of this treenode recursively if either:
-" *they arent filtered by file filters
-" *a:forceOpen is 1
-"
-"Args:
-"forceOpen: 1 if this node should be opened regardless of file filters
-function! s:TreeDirNode._openRecursively2(forceOpen)
- if self.path.ignore() == 0 || a:forceOpen
- let self.isOpen = 1
- if self.children == []
- call self._initChildren(1)
- endif
-
- for i in self.children
- if i.path.isDirectory == 1
- call i._openRecursively2(0)
- endif
- endfor
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.refresh() {{{3
-unlet s:TreeDirNode.refresh
-function! s:TreeDirNode.refresh()
- call self.path.refresh()
-
- "if this node was ever opened, refresh its children
- if self.isOpen || !empty(self.children)
- "go thru all the files/dirs under this node
- let newChildNodes = []
- let invalidFilesFound = 0
- let dir = self.path
- let filesStr = globpath(dir.strForGlob(), '*') . "\n" . globpath(dir.strForGlob(), '.*')
- let files = split(filesStr, "\n")
- for i in files
- if i !~ '\.\.$' && i !~ '\.$'
-
- try
- "create a new path and see if it exists in this nodes children
- let path = s:Path.New(i)
- let newNode = self.getChild(path)
- if newNode != {}
- call newNode.refresh()
- call add(newChildNodes, newNode)
-
- "the node doesnt exist so create it
- else
- let newNode = s:TreeFileNode.New(path)
- let newNode.parent = self
- call add(newChildNodes, newNode)
- endif
-
-
- catch /^NERDTree.InvalidArgumentsError/
- let invalidFilesFound = 1
- endtry
- endif
- endfor
-
- "swap this nodes children out for the children we just read/refreshed
- let self.children = newChildNodes
- call self.sortChildren()
-
- if invalidFilesFound
- call s:echoWarning("some files could not be loaded into the NERD tree")
- endif
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.removeChild(treenode) {{{3
-"
-"Removes the given treenode from this nodes set of children
-"
-"Args:
-"treenode: the node to remove
-"
-"Throws a NERDTree.ChildNotFoundError if the given treenode is not found
-function! s:TreeDirNode.removeChild(treenode)
- for i in range(0, self.getChildCount()-1)
- if self.children[i].equals(a:treenode)
- call remove(self.children, i)
- return
- endif
- endfor
-
- throw "NERDTree.ChildNotFoundError: child node was not found"
-endfunction
-
-"FUNCTION: TreeDirNode.sortChildren() {{{3
-"
-"Sorts the children of this node according to alphabetical order and the
-"directory priority.
-"
-function! s:TreeDirNode.sortChildren()
- let CompareFunc = function("s:compareNodes")
- call sort(self.children, CompareFunc)
-endfunction
-
-"FUNCTION: TreeDirNode.toggleOpen() {{{3
-"Opens this directory if it is closed and vice versa
-function! s:TreeDirNode.toggleOpen()
- if self.isOpen == 1
- call self.close()
- else
- call self.open()
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.transplantChild(newNode) {{{3
-"Replaces the child of this with the given node (where the child node's full
-"path matches a:newNode's fullpath). The search for the matching node is
-"non-recursive
-"
-"Arg:
-"newNode: the node to graft into the tree
-function! s:TreeDirNode.transplantChild(newNode)
- for i in range(0, self.getChildCount()-1)
- if self.children[i].equals(a:newNode)
- let self.children[i] = a:newNode
- let a:newNode.parent = self
- break
- endif
- endfor
-endfunction
-"============================================================
-"CLASS: Path {{{2
-"============================================================
-let s:Path = {}
-"FUNCTION: Path.bookmarkNames() {{{3
-function! s:Path.bookmarkNames()
- if !exists("self._bookmarkNames")
- call self.cacheDisplayString()
- endif
- return self._bookmarkNames
-endfunction
-"FUNCTION: Path.cacheDisplayString() {{{3
-function! s:Path.cacheDisplayString()
- let self.cachedDisplayString = self.getLastPathComponent(1)
-
- if self.isExecutable
- let self.cachedDisplayString = self.cachedDisplayString . '*'
- endif
-
- let self._bookmarkNames = []
- for i in s:Bookmark.Bookmarks()
- if i.path.equals(self)
- call add(self._bookmarkNames, i.name)
- endif
- endfor
- if !empty(self._bookmarkNames)
- let self.cachedDisplayString .= ' {' . join(self._bookmarkNames) . '}'
- endif
-
- if self.isSymLink
- let self.cachedDisplayString .= ' -> ' . self.symLinkDest
- endif
-
- if self.isReadOnly
- let self.cachedDisplayString .= ' [RO]'
- endif
-endfunction
-"FUNCTION: Path.changeToDir() {{{3
-function! s:Path.changeToDir()
- let dir = self.strForCd()
- if self.isDirectory == 0
- let dir = self.getPathTrunk().strForCd()
- endif
-
- try
- execute "cd " . dir
- call s:echo("CWD is now: " . getcwd())
- catch
- throw "NERDTree.PathChangeError: cannot change CWD to " . dir
- endtry
-endfunction
-
-"FUNCTION: Path.compareTo() {{{3
-"
-"Compares this Path to the given path and returns 0 if they are equal, -1 if
-"this Path is "less than" the given path, or 1 if it is "greater".
-"
-"Args:
-"path: the path object to compare this to
-"
-"Return:
-"1, -1 or 0
-function! s:Path.compareTo(path)
- let thisPath = self.getLastPathComponent(1)
- let thatPath = a:path.getLastPathComponent(1)
-
- "if the paths are the same then clearly we return 0
- if thisPath == thatPath
- return 0
- endif
-
- let thisSS = self.getSortOrderIndex()
- let thatSS = a:path.getSortOrderIndex()
-
- "compare the sort sequences, if they are different then the return
- "value is easy
- if thisSS < thatSS
- return -1
- elseif thisSS > thatSS
- return 1
- else
- "if the sort sequences are the same then compare the paths
- "alphabetically
- let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath <? thatPath
- if pathCompare
- return -1
- else
- return 1
- endif
- endif
-endfunction
-
-"FUNCTION: Path.Create(fullpath) {{{3
-"
-"Factory method.
-"
-"Creates a path object with the given path. The path is also created on the
-"filesystem. If the path already exists, a NERDTree.Path.Exists exception is
-"thrown. If any other errors occur, a NERDTree.Path exception is thrown.
-"
-"Args:
-"fullpath: the full filesystem path to the file/dir to create
-function! s:Path.Create(fullpath)
- "bail if the a:fullpath already exists
- if isdirectory(a:fullpath) || filereadable(a:fullpath)
- throw "NERDTree.CreatePathError: Directory Exists: '" . a:fullpath . "'"
- endif
-
- try
-
- "if it ends with a slash, assume its a dir create it
- if a:fullpath =~ '\(\\\|\/\)$'
- "whack the trailing slash off the end if it exists
- let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '')
-
- call mkdir(fullpath, 'p')
-
- "assume its a file and create
- else
- call writefile([], a:fullpath)
- endif
- catch
- throw "NERDTree.CreatePathError: Could not create path: '" . a:fullpath . "'"
- endtry
-
- return s:Path.New(a:fullpath)
-endfunction
-
-"FUNCTION: Path.copy(dest) {{{3
-"
-"Copies the file/dir represented by this Path to the given location
-"
-"Args:
-"dest: the location to copy this dir/file to
-function! s:Path.copy(dest)
- if !s:Path.CopyingSupported()
- throw "NERDTree.CopyingNotSupportedError: Copying is not supported on this OS"
- endif
-
- let dest = s:Path.WinToUnixPath(a:dest)
-
- let cmd = g:NERDTreeCopyCmd . " " . self.strForOS(0) . " " . dest
- let success = system(cmd)
- if success != 0
- throw "NERDTree.CopyError: Could not copy ''". self.strForOS(0) ."'' to: '" . a:dest . "'"
- endif
-endfunction
-
-"FUNCTION: Path.CopyingSupported() {{{3
-"
-"returns 1 if copying is supported for this OS
-function! s:Path.CopyingSupported()
- return exists('g:NERDTreeCopyCmd')
-endfunction
-
-
-"FUNCTION: Path.copyingWillOverwrite(dest) {{{3
-"
-"returns 1 if copy this path to the given location will cause files to
-"overwritten
-"
-"Args:
-"dest: the location this path will be copied to
-function! s:Path.copyingWillOverwrite(dest)
- if filereadable(a:dest)
- return 1
- endif
-
- if isdirectory(a:dest)
- let path = s:Path.JoinPathStrings(a:dest, self.getLastPathComponent(0))
- if filereadable(path)
- return 1
- endif
- endif
-endfunction
-
-"FUNCTION: Path.delete() {{{3
-"
-"Deletes the file represented by this path.
-"Deletion of directories is not supported
-"
-"Throws NERDTree.Path.Deletion exceptions
-function! s:Path.delete()
- if self.isDirectory
-
- let cmd = ""
- if s:running_windows
- "if we are runnnig windows then put quotes around the pathstring
- let cmd = g:NERDTreeRemoveDirCmd . self.strForOS(1)
- else
- let cmd = g:NERDTreeRemoveDirCmd . self.strForOS(1)
- endif
- let success = system(cmd)
-
- if v:shell_error != 0
- throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.strForOS(0) . "'"
- endif
- else
- let success = delete(self.strForOS(0))
- if success != 0
- throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str(0) . "'"
- endif
- endif
-
- "delete all bookmarks for this path
- for i in self.bookmarkNames()
- let bookmark = s:Bookmark.BookmarkFor(i)
- call bookmark.delete()
- endfor
-endfunction
-
-"FUNCTION: Path.extractDriveLetter(fullpath) {{{3
-"
-"If running windows, cache the drive letter for this path
-function! s:Path.extractDriveLetter(fullpath)
- if s:running_windows
- let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
- else
- let self.drive = ''
- endif
-
-endfunction
-"FUNCTION: Path.exists() {{{3
-"return 1 if this path points to a location that is readable or is a directory
-function! s:Path.exists()
- return filereadable(self.strForOS(0)) || isdirectory(self.strForOS(0))
-endfunction
-"FUNCTION: Path.getDir() {{{3
-"
-"Returns this path if it is a directory, else this paths parent.
-"
-"Return:
-"a Path object
-function! s:Path.getDir()
- if self.isDirectory
- return self
- else
- return self.getParent()
- endif
-endfunction
-"FUNCTION: Path.getParent() {{{3
-"
-"Returns a new path object for this paths parent
-"
-"Return:
-"a new Path object
-function! s:Path.getParent()
- let path = '/'. join(self.pathSegments[0:-2], '/')
- return s:Path.New(path)
-endfunction
-"FUNCTION: Path.getLastPathComponent(dirSlash) {{{3
-"
-"Gets the last part of this path.
-"
-"Args:
-"dirSlash: if 1 then a trailing slash will be added to the returned value for
-"directory nodes.
-function! s:Path.getLastPathComponent(dirSlash)
- if empty(self.pathSegments)
- return ''
- endif
- let toReturn = self.pathSegments[-1]
- if a:dirSlash && self.isDirectory
- let toReturn = toReturn . '/'
- endif
- return toReturn
-endfunction
-
-"FUNCTION: Path.getPathTrunk() {{{3
-"Gets the path without the last segment on the end.
-function! s:Path.getPathTrunk()
- return s:Path.New(self.strTrunk())
-endfunction
-
-"FUNCTION: Path.getSortOrderIndex() {{{3
-"returns the index of the pattern in g:NERDTreeSortOrder that this path matches
-function! s:Path.getSortOrderIndex()
- let i = 0
- while i < len(g:NERDTreeSortOrder)
- if self.getLastPathComponent(1) =~ g:NERDTreeSortOrder[i]
- return i
- endif
- let i = i + 1
- endwhile
- return s:NERDTreeSortStarIndex
-endfunction
-
-"FUNCTION: Path.ignore() {{{3
-"returns true if this path should be ignored
-function! s:Path.ignore()
- let lastPathComponent = self.getLastPathComponent(0)
-
- "filter out the user specified paths to ignore
- if b:NERDTreeIgnoreEnabled
- for i in g:NERDTreeIgnore
- if lastPathComponent =~ i
- return 1
- endif
- endfor
- endif
-
- "dont show hidden files unless instructed to
- if b:NERDTreeShowHidden == 0 && lastPathComponent =~ '^\.'
- return 1
- endif
-
- if b:NERDTreeShowFiles == 0 && self.isDirectory == 0
- return 1
- endif
-
- return 0
-endfunction
-
-"FUNCTION: Path.JoinPathStrings(...) {{{3
-function! s:Path.JoinPathStrings(...)
- let components = []
- for i in a:000
- let components = extend(components, split(i, '/'))
- endfor
- return '/' . join(components, '/')
-endfunction
-
-"FUNCTION: Path.equals() {{{3
-"
-"Determines whether 2 path objects are "equal".
-"They are equal if the paths they represent are the same
-"
-"Args:
-"path: the other path obj to compare this with
-function! s:Path.equals(path)
- return self.str(0) == a:path.str(0)
-endfunction
-
-"FUNCTION: Path.New() {{{3
-"
-"The Constructor for the Path object
-"Throws NERDTree.Path.InvalidArguments exception.
-function! s:Path.New(fullpath)
- let newPath = copy(self)
-
- call newPath.readInfoFromDisk(a:fullpath)
-
- let newPath.cachedDisplayString = ""
-
- return newPath
-endfunction
-
-"FUNCTION: Path.readInfoFromDisk(fullpath) {{{3
-"
-"
-"Throws NERDTree.Path.InvalidArguments exception.
-function! s:Path.readInfoFromDisk(fullpath)
- call self.extractDriveLetter(a:fullpath)
-
- let fullpath = s:Path.WinToUnixPath(a:fullpath)
-
- if getftype(fullpath) == "fifo"
- throw "NERDTree.InvalidFiletypeError: Cant handle FIFO files: " . a:fullpath
- endif
-
- let self.pathSegments = split(fullpath, '/')
-
-
- let self.isReadOnly = 0
- if isdirectory(a:fullpath)
- let self.isDirectory = 1
- elseif filereadable(a:fullpath)
- let self.isDirectory = 0
- let self.isReadOnly = filewritable(a:fullpath) == 0
- else
- throw "NERDTree.InvalidArgumentsError: Invalid path = " . a:fullpath
- endif
-
- let self.isExecutable = 0
- if !self.isDirectory
- let self.isExecutable = getfperm(a:fullpath) =~ 'x'
- endif
-
- "grab the last part of the path (minus the trailing slash)
- let lastPathComponent = self.getLastPathComponent(0)
-
- "get the path to the new node with the parent dir fully resolved
- let hardPath = resolve(self.strTrunk()) . '/' . lastPathComponent
-
- "if the last part of the path is a symlink then flag it as such
- let self.isSymLink = (resolve(hardPath) != hardPath)
- if self.isSymLink
- let self.symLinkDest = resolve(fullpath)
-
- "if the link is a dir then slap a / on the end of its dest
- if isdirectory(self.symLinkDest)
-
- "we always wanna treat MS windows shortcuts as files for
- "simplicity
- if hardPath !~ '\.lnk$'
-
- let self.symLinkDest = self.symLinkDest . '/'
- endif
- endif
- endif
-endfunction
-
-"FUNCTION: Path.refresh() {{{3
-function! s:Path.refresh()
- call self.readInfoFromDisk(self.strForOS(0))
- call self.cacheDisplayString()
-endfunction
-
-"FUNCTION: Path.rename() {{{3
-"
-"Renames this node on the filesystem
-function! s:Path.rename(newPath)
- if a:newPath == ''
- throw "NERDTree.InvalidArgumentsError: Invalid newPath for renaming = ". a:newPath
- endif
-
- let success = rename(self.strForOS(0), a:newPath)
- if success != 0
- throw "NERDTree.PathRenameError: Could not rename: '" . self.strForOS(0) . "'" . 'to:' . a:newPath
- endif
- call self.readInfoFromDisk(a:newPath)
-
- for i in self.bookmarkNames()
- let b = s:Bookmark.BookmarkFor(i)
- call b.setPath(copy(self))
- endfor
- call s:Bookmark.Write()
-endfunction
-
-"FUNCTION: Path.str(esc) {{{3
-"
-"Gets the actual string path that this obj represents.
-"
-"Args:
-"esc: if 1 then all the tricky chars in the returned string will be escaped
-function! s:Path.str(esc)
- let toReturn = '/' . join(self.pathSegments, '/')
- if self.isDirectory && toReturn != '/'
- let toReturn = toReturn . '/'
- endif
-
- if a:esc
- let toReturn = escape(toReturn, s:escape_chars)
- endif
- return toReturn
-endfunction
-
-"FUNCTION: Path.strAbs() {{{3
-"
-"Returns a string representing this path with all the symlinks resolved
-"
-"Return:
-"string
-function! s:Path.strAbs()
- return resolve(self.str(1))
-endfunction
-
-"FUNCTION: Path.strForCd() {{{3
-"
-" returns a string that can be used with :cd
-"
-"Return:
-"a string that can be used in the view to represent this path
-function! s:Path.strForCd()
- if s:running_windows
- return self.strForOS(0)
- else
- return self.strForOS(1)
- endif
-endfunction
-"FUNCTION: Path.strDisplay() {{{3
-"
-"Returns a string that specifies how the path should be represented as a
-"string
-"
-"Return:
-"a string that can be used in the view to represent this path
-function! s:Path.strDisplay()
- if self.cachedDisplayString == ""
- call self.cacheDisplayString()
- endif
-
- return self.cachedDisplayString
-endfunction
-
-"FUNCTION: Path.strForEditCmd() {{{3
-"
-"Return: the string for this path that is suitable to be used with the :edit
-"command
-function! s:Path.strForEditCmd()
- let p = self.str(1)
- let cwd = getcwd()
-
- if s:running_windows
- let p = tolower(self.strForOS(0))
- let cwd = tolower(getcwd())
- endif
-
- "return a relative path if we can
- if stridx(p, cwd) == 0
- let p = strpart(p, strlen(cwd)+1)
- endif
-
- if p == ''
- let p = '.'
- endif
-
- return p
-
-endfunction
-"FUNCTION: Path.strForGlob() {{{3
-function! s:Path.strForGlob()
- let lead = s:os_slash
-
- "if we are running windows then slap a drive letter on the front
- if s:running_windows
- let lead = self.drive . '\'
- endif
-
- let toReturn = lead . join(self.pathSegments, s:os_slash)
-
- if !s:running_windows
- let toReturn = escape(toReturn, s:escape_chars)
- endif
- return toReturn
-endfunction
-"FUNCTION: Path.strForOS(esc) {{{3
-"
-"Gets the string path for this path object that is appropriate for the OS.
-"EG, in windows c:\foo\bar
-" in *nix /foo/bar
-"
-"Args:
-"esc: if 1 then all the tricky chars in the returned string will be
-" escaped. If we are running windows then the str is double quoted instead.
-function! s:Path.strForOS(esc)
- let lead = s:os_slash
-
- "if we are running windows then slap a drive letter on the front
- if s:running_windows
- let lead = self.drive . '\'
- endif
-
- let toReturn = lead . join(self.pathSegments, s:os_slash)
-
- if a:esc
- if s:running_windows
- let toReturn = '"' . toReturn . '"'
- else
- let toReturn = escape(toReturn, s:escape_chars)
- endif
- endif
- return toReturn
-endfunction
-
-"FUNCTION: Path.strTrunk() {{{3
-"Gets the path without the last segment on the end.
-function! s:Path.strTrunk()
- return self.drive . '/' . join(self.pathSegments[0:-2], '/')
-endfunction
-
-"FUNCTION: Path.WinToUnixPath(pathstr){{{3
-"Takes in a windows path and returns the unix equiv
-"
-"A class level method
-"
-"Args:
-"pathstr: the windows path to convert
-function! s:Path.WinToUnixPath(pathstr)
- if !s:running_windows
- return a:pathstr
- endif
-
- let toReturn = a:pathstr
-
- "remove the x:\ of the front
- let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "")
-
- "convert all \ chars to /
- let toReturn = substitute(toReturn, '\', '/', "g")
-
- return toReturn
-endfunction
-
-" SECTION: General Functions {{{1
-"============================================================
-"FUNCTION: s:bufInWindows(bnum){{{2
-"[[STOLEN FROM VTREEEXPLORER.VIM]]
-"Determine the number of windows open to this buffer number.
-"Care of Yegappan Lakshman. Thanks!
-"
-"Args:
-"bnum: the subject buffers buffer number
-function! s:bufInWindows(bnum)
- let cnt = 0
- let winnum = 1
- while 1
- let bufnum = winbufnr(winnum)
- if bufnum < 0
- break
- endif
- if bufnum == a:bnum
- let cnt = cnt + 1
- endif
- let winnum = winnum + 1
- endwhile
-
- return cnt
-endfunction " >>>
-"FUNCTION: s:checkForBrowse(dir) {{{2
-"inits a secondary nerd tree in the current buffer if appropriate
-function! s:checkForBrowse(dir)
- if !exists("b:NERDTreeProcessed") && a:dir != '' && isdirectory(a:dir)
- let b:NERDTreeProcessed = 1
- call s:initNerdTreeInPlace(a:dir)
- endif
-endfunction
-"FUNCTION: s:compareBookmarks(first, second) {{{2
-"Compares two bookmarks
-function! s:compareBookmarks(first, second)
- return a:first.compareTo(a:second)
-endfunction
-
-" FUNCTION: s:completeBookmarks(A,L,P) {{{2
-" completion function for the bookmark commands
-function! s:completeBookmarks(A,L,P)
- return filter(s:Bookmark.BookmarkNames(), 'v:val =~ "^' . a:A . '"')
-endfunction
-" FUNCTION: s:exec(cmd) {{{2
-" same as :exec cmd but eventignore=all is set for the duration
-function! s:exec(cmd)
- let old_ei = &ei
- set ei=all
- exec a:cmd
- let &ei = old_ei
-endfunction
-"FUNCTION: s:initNerdTree(name) {{{2
-"Initialise the nerd tree for this tab. The tree will start in either the
-"given directory, or the directory associated with the given bookmark
-"
-"Args:
-"name: the name of a bookmark or a directory
-function! s:initNerdTree(name)
- let path = {}
- if s:Bookmark.BookmarkExistsFor(a:name)
- let path = s:Bookmark.BookmarkFor(a:name).path
- else
- let dir = a:name == '' ? getcwd() : a:name
-
- "hack to get an absolute path if a relative path is given
- if dir =~ '^\.'
- let dir = getcwd() . s:os_slash . dir
- endif
- let dir = resolve(dir)
-
- try
- let path = s:Path.New(dir)
- catch /^NERDTree.InvalidArgumentsError/
- call s:echo("No bookmark or directory found for: " . a:name)
- return
- endtry
- endif
- if !path.isDirectory
- let path = path.getParent()
- endif
-
- "if instructed to, then change the vim CWD to the dir the NERDTree is
- "inited in
- if g:NERDTreeChDirMode != 0
- exec 'cd ' . path.strForCd()
- endif
-
- if s:treeExistsForTab()
- if s:isTreeOpen()
- call s:closeTree()
- endif
- unlet t:NERDTreeBufName
- endif
-
- let newRoot = s:TreeDirNode.New(path)
- call newRoot.open()
-
- call s:createTreeWin()
- let b:treeShowHelp = 0
- let b:NERDTreeIgnoreEnabled = 1
- let b:NERDTreeShowFiles = g:NERDTreeShowFiles
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden
- let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
- let b:NERDTreeRoot = newRoot
-
- let b:NERDTreeType = "primary"
-
- call s:renderView()
- call s:putCursorOnNode(b:NERDTreeRoot, 0, 0)
-endfunction
-
-"FUNCTION: s:initNerdTreeInPlace(name) {{{2
-function! s:initNerdTreeInPlace(dir)
- try
- let path = s:Path.New(a:dir)
- catch /^NERDTree.InvalidArgumentsError/
- call s:echo("Invalid directory name:" . a:name)
- return
- endtry
- let b:NERDTreeRoot = s:TreeDirNode.New(path)
- call b:NERDTreeRoot.open()
-
- "throwaway buffer options
- setlocal noswapfile
- setlocal buftype=nofile
- setlocal bufhidden=delete
- setlocal nowrap
- setlocal foldcolumn=0
- setlocal nobuflisted
- setlocal nospell
- if g:NERDTreeShowLineNumbers
- setlocal nu
- else
- setlocal nonu
- endif
-
- iabc <buffer>
-
- if g:NERDTreeHighlightCursorline
- setlocal cursorline
- endif
-
- let b:treeShowHelp = 0
- let b:NERDTreeIgnoreEnabled = 1
- let b:NERDTreeShowFiles = g:NERDTreeShowFiles
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden
- let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
-
- let b:NERDTreeType = "secondary"
-
- call s:bindMappings()
- setfiletype nerdtree
- " syntax highlighting
- if has("syntax") && exists("g:syntax_on") && !has("syntax_items")
- call s:setupSyntaxHighlighting()
- endif
-
- call s:renderView()
-endfunction
-" FUNCTION: s:initNerdTreeMirror() {{{2
-function! s:initNerdTreeMirror()
-
- "get the names off all the nerd tree buffers
- let treeBufNames = []
- for i in range(1, tabpagenr("$"))
- let nextName = s:tabpagevar(i, 'NERDTreeBufName')
- if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
- call add(treeBufNames, nextName)
- endif
- endfor
- let treeBufNames = s:unique(treeBufNames)
-
- "map the option names (that the user will be prompted with) to the nerd
- "tree buffer names
- let options = {}
- let i = 0
- while i < len(treeBufNames)
- let bufName = treeBufNames[i]
- let treeRoot = getbufvar(bufName, "NERDTreeRoot")
- let options[i+1 . '. ' . treeRoot.path.strForOS(0) . ' (buf name: ' . bufName . ')'] = bufName
- let i = i + 1
- endwhile
-
- "work out which tree to mirror, if there is more than 1 then ask the user
- let bufferName = ''
- if len(keys(options)) > 1
- let choices = ["Choose a tree to mirror"]
- let choices = extend(choices, sort(keys(options)))
- let choice = inputlist(choices)
- if choice < 1 || choice > len(options) || choice == ''
- return
- endif
-
- let bufferName = options[keys(options)[choice-1]]
- elseif len(keys(options)) == 1
- let bufferName = values(options)[0]
- else
- call s:echo("No trees to mirror")
- return
- endif
-
- if s:treeExistsForTab() && s:isTreeOpen()
- call s:closeTree()
- endif
-
- let t:NERDTreeBufName = bufferName
- call s:createTreeWin()
- exec 'buffer ' . bufferName
-endfunction
-" FUNCTION: s:tabpagevar(tabnr, var) {{{2
-function! s:tabpagevar(tabnr, var)
- let currentTab = tabpagenr()
- let old_ei = &ei
- set ei=all
-
- exec "tabnext " . a:tabnr
- let v = -1
- if exists('t:' . a:var)
- exec 'let v = t:' . a:var
- endif
- exec "tabnext " . currentTab
-
- let &ei = old_ei
-
- return v
-endfunction
-" Function: s:treeExistsForBuffer() {{{2
-" Returns 1 if a nerd tree root exists in the current buffer
-function! s:treeExistsForBuf()
- return exists("b:NERDTreeRoot")
-endfunction
-" Function: s:treeExistsForTab() {{{2
-" Returns 1 if a nerd tree root exists in the current tab
-function! s:treeExistsForTab()
- return exists("t:NERDTreeBufName")
-endfunction
-" Function: s:unique(list) {{{2
-" returns a:list without duplicates
-function! s:unique(list)
- let uniqlist = []
- for elem in a:list
- if index(uniqlist, elem) == -1
- let uniqlist += [elem]
- endif
- endfor
- return uniqlist
-endfunction
-" SECTION: Public Functions {{{1
-"============================================================
-"Returns the node that the cursor is currently on.
-"
-"If the cursor is not in the NERDTree window, it is temporarily put there.
-"
-"If no NERD tree window exists for the current tab, a NERDTree.NoTreeForTab
-"exception is thrown.
-"
-"If the cursor is not on a node then an empty dictionary {} is returned.
-function! NERDTreeGetCurrentNode()
- if !s:treeExistsForTab() || !s:isTreeOpen()
- throw "NERDTree.NoTreeForTabError: there is no NERD tree open for the current tab"
- endif
-
- let winnr = winnr()
- if winnr != s:getTreeWinNum()
- call s:putCursorInTreeWin()
- endif
-
- let treenode = s:getSelectedNode()
-
- if winnr != winnr()
- call s:exec('wincmd w')
- endif
-
- return treenode
-endfunction
-
-"Returns the path object for the current node.
-"
-"Subject to the same conditions as NERDTreeGetCurrentNode
-function! NERDTreeGetCurrentPath()
- let node = NERDTreeGetCurrentNode()
- if node != {}
- return node.path
- else
- return {}
- endif
-endfunction
-
-" SECTION: View Functions {{{1
-"============================================================
-"FUNCTION: s:centerView() {{{2
-"centers the nerd tree window around the cursor (provided the nerd tree
-"options permit)
-function! s:centerView()
- if g:NERDTreeAutoCenter
- let current_line = winline()
- let lines_to_top = current_line
- let lines_to_bottom = winheight(s:getTreeWinNum()) - current_line
- if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
- normal! zz
- endif
- endif
-endfunction
-"FUNCTION: s:closeTree() {{{2
-"Closes the NERD tree window
-function! s:closeTree()
- if !s:isTreeOpen()
- throw "NERDTree.NoTreeFoundError: no NERDTree is open"
- endif
-
- if winnr("$") != 1
- call s:exec(s:getTreeWinNum() . " wincmd w")
- close
- call s:exec("wincmd p")
- else
- :q
- endif
-endfunction
-
-"FUNCTION: s:closeTreeIfOpen() {{{2
-"Closes the NERD tree window if it is open
-function! s:closeTreeIfOpen()
- if s:isTreeOpen()
- call s:closeTree()
- endif
-endfunction
-"FUNCTION: s:closeTreeIfQuitOnOpen() {{{2
-"Closes the NERD tree window if the close on open option is set
-function! s:closeTreeIfQuitOnOpen()
- if g:NERDTreeQuitOnOpen
- call s:closeTree()
- endif
-endfunction
-"FUNCTION: s:createTreeWin() {{{2
-"Inits the NERD tree window. ie. opens it, sizes it, sets all the local
-"options etc
-function! s:createTreeWin()
- "create the nerd tree window
- let splitLocation = g:NERDTreeWinPos == "left" ? "topleft " : "botright "
- let splitSize = g:NERDTreeWinSize
- if !exists('t:NERDTreeBufName')
- let t:NERDTreeBufName = s:NERDTreeBufName . s:next_buffer_number
- let s:next_buffer_number += 1
- endif
- let cmd = splitLocation . 'vertical ' . splitSize . ' new ' . t:NERDTreeBufName
- silent! execute cmd
-
- setlocal winfixwidth
-
- "throwaway buffer options
- setlocal noswapfile
- setlocal buftype=nofile
- "setlocal bufhidden=delete
- setlocal nowrap
- setlocal foldcolumn=0
- setlocal nobuflisted
- setlocal nospell
- if g:NERDTreeShowLineNumbers
- setlocal nu
- else
- setlocal nonu
- endif
-
- iabc <buffer>
-
- if g:NERDTreeHighlightCursorline
- setlocal cursorline
- endif
-
-
-
- call s:bindMappings()
- setfiletype nerdtree
- " syntax highlighting
- if has("syntax") && exists("g:syntax_on") && !has("syntax_items")
- call s:setupSyntaxHighlighting()
- endif
-endfunction
-
-"FUNCTION: s:drawTree {{{2
-"Draws the given node recursively
-"
-"Args:
-"curNode: the node that is being rendered with this call
-"depth: the current depth in the tree for this call
-"drawText: 1 if we should actually draw the line for this node (if 0 then the
-"child nodes are rendered only)
-"vertMap: a binary array that indicates whether a vertical bar should be draw
-"for each depth in the tree
-"isLastChild:true if this curNode is the last child of its parent
-function! s:drawTree(curNode, depth, drawText, vertMap, isLastChild)
- if a:drawText == 1
-
- let treeParts = ''
-
- "get all the leading spaces and vertical tree parts for this line
- if a:depth > 1
- for j in a:vertMap[0:-2]
- if j == 1
- let treeParts = treeParts . '| '
- else
- let treeParts = treeParts . ' '
- endif
- endfor
- endif
-
- "get the last vertical tree part for this line which will be different
- "if this node is the last child of its parent
- if a:isLastChild
- let treeParts = treeParts . '`'
- else
- let treeParts = treeParts . '|'
- endif
-
-
- "smack the appropriate dir/file symbol on the line before the file/dir
- "name itself
- if a:curNode.path.isDirectory
- if a:curNode.isOpen
- let treeParts = treeParts . '~'
- else
- let treeParts = treeParts . '+'
- endif
- else
- let treeParts = treeParts . '-'
- endif
- let line = treeParts . a:curNode.strDisplay()
-
- call setline(line(".")+1, line)
- call cursor(line(".")+1, col("."))
- endif
-
- "if the node is an open dir, draw its children
- if a:curNode.path.isDirectory == 1 && a:curNode.isOpen == 1
-
- let childNodesToDraw = a:curNode.getVisibleChildren()
- if len(childNodesToDraw) > 0
-
- "draw all the nodes children except the last
- let lastIndx = len(childNodesToDraw)-1
- if lastIndx > 0
- for i in childNodesToDraw[0:lastIndx-1]
- call s:drawTree(i, a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
- endfor
- endif
-
- "draw the last child, indicating that it IS the last
- call s:drawTree(childNodesToDraw[lastIndx], a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
- endif
- endif
-endfunction
-
-
-"FUNCTION: s:dumpHelp {{{2
-"prints out the quick help
-function! s:dumpHelp()
- let old_h = @h
- if b:treeShowHelp == 1
- let @h= "\" NERD tree (" . s:NERD_tree_version . ") quickhelp~\n"
- let @h=@h."\" ============================\n"
- let @h=@h."\" File node mappings~\n"
- let @h=@h."\" ". (g:NERDTreeMouseMode == 3 ? "single" : "double") ."-click,\n"
- if b:NERDTreeType == "primary"
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
- else
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in current window\n"
- endif
- if b:NERDTreeType == "primary"
- let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n"
- endif
- let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
- let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
- let @h=@h."\" middle-click,\n"
- let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n"
- let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n"
- let @h=@h."\" ". g:NERDTreeMapExecute.": Execute file\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Directory node mappings~\n"
- let @h=@h."\" ". (g:NERDTreeMouseMode == 1 ? "double" : "single") ."-click,\n"
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open & close node\n"
- let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n"
- let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n"
- let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n"
- let @h=@h."\" current node recursively\n"
- let @h=@h."\" middle-click,\n"
- let @h=@h."\" ". g:NERDTreeMapOpenExpl.": explore selected dir\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Bookmark table mappings~\n"
- let @h=@h."\" double-click,\n"
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open bookmark\n"
- let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
- let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
- let @h=@h."\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Tree navigation mappings~\n"
- let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n"
- let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n"
- let @h=@h."\" ". g:NERDTreeMapJumpFirstChild .": go to first child\n"
- let @h=@h."\" ". g:NERDTreeMapJumpLastChild .": go to last child\n"
- let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
- let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Filesystem mappings~\n"
- let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n"
- let @h=@h."\" selected dir\n"
- let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n"
- let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
- let @h=@h."\" but leave old root open\n"
- let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n"
- let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n"
- let @h=@h."\" ". g:NERDTreeMapFilesystemMenu .": Show filesystem menu\n"
- let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n"
- let @h=@h."\" selected dir\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Tree filtering mappings~\n"
- let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (b:NERDTreeShowHidden ? "on" : "off") . ")\n"
- let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (b:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
- let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (b:NERDTreeShowFiles ? "on" : "off") . ")\n"
- let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (b:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Other mappings~\n"
- let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n"
- let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n"
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Bookmark commands~\n"
- let @h=@h."\" :Bookmark <name>\n"
- let @h=@h."\" :BookmarkToRoot <name>\n"
- let @h=@h."\" :RevealBookmark <name>\n"
- let @h=@h."\" :OpenBookmark <name>\n"
- let @h=@h."\" :ClearBookmarks [<names>]\n"
- let @h=@h."\" :ClearAllBookmarks\n"
- else
- let @h="\" Press ". g:NERDTreeMapHelp ." for help\n"
- endif
-
- silent! put h
-
- let @h = old_h
-endfunction
-"FUNCTION: s:echo {{{2
-"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages
-"
-"Args:
-"msg: the message to echo
-function! s:echo(msg)
- redraw
- echomsg "NERDTree: " . a:msg
-endfunction
-"FUNCTION: s:echoWarning {{{2
-"Wrapper for s:echo, sets the message type to warningmsg for this message
-"Args:
-"msg: the message to echo
-function! s:echoWarning(msg)
- echohl warningmsg
- call s:echo(a:msg)
- echohl normal
-endfunction
-"FUNCTION: s:echoError {{{2
-"Wrapper for s:echo, sets the message type to errormsg for this message
-"Args:
-"msg: the message to echo
-function! s:echoError(msg)
- echohl errormsg
- call s:echo(a:msg)
- echohl normal
-endfunction
-"FUNCTION: s:findNodeLineNumber(treenode){{{2
-"Finds the line number for the given tree node
-"
-"Args:
-"treenode: the node to find the line no. for
-function! s:findNodeLineNumber(treenode)
- "if the node is the root then return the root line no.
- if a:treenode.isRoot()
- return s:findRootNodeLineNumber()
- endif
-
- let totalLines = line("$")
-
- "the path components we have matched so far
- let pathcomponents = [substitute(b:NERDTreeRoot.path.str(0), '/ *$', '', '')]
- "the index of the component we are searching for
- let curPathComponent = 1
-
- let fullpath = a:treenode.path.str(0)
-
-
- let lnum = s:findRootNodeLineNumber()
- while lnum > 0
- let lnum = lnum + 1
- "have we reached the bottom of the tree?
- if lnum == totalLines+1
- return -1
- endif
-
- let curLine = getline(lnum)
-
- let indent = s:indentLevelFor(curLine)
- if indent == curPathComponent
- let curLine = s:stripMarkupFromLine(curLine, 1)
-
- let curPath = join(pathcomponents, '/') . '/' . curLine
- if stridx(fullpath, curPath, 0) == 0
- if fullpath == curPath || strpart(fullpath, len(curPath)-1,1) == '/'
- let curLine = substitute(curLine, '/ *$', '', '')
- call add(pathcomponents, curLine)
- let curPathComponent = curPathComponent + 1
-
- if fullpath == curPath
- return lnum
- endif
- endif
- endif
- endif
- endwhile
- return -1
-endfunction
-
-"FUNCTION: s:findRootNodeLineNumber(){{{2
-"Finds the line number of the root node
-function! s:findRootNodeLineNumber()
- let rootLine = 1
- while getline(rootLine) !~ '^/'
- let rootLine = rootLine + 1
- endwhile
- return rootLine
-endfunction
-
-"FUNCTION: s:firstNormalWindow(){{{2
-"find the window number of the first normal window
-function! s:firstNormalWindow()
- let i = 1
- while i <= winnr("$")
- let bnum = winbufnr(i)
- if bnum != -1 && getbufvar(bnum, '&buftype') == ''
- \ && !getwinvar(i, '&previewwindow')
- return i
- endif
-
- let i += 1
- endwhile
- return -1
-endfunction
-"FUNCTION: s:getPath(ln) {{{2
-"Gets the full path to the node that is rendered on the given line number
-"
-"Args:
-"ln: the line number to get the path for
-"
-"Return:
-"A path if a node was selected, {} if nothing is selected.
-"If the 'up a dir' line was selected then the path to the parent of the
-"current root is returned
-function! s:getPath(ln)
- let line = getline(a:ln)
-
- "check to see if we have the root node
- if line =~ '^\/'
- return b:NERDTreeRoot.path
- endif
-
- " in case called from outside the tree
- if line !~ '^ *[|`]' || line =~ '^$'
- return {}
- endif
-
- if line == s:tree_up_dir_line
- return b:NERDTreeRoot.path.getParent()
- endif
-
- let indent = s:indentLevelFor(line)
-
- "remove the tree parts and the leading space
- let curFile = s:stripMarkupFromLine(line, 0)
-
- let wasdir = 0
- if curFile =~ '/$'
- let wasdir = 1
- let curFile = substitute(curFile, '/\?$', '/', "")
- endif
-
-
- let dir = ""
- let lnum = a:ln
- while lnum > 0
- let lnum = lnum - 1
- let curLine = getline(lnum)
- let curLineStripped = s:stripMarkupFromLine(curLine, 1)
-
- "have we reached the top of the tree?
- if curLine =~ '^/'
- let dir = substitute (curLine, ' *$', "", "") . dir
- break
- endif
- if curLineStripped =~ '/$'
- let lpindent = s:indentLevelFor(curLine)
- if lpindent < indent
- let indent = indent - 1
-
- let dir = substitute (curLineStripped,'^\\', "", "") . dir
- continue
- endif
- endif
- endwhile
- let curFile = b:NERDTreeRoot.path.drive . dir . curFile
- let toReturn = s:Path.New(curFile)
- return toReturn
-endfunction
-
-"FUNCTION: s:getSelectedBookmark() {{{2
-"returns the bookmark the cursor is over in the bookmarks table or {}
-function! s:getSelectedBookmark()
- let line = getline(".")
- let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
- if name != line
- try
- return s:Bookmark.BookmarkFor(name)
- catch /^NERDTree.BookmarkNotFoundError/
- return {}
- endtry
- endif
- return {}
-endfunction
-
-"FUNCTION: s:getSelectedDir() {{{2
-"Returns the current node if it is a dir node, or else returns the current
-"nodes parent
-function! s:getSelectedDir()
- let currentDir = s:getSelectedNode()
- if currentDir != {} && !currentDir.isRoot()
- if currentDir.path.isDirectory == 0
- let currentDir = currentDir.parent
- endif
- endif
- return currentDir
-endfunction
-"FUNCTION: s:getSelectedNode() {{{2
-"gets the treenode that the cursor is currently over
-function! s:getSelectedNode()
- try
- let path = s:getPath(line("."))
- if path == {}
- return {}
- endif
- return b:NERDTreeRoot.findNode(path)
- catch /NERDTree/
- return {}
- endtry
-endfunction
-"FUNCTION: s:getTreeWinNum() {{{2
-"gets the nerd tree window number for this tab
-function! s:getTreeWinNum()
- if exists("t:NERDTreeBufName")
- return bufwinnr(t:NERDTreeBufName)
- else
- return -1
- endif
-endfunction
-"FUNCTION: s:indentLevelFor(line) {{{2
-function! s:indentLevelFor(line)
- return match(a:line, '[^ \-+~`|]') / s:tree_wid
-endfunction
-"FUNCTION: s:isTreeOpen() {{{2
-function! s:isTreeOpen()
- return s:getTreeWinNum() != -1
-endfunction
-"FUNCTION: s:isWindowUsable(winnumber) {{{2
-"Returns 1 if opening a file from the tree in the given window requires it to
-"be split
-"
-"Args:
-"winnumber: the number of the window in question
-function! s:isWindowUsable(winnumber)
- "gotta split if theres only one window (i.e. the NERD tree)
- if winnr("$") == 1
- return 0
- endif
-
- let oldwinnr = winnr()
- call s:exec(a:winnumber . "wincmd p")
- let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
- let modified = &modified
- call s:exec(oldwinnr . "wincmd p")
-
- "if its a special window e.g. quickfix or another explorer plugin then we
- "have to split
- if specialWindow
- return 0
- endif
-
- if &hidden
- return 1
- endif
-
- return !modified || s:bufInWindows(winbufnr(a:winnumber)) >= 2
-endfunction
-
-" FUNCTION: s:jumpToChild(direction) {{{2
-" Args:
-" direction: 0 if going to first child, 1 if going to last
-function! s:jumpToChild(direction)
- let currentNode = s:getSelectedNode()
- if currentNode == {} || currentNode.isRoot()
- call s:echo("cannot jump to " . (a:direction ? "last" : "first") . " child")
- return
- end
- let dirNode = currentNode.parent
- let childNodes = dirNode.getVisibleChildren()
-
- let targetNode = childNodes[0]
- if a:direction
- let targetNode = childNodes[len(childNodes) - 1]
- endif
-
- if targetNode.equals(currentNode)
- let siblingDir = currentNode.parent.findOpenDirSiblingWithVisibleChildren(a:direction)
- if siblingDir != {}
- let indx = a:direction ? siblingDir.getVisibleChildCount()-1 : 0
- let targetNode = siblingDir.getChildByIndex(indx, 1)
- endif
- endif
-
- call s:putCursorOnNode(targetNode, 1, 0)
-
- call s:centerView()
-endfunction
-
-
-"FUNCTION: s:openDirNodeSplit(treenode) {{{2
-"Open the file represented by the given node in a new window.
-"No action is taken for file nodes
-"
-"ARGS:
-"treenode: file node to open
-function! s:openDirNodeSplit(treenode)
- if a:treenode.path.isDirectory == 1
- call s:openNodeSplit(a:treenode)
- endif
-endfunction
-
-" FUNCTION: s:openExplorerFor(treenode) {{{2
-" opens a netrw window for the given dir treenode
-function! s:openExplorerFor(treenode)
- let oldwin = winnr()
- call s:exec('wincmd p')
- if oldwin == winnr() || (&modified && s:bufInWindows(winbufnr(winnr())) < 2)
- call s:exec('wincmd p')
- call s:openDirNodeSplit(a:treenode)
- else
- exec ("silent edit " . a:treenode.path.strForEditCmd())
- endif
-endfunction
-"FUNCTION: s:openFileNode(treenode) {{{2
-"Open the file represented by the given node in the current window, splitting
-"the window if needed
-"
-"ARGS:
-"treenode: file node to open
-function! s:openFileNode(treenode)
- if b:NERDTreeType == "secondary"
- exec 'edit ' . a:treenode.path.strForEditCmd()
- return
- endif
-
- call s:putCursorInTreeWin()
-
- "if the file is already open in this tab then just stick the cursor in it
- let winnr = bufwinnr('^' . a:treenode.path.strForOS(0) . '$')
- if winnr != -1
- call s:exec(winnr . "wincmd w")
-
- else
- if !s:isWindowUsable(winnr("#")) && s:firstNormalWindow() == -1
- call s:openFileNodeSplit(a:treenode)
- else
- try
- if !s:isWindowUsable(winnr("#"))
- call s:exec(s:firstNormalWindow() . "wincmd w")
- else
- call s:exec('wincmd p')
- endif
- exec ("edit " . a:treenode.path.strForEditCmd())
- catch /^Vim\%((\a\+)\)\=:E37/
- call s:putCursorInTreeWin()
- call s:echo("Cannot open file, it is already open and modified")
- catch /^Vim\%((\a\+)\)\=:/
- echo v:exception
- endtry
- endif
- endif
-endfunction
-
-"FUNCTION: s:openFileNodeSplit(treenode) {{{2
-"Open the file represented by the given node in a new window.
-"No action is taken for dir nodes
-"
-"ARGS:
-"treenode: file node to open
-function! s:openFileNodeSplit(treenode)
- if a:treenode.path.isDirectory == 0
- try
- call s:openNodeSplit(a:treenode)
- catch /^NERDTree.FileAlreadyOpenAndModifiedError/
- call s:echo("Cannot open file, it is already open and modified" )
- endtry
- endif
-endfunction
-
-"FUNCTION: s:openNodeSplit(treenode) {{{2
-"Open the file/dir represented by the given node in a new window
-"
-"ARGS:
-"treenode: file node to open
-function! s:openNodeSplit(treenode)
-
- if b:NERDTreeType == "secondary"
- exec "split " . a:treenode.path.strForEditCmd()
- return
- endif
-
- " Save the user's settings for splitbelow and splitright
- let savesplitbelow=&splitbelow
- let savesplitright=&splitright
-
- " 'there' will be set to a command to move from the split window
- " back to the explorer window
- "
- " 'back' will be set to a command to move from the explorer window
- " back to the newly split window
- "
- " 'right' and 'below' will be set to the settings needed for
- " splitbelow and splitright IF the explorer is the only window.
- "
- let there= g:NERDTreeWinPos == "left" ? "wincmd h" : "wincmd l"
- let back = g:NERDTreeWinPos == "left" ? "wincmd l" : "wincmd h"
- let right= g:NERDTreeWinPos == "left"
- let below=0
-
- " Attempt to go to adjacent window
- call s:exec(back)
-
- let onlyOneWin = (winnr() == s:getTreeWinNum())
-
- " If no adjacent window, set splitright and splitbelow appropriately
- if onlyOneWin
- let &splitright=right
- let &splitbelow=below
- else
- " found adjacent window - invert split direction
- let &splitright=!right
- let &splitbelow=!below
- endif
-
- let splitMode = onlyOneWin ? "vertical" : ""
-
- " Open the new window
- try
- exec(splitMode." sp " . a:treenode.path.strForEditCmd())
- catch /^Vim\%((\a\+)\)\=:E37/
- call s:putCursorInTreeWin()
- throw "NERDTree.FileAlreadyOpenAndModifiedError: ". a:treenode.path.str(0) ." is already open and modified."
- catch /^Vim\%((\a\+)\)\=:/
- "do nothing
- endtry
-
- "resize the tree window if no other window was open before
- if onlyOneWin
- let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
- call s:exec(there)
- exec("silent ". splitMode ." resize ". size)
- call s:exec('wincmd p')
- endif
-
- " Restore splitmode settings
- let &splitbelow=savesplitbelow
- let &splitright=savesplitright
-endfunction
-
-"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{2
-"prints out the given msg and, if the user responds by pushing 'y' then the
-"buffer with the given bufnum is deleted
-"
-"Args:
-"bufnum: the buffer that may be deleted
-"msg: a message that will be echoed to the user asking them if they wish to
-" del the buffer
-function! s:promptToDelBuffer(bufnum, msg)
- echo a:msg
- if nr2char(getchar()) == 'y'
- exec "silent bdelete! " . a:bufnum
- endif
-endfunction
-
-"FUNCTION: s:putCursorOnBookmarkTable(){{{2
-"Places the cursor at the top of the bookmarks table
-function! s:putCursorOnBookmarkTable()
- if !b:NERDTreeShowBookmarks
- throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active"
- endif
-
- let rootNodeLine = s:findRootNodeLineNumber()
-
- let line = 1
- while getline(line) !~ '^>-\+Bookmarks-\+$'
- let line = line + 1
- if line >= rootNodeLine
- throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table"
- endif
- endwhile
- call cursor(line, 0)
-endfunction
-
-"FUNCTION: s:putCursorOnNode(treenode, isJump, recurseUpward){{{2
-"Places the cursor on the line number representing the given node
-"
-"Args:
-"treenode: the node to put the cursor on
-"isJump: 1 if this cursor movement should be counted as a jump by vim
-"recurseUpward: try to put the cursor on the parent if the this node isnt
-"visible
-function! s:putCursorOnNode(treenode, isJump, recurseUpward)
- let ln = s:findNodeLineNumber(a:treenode)
- if ln != -1
- if a:isJump
- mark '
- endif
- call cursor(ln, col("."))
- else
- if a:recurseUpward
- let node = a:treenode
- while s:findNodeLineNumber(node) == -1 && node != {}
- let node = node.parent
- call node.open()
- endwhile
- call s:renderView()
- call s:putCursorOnNode(a:treenode, a:isJump, 0)
- endif
- endif
-endfunction
-
-"FUNCTION: s:putCursorInTreeWin(){{{2
-"Places the cursor in the nerd tree window
-function! s:putCursorInTreeWin()
- if !s:isTreeOpen()
- throw "NERDTree.InvalidOperationError: cant put cursor in NERD tree window, no window exists"
- endif
-
- call s:exec(s:getTreeWinNum() . "wincmd w")
-endfunction
-
-"FUNCTION: s:renderBookmarks {{{2
-function! s:renderBookmarks()
-
- call setline(line(".")+1, ">----------Bookmarks----------")
- call cursor(line(".")+1, col("."))
-
- for i in s:Bookmark.Bookmarks()
- call setline(line(".")+1, i.str())
- call cursor(line(".")+1, col("."))
- endfor
-
- call setline(line(".")+1, '')
- call cursor(line(".")+1, col("."))
-endfunction
-"FUNCTION: s:renderView {{{2
-"The entry function for rendering the tree. Renders the root then calls
-"s:drawTree to draw the children of the root
-"
-"Args:
-function! s:renderView()
- setlocal modifiable
-
- "remember the top line of the buffer and the current line so we can
- "restore the view exactly how it was
- let curLine = line(".")
- let curCol = col(".")
- let topLine = line("w0")
-
- "delete all lines in the buffer (being careful not to clobber a register)
- silent 1,$delete _
-
- call s:dumpHelp()
-
- "delete the blank line before the help and add one after it
- call setline(line(".")+1, "")
- call cursor(line(".")+1, col("."))
-
- if b:NERDTreeShowBookmarks
- call s:renderBookmarks()
- endif
-
- "add the 'up a dir' line
- call setline(line(".")+1, s:tree_up_dir_line)
- call cursor(line(".")+1, col("."))
-
- "draw the header line
- call setline(line(".")+1, b:NERDTreeRoot.path.str(0))
- call cursor(line(".")+1, col("."))
-
- "draw the tree
- call s:drawTree(b:NERDTreeRoot, 0, 0, [], b:NERDTreeRoot.getChildCount() == 1)
-
- "delete the blank line at the top of the buffer
- silent 1,1delete _
-
- "restore the view
- let old_scrolloff=&scrolloff
- let &scrolloff=0
- call cursor(topLine, 1)
- normal! zt
- call cursor(curLine, curCol)
- let &scrolloff = old_scrolloff
-
- setlocal nomodifiable
-endfunction
-
-"FUNCTION: s:renderViewSavingPosition {{{2
-"Renders the tree and ensures the cursor stays on the current node or the
-"current nodes parent if it is no longer available upon re-rendering
-function! s:renderViewSavingPosition()
- let currentNode = s:getSelectedNode()
-
- "go up the tree till we find a node that will be visible or till we run
- "out of nodes
- while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot()
- let currentNode = currentNode.parent
- endwhile
-
- call s:renderView()
-
- if currentNode != {}
- call s:putCursorOnNode(currentNode, 0, 0)
- endif
-endfunction
-"FUNCTION: s:restoreScreenState() {{{2
-"
-"Sets the screen state back to what it was when s:saveScreenState was last
-"called.
-"
-"Assumes the cursor is in the NERDTree window
-function! s:restoreScreenState()
- if !exists("b:NERDTreeOldTopLine") || !exists("b:NERDTreeOldPos") || !exists("b:NERDTreeOldWindowSize")
- return
- endif
- exec("silent vertical resize ".b:NERDTreeOldWindowSize)
-
- let old_scrolloff=&scrolloff
- let &scrolloff=0
- call cursor(b:NERDTreeOldTopLine, 0)
- normal! zt
- call setpos(".", b:NERDTreeOldPos)
- let &scrolloff=old_scrolloff
-endfunction
-
-"FUNCTION: s:saveScreenState() {{{2
-"Saves the current cursor position in the current buffer and the window
-"scroll position
-function! s:saveScreenState()
- let win = winnr()
- try
- call s:putCursorInTreeWin()
- let b:NERDTreeOldPos = getpos(".")
- let b:NERDTreeOldTopLine = line("w0")
- let b:NERDTreeOldWindowSize = winwidth("")
- call s:exec(win . "wincmd w")
- catch /^NERDTree.InvalidOperationError/
- endtry
-endfunction
-
-"FUNCTION: s:setupSyntaxHighlighting() {{{2
-function! s:setupSyntaxHighlighting()
- "treeFlags are syntax items that should be invisible, but give clues as to
- "how things should be highlighted
- syn match treeFlag #\~#
- syn match treeFlag #\[RO\]#
-
- "highlighting for the .. (up dir) line at the top of the tree
- execute "syn match treeUp #". s:tree_up_dir_line ."#"
-
- "highlighting for the ~/+ symbols for the directory nodes
- syn match treeClosable #\~\<#
- syn match treeClosable #\~\.#
- syn match treeOpenable #+\<#
- syn match treeOpenable #+\.#he=e-1
-
- "highlighting for the tree structural parts
- syn match treePart #|#
- syn match treePart #`#
- syn match treePartFile #[|`]-#hs=s+1 contains=treePart
-
- "quickhelp syntax elements
- syn match treeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
- syn match treeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
- syn match treeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=treeFlag
- syn match treeToggleOn #".*(on)#hs=e-2,he=e-1 contains=treeHelpKey
- syn match treeToggleOff #".*(off)#hs=e-3,he=e-1 contains=treeHelpKey
- syn match treeHelpCommand #" :.\{-}\>#hs=s+3
- syn match treeHelp #^".*# contains=treeHelpKey,treeHelpTitle,treeFlag,treeToggleOff,treeToggleOn,treeHelpCommand
-
- "highlighting for readonly files
- syn match treeRO #.*\[RO\]#hs=s+2 contains=treeFlag,treeBookmark,treePart,treePartFile
-
- "highlighting for sym links
- syn match treeLink #[^-| `].* -> # contains=treeBookmark,treeOpenable,treeClosable,treeDirSlash
-
- "highlighing for directory nodes and file nodes
- syn match treeDirSlash #/#
- syn match treeDir #[^-| `].*/# contains=treeLink,treeDirSlash,treeOpenable,treeClosable
- syn match treeExecFile #[|`]-.*\*\($\| \)# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark
- syn match treeFile #|-.*# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark,treeExecFile
- syn match treeFile #`-.*# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark,treeExecFile
- syn match treeCWD #^/.*$#
-
- "highlighting for bookmarks
- syn match treeBookmark # {.*}#hs=s+1
-
- "highlighting for the bookmarks table
- syn match treeBookmarksLeader #^>#
- syn match treeBookmarksHeader #^>-\+Bookmarks-\+$# contains=treeBookmarksLeader
- syn match treeBookmarkName #^>.\{-} #he=e-1 contains=treeBookmarksLeader
- syn match treeBookmark #^>.*$# contains=treeBookmarksLeader,treeBookmarkName,treeBookmarksHeader
-
- if g:NERDChristmasTree
- hi def link treePart Special
- hi def link treePartFile Type
- hi def link treeFile Normal
- hi def link treeExecFile Title
- hi def link treeDirSlash Identifier
- hi def link treeClosable Type
- else
- hi def link treePart Normal
- hi def link treePartFile Normal
- hi def link treeFile Normal
- hi def link treeClosable Title
- endif
-
- hi def link treeBookmarksHeader statement
- hi def link treeBookmarksLeader ignore
- hi def link treeBookmarkName Identifier
- hi def link treeBookmark normal
-
- hi def link treeHelp String
- hi def link treeHelpKey Identifier
- hi def link treeHelpCommand Identifier
- hi def link treeHelpTitle Macro
- hi def link treeToggleOn Question
- hi def link treeToggleOff WarningMsg
-
- hi def link treeDir Directory
- hi def link treeUp Directory
- hi def link treeCWD Statement
- hi def link treeLink Macro
- hi def link treeOpenable Title
- hi def link treeFlag ignore
- hi def link treeRO WarningMsg
- hi def link treeBookmark Statement
-
- hi def link NERDTreeCurrentNode Search
-endfunction
-
-"FUNCTION: s:stripMarkupFromLine(line, removeLeadingSpaces){{{2
-"returns the given line with all the tree parts stripped off
-"
-"Args:
-"line: the subject line
-"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces =
-"any spaces before the actual text of the node)
-function! s:stripMarkupFromLine(line, removeLeadingSpaces)
- let line = a:line
- "remove the tree parts and the leading space
- let line = substitute (line, s:tree_markup_reg,"","")
-
- "strip off any read only flag
- let line = substitute (line, ' \[RO\]', "","")
-
- "strip off any bookmark flags
- let line = substitute (line, ' {[^}]*}', "","")
-
- "strip off any executable flags
- let line = substitute (line, '*\ze\($\| \)', "","")
-
- let wasdir = 0
- if line =~ '/$'
- let wasdir = 1
- endif
- let line = substitute (line,' -> .*',"","") " remove link to
- if wasdir == 1
- let line = substitute (line, '/\?$', '/', "")
- endif
-
- if a:removeLeadingSpaces
- let line = substitute (line, '^ *', '', '')
- endif
-
- return line
-endfunction
-
-"FUNCTION: s:toggle(dir) {{{2
-"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is
-"closed it is restored or initialized (if it doesnt exist)
-"
-"Args:
-"dir: the full path for the root node (is only used if the NERD tree is being
-"initialized.
-function! s:toggle(dir)
- if s:treeExistsForTab()
- if !s:isTreeOpen()
- call s:createTreeWin()
- call s:restoreScreenState()
- else
- call s:closeTree()
- endif
- else
- call s:initNerdTree(a:dir)
- endif
-endfunction
-"SECTION: Interface bindings {{{1
-"============================================================
-"FUNCTION: s:activateNode(forceKeepWindowOpen) {{{2
-"If the current node is a file, open it in the previous window (or a new one
-"if the previous is modified). If it is a directory then it is opened.
-"
-"args:
-"forceKeepWindowOpen - dont close the window even if NERDTreeQuitOnOpen is set
-function! s:activateNode(forceKeepWindowOpen)
- if getline(".") == s:tree_up_dir_line
- return s:upDir(0)
- endif
-
- let treenode = s:getSelectedNode()
- if treenode != {}
- if treenode.path.isDirectory
- call treenode.toggleOpen()
- call s:renderView()
- call s:putCursorOnNode(treenode, 0, 0)
- else
- call s:openFileNode(treenode)
- if !a:forceKeepWindowOpen
- call s:closeTreeIfQuitOnOpen()
- end
- endif
- else
- let bookmark = s:getSelectedBookmark()
- if !empty(bookmark)
- if bookmark.path.isDirectory
- call bookmark.toRoot()
- else
- if bookmark.validate()
- call s:openFileNode(s:TreeFileNode.New(bookmark.path))
- endif
- endif
- endif
- endif
-endfunction
-
-"FUNCTION: s:bindMappings() {{{2
-function! s:bindMappings()
- " set up mappings and commands for this buffer
- nnoremap <silent> <buffer> <middlerelease> :call <SID>handleMiddleMouse()<cr>
- nnoremap <silent> <buffer> <leftrelease> <leftrelease>:call <SID>checkForActivate()<cr>
- nnoremap <silent> <buffer> <2-leftmouse> :call <SID>activateNode(0)<cr>
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapActivateNode . " :call <SID>activateNode(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenSplit ." :call <SID>openEntrySplit(0)<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreview ." :call <SID>previewNode(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreviewSplit ." :call <SID>previewNode(1)<cr>"
-
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapExecute ." :call <SID>executeNode()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenRecursively ." :call <SID>openNodeRecursively()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdirKeepOpen ." :call <SID>upDir(1)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdir ." :call <SID>upDir(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChangeRoot ." :call <SID>chRoot()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChdir ." :call <SID>chCwd()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapQuit ." :NERDTreeToggle<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefreshRoot ." :call <SID>refreshRoot()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefresh ." :call <SID>refreshCurrent()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapHelp ." :call <SID>displayHelp()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleHidden ." :call <SID>toggleShowHidden()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFilters ." :call <SID>toggleIgnoreFilter()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFiles ." :call <SID>toggleShowFiles()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleBookmarks ." :call <SID>toggleShowBookmarks()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseDir ." :call <SID>closeCurrentDir()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseChildren ." :call <SID>closeChildren()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapFilesystemMenu ." :call <SID>showFileSystemMenu()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpParent ." :call <SID>jumpToParent()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpNextSibling ." :call <SID>jumpToSibling(1)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpPrevSibling ." :call <SID>jumpToSibling(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpFirstChild ." :call <SID>jumpToFirstChild()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpLastChild ." :call <SID>jumpToLastChild()<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpRoot ." :call <SID>jumpToRoot()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTab ." :call <SID>openInNewTab(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTabSilent ." :call <SID>openInNewTab(1)<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenExpl ." :call <SID>openExplorer()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapDeleteBookmark ." :call <SID>deleteBookmark()<cr>"
-
- command! -buffer -nargs=1 Bookmark :call <SID>bookmarkNode('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 RevealBookmark :call <SID>revealBookmark('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 OpenBookmark :call <SID>openBookmark('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=* ClearBookmarks call <SID>clearBookmarks('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=+ BookmarkToRoot call s:Bookmark.ToRoot('<args>')
- command! -buffer -nargs=0 ClearAllBookmarks call s:Bookmark.ClearAll() <bar> call <SID>renderView()
- command! -buffer -nargs=0 ReadBookmarks call s:Bookmark.CacheBookmarks(0) <bar> call <SID>renderView()
- command! -buffer -nargs=0 WriteBookmarks call s:Bookmark.Write()
-endfunction
-
-" FUNCTION: s:bookmarkNode(name) {{{2
-" Associate the current node with the given name
-function! s:bookmarkNode(name)
- let currentNode = s:getSelectedNode()
- if currentNode != {}
- try
- call currentNode.bookmark(a:name)
- call s:renderView()
- catch /^NERDTree.IllegalBookmarkNameError/
- call s:echo("bookmark names must not contain spaces")
- endtry
- else
- call s:echo("select a node first")
- endif
-endfunction
-"FUNCTION: s:checkForActivate() {{{2
-"Checks if the click should open the current node, if so then activate() is
-"called (directories are automatically opened if the symbol beside them is
-"clicked)
-function! s:checkForActivate()
- let currentNode = s:getSelectedNode()
- if currentNode != {}
- let startToCur = strpart(getline(line(".")), 0, col("."))
- let char = strpart(startToCur, strlen(startToCur)-1, 1)
-
- "if they clicked a dir, check if they clicked on the + or ~ sign
- "beside it
- if currentNode.path.isDirectory
- if startToCur =~ s:tree_markup_reg . '$' && char =~ '[+~]'
- call s:activateNode(0)
- return
- endif
- endif
-
- if (g:NERDTreeMouseMode == 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode == 3
- if char !~ s:tree_markup_reg && startToCur !~ '\/$'
- call s:activateNode(0)
- return
- endif
- endif
- endif
-endfunction
-
-" FUNCTION: s:chCwd() {{{2
-function! s:chCwd()
- let treenode = s:getSelectedNode()
- if treenode == {}
- call s:echo("Select a node first")
- return
- endif
-
- try
- call treenode.path.changeToDir()
- catch /^NERDTree.PathChangeError/
- call s:echoWarning("could not change cwd")
- endtry
-endfunction
-
-" FUNCTION: s:chRoot() {{{2
-" changes the current root to the selected one
-function! s:chRoot()
- let treenode = s:getSelectedNode()
- if treenode == {}
- call s:echo("Select a node first")
- return
- endif
-
- call treenode.makeRoot()
- call s:renderView()
- call s:putCursorOnNode(b:NERDTreeRoot, 0, 0)
-endfunction
-
-" FUNCTION: s:clearBookmarks(bookmarks) {{{2
-function! s:clearBookmarks(bookmarks)
- if a:bookmarks == ''
- let currentNode = s:getSelectedNode()
- if currentNode != {}
- call currentNode.clearBoomarks()
- endif
- else
- for name in split(a:bookmarks, ' ')
- let bookmark = s:Bookmark.BookmarkFor(name)
- call bookmark.delete()
- endfor
- endif
- call s:renderView()
-endfunction
-" FUNCTION: s:closeChildren() {{{2
-" closes all childnodes of the current node
-function! s:closeChildren()
- let currentNode = s:getSelectedDir()
- if currentNode == {}
- call s:echo("Select a node first")
- return
- endif
-
- call currentNode.closeChildren()
- call s:renderView()
- call s:putCursorOnNode(currentNode, 0, 0)
-endfunction
-" FUNCTION: s:closeCurrentDir() {{{2
-" closes the parent dir of the current node
-function! s:closeCurrentDir()
- let treenode = s:getSelectedNode()
- if treenode == {}
- call s:echo("Select a node first")
- return
- endif
-
- let parent = treenode.parent
- if parent.isRoot()
- call s:echo("cannot close tree root")
- else
- call treenode.parent.close()
- call s:renderView()
- call s:putCursorOnNode(treenode.parent, 0, 0)
- endif
-endfunction
-
-" FUNCTION: s:copyNode() {{{2
-function! s:copyNode()
- let currentNode = s:getSelectedNode()
- if currentNode == {}
- call s:echo("Put the cursor on a file node first")
- return
- endif
-
- let newNodePath = input("Copy the current node\n" .
- \ "==========================================================\n" .
- \ "Enter the new path to copy the node to: \n" .
- \ "", currentNode.path.str(0))
-
- if newNodePath != ""
- "strip trailing slash
- let newNodePath = substitute(newNodePath, '\/$', '', '')
-
- let confirmed = 1
- if currentNode.path.copyingWillOverwrite(newNodePath)
- call s:echo("\nWarning: copying may overwrite files! Continue? (yN)")
- let choice = nr2char(getchar())
- let confirmed = choice == 'y'
- endif
-
- if confirmed
- try
- let newNode = currentNode.copy(newNodePath)
- call s:renderView()
- call s:putCursorOnNode(newNode, 0, 0)
- catch /^NERDTree/
- call s:echoWarning("Could not copy node")
- endtry
- endif
- else
- call s:echo("Copy aborted.")
- endif
- redraw
-endfunction
-
-" FUNCTION: s:deleteBookmark() {{{2
-" if the cursor is on a bookmark, prompt to delete
-function! s:deleteBookmark()
- let bookmark = s:getSelectedBookmark()
- if bookmark == {}
- call s:echo("Put the cursor on a bookmark")
- return
- endif
-
- echo "Are you sure you wish to delete the bookmark:\n\"" . bookmark.name . "\" (yN):"
-
- if nr2char(getchar()) == 'y'
- try
- call bookmark.delete()
- call s:renderView()
- redraw
- catch /^NERDTree/
- call s:echoWarning("Could not remove bookmark")
- endtry
- else
- call s:echo("delete aborted" )
- endif
-
-endfunction
-
-" FUNCTION: s:deleteNode() {{{2
-" if the current node is a file, pops up a dialog giving the user the option
-" to delete it
-function! s:deleteNode()
- let currentNode = s:getSelectedNode()
- if currentNode == {}
- call s:echo("Put the cursor on a file node first")
- return
- endif
-
- let confirmed = 0
-
- if currentNode.path.isDirectory
- let choice =input("Delete the current node\n" .
- \ "==========================================================\n" .
- \ "STOP! To delete this entire directory, type 'yes'\n" .
- \ "" . currentNode.path.strForOS(0) . ": ")
- let confirmed = choice == 'yes'
- else
- echo "Delete the current node\n" .
- \ "==========================================================\n".
- \ "Are you sure you wish to delete the node:\n" .
- \ "" . currentNode.path.strForOS(0) . " (yN):"
- let choice = nr2char(getchar())
- let confirmed = choice == 'y'
- endif
-
-
- if confirmed
- try
- call currentNode.delete()
- call s:renderView()
-
- "if the node is open in a buffer, ask the user if they want to
- "close that buffer
- let bufnum = bufnr(currentNode.path.str(0))
- if buflisted(bufnum)
- let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) == -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
- call s:promptToDelBuffer(bufnum, prompt)
- endif
-
- redraw
- catch /^NERDTree/
- call s:echoWarning("Could not remove node")
- endtry
- else
- call s:echo("delete aborted" )
- endif
-
-endfunction
-
-" FUNCTION: s:displayHelp() {{{2
-" toggles the help display
-function! s:displayHelp()
- let b:treeShowHelp = b:treeShowHelp ? 0 : 1
- call s:renderView()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:executeNode() {{{2
-function! s:executeNode()
- let treenode = s:getSelectedNode()
- if treenode == {} || treenode.path.isDirectory
- call s:echo("Select an executable file node first" )
- else
- echo "NERDTree executor\n" .
- \ "==========================================================\n".
- \ "Complete the command to execute (add arguments etc): \n\n"
- let cmd = treenode.path.strForOS(1)
- let cmd = input(':!', cmd . ' ')
-
- if cmd != ''
- exec ':!' . cmd
- else
- call s:echo("command aborted")
- endif
- endif
-endfunction
-
-" FUNCTION: s:handleMiddleMouse() {{{2
-function! s:handleMiddleMouse()
- let curNode = s:getSelectedNode()
- if curNode == {}
- call s:echo("Put the cursor on a node first" )
- return
- endif
-
- if curNode.path.isDirectory
- call s:openExplorer()
- else
- call s:openEntrySplit(0)
- endif
-endfunction
-
-
-" FUNCTION: s:insertNewNode() {{{2
-" Adds a new node to the filesystem and then into the tree
-function! s:insertNewNode()
- let curDirNode = s:getSelectedDir()
- if curDirNode == {}
- call s:echo("Put the cursor on a node first" )
- return
- endif
-
- let newNodeName = input("Add a childnode\n".
- \ "==========================================================\n".
- \ "Enter the dir/file name to be created. Dirs end with a '/'\n" .
- \ "", curDirNode.path.strForGlob() . s:os_slash)
-
- if newNodeName == ''
- call s:echo("Node Creation Aborted.")
- return
- endif
-
- try
- let newPath = s:Path.Create(newNodeName)
- let parentNode = b:NERDTreeRoot.findNode(newPath.getPathTrunk())
-
- let newTreeNode = s:TreeFileNode.New(newPath)
- if parentNode.isOpen || !empty(parentNode.children)
- call parentNode.addChild(newTreeNode, 1)
- call s:renderView()
- call s:putCursorOnNode(newTreeNode, 1, 0)
- endif
- catch /^NERDTree/
- call s:echoWarning("Node Not Created.")
- endtry
-endfunction
-
-" FUNCTION: s:jumpToFirstChild() {{{2
-" wrapper for the jump to child method
-function! s:jumpToFirstChild()
- call s:jumpToChild(0)
-endfunction
-
-" FUNCTION: s:jumpToLastChild() {{{2
-" wrapper for the jump to child method
-function! s:jumpToLastChild()
- call s:jumpToChild(1)
-endfunction
-
-" FUNCTION: s:jumpToParent() {{{2
-" moves the cursor to the parent of the current node
-function! s:jumpToParent()
- let currentNode = s:getSelectedNode()
- if !empty(currentNode)
- if !empty(currentNode.parent)
- call s:putCursorOnNode(currentNode.parent, 1, 0)
- call s:centerView()
- else
- call s:echo("cannot jump to parent")
- endif
- else
- call s:echo("put the cursor on a node first")
- endif
-endfunction
-
-" FUNCTION: s:jumpToRoot() {{{2
-" moves the cursor to the root node
-function! s:jumpToRoot()
- call s:putCursorOnNode(b:NERDTreeRoot, 1, 0)
- call s:centerView()
-endfunction
-
-" FUNCTION: s:jumpToSibling() {{{2
-" moves the cursor to the sibling of the current node in the given direction
-"
-" Args:
-" forward: 1 if the cursor should move to the next sibling, 0 if it should
-" move back to the previous sibling
-function! s:jumpToSibling(forward)
- let currentNode = s:getSelectedNode()
- if !empty(currentNode)
- let sibling = currentNode.findSibling(a:forward)
-
- if !empty(sibling)
- call s:putCursorOnNode(sibling, 1, 0)
- call s:centerView()
- endif
- else
- call s:echo("put the cursor on a node first")
- endif
-endfunction
-
-" FUNCTION: s:openBookmark(name) {{{2
-" put the cursor on the given bookmark and, if its a file, open it
-function! s:openBookmark(name)
- try
- let targetNode = s:Bookmark.GetNodeForName(a:name, 0)
- call s:putCursorOnNode(targetNode, 0, 1)
- redraw!
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- call s:echo("note - target node is not cached")
- let bookmark = s:Bookmark.BookmarkFor(a:name)
- let targetNode = s:TreeFileNode.New(bookmark.path)
- endtry
- if targetNode.path.isDirectory
- call s:openExplorerFor(targetNode)
- else
- call s:openFileNode(targetNode)
- endif
-endfunction
-" FUNCTION: s:openEntrySplit(forceKeepWindowOpen) {{{2
-"Opens the currently selected file from the explorer in a
-"new window
-"
-"args:
-"forceKeepWindowOpen - dont close the window even if NERDTreeQuitOnOpen is set
-function! s:openEntrySplit(forceKeepWindowOpen)
- let treenode = s:getSelectedNode()
- if treenode != {}
- call s:openFileNodeSplit(treenode)
- if !a:forceKeepWindowOpen
- call s:closeTreeIfQuitOnOpen()
- endif
- else
- call s:echo("select a node first")
- endif
-endfunction
-
-" FUNCTION: s:openExplorer() {{{2
-function! s:openExplorer()
- let treenode = s:getSelectedDir()
- if treenode != {}
- call s:openExplorerFor(treenode)
- else
- call s:echo("select a node first")
- endif
-endfunction
-
-" FUNCTION: s:openInNewTab(stayCurrentTab) {{{2
-" Opens the selected node or bookmark in a new tab
-" Args:
-" stayCurrentTab: if 1 then vim will stay in the current tab, if 0 then vim
-" will go to the tab where the new file is opened
-function! s:openInNewTab(stayCurrentTab)
- let currentTab = tabpagenr()
-
- let treenode = s:getSelectedNode()
- if treenode != {}
- if treenode.path.isDirectory
- tabnew
- call s:initNerdTree(treenode.path.strForOS(0))
- else
- exec "tabedit " . treenode.path.strForEditCmd()
- endif
- else
- let bookmark = s:getSelectedBookmark()
- if bookmark != {}
- if bookmark.path.isDirectory
- tabnew
- call s:initNerdTree(bookmark.name)
- else
- exec "tabedit " . bookmark.path.strForEditCmd()
- endif
- endif
- endif
- if a:stayCurrentTab
- exec "tabnext " . currentTab
- endif
-endfunction
-
-" FUNCTION: s:openNodeRecursively() {{{2
-function! s:openNodeRecursively()
- let treenode = s:getSelectedNode()
- if treenode == {} || treenode.path.isDirectory == 0
- call s:echo("Select a directory node first" )
- else
- call s:echo("Recursively opening node. Please wait...")
- call treenode.openRecursively()
- call s:renderView()
- redraw
- call s:echo("Recursively opening node. Please wait... DONE")
- endif
-
-endfunction
-
-"FUNCTION: s:previewNode() {{{2
-function! s:previewNode(openNewWin)
- let currentBuf = bufnr("")
- if a:openNewWin
- call s:openEntrySplit(1)
- else
- call s:activateNode(1)
- end
- call s:exec(bufwinnr(currentBuf) . "wincmd w")
-endfunction
-
-" FUNCTION: s:revealBookmark(name) {{{2
-" put the cursor on the node associate with the given name
-function! s:revealBookmark(name)
- try
- let targetNode = s:Bookmark.GetNodeForName(a:name, 0)
- call s:putCursorOnNode(targetNode, 0, 1)
- catch /^NERDTree.BookmarkNotFoundError/
- call s:echo("Bookmark isnt cached under the current root")
- endtry
-endfunction
-" FUNCTION: s:refreshRoot() {{{2
-" Reloads the current root. All nodes below this will be lost and the root dir
-" will be reloaded.
-function! s:refreshRoot()
- call s:echo("Refreshing the root node. This could take a while...")
- call b:NERDTreeRoot.refresh()
- call s:renderView()
- redraw
- call s:echo("Refreshing the root node. This could take a while... DONE")
-endfunction
-
-" FUNCTION: s:refreshCurrent() {{{2
-" refreshes the root for the current node
-function! s:refreshCurrent()
- let treenode = s:getSelectedDir()
- if treenode == {}
- call s:echo("Refresh failed. Select a node first")
- return
- endif
-
- call s:echo("Refreshing node. This could take a while...")
- call treenode.refresh()
- call s:renderView()
- redraw
- call s:echo("Refreshing node. This could take a while... DONE")
-endfunction
-" FUNCTION: s:renameCurrent() {{{2
-" allows the user to rename the current node
-function! s:renameCurrent()
- let curNode = s:getSelectedNode()
- if curNode == {}
- call s:echo("Put the cursor on a node first" )
- return
- endif
-
- let newNodePath = input("Rename the current node\n" .
- \ "==========================================================\n" .
- \ "Enter the new path for the node: \n" .
- \ "", curNode.path.strForOS(0))
-
- if newNodePath == ''
- call s:echo("Node Renaming Aborted.")
- return
- endif
-
- try
- let bufnum = bufnr(curNode.path.str(0))
-
- call curNode.rename(newNodePath)
- call s:renderView()
-
- "if the node is open in a buffer, ask the user if they want to
- "close that buffer
- if bufnum != -1
- let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) == -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
- call s:promptToDelBuffer(bufnum, prompt)
- endif
-
- call s:putCursorOnNode(curNode, 1, 0)
-
- redraw
- catch /^NERDTree/
- call s:echoWarning("Node Not Renamed.")
- endtry
-endfunction
-
-" FUNCTION: s:showFileSystemMenu() {{{2
-function! s:showFileSystemMenu()
- let curNode = s:getSelectedNode()
- if curNode == {}
- call s:echo("Put the cursor on a node first" )
- return
- endif
-
-
- let prompt = "NERDTree Filesystem Menu\n" .
- \ "==========================================================\n".
- \ "Select the desired operation: \n" .
- \ " (a)dd a childnode\n".
- \ " (m)ove the current node\n".
- \ " (d)elete the current node\n"
- if s:Path.CopyingSupported()
- let prompt = prompt . " (c)opy the current node\n\n"
- else
- let prompt = prompt . " \n"
- endif
-
- echo prompt
-
- let choice = nr2char(getchar())
-
- if choice ==? "a"
- call s:insertNewNode()
- elseif choice ==? "m"
- call s:renameCurrent()
- elseif choice ==? "d"
- call s:deleteNode()
- elseif choice ==? "c" && s:Path.CopyingSupported()
- call s:copyNode()
- endif
-endfunction
-
-" FUNCTION: s:toggleIgnoreFilter() {{{2
-" toggles the use of the NERDTreeIgnore option
-function! s:toggleIgnoreFilter()
- let b:NERDTreeIgnoreEnabled = !b:NERDTreeIgnoreEnabled
- call s:renderViewSavingPosition()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:toggleShowBookmarks() {{{2
-" toggles the display of bookmarks
-function! s:toggleShowBookmarks()
- let b:NERDTreeShowBookmarks = !b:NERDTreeShowBookmarks
- if b:NERDTreeShowBookmarks
- call s:renderView()
- call s:putCursorOnBookmarkTable()
- else
- call s:renderViewSavingPosition()
- endif
- call s:centerView()
-endfunction
-" FUNCTION: s:toggleShowFiles() {{{2
-" toggles the display of hidden files
-function! s:toggleShowFiles()
- let b:NERDTreeShowFiles = !b:NERDTreeShowFiles
- call s:renderViewSavingPosition()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:toggleShowHidden() {{{2
-" toggles the display of hidden files
-function! s:toggleShowHidden()
- let b:NERDTreeShowHidden = !b:NERDTreeShowHidden
- call s:renderViewSavingPosition()
- call s:centerView()
-endfunction
-
-"FUNCTION: s:upDir(keepState) {{{2
-"moves the tree up a level
-"
-"Args:
-"keepState: 1 if the current root should be left open when the tree is
-"re-rendered
-function! s:upDir(keepState)
- let cwd = b:NERDTreeRoot.path.str(0)
- if cwd == "/" || cwd =~ '^[^/]..$'
- call s:echo("already at top dir")
- else
- if !a:keepState
- call b:NERDTreeRoot.close()
- endif
-
- let oldRoot = b:NERDTreeRoot
-
- if empty(b:NERDTreeRoot.parent)
- let path = b:NERDTreeRoot.path.getPathTrunk()
- let newRoot = s:TreeDirNode.New(path)
- call newRoot.open()
- call newRoot.transplantChild(b:NERDTreeRoot)
- let b:NERDTreeRoot = newRoot
- else
- let b:NERDTreeRoot = b:NERDTreeRoot.parent
-
- endif
-
- call s:renderView()
- call s:putCursorOnNode(oldRoot, 0, 0)
- endif
-endfunction
-
-
-"reset &cpo back to users setting
-let &cpo = s:old_cpo
-
-" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/vim/plugin/fugitive.vim b/vim/plugin/fugitive.vim
deleted file mode 100644
index 6e2830b..0000000
--- a/vim/plugin/fugitive.vim
+++ /dev/null
@@ -1,1351 +0,0 @@
-" fugitive.vim - Fugitive
-" Maintainer: Tim Pope <vimNOSPAM@tpope.info>
-
-if (exists("g:loaded_fugitive") && g:loaded_fugitive) || &cp
- finish
-endif
-let g:loaded_fugitive = 1
-
-if !exists('g:fugitive_git_executable')
- let g:fugitive_git_executable = 'git'
-endif
-
-" Utility {{{1
-
-function! s:function(name) abort
- return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),''))
-endfunction
-
-function! s:sub(str,pat,rep) abort
- return substitute(a:str,'\v\C'.a:pat,a:rep,'')
-endfunction
-
-function! s:gsub(str,pat,rep) abort
- return substitute(a:str,'\v\C'.a:pat,a:rep,'g')
-endfunction
-
-function! s:shellesc(arg) abort
- if a:arg =~ '^[A-Za-z0-9_/.-]\+$'
- return a:arg
- else
- return shellescape(a:arg)
- endif
-endfunction
-
-function! s:fnameescape(file) abort
- if exists('*fnameescape')
- return fnameescape(a:file)
- else
- return escape(a:file," \t\n*?[{`$\\%#'\"|!<")
- endif
-endfunction
-
-function! s:throw(string) abort
- let v:errmsg = 'fugitive: '.a:string
- throw v:errmsg
-endfunction
-
-function! s:add_methods(namespace, method_names) abort
- for name in a:method_names
- let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name)
- endfor
-endfunction
-
-let s:commands = []
-function! s:command(definition) abort
- let s:commands += [a:definition]
-endfunction
-
-function! s:define_commands()
- for command in s:commands
- exe 'command! -buffer '.command
- endfor
-endfunction
-
-augroup fugitive_commands
- autocmd!
- autocmd User Fugitive call s:define_commands()
-augroup END
-
-let s:abstract_prototype = {}
-
-" }}}1
-" Initialization {{{1
-
-function! s:ExtractGitDir(path) abort
- if a:path =~? '^fugitive://.*//'
- return matchstr(a:path,'fugitive://\zs.\{-\}\ze//')
- endif
- let fn = fnamemodify(a:path,':s?[\/]$??')
- let ofn = ""
- let nfn = fn
- while fn != ofn
- if isdirectory(fn . '/.git')
- return s:sub(simplify(fnamemodify(fn . '/.git',':p')),'/$','')
- elseif fn =~ '\.git$' && filereadable(fn . '/HEAD')
- return s:sub(simplify(fnamemodify(fn,':p')),'/$','')
- endif
- let ofn = fn
- let fn = fnamemodify(ofn,':h')
- endwhile
- return ''
-endfunction
-
-function! s:Detect()
- if !exists('b:git_dir')
- let dir = s:ExtractGitDir(expand('%:p'))
- if dir != ''
- let b:git_dir = dir
- endif
- endif
- if exists('b:git_dir')
- silent doautocmd User Fugitive
- cnoremap <expr> <buffer> <C-R><C-G> fugitive#buffer().rev()
- endif
-endfunction
-
-augroup fugitive
- autocmd!
- autocmd BufNewFile,BufReadPost * call s:Detect()
- autocmd FileType netrw call s:Detect()
- autocmd BufWinLeave * execute getbufvar(+expand('<abuf>'), 'fugitive_restore')
-augroup END
-
-" }}}1
-" Repository {{{1
-
-let s:repo_prototype = {}
-let s:repos = {}
-
-function! s:repo(...) abort
- let dir = a:0 ? a:1 : (exists('b:git_dir') ? b:git_dir : s:ExtractGitDir(expand('%:p')))
- if dir == ''
- call s:throw('not a git repository: '.expand('%:p'))
- else
- if has_key(s:repos,dir)
- let repo = get(s:repos,dir)
- else
- let repo = {'git_dir': dir}
- let s:repos[dir] = repo
- endif
- return extend(extend(repo,s:repo_prototype,'keep'),s:abstract_prototype,'keep')
- endif
-endfunction
-
-function! s:repo_dir(...) dict abort
- return join([self.git_dir]+a:000,'/')
-endfunction
-
-function! s:repo_tree(...) dict abort
- if self.bare()
- call s:throw('no work tree')
- else
- let dir = fnamemodify(self.git_dir,':h')
- return join([dir]+a:000,'/')
- endif
-endfunction
-
-function! s:repo_bare() dict abort
- return self.dir() !~# '/\.git$'
-endfunction
-
-function! s:repo_translate(spec) dict abort
- if a:spec ==# '.' || a:spec ==# '/.'
- return self.bare() ? self.dir() : self.tree()
- elseif a:spec =~# '^/'
- return fnamemodify(self.dir(),':h').a:spec
- elseif a:spec =~# '^:[0-3]:'
- return 'fugitive://'.self.dir().'//'.a:spec[1].'/'.a:spec[3:-1]
- elseif a:spec ==# ':'
- return self.dir('index')
- elseif a:spec =~# '^:/'
- let ref = self.rev_parse(matchstr(a:spec,'.[^:]*'))
- return 'fugitive://'.self.dir().'//'.ref
- elseif a:spec =~# '^:'
- return 'fugitive://'.self.dir().'//0/'.a:spec[1:-1]
- elseif a:spec =~# 'HEAD\|^refs/' && a:spec !~ ':' && filereadable(self.dir(a:spec))
- return self.dir(a:spec)
- elseif filereadable(s:repo().dir('refs/'.a:spec))
- return self.dir('refs/'.a:spec)
- elseif filereadable(s:repo().dir('refs/tags/'.a:spec))
- return self.dir('refs/tags/'.a:spec)
- elseif filereadable(s:repo().dir('refs/heads/'.a:spec))
- return self.dir('refs/heads/'.a:spec)
- elseif filereadable(s:repo().dir('refs/remotes/'.a:spec))
- return self.dir('refs/remotes/'.a:spec)
- elseif filereadable(s:repo().dir('refs/remotes/'.a:spec.'/HEAD'))
- return self.dir('refs/remotes/'.a:spec,'/HEAD')
- else
- try
- let ref = self.rev_parse(matchstr(a:spec,'[^:]*'))
- let path = s:sub(matchstr(a:spec,':.*'),'^:','/')
- return 'fugitive://'.self.dir().'//'.ref.path
- catch /^fugitive:/
- return self.tree(a:spec)
- endtry
- endif
-endfunction
-
-call s:add_methods('repo',['dir','tree','bare','translate'])
-
-function! s:repo_git_command(...) dict abort
- let git = g:fugitive_git_executable . ' --git-dir='.s:shellesc(self.git_dir)
- return git.join(map(copy(a:000),'" ".s:shellesc(v:val)'),'')
-endfunction
-
-function! s:repo_git_chomp(...) dict abort
- return s:sub(system(call(self.git_command,a:000,self)),'\n$','')
-endfunction
-
-function! s:repo_git_chomp_in_tree(...) dict abort
- let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
- let dir = getcwd()
- try
- execute cd.' `=s:repo().tree()`'
- return call(s:repo().git_chomp, a:000, s:repo())
- finally
- execute cd.' `=dir`'
- endtry
-endfunction
-
-function! s:repo_rev_parse(rev) dict abort
- let hash = self.git_chomp('rev-parse','--verify',a:rev)
- if hash =~ '^\x\{40\}$'
- return hash
- else
- call s:throw('rev-parse '.a:rev.': '.hash)
- endif
-endfunction
-
-call s:add_methods('repo',['git_command','git_chomp','git_chomp_in_tree','rev_parse'])
-
-function! s:repo_dirglob(base) dict abort
- let base = s:sub(a:base,'^/','')
- let matches = split(glob(self.tree(s:gsub(base,'/','*&').'*/')),"\n")
- call map(matches,'v:val[ strlen(self.tree())+(a:base !~ "^/") : -1 ]')
- return matches
-endfunction
-
-function! s:repo_superglob(base) dict abort
- if a:base =~# '^/' || a:base !~# ':'
- let results = []
- if a:base !~# '^/'
- let heads = ["HEAD","ORIG_HEAD","FETCH_HEAD","MERGE_HEAD"]
- let heads += sort(split(s:repo().git_chomp("rev-parse","--symbolic","--branches","--tags","--remotes"),"\n"))
- call filter(heads,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
- let results += heads
- endif
- if !self.bare()
- let base = s:sub(a:base,'^/','')
- let matches = split(glob(self.tree(s:gsub(base,'/','*&').'*')),"\n")
- call map(matches,'v:val !~ "/$" && isdirectory(v:val) ? v:val."/" : v:val')
- call map(matches,'v:val[ strlen(self.tree())+(a:base !~ "^/") : -1 ]')
- let results += matches
- endif
- return results
-
- elseif a:base =~# '^:'
- let entries = split(self.git_chomp('ls-files','--stage'),"\n")
- call map(entries,'s:sub(v:val,".*(\\d)\\t(.*)",":\\1:\\2")')
- if a:base !~# '^:[0-3]\%(:\|$\)'
- call filter(entries,'v:val[1] == "0"')
- call map(entries,'v:val[2:-1]')
- endif
- call filter(entries,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
- return entries
-
- else
- let tree = matchstr(a:base,'.*[:/]')
- let entries = split(self.git_chomp('ls-tree',tree),"\n")
- call map(entries,'s:sub(v:val,"^04.*\\zs$","/")')
- call map(entries,'tree.s:sub(v:val,".*\t","")')
- return filter(entries,'v:val[ 0 : strlen(a:base)-1 ] ==# a:base')
- endif
-endfunction
-
-call s:add_methods('repo',['dirglob','superglob'])
-
-function! s:repo_keywordprg() dict abort
- let args = ' --git-dir='.escape(self.dir(),"\\\"' ").' show'
- if has("gui_running")
- return g:fugitive_git_executable . ' --no-pager' . args
- else
- return g:fugitive_git_executable . args
- endif
-endfunction
-
-call s:add_methods('repo',['keywordprg'])
-
-" }}}1
-" Buffer {{{1
-
-let s:buffer_prototype = {}
-
-function! s:buffer(...) abort
- let buffer = {'#': bufnr(a:0 ? a:1 : '%')}
- call extend(extend(buffer,s:buffer_prototype,'keep'),s:abstract_prototype,'keep')
- if buffer.getvar('git_dir') == ''
- call s:throw('not a git repository: '.expand('%:p'))
- endif
- return buffer
-endfunction
-
-function! fugitive#buffer(...) abort
- return s:buffer(a:0 ? a:1 : '%')
-endfunction
-
-function! s:buffer_getvar(var) dict abort
- return getbufvar(self['#'],a:var)
-endfunction
-
-function! s:buffer_getline(lnum) dict abort
- return getbufline(self['#'],a:lnum)[0]
-endfunction
-
-function! s:buffer_repo() dict abort
- return s:repo(self.getvar('git_dir'))
-endfunction
-
-function! s:buffer_type(...) dict abort
- if self.getvar('fugitive_type') != ''
- let type = self.getvar('fugitive_type')
- elseif fnamemodify(self.name(),':p') =~# '.\git/refs/\|\.git/\w*HEAD$'
- let type = 'head'
- elseif self.getline(1) =~ '^tree \x\{40\}$' && self.getline(2) == ''
- let type = 'tree'
- elseif self.getline(1) =~ '^\d\{6\} \w\{4\} \x\{40\}\>\t'
- let type = 'tree'
- elseif self.getline(1) =~ '^\d\{6\} \x\{40\}\> \d\t'
- let type = 'index'
- elseif isdirectory(self.name())
- let type = 'directory'
- elseif filereadable(self.name())
- let type = 'file'
- else
- let type = ''
- endif
- if a:0
- return !empty(filter(copy(a:000),'v:val ==# type'))
- else
- return type
- endif
-endfunction
-
-function! s:buffer_name() dict abort
- return fnamemodify(bufname(self['#']),':p')
-endfunction
-
-function! s:buffer_commit() dict abort
- return matchstr(self.name(),'^fugitive://.\{-\}//\zs\w*')
-endfunction
-
-function! s:buffer_path(...) dict abort
- let rev = matchstr(self.name(),'^fugitive://.\{-\}//\zs.*')
- if rev != ''
- let rev = s:sub(rev,'\w*','')
- elseif self.name() =~ '\.git/refs/\|\.git/.*HEAD$'
- let rev = ''
- else
- let rev = self.name()[strlen(self.repo().tree()) : -1]
- endif
- return s:sub(rev,'^/',a:0 ? a:1 : '')
-endfunction
-
-function! s:buffer_rev() dict abort
- let rev = matchstr(self.name(),'^fugitive://.\{-\}//\zs.*')
- if rev =~ '^\x/'
- return ':'.rev[0].':'.rev[2:-1]
- elseif rev =~ '.'
- return s:sub(rev,'/',':')
- elseif self.name() =~ '\.git/index$'
- return ':'
- elseif self.name() =~ '\.git/refs/\|\.git/.*HEAD$'
- return self.name()[strlen(self.repo().dir())+1 : -1]
- else
- return self.path()
- endif
-endfunction
-
-function! s:buffer_sha1() dict abort
- if self.name() =~ '^fugitive://' || self.name() =~ '\.git/refs/\|\.git/.*HEAD$'
- return self.repo().rev_parse(self.rev())
- else
- return ''
- endif
-endfunction
-
-function! s:buffer_expand(rev) dict abort
- if a:rev =~# '^:[0-3]$'
- let file = a:rev.self.path(':')
- elseif a:rev =~# '^-'
- let file = 'HEAD^{}'.a:rev[1:-1].self.path(':')
- elseif a:rev =~# '^@{'
- let file = 'HEAD'.a:rev.self.path(':')
- elseif a:rev =~# '^[~^]'
- let commit = s:sub(self.commit(),'^\d=$','HEAD')
- let file = commit.a:rev.self.path(':')
- else
- let file = a:rev
- endif
- return s:sub(file,'\%$',self.path())
-endfunction
-
-function! s:buffer_containing_commit() dict abort
- if self.commit() =~# '\x\{40\}'
- return self.commit()
- elseif self.commit() =~# '.'
- return ':'
- else
- return 'HEAD'
- endif
-endfunction
-
-call s:add_methods('buffer',['getvar','getline','repo','type','name','commit','path','rev','sha1','expand','containing_commit'])
-
-" }}}1
-" Git {{{1
-
-call s:command("-bar -bang -nargs=? -complete=customlist,s:GitComplete Git :call s:Git(<bang>0,<q-args>)")
-
-function! s:ExecuteInTree(cmd) abort
- let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
- let dir = getcwd()
- try
- execute cd.' `=s:repo().tree()`'
- execute a:cmd
- finally
- execute cd.' `=dir`'
- endtry
-endfunction
-
-function! s:Git(bang,cmd) abort
- let git = s:repo().git_command()
- if has('gui_running')
- let git .= ' --no-pager'
- endif
- call s:ExecuteInTree('!'.git.' '.a:cmd)
- call s:ReloadIndex()
-endfunction
-
-function! s:GitComplete(A,L,P) abort
- if !exists('s:exec_path')
- let s:exec_path = s:sub(system(g:fugitive_git_executable.' --exec-path'),'\n$','')
- endif
- let cmds = map(split(glob(s:exec_path.'/git-*'),"\n"),'v:val[strlen(s:exec_path)+5 : -1]')
- if a:L =~ ' [[:alnum:]-]\+ '
- return s:repo().superglob(a:A)
- elseif a:A == ''
- return cmds
- else
- return filter(cmds,'v:val[0 : strlen(a:A)-1] ==# a:A')
- endif
-endfunction
-
-" }}}1
-" Gcd, Glcd {{{1
-
-function! s:DirComplete(A,L,P) abort
- let matches = s:repo().dirglob(a:A)
- return matches
-endfunction
-
-call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Gcd :cd<bang> `=s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>)`")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Glcd :lcd<bang> `=s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>)`")
-
-" }}}1
-" Gstatus {{{1
-
-call s:command("-bar Gstatus :execute s:Status()")
-
-function! s:Status()
- try
- Gpedit :
- wincmd P
- nnoremap <buffer> <silent> q :<C-U>bdelete<CR>
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
- return ''
-endfunction
-
-function! s:ReloadIndex()
- let mytab = tabpagenr()
- for tab in [mytab] + range(1,tabpagenr('$'))
- for winnr in range(1,tabpagewinnr(tab,'$'))
- if getbufvar(tabpagebuflist(tab)[winnr-1],'fugitive_type') ==# 'index'
- execute 'tabnext '.tab
- if winnr != winnr()
- execute winnr.'wincmd w'
- let restorewinnr = 1
- endif
- try
- if !&modified
- call s:BufReadIndex()
- endif
- finally
- if exists('restorewinnr')
- wincmd p
- endif
- execute 'tabnext '.mytab
- endtry
- endif
- endfor
- endfor
-endfunction
-
-function! s:StageToggle(lnum1,lnum2)
- try
- let output = ''
- for lnum in range(a:lnum1,a:lnum2)
- let line = getline(lnum)
- let filename = matchstr(line,'^#\t[[:alpha:] ]\+: *\zs.*')
- if filename ==# ''
- let filename = matchstr(line,'^#\t\zs.*')
- endif
- if filename ==# ''
- continue
- endif
- if !exists('first_filename')
- let first_filename = filename
- endif
- execute lnum
- let section = getline(search('^# .*:$','bnW'))
- if line =~# '^#\trenamed:' && filename =~ ' -> '
- let cmd = ['mv','--'] + reverse(split(filename,' -> '))
- let filename = cmd[-1]
- elseif section =~? ' to be '
- let cmd = ['reset','-q','--',filename]
- elseif line =~# '^#\tdeleted:'
- let cmd = ['rm','--',filename]
- else
- let cmd = ['add','--',filename]
- endif
- let output .= call(s:repo().git_chomp_in_tree,cmd,s:repo())."\n"
- endfor
- if exists('first_filename')
- silent! edit!
- 1
- redraw
- call search('^#\t\%([[:alpha:] ]\+: *\)\=\V'.first_filename.'\$','W')
- endif
- echo s:sub(s:gsub(output,'\n+','\n'),'\n$','')
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
- return 'checktime'
-endfunction
-
-" }}}1
-" Ggrep, Glog {{{1
-
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Ggrep :execute s:Grep(<bang>0,<q-args>)")
-call s:command("-bar -bang Glog :execute s:Log('grep<bang>')")
-
-function! s:Grep(bang,arg) abort
- let grepprg = &grepprg
- let grepformat = &grepformat
- let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
- let cd .= s:fnameescape(getcwd())
- try
- cd `=s:repo().tree()`
- let &grepprg = s:repo().git_command('--no-pager', 'grep', '-n')
- let &grepformat = '%f:%l:%m'
- exe 'grep! '.a:arg
- let list = getqflist()
- for entry in list
- if bufname(entry.bufnr) =~ ':'
- let entry.filename = s:repo().translate(bufname(entry.bufnr))
- unlet! entry.bufnr
- elseif a:arg =~# '\%(^\| \)--cached\>'
- let entry.filename = s:repo().translate(':0:'.bufname(entry.bufnr))
- unlet! entry.bufnr
- endif
- endfor
- call setqflist(list,'r')
- if !a:bang && !empty(list)
- return 'cfirst'
- else
- return ''
- endif
- finally
- let &grepprg = grepprg
- let &grepformat = grepformat
- exe cd
- endtry
-endfunction
-
-function! s:Log(cmd)
- let cmd = ['--no-pager', 'log', '--no-color', '--pretty=format:fugitive://'.s:repo().dir().'//%H'.s:buffer().path('/').'::%s']
- if s:buffer().commit() =~# '\x\{40\}'
- let cmd += [s:buffer().commit().'^']
- endif
- let cmd += ['--']
- if s:buffer().path() != ''
- let cmd += [s:buffer().path()]
- endif
- let grepformat = &grepformat
- let grepprg = &grepprg
- try
- let &grepprg = escape(call(s:repo().git_command,cmd,s:repo()),'%')
- let &grepformat = '%f::%m'
- exe a:cmd
- finally
- let &grepformat = grepformat
- let &grepprg = grepprg
- endtry
-endfunction
-
-" }}}1
-" Gedit, Gpedit, Gsplit, Gvsplit, Gtabedit, Gread {{{1
-
-function! s:Edit(cmd,...) abort
- if a:0 && a:1 == ''
- return ''
- elseif a:0
- let file = s:buffer().expand(a:1)
- elseif s:buffer().commit() ==# '' && s:buffer().path('/') !~# '^/.git\>'
- let file = s:buffer().path(':')
- else
- let file = s:buffer().path('/')
- endif
- try
- let file = s:repo().translate(file)
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
- if a:cmd =~# 'read!$'
- return '%delete|read '.s:fnameescape(file).'|1delete_|diffupdate|'.line('.')
- else
- if &previewwindow && getbufvar('','fugitive_type') ==# 'index'
- wincmd p
- endif
- return a:cmd.' '.s:fnameescape(file)
- endif
-endfunction
-
-function! s:EditComplete(A,L,P) abort
- return s:repo().superglob(a:A)
-endfunction
-
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Ge :execute s:Edit('edit<bang>',<f-args>)")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Gedit :execute s:Edit('edit<bang>',<f-args>)")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Gpedit :execute s:Edit('pedit<bang>',<f-args>)")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Gsplit :execute s:Edit('split<bang>',<f-args>)")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Gvsplit :execute s:Edit('vsplit<bang>',<f-args>)")
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Gtabedit :execute s:Edit('tabedit<bang>',<f-args>)")
-call s:command("-bar -bang -nargs=? -range -complete=customlist,s:EditComplete Gread :execute s:Edit('<line1>,<line2>read<bang>',<f-args>)")
-
-" }}}1
-" Gwrite {{{1
-
-call s:command("-bar -bang -nargs=? -complete=customlist,s:EditComplete Gwrite :execute s:Write(<bang>0,<f-args>)")
-
-function! s:Write(force,...) abort
- let mytab = tabpagenr()
- let mybufnr = bufnr('')
- let path = a:0 ? a:1 : s:buffer().path()
- if path =~# '^:\d\>'
- return 'write'.(a:force ? '! ' : ' ').s:fnameescape(s:repo().translate(s:buffer().expand(path)))
- endif
- let always_permitted = (s:buffer().path() ==# path && s:buffer().commit() =~# '^0\=$')
- if !always_permitted && !a:force && s:repo().git_chomp_in_tree('diff','--name-status','HEAD','--',path) . s:repo().git_chomp_in_tree('ls-files','--others','--',path) !=# ''
- let v:errmsg = 'fugitive: file has uncommitted changes (use ! to override)'
- return 'echoerr v:errmsg'
- endif
- let file = s:repo().translate(path)
- let treebufnr = 0
- for nr in range(1,bufnr('$'))
- if fnamemodify(bufname(nr),':p') == file
- let treebufnr = nr
- endif
- endfor
-
- if treebufnr > 0 && treebufnr != bufnr('')
- let temp = tempname()
- silent execute '%write '.temp
- for tab in [mytab] + range(1,tabpagenr('$'))
- for winnr in range(1,tabpagewinnr(tab,'$'))
- if tabpagebuflist(tab)[winnr-1] == treebufnr
- execute 'tabnext '.tab
- if winnr != winnr()
- execute winnr.'wincmd w'
- let restorewinnr = 1
- endif
- try
- let lnum = line('.')
- let last = line('$')
- silent execute '$read '.temp
- silent execute '1,'.last.'delete_'
- silent write!
- silent execute lnum
- let did = 1
- finally
- if exists('restorewinnr')
- wincmd p
- endif
- execute 'tabnext '.mytab
- endtry
- endif
- endfor
- endfor
- if !exists('did')
- call writefile(readfile(temp,'b'),file,'b')
- endif
- else
- execute 'write! '.s:fnameescape(s:repo().translate(path))
- endif
-
- let error = s:repo().git_chomp_in_tree('add', file)
- if v:shell_error
- let v:errmsg = 'fugitive: '.error
- return 'echoerr v:errmsg'
- endif
- if s:buffer().path() == path && s:buffer().commit() =~# '^\d$'
- set nomodified
- endif
-
- let one = s:repo().translate(':1:'.path)
- let two = s:repo().translate(':2:'.path)
- let three = s:repo().translate(':3:'.path)
- for nr in range(1,bufnr('$'))
- if bufloaded(nr) && !getbufvar(nr,'&modified') && (bufname(nr) == one || bufname(nr) == two || bufname(nr) == three)
- execute nr.'bdelete'
- endif
- endfor
-
- unlet! restorewinnr
- let zero = s:repo().translate(':0:'.path)
- for tab in range(1,tabpagenr('$'))
- for winnr in range(1,tabpagewinnr(tab,'$'))
- let bufnr = tabpagebuflist(tab)[winnr-1]
- let bufname = bufname(bufnr)
- if bufname ==# zero && bufnr != mybufnr
- execute 'tabnext '.tab
- if winnr != winnr()
- execute winnr.'wincmd w'
- let restorewinnr = 1
- endif
- try
- let lnum = line('.')
- let last = line('$')
- silent $read `=file`
- silent execute '1,'.last.'delete_'
- silent execute lnum
- set nomodified
- diffupdate
- finally
- if exists('restorewinnr')
- wincmd p
- endif
- execute 'tabnext '.mytab
- endtry
- break
- endif
- endfor
- endfor
- call s:ReloadIndex()
- return 'checktime'
-endfunction
-
-" }}}1
-" Gdiff {{{1
-
-call s:command("-bar -nargs=? -complete=customlist,s:EditComplete Gdiff :execute s:Diff(<f-args>)")
-
-augroup fugitive_diff
- autocmd BufWinLeave * if winnr('$') == 2 && &diff && getbufvar(+expand('<abuf>'), 'git_dir') !=# '' | diffoff! | endif
- autocmd BufWinEnter * if winnr('$') == 1 && &diff && getbufvar(+expand('<abuf>'), 'git_dir') !=# '' | diffoff | endif
-augroup END
-
-function! s:Diff(...) abort
- if exists(':DiffGitCached')
- return 'DiffGitCached'
- elseif (!a:0 || a:1 == ':') && s:buffer().commit() =~# '^[0-1]\=$' && s:repo().git_chomp_in_tree('ls-files', '--unmerged', '--', s:buffer().path()) !=# ''
- leftabove vsplit `=fugitive#buffer().repo().translate(s:buffer().expand(':2'))`
- diffthis
- wincmd p
- rightbelow vsplit `=fugitive#buffer().repo().translate(s:buffer().expand(':3'))`
- diffthis
- wincmd p
- diffthis
- return ''
- elseif a:0
- if a:1 ==# ''
- return ''
- elseif a:1 ==# '/'
- let file = s:buffer().path('/')
- elseif a:1 ==# ':'
- let file = s:buffer().path(':0:')
- elseif a:1 =~# '^:/'
- try
- let file = s:repo().rev_parse(a:1)
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
- else
- let file = s:buffer().expand(a:1)
- endif
- if file !~ ':' && file !~ '^/'
- let file = file.s:buffer().path(':')
- endif
- else
- let file = s:buffer().path(s:buffer().commit() == '' ? ':0:' : '/')
- endif
- try
- vsplit `=fugitive#buffer().repo().translate(file)`
- diffthis
- wincmd p
- diffthis
- return ''
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-" }}}1
-" Gmove, Gremove {{{1
-
-function! s:Move(force,destination)
- if a:destination =~# '^/'
- let destination = a:destination[1:-1]
- else
- let destination = fnamemodify(s:sub(a:destination,'[%#]%(:\w)*','\=expand(submatch(0))'),':p')
- if destination[0:strlen(s:repo().tree())] == s:repo().tree('')
- let destination = destination[strlen(s:repo().tree('')):-1]
- endif
- endif
- let message = call(s:repo().git_chomp_in_tree,['mv']+(a:force ? ['-f'] : [])+['--', s:buffer().path(), destination], s:repo())
- if v:shell_error
- let v:errmsg = 'fugitive: '.message
- return 'echoerr v:errmsg'
- endif
- let destination = s:repo().tree(destination)
- if isdirectory(destination)
- let destination = fnamemodify(s:sub(destination,'/$','').'/'.expand('%:t'),':.')
- endif
- call s:ReloadIndex()
- if s:buffer().commit() == ''
- return 'saveas! '.s:fnameescape(destination)
- else
- return 'file '.s:fnameescape(s:repo.translate(':0:'.destination)
- endif
-endfunction
-
-function! s:MoveComplete(A,L,P)
- if a:A =~ '^/'
- return s:repo().superglob(a:A)
- else
- return split(glob(a:A.'*'),"\n")
- endif
-endfunction
-
-function! s:Remove(force)
- if s:buffer().commit() ==# ''
- let cmd = ['rm']
- elseif s:buffer().commit() ==# '0'
- let cmd = ['rm','--cached']
- else
- let v:errmsg = 'fugitive: rm not supported here'
- return 'echoerr v:errmsg'
- endif
- if a:force
- let cmd += ['--force']
- endif
- let message = call(s:repo().git_chomp_in_tree,cmd+['--',s:buffer().path()],s:repo())
- if v:shell_error
- let v:errmsg = 'fugitive: '.s:sub(message,'error:.*\zs\n\(.*-f.*',' (add ! to force)')
- return 'echoerr '.string(v:errmsg)
- else
- call s:ReloadIndex()
- return 'bdelete'.(a:force ? '!' : '')
- endif
-endfunction
-
-augroup fugitive_remove
- autocmd!
- autocmd User Fugitive if s:buffer().commit() =~# '^0\=$' |
- \ exe "command! -buffer -bar -bang -nargs=1 -complete=customlist,s:MoveComplete Gmove :execute s:Move(<bang>0,<q-args>)" |
- \ exe "command! -buffer -bar -bang Gremove :execute s:Remove(<bang>0)" |
- \ endif
-augroup END
-
-" }}}1
-" Gblame {{{1
-
-augroup fugitive_blame
- autocmd!
- autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame
- autocmd FileType fugitiveblame setlocal nomodeline | if exists('b:git_dir') | let &l:keywordprg = s:repo().keywordprg() | endif
- autocmd Syntax fugitiveblame call s:BlameSyntax()
- autocmd User Fugitive if s:buffer().type('file', 'blob') | exe "command! -buffer -bar -bang -range=0 Gblame :execute s:Blame(<bang>0,<line1>,<line2>,<count>,<f-args>)" | endif
-augroup END
-
-function! s:Blame(bang,line1,line2,count) abort
- try
- if s:buffer().path() == ''
- call s:throw('file or blob required')
- endif
- let git_dir = s:repo().dir()
- let cmd = ['--no-pager', 'blame', '--show-number']
- if strlen(s:buffer().commit()) == 40
- let cmd += [s:buffer().commit()]
- else
- let cmd += ['--contents', '-']
- endif
- let basecmd = call(s:repo().git_command,cmd+['--',s:buffer().path()],s:repo())
- try
- let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
- if !s:repo().bare()
- let dir = getcwd()
- execute cd.' `=s:repo().tree()`'
- endif
- if a:count
- execute 'write !'.substitute(basecmd,' blame ',' blame -L '.a:line1.','.a:line2.' ','g')
- else
- let temp = tempname().'.fugitiveblame'
- silent! exe '%write !'.basecmd.' > '.temp.' 2> '.temp
- if v:shell_error
- call s:throw(join(readfile(temp),"\n"))
- endif
- let bufnr = bufnr('')
- let restore = 'call setbufvar('.bufnr.',"&scrollbind",0)'
- if &l:wrap
- let restore .= '|call setbufvar('.bufnr.',"&wrap",1)'
- endif
- if &l:foldenable
- let restore .= '|call setbufvar('.bufnr.',"&foldenable",1)'
- endif
- let winnr = winnr()
- windo set noscrollbind
- exe winnr.'wincmd w'
- setlocal scrollbind nowrap nofoldenable
- let top = line('w0') + &scrolloff
- let current = line('.')
- exe 'leftabove vsplit '.temp
- let b:git_dir = git_dir
- let b:fugitive_type = 'blame'
- let b:fugitive_blamed_bufnr = bufnr
- let b:fugitive_restore = restore
- call s:Detect()
- execute top
- normal! zt
- execute current
- execute "vertical resize ".(match(getline('.'),'\s\+\d\+)')+1)
- setlocal nomodified nomodifiable nonumber scrollbind nowrap foldcolumn=0 nofoldenable filetype=fugitiveblame
- nnoremap <buffer> <silent> q :<C-U>bdelete<CR>
- nnoremap <buffer> <silent> <CR> :<C-U>exe <SID>BlameJump()<CR>
- nnoremap <buffer> <silent> o :<C-U>exe <SID>Edit((&splitbelow ? "botright" : "topleft")." split", matchstr(getline('.'),'\x\+'))<CR>
- nnoremap <buffer> <silent> O :<C-U>exe <SID>Edit("tabedit", matchstr(getline('.'),'\x\+'))<CR>
- syncbind
- endif
- finally
- if exists('l:dir')
- execute cd.' `=dir`'
- endif
- endtry
- return ''
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-function! s:BlameJump() abort
- let commit = matchstr(getline('.'),'^\^\=\zs\x\+')
- if commit =~# '^0\+$'
- let commit = ':0'
- endif
- let lnum = matchstr(getline('.'),'\d\+\ze (')
- let path = matchstr(getline('.'),'^\^\=\zs\x\+\s\+\zs.\{-\}\ze\s*\d\+ (')
- if path ==# ''
- let path = s:buffer(b:fugitive_blamed_bufnr).path()
- endif
- let offset = line('.') - line('w0')
- let bufnr = bufnr('%')
- let winnr = bufwinnr(b:fugitive_blamed_bufnr)
- if winnr > 0
- exe winnr.'wincmd w'
- endif
- execute s:Edit('edit',commit.':'.path)
- if winnr > 0
- exe bufnr.'bdelete'
- endif
- Gblame
- execute lnum
- let delta = line('.') - line('w0') - offset
- if delta > 0
- execute 'norm! 'delta."\<C-E>"
- elseif delta < 0
- execute 'norm! '(-delta)."\<C-Y>"
- endif
- syncbind
- return ''
-endfunction
-
-function! s:BlameSyntax() abort
- let b:current_syntax = 'fugitiveblame'
- syn match FugitiveblameBoundary "^\^"
- syn match FugitiveblameHash "\%(^\^\=\)\@<=\x\{7,40\}\>" nextgroup=FugitiveblameAnnotation,fugitiveblameOriginalFile,FugitiveblameOriginalLineNumber skipwhite
- syn match FugitiveblameUncommitted "\%(^\^\=\)\@<=0\{7,40\}\>" nextgroup=FugitiveblameAnnotation,FugitiveblameOriginalLineNumber,fugitiveblameOriginalFile skipwhite
- syn region FugitiveblameAnnotation matchgroup=FugitiveblameDelimiter start="(" end="\%( \d\+\)\@<=)" contained keepend oneline
- syn match FugitiveblameTime "[0-9:/+-][0-9:/+ -]*[0-9:/+-]\%( \+\d\+)\)\@=" contained containedin=FugitiveblameAnnotation
- syn match FugitiveblameLineNumber " \@<=\d\+)\@=" contained containedin=FugitiveblameAnnotation
- syn match FugitiveblameOriginalFile " \%(\f\+\D\@<=\|\D\@=\f\+\)\%(\%(\s\+\d\+\)\= (\)\@=" contained nextgroup=FugitiveblameOriginalLineNumber,FugitiveblameAnnotation skipwhite
- syn match FugitiveblameOriginalLineNumber " \@<=\d\+\%( (\)\@=" contained nextgroup=FugitiveblameAnnotation skipwhite
- syn match FugitiveblameNotCommittedYet "(\@<=Not Committed Yet\>" contained containedin=FugitiveblameAnnotation
- hi def link FugitiveblameBoundary Keyword
- hi def link FugitiveblameHash Identifier
- hi def link FugitiveblameUncommitted Function
- hi def link FugitiveblameTime PreProc
- hi def link FugitiveblameLineNumber Number
- hi def link FugitiveblameOriginalFile String
- hi def link FugitiveblameOriginalLineNumber Float
- hi def link FugitiveblameDelimiter Delimiter
- hi def link FugitiveblameNotCommittedYet Comment
-endfunction
-
-" }}}1
-" File access {{{1
-
-function! s:ReplaceCmd(cmd) abort
- let fn = bufname('')
- let tmp = tempname()
- let aw = &autowrite
- try
- set noautowrite
- silent exe '!'.escape(a:cmd,'%#') ' > '.tmp
- finally
- let &autowrite = aw
- endtry
- silent exe 'keepalt file '.tmp
- silent edit!
- silent exe 'keepalt file '.s:fnameescape(fn)
- call delete(tmp)
- silent exe 'doau BufReadPost '.s:fnameescape(fn)
-endfunction
-
-function! s:BufReadIndex()
- if !exists('b:fugitive_display_format')
- let b:fugitive_display_format = +getbufvar('#','fugitive_display_format')
- endif
- let b:fugitive_display_format = b:fugitive_display_format % 2
- let b:fugitive_type = 'index'
- try
- let b:git_dir = s:repo().dir()
- setlocal noro ma
- if b:fugitive_display_format
- call s:ReplaceCmd(s:repo().git_command('ls-files','--stage'))
- set ft=git nospell
- else
- let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
- let dir = getcwd()
- try
- execute cd.' `=s:repo().tree()`'
- call s:ReplaceCmd(s:repo().git_command('status'))
- finally
- execute cd.' `=dir`'
- endtry
- set ft=gitcommit
- endif
- setlocal ro noma nomod nomodeline bufhidden=delete
- nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += 1<Bar>exe <SID>BufReadIndex()<CR>
- nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= 1<Bar>exe <SID>BufReadIndex()<CR>
- nnoremap <buffer> <silent> - :<C-U>execute <SID>StageToggle(line('.'),line('.')+v:count1-1)<CR>
- xnoremap <buffer> <silent> - :<C-U>execute <SID>StageToggle(line("'<"),line("'>"))<CR>
- call s:JumpInit()
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-function! s:FileRead()
- try
- let repo = s:repo(s:ExtractGitDir(expand('<amatch>')))
- let path = s:sub(s:sub(matchstr(expand('<amatch>'),'fugitive://.\{-\}//\zs.*'),'/',':'),'^\d:',':&')
- let hash = repo.rev_parse(path)
- if path =~ '^:'
- let type = 'blob'
- else
- let type = repo.git_chomp('cat-file','-t',hash)
- endif
- " TODO: use count, if possible
- return "read !".escape(repo.git_command('cat-file',type,hash),'%#\')
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-function! s:BufReadIndexFile()
- try
- let b:fugitive_type = 'blob'
- let b:git_dir = s:repo().dir()
- call s:ReplaceCmd(s:repo().git_command('cat-file','blob',s:buffer().sha1()))
- return ''
- catch /^fugitive: rev-parse/
- silent exe 'doau BufNewFile '.s:fnameescape(bufname(''))
- return ''
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-function! s:BufWriteIndexFile()
- let tmp = tempname()
- try
- let path = matchstr(expand('<amatch>'),'//\d/\zs.*')
- let stage = matchstr(expand('<amatch>'),'//\zs\d')
- silent execute 'write !'.s:repo().git_command('hash-object','-w','--stdin').' > '.tmp
- let sha1 = readfile(tmp)[0]
- let old_mode = matchstr(s:repo().git_chomp('ls-files','--stage',path),'^\d\+')
- if old_mode == ''
- let old_mode = executable(s:repo().tree(path)) ? '100755' : '100644'
- endif
- let info = old_mode.' '.sha1.' '.stage."\t".path
- call writefile([info],tmp)
- let error = system(s:repo().git_command('update-index','--index-info').' < '.tmp)
- if v:shell_error == 0
- setlocal nomodified
- silent execute 'doautocmd BufWritePost '.s:fnameescape(expand('%:p'))
- call s:ReloadIndex()
- return ''
- else
- return 'echoerr '.string('fugitive: '.error)
- endif
- finally
- call delete(tmp)
- endtry
-endfunction
-
-function! s:BufReadObject()
- try
- setlocal noro ma
- let b:git_dir = s:repo().dir()
- let hash = s:buffer().sha1()
- if !exists("b:fugitive_type")
- let b:fugitive_type = s:repo().git_chomp('cat-file','-t',hash)
- endif
- if b:fugitive_type !~# '^\%(tag\|commit\|tree\|blob\)$'
- return "echoerr 'fugitive: unrecognized git type'"
- endif
- let firstline = getline('.')
- if !exists('b:fugitive_display_format') && b:fugitive_type != 'blob'
- let b:fugitive_display_format = +getbufvar('#','fugitive_display_format')
- endif
-
- let pos = getpos('.')
- silent %delete
- setlocal endofline
-
- if b:fugitive_type == 'tree'
- let b:fugitive_display_format = b:fugitive_display_format % 2
- if b:fugitive_display_format
- call s:ReplaceCmd(s:repo().git_command('ls-tree',hash))
- else
- call s:ReplaceCmd(s:repo().git_command('show',hash))
- endif
- elseif b:fugitive_type == 'tag'
- let b:fugitive_display_format = b:fugitive_display_format % 2
- if b:fugitive_display_format
- call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
- else
- call s:ReplaceCmd(s:repo().git_command('cat-file','-p',hash))
- endif
- elseif b:fugitive_type == 'commit'
- let b:fugitive_display_format = b:fugitive_display_format % 2
- if b:fugitive_display_format
- call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
- else
- call s:ReplaceCmd(s:repo().git_command('show','--pretty=format:tree %T%nparent %P%nauthor %an <%ae> %ad%ncommitter %cn <%ce> %cd%nencoding %e%n%n%s%n%n%b',hash))
- call search('^parent ')
- silent s/\%(^parent\)\@<! /\rparent /ge
- if search('^encoding \%(<unknown>\)\=$','W',line('.')+3)
- silent delete
- end
- 1
- endif
- elseif b:fugitive_type ==# 'blob'
- call s:ReplaceCmd(s:repo().git_command('cat-file',b:fugitive_type,hash))
- endif
- call setpos('.',pos)
- setlocal ro noma nomod nomodeline
- if b:fugitive_type !=# 'blob'
- set filetype=git
- nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += v:count1<Bar>exe <SID>BufReadObject()<CR>
- nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= v:count1<Bar>exe <SID>BufReadObject()<CR>
- else
- call s:JumpInit()
- endif
-
- return ''
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-augroup fugitive_files
- autocmd!
- autocmd BufReadCmd *.git/index exe s:BufReadIndex()
- autocmd FileReadCmd fugitive://**//[0-3]/** exe s:FileRead()
- autocmd BufReadCmd fugitive://**//[0-3]/** exe s:BufReadIndexFile()
- autocmd BufWriteCmd fugitive://**//[0-3]/** exe s:BufWriteIndexFile()
- autocmd BufReadCmd fugitive://**//[0-9a-f][0-9a-f]* exe s:BufReadObject()
- autocmd FileReadCmd fugitive://**//[0-9a-f][0-9a-f]* exe s:FileRead()
- autocmd FileType git call s:JumpInit()
-augroup END
-
-" }}}1
-" Go to file {{{1
-
-function! s:JumpInit() abort
- nnoremap <buffer> <silent> <CR> :<C-U>exe <SID>GF("edit")<CR>
- if !&modifiable
- nnoremap <buffer> <silent> o :<C-U>exe <SID>GF("split")<CR>
- nnoremap <buffer> <silent> O :<C-U>exe <SID>GF("tabedit")<CR>
- nnoremap <buffer> <silent> P :<C-U>exe <SID>Edit('edit',<SID>buffer().commit().'^'.v:count1.<SID>buffer().path(':'))<CR>
- nnoremap <buffer> <silent> ~ :<C-U>exe <SID>Edit('edit',<SID>buffer().commit().'~'.v:count1.<SID>buffer().path(':'))<CR>
- nnoremap <buffer> <silent> C :<C-U>exe <SID>Edit('edit',<SID>buffer().containing_commit())<CR>
- nnoremap <buffer> <silent> c :<C-U>exe <SID>Edit('pedit',<SID>buffer().containing_commit())<CR>
- endif
-endfunction
-
-function! s:GF(mode) abort
- try
- let buffer = s:buffer()
- let myhash = buffer.sha1()
-
- if buffer.type('tree')
- let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
- if showtree && line('.') == 1
- return ""
- elseif showtree && line('.') > 2
- return s:Edit(a:mode,buffer.commit().':'.(buffer.path() == '' ? '' : buffer.path().'/').s:sub(getline('.'),'/$',''))
- elseif getline('.') =~# '^\d\{6\} \l\{3,8\} \x\{40\}\t'
- return s:Edit(a:mode,buffer.commit().':'.(buffer.path() == '' ? '' : buffer.path().'/').s:sub(matchstr(getline('.'),'\t\zs.*'),'/$',''))
- endif
-
- elseif buffer.type('blob')
- let ref = expand("<cfile>")
- try
- let sha1 = buffer.repo().rev_parse(ref)
- catch /^fugitive:/
- endtry
- if exists('sha1')
- return s:Edit(a:mode,ref)
- endif
-
- else
-
- " Index
- if getline('.') =~# '^\d\{6\} \x\{40\} \d\t'
- let ref = matchstr(getline('.'),'\x\{40\}')
- let file = ':'.s:sub(matchstr(getline('.'),'\d\t.*'),'\t',':')
- return s:Edit(a:mode,file)
-
- elseif getline('.') =~# '^#\trenamed:.* -> '
- let file = '/'.matchstr(getline('.'),' -> \zs.*')
- return s:Edit(a:mode,file)
- elseif getline('.') =~# '^#\t[[:alpha:] ]\+: *.'
- let file = '/'.matchstr(getline('.'),': *\zs.*')
- return s:Edit(a:mode,file)
- elseif getline('.') =~# '^#\t.'
- let file = '/'.matchstr(getline('.'),'#\t\zs.*')
- return s:Edit(a:mode,file)
- elseif getline('.') =~# ': needs merge$'
- let file = '/'.matchstr(getline('.'),'.*\ze: needs merge$')
- return s:Edit(a:mode,file).'|Gdiff'
-
- elseif getline('.') ==# '# Not currently on any branch.'
- return s:Edit(a:mode,'HEAD')
- elseif getline('.') =~# '^# On branch '
- let file = 'refs/heads/'.getline('.')[12:]
- return s:Edit(a:mode,file)
- elseif getline('.') =~# "^# Your branch .*'"
- let file = 'refs/remotes/'.matchstr(getline('.'),"'\\zs\\S\\+\\ze'")
- return s:Edit(a:mode,file)
- endif
-
- let showtree = (getline(1) =~# '^tree ' && getline(2) == "")
-
- if getline('.') =~# '^ref: '
- let ref = strpart(getline('.'),5)
-
- elseif getline('.') =~# '^parent \x\{40\}\>'
- let ref = matchstr(getline('.'),'\x\{40\}')
- let line = line('.')
- let parent = 0
- while getline(line) =~# '^parent '
- let parent += 1
- let line -= 1
- endwhile
- return s:Edit(a:mode,ref)
-
- elseif getline('.') =~ '^tree \x\{40\}$'
- let ref = matchstr(getline('.'),'\x\{40\}')
- if s:repo().rev_parse(myhash.':') == ref
- let ref = myhash.':'
- endif
- return s:Edit(a:mode,ref)
-
- elseif getline('.') =~# '^object \x\{40\}$' && getline(line('.')+1) =~ '^type \%(commit\|tree\|blob\)$'
- let ref = matchstr(getline('.'),'\x\{40\}')
- let type = matchstr(getline(line('.')+1),'type \zs.*')
-
- elseif getline('.') =~# '^\l\{3,8\} '.myhash.'$'
- return ''
-
- elseif getline('.') =~# '^\l\{3,8\} \x\{40\}\>'
- let ref = matchstr(getline('.'),'\x\{40\}')
- echoerr "warning: unknown context ".matchstr(getline('.'),'^\l*')
-
- elseif getline('.') =~# '^[+-]\{3\} [ab/]'
- let ref = getline('.')[4:]
-
- elseif getline('.') =~# '^rename from '
- let ref = 'a/'.getline('.')[12:]
- elseif getline('.') =~# '^rename to '
- let ref = 'b/'.getline('.')[10:]
-
- elseif getline('.') =~# '^diff --git \%(a/.*\|/dev/null\) \%(b/.*\|/dev/null\)'
- let dref = matchstr(getline('.'),'\Cdiff --git \zs\%(a/.*\|/dev/null\)\ze \%(b/.*\|/dev/null\)')
- let ref = matchstr(getline('.'),'\Cdiff --git \%(a/.*\|/dev/null\) \zs\%(b/.*\|/dev/null\)')
-
- elseif line('$') == 1 && getline('.') =~ '^\x\{40\}$'
- let ref = getline('.')
- else
- let ref = ''
- endif
-
- if myhash ==# ''
- let ref = s:sub(ref,'^a/','HEAD:')
- let ref = s:sub(ref,'^b/',':0:')
- if exists('dref')
- let dref = s:sub(dref,'^a/','HEAD:')
- endif
- else
- let ref = s:sub(ref,'^a/',myhash.'^:')
- let ref = s:sub(ref,'^b/',myhash.':')
- if exists('dref')
- let dref = s:sub(dref,'^a/',myhash.'^:')
- endif
- endif
-
- if ref == '/dev/null'
- " Empty blob
- let ref = 'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391'
- endif
-
- if exists('dref')
- return s:Edit(a:mode,ref) . '|Gdiff '.s:fnameescape(dref)
- elseif ref != ""
- return s:Edit(a:mode,ref)
- endif
-
- endif
- return ''
- catch /^fugitive:/
- return 'echoerr v:errmsg'
- endtry
-endfunction
-
-" }}}1
-
-" vim:set ft=vim ts=8 sw=2 sts=2:
diff --git a/vim/plugin/surround.vim b/vim/plugin/surround.vim
deleted file mode 100644
index 8421bd1..0000000
--- a/vim/plugin/surround.vim
+++ /dev/null
@@ -1,628 +0,0 @@
-" surround.vim - Surroundings
-" Author: Tim Pope <vimNOSPAM@tpope.info>
-" GetLatestVimScripts: 1697 1 :AutoInstall: surround.vim
-" $Id: surround.vim,v 1.34 2008-02-15 21:43:42 tpope Exp $
-"
-" See surround.txt for help. This can be accessed by doing
-"
-" :helptags ~/.vim/doc
-" :help surround
-"
-" Licensed under the same terms as Vim itself.
-
-" ============================================================================
-
-" Exit quickly when:
-" - this plugin was already loaded or disabled
-" - when 'compatible' is set
-if (exists("g:loaded_surround") && g:loaded_surround) || &cp
- finish
-endif
-let g:loaded_surround = 1
-
-let s:cpo_save = &cpo
-set cpo&vim
-
-" Input functions {{{1
-
-function! s:getchar()
- let c = getchar()
- if c =~ '^\d\+$'
- let c = nr2char(c)
- endif
- return c
-endfunction
-
-function! s:inputtarget()
- let c = s:getchar()
- while c =~ '^\d\+$'
- let c = c . s:getchar()
- endwhile
- if c == " "
- let c = c . s:getchar()
- endif
- if c =~ "\<Esc>\|\<C-C>\|\0"
- return ""
- else
- return c
- endif
-endfunction
-
-function! s:inputreplacement()
- "echo '-- SURROUND --'
- let c = s:getchar()
- if c == " "
- let c = c . s:getchar()
- endif
- if c =~ "\<Esc>" || c =~ "\<C-C>"
- return ""
- else
- return c
- endif
-endfunction
-
-function! s:beep()
- exe "norm! \<Esc>"
- return ""
-endfunction
-
-function! s:redraw()
- redraw
- return ""
-endfunction
-
-" }}}1
-
-" Wrapping functions {{{1
-
-function! s:extractbefore(str)
- if a:str =~ '\r'
- return matchstr(a:str,'.*\ze\r')
- else
- return matchstr(a:str,'.*\ze\n')
- endif
-endfunction
-
-function! s:extractafter(str)
- if a:str =~ '\r'
- return matchstr(a:str,'\r\zs.*')
- else
- return matchstr(a:str,'\n\zs.*')
- endif
-endfunction
-
-function! s:repeat(str,count)
- let cnt = a:count
- let str = ""
- while cnt > 0
- let str = str . a:str
- let cnt = cnt - 1
- endwhile
- return str
-endfunction
-
-function! s:fixindent(str,spc)
- let str = substitute(a:str,'\t',s:repeat(' ',&sw),'g')
- let spc = substitute(a:spc,'\t',s:repeat(' ',&sw),'g')
- let str = substitute(str,'\(\n\|\%^\).\@=','\1'.spc,'g')
- if ! &et
- let str = substitute(str,'\s\{'.&ts.'\}',"\t",'g')
- endif
- return str
-endfunction
-
-function! s:process(string)
- let i = 0
- while i < 7
- let i = i + 1
- let repl_{i} = ''
- let m = matchstr(a:string,nr2char(i).'.\{-\}\ze'.nr2char(i))
- if m != ''
- let m = substitute(strpart(m,1),'\r.*','','')
- let repl_{i} = input(substitute(m,':\s*$','','').': ')
- endif
- endwhile
- let s = ""
- let i = 0
- while i < strlen(a:string)
- let char = strpart(a:string,i,1)
- if char2nr(char) < 8
- let next = stridx(a:string,char,i+1)
- if next == -1
- let s = s . char
- else
- let insertion = repl_{char2nr(char)}
- let subs = strpart(a:string,i+1,next-i-1)
- let subs = matchstr(subs,'\r.*')
- while subs =~ '^\r.*\r'
- let sub = matchstr(subs,"^\r\\zs[^\r]*\r[^\r]*")
- let subs = strpart(subs,strlen(sub)+1)
- let r = stridx(sub,"\r")
- let insertion = substitute(insertion,strpart(sub,0,r),strpart(sub,r+1),'')
- endwhile
- let s = s . insertion
- let i = next
- endif
- else
- let s = s . char
- endif
- let i = i + 1
- endwhile
- return s
-endfunction
-
-function! s:wrap(string,char,type,...)
- let keeper = a:string
- let newchar = a:char
- let type = a:type
- let linemode = type ==# 'V' ? 1 : 0
- let special = a:0 ? a:1 : 0
- let before = ""
- let after = ""
- if type == "V"
- let initspaces = matchstr(keeper,'\%^\s*')
- else
- let initspaces = matchstr(getline('.'),'\%^\s*')
- endif
- " Duplicate b's are just placeholders (removed)
- let pairs = "b()B{}r[]a<>"
- let extraspace = ""
- if newchar =~ '^ '
- let newchar = strpart(newchar,1)
- let extraspace = ' '
- endif
- let idx = stridx(pairs,newchar)
- if newchar == ' '
- let before = ''
- let after = ''
- elseif exists("b:surround_".char2nr(newchar))
- let all = s:process(b:surround_{char2nr(newchar)})
- let before = s:extractbefore(all)
- let after = s:extractafter(all)
- elseif exists("g:surround_".char2nr(newchar))
- let all = s:process(g:surround_{char2nr(newchar)})
- let before = s:extractbefore(all)
- let after = s:extractafter(all)
- elseif newchar ==# "p"
- let before = "\n"
- let after = "\n\n"
- elseif newchar =~# "[tT\<C-T><,]"
- let dounmapp = 0
- let dounmapb = 0
- if !maparg(">","c")
- let dounmapb= 1
- " Hide from AsNeeded
- exe "cn"."oremap > <CR>"
- exe "cn"."oremap % %<C-V>"
- "cm ap > <C-R>=getcmdline() =~ '^[^%?].*[%?]$' ? "\026\076" : "\026\076\015"<CR>
- endif
- let default = ""
- if !maparg("%","c")
- " This is to help when typing things like
- " <a href="/images/<%= @image.filename %>">
- " The downside is it breaks backspace, so lets disable it for now
- "let dounmapp= 1
- "exe "cn"."oremap % %<C-V>"
- endif
- if newchar ==# "T"
- if !exists("s:lastdel")
- let s:lastdel = ""
- endif
- let default = matchstr(s:lastdel,'<\zs.\{-\}\ze>')
- endif
- let tag = input("<",default)
- echo "<".substitute(tag,'>*$','>','')
- "if dounmapr
- "silent! cunmap <CR>
- "endif
- if dounmapb
- silent! cunmap >
- endif
- if dounmapp
- silent! cunmap %
- endif
- if tag != ""
- let tag = substitute(tag,'>*$','','')
- let before = '<'.tag.'>'
- if tag =~ '/$'
- let after = ''
- else
- let after = '</'.substitute(tag,' .*','','').'>'
- endif
- if newchar == "\<C-T>" || newchar == ","
- if type ==# "v" || type ==# "V"
- let before = before . "\n\t"
- endif
- if type ==# "v"
- let after = "\n". after
- endif
- endif
- endif
- elseif newchar ==# 'l' || newchar == '\'
- " LaTeX
- let env = input('\begin{')
- let env = '{' . env
- let env = env . s:closematch(env)
- echo '\begin'.env
- if env != ""
- let before = '\begin'.env
- let after = '\end'.matchstr(env,'[^}]*').'}'
- endif
- "if type ==# 'v' || type ==# 'V'
- "let before = before ."\n\t"
- "endif
- "if type ==# 'v'
- "let after = "\n".initspaces.after
- "endif
- elseif newchar ==# 'f' || newchar ==# 'F'
- let fnc = input('function: ')
- if fnc != ""
- let before = substitute(fnc,'($','','').'('
- let after = ')'
- if newchar ==# 'F'
- let before = before . ' '
- let after = ' ' . after
- endif
- endif
- elseif idx >= 0
- let spc = (idx % 3) == 1 ? " " : ""
- let idx = idx / 3 * 3
- let before = strpart(pairs,idx+1,1) . spc
- let after = spc . strpart(pairs,idx+2,1)
- elseif newchar == "\<C-[>" || newchar == "\<C-]>"
- let before = "{\n\t"
- let after = "\n}"
- elseif newchar !~ '\a'
- let before = newchar
- let after = newchar
- else
- let before = ''
- let after = ''
- endif
- "let before = substitute(before,'\n','\n'.initspaces,'g')
- let after = substitute(after ,'\n','\n'.initspaces,'g')
- "let after = substitute(after,"\n\\s*\<C-U>\\s*",'\n','g')
- if type ==# 'V' || (special && type ==# "v")
- let before = substitute(before,' \+$','','')
- let after = substitute(after ,'^ \+','','')
- if after !~ '^\n'
- let after = initspaces.after
- endif
- if keeper !~ '\n$' && after !~ '^\n'
- let keeper = keeper . "\n"
- elseif keeper =~ '\n$' && after =~ '^\n'
- let after = strpart(after,1)
- endif
- if before !~ '\n\s*$'
- let before = before . "\n"
- if special
- let before = before . "\t"
- endif
- endif
- endif
- if type ==# 'V'
- let before = initspaces.before
- endif
- if before =~ '\n\s*\%$'
- if type ==# 'v'
- let keeper = initspaces.keeper
- endif
- let padding = matchstr(before,'\n\zs\s\+\%$')
- let before = substitute(before,'\n\s\+\%$','\n','')
- let keeper = s:fixindent(keeper,padding)
- endif
- if type ==# 'V'
- let keeper = before.keeper.after
- elseif type =~ "^\<C-V>"
- " Really we should be iterating over the buffer
- let repl = substitute(before,'[\\~]','\\&','g').'\1'.substitute(after,'[\\~]','\\&','g')
- let repl = substitute(repl,'\n',' ','g')
- let keeper = substitute(keeper."\n",'\(.\{-\}\)\('.(special ? '\s\{-\}' : '').'\n\)',repl.'\n','g')
- let keeper = substitute(keeper,'\n\%$','','')
- else
- let keeper = before.extraspace.keeper.extraspace.after
- endif
- return keeper
-endfunction
-
-function! s:wrapreg(reg,char,...)
- let orig = getreg(a:reg)
- let type = substitute(getregtype(a:reg),'\d\+$','','')
- let special = a:0 ? a:1 : 0
- let new = s:wrap(orig,a:char,type,special)
- call setreg(a:reg,new,type)
-endfunction
-" }}}1
-
-function! s:insert(...) " {{{1
- " Optional argument causes the result to appear on 3 lines, not 1
- "call inputsave()
- let linemode = a:0 ? a:1 : 0
- let char = s:inputreplacement()
- while char == "\<CR>" || char == "\<C-W>"
- " TODO: use total count for additional blank lines
- let linemode = linemode + 1
- let char = s:inputreplacement()
- endwhile
- "call inputrestore()
- if char == ""
- return ""
- endif
- "call inputsave()
- let cb_save = &clipboard
- let reg_save = @@
- call setreg('"',"\r",'v')
- call s:wrapreg('"',char,linemode)
- " If line mode is used and the surrounding consists solely of a suffix,
- " remove the initial newline. This fits a use case of mine but is a
- " little inconsistent. Is there anyone that would prefer the simpler
- " behavior of just inserting the newline?
- if linemode && match(getreg('"'),'^\n\s*\zs.*') == 0
- call setreg('"',matchstr(getreg('"'),'^\n\s*\zs.*'),getregtype('"'))
- endif
- " This can be used to append a placeholder to the end
- if exists("g:surround_insert_tail")
- call setreg('"',g:surround_insert_tail,"a".getregtype('"'))
- endif
- "if linemode
- "call setreg('"',substitute(getreg('"'),'^\s\+','',''),'c')
- "endif
- if col('.') >= col('$')
- norm! ""p
- else
- norm! ""P
- endif
- if linemode
- call s:reindent()
- endif
- norm! `]
- call search('\r','bW')
- let @@ = reg_save
- let &clipboard = cb_save
- return "\<Del>"
-endfunction " }}}1
-
-function! s:reindent() " {{{1
- if exists("b:surround_indent") ? b:surround_indent : (exists("g:surround_indent") && g:surround_indent)
- silent norm! '[=']
- endif
-endfunction " }}}1
-
-function! s:dosurround(...) " {{{1
- let scount = v:count1
- let char = (a:0 ? a:1 : s:inputtarget())
- let spc = ""
- if char =~ '^\d\+'
- let scount = scount * matchstr(char,'^\d\+')
- let char = substitute(char,'^\d\+','','')
- endif
- if char =~ '^ '
- let char = strpart(char,1)
- let spc = 1
- endif
- if char == 'a'
- let char = '>'
- endif
- if char == 'r'
- let char = ']'
- endif
- let newchar = ""
- if a:0 > 1
- let newchar = a:2
- if newchar == "\<Esc>" || newchar == "\<C-C>" || newchar == ""
- return s:beep()
- endif
- endif
- let cb_save = &clipboard
- set clipboard-=unnamed
- let append = ""
- let original = getreg('"')
- let otype = getregtype('"')
- call setreg('"',"")
- let strcount = (scount == 1 ? "" : scount)
- if char == '/'
- exe 'norm '.strcount.'[/d'.strcount.']/'
- else
- exe 'norm d'.strcount.'i'.char
- endif
- let keeper = getreg('"')
- let okeeper = keeper " for reindent below
- if keeper == ""
- call setreg('"',original,otype)
- let &clipboard = cb_save
- return ""
- endif
- let oldline = getline('.')
- let oldlnum = line('.')
- if char ==# "p"
- call setreg('"','','V')
- elseif char ==# "s" || char ==# "w" || char ==# "W"
- " Do nothing
- call setreg('"','')
- elseif char =~ "[\"'`]"
- exe "norm! i \<Esc>d2i".char
- call setreg('"',substitute(getreg('"'),' ','',''))
- elseif char == '/'
- norm! "_x
- call setreg('"','/**/',"c")
- let keeper = substitute(substitute(keeper,'^/\*\s\=','',''),'\s\=\*$','','')
- else
- " One character backwards
- call search('.','bW')
- exe "norm da".char
- endif
- let removed = getreg('"')
- let rem2 = substitute(removed,'\n.*','','')
- let oldhead = strpart(oldline,0,strlen(oldline)-strlen(rem2))
- let oldtail = strpart(oldline, strlen(oldline)-strlen(rem2))
- let regtype = getregtype('"')
- if char =~# '[\[({<T]' || spc
- let keeper = substitute(keeper,'^\s\+','','')
- let keeper = substitute(keeper,'\s\+$','','')
- endif
- if col("']") == col("$") && col('.') + 1 == col('$')
- if oldhead =~# '^\s*$' && a:0 < 2
- let keeper = substitute(keeper,'\%^\n'.oldhead.'\(\s*.\{-\}\)\n\s*\%$','\1','')
- endif
- let pcmd = "p"
- else
- let pcmd = "P"
- endif
- if line('.') < oldlnum && regtype ==# "V"
- let pcmd = "p"
- endif
- call setreg('"',keeper,regtype)
- if newchar != ""
- call s:wrapreg('"',newchar)
- endif
- silent exe 'norm! ""'.pcmd.'`['
- if removed =~ '\n' || okeeper =~ '\n' || getreg('"') =~ '\n'
- call s:reindent()
- endif
- if getline('.') =~ '^\s\+$' && keeper =~ '^\s*\n'
- silent norm! cc
- endif
- call setreg('"',removed,regtype)
- let s:lastdel = removed
- let &clipboard = cb_save
- if newchar == ""
- silent! call repeat#set("\<Plug>Dsurround".char,scount)
- else
- silent! call repeat#set("\<Plug>Csurround".char.newchar,scount)
- endif
-endfunction " }}}1
-
-function! s:changesurround() " {{{1
- let a = s:inputtarget()
- if a == ""
- return s:beep()
- endif
- let b = s:inputreplacement()
- if b == ""
- return s:beep()
- endif
- call s:dosurround(a,b)
-endfunction " }}}1
-
-function! s:opfunc(type,...) " {{{1
- let char = s:inputreplacement()
- if char == ""
- return s:beep()
- endif
- let reg = '"'
- let sel_save = &selection
- let &selection = "inclusive"
- let cb_save = &clipboard
- set clipboard-=unnamed
- let reg_save = getreg(reg)
- let reg_type = getregtype(reg)
- "call setreg(reg,"\n","c")
- let type = a:type
- if a:type == "char"
- silent exe 'norm! v`[o`]"'.reg.'y'
- let type = 'v'
- elseif a:type == "line"
- silent exe 'norm! `[V`]"'.reg.'y'
- let type = 'V'
- elseif a:type ==# "v" || a:type ==# "V" || a:type ==# "\<C-V>"
- silent exe 'norm! gv"'.reg.'y'
- elseif a:type =~ '^\d\+$'
- let type = 'v'
- silent exe 'norm! ^v'.a:type.'$h"'.reg.'y'
- if mode() == 'v'
- norm! v
- return s:beep()
- endif
- else
- let &selection = sel_save
- let &clipboard = cb_save
- return s:beep()
- endif
- let keeper = getreg(reg)
- if type == "v" && a:type != "v"
- let append = matchstr(keeper,'\_s\@<!\s*$')
- let keeper = substitute(keeper,'\_s\@<!\s*$','','')
- endif
- call setreg(reg,keeper,type)
- call s:wrapreg(reg,char,a:0)
- if type == "v" && a:type != "v" && append != ""
- call setreg(reg,append,"ac")
- endif
- silent exe 'norm! gv'.(reg == '"' ? '' : '"' . reg).'p`['
- if type == 'V' || (getreg(reg) =~ '\n' && type == 'v')
- call s:reindent()
- endif
- call setreg(reg,reg_save,reg_type)
- let &selection = sel_save
- let &clipboard = cb_save
- if a:type =~ '^\d\+$'
- silent! call repeat#set("\<Plug>Y".(a:0 ? "S" : "s")."surround".char,a:type)
- endif
-endfunction
-
-function! s:opfunc2(arg)
- call s:opfunc(a:arg,1)
-endfunction " }}}1
-
-function! s:closematch(str) " {{{1
- " Close an open (, {, [, or < on the command line.
- let tail = matchstr(a:str,'.[^\[\](){}<>]*$')
- if tail =~ '^\[.\+'
- return "]"
- elseif tail =~ '^(.\+'
- return ")"
- elseif tail =~ '^{.\+'
- return "}"
- elseif tail =~ '^<.+'
- return ">"
- else
- return ""
- endif
-endfunction " }}}1
-
-nnoremap <silent> <Plug>Dsurround :<C-U>call <SID>dosurround(<SID>inputtarget())<CR>
-nnoremap <silent> <Plug>Csurround :<C-U>call <SID>changesurround()<CR>
-nnoremap <silent> <Plug>Yssurround :<C-U>call <SID>opfunc(v:count1)<CR>
-nnoremap <silent> <Plug>YSsurround :<C-U>call <SID>opfunc2(v:count1)<CR>
-" <C-U> discards the numerical argument but there's not much we can do with it
-nnoremap <silent> <Plug>Ysurround :<C-U>set opfunc=<SID>opfunc<CR>g@
-nnoremap <silent> <Plug>YSurround :<C-U>set opfunc=<SID>opfunc2<CR>g@
-vnoremap <silent> <Plug>Vsurround :<C-U>call <SID>opfunc(visualmode())<CR>
-vnoremap <silent> <Plug>VSurround :<C-U>call <SID>opfunc2(visualmode())<CR>
-inoremap <silent> <Plug>Isurround <C-R>=<SID>insert()<CR>
-inoremap <silent> <Plug>ISurround <C-R>=<SID>insert(1)<CR>
-
-if !exists("g:surround_no_mappings") || ! g:surround_no_mappings
- nmap dw <Plug>Dsurround
- nmap cw <Plug>Csurround
- nmap yw <Plug>Ysurround
- nmap yW <Plug>YSurround
- nmap yww <Plug>Yssurround
- nmap yWw <Plug>YSsurround
- nmap yWW <Plug>YSsurround
- if !hasmapto("<Plug>Vsurround","v")
- if exists(":xmap")
- xmap w <Plug>Vsurround
- else
- vmap w <Plug>Vsurround
- endif
- endif
- if !hasmapto("<Plug>VSurround","v")
- if exists(":xmap")
- xmap W <Plug>VSurround
- else
- vmap W <Plug>VSurround
- endif
- endif
- if !hasmapto("<Plug>Isurround","i") && "" == mapcheck("<C-W>","i")
- imap <C-W> <Plug>Isurround
- endif
- imap <C-G>w <Plug>Isurround
- imap <C-G>W <Plug>ISurround
- "Implemented internally instead
- "imap <C-S><C-S> <Plug>ISurround
-endif
-
-let &cpo = s:cpo_save
-
-" vim:set ft=vim sw=4 sts=4 et:
diff --git a/vim/plugin/taglist.vim b/vim/plugin/taglist.vim
deleted file mode 100644
index 59901f6..0000000
--- a/vim/plugin/taglist.vim
+++ /dev/null
@@ -1,4546 +0,0 @@
-" File: taglist.vim
-" Author: Yegappan Lakshmanan (yegappan AT yahoo DOT com)
-" Version: 4.5
-" Last Modified: September 21, 2007
-" Copyright: 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.
-"
-" The "Tag List" plugin is a source code browser plugin for Vim and provides
-" an overview of the structure of the programming language files and allows
-" you to efficiently browse through source code files for different
-" programming languages. You can visit the taglist plugin home page for more
-" information:
-"
-" http://vim-taglist.sourceforge.net
-"
-" You can subscribe to the taglist mailing list to post your questions
-" or suggestions for improvement or to report bugs. Visit the following
-" page for subscribing to the mailing list:
-"
-" http://groups.yahoo.com/group/taglist/
-"
-" 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.vim - main taglist plugin file
-" doc/taglist.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
- 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'
-
-" 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, '" + : Open a fold')
- call append(9, '" - : Close a fold')
- call append(10, '" * : Open all folds')
- call append(11, '" = : Close all folds')
- call append(12, '" [[ : Move to the start of previous file')
- call append(13, '" ]] : Move to the start of next file')
- call append(14, '" q : Close the taglist window')
- call append(15, '" <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 match TagListTagScope '\s\[.\{-\}\]$'
-
- " 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 TagListTagScope MyTagListTagScope
- else
- highlight clear TagListTagScope
- highlight default link TagListTagScope Identifier
- 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>
- 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
-
- " 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)
-
- " 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 = strridx(tag_line, 'line:') + 5
- let end = strridx(tag_line, "\t")
- 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)
- 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 tag_scope = s:Tlist_Extract_Tag_Scope(a:tag_line)
- if tag_scope != ''
- let ttxt = ttxt . ' [' . tag_scope . ']'
- endif
- 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
-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 = ctags_args . '--sort=yes'
- else
- let ctags_args = ctags_args . '--sort=no'
- endif
-
- " Add the filetype specific arguments
- let ctags_args = ctags_args . ' ' . s:tlist_{a:ftype}_ctags_args
-
- " Ctags command to produce output with regexp for locating the tags
- let ctags_cmd = g:Tlist_Ctags_Cmd . ctags_args
- 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
-
- " 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))', '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 tag_scope = s:Tlist_Extract_Tag_Scope(one_line)
- if tag_scope != ''
- let ttxt = ttxt . ' [' . tag_scope . ']'
- endif
- 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
- if winbufnr(2) != -1
- " If a window other than the taglist window is open,
- " then only close the taglist window.
- close
- 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
-
- 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
- call s:Tlist_Exe_Cmd_No_Acmds('wincmd p')
- 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 = strridx(a:tag_line, 'line:') - 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 = strridx(a:tag_line, 'line:')
- let end = strridx(a:tag_line, "\t")
- if end <= start
- return ''
- endif
-
- let tag_scope = strpart(a:tag_line, end + 1)
- let tag_scope = strpart(tag_scope, stridx(tag_scope, ':') + 1)
-
- return tag_scope
-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
-