├── vimfiles
    ├── ftplugin
    │   ├── txt.vim
    │   ├── python.vim
    │   ├── cs.vim
    │   ├── java.vim
    │   ├── c.vim
    │   └── php.vim
    ├── plugin
    │   ├── filetype.vim
    │   ├── phpcs.vim
    │   ├── checksyntax.vim
    │   ├── Tabular.vim
    │   ├── tasklist.vim
    │   └── php-doc.vim
    ├── phpm
    │   ├── lib
    │   │   └── epc
    │   │   │   ├── object.php
    │   │   │   └── phpm
    │   │   │       ├── install.php
    │   │   │       ├── reader.php
    │   │   │       ├── listinstalled.php
    │   │   │       ├── listall.php
    │   │   │       └── parser.php
    │   ├── phpm
    │   ├── reader.php
    │   ├── generator.php
    │   ├── settings.xml
    │   ├── HISTORY
    │   ├── README
    │   └── list.xml
    ├── .netrwhist
    ├── template.spec
    ├── nerdtree_plugin
    │   ├── exec_menuitem.vim
    │   └── fs_menu.vim
    ├── after
    │   └── plugin
    │   │   └── TabularMaps.vim
    ├── doc
    │   ├── checksyntax.txt
    │   ├── Tabular.txt
    │   └── NERD_tree.txt
    └── autoload
    │   ├── tabular.vim
    │   └── checksyntax.vim
├── hotkeys
├── TODO
├── .vimrc
├── ptags.cpp
└── README


/vimfiles/ftplugin/txt.vim:
--------------------------------------------------------------------------------
1 | set autoindent
2 | 


--------------------------------------------------------------------------------
/vimfiles/plugin/filetype.vim:
--------------------------------------------------------------------------------
1 | augroup filetypedetect
2 | au BufNewFile,BufRead *.xt  setf xt
3 | augroup END
4 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/lib/epc/object.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jqlblue/php-vim/HEAD/vimfiles/phpm/lib/epc/object.php


--------------------------------------------------------------------------------
/vimfiles/phpm/lib/epc/phpm/install.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jqlblue/php-vim/HEAD/vimfiles/phpm/lib/epc/phpm/install.php


--------------------------------------------------------------------------------
/vimfiles/phpm/lib/epc/phpm/reader.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jqlblue/php-vim/HEAD/vimfiles/phpm/lib/epc/phpm/reader.php


--------------------------------------------------------------------------------
/vimfiles/phpm/lib/epc/phpm/listinstalled.php:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jqlblue/php-vim/HEAD/vimfiles/phpm/lib/epc/phpm/listinstalled.php


--------------------------------------------------------------------------------
/vimfiles/phpm/phpm:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | cd /usr/share/vim/vimfiles/phpm/
3 | args=" "
4 | while (( "$#" )); do
5 |     args="$args $1"
6 |     shift
7 | done
8 | php reader.php $args
9 | 


--------------------------------------------------------------------------------
/vimfiles/ftplugin/python.vim:
--------------------------------------------------------------------------------
1 | " Auto expand tabs to spaces
2 | setlocal expandtab
3 | 
4 | " Switch syntax highlighting on, if it was not
5 | syntax on
6 | 
7 | inoremap <buffer> " ""<LEFT>
8 | inoremap <buffer> ' ''<LEFT>
9 | 


--------------------------------------------------------------------------------
/vimfiles/.netrwhist:
--------------------------------------------------------------------------------
1 | let g:netrw_dirhistmax  =10
2 | let g:netrw_dirhist_cnt =3
3 | let g:netrw_dirhist_1='/var/log/httpd'
4 | let g:netrw_dirhist_2='/var/www/html'
5 | let g:netrw_dirhist_3='/usr/share/vim/vimfiles/phpm/phpdoc/en/reference/zlib/functions'
6 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/reader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  *  Progam to query a XML file with API calls.
 4 |  *
 5 |  *  See the epc/xml/manualreader.php
 6 |  */
 7 | include( "lib/epc/object.php" );
 8 | $xml = new EPC_Phpm_Reader( "settings.xml" );
 9 | if( $xml->query( $argv ) )
10 | {
11 | 	echo $xml->display();
12 | }
13 | else
14 | {
15 | 	echo "Could not find the function specified";
16 | 	echo "\n";
17 | }
18 | ?>
19 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/generator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  *	This is the generator of the XML file that is needed to query
 4 |  *	the PHP functions, not needed if you don't have the CVS tree
 5 |  *	on your computer.
 6 |  */ 
 7 | echo ">> Starting up the XML generator...\n";
 8 | 
 9 | include( "lib/epc/object.php" );
10 | $parser = new EPC_Phpm_Parser( "settings.xml" );
11 | 
12 | $parser->run();
13 | 
14 | echo ">> Finished\n\n";
15 | ?>
16 | 


--------------------------------------------------------------------------------
/vimfiles/plugin/phpcs.vim:
--------------------------------------------------------------------------------
 1 | function! Phpcs()
 2 |   " phpcs 命令的路径和参数, 请根据环境自行修改
 3 |     let l:filename=@%
 4 |     let l:phpcs_output=system('phpcs --report=csv --standard=Zend '.l:filename)
 5 |     let l:phpcs_list=split(l:phpcs_output, "\n")
 6 |     unlet l:phpcs_list[0]
 7 |     cexpr l:phpcs_list
 8 |     cwindow
 9 | endfunction
10 | 
11 | " :w 自动验证语法
12 | autocmd BufWritePost *.php call Phpcs()
13 | " :Phpcs 验证语法
14 | set errorformat=\"%f\"\\,%l\\,%c\\,%t%*[a-zA-Z]\\,\"%m\"\\,%*[a-zA-Z0-9_.-]\\,%*[0-9]
15 | command! Phpcs execute Phpcs()
16 | 


--------------------------------------------------------------------------------
/vimfiles/template.spec:
--------------------------------------------------------------------------------
 1 | Name:		
 2 | Version:	
 3 | Release:	1%{?dist}
 4 | Summary:	
 5 | 
 6 | Group:		
 7 | License:	
 8 | URL:		
 9 | Source0:	
10 | BuildRoot:	%(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
11 | 
12 | BuildRequires:	
13 | Requires:	
14 | 
15 | %description
16 | 
17 | 
18 | %prep
19 | %setup -q
20 | 
21 | 
22 | %build
23 | %configure
24 | make %{?_smp_mflags}
25 | 
26 | 
27 | %install
28 | rm -rf $RPM_BUILD_ROOT
29 | make install DESTDIR=$RPM_BUILD_ROOT
30 | 
31 | 
32 | %clean
33 | rm -rf $RPM_BUILD_ROOT
34 | 
35 | 
36 | %files
37 | %defattr(-,root,root,-)
38 | %doc
39 | 
40 | 
41 | 
42 | %changelog
43 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/settings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <settings>
 3 |     <!--
 4 |         Generation of the php.net manual 
 5 |     -->
 6 |     <!-- The path to the cvs REFERENCE directory -->
 7 | 	<cvsdir>/usr/share/vim/vimfiles/phpm/phpdoc/en/reference</cvsdir>
 8 | 	<!-- Enable debugging -->
 9 | 	<debug>1</debug>
10 | 	<!-- where to save the manual -->
11 | 	<save>php.xml</save>
12 | 	
13 | 	
14 | 	<!-- Display options, see Console_Color for valid options -->
15 | 	<color display="yes">
16 | 		<func>B</func>
17 | 		<return>G</return>
18 | 		<type>b</type>
19 | 		<var>B</var>
20 | 	</color>
21 | 	<!-- Set to what you are u sing the most -->
22 | 	<defaultproject value="php" />
23 | 	
24 | 	<!-- Version 0.3 -->
25 | 	<download listing="http://eide.org/files/phpm/list.xml" />
26 | 	
27 | 	<install path="/usr/share/vim/vimfiles/phpm" />
28 | </settings>
29 | 


--------------------------------------------------------------------------------
/hotkeys:
--------------------------------------------------------------------------------
 1 | some shortcut keys in use php-vim
 2 | 
 3 | f3 - show tag list,press agian to close
 4 | f2 - show NERD_tree,press again to close
 5 | [v,i]ctrl+p - 在可视和插入模式下，调用phpdoc会函数和类添加phpdocument
 6 | [v]ctrl+a - 在可视模式下，调用phpAlign对代码格式进行对齐
 7 | [i]ctrl+h - 在插入模式下，调用phpm打开php函数的定义
 8 | [v]ctrl+c - 注释代码块或者行，再按一下则取消注释
 9 | [v,i]ctrl+方向键 - 以峰驼的形式，跳转到上一处或者下一处
10 | 
11 | ctrl+] - 跳转到定义处
12 | ctrl+t - 从定义处跳转回来
13 | ctrl+w ctrl+] - 水平分割窗口，并在上部打开定义所在文件，跳转到定义处
14 | ctrl+\ - 打开新标签页。并跳转到定义处
15 | alt+] - 垂直分割窗口，并在右部打开定义所在文件，跳转到定义处
16 | 
17 | 
18 | ctrl+鼠标左键 - 跳转到定义处
19 | ctrl+鼠标右键 - 从定义处跳转回来
20 | 
21 | some command in use php-vim
22 | 
23 | :tabnew[:tabe] - 打开新的标签页
24 | :tabclose[:tabc] - 关闭正在打开的标签页
25 | :vimgrep - 在文件夹中查找
26 |   在当前目录下查找含有“getInfo”的php文档，但不跳到第一个匹配
27 |   :vimgrep /getInfo/gj ./*/*.php
28 |   如果要包含子文件夹，则用
29 |   :vimgrep /getInfo/gj ./**/*.php
30 |   :vim[grep][!] /{pattern}/[g][j] {file}
31 | :cw -  打开quickfix窗口查看匹配结果
32 | 
33 | 
34 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
 1 | 1 use cscope in vim with php
 2 | 2 update phpm
 3 | 3 other 
 4 | 4 check phpcs use,and uncomment later
 5 | 5 search in floder
 6 | 在当前目录下查找含有“getInfo”的php文档，但不跳到第一个匹配
 7 | :vimgrep /getInfo/gj ./*/*.php
 8 | 如果要包含子文件夹，则用
 9 | :vimgrep /getInfo/gj ./**/*.php
10 | :cw
11 | 打开quickfix窗口查看匹配结果
12 | :vim[grep][!] /{pattern}/[g][j] {file}
13 | Search for {pattern} in the files {file} … and set
14 | the error list to the matches.
15 | Without the ‘g’ flag each line is added only once.
16 | With ‘g’ every match is added.
17 | 
18 | {pattern} is a Vim search pattern.  Instead of
19 | enclosing it in / any non-ID character (see
20 | |’isident’|) can be used, so long as it does not
21 | appear in {pattern}.
22 | ‘ignorecase’ applies.  To overrule it put |/c| in the
23 | pattern to ignore case or |/C| to match case.
24 | ‘smartcase’ is not used.
25 | 
26 | When a number is put before the command this is used
27 | as the maximum number of matches to find.  Use
28 | “:1vimgrep pattern file” to find only the first.
29 | Useful if you only want to check if there is a match
30 | and quit quickly when it’s found.
31 | 
32 | Without the ‘j’ flag Vim jumps to the first match.
33 | With ‘j’ only the quickfix list is updated.
34 | With the [!] any changes in the current buffer are
35 | abandoned.
36 | 
37 | @@@@ test github
38 | 


--------------------------------------------------------------------------------
/vimfiles/plugin/checksyntax.vim:
--------------------------------------------------------------------------------
 1 | " checksyntax.vim -- Check syntax when saving a file (php, ruby, tex ...)
 2 | " @Author:      Tom Link (micathom AT gmail com)
 3 | " @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 4 | " @Created:     04-Mai-2005.
 5 | " @Last Change: 2011-05-26.
 6 | " GetLatestVimScripts: 1431 0 :AutoInstall: checksyntax.vim
 7 | " @Revision:    396
 8 | 
 9 | if exists('g:loaded_checksyntax')
10 |     finish
11 | endif
12 | let g:loaded_checksyntax = 103
13 | 
14 | 
15 | " @TPluginInclude
16 | if !exists('g:checksyntax_auto')
17 |     " If non-null, enable automatic syntax checks after saving a file.
18 |     let g:checksyntax_auto = 1
19 | endif
20 | 
21 | 
22 | " @TPluginInclude
23 | augroup CheckSyntax
24 |     autocmd!
25 |     if g:checksyntax_auto
26 |         autocmd CheckSyntax BufWritePost * call checksyntax#Check(0)
27 |     endif
28 | augroup END
29 | 
30 | 
31 | " :display: CheckSyntax[!] [NAME]
32 | " Check the current buffer's syntax (type defaults to &filetype).
33 | " Or use NAME instead of &filetype.
34 | "
35 | " With the bang !, use the alternative syntax checker (see 
36 | " |g:checksyntax|).
37 | command! -bang -nargs=? CheckSyntax call checksyntax#Check(1, "<bang>", <f-args>)
38 | 
39 | 
40 | " @TPluginInclude
41 | if !hasmapto(':CheckSyntax') && empty(maparg('<F5>', 'n'))
42 |     noremap <F5> :CheckSyntax<cr>
43 |     inoremap <F5> <c-o>:CheckSyntax<cr>
44 | endif
45 | 
46 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/HISTORY:
--------------------------------------------------------------------------------
 1 | 20/11/2004
 2 | 	- Added support for extended information, all the old XML files will not
 3 | 	  work with this new functionality:
 4 | 	  * -e/--extended: extended description
 5 | 	  * -s/--short: short description
 6 | 	- Added remote install: you can now query for projects and install from the
 7 | 	  eide.org server ( see http://wiki.cc/php/Epc_phpm for more information ) 
 8 | 	- Added help to the program "-h/--help"
 9 | 	- New settings param in settings.xml , so make sure to update this!
10 | 	- A new phpDocumentor converter is in place for people that want to generate their
11 | 	  own XML files ( contact me and I'll put them on the server )
12 | 	  
13 | 14/11/2004
14 | 	- Added support for multiple projects, all XML is now in "xml/"
15 | 		This needs the "-p pro" call where "pro" is a project name
16 | 	- Added support for wildcard query if a exact match isn't found
17 | 	- Multiple function calls will be output to the terminal if more than one
18 | 		hit was found for the param
19 | 	- Added "defaultproject" node to the settings
20 | 	- Added support for case/case-insensitive queries:
21 | 		* -c/--case or -ci/--case-insensitive
22 | 	- The query needs to be the last thing passed in the argument line
23 | 
24 | 01/11/2004
25 | 	- Added a "phpm" bash script
26 | 	- More information and renamed the files to be a bit more 
27 | 	description to what they do.
28 | 	- Added more configuration options to color the output
29 | 	with Console_Color ( Optional )
30 | 	
31 | 31/10/2004
32 | 	First release with base functionality
33 | 


--------------------------------------------------------------------------------
/vimfiles/ftplugin/cs.vim:
--------------------------------------------------------------------------------
 1 | " {{{ Settings
 2 | 
 3 | " Auto expand tabs to spaces
 4 | set expandtab
 5 | 
 6 | " Auto indent after a {
 7 | set autoindent
 8 | set smartindent
 9 | 
10 | " Linewidth to endless
11 | set textwidth=0
12 | 
13 | " Do not wrap lines automatically
14 | set nowrap
15 | 
16 | " Correct indentation after opening a phpdocblock and automatic * on every
17 | " line
18 | set formatoptions=qroct
19 | 
20 | " }}} Settings
21 | 
22 | " {{{ Automatic close char mapping
23 | 
24 | " More common in PEAR coding standard
25 | inoremap  { {<CR>}<C-O>O
26 | " Maybe this way in other coding standards
27 | " inoremap  { <CR>{<CR>}<C-O>O
28 | 
29 | inoremap [ []<LEFT>
30 | 
31 | " Standard mapping after PEAR coding standard
32 | inoremap ( ()<LEFT>
33 | 
34 | " Maybe this way in other coding standards
35 | " inoremap ( ( )<LEFT><LEFT> 
36 | 
37 | inoremap " ""<LEFT>
38 | inoremap ' ''<LEFT>
39 | 
40 | " }}} Automatic close char mapping
41 | 
42 | " {{{ Wrap visual selections with chars
43 | 
44 | :vnoremap ( "zdi(<C-R>z)<ESC>
45 | :vnoremap { "zdi{<C-R>z}<ESC>
46 | :vnoremap [ "zdi[<C-R>z]<ESC>
47 | :vnoremap ' "zdi'<C-R>z'<ESC>
48 | :vnoremap " "zdi"<C-R>z"<ESC>
49 | 
50 | " }}} Wrap visual selections with chars
51 | 
52 | " {{{ Autocompletion using the TAB key
53 | 
54 | " This function determines, wether we are on the start of the line text (then tab indents) or
55 | " if we want to try autocompletion
56 | func! InsertTabWrapper()
57 |     let col = col('.') - 1
58 |     if !col || getline('.')[col - 1] !~ '\k'
59 |         return "\<tab>"
60 |     else
61 |         return "\<c-p>"
62 |     endif
63 | endfunction
64 | 
65 | " Remap the tab key to select action with InsertTabWrapper
66 | inoremap <tab> <c-r>=InsertTabWrapper()<cr>
67 | 
68 | " }}} Autocompletion using the TAB key
69 | 


--------------------------------------------------------------------------------
/vimfiles/nerdtree_plugin/exec_menuitem.vim:
--------------------------------------------------------------------------------
 1 | " ============================================================================
 2 | " File:        exec_menuitem.vim
 3 | " Description: plugin for NERD Tree that provides an execute file menu item
 4 | " Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
 5 | " Last Change: 22 July, 2009
 6 | " License:     This program is free software. It comes without any warranty,
 7 | "              to the extent permitted by applicable law. You can redistribute
 8 | "              it and/or modify it under the terms of the Do What The Fuck You
 9 | "              Want To Public License, Version 2, as published by Sam Hocevar.
10 | "              See http://sam.zoy.org/wtfpl/COPYING for more details.
11 | "
12 | " ============================================================================
13 | if exists("g:loaded_nerdtree_exec_menuitem")
14 |     finish
15 | endif
16 | let g:loaded_nerdtree_exec_menuitem = 1
17 | 
18 | call NERDTreeAddMenuItem({
19 |             \ 'text': '(!)Execute file',
20 |             \ 'shortcut': '!',
21 |             \ 'callback': 'NERDTreeExecFile',
22 |             \ 'isActiveCallback': 'NERDTreeExecFileActive' })
23 | 
24 | function! NERDTreeExecFileActive()
25 |     let node = g:NERDTreeFileNode.GetSelected()
26 |     return !node.path.isDirectory && node.path.isExecutable
27 | endfunction
28 | 
29 | function! NERDTreeExecFile()
30 |     let treenode = g:NERDTreeFileNode.GetSelected()
31 |     echo "==========================================================\n"
32 |     echo "Complete the command to execute (add arguments etc):\n"
33 |     let cmd = treenode.path.str({'escape': 1})
34 |     let cmd = input(':!', cmd . ' ')
35 | 
36 |     if cmd != ''
37 |         exec ':!' . cmd
38 |     else
39 |         echo "Aborted"
40 |     endif
41 | endfunction
42 | 


--------------------------------------------------------------------------------
/vimfiles/ftplugin/java.vim:
--------------------------------------------------------------------------------
 1 | " .vim/ftplugin/php.vim by Tobias Schlitt <toby@php.net>.
 2 | " No copyright, feel free to use this, as you like.
 3 | 
 4 | " {{{ Settings
 5 | 
 6 | " Auto expand tabs to spaces
 7 | setlocal expandtab
 8 | 
 9 | " Auto indent after a {
10 | " setlocal autoindent
11 | " setlocal smartindent
12 | 
13 | " Linewidth to endless
14 | setlocal textwidth=0
15 | 
16 | " Do not wrap lines automatically
17 | setlocal nowrap
18 | 
19 | " Correct indentation after opening a phpdocblock and automatic * on every
20 | " line
21 | " setlocal formatoptions=qroct
22 | 
23 | " Switch syntax highlighting on, if it was not
24 | syntax on
25 | 
26 | " }}} Settings
27 | 
28 | " {{{ Command mappings
29 | 
30 | " Map ; to "add ; to the end of the line, when missing"
31 | noremap ; :s/\([^;]\)$/\1;/<cr>
32 | 
33 | " }}}
34 | 
35 | " {{{ Automatic close char mapping
36 | 
37 | " More common in PEAR coding standard
38 | inoremap  { {<CR>}<C-O>O
39 | " Maybe this way in other coding standards
40 | " inoremap  { <CR>{<CR>}<C-O>O
41 | 
42 | inoremap [ []<LEFT>
43 | 
44 | " Maybe this way in other coding standards
45 | inoremap ( ()<LEFT>
46 | 
47 | inoremap " ""<LEFT>
48 | inoremap ' ''<LEFT>
49 | 
50 | " }}} Automatic close char mapping
51 | 
52 | " {{{ Dictionary completion
53 | 
54 | " Use the dictionary completion
55 | setlocal complete-=k complete+=k
56 | 
57 | " }}} Dictionary completion
58 | 
59 | " {{{ Autocompletion using the TAB key
60 | 
61 | " This function determines, wether we are on the start of the line text (then tab indents) or
62 | " if we want to try autocompletion
63 | func! InsertTabWrapper()
64 |     let col = col('.') - 1
65 |     if !col || getline('.')[col - 1] !~ '\k'
66 |         return "\<tab>"
67 |     else
68 |         return "\<c-p>"
69 |     endif
70 | endfunction
71 | 
72 | " Remap the tab key to select action with InsertTabWrapper
73 | inoremap <tab> <c-r>=InsertTabWrapper()<cr>
74 | 
75 | " }}} Autocompletion using the TAB key
76 | 


--------------------------------------------------------------------------------
/vimfiles/after/plugin/TabularMaps.vim:
--------------------------------------------------------------------------------
 1 | if !exists(':Tabularize')
 2 |   finish " Tabular.vim wasn't loaded
 3 | endif
 4 | 
 5 | let s:save_cpo = &cpo
 6 | set cpo&vim
 7 | 
 8 | AddTabularPattern!  assignment      /[|&+*/%<>=!~-]\@<!\([<>!=]=\|=\~\)\@![|&+*/%<>=!~-]*=/l1r1
 9 | AddTabularPattern!  two_spaces      /  /l0
10 | 
11 | AddTabularPipeline! multiple_spaces /  / map(a:lines, "substitute(v:val, '   *', '  ', 'g')") | tabular#TabularizeStrings(a:lines, '  ', 'l0')
12 | 
13 | AddTabularPipeline! argument_list   /(.*)/ map(a:lines, 'substitute(v:val, ''\s*\([(,)]\)\s*'', ''\1'', ''g'')')
14 |                                        \ | tabular#TabularizeStrings(a:lines, '[(,)]', 'l0')
15 |                                        \ | map(a:lines, 'substitute(v:val, ''\(\s*\),'', '',\1 '', "g")')
16 |                                        \ | map(a:lines, 'substitute(v:val, ''\s*)'', ")", "g")')
17 | 
18 | function! SplitCDeclarations(lines)
19 |   let rv = []
20 |   for line in a:lines
21 |     " split the line into declaractions
22 |     let split = split(line, '\s*[,;]\s*')
23 |     " separate the type from the first declaration
24 |     let type = substitute(split[0], '\%(\%([&*]\s*\)*\)\=\k\+$', '', '')
25 |     " add the ; back on every declaration
26 |     call map(split, 'v:val . ";"')
27 |     " add the first element to the return as-is, and remove it from the list
28 |     let rv += [ remove(split, 0) ]
29 |     " transform the other elements by adding the type on at the beginning
30 |     call map(split, 'type . v:val')
31 |     " and add them all to the return
32 |     let rv += split
33 |   endfor
34 |   return rv
35 | endfunction
36 | 
37 | AddTabularPipeline! split_declarations /,.*;/ SplitCDeclarations(a:lines)
38 | 
39 | AddTabularPattern! ternary_operator /^.\{-}\zs?\|:/l1
40 | 
41 | AddTabularPattern! cpp_io /<<\|>>/l1
42 | 
43 | AddTabularPattern! pascal_assign /:=/l1
44 | 
45 | AddTabularPattern! trailing_c_comments /\/\*\|\*\/\|\/\//l1
46 | 
47 | let &cpo = s:save_cpo
48 | unlet s:save_cpo
49 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/README:
--------------------------------------------------------------------------------
 1 | --------------
 2 | Program: phpm 
 3 | Author: Havard Eide
 4 | Version: 0.3
 5 | License: GPL
 6 | Release: 20/11/2004
 7 | --------------
 8 | Quick description:
 9 | phpm is a program for accessing API calls for PHP libraries.
10 | It was originally created to query the PHP manual from the shell,
11 | but comes with a range of pre-generated project API's that can
12 | be queried.
13 | 
14 | --------------
15 | The files:
16 | * generator.php 
17 |   This is the XML generator: if you have a CVS dir with the
18 |   PHP doc code - configure "settings.xml" and run this
19 |   with "php epcmanual.php"
20 |   
21 | * reader.php
22 |   This is the actual query tool: run it with
23 |   "php reader.php mysql_query" to get the result.
24 |   If a exact hit isn't found it will query the API for functions
25 |   that start with the argument, if this fails the program will 
26 |   try a wildcard query for anything that contains the argument.
27 |   The "xml/*.xml" contains all the functions, pregenerated, so 
28 |   you don't need to run the "generator.php" to generate it.
29 | 
30 |   To query a different project than the default:
31 |   "php reader.php -p pro query" where "pro" is one of the projects listed 
32 |   below.
33 |  
34 | * The "phpm" script
35 |   You will need to symlink this to /usr/bin/, /usr/local/bin with:
36 |   "sudo ln -s /Users/nucleuz/Sites/phpm/phpm /usr/bin/phpm"
37 |   to make it work from anywhere in the terminal. 
38 |   
39 |   You will also need to change the first command to reference the folder
40 |   where this program is installed
41 | 	
42 | * xml files
43 |   Update the settings.xml and point to a directory where you want
44 |   the XML files to be stored. Download and copy the XML bundle from eide.org
45 |   to this folder.
46 |   
47 | ----------------
48 | ToDo:
49 |   - Versioning
50 |   - Integrate with wordpress [Planned for v0.4]
51 |   - Support for wildcard query [Done - v0.2]
52 |   - Query for a class
53 |   - Get extended result "-e" -> more text from the DocBook needs to be extracted. [Done -v0.3]
54 | 
55 | Havard Eide.  
56 | 


--------------------------------------------------------------------------------
/vimfiles/ftplugin/c.vim:
--------------------------------------------------------------------------------
 1 | " .vim/ftplugin/c.vim by Tobias Schlitt <toby@php.net>.
 2 | " No copyright, feel free to use this, as you like.
 3 | 
 4 | " {{{ Settings
 5 | 
 6 | " Auto expand tabs to spaces
 7 | set expandtab
 8 | 
 9 | " Auto indent after a {
10 | set autoindent
11 | set smartindent
12 | 
13 | " Linewidth to endless
14 | set textwidth=0
15 | 
16 | " Do not wrap lines automatically
17 | set nowrap
18 | 
19 | " Correct indentation after opening a phpdocblock and automatic * on every
20 | " line
21 | set formatoptions=qroct
22 | 
23 | " Switch syntax highlighting on, if it was not
24 | syntax on
25 | 
26 | " }}} Settings
27 | 
28 | " {{{ Command mappings
29 | 
30 | " Map ; to run PHP parser check
31 | " noremap ; :!php5 -l %<CR>
32 | 
33 | " Map ; to "add ; to the end of the line, when missing"
34 | noremap ; :s/\([^;]\)$/\1;/<cr>
35 | 
36 | " }}}
37 | 
38 | " {{{ Automatic close char mapping
39 | 
40 | " More common in PEAR coding standard
41 | inoremap  { {<CR>}<C-O>O
42 | " Maybe this way in other coding standards
43 | " inoremap  { <CR>{<CR>}<C-O>O
44 | 
45 | inoremap [ []<LEFT>
46 | 
47 | " Standard mapping after PEAR coding standard
48 | inoremap ( ()<LEFT>
49 | 
50 | " Maybe this way in other coding standards
51 | " inoremap ( ( )<LEFT><LEFT> 
52 | 
53 | inoremap " ""<LEFT>
54 | inoremap ' ''<LEFT>
55 | 
56 | " }}} Automatic close char mapping
57 | 
58 | " {{{ Wrap visual selections with chars
59 | 
60 | :vnoremap ( "zdi(<C-R>z)<ESC>
61 | :vnoremap { "zdi{<C-R>z}<ESC>
62 | :vnoremap [ "zdi[<C-R>z]<ESC>
63 | :vnoremap ' "zdi'<C-R>z'<ESC>
64 | " Removed in favor of register addressing
65 | " :vnoremap " "zdi"<C-R>z"<ESC>
66 | 
67 | " }}} Wrap visual selections with chars
68 | 
69 | " {{{ Autocompletion using the TAB key
70 | 
71 | " This function determines, wether we are on the start of the line text (then tab indents) or
72 | " if we want to try autocompletion
73 | func! InsertTabWrapper()
74 |     let col = col('.') - 1
75 |     if !col || getline('.')[col - 1] !~ '\k'
76 |         return "\<tab>"
77 |     else
78 |         return "\<c-p>"
79 |     endif
80 | endfunction
81 | 
82 | " Remap the tab key to select action with InsertTabWrapper
83 | inoremap <tab> <c-r>=InsertTabWrapper()<cr>
84 | 
85 | " }}} Autocompletion using the TAB key
86 | 


--------------------------------------------------------------------------------
/vimfiles/phpm/lib/epc/phpm/listall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  *  Class for displaying all the current projects that can
 4 |  *  be installed with the phpm program.
 5 |  *
 6 |  *  @package EPC_Phpm
 7 |  *  @copyright &copy; 2004 Havard Eide
 8 |  *  @license GPL
 9 |  */
10 | class EPC_Phpm_ListAll extends EPC_Object
11 | {
12 |     // {{{ public function __construct( $settings )
13 |     /**
14 |      *  Constructor - Makes sure that the settings object contains
15 |      *  the download listing URL, if not the constructor will die() with
16 |      *  a message to the user.
17 |      *
18 |      *  @param object SimpleXMLElement Settings object that comes from "settings.xml"
19 |      *  @access public
20 |      *  @return void
21 |      */
22 |     public function __construct( SimpleXMLElement $settings )
23 |     {
24 |         $this->settings = $settings;
25 |         if( !isset( $this->settings->download["listing"] ) )
26 |         {
27 |             die( "The download listing setting was not set!" );
28 |         }
29 |     }
30 |     // }}}
31 |     
32 |     // {{{ public function run()
33 |     /**
34 |      *  The only function to run on the object.
35 |      *
36 |      *  It will attempt to download the settings file and list all the
37 |      *  projects that can be downloaded from the central server.
38 |      *
39 |      *  @access public
40 |      *  @return void
41 |      */ 
42 |     public function run()
43 |     {
44 |         $list = @file_get_contents( $this->settings->download["listing"] );
45 |         if( $list )
46 |         {
47 |             echo ">>The following projects are available from the server:\n";
48 |             $xml = new SimpleXMLElement( $list );
49 |             foreach( $xml->project as $project )
50 |             {
51 |                 echo 'Project: "' . $project->name . '" ';
52 |                 echo 'version: '. $project->version . ' '. "\n\t\t";
53 |                 echo 'key: "' . $project->key . '"' . "\n";
54 |             }
55 |             echo "\n>>Install any of these with: 'phpm --install {key}'\n";
56 |         }
57 |         else
58 |         {
59 |             echo ">>Could not get the settings file from the server.\n";
60 |         }
61 |     }
62 |     // }}}
63 |     
64 |     // {{{ public function toXML()
65 |     /** 
66 |      *  Override the parent toXML().
67 |      *
68 |      *  @return string A XML string with the settings URL listed as variable.
69 |      */
70 |     public function toXML()
71 |     {
72 |         return parent::toXML( array( "settings" => $this->settings->download["listing"] ) );
73 |     }
74 |     // }}}
75 | }
76 | ?>


--------------------------------------------------------------------------------
/vimfiles/phpm/list.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <phpm>
  3 |     <download path="http://eide.org/files/phpm/xml/" />
  4 |     <project>
  5 |         <key>epc</key>
  6 |         <name>Eide PHP Classes</name>
  7 |         <version>CVS Head</version>
  8 |         <updated>2004/11/20</updated>
  9 |         <home>http://eide.org/?epc=php</home>
 10 |         <license>GPL</license>
 11 |     </project>
 12 |     <project>
 13 |         <key>ism</key>
 14 |         <name>Isom</name>
 15 |         <version>0.1.4</version>
 16 |         <updated>2004/11/20</updated>
 17 |         <home>http://ismo.morrdusk.net/</home>
 18 |         <license>PHP</license>
 19 |     </project>  
 20 |     <project>
 21 |         <key>moj</key>
 22 |         <name>Mojavi</name>
 23 |         <version>3.0.0</version>
 24 |         <updated>2004/11/20</updated>
 25 |         <home>http://www.mojavi.org</home>
 26 |         <license>LGPL</license>
 27 |     </project>
 28 |     <project>
 29 |         <key>php</key>
 30 |         <name>php.net manual</name>
 31 |         <updated>2004/11/20</updated>
 32 |         <version>CVS HEAD</version>
 33 |         <home>http://php.net/manual</home>
 34 |         <license>PHP</license>
 35 |     </project>     
 36 |     <project>
 37 |         <key>phr</key>
 38 |         <name>Phrame</name>
 39 |         <version>2.1RC1</version>
 40 |         <updated>2004/11/20</updated>
 41 |         <home>http://sourceforge.net/projects/phrame</home>
 42 |         <license>LGPL</license>
 43 |     </project>           
 44 |     <project>
 45 |         <key>phv</key>
 46 |         <name>php.MVC</name>
 47 |         <version>0.3.4</version>
 48 |         <updated>2004/11/20</updated>
 49 |         <home>http://www.phpmvc.net</home>
 50 |         <license>LGPL</license>
 51 |     </project>
 52 |     <project>
 53 |         <key>pra</key>
 54 |         <name>Prado</name>
 55 |         <version>1.6</version>
 56 |         <updated>2004/11/20</updated>
 57 |         <home>http://www.xisc.com/</home>
 58 |         <license>BSD</license>
 59 |     </project>
 60 |     <project>
 61 |         <key>rmf</key>
 62 |         <name>rmfPHP</name>
 63 |         <version>0.1.2</version>
 64 |         <updated>2004/11/20</updated>
 65 |         <home>http://www.rwfphp.org/</home>
 66 |         <license>BSD (?)</license>
 67 |     </project>
 68 |     <project>
 69 |         <key>sim</key>
 70 |         <name>SimpleTest</name>
 71 |         <version>1.0RC1</version>
 72 |         <updated>2004/11/20</updated>
 73 |         <home>http://sourceforge.net/projects/simpletest/</home>
 74 |         <license>The Open Group Test Suite License</license>
 75 |     </project>    
 76 |     <project>
 77 |         <key>std</key>
 78 |         <name>studs</name>
 79 |         <version>1.0RC1</version>
 80 |         <updated>2004/11/20</updated>
 81 |         <home>http://www.mojavelinux.com/projects/studs/</home>
 82 |         <license>Apache2.0</license>
 83 |     </project>  
 84 |     <project>
 85 |         <key>wct</key>
 86 |         <name>wact</name>
 87 |         <version>CVS head</version>
 88 |         <updated>2004/11/20</updated>
 89 |         <home>http://wact.sourceforge.net</home>
 90 |         <license>LGPL</license>
 91 |     </project>
 92 |     <project>
 93 |         <key>xp</key>
 94 |         <name>wact</name>
 95 |         <version>xp-2004-11-12</version>
 96 |         <updated>2004/11/20</updated>
 97 |         <home>http://xp-framework.net/</home>
 98 |         <license>BSD</license>
 99 |     </project>       
100 | </phpm>
101 | 


--------------------------------------------------------------------------------
/vimfiles/doc/checksyntax.txt:
--------------------------------------------------------------------------------
  1 | *checksyntax.txt*   checksyntax -- Check syntax when saving a file (php, ruby, tex ...)
  2 |                     Author: Tom Link, micathom at gmail com
  3 | 
  4 | By default, |:CheckSyntax| is mapped to <F5> (if not mapped already), and
  5 | automatically executed when saving the buffer.
  6 | The |:CheckSyntax| command takes one optional argument: the mode (default:
  7 | &filetype). The following modes are pre-defined (and maybe some more):
  8 | 
  9 |     c, cpp :: Check syntax via splint
 10 |     html :: Check syntax via tidy
 11 |     javascript :: Check syntax via jsl or gjslint
 12 |     java :: Check syntax via jlint or javaCheckstyle
 13 |     lua :: Parse file (luac -p)
 14 |     php  :: Check syntax (php -l)
 15 |     phpp :: Parse a file (php -f) (alternative php checker)
 16 |     python :: Check file with pyflakes
 17 |     pylint :: Use the pylint compiler plugin (alternative python checker)
 18 |     ruby :: Check syntax (ruby -c; no auto-checks)
 19 |     tex, latex :: Parse file (chktex -q -v0; no auto-checks)
 20 |     xml, docbk :: Check syntax via xmllint
 21 | 
 22 | See |g:checksyntax| for how to define your own syntax checkers.
 23 | 
 24 | This plugin was originally based on Klaus Horsten's php_console 
 25 | (vimscript #779) and it is the successor of php_check_syntax.vim 
 26 | (vimscript #1272). In opposition to php_console, it is not a php 
 27 | ftplugin but a general solution for checking the syntax when saving a 
 28 | file (using the appropriate interpreter, lint or whatsoever).
 29 | 
 30 | 
 31 | -----------------------------------------------------------------------
 32 | Install~
 33 | 
 34 | Edit the vba file and type: >
 35 | 
 36 |     :so %
 37 | 
 38 | See :help vimball for details. If you have difficulties or use vim 7.0, 
 39 | please make sure, you have the current version of vimball (vimscript 
 40 | #1502) installed or update your runtime.
 41 | 
 42 | 
 43 | ========================================================================
 44 | Contents~
 45 | 
 46 |         :CheckSyntax ............... |:CheckSyntax|
 47 |         <F5> ....................... |<F5>|
 48 |         i_<F5> ..................... |i_<F5>|
 49 |         g:checksyntax .............. |g:checksyntax|
 50 |         checksyntax#Check .......... |checksyntax#Check()|
 51 | 
 52 | 
 53 | ========================================================================
 54 | plugin/checksyntax.vim~
 55 | 
 56 |                                                     *:CheckSyntax*
 57 | CheckSyntax[!] [NAME]
 58 |     Check the current buffer's syntax (type defaults to &filetype).
 59 |     Or use NAME instead of &filetype.
 60 |     
 61 |     With the bang !, use the alternative syntax checker (see 
 62 |     |g:checksyntax|).
 63 | 
 64 |                                                     *<F5>*
 65 | <F5> ... :CheckSyntax<cr>
 66 | 
 67 |                                                     *i_<F5>*
 68 | i_<F5> ... <c-o>:CheckSyntax<cr>
 69 | 
 70 | 
 71 | ========================================================================
 72 | autoload/checksyntax.vim~
 73 | 
 74 |                                                     *g:checksyntax*
 75 | g:checksyntax                  (default: {})
 76 |     A dictionary {name/filetype => definition} of syntax checkers, where 
 77 |     definition is a dictionary with the following fields:
 78 |     
 79 |     Mandatory (either one of the following):
 80 |       cmd  ... A shell command used as 'makeprg' to check the file.
 81 |       exec ... A vim command used to check the file.
 82 |       compiler ... A vim compiler that is used to check the file.
 83 |     
 84 |     Optional:
 85 |       auto ... Run automatically when saving a file.
 86 |       efm  ... An 'errorformat' string.
 87 |       okrx ... A |regexp| matching the command output if no error were 
 88 |                found.
 89 |       failrx ... A |regexp| matching the command output if an error 
 90 |                was found.
 91 |       alt  ... The name of an alternative syntax checker (see 
 92 |                |:CheckSyntax|).
 93 |       prepare ... An ex command that is run before doing anything.
 94 |       ignore_nr ... A list of error numbers that should be ignored.
 95 | 
 96 |                                                     *checksyntax#Check()*
 97 | checksyntax#Check(manually, ?bang='', ?type=&ft)
 98 | 
 99 | 
100 | 
101 | vim:tw=78:fo=tcq2:isk=!-~,^*,^|,^":ts=8:ft=help:norl:
102 | 


--------------------------------------------------------------------------------
/.vimrc:
--------------------------------------------------------------------------------
  1 | " .vimrc
  2 | " See: http://vimdoc.sourceforge.net/htmldoc/options.html for details
  3 | 
  4 | " Source local settings
  5 | if filereadable("~/.vimrc")
  6 |     source ~/.vimrc
  7 | endif
  8 | 
  9 | " disable VI's compatible mode（关闭vi兼容模式）
 10 | set nocompatible
 11 | " set encoding=utf-8（设置支持多语言）
 12 | set fileencodings=utf-8,gbk,default,latin1
 13 | "set gui options(设置字体，配色方案)
 14 | if has("gui_running")
 15 | set guifont=Courier\ New\ 14
 16 | " on windows,use "set guifont=Courier:14 "
 17 | " set color schema(设置配色方案)
 18 | " colorscheme oceandeep
 19 | endif
 20 | 
 21 | " Basic editing options
 22 | set number          " Show line numbers.显示行号
 23 | set expandtab       " Use the appropriate number of spaces to insert a <Tab>.用空格替换tab
 24 | set shiftwidth=2    " Number of spaces to use for each step of (auto)indent.自动缩进的空格数
 25 | set tabstop=2       " Number of spaces that a <Tab> in the file counts for.一个tab用几个空格替换
 26 | au FileType html,python,vim,javascript,css setl shiftwidth=2
 27 | au FileType html,python,vim,javascript,css setl tabstop=2
 28 | au FileType java,php setl shiftwidth=4
 29 | au FileType java,php setl tabstop=4
 30 | 
 31 | set textwidth=80    " Maximum width of text that is being inserted. A longer
 32 |                     " line will be broken after white space to get this width.（每行的最大字符数，超过的话，将换行）
 33 | set hlsearch        " When there is a previous search pattern, highlight all
 34 |                     " its matches.（搜索时高亮显示）
 35 |  
 36 | set incsearch       " While typing a search command, show immediately where the
 37 |                     " so far typed pattern matches.（搜索时，立即高亮显示输入的字符）
 38 | set fileformat=unix   " 文本格式
 39 | set nobackup          " 不生成备份文件
 40 | " Show a status bar  "  显示状态栏
 41 | set ruler
 42 | set laststatus=2
 43 | " Show Tab Bar
 44 | set showtabline=2     " 生成多tab
 45 | set tabline+=%f
 46 | " Enable Code Folding
 47 | set foldenable
 48 | set foldmethod=syntax
 49 | set mouse=a         " Enable the use of the mouse.（可以使用鼠标）
 50 | 
 51 | 
 52 | set cmdheight=1     "设定命令行的行数为 1
 53 | "去掉烦死我的错误声音
 54 | set vb t_vb=
 55 | "工作目录随文件变
 56 | autocmd BufEnter * cd %:p:h
 57 | "设置状态栏
 58 | set statusline=%F%m%r,%Y,%{&fileformat}\ \ \ ASCII=\%b,HEX=\%B\ \ \ %l,%c%V\ %p%%\ \ \ [\ %L\ lines\ in\ all\ ]
 59 | "不显示工具条
 60 | "set guioptions-=T
 61 | set backspace=indent,eol,start "不设定的话在插入状态无法用退格键和 Delete
 62 | filetype indent on "设置文件类型的检测，e.g. for PHP
 63 | filetype plugin on "为特定的文件类型允许插件文件的载入
 64 | 
 65 | " Allow file inline modelines to provide settings
 66 | set modeline
 67 | 
 68 | 
 69 | 
 70 | """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 71 | " => Plugin configuration
 72 | """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 73 | " NERDTree
 74 | map <F2> :NERDTreeToggle<CR>
 75 | let NERDTreeIgnore=['\.svn$','\.bak$']
 76 | 
 77 | " taglist
 78 | set tags=tags;/
 79 | let Tlist_Ctags_Cmd="/usr/bin/ctags"
 80 | map <F3> :TlistToggle<CR>
 81 | let Tlist_Auto_Highlight_Tag = 1
 82 | let Tlist_Auto_Open = 0
 83 | let Tlist_Auto_Update = 1
 84 | let Tlist_Close_On_Select = 0
 85 | let Tlist_Compact_Format = 0
 86 | let Tlist_Display_Prototype = 0
 87 | let Tlist_Display_Tag_Scope = 1
 88 | let Tlist_Enable_Fold_Column = 0
 89 | let Tlist_Exit_OnlyWindow = 0
 90 | let Tlist_File_Fold_Auto_Close = 0
 91 | let Tlist_GainFocus_On_ToggleOpen = 1
 92 | let Tlist_Hightlight_Tag_On_BufEnter = 1
 93 | let Tlist_Inc_Winwidth = 0
 94 | let Tlist_Max_Submenu_Items = 1
 95 | let Tlist_Max_Tag_Length = 30
 96 | let Tlist_Process_File_Always = 0
 97 | let Tlist_Show_Menu = 0
 98 | let Tlist_Show_One_File = 0
 99 | let Tlist_Sort_Type = "order"
100 | let Tlist_Use_Horiz_Window = 0
101 | let Tlist_Use_Right_Window = 0
102 | let Tlist_WinWidth = 40
103 | let tlist_php_settings = 'php;c:class;i:interfaces;d:constant;f:function'
104 | 
105 | " Disable phpsyntax based indenting for .php files {{{
106 | au BufRead,BufNewFile *.php		set indentexpr= | set smartindent
107 | " }}}
108 | 
109 | " {{{ .phps files handled like .php
110 | 
111 | au BufRead,BufNewFile *.phps		set filetype=php
112 | 
113 | " }}}
114 | 
115 | " {{{  Settings
116 | 
117 | 
118 | 
119 | " MovingThroughCamelCaseWords
120 | nnoremap <silent><C-Left>  :<C-u>cal search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%^','bW')<CR>
121 | nnoremap <silent><C-Right> :<C-u>cal search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%$','W')<CR>
122 | inoremap <silent><C-Left>  <C-o>:cal search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%^','bW')<CR>
123 | inoremap <silent><C-Right> <C-o>:cal search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%$','W')<CR> 
124 | 
125 | " }}}
126 | 
127 | " Map <F5> to turn spelling on (VIM 7.0+)
128 | map <F5> :setlocal spell! spelllang=en_us<cr>
129 | " Map <F6> to turn spelling (de) on (VIM 7.0+)
130 | "map <F6> :setlocal spell! spelllang=de<cr>
131 | 
132 | " Highlight current line in insert mode.
133 | autocmd InsertLeave * se nocul
134 | autocmd InsertEnter * se cul 
135 | 
136 | if has("cscope")
137 | 	set csprg=/usr/bin/cscope
138 | 	set csto=0
139 | 	set cst
140 | 	set nocsverb
141 | 	" add any database in current directory
142 | 	if filereadable("cscope.out")
143 | 	    cs add cscope.out
144 | 	" else add database pointed to by environment
145 | 	elseif $CSCOPE_DB != ""
146 | 	    cs add $CSCOPE_DB
147 | 	endif
148 | 	set csverb
149 | endif
150 | 


--------------------------------------------------------------------------------
/ptags.cpp:
--------------------------------------------------------------------------------
  1 | // Save this file as ptags.cpp and compile by
  2 | //              g++ -o ptags ptags.cpp
  3 | //*****************************************************************
  4 | // Copyright policy is GNU/GPL but additional request is
  5 | // that you include author's name and email on all copies
  6 | // Author : Al Dev Email: alavoor@yahoo.com
  7 | // Usage : ptags *.php3 *.inc
  8 | //                 This will generate a file called tags
  9 | //*****************************************************************
 10 | #include <iostream>
 11 | #include <fstream>
 12 | #include <stdio.h> // for sprintf
 13 | #include <stdlib.h> // for system
 14 | #include <string.h> // for memset
 15 | #include <ctype.h> // for isspace
 16 | 
 17 | #define BUFF_LEN  1024
 18 | #define LOCATION  9
 19 | using namespace std;
 20 | 
 21 | char *ltrim(char *dd);
 22 | char *rtrim(char *ee);
 23 | 
 24 | main(int argc, char **argv)
 25 | {
 26 |         if (argc < 2)
 27 |         {
 28 |                 cerr << "\nUsage: " << argv[0] << " file .... " << endl;
 29 |                 exit(0);
 30 |         }
 31 | 
 32 |         char fname[100] = "tag_file.out";
 33 |         FILE    *fpout;
 34 |         ofstream    fout(fname);
 35 |         if (fout.fail())
 36 |         {
 37 |                 cerr << "\nError opening file : " << fname << endl;
 38 |                 exit(-1);
 39 |         }
 40 |         //fpout = fopen(fname, "w");
 41 | 
 42 |         for (int ii = 1; ii < argc; ii++)
 43 |         {
 44 |                 /*
 45 |                 char buff[2024];
 46 | 
 47 |                 sprintf(buff, "\\rm -f %s; ls %s > %s 2>/dev/null", outfile, argv[1], outfile);
 48 |                 cout << "\nbuff = " << buff << endl;
 49 | 
 50 |                 system(buff);
 51 |                 fclose(fp);
 52 |                 */
 53 |                 FILE *fpin = NULL;
 54 |                 fpin = fopen(argv[ii], "r");
 55 |                 if (fpin == NULL)
 56 |                 {
 57 |                         cerr << "\nError opening file : " << argv[ii] << endl;
 58 |                         exit(-1);
 59 |                 }
 60 |                 char buff[BUFF_LEN + 100];
 61 |                 memset(buff, 0, BUFF_LEN +10);
 62 |                 for ( ; fgets(buff, BUFF_LEN, fpin) != NULL; )
 63 |                 {
 64 |                         char aa[BUFF_LEN + 100];
 65 |                         char aapointer[BUFF_LEN + 100];
 66 |                         memset(aa, 0, BUFF_LEN +10);
 67 |                         strcpy(aa, buff);
 68 |                         strcpy(aapointer, ltrim(aa));
 69 |                         strcpy(aa, aapointer);
 70 | 
 71 |                         // Remove the trailing new line..
 72 |                         {
 73 |                                 int tmpii = strlen(aa);
 74 |                                 if (aa[tmpii-1] == '\n')
 75 |                                         aa[tmpii-1] = 0;
 76 |                         }
 77 |                         //cout << "aa is : " << aa << endl;
 78 |                         //cout << "aapointer is : " << aapointer << endl;
 79 |                         if (strncmp(aa, "function ", LOCATION) != 0)
 80 |                                 continue;
 81 |                         //cout << buff << endl;
 82 | 
 83 |                         // Example tags file output is like -
 84 |                         // al2  al.c    /^al2()$/;"     f
 85 |                         {
 86 |                                 char bb[BUFF_LEN + 100];
 87 |                                 memset(bb, 0, BUFF_LEN +10);
 88 |                                 strcpy(bb, & aa[LOCATION]);
 89 |                                 char *cc = bb;
 90 |                                 while (cc != NULL && *cc != '(')
 91 |                                         *cc++;
 92 |                                 *cc = 0;
 93 |                                 cc = rtrim(bb);
 94 |                                 //cout << "bb is : " << bb << endl;
 95 |                                 //cout << cc << "\t" << argv[ii] << "\t" << "/^" << aa << "$/;\"\tf" << endl;
 96 |                                 fout << cc << "\t" << argv[ii] << "\t" << "/^" << aa << "$/;\"\tf" << endl;
 97 |                                 //fprintf(fpout, "%s\t%s\t/^%s$/;\"f\n", cc, argv[ii], aa );
 98 |                         }
 99 | 
100 |                         memset(buff, 0, BUFF_LEN +10);
101 |                 }
102 |                 fclose(fpin);
103 |         }
104 |         fout.flush();
105 |         fout.close();
106 |         //fclose(fpout);
107 | 
108 |         // Sort and generate the tag file
109 |         {
110 |                 char tmpaa[1024];
111 |                 sprintf(tmpaa, "sort %s > tags; \\rm -f %s", fname, fname);
112 |                 system(tmpaa);
113 |         }
114 | }
115 | 
116 | char *ltrim(char *dd)
117 | {
118 |     if (dd == NULL)
119 |         return NULL;
120 | 
121 |     while (isspace(*dd))
122 |         dd++;
123 |         
124 |         return dd;
125 | }
126 | 
127 | char *rtrim(char *ee)
128 | {
129 |     if (ee == NULL)
130 |         return NULL;
131 | 
132 |         int tmpii = strlen(ee) - 1;
133 |         for (; tmpii >= 0 ; tmpii--)
134 |         {
135 |                 if (isspace(ee[tmpii]) )
136 |                 {
137 |                         //cout << "\nis a space!!" << endl;
138 |                         ee[tmpii] = 0;
139 |                 }
140 |         }
141 |         return ee;
142 | }


--------------------------------------------------------------------------------
/vimfiles/phpm/lib/epc/phpm/parser.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  *	PHP.net DocBook manual parser.
  4 |  *   
  5 |  *  The purpose of the class is to generate a XML file that contains all the
  6 |  *  function calls available in the PHP manual, this will be used to make a CLI
  7 |  *  function lookup program.
  8 |  *
  9 |  *	@package EPC_Phpm
 10 |  *	@license GPL
 11 |  */
 12 | 
 13 | // {{{ class EPC_Xml_ManualParser
 14 | class EPC_Phpm_Parser
 15 | {
 16 |     // {{{ private variables
 17 |     private $startDir;
 18 |     // }}}
 19 | 
 20 |     // {{{ public function __construct( $conf )
 21 |     /**
 22 |      *	Create a new manual parser
 23 |      *
 24 |      *	@param string $startDir Where are we starting the parsing
 25 |      *  @access public
 26 |      *  @return void
 27 |      */ 
 28 |     public function __construct( $conf )
 29 |     {
 30 |         if( file_exists( $conf ) )
 31 |         {
 32 |             $this->settings = simplexml_load_file( $conf );
 33 |             if( !file_exists( $this->settings->cvsdir ) )
 34 |             {
 35 |                 die( "Can't find the CVS dir in: " . $this->settings->cvsdir );
 36 |             }
 37 |         }
 38 |         else
 39 |         {
 40 |             die( "Can't load a settings file that is missing...." );
 41 |         }
 42 |         $this->startDir = $startDir;
 43 |     }
 44 |     // }}}
 45 | 
 46 |     // {{{ public function run()
 47 |     /**
 48 |      *	Main function on the object, initiates the parsing
 49 |      *  of the main document tree.
 50 |      *
 51 |      *  @access public
 52 |      *  @return void
 53 |      */
 54 |     public function run()
 55 |     {
 56 |         // XML declaration is good to have:
 57 |         $this->buffer = '<?xml version="1.0" encoding="iso-8859-1"?>' . "\n<manual>";
 58 |         /*
 59 |          *  We loop over all the directories in the dir given in the 
 60 |          *  constructor: each of these will have a directory called "functions", this
 61 |          *  is where all the XML files we want to process are.
 62 |          */
 63 |         $dir = new RecursiveDirectoryIterator( $this->settings->cvsdir );
 64 |         foreach( $dir as $file )
 65 |         {
 66 |             echo ">>Processing: $file\n";
 67 |             if( $file->isDir() && $file->getFileName() != "CVS" )
 68 |             {
 69 |                 foreach( $file->getChildren() as $f )
 70 |                 {
 71 |                     if( $f->getFileName() == "functions" )
 72 |                     {
 73 |                         $this->processDirectory( $f->getChildren() );
 74 |                     }   
 75 |                 }
 76 |             }
 77 |         }
 78 |         $this->buffer .= "\n</manual>";
 79 |         file_put_contents( $this->settings->save, $this->buffer );
 80 |     }
 81 |     // }}}
 82 |     
 83 |     // {{{ private function processDirectory( $file )
 84 |     /**
 85 |      *  Helper function that iterates over the XML files in a single "functions/" 
 86 |      *  directory.
 87 |      *  It passes each file to the processFile() function.
 88 |      *
 89 |      *  @access private
 90 |      *  @return void
 91 |      *  @param $file object A DirectoryIterator instance
 92 |      */
 93 |     private function processDirectory( DirectoryIterator $file )
 94 |     {
 95 |         foreach( $file as $f )
 96 |         {
 97 |             $this->processFile( $f );
 98 |         }
 99 |     }
100 |     // }}}
101 |     
102 |     // {{{ private function processFile( $file )
103 |     /**
104 |      *  This function is where all the lookup of the manual entry is.
105 |      *
106 |      *  We are very lazy here: we suppress any errors that the Dom might throw at
107 |      *  us, and we load the XML data as HTML - we're just interested in a particular
108 |      *  node - no need to have a whole document that is valid, as long as we are able
109 |      *  to get to the "methodsynopsis" node.
110 |      *
111 |      
112 |      *  @param object $file A DirectoryIterator instance
113 |      *  @access private
114 |      *  @return void
115 |      */
116 |     private function processFile( DirectoryIterator $file )
117 |     {
118 |         $dom = new DomDocument();
119 |         @$dom->loadHTML( file_get_contents( $file->getPathName() ) );
120 |         $xpath = new DomXpath( $dom );
121 |         
122 |         // Get the node where the description of the function call is:
123 |         $result = @$xpath->query( "//methodsynopsis" );
124 |         // Make sure we find a node:
125 |         if( $result->item( 0 ) )
126 |         {
127 |         	$item = $result->item( 0 );
128 |             if( $this->settings->debug == 1 )
129 |             {
130 |                 echo "\tparsing: " . $file->getFileName() . "\n";
131 |             }
132 |             
133 |             /*
134 |              *	Get the first para in the documentation, this might come
135 |              *	out wrong for some of the functions, but: it's the closest
136 |              *	we can come to something useful.
137 |              */
138 |             $result = @$xpath->query( "//para" );
139 |         	if( $result->item( 0 ) )
140 |         	{
141 |         		$para = simplexml_import_dom( $result->item( 0 ) );
142 |         		$desc = $para->asXml();
143 |         		// defenently don't need tags for the terminal :)
144 |         		$desc = htmlentities( strip_tags( $desc ) );
145 |         		// We don't need all the space/newlines around either
146 |         		$desc = preg_replace( "/[\r\n][\s]+/", " ", $desc );
147 |         		
148 |         		// Some of the functions are undocumented:
149 |         		if( strstr( $desc, "warn.undocumented.func;" ) )
150 |         		{
151 |         			$desc = "Undocumented";
152 |         		}
153 |         		$item->appendChild(
154 |         			$dom->createElement(
155 |         				"desc",
156 |        					$desc
157 |         			)	
158 |         		);
159 |         	}            
160 |             $xml = simplexml_import_dom( $item );
161 |             // Set the "function" attribute - this is what we will look for later.
162 |             $xml['function'] = (string)$xml->methodname;
163 |         	$result = @$xpath->query( "//para" );
164 |        		$this->buffer .= "\n" . $xml->asXml();
165 |         }
166 |     }
167 | 
168 | }
169 | // }}}
170 | 
171 | // }}}
172 | ?>
173 | 


--------------------------------------------------------------------------------
/vimfiles/ftplugin/php.vim:
--------------------------------------------------------------------------------
  1 | " .vim/ftplugin/php.vim by Tobias Schlitt <toby@php.net>.
  2 | " No copyright, feel free to use this, as you like.
  3 | 
  4 | " Including PDV
  5 | source /usr/share/vim/vimfiles/plugin/php-doc.vim
  6 | 
  7 | let PHP_autoformatcomment = 1
  8 | 
  9 | " {{{ Settings
 10 | 
 11 | " Auto expand tabs to spaces
 12 | setlocal expandtab
 13 | 
 14 | " Auto indent after a {
 15 | setlocal autoindent
 16 | setlocal smartindent
 17 | 
 18 | " Linewidth to 79, because of the formatoptions this is only valid for
 19 | " comments
 20 | setlocal textwidth=79
 21 | setlocal formatoptions=qrocb
 22 | 
 23 | " Do not wrap lines automatically
 24 | " setlocal nowrap
 25 | 
 26 | " Correct indentation after opening a phpdocblock and automatic * on every
 27 | " line
 28 | setlocal formatoptions=qroct
 29 | 
 30 | " Use php syntax check when doing :make
 31 | setlocal makeprg=php\ -l\ %
 32 | 
 33 | " Use errorformat for parsing PHP error output
 34 | setlocal errorformat=%m\ in\ %f\ on\ line\ %l
 35 | 
 36 | " Switch syntax highlighting on, if it was not
 37 | syntax on
 38 | 
 39 | " Use pman for manual pages
 40 | setlocal keywordprg=pman
 41 | 
 42 | " }}} Settings
 43 | 
 44 | " {{{ Command mappings
 45 | 
 46 | " Map ; to run PHP parser check
 47 | " noremap ; :!php5 -l %<CR>
 48 | 
 49 | " Map ; to "add ; to the end of the line, when missing"
 50 | noremap <buffer> ; :s/\([^;]\)$/\1;/<cr>
 51 | 
 52 | " DEPRECATED in favor of PDV documentation (see below!)
 53 | " Map <CTRL>-P to run actual file with PHP CLI
 54 | " noremap <C-P> :w!<CR>:!php5 %<CR>
 55 | 
 56 | " Map <ctrl>+p to single line mode documentation (in insert and command mode)
 57 | inoremap <buffer> <C-P> :call PhpDocSingle()<CR>i
 58 | nnoremap <buffer> <C-P> :call PhpDocSingle()<CR>
 59 | " Map <ctrl>+p to multi line mode documentation (in visual mode)
 60 | vnoremap <buffer> <C-P> :call PhpDocRange()<CR>
 61 | 
 62 | " Map <CTRL>-H to search phpm for the function name currently under the cursor (insert mode only)
 63 | inoremap <buffer> <C-H> <ESC>:!/usr/share/vim/vimfiles/phpm/phpm <C-R>=expand("<cword>")<CR><CR>
 64 | 
 65 | " Map <CTRL>-a to alignment function
 66 | vnoremap <buffer> <C-a> :call PhpAlign()<CR>
 67 | 
 68 | " Map <CTRL>-a to (un-)comment function
 69 | vnoremap <buffer> <C-c> :call PhpUnComment()<CR>
 70 | 
 71 | " }}}
 72 | 
 73 | " {{{ Automatic close char mapping
 74 | 
 75 | " More common in PEAR coding standard
 76 | " inoremap <buffer>  { {<CR>}<C-O>O
 77 | " Maybe this way in other coding standards
 78 | inoremap <buffer>  { {<CR>}<C-O>O
 79 | 
 80 | inoremap <buffer> [ []<LEFT>
 81 | 
 82 | " Standard mapping after PEAR coding standard
 83 | inoremap <buffer> ( ()<LEFT>
 84 | " inoremap <buffer> ( ()<LEFT>
 85 | 
 86 | " Maybe this way in other coding standards
 87 | " inoremap ( ( )<LEFT><LEFT> 
 88 | 
 89 | inoremap <buffer> " ""<LEFT>
 90 | inoremap <buffer> ' ''<LEFT>
 91 | 
 92 | " }}} Automatic close char mapping
 93 | 
 94 | " {{{ Wrap visual selections with chars
 95 | 
 96 | :vnoremap <buffer> ( "zdi(<C-R>z)<ESC>
 97 | :vnoremap <buffer> { "zdi{<C-R>z}<ESC>
 98 | :vnoremap <buffer> [ "zdi[<C-R>z]<ESC>
 99 | :vnoremap <buffer> ' "zdi'<C-R>z'<ESC>
100 | " Removed in favor of register addressing
101 | " :vnoremap " "zdi"<C-R>z"<ESC>
102 | 
103 | " }}} Wrap visual selections with chars
104 | 
105 | " {{{ Dictionary completion
106 | 
107 | " The completion dictionary is provided by Rasmus:
108 | " http://lerdorf.com/funclist.txt
109 | setlocal dictionary-=/usr/share/vim/vimfiles/funclist.txt dictionary+=/usr/share/vim/vimfiles/funclist.txt
110 | " Use the dictionary completion
111 | setlocal complete-=k complete+=k
112 | 
113 | " }}} Dictionary completion
114 | 
115 | " {{{ Autocompletion using the TAB key
116 | 
117 | " This function determines, wether we are on the start of the line text (then tab indents) or
118 | " if we want to try autocompletion
119 | func! InsertTabWrapper()
120 |     let col = col('.') - 1
121 |     if !col || getline('.')[col - 1] !~ '\k'
122 |         return "\<tab>"
123 |     else
124 |         return "\<c-p>"
125 |     endif
126 | endfunction
127 | 
128 | " Remap the tab key to select action with InsertTabWrapper
129 | inoremap <buffer> <tab> <c-r>=InsertTabWrapper()<cr>
130 | 
131 | " }}} Autocompletion using the TAB key
132 | 
133 | " {{{ Alignment
134 | 
135 | func! PhpAlign() range
136 |     let l:paste = &g:paste
137 |     let &g:paste = 0
138 | 
139 |     let l:line        = a:firstline
140 |     let l:endline     = a:lastline
141 |     let l:maxlength = 0
142 |     while l:line <= l:endline
143 | 		" Skip comment lines
144 | 		if getline (l:line) =~ '^\s*\/\/.*$'
145 | 			let l:line = l:line + 1
146 | 			continue
147 | 		endif
148 | 		" \{-\} matches ungreed *
149 |         let l:index = substitute (getline (l:line), '^\s*\(.\{-\}\)\s*\S\{0,1}=\S\{0,1\}\s.*$', '\1', "") 
150 |         let l:indexlength = strlen (l:index)
151 |         let l:maxlength = l:indexlength > l:maxlength ? l:indexlength : l:maxlength
152 |         let l:line = l:line + 1
153 |     endwhile
154 |     
155 | 	let l:line = a:firstline
156 | 	let l:format = "%s%-" . l:maxlength . "s %s %s"
157 |     
158 | 	while l:line <= l:endline
159 | 		if getline (l:line) =~ '^\s*\/\/.*$'
160 | 			let l:line = l:line + 1
161 | 			continue
162 | 		endif
163 |         let l:linestart = substitute (getline (l:line), '^\(\s*\).*', '\1', "")
164 |         let l:linekey   = substitute (getline (l:line), '^\s*\(.\{-\}\)\s*\(\S\{0,1}=\S\{0,1\}\)\s\(.*\)$', '\1', "")
165 |         let l:linesep   = substitute (getline (l:line), '^\s*\(.\{-\}\)\s*\(\S\{0,1}=\S\{0,1\}\)\s\(.*\)$', '\2', "")
166 |         let l:linevalue = substitute (getline (l:line), '^\s*\(.\{-\}\)\s*\(\S\{0,1}=\S\{0,1\}\)\s\(.*\)$', '\3', "")
167 | 
168 |         let l:newline = printf (l:format, l:linestart, l:linekey, l:linesep, l:linevalue)
169 |         call setline (l:line, l:newline)
170 |         let l:line = l:line + 1
171 |     endwhile
172 |     let &g:paste = l:paste
173 | endfunc
174 | 
175 | " }}}   
176 | 
177 | " {{{ (Un-)comment
178 | 
179 | func! PhpUnComment() range
180 |     let l:paste = &g:paste
181 |     let &g:paste = 0
182 | 
183 |     let l:line        = a:firstline
184 |     let l:endline     = a:lastline
185 | 
186 | 	while l:line <= l:endline
187 | 		if getline (l:line) =~ '^\s*\/\/.*$'
188 | 			let l:newline = substitute (getline (l:line), '^\(\s*\)\/\/ \(.*\).*$', '\1\2', '')
189 | 		else
190 | 			let l:newline = substitute (getline (l:line), '^\(\s*\)\(.*\)$', '\1// \2', '')
191 | 		endif
192 | 		call setline (l:line, l:newline)
193 | 		let l:line = l:line + 1
194 | 	endwhile
195 | 
196 |     let &g:paste = l:paste
197 | endfunc
198 | 
199 | " }}}
200 | 


--------------------------------------------------------------------------------
/vimfiles/nerdtree_plugin/fs_menu.vim:
--------------------------------------------------------------------------------
  1 | " ============================================================================
  2 | " File:        fs_menu.vim
  3 | " Description: plugin for the NERD Tree that provides a file system menu
  4 | " Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
  5 | " Last Change: 17 July, 2009
  6 | " License:     This program is free software. It comes without any warranty,
  7 | "              to the extent permitted by applicable law. You can redistribute
  8 | "              it and/or modify it under the terms of the Do What The Fuck You
  9 | "              Want To Public License, Version 2, as published by Sam Hocevar.
 10 | "              See http://sam.zoy.org/wtfpl/COPYING for more details.
 11 | "
 12 | " ============================================================================
 13 | if exists("g:loaded_nerdtree_fs_menu")
 14 |     finish
 15 | endif
 16 | let g:loaded_nerdtree_fs_menu = 1
 17 | 
 18 | call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'})
 19 | call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
 20 | call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
 21 | if g:NERDTreePath.CopyingSupported()
 22 |     call NERDTreeAddMenuItem({'text': '(c)copy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
 23 | endif
 24 | 
 25 | "FUNCTION: s:echo(msg){{{1
 26 | function! s:echo(msg)
 27 |     redraw
 28 |     echomsg "NERDTree: " . a:msg
 29 | endfunction
 30 | 
 31 | "FUNCTION: s:echoWarning(msg){{{1
 32 | function! s:echoWarning(msg)
 33 |     echohl warningmsg
 34 |     call s:echo(a:msg)
 35 |     echohl normal
 36 | endfunction
 37 | 
 38 | "FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1
 39 | "prints out the given msg and, if the user responds by pushing 'y' then the
 40 | "buffer with the given bufnum is deleted
 41 | "
 42 | "Args:
 43 | "bufnum: the buffer that may be deleted
 44 | "msg: a message that will be echoed to the user asking them if they wish to
 45 | "     del the buffer
 46 | function! s:promptToDelBuffer(bufnum, msg)
 47 |     echo a:msg
 48 |     if nr2char(getchar()) ==# 'y'
 49 |         exec "silent bdelete! " . a:bufnum
 50 |     endif
 51 | endfunction
 52 | 
 53 | "FUNCTION: NERDTreeAddNode(){{{1
 54 | function! NERDTreeAddNode()
 55 |     let curDirNode = g:NERDTreeDirNode.GetSelected()
 56 | 
 57 |     let newNodeName = input("Add a childnode\n".
 58 |                           \ "==========================================================\n".
 59 |                           \ "Enter the dir/file name to be created. Dirs end with a '/'\n" .
 60 |                           \ "", curDirNode.path.str() . g:NERDTreePath.Slash())
 61 | 
 62 |     if newNodeName ==# ''
 63 |         call s:echo("Node Creation Aborted.")
 64 |         return
 65 |     endif
 66 | 
 67 |     try
 68 |         let newPath = g:NERDTreePath.Create(newNodeName)
 69 |         let parentNode = b:NERDTreeRoot.findNode(newPath.getParent())
 70 | 
 71 |         let newTreeNode = g:NERDTreeFileNode.New(newPath)
 72 |         if parentNode.isOpen || !empty(parentNode.children)
 73 |             call parentNode.addChild(newTreeNode, 1)
 74 |             call NERDTreeRender()
 75 |             call newTreeNode.putCursorHere(1, 0)
 76 |         endif
 77 |     catch /^NERDTree/
 78 |         call s:echoWarning("Node Not Created.")
 79 |     endtry
 80 | endfunction
 81 | 
 82 | "FUNCTION: NERDTreeMoveNode(){{{1
 83 | function! NERDTreeMoveNode()
 84 |     let curNode = g:NERDTreeFileNode.GetSelected()
 85 |     let newNodePath = input("Rename the current node\n" .
 86 |                           \ "==========================================================\n" .
 87 |                           \ "Enter the new path for the node:                          \n" .
 88 |                           \ "", curNode.path.str())
 89 | 
 90 |     if newNodePath ==# ''
 91 |         call s:echo("Node Renaming Aborted.")
 92 |         return
 93 |     endif
 94 | 
 95 |     try
 96 |         let bufnum = bufnr(curNode.path.str())
 97 | 
 98 |         call curNode.rename(newNodePath)
 99 |         call NERDTreeRender()
100 | 
101 |         "if the node is open in a buffer, ask the user if they want to
102 |         "close that buffer
103 |         if bufnum != -1
104 |             let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
105 |             call s:promptToDelBuffer(bufnum, prompt)
106 |         endif
107 | 
108 |         call curNode.putCursorHere(1, 0)
109 | 
110 |         redraw
111 |     catch /^NERDTree/
112 |         call s:echoWarning("Node Not Renamed.")
113 |     endtry
114 | endfunction
115 | 
116 | " FUNCTION: NERDTreeDeleteNode() {{{1
117 | function! NERDTreeDeleteNode()
118 |     let currentNode = g:NERDTreeFileNode.GetSelected()
119 |     let confirmed = 0
120 | 
121 |     if currentNode.path.isDirectory
122 |         let choice =input("Delete the current node\n" .
123 |                          \ "==========================================================\n" .
124 |                          \ "STOP! To delete this entire directory, type 'yes'\n" .
125 |                          \ "" . currentNode.path.str() . ": ")
126 |         let confirmed = choice ==# 'yes'
127 |     else
128 |         echo "Delete the current node\n" .
129 |            \ "==========================================================\n".
130 |            \ "Are you sure you wish to delete the node:\n" .
131 |            \ "" . currentNode.path.str() . " (yN):"
132 |         let choice = nr2char(getchar())
133 |         let confirmed = choice ==# 'y'
134 |     endif
135 | 
136 | 
137 |     if confirmed
138 |         try
139 |             call currentNode.delete()
140 |             call NERDTreeRender()
141 | 
142 |             "if the node is open in a buffer, ask the user if they want to
143 |             "close that buffer
144 |             let bufnum = bufnr(currentNode.path.str())
145 |             if buflisted(bufnum)
146 |                 let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
147 |                 call s:promptToDelBuffer(bufnum, prompt)
148 |             endif
149 | 
150 |             redraw
151 |         catch /^NERDTree/
152 |             call s:echoWarning("Could not remove node")
153 |         endtry
154 |     else
155 |         call s:echo("delete aborted")
156 |     endif
157 | 
158 | endfunction
159 | 
160 | " FUNCTION: NERDTreeCopyNode() {{{1
161 | function! NERDTreeCopyNode()
162 |     let currentNode = g:NERDTreeFileNode.GetSelected()
163 |     let newNodePath = input("Copy the current node\n" .
164 |                           \ "==========================================================\n" .
165 |                           \ "Enter the new path to copy the node to:                   \n" .
166 |                           \ "", currentNode.path.str())
167 | 
168 |     if newNodePath != ""
169 |         "strip trailing slash
170 |         let newNodePath = substitute(newNodePath, '\/$', '', '')
171 | 
172 |         let confirmed = 1
173 |         if currentNode.path.copyingWillOverwrite(newNodePath)
174 |             call s:echo("Warning: copying may overwrite files! Continue? (yN)")
175 |             let choice = nr2char(getchar())
176 |             let confirmed = choice ==# 'y'
177 |         endif
178 | 
179 |         if confirmed
180 |             try
181 |                 let newNode = currentNode.copy(newNodePath)
182 |                 call NERDTreeRender()
183 |                 call newNode.putCursorHere(0, 0)
184 |             catch /^NERDTree/
185 |                 call s:echoWarning("Could not copy node")
186 |             endtry
187 |         endif
188 |     else
189 |         call s:echo("Copy aborted.")
190 |     endif
191 |     redraw
192 | endfunction
193 | 
194 | " vim: set sw=4 sts=4 et fdm=marker:
195 | 


--------------------------------------------------------------------------------
/vimfiles/plugin/Tabular.vim:
--------------------------------------------------------------------------------
  1 | " Tabular:     Align columnar data using regex-designated column boundaries
  2 | " Maintainer:  Matthew Wozniski (mjw@drexel.edu)
  3 | " Date:        Thu, 11 Oct 2007 00:35:34 -0400
  4 | " Version:     0.1
  5 | 
  6 | " Abort if running in vi-compatible mode or the user doesn't want us.
  7 | if &cp || exists('g:tabular_loaded')
  8 |   if &cp && &verbose
  9 |     echo "Not loading Tabular in compatible mode."
 10 |   endif
 11 |   finish
 12 | endif
 13 | 
 14 | let g:tabular_loaded = 1
 15 | 
 16 | " Stupid vimscript crap                                                   {{{1
 17 | let s:savecpo = &cpo
 18 | set cpo&vim
 19 | 
 20 | " Private Things                                                          {{{1
 21 | 
 22 | " Dictionary of command name to command
 23 | let s:TabularCommands = {}
 24 | 
 25 | " Generate tab completion list for :Tabularize                            {{{2
 26 | " Return a list of commands that match the command line typed so far.
 27 | " NOTE: Tries to handle commands with spaces in the name, but Vim doesn't seem
 28 | "       to handle that terribly well... maybe I should give up on that.
 29 | function! s:CompleteTabularizeCommand(argstart, cmdline, cursorpos)
 30 |   let names = keys(s:TabularCommands)
 31 |   if exists("b:TabularCommands")
 32 |     let names += keys(b:TabularCommands)
 33 |   endif
 34 | 
 35 |   let cmdstart = substitute(a:cmdline, '^\s*\S\+\s*', '', '')
 36 | 
 37 |   return filter(names, 'v:val =~# ''^\V'' . escape(cmdstart, ''\'')')
 38 | endfunction
 39 | 
 40 | " Choose the proper command map from the given command line               {{{2
 41 | " Returns [ command map, command line with leading <buffer> removed ]
 42 | function! s:ChooseCommandMap(commandline)
 43 |   let map = s:TabularCommands
 44 |   let cmd = a:commandline
 45 | 
 46 |   if cmd =~# '^<buffer>\s\+'
 47 |     if !exists('b:TabularCommands')
 48 |       let b:TabularCommands = {}
 49 |     endif
 50 |     let map = b:TabularCommands
 51 |     let cmd = substitute(cmd, '^<buffer>\s\+', '', '')
 52 |   endif
 53 | 
 54 |   return [ map, cmd ]
 55 | endfunction
 56 | 
 57 | " Parse '/pattern/format' into separate pattern and format parts.         {{{2
 58 | " If parsing fails, return [ '', '' ]
 59 | function! s:ParsePattern(string)
 60 |   if a:string[0] != '/'
 61 |     return ['','']
 62 |   endif
 63 | 
 64 |   let pat = '\\\@<!\%(\\\\\)\{-}\zs/' . tabular#ElementFormatPattern() . '*$'
 65 |   let format = matchstr(a:string[1:-1], pat)
 66 |   if !empty(format)
 67 |     let format = format[1 : -1]
 68 |     let pattern = a:string[1 : -len(format) - 2]
 69 |   else
 70 |     let pattern = a:string[1 : -1]
 71 |   endif
 72 | 
 73 |   return [pattern, format]
 74 | endfunction
 75 | 
 76 | " Split apart a list of | separated expressions.                          {{{2
 77 | function! s:SplitCommands(string)
 78 |   if a:string =~ '^\s*$'
 79 |     return []
 80 |   endif
 81 | 
 82 |   let end = match(a:string, "[\"'|]")
 83 | 
 84 |   " Loop until we find a delimiting | or end-of-string
 85 |   while end != -1 && (a:string[end] != '|' || a:string[end+1] == '|')
 86 |     if a:string[end] == "'"
 87 |       let end = match(a:string, "'", end+1) + 1
 88 |       if end == 0
 89 |         throw "No matching end single quote"
 90 |       endif
 91 |     elseif a:string[end] == '"'
 92 |       " Find a " preceded by an even number of \ (or 0)
 93 |       let pattern = '\%(\\\@<!\%(\\\\\)*\)\@<="'
 94 |       let end = matchend(a:string, pattern, end+1) + 1
 95 |       if end == 0
 96 |         throw "No matching end double quote"
 97 |       endif
 98 |     else " Found ||
 99 |       let end += 2
100 |     endif
101 | 
102 |     let end = match(a:string, "[\"'|]", end)
103 |   endwhile
104 | 
105 |   if end == 0 || a:string[0 : end - (end > 0)] =~ '^\s*$'
106 |     throw "Empty element"
107 |   endif
108 | 
109 |   if end == -1
110 |     let rv = [ a:string ]
111 |   else
112 |     let rv = [ a:string[0 : end-1] ] + s:SplitCommands(a:string[end+1 : -1])
113 |   endif
114 | 
115 |   return rv
116 | endfunction
117 | 
118 | " Public Things                                                           {{{1
119 | 
120 | " Command associating a command name with a simple pattern command        {{{2
121 | " AddTabularPattern[!] [<buffer>] name /pattern[/format]
122 | "
123 | " If <buffer> is provided, the command will only be available in the current
124 | " buffer, and will be used instead of any global command with the same name.
125 | "
126 | " If a command with the same name and scope already exists, it is an error,
127 | " unless the ! is provided, in which case the existing command will be
128 | " replaced.
129 | "
130 | " pattern is a regex describing the delimiter to be used.
131 | "
132 | " format describes the format pattern to be used.  The default will be used if
133 | " none is provided.
134 | com! -nargs=+ -bang AddTabularPattern
135 |    \ call AddTabularPattern(<q-args>, <bang>0)
136 | 
137 | function! AddTabularPattern(command, force)
138 |   try
139 |     let [ commandmap, rest ] = s:ChooseCommandMap(a:command)
140 | 
141 |     let name = matchstr(rest, '.\{-}\ze\s*/')
142 |     let pattern = substitute(rest, '.\{-}\s*\ze/', '', '')
143 | 
144 |     let [ pattern, format ] = s:ParsePattern(pattern)
145 | 
146 |     if empty(name) || empty(pattern)
147 |       throw "Invalid arguments!"
148 |     endif
149 | 
150 |     if !a:force && has_key(commandmap, name)
151 |       throw string(name) . " is already defined, use ! to overwrite."
152 |     endif
153 | 
154 |     let command = "tabular#TabularizeStrings(a:lines, " . string(pattern)
155 | 
156 |     if !empty(format)
157 |       let command .=  ", " . string(format)
158 |     endif
159 | 
160 |     let command .= ")"
161 | 
162 |     let commandmap[name] = ":call tabular#PipeRange("
163 |           \ . string(pattern) . ","
164 |           \ . string(command) . ")"
165 |   catch
166 |     echohl ErrorMsg
167 |     echomsg "AddTabularPattern: " . v:exception
168 |     echohl None
169 |   endtry
170 | endfunction
171 | 
172 | " Command associating a command name with a pipeline of functions         {{{2
173 | " AddTabularPipeline[!] [<buffer>] name /pattern/ func [ | func2 [ | func3 ] ]
174 | "
175 | " If <buffer> is provided, the command will only be available in the current
176 | " buffer, and will be used instead of any global command with the same name.
177 | "
178 | " If a command with the same name and scope already exists, it is an error,
179 | " unless the ! is provided, in which case the existing command will be
180 | " replaced.
181 | "
182 | " pattern is a regex that will be used to determine which lines will be
183 | " filtered.  If the cursor line doesn't match the pattern, using the command
184 | " will be a no-op, otherwise the cursor and all contiguous lines matching the
185 | " pattern will be filtered.
186 | "
187 | " Each 'func' argument represents a function to be called.  This function
188 | " will have access to a:lines, a List containing one String per line being
189 | " filtered.
190 | com! -nargs=+ -bang AddTabularPipeline
191 |    \ call AddTabularPipeline(<q-args>, <bang>0)
192 | 
193 | function! AddTabularPipeline(command, force)
194 |   try
195 |     let [ commandmap, rest ] = s:ChooseCommandMap(a:command)
196 | 
197 |     let name = matchstr(rest, '.\{-}\ze\s*/')
198 |     let pattern = substitute(rest, '.\{-}\s*\ze/', '', '')
199 | 
200 |     let commands = matchstr(pattern, '^/.\{-}\\\@<!\%(\\\\\)\{-}/\zs.*')
201 |     let pattern = matchstr(pattern, '/\zs.\{-}\\\@<!\%(\\\\\)\{-}\ze/')
202 | 
203 |     if empty(name) || empty(pattern)
204 |       throw "Invalid arguments!"
205 |     endif
206 | 
207 |     if !a:force && has_key(commandmap, name)
208 |       throw string(name) . " is already defined, use ! to overwrite."
209 |     endif
210 | 
211 |     let commandlist = s:SplitCommands(commands)
212 | 
213 |     if empty(commandlist)
214 |       throw "Must provide a list of functions!"
215 |     endif
216 | 
217 |     let cmd = ":call tabular#PipeRange(" . string(pattern)
218 | 
219 |     for command in commandlist
220 |       let cmd .= "," . string(command)
221 |     endfor
222 | 
223 |     let cmd .= ")"
224 | 
225 |     let commandmap[name] = cmd
226 |   catch
227 |     echohl ErrorMsg
228 |     echomsg "AddTabularPipeline: " . v:exception
229 |     echohl None
230 |   endtry
231 | endfunction
232 | 
233 | " Tabularize /pattern[/format]                                            {{{2
234 | " Tabularize name
235 | "
236 | " Align text, either using the given pattern, or the command associated with
237 | " the given name.
238 | com! -nargs=* -range -complete=customlist,<SID>CompleteTabularizeCommand
239 |    \ Tabularize <line1>,<line2>call Tabularize(<q-args>)
240 | 
241 | function! Tabularize(command) range
242 |   if empty(a:command)
243 |     if !exists("s:last_tabularize_command")
244 |       echohl ErrorMsg
245 |       echomsg "Tabularize hasn't been called yet; no pattern/command to reuse!"
246 |       echohl None
247 |       return
248 |     endif
249 |   else
250 |     let s:last_tabularize_command = a:command
251 |   endif
252 | 
253 |   let command = s:last_tabularize_command
254 | 
255 |   let range = a:firstline . ',' . a:lastline
256 | 
257 |   try
258 |     let [ pattern, format ] = s:ParsePattern(command)
259 | 
260 |     if !empty(pattern)
261 |       let cmd  = "tabular#TabularizeStrings(a:lines, " . string(pattern)
262 | 
263 |       if !empty(format)
264 |         let cmd .= "," . string(format)
265 |       endif
266 | 
267 |       let cmd .= ")"
268 | 
269 |       exe range . 'call tabular#PipeRange(pattern, cmd)'
270 |     else
271 |       if exists('b:TabularCommands') && has_key(b:TabularCommands, command)
272 |         let command = b:TabularCommands[command]
273 |       elseif has_key(s:TabularCommands, command)
274 |         let command = s:TabularCommands[command]
275 |       else
276 |         throw "Unrecognized command " . string(command)
277 |       endif
278 | 
279 |       exe range . command
280 |     endif
281 |   catch
282 |     echohl ErrorMsg
283 |     echomsg "Tabularize: " . v:exception
284 |     echohl None
285 |     return
286 |   endtry
287 | endfunction
288 | 
289 | " Stupid vimscript crap, part 2                                           {{{1
290 | let &cpo = s:savecpo
291 | unlet s:savecpo
292 | 
293 | " vim:set sw=2 sts=2 fdm=marker:
294 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | 在fedora上用vim打造一个php集成开发环境（ide）
  2 | 1 安装vim
  3 | yum install vim-X11.x86_64  vim-common.x86_64 vim-enhanced.x86_64
  4 | vim-minimal.x86_64
  5 | 
  6 | 2 创建配置文件
  7 | touch ~/.vimrc
  8 | 
  9 | 3 我的配置文件
 10 | " .vimrc
 11 | " See: http://vimdoc.sourceforge.net/htmldoc/options.html for details
 12 | 
 13 | "设定 gvim 运行在增强模式下,不使用vi的键盘模式
 14 | set nocompatible
 15 | "设置支持多语言,解决乱码
 16 | set encoding=utf-8
 17 | set fileencodings=utf-8,gbk,default,latin1
 18 | "设置字体，配色方案
 19 | if has("gui_running")
 20 | set guifont=Courier\ New\ 14
 21 | " on windows,use "set guifont=Courier:14 "
 22 | "设置配色方案
 23 | " colorscheme oceandeep
 24 | endif
 25 | 
 26 | "基本编辑器设置
 27 | set number          "显示行号
 28 | set expandtab       "编辑时将所有 Tab 替换为空格
 29 | set shiftwidth=2    "自动缩进的时候，缩进尺寸为2个空格
 30 | set tabstop=2       "设置 softtabstop 为 2. 输入 tab 后就跳了2格
 31 | "对于不同类型的文件，进行自定义设置
 32 | au FileType html,python,vim,javascript,css setl shiftwidth=2
 33 | au FileType html,python,vim,javascript,css setl tabstop=2
 34 | au FileType java,php setl shiftwidth=4
 35 | au FileType java,php setl tabstop=4
 36 | 
 37 | set textwidth=80    "设置每行的最大字符数，超过的话，将换行
 38 | set hlsearch        "搜索时高亮显示 
 39 | set incsearch       "输入搜索内容时就显示搜索结果
 40 | set fileformat=unix "文本格式
 41 | set nobackup        "覆盖文件时不备份
 42 | 
 43 | set ruler           "打开状态栏标尺
 44 | set laststatus=2    "显示状态栏 (默认值为 1, 无法显示状态栏)
 45 | set cmdheight=1     "设定命令行的行数为 1
 46 | 
 47 | set showtabline=2   "显示tab标签
 48 | set tabline+=%f     "tab标签
 49 | " Enable Code Folding
 50 | set foldenable
 51 | set foldmethod=syntax
 52 | set mouse=a         "任何情况都可以使用鼠标）
 53 | 
 54 | "去掉错误声音
 55 | set vb t_vb=
 56 | "工作目录随文件变
 57 | autocmd BufEnter * cd %:p:h
 58 | "设置状态栏
 59 | set statusline=%F%m%r,%Y,%{&fileformat}\ \ \ ASCII=\%b,HEX=\%B\ \ \ %l,%c%V\
 60 | %p%%\ \ \ [\ %L\ lines\ in\ all\ ]
 61 | "不显示工具条
 62 | set guioptions-=T
 63 | set backspace=indent,eol,start "不设定的话在插入状态无法用退格键和 Delete
 64 | filetype on        "设置文件类型的检测
 65 | filetype plugin on "为特定的文件类型允许插件文件的载入
 66 | 
 67 | "按住ctrl键，移动方向键时，以峰驼的方式
 68 | nnoremap <silent><C-Left>  :<C-u>cal
 69 | search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%^','bW')<CR>
 70 | nnoremap <silent><C-Right> :<C-u>cal
 71 | search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%$','W')<CR>
 72 | inoremap <silent><C-Left>  <C-o>:cal
 73 | search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%^','bW')<CR>
 74 | inoremap <silent><C-Right> <C-o>:cal
 75 | search('\<\<Bar>\U\@<=\u\<Bar>\u\ze\%(\U\&\>\@!\)\<Bar>\%$','W')<CR> 
 76 | 
 77 | "php语法检查
 78 | setlocal makeprg=\/usr/bin/php\ -l\ -n\ -d\ html_errors=off\ %
 79 | setlocal errorformat=%m\ in\ %f\ on\ line\ %l
 80 | "autocmd BufWritePost *.php,*.phps :make
 81 | map :w:noh:make
 82 | 
 83 | "Disable phpsyntax based indenting for .php files
 84 | au BufRead,BufNewFile *.php             set indentexpr= | set smartindent
 85 | au BufRead,BufNewFile *.phps            set filetype=php
 86 | 
 87 | 5 插件配置
 88 | 
 89 | 1)集成NERDTree实现目录导航
 90 | wget https://github.com/scrooloose/nerdtree/tarball/master
 91 | tar zxvf scrooloose-nerdtree-4.1.0-35-g1cd5048.tar.gz
 92 | cp doc/NERD_tree.txt /usr/share/vim/vimfiles/doc/
 93 | cp plugin/NERD_tree.vim /usr/share/vim/vimfiles/plugin/
 94 | cp -fr nerdtree_plugin/ /usr/share/vim/vimfiles/
 95 | 最后在 .vimrc 添加如下内容：
 96 | 
 97 | "NERDTree
 98 | map <F10> :NERDTreeToggle<CR>
 99 | let NERDTreeIgnore=['\.svn$','\.bak$']
100 | 
101 | 通过F10即可调出目录导航,通过键盘ctrl+w+w可以在导航和编辑中的文件之前切换焦点。“u”可到上一级目录，回车则展开文件夹
102 | 
103 | 2)集成task list url：http://www.vim.org/scripts/script.php?script_id=2607
104 | cp tasklist.vim /usr/share/vim/vimfiles/plugin/
105 | 通过":TaskList"可以列出代码中的TODO和FIXME列表，将鼠标移动到相应的项目上时，会关闭列表窗口，并跳转到代码指定的位置
106 | 
107 | 3)集成tag list url：http://www.vim.org/scripts/script.php?script_id=273
108 | taglist 可以列出已打开文件中定义的类、函数、常量，甚至变量。
109 | cp plugin/taglist.vim /usr/share/vim/vimfiles/plugin/
110 | cp doc/taglist.txt /usr/share/vim/vimfiles/doc/
111 | 最后在 .vimrc 添加如下内容：
112 | 
113 | "taglist
114 | set tags=tags;/
115 | let Tlist_Ctags_Cmd="/usr/bin/ctags"
116 | map <F3> :TlistToggle<CR>
117 | let Tlist_Auto_Highlight_Tag = 1
118 | let Tlist_Auto_Open = 0
119 | let Tlist_Auto_Update = 1
120 | let Tlist_Close_On_Select = 0
121 | let Tlist_Compact_Format = 0
122 | let Tlist_Display_Prototype = 0
123 | let Tlist_Display_Tag_Scope = 1
124 | let Tlist_Enable_Fold_Column = 0
125 | let Tlist_Exit_OnlyWindow = 0
126 | let Tlist_File_Fold_Auto_Close = 0
127 | let Tlist_GainFocus_On_ToggleOpen = 1
128 | let Tlist_Hightlight_Tag_On_BufEnter = 1
129 | let Tlist_Inc_Winwidth = 0
130 | let Tlist_Max_Submenu_Items = 1
131 | let Tlist_Max_Tag_Length = 30
132 | let Tlist_Process_File_Always = 0
133 | let Tlist_Show_Menu = 0
134 | let Tlist_Show_One_File = 0
135 | let Tlist_Sort_Type = "order"
136 | let Tlist_Use_Horiz_Window = 0
137 | let Tlist_Use_Right_Window = 0
138 | let Tlist_WinWidth = 40
139 | let tlist_php_settings = 'php;c:class;i:interfaces;d:constant;f:function'
140 | 
141 | map <C-\> :tab split<CR>:exec("tag ".expand("<cword>"))<CR>
142 | map <A-]> :vsp <CR>:exec("tag ".expand("<cword>"))<CR>
143 | 
144 | 需要安装ctags，本文采用yum安装，如需编译安装，请参见其他资料。
145 | 通过ctags -R生成tags后，可以使用如下快捷键：
146 | ctrl+] - 跳转到定义处
147 | ctrl+t - 从定义处跳转回来
148 | ctrl+w ctrl+] - 水平分割窗口，并在上部打开定义所在文件，跳转到定义处
149 | ctrl+\ - 打开新标签页。并跳转到定义处
150 | alt+] - 垂直分割窗口，并在右部打开定义所在文件，跳转到定义处
151 | 
152 | ctrl+鼠标左键 - 跳转到定义处
153 | ctrl+鼠标右键 - 从定义处跳转回来
154 | 
155 | 4)集成php-doc url http://www.vim.org/scripts/script.php?script_id=1355
156 | cp php-doc.vim /usr/share/vim/vimfiles/plugin/
157 | 
158 | 最后在 .vimrc 添加如下内容：
159 | "在通常模式（n）和插入模式（i），按ctrl+p插入注释
160 | inoremap <buffer> <C-P> ^[:call PhpDocSingle()<CR>i
161 | nnoremap <buffer> <C-P> :call PhpDocSingle()<CR>
162 | "选择多行，在可视模式（v）下，对选中的多行插入注释
163 | vnoremap <buffer> <C-P> :call PhpDocRange()<CR>
164 | 
165 | 5)集成PHPM url http://eide.org/2009/01/02/phpm/
166 | cp -fr phpm /usr/share/vim/vimfiles
167 | 最后在 .vimrc 添加如下内容：
168 | 
169 | " Map <CTRL>-H to search phpm for the function name currently under the cursor
170 | (insert mode only)
171 | inoremap <buffer> <C-H> <ESC>:!/usr/share/vim/vimfiles/phpm/phpm
172 | <C-R>=expand("<cword>")<CR><CR>
173 | 在插入模式下，按ctrl+h，即可调出光标在函数的说明，参数，返回值
174 | 
175 | 6)集成funclist，实现自动完成 url
176 | http://svn.php.net/viewvc/phpdoc/doc-base/trunk/funclist.txt
177 | cp funclist.txt /usr/share/vim/vimfiles
178 | 最后在 .vimrc 添加如下内容：
179 | 
180 | setlocal dictionary-=/usr/share/vim/vimfiles/funclist.txt
181 | dictionary+=/usr/share/vim/vimfiles/funclist.txt
182 | " Use the dictionary completion
183 | setlocal complete-=k complete+=k
184 | 
185 | func! InsertTabWrapper()
186 |     let col = col('.') - 1
187 |     if !col || getline('.')[col - 1] !~ '\k'
188 |         return "\<tab>"
189 |     else
190 |         return "\<c-p>"
191 |     endif
192 | endfunction
193 | 
194 | " Remap the tab key to select action with InsertTabWrapper
195 | inoremap <buffer> <tab> <c-r>=InsertTabWrapper()<cr>
196 | 在插入模式下，按tab，即可调出函数列表
197 | 
198 | 7)在任意模式下，按";"在行尾输入添加";"，如果没有";"的话
199 | noremap <buffer> ; :s/\([^;]\)$/\1;/<cr>
200 | 
201 | 8)配置 PhpAlign,手动格式代码的对齐
202 | 在 .vimrc 添加如下内容：
203 | 
204 | " Map <CTRL>-a to alignment function
205 | vnoremap <buffer> <C-a> :call PhpAlign()<CR>
206 | 
207 | func! PhpAlign() range
208 |     let l:paste = &g:paste
209 |     let &g:paste = 0
210 | 
211 |     let l:line        = a:firstline
212 |     let l:endline     = a:lastline
213 |     let l:maxlength = 0
214 |     while l:line <= l:endline
215 |                 " Skip comment lines
216 |                 if getline (l:line) =~ '^\s*\/\/.*$'
217 |                         let l:line = l:line + 1
218 |                         continue
219 |                 endif
220 |                 " \{-\} matches ungreed *
221 |         let l:index = substitute (getline (l:line),
222 | '^\s*\(.\{-\}\)\s*\S\{0,1}=\S\{0,1\}\s.*$', '\1', "")
223 |         let l:indexlength = strlen (l:index)
224 |         let l:maxlength = l:indexlength > l:maxlength ? l:indexlength :
225 | l:maxlength
226 |         let l:line = l:line + 1
227 |     endwhile
228 | 
229 |         let l:line = a:firstline
230 |         let l:format = "%s%-" . l:maxlength . "s %s %s"
231 | 
232 |         while l:line <= l:endline
233 |                 if getline (l:line) =~ '^\s*\/\/.*$'
234 |                         let l:line = l:line + 1
235 |                         continue
236 |                 endif
237 |         let l:linestart = substitute (getline (l:line), '^\(\s*\).*', '\1', "")
238 |         let l:linekey   = substitute (getline (l:line),
239 | '^\s*\(.\{-\}\)\s*\(\S\{0,1}=\S\{0,1\}\)\s\(.*\)$', '\1', "")
240 |         let l:linesep   = substitute (getline (l:line),
241 | '^\s*\(.\{-\}\)\s*\(\S\{0,1}=\S\{0,1\}\)\s\(.*\)$', '\2', "")
242 |         let l:linevalue = substitute (getline (l:line),
243 | '^\s*\(.\{-\}\)\s*\(\S\{0,1}=\S\{0,1\}\)\s\(.*\)$', '\3', "")
244 | 
245 |         let l:newline = printf (l:format, l:linestart, l:linekey, l:linesep,
246 | l:linevalue)
247 |         call setline (l:line, l:newline)
248 |         let l:line = l:line + 1
249 |     endwhile
250 |     let &g:paste = l:paste
251 | endfunc
252 | 在可视模式下，选中代码，按ctrl+a，即可格式代码的对齐
253 | 
254 | 9)配置 PhpUnComment,批量注释代码
255 | 在 .vimrc 添加如下内容：
256 | 
257 | vnoremap <buffer> <C-c> :call PhpUnComment()<CR>
258 | 
259 | func! PhpUnComment() range
260 |     let l:paste = &g:paste
261 |     let &g:paste = 0
262 | 
263 |     let l:line        = a:firstline
264 |     let l:endline     = a:lastline
265 | 
266 |         while l:line <= l:endline
267 |                 if getline (l:line) =~ '^\s*\/\/.*$'
268 |                         let l:newline = substitute (getline (l:line),
269 | '^\(\s*\)\/\/ \(.*\).*$', '\1\2', '')
270 |                 else
271 |                         let l:newline = substitute (getline (l:line),
272 | '^\(\s*\)\(.*\)$', '\1// \2', '')
273 |                 endif
274 |                 call setline (l:line, l:newline)
275 |                 let l:line = l:line + 1
276 |         endwhile
277 | 
278 |     let &g:paste = l:paste
279 | endfunc
280 | 在可视模式下，选中代码，按ctrl+c，即批量注释代码，再按就取消注释
281 | 
282 | 10)设置自动补齐
283 | 在 .vimrc 添加如下内容：
284 | 
285 | inoremap <buffer>  { {<CR>}<C-O>O
286 | 
287 | inoremap <buffer> [ []<LEFT>
288 | 
289 | " Standard mapping after PEAR coding standard
290 | inoremap <buffer> ( ()<LEFT><LEFT>
291 | " inoremap <buffer> ( ()<LEFT>
292 | 
293 | " Maybe this way in other coding standards
294 | " inoremap ( ( )<LEFT><LEFT> 
295 | 
296 | inoremap <buffer> " ""<LEFT>
297 | inoremap <buffer> ' ''<LEFT>
298 | 11)在文件夹中查找
299 | :vimgrep /pattern/gj ./**/*.php
300 | 这哥命令告诉vim，在当前目前下的所有.php文件中全局查找符合pattern的结果。
301 | 运行
302 | :cw
303 | 会列出查找结果。
304 | 
305 | 11）转换大小写
306 | ～ 转换当前光标所在字符的大小写
307 | u  将选中的字符全转成小写
308 | U  将选中的字符全转成大写
309 | UV 将当前行转成大写
310 | guw 将当前的单词转成小写
311 | 
312 | 12）排序
313 | vim在linux上，可以通过在命令模式下输入相关命令，进行文本的排序
314 | %!sort -u 排序时，删除重复的行
315 | %!sort -f 排序时，忽略大小写
316 | %!sort -r 进行逆向排序
317 | 排序时，都是以行为单位。按照字典顺序，如：a-z, 0-100的顺序进行排序
318 | sort /pattern/ 可以在排序时，过滤掉正则匹配到的字符。
319 | sort /^./ 将不是按照第一个字符排序，而是过滤掉第一个字符，从第二个开始。正则表达式/^./匹配开头的第一个字符。
320 | 
321 | 
322 | 参考链接
323 | http://eide.org/category/php/
324 | http://taggedzi.com/articles/display/vim-for-php-developers-part-3
325 | http://www.foolbirds.com/c/vi
326 | https://github.com/tobyS/vip
327 | http://lostechies.com/derickbailey/2010/05/11/vim-grep-find-all-occurrences-of-text-in-your-project/
328 | 


--------------------------------------------------------------------------------
/vimfiles/autoload/tabular.vim:
--------------------------------------------------------------------------------
  1 | " Tabular:     Align columnar data using regex-designated column boundaries
  2 | " Maintainer:  Matthew Wozniski (mjw@drexel.edu)
  3 | " Date:        Thu, 11 Oct 2007 00:35:34 -0400
  4 | " Version:     0.1
  5 | 
  6 | " Stupid vimscript crap                                                   {{{1
  7 | let s:savecpo = &cpo
  8 | set cpo&vim
  9 | 
 10 | " Private Functions                                                       {{{1
 11 | 
 12 | " Return the number of bytes in a string after expanding tabs to spaces.  {{{2
 13 | " This expansion is done based on the current value of 'tabstop'
 14 | function! s:Strlen(string)
 15 |   let rv = 0
 16 |   let i = 0
 17 | 
 18 |   for char in split(a:string, '\zs')
 19 |     if char == "\t"
 20 |       let rv += &ts - i
 21 |       let i = 0
 22 |     else
 23 |       let rv += 1
 24 |       let i = (i + 1) % &ts
 25 |     endif
 26 |   endfor
 27 | 
 28 |   return rv
 29 | endfunction
 30 | 
 31 | " Align a string within a field                                           {{{2
 32 | " These functions do not trim leading and trailing spaces.
 33 | 
 34 | " Right align 'string' in a field of size 'fieldwidth'
 35 | function! s:Right(string, fieldwidth)
 36 |   let spaces = a:fieldwidth - s:Strlen(a:string)
 37 |   return matchstr(a:string, '^\s*') . repeat(" ", spaces) . substitute(a:string, '^\s*', '', '')
 38 | endfunction
 39 | 
 40 | " Left align 'string' in a field of size 'fieldwidth'
 41 | function! s:Left(string, fieldwidth)
 42 |   let spaces = a:fieldwidth - s:Strlen(a:string)
 43 |   return a:string . repeat(" ", spaces)
 44 | endfunction
 45 | 
 46 | " Center align 'string' in a field of size 'fieldwidth'
 47 | function! s:Center(string, fieldwidth)
 48 |   let spaces = a:fieldwidth - s:Strlen(a:string)
 49 |   let right = spaces / 2
 50 |   let left = right + (right * 2 != spaces)
 51 |   return repeat(" ", left) . a:string . repeat(" ", right)
 52 | endfunction
 53 | 
 54 | " Remove spaces around a string                                           {{{2
 55 | 
 56 | " Remove all trailing spaces from a string.
 57 | function! s:StripTrailingSpaces(string)
 58 |   return matchstr(a:string, '^.\{-}\ze\s*$')
 59 | endfunction
 60 | 
 61 | " Remove all leading spaces from a string.
 62 | function! s:StripLeadingSpaces(string)
 63 |   return matchstr(a:string, '^\s*\zs.*$')
 64 | endfunction
 65 | 
 66 | " Split a string into fields and delimiters                               {{{2
 67 | " Like split(), but include the delimiters as elements
 68 | " All odd numbered elements are delimiters
 69 | " All even numbered elements are non-delimiters (including zero)
 70 | function! s:SplitDelim(string, delim)
 71 |   let rv = []
 72 |   let beg = 0
 73 | 
 74 |   let len = len(a:string)
 75 |   let searchoff = 0
 76 | 
 77 |   while 1
 78 |     let mid = match(a:string, a:delim, beg + searchoff, 1)
 79 |     if mid == -1 || mid == len
 80 |       break
 81 |     endif
 82 | 
 83 |     let matchstr = matchstr(a:string, a:delim, beg + searchoff, 1)
 84 |     let length = strlen(matchstr)
 85 | 
 86 |     if length == 0 && beg == mid
 87 |       " Zero-length match for a zero-length delimiter - advance past it
 88 |       let searchoff += 1
 89 |       continue
 90 |     endif
 91 | 
 92 |     if beg == mid
 93 |       let rv += [ "" ]
 94 |     else
 95 |       let rv += [ a:string[beg : mid-1] ]
 96 |     endif
 97 | 
 98 |     let rv += [ matchstr ]
 99 | 
100 |     let beg = mid + length
101 |     let searchoff = 0
102 |   endwhile
103 | 
104 |   let rv += [ strpart(a:string, beg) ]
105 | 
106 |   return rv
107 | endfunction
108 | 
109 | " Replace lines from `start' to `start + len - 1' with the given strings. {{{2
110 | " If more lines are needed to show all strings, they will be added.
111 | " If there are too few strings to fill all lines, lines will be removed.
112 | function! s:SetLines(start, len, strings)
113 |   if a:start > line('$') + 1 || a:start < 1
114 |     throw "Invalid start line!"
115 |   endif
116 | 
117 |   if len(a:strings) > a:len
118 |     let fensave = &fen
119 |     let view = winsaveview()
120 |     call append(a:start + a:len - 1, repeat([''], len(a:strings) - a:len))
121 |     call winrestview(view)
122 |     let &fen = fensave
123 |   elseif len(a:strings) < a:len
124 |     let fensave = &fen
125 |     let view = winsaveview()
126 |     sil exe (a:start + len(a:strings)) . ',' .  (a:start + a:len - 1) . 'd_'
127 |     call winrestview(view)
128 |     let &fen = fensave
129 |   endif
130 | 
131 |   call setline(a:start, a:strings)
132 | endfunction
133 | 
134 | " Runs the given commandstring argument as an expression.                 {{{2
135 | " The commandstring expression is expected to reference the a:lines argument.
136 | " If the commandstring expression returns a list the items of that list will
137 | " replace the items in a:lines, otherwise the expression is assumed to have
138 | " modified a:lines itself.
139 | function! s:FilterString(lines, commandstring)
140 |   exe 'let rv = ' . a:commandstring
141 | 
142 |   if type(rv) == type(a:lines) && rv isnot a:lines
143 |     call filter(a:lines, 0)
144 |     call extend(a:lines, rv)
145 |   endif
146 | endfunction
147 | 
148 | " Public API                                                              {{{1
149 | 
150 | if !exists("g:tabular_default_format")
151 |   let g:tabular_default_format = "l1"
152 | endif
153 | 
154 | let s:formatelempat = '\%([lrc]\d\+\)'
155 | 
156 | function! tabular#ElementFormatPattern()
157 |   return s:formatelempat
158 | endfunction
159 | 
160 | " Given a list of strings and a delimiter, split each string on every
161 | " occurrence of the delimiter pattern, format each element according to either
162 | " the provided format (optional) or the default format, and join them back
163 | " together with enough space padding to guarantee that the nth delimiter of
164 | " each string is aligned.
165 | function! tabular#TabularizeStrings(strings, delim, ...)
166 |   if a:0 > 1
167 |     echoerr "TabularizeStrings accepts only 2 or 3 arguments (got ".(a:0+2).")"
168 |     return 1
169 |   endif
170 | 
171 |   let formatstr = (a:0 ? a:1 : g:tabular_default_format)
172 | 
173 |   if formatstr !~? s:formatelempat . '\+'
174 |     echoerr "Tabular: Invalid format \"" . formatstr . "\" specified!"
175 |     return 1
176 |   endif
177 | 
178 |   let format = split(formatstr, s:formatelempat . '\zs')
179 | 
180 |   let lines = map(a:strings, 's:SplitDelim(v:val, a:delim)')
181 | 
182 |   " Strip spaces
183 |   "   - Only from non-delimiters; spaces in delimiters must have been matched
184 |   "     intentionally
185 |   "   - Don't strip leading spaces from the first element; we like indenting.
186 |   for line in lines
187 |     if line[0] !~ '^\s*$'
188 |       let line[0] = s:StripTrailingSpaces(line[0])
189 |     endif
190 |     if len(line) >= 3
191 |       for i in range(2, len(line)-1, 2)
192 |         let line[i] = s:StripLeadingSpaces(s:StripTrailingSpaces(line[i]))
193 |       endfor
194 |     endif
195 |   endfor
196 | 
197 |   " Find the max length of each field
198 |   let maxes = []
199 |   for line in lines
200 |     for i in range(len(line))
201 |       if i == len(maxes)
202 |         let maxes += [ s:Strlen(line[i]) ]
203 |       else
204 |         let maxes[i] = max( [ maxes[i], s:Strlen(line[i]) ] )
205 |       endif
206 |     endfor
207 |   endfor
208 | 
209 |   let lead_blank = empty(filter(copy(lines), 'v:val[0] =~ "\\S"'))
210 | 
211 |   " Concatenate the fields, according to the format pattern.
212 |   for idx in range(len(lines))
213 |     let line = lines[idx]
214 |     for i in range(len(line))
215 |       let how = format[i % len(format)][0]
216 |       let pad = format[i % len(format)][1:-1]
217 | 
218 |       if how =~? 'l'
219 |         let field = s:Left(line[i], maxes[i])
220 |       elseif how =~? 'r'
221 |         let field = s:Right(line[i], maxes[i])
222 |       elseif how =~? 'c'
223 |         let field = s:Center(line[i], maxes[i])
224 |       endif
225 | 
226 |       let line[i] = field . (lead_blank && i == 0 ? '' : repeat(" ", pad))
227 |     endfor
228 | 
229 |     let lines[idx] = s:StripTrailingSpaces(join(line, ''))
230 |   endfor
231 | endfunction
232 | 
233 | " Apply 0 or more filters, in sequence, to selected text in the buffer    {{{2
234 | " The lines to be filtered are determined as follows:
235 | "   If the function is called with a range containing multiple lines, then
236 | "     those lines will be used as the range.
237 | "   If the function is called with no range or with a range of 1 line, then
238 | "     if "includepat" is not specified,
239 | "       that 1 line will be filtered,
240 | "     if "includepat" is specified and that line does not match it,
241 | "       no lines will be filtered
242 | "     if "includepat" is specified and that line does match it,
243 | "       all contiguous lines above and below the specified line matching the
244 | "       pattern will be filtered.
245 | "
246 | " The remaining arguments must each be a filter to apply to the text.
247 | " Each filter must either be a String evaluating to a function to be called.
248 | function! tabular#PipeRange(includepat, ...) range
249 |   let top = a:firstline
250 |   let bot = a:lastline
251 | 
252 |   if a:includepat != '' && top == bot
253 |     if top < 0 || top > line('$') || getline(top) !~ a:includepat
254 |       return
255 |     endif
256 |     while top > 1 && getline(top-1) =~ a:includepat
257 |       let top -= 1
258 |     endwhile
259 |     while bot < line('$') && getline(bot+1) =~ a:includepat
260 |       let bot += 1
261 |     endwhile
262 |   endif
263 | 
264 |   let lines = map(range(top, bot), 'getline(v:val)')
265 | 
266 |   for filter in a:000
267 |     if type(filter) != type("")
268 |       echoerr "PipeRange: Bad filter: " . string(filter)
269 |     endif
270 | 
271 |     call s:FilterString(lines, filter)
272 | 
273 |     unlet filter
274 |   endfor
275 | 
276 |   call s:SetLines(top, bot - top + 1, lines)
277 | endfunction
278 | 
279 | function! s:SplitDelimTest(string, delim, expected)
280 |   let result = s:SplitDelim(a:string, a:delim)
281 | 
282 |   if result !=# a:expected
283 |     echomsg 'Test failed!'
284 |     echomsg '  string=' . string(a:string) . '  delim=' . string(a:delim)
285 |     echomsg '  Returned=' . string(result)
286 |     echomsg '  Expected=' . string(a:expected)
287 |   endif
288 | endfunction
289 | 
290 | function! tabular#SplitDelimUnitTest()
291 |   let assignment = '[|&+*/%<>=!~-]\@<!\([<>!=]=\|=\~\)\@![|&+*/%<>=!~-]*='
292 |   let two_spaces = '  '
293 |   let ternary_operator = '^.\{-}\zs?\|:'
294 |   let cpp_io = '<<\|>>'
295 |   let pascal_assign = ':='
296 |   let trailing_c_comments = '\/\*\|\*\/\|\/\/'
297 | 
298 |   call s:SplitDelimTest('a+=b',    assignment, ['a', '+=', 'b'])
299 |   call s:SplitDelimTest('a-=b',    assignment, ['a', '-=', 'b'])
300 |   call s:SplitDelimTest('a!=b',    assignment, ['a!=b'])
301 |   call s:SplitDelimTest('a==b',    assignment, ['a==b'])
302 |   call s:SplitDelimTest('a&=b',    assignment, ['a', '&=', 'b'])
303 |   call s:SplitDelimTest('a|=b',    assignment, ['a', '|=', 'b'])
304 |   call s:SplitDelimTest('a=b=c',   assignment, ['a', '=', 'b', '=', 'c'])
305 | 
306 |   call s:SplitDelimTest('a  b  c', two_spaces, ['a', '  ', 'b', '  ', 'c'])
307 |   call s:SplitDelimTest('a b   c', two_spaces, ['a b', '  ', ' c'])
308 |   call s:SplitDelimTest('ab    c', two_spaces, ['ab', '  ', '', '  ', 'c'])
309 | 
310 |   call s:SplitDelimTest('a?b:c',   ternary_operator, ['a', '?', 'b', ':', 'c'])
311 | 
312 |   call s:SplitDelimTest('a<<b<<c', cpp_io, ['a', '<<', 'b', '<<', 'c'])
313 | 
314 |   call s:SplitDelimTest('a:=b=c',  pascal_assign, ['a', ':=', 'b=c'])
315 | 
316 |   call s:SplitDelimTest('x//foo',  trailing_c_comments, ['x', '//', 'foo'])
317 |   call s:SplitDelimTest('x/*foo*/',trailing_c_comments, ['x', '/*', 'foo', '*/', ''])
318 | 
319 |   call s:SplitDelimTest('#ab#cd#ef', '[^#]*', ['#', 'ab', '#', 'cd', '#', 'ef', ''])
320 |   call s:SplitDelimTest('#ab#cd#ef', '#\zs',  ['#', '', 'ab#', '', 'cd#', '', 'ef'])
321 | endfunction
322 | 
323 | " Stupid vimscript crap, part 2                                           {{{1
324 | let &cpo = s:savecpo
325 | unlet s:savecpo
326 | 
327 | " vim:set sw=2 sts=2 fdm=marker:
328 | 


--------------------------------------------------------------------------------
/vimfiles/plugin/tasklist.vim:
--------------------------------------------------------------------------------
  1 | "------------------------------------------------------------------------------
  2 | "   Name Of File: tasklist.vim
  3 | "
  4 | "    Description: Vim plugin to search for a list of tokens and display a
  5 | "                 window with matches.
  6 | "
  7 | "         Author: Juan Frias (juandfrias at gmail.com)
  8 | "
  9 | "    Last Change: 2009 Apr 11
 10 | "        Version: 1.0.1
 11 | "
 12 | "      Copyright: Permission is hereby granted to use and distribute this code,
 13 | "                 with or without modifications, provided that this header
 14 | "                 is included with it.
 15 | "
 16 | "                 This script is to be distributed freely in the hope that it
 17 | "                 will be useful, but is provided 'as is' and without warranties
 18 | "                 as to performance of merchantability or any other warranties
 19 | "                 whether expressed or implied. Because of the various hardware
 20 | "                 and software environments into which this script may be put,
 21 | "                 no warranty of fitness for a particular purpose is offered.
 22 | "
 23 | "                 GOOD DATA PROCESSING PROCEDURE DICTATES THAT ANY SCRIPT BE
 24 | "                 THOROUGHLY TESTED WITH NON-CRITICAL DATA BEFORE RELYING ON IT.
 25 | "
 26 | "                 THE USER MUST ASSUME THE ENTIRE RISK OF USING THE SCRIPT.
 27 | "
 28 | "                 The author does not retain any liability on any damage caused
 29 | "                 through the use of this script.
 30 | "
 31 | "        Install: 1. Read the section titled 'Options'
 32 | "                 2. Setup any variables need in your vimrc file
 33 | "                 3. Copy 'tasklist.vim' to your plugin directory.
 34 | "
 35 | "    Mapped Keys: <Leader>t   Display list.
 36 | "
 37 | "          Usage: Start the script with the mapped key, a new window appears
 38 | "                 with the matches found, moving around the window will also
 39 | "                 update the position of the current document.
 40 | "
 41 | "                 The following keys are mapped to the results window:
 42 | "
 43 | "                     q - Quit, and restore original cursor position.
 44 | "
 45 | "                     e - Exit, and keep results window open note that
 46 | "                         movements on the result window will no longer be
 47 | "                         updated.
 48 | "
 49 | "                     <cr> - Quit and place the cursor on the selected line.
 50 | "
 51 | " Aknowledgments: Many thanks to Zhang Shuhan for taking the time to beta
 52 | "                 test and suggest many of the improvements and features
 53 | "                 found in the script.  I don't think I would have
 54 | "                 implemented it wihout his help. Thanks!
 55 | "
 56 | "------------------------------------------------------------------------------
 57 | " Please send me any bugs you find, so I can keep the script up to date.
 58 | "------------------------------------------------------------------------------
 59 | 
 60 | " History: {{{1
 61 | "------------------------------------------------------------------------------
 62 | "
 63 | " 1.00  Initial version.
 64 | "
 65 | " User Options: {{{1
 66 | "------------------------------------------------------------------------------
 67 | "
 68 | " <Leader>t
 69 | "       This is the default key map to view the task list.
 70 | "       to overwrite use something like:
 71 | "           map <leader>v <Plug>TaskList
 72 | "       in your vimrc file
 73 | "
 74 | " g:tlWindowPosition
 75 | "       This is specifies the position of the window to be opened. By
 76 | "       default it will open at on top. To overwrite use:
 77 | "           let g:tlWindowPosition = 1
 78 | "       in your vimrc file, options are as follows:
 79 | "           0 = Open on top
 80 | "           1 = Open on the bottom
 81 | "
 82 | " g:tlTokenList
 83 | "       This is the list of tokens to search for default is
 84 | "       'FIXME TODO XXX'. The results are groupped and displayed in the
 85 | "       order that they appear. to overwrite use:
 86 | "           let g:tlTokenList = ['TOKEN1', 'TOKEN2', 'TOKEN3']
 87 | "       in your vimrc file
 88 | "
 89 | " g:tlRememberPosition
 90 | "       If this is set to 1 then the script will try to get back to the
 91 | "       position where it last was closed. By default it will find the line
 92 | "       closest to the current cursor position.
 93 | "       to overwrite use:
 94 | "           let g:tlRememberPosition = 1
 95 | "       in your vimrc file
 96 | "
 97 | 
 98 | " Global variables: {{{1
 99 | "------------------------------------------------------------------------------
100 | 
101 | " Load script once
102 | "------------------------------------------------------------------------------
103 | if exists("g:loaded_tasklist") || &cp
104 |     finish
105 | endif
106 | let g:loaded_tasklist = 1
107 | 
108 | " Set where the window opens
109 | "------------------------------------------------------------------------------
110 | if !exists('g:tlWindowPosition')
111 | "   0 = Open at top
112 |     let g:tlWindowPosition = 0
113 | endif
114 | 
115 | " Set the token list
116 | "------------------------------------------------------------------------------
117 | if !exists('g:tlTokenList')
118 | "   default list of tokens
119 |     let g:tlTokenList = ["FIXME", "TODO", "XXX"]
120 | endif
121 | 
122 | " Remember position
123 | "------------------------------------------------------------------------------
124 | if !exists('g:tlRememberPosition')
125 | "   0 = Donot remember, find closest match
126 |     let g:tlRememberPosition = 0
127 | endif
128 | 
129 | " Script variables: {{{1
130 | "------------------------------------------------------------------------------
131 | 
132 | " Function: Open Window {{{1
133 | "--------------------------------------------------------------------------
134 | function! s:OpenWindow(buffnr, lineno)
135 |     " Open results window and place items there.
136 |     if g:tlWindowPosition == 0
137 |       execute 'sp -TaskList_'.a:buffnr.'-'
138 |     else
139 |       execute 'botright sp -TaskList_'.a:buffnr.'-'
140 |     endif
141 | 
142 |     let b:original_buffnr = a:buffnr
143 |     let b:original_line = a:lineno
144 | 
145 |     set noswapfile
146 |     set modifiable
147 |     normal! "zPGddgg
148 |     set fde=getline(v:lnum)[0]=='L'
149 |     set foldmethod=expr
150 |     set foldlevel=0
151 |     normal! zR
152 | 
153 |     " Resize line if too big.
154 |     let l:hits = line("$")
155 |     if l:hits < winheight(0)
156 |         sil! exe "resize ".l:hits
157 |     endif
158 | 
159 |     " Clean up.
160 |     let @z = ""
161 |     set nomodified
162 | endfunction
163 | 
164 | " Function: Search file {{{1
165 | "--------------------------------------------------------------------------
166 | function! s:SearchFile(hits, word)
167 |     " Search at the beginning and keep adding them to the register
168 |     let l:match_count = 0
169 |     normal! gg0
170 |     let l:max = strlen(line('$'))
171 |     let l:last_match = -1
172 |     let l:div = 0
173 |     while search(a:word, "Wc") > 0
174 |         let l:curr_line = line('.')
175 |         if l:last_match == l:curr_line
176 |             if l:curr_line == line('$')
177 |                 break
178 |             endif
179 |             normal! j0
180 |             continue
181 |         endif
182 |         let l:last_match = l:curr_line
183 |         if foldlevel(l:curr_line) != 0
184 |             normal! 99zo
185 |         endif
186 |         if l:div == 0 
187 |             if a:hits != 0
188 |                 let @z = @z."\n"
189 |             endif
190 |             let l:div = 1
191 |         endif
192 |         normal! 0
193 |         let l:lineno = '     '.l:curr_line
194 |         let @z = @z.'Ln '.strpart(l:lineno, strlen(l:lineno) - l:max).': '
195 |         let l:text = getline(".")
196 |         let @z = @z.strpart(l:text, stridx(l:text, a:word))
197 |         let @z = @z."\n"
198 |         normal! $
199 |         let l:match_count = l:match_count + 1
200 |     endwhile
201 |     return l:match_count
202 | endfunction
203 | 
204 | " Function: Get line number {{{1
205 | "--------------------------------------------------------------------------
206 | function! s:LineNumber()
207 |     let l:text = getline(".")
208 |     if strpart(l:text, 0, 5) == "File:"
209 |         return 0
210 |     endif
211 |     if strlen(l:text) == 0
212 |         return -1
213 |     endif
214 |     let l:num = matchstr(l:text, '[0-9]\+')
215 |     if l:num == ''
216 |         return -1
217 |     endif
218 |     return l:num
219 | endfunction
220 | 
221 | " Function: Update document position {{{1
222 | "--------------------------------------------------------------------------
223 | function! s:UpdateDoc()
224 |     let l:line_hit = <sid>LineNumber()
225 | 
226 |     match none
227 |     if l:line_hit == -1
228 |         redraw
229 |         return
230 |     endif
231 | 
232 |     let l:buffnr = b:original_buffnr
233 |     exe 'match Search /\%'.line(".").'l.*/'
234 |     if line(".") < (line("$") - (winheight(0) / 2)) + 1
235 |         normal! zz
236 |     endif
237 |     execute bufwinnr(l:buffnr)." wincmd w"
238 |     match none
239 |     if l:line_hit == 0
240 |         normal! 1G
241 |     else
242 |         exe "normal! ".l:line_hit."Gzz"
243 |         exe 'match Search /\%'.line(".").'l.*/'
244 |     endif
245 |     execute bufwinnr('-TaskList_'.l:buffnr.'-')." wincmd w"
246 |     redraw
247 | endfunction
248 | 
249 | " Function: Clean up on exit {{{1
250 | "--------------------------------------------------------------------------
251 | function! s:Exit(key)
252 | 
253 |     call <sid>UpdateDoc()
254 |     match none
255 | 
256 |     let l:original_line = b:original_line
257 |     let l:last_position = line('.')
258 | 
259 |     if a:key == -1
260 |         nunmap <buffer> e
261 |         nunmap <buffer> q
262 |         nunmap <buffer> <cr>
263 |         execute bufwinnr(b:original_buffnr)." wincmd w"
264 |     else
265 |         bd!
266 |     endif
267 | 
268 |     let b:last_position = l:last_position
269 | 
270 |     if a:key == 0
271 |         exe "normal! ".l:original_line."G"
272 |     endif
273 | 
274 |     match none
275 |     normal! zz
276 | 
277 |     execute "set updatetime=".s:old_updatetime
278 | endfunction
279 | 
280 | " Function: Check for screen update {{{1
281 | "--------------------------------------------------------------------------
282 | function! s:CheckForUpdate()
283 |     if stridx(expand("%:t"), '-TaskList_') == -1
284 |         return
285 |     endif
286 |     if b:selected_line != line(".")
287 |         call <sid>UpdateDoc()
288 |         let b:selected_line = line(".")
289 |     endif
290 | endfunction
291 | 
292 | " Function: Start the search. {{{1
293 | "--------------------------------------------------------------------------
294 | function! s:TaskList()
295 |     let l:original_buffnr = bufnr('%')
296 |     let l:original_line = line(".")
297 | 
298 |     " last position
299 |     if !exists('b:last_position')
300 |         let b:last_position = 1
301 |     endif
302 |     let l:last_position = b:last_position
303 | 
304 | 
305 |     " get file name
306 |     let @z = "File:".expand("%:p")."\n\n"
307 | 
308 |     " search file
309 |     let l:index = 0
310 |     let l:count = 0
311 |     let l:hits = 0
312 |     while l:index < len(g:tlTokenList)
313 |         let l:search_word = g:tlTokenList[l:index]
314 |         let l:hits = s:SearchFile(l:hits, l:search_word)
315 |         let l:count = l:count + l:hits
316 |         let l:index = l:index + 1
317 |     endwhile
318 | 
319 |     " Make sure we at least have one hit.
320 |     if l:count == 0
321 |         echohl Search
322 |         echo "tasklist.vim: No task information found."
323 |         echohl None
324 |         execute 'normal! '.l:original_line.'G'
325 |         return
326 |     endif
327 | 
328 |     " display window
329 |     call s:OpenWindow(l:original_buffnr, l:original_line)
330 | 
331 |     " restore the cursor position
332 |     if g:tlRememberPosition != 0
333 |         exec 'normal! '.l:last_position.'G'
334 |     else
335 |         normal! gg
336 |     endif
337 | 
338 |     " Map exit keys
339 |     nnoremap <buffer> <silent> q :call <sid>Exit(0)<cr>
340 |     nnoremap <buffer> <silent> <cr> :call <sid>Exit(1)<cr>
341 |     nnoremap <buffer> <silent> e :call <sid>Exit(-1)<cr>
342 | 
343 |     " Setup syntax highlight {{{
344 |     syntax match tasklistFileDivider       /^File:.*$/
345 |     syntax match tasklistLineNumber        /^Ln\s\+\d\+:/
346 | 
347 |     highlight def link tasklistFileDivider  Title
348 |     highlight def link tasklistLineNumber   LineNr
349 |     highlight def link tasklistSearchWord   Search
350 |     " }}}
351 | 
352 |     " Save globals and change updatetime
353 |     let b:selected_line = line(".")
354 |     let s:old_updatetime = &updatetime
355 |     set updatetime=350
356 | 
357 |     " update the doc and hook the CheckForUpdate function.
358 |     call <sid>UpdateDoc()
359 |     au! CursorHold <buffer> nested call <sid>CheckForUpdate()
360 | 
361 | endfunction
362 | "}}}
363 | 
364 | " Command
365 | command! TaskList call s:TaskList()
366 | 
367 | " Default key map
368 | if !hasmapto('<Plug>TaskList')
369 |     map <unique> <Leader>t <Plug>TaskList
370 | endif
371 | 
372 | " Key map to Command
373 | nnoremap <unique> <script> <Plug>TaskList :TaskList<CR>
374 | 
375 | " vim:fdm=marker:tw=75:ff=unix:
376 | 


--------------------------------------------------------------------------------
/vimfiles/autoload/checksyntax.vim:
--------------------------------------------------------------------------------
  1 | " checksyntax.vim
  2 | " @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
  3 | " @Website:     http://www.vim.org/account/profile.php?user_id=4037
  4 | " @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
  5 | " @Created:     2010-01-03.
  6 | " @Last Change: 2011-07-04.
  7 | " @Revision:    283
  8 | 
  9 | 
 10 | if !exists('g:checksyntax#failrx')
 11 |     let g:checksyntax#failrx = '\ *\(\d \f\{-}:\)\?\d\{-}:'
 12 | endif
 13 | 
 14 | if !exists('g:checksyntax#okrx')
 15 |     let g:checksyntax#okrx = ''
 16 | endif
 17 | 
 18 | if !exists('g:checksyntax')
 19 |     " A dictionary {name/filetype => definition} of syntax checkers, where 
 20 |     " definition is a dictionary with the following fields:
 21 |     " 
 22 |     " Mandatory (either one of the following):
 23 |     "   cmd  ... A shell command used as 'makeprg' to check the file.
 24 |     "   exec ... A vim command used to check the file.
 25 |     "   compiler ... A vim compiler that is used to check the file.
 26 |     " 
 27 |     " Optional:
 28 |     "   auto ... Run automatically when saving a file.
 29 |     "   efm  ... An 'errorformat' string.
 30 |     "   okrx ... A |regexp| matching the command output if no error were 
 31 |     "            found.
 32 |     "   failrx ... A |regexp| matching the command output if an error 
 33 |     "            was found.
 34 |     "   alt  ... The name of an alternative syntax checker (see 
 35 |     "            |:CheckSyntax|).
 36 |     "   prepare ... An ex command that is run before doing anything.
 37 |     "   ignore_nr ... A list of error numbers that should be ignored.
 38 |     let g:checksyntax = {}   "{{{2
 39 | endif
 40 | 
 41 | 
 42 | """ Php
 43 | if !exists('g:checksyntax.php')
 44 |     let g:checksyntax['php'] = {
 45 |                 \ 'auto': executable('php') == 1,
 46 |                 \ 'cmd': 'php -l',
 47 |                 \ 'efm': '%*[^:]: %m in %f on line %l',
 48 |                 \ 'okrx': 'No syntax errors detected in ',
 49 |                 \ 'alt': 'phpp'
 50 |                 \ }
 51 | endif
 52 | 
 53 | 
 54 | """""" Parse php
 55 | if !exists('g:checksyntax.phpp')
 56 |     let g:checksyntax['phpp'] = {
 57 |                 \ 'cmd': 'php -f',
 58 |                 \ 'efm': g:checksyntax.php.efm,
 59 |                 \ 'okrx': g:checksyntax.php.okrx
 60 |                 \ }
 61 | endif
 62 | 
 63 | autocmd CheckSyntax BufReadPost *.php if exists(':EclimValidate') && !empty(eclim#project#util#GetCurrentProjectName()) | let g:checksyntax.php.auto = 0 | endif
 64 | 
 65 | 
 66 | """ JavaScript
 67 | if !exists('g:checksyntax.javascript')
 68 |     if exists('g:checksyntax_javascript') ? (g:checksyntax_javascript == 'gjslint') : executable('gjslint')
 69 |         let g:checksyntax['javascript'] = {
 70 |                     \ 'cmd': 'gjslint',
 71 |                     \ 'ignore_nr': [1, 110],
 72 |                     \ 'efm': '%P%*[^F]FILE%*[^:]: %f %*[-],Line %l%\, %t:%n: %m,%Q',
 73 |                     \ }
 74 |     elseif exists('g:checksyntax_javascript') ? (g:checksyntax_javascript == 'jsl') : executable('jsl')
 75 |         let g:checksyntax['javascript'] = {
 76 |                     \ 'cmd': 'jsl -nofilelisting -nocontext -nosummary -nologo -process',
 77 |                     \ 'okrx': '0 error(s), 0 warning(s)',
 78 |                     \ }
 79 |     endif
 80 | endif
 81 | 
 82 | 
 83 | """ Python
 84 | if !exists('g:checksyntax.python')
 85 |     let g:checksyntax['python'] = {
 86 |                 \ 'cmd': 'pyflakes',
 87 |                 \ 'alt': 'pylint'
 88 |                 \ }
 89 | endif
 90 | 
 91 | if !exists('g:checksyntax.pylint')
 92 |     let g:checksyntax['pylint'] = {
 93 |                 \ 'compiler': 'pylint'
 94 |                 \ }
 95 | endif
 96 | 
 97 | 
 98 | """ Ruby
 99 | if !exists('g:checksyntax.ruby')
100 |     let g:checksyntax['ruby'] = {
101 |                 \ 'prepare': 'compiler ruby',
102 |                 \ 'cmd': 'ruby -c',
103 |                 \ 'okrx': 'Syntax OK\|No Errors'
104 |                 \ }
105 | endif
106 | 
107 | 
108 | """ Viki
109 | if !exists('g:checksyntax.viki')
110 |     let g:checksyntax['viki'] = {
111 |                 \ 'cmd': 'deplate -f null',
112 |                 \ }
113 | endif
114 | 
115 | 
116 | """ chktex (LaTeX)
117 | if !exists('g:checksyntax.tex')
118 |     if executable('chktex')
119 |         let g:checksyntax['tex'] = {
120 |                     \ 'cmd': 'chktex -q -v0',
121 |                     \ 'efm': '%f:%l:%m',
122 |                     \ }
123 |     endif
124 | endif
125 | 
126 | 
127 | """ c, cpp
128 | if !exists('g:checksyntax.c')
129 |     if executable('splint')
130 |         let g:checksyntax['c'] = {
131 |                     \ 'compiler': 'splint',
132 |                     \ }
133 |     endif
134 | endif
135 | 
136 | if !exists('g:checksyntax.cpp') && exists('g:checksyntax.c')
137 |     let g:checksyntax['cpp'] = copy(g:checksyntax.c)
138 | endif
139 | 
140 | 
141 | """ java
142 | if !exists('g:checksyntax.java')
143 |     if executable('jlint')
144 |         let g:checksyntax['java'] = {
145 |                     \ 'exec': 'call checksyntax#Jlint()',
146 |                     \ 'alt': 'javaCheckstyle'
147 |                     \ }
148 | 
149 |         " :nodoc:
150 |         function! checksyntax#Jlint() "{{{3
151 |             let filename = expand('%:r') .'.class'
152 |             " TLogVAR filename
153 |             " echom '! jlint -done '. shellescape(filename)
154 |             exec '! jlint -done '. shellescape(filename)
155 |         endf
156 |     endif
157 | endif
158 | 
159 | if !exists('g:checksyntax.javaCheckstyle')
160 |     if executable('checkstyle')
161 |         let g:checksyntax['javaCheckstyle'] = {
162 |                     \ 'compiler': 'checkstyle',
163 |                     \ }
164 |     endif
165 | endif
166 | 
167 | 
168 | """ lua
169 | if !exists('g:checksyntax.lua')
170 |     " efm: File:Line:Column:Warning number:Warning message
171 |     let g:checksyntax['lua'] = {
172 |                 \ 'auto': executable('luac') == 1,
173 |                 \ 'cmd': 'luac -p',
174 |                 \ 'efm': 'luac\:\ %f:%l:\ %m'
175 |                 \ }
176 | endif
177 | 
178 | 
179 | """ tidy (HTML)
180 | if !exists('g:checksyntax.html')
181 |     let g:checksyntax['html'] = {
182 |                 \ 'cmd': 'tidy -eq',
183 |                 \ 'efm': 'line %l column %c - %m'
184 |                 \ }
185 | endif
186 | if !exists('g:checksyntax.xhtml')
187 |     let g:checksyntax['xhtml'] = copy(g:checksyntax.html)
188 | endif
189 | 
190 | 
191 | """ XML
192 | if !exists('g:checksyntax.xml')
193 |     let g:checksyntax['xml'] = {
194 |                 \ 'compiler': 'xmllint'
195 |                 \ }
196 | endif
197 | if !exists('g:checksyntax.docbk')
198 |     let g:checksyntax['docbk'] = copy(g:checksyntax.xml)
199 | endif
200 | 
201 | 
202 | if !exists('*CheckSyntaxSucceed')
203 |     " :nodoc:
204 |     function! CheckSyntaxSucceed(type, manually)
205 |         call s:prototypes[a:type].Close()
206 |         if a:manually
207 |             echo
208 |             echo 'Syntax ok.'
209 |         endif
210 |     endf
211 | endif
212 | 
213 | 
214 | if !exists('*CheckSyntaxFail')
215 |     " :nodoc:
216 |     function! CheckSyntaxFail(type, manually)
217 |         call s:prototypes[a:type].Open()
218 |     endf
219 | endif
220 | 
221 | 
222 | let s:prototypes = {'loc': {}, 'qfl': {}}
223 | 
224 | function! s:prototypes.loc.Close() dict "{{{3
225 |     lclose
226 | endf
227 | 
228 | function! s:prototypes.loc.Open() dict "{{{3
229 |     lopen
230 | endf
231 | 
232 | function! s:prototypes.loc.Make(args) dict "{{{3
233 |     exec 'silent lmake' a:args
234 | endf
235 | 
236 | function! s:prototypes.loc.Get() dict "{{{3
237 |     return copy(getloclist(0))
238 | endf
239 | 
240 | function! s:prototypes.loc.Set(list) dict "{{{3
241 |     call setloclist(0, a:list)
242 | endf
243 | 
244 | 
245 | function! s:prototypes.qfl.Close() dict "{{{3
246 |     cclose
247 | endf
248 | 
249 | function! s:prototypes.qfl.Open() dict "{{{3
250 |     copen
251 | endf
252 | 
253 | function! s:prototypes.qfl.Make(args) dict "{{{3
254 |     exec 'silent make' a:args
255 | endf
256 | 
257 | function! s:prototypes.qfl.Get() dict "{{{3
258 |     return copy(getqflist())
259 | endf
260 | 
261 | function! s:prototypes.qfl.Set(list) dict "{{{3
262 |     call setqflist(a:list)
263 | endf
264 | 
265 | 
266 | function! s:Make(def)
267 |     let bufnr = bufnr('%')
268 |     let pos = getpos('.')
269 |     let type = get(a:def, 'listtype', 'loc')
270 |     try
271 |         if has_key(a:def, 'compiler')
272 | 
273 |             if exists('g:current_compiler')
274 |                 let cc = g:current_compiler
275 |             else
276 |                 let cc = ''
277 |             endif
278 |             try
279 |                 exec 'compiler '. a:def.compiler
280 |                 call s:prototypes[type].Make('')
281 |                 return 1
282 |             finally
283 |                 if cc != ''
284 |                     let g:current_compiler = cc
285 |                     exec 'compiler '. cc
286 |                 endif
287 |             endtry
288 | 
289 |         else
290 | 
291 |             let makeprg = &makeprg
292 |             let shellpipe = &shellpipe
293 |             let errorformat = &errorformat
294 |             if has_key(a:def, 'shellpipe')
295 |                 let &l:shellpipe = get(a:def, 'shellpipe')
296 |             endif
297 |             if has_key(a:def, 'efm')
298 |                 let &l:errorformat = get(a:def, 'efm')
299 |             endif
300 |             try
301 |                 if has_key(a:def, 'cmd')
302 |                     let &l:makeprg = a:def.cmd
303 |                     " TLogVAR &l:makeprg, &l:errorformat
304 |                     call s:prototypes[type].Make('%')
305 |                     return 1
306 |                 elseif has_key(a:def, 'exec')
307 |                     exec a:def.exec
308 |                     return 1
309 |                 endif
310 |             finally
311 |                 if &l:makeprg != makeprg
312 |                     let &l:makeprg = makeprg
313 |                 endif
314 |                 if &l:shellpipe != shellpipe
315 |                     let &l:shellpipe = shellpipe
316 |                 endif
317 |                 if &l:errorformat != errorformat
318 |                     let &l:errorformat = errorformat
319 |                 endif
320 |             endtry
321 | 
322 |         endif
323 |     catch
324 |         echohl Error
325 |         echom v:errmsg
326 |         echohl NONE
327 |     finally
328 |         " TLogVAR pos, bufnr
329 |         if bufnr != bufnr('%')
330 |             exec bufnr 'buffer'
331 |         endif
332 |         call setpos('.', pos)
333 |     endtry
334 |     return 0
335 | endf
336 | 
337 | 
338 | function! s:GetDef(ft) "{{{3
339 |     if exists('b:checksyntax') && has_key(b:checksyntax, a:ft)
340 |         return b:checksyntax[a:ft]
341 |     elseif has_key(g:checksyntax, a:ft)
342 |         return g:checksyntax[a:ft]
343 |     else
344 |         return {}
345 |     endif
346 | endf
347 | 
348 | 
349 | " :def: function! checksyntax#Check(manually, ?bang='', ?type=&ft)
350 | function! checksyntax#Check(manually, ...)
351 |     let bang = a:0 >= 1 && a:1 != '' ? 1 : 0
352 |     let ft   = a:0 >= 2 && a:2 != '' ? a:2 : &filetype
353 |     let def = a:manually ? {} : s:GetDef(ft .',auto')
354 |     if empty(def)
355 |         let def  = s:GetDef(ft)
356 |     endif
357 |     if &modified
358 |         if has_key(def, 'modified')
359 |             let def = s:GetDef(def.modified)
360 |         else
361 |             echohl WarningMsg
362 |             echom "Buffer was modified. Please save it before calling :CheckSyntax."
363 |             echohl NONE
364 |             return
365 |         endif
366 |     endif
367 |     if bang && has_key(def, 'alt')
368 |         let def = s:GetDef(def.alt)
369 |     endif
370 |     " TLogVAR def
371 |     if empty(def)
372 |         return
373 |     endif
374 |     let auto = get(def, 'auto', 0)
375 |     " TLogVAR auto
376 |     if !(a:manually || auto)
377 |         return
378 |     endif
379 |     " TLogVAR &makeprg, &l:makeprg, &g:makeprg, &errorformat
380 |     exec get(def, 'prepare', '')
381 |     if s:Make(def)
382 |         let failrx = get(def, 'failrx', g:checksyntax#failrx)
383 |         let okrx   = get(def, 'okrx', g:checksyntax#okrx)
384 |         let type = get(def, 'listtype', 'loc')
385 |         let list = s:prototypes[type].Get()
386 |         let list = filter(list, 's:FilterItem(def, v:val)')
387 |         let list = map(list, 's:CompleteItem(def, v:val)')
388 |         call s:prototypes[type].Set(list)
389 |         " echom "DBG 1" string(list)
390 |         redraw!
391 |         if len(list) == 0
392 |             call CheckSyntaxSucceed(type, a:manually)
393 |         else
394 |             call CheckSyntaxFail(type, a:manually)
395 |         endif
396 |     endif
397 | endf
398 | 
399 | 
400 | function! s:CompleteItem(def, val) "{{{3
401 |     if get(a:val, 'bufnr', 0) == 0
402 |         let a:val.bufnr = bufnr('%')
403 |     endif
404 |     return a:val
405 | endf
406 | 
407 | 
408 | function! s:FilterItem(def, val) "{{{3
409 |     if a:val.lnum == 0 && a:val.pattern == ''
410 |         return 0
411 |     elseif has_key(a:val, 'nr') && has_key(a:def, 'ignore_nr') && index(a:def.ignore_nr, a:val.nr) != -1
412 |         return 0
413 |     endif
414 |     return 1
415 | endf
416 | 
417 | 


--------------------------------------------------------------------------------
/vimfiles/doc/Tabular.txt:
--------------------------------------------------------------------------------
  1 | *Tabular.txt*   Configurable, flexible, intuitive text aligning
  2 | 
  3 |                                                        *tabular* *tabular.vim*
  4 | 
  5 |        #|#|#|#|#|          #|                  #|                     ~
  6 |            #|      #|#|#|  #|#|#|    #|    #|  #|    #|#|#|  #|  #|#| ~
  7 |            #|    #|    #|  #|    #|  #|    #|  #|  #|    #|  #|#|     ~
  8 |            #|    #|    #|  #|    #|  #|    #|  #|  #|    #|  #|       ~
  9 |            #|      #|#|#|  #|#|#|      #|#|#|  #|    #|#|#|  #|       ~
 10 | 
 11 |                                                   For Vim version 7.0 or newer
 12 | 
 13 |                                By Matt Wozniski
 14 |                                 mjw@drexel.edu
 15 | 
 16 |                                Reference Manual ~
 17 | 
 18 |                                                                  *tabular-toc*
 19 | 
 20 | 1. Description                                           |tabular-intro|
 21 | 2. Walkthrough                                           |tabular-walkthrough|
 22 | 3. Scripting                                             |tabular-scripting|
 23 | 
 24 | The functionality mentioned here is a plugin, see |add-plugin|.
 25 | You can avoid loading this plugin by setting the "Tabular_loaded" global
 26 | variable in your |vimrc| file: >
 27 |     :let g:tabular_loaded = 1
 28 | 
 29 | ==============================================================================
 30 | 1. Description                                                 *tabular-intro*
 31 | 
 32 | Sometimes, it's useful to line up text.  Naturally, it's nicer to have the
 33 | computer do this for you, since aligning things by hand quickly becomes
 34 | unpleasant.  While there are other plugins for aligning text, the ones I've
 35 | tried are either impossibly difficult to understand and use, or too simplistic
 36 | to handle complicated tasks.  This plugin aims to make the easy things easy
 37 | and the hard things possible, without providing an unnecessarily obtuse
 38 | interface.  It's still a work in progress, and criticisms are welcome.
 39 | 
 40 | ==============================================================================
 41 | 2. Walkthrough                                           *tabular-walkthrough*
 42 | 
 43 | Tabular's commands are based largely on regular expressions.  The basic
 44 | technique used by Tabular is taking some regex to match field delimiters,
 45 | splitting the input lines at those delimiters, trimming unnecessary spaces
 46 | from the non-delimiter parts, padding the non-delimiter parts of the lines
 47 | with spaces to make them the same length, and joining things back together
 48 | again.
 49 | 
 50 | For instance, consider starting with the following lines:
 51 | >
 52 |     Some short phrase,some other phrase
 53 |     A much longer phrase here,and another long phrase
 54 | <
 55 | Let's say we want to line these lines up at the commas.  We can tell
 56 | Tabularize to do this by passing a pattern matching , to the Tabularize
 57 | command:
 58 | >
 59 |   :Tabularize /,
 60 | 
 61 |     Some short phrase         , some other phrase
 62 |     A much longer phrase here , and another long phrase
 63 | <
 64 | I encourage you to try copying those lines to another buffer and trying to
 65 | call :Tabularize.  You'll want to take notice of two things quickly: First,
 66 | instead of requiring a range, Tabularize tries to figure out what you want to
 67 | happen.  Since it knows that you want to act on lines matching a comma, it
 68 | will look upwards and downwards for lines around the current line that match a
 69 | comma, and consider all contiguous lines matching the pattern to be the range
 70 | to be acted upon.  You can always override this by specifying a range, though.
 71 | 
 72 | The second thing you should notice is that you'll almost certainly be able to
 73 | abbreviate :Tabularize to :Tab - using this form in mappings and scripts is
 74 | discouraged as it will make conflicts with other scripts more likely, but for
 75 | interactive use it's a nice timesaver.  Another convenience feature is that
 76 | running :Tabularize without providing a new pattern will cause it to reuse the
 77 | last pattern it was called with.
 78 | 
 79 | So, anyway, now the commas line up.  Splitting the lines on commas, Tabular
 80 | realized that 'Some short phrase' would need to be padded with spaces to match
 81 | the length of 'A much longer phrase here', and it did that before joining the
 82 | lines back together.  You'll also notice that, in addition to the spaces
 83 | inserting for padding, extra spaces were inserted between fields.  That's
 84 | because by default, Tabular prints things left-aligned with one space between
 85 | fields.  If you wanted to print things right-aligned with no spaces between
 86 | fields, you would provide a different format to the Tabularize command:
 87 | >
 88 |   :Tabularize /,/r0
 89 | 
 90 |             Some short phrase,      some other phrase
 91 |     A much longer phrase here,and another long phrase
 92 | <
 93 | A format specifier is either l, r, or c, followed by one or more digits.  If
 94 | the letter is l, the field will be left aligned, similarly for r and right
 95 | aligning and c and center aligning.  The number following the letter is the
 96 | number of spaces padding to insert before the start of the next field.
 97 | Multiple format specifiers can be added to the same command - each field will
 98 | be printed with the next format specifier in the list; when they all have been
 99 | used the first will be used again, and so on.  So, the last command right
100 | aligned every field, then inserted 0 spaces of padding before the next field.
101 | What if we wanted to right align the text before the comma, and left align the
102 | text after the comma?  The command would look like this:
103 | >
104 |   :Tabularize /,/r1c1l0
105 | 
106 |             Some short phrase , some other phrase
107 |     A much longer phrase here , and another long phrase
108 | <
109 | That command would be read as "Align the matching text, splitting fields on
110 | commas.  Print everything before the first comma right aligned, then 1 space,
111 | then the comma center aligned, then 1 space, then everything after the comma
112 | left aligned."  Notice that the alignment of the field the comma is in is
113 | irrelevant - since it's only 1 cell wide, it looks the same whether it's right,
114 | left, or center aligned.  Also notice that the 0 padding spaces specified for
115 | the 3rd field are unused - but they would be used if there were enough fields
116 | to require looping through the fields again.  For instance:
117 | >
118 |     abc,def,ghi
119 |     a,b
120 |     a,b,c
121 | 
122 |   :Tabularize /,/r1c1l0
123 | 
124 |     abc , def, ghi
125 |       a , b
126 |       a , b  ,  c
127 | <
128 | Notice that now, the format pattern has been reused; field 4 (the second comma)
129 | is right aligned, field 5 is center aligned.  No spaces were inserted between
130 | the 3rd field (containing "def") and the 4th field (the second comma) because
131 | the format specified 'l0'.
132 | 
133 | But, what if you only wanted to act on the first comma on the line, rather than
134 | all of the commas on the line?  Let's say we want everything before the first
135 | comma right aligned, then the comma, then everything after the comma left
136 | aligned:
137 | >
138 |     abc,def,ghi
139 |     a,b
140 |     a,b,c
141 | 
142 |   :Tabularize /^[^,]*\zs,/r0c0l0
143 | 
144 |     abc,def,ghi
145 |       a,b
146 |       a,b,c
147 | <
148 | Here, we used a Vim regex that would only match the first comma on the line.
149 | It matches the beginning of the line, followed by all the non-comma characters
150 | up to the first comma, and then forgets about what it matched so far and
151 | pretends that the match starts exactly at the comma.
152 | 
153 | But, now that this command does exactly what we want it to, it's become pretty
154 | unwieldy.  It would be unpleasant to need to type that more than once or
155 | twice.  The solution is to assign a name to it.
156 | >
157 |   :AddTabularPattern first_comma /^[^,]*\zs,/r0c0l0
158 | <
159 | Now, typing ":Tabularize first_comma" will do the same thing as typing the
160 | whole pattern out each time.  Of course this is more useful if you store the
161 | name in a file to be used later.
162 | 
163 | NOTE: In order to make these new commands available every time vim starts,
164 | you'll need to put those new commands into a .vim file in a plugin directory
165 | somewhere in your 'runtimepath'.  In order to make sure that Tabular.vim has
166 | already been loaded before your file tries to use :AddTabularPattern or
167 | :AddTabularPipeline, the new file should be installed in an after/plugin
168 | directory in 'runtimepath'.  In general, it will be safe to find out where the
169 | TabularMaps.vim plugin was installed, and place other files extending
170 | Tabular.vim in the same directory as TabularMaps.vim.  For more information,
171 | and some suggested best practices, check out the |tabular-scripting| section.
172 | 
173 | Lastly, we'll approach the case where tabular cannot achieve your desired goal
174 | just by splitting lines appart, trimming whitespace, padding with whitespace,
175 | and rejoining the lines.  As an example, consider the multiple_spaces command
176 | from TabularMaps.vim.  The goal is to split using two or more spaces as a
177 | field delimiter, and join fields back together, properly lined up, with only
178 | two spaces between the end of each field and the beginning of the next.
179 | Unfortunately, Tabular can't do this with only the commands we know so far:
180 | >
181 |   :Tabularize /  /
182 | <
183 | The above function won't work, because it will consider "a    b" as 5 fields
184 | delimited by two pairs of 2 spaces ( 'a', '  ', '', '  ', 'b' ) instead of as
185 | 3 fields delimited by one set of 2 or more spaces ( 'a', '    ', 'b' ).
186 | >
187 |   :Tabularize /  \+/
188 | <
189 | The above function won't work either, because it will leave the delimiter as 4
190 | spaces when used against "a    b", meaning that we would fail at our goal of
191 | collapsing everything down to two spaces between fields.  So, we need a new
192 | command to get around this:
193 | >
194 |   :AddTabularPipeline multiple_spaces / \{2,}/
195 |     \ map(a:lines, "substitute(v:val, ' \{2,}', '  ', 'g')")
196 |     \   | tabular#TabularizeStrings(a:lines, '  ', 'l0')
197 | <
198 | Yeah.  I know it looks complicated.  Bear with me.  I probably will try to add
199 | in some shortcuts for this syntax, but this verbose will be guaranteed to
200 | always work.
201 | 
202 | You should already recognize the name being assigned.  The next thing to
203 | happen is / \{2,}/ which is a pattern specifying which lines should
204 | automatically be included in the range when no range is given.  Without this,
205 | there would be no pattern to use for extending the range.  Everything after
206 | that is a | separated list of expressions to be evaluated.  In the context in
207 | which they will be evaluated, a:lines will be set to a List of Strings
208 | containing the text of the lines being filtered as they procede through the
209 | pipeline you've set up.  The \ at the start of the lines are just vim's line
210 | continuation marker; you needn't worry much about them.  So, the first
211 | expression in the pipeline transforms each line by replacing every instance of
212 | 2 or more spaces with exactly two spaces.  The second command in the pipeline
213 | performs the equivalent of ":Tabularize /  /l0"; the only difference is that
214 | it is operating on a List of Strings rather than text in the buffer.  At the
215 | end of the pipeline, the Strings in the modified a:lines (or the return value
216 | of the last expression in the pipeline, if it returns a List) will replace the
217 | chosen range.
218 | 
219 | ==============================================================================
220 | 3. Extending                                               *tabular-scripting*
221 | 
222 | As mentioned above, the most important consideration when extending Tabular
223 | with new maps or commands is that your plugin must be loaded after Tabular.vim
224 | has finished loading, and only if Tabular.vim has loaded successfully.  The
225 | easiest approach to making sure it loads after Tabular.vim is simply putting
226 | the new file (we'll call it "tabular_extra.vim" as an example) into an
227 | "after/plugin/" directory in 'runtimepath', for instance:
228 | >
229 |   ~/.vim/after/plugin/tabular_extra.vim
230 | <
231 | The default set of mappings, found in "TabularMaps.vim", is installed in
232 | the after/plugin/ subdirectory of whatever directory Tabular was installed to.
233 | 
234 | The other important consideration is making sure that your commands are only
235 | called if Tabular.vim was actually loaded.  The easiest way to do this is by
236 | checking for the existence of the :Tabularize command at the start of your
237 | plugin.  A short example plugin would look like this:
238 | >
239 |   " after/plugin/my_tabular_commands.vim
240 |   " Provides extra :Tabularize commands
241 | 
242 |   if !exists(':Tabularize')
243 |     finish " Give up here; the Tabular plugin musn't have been loaded
244 |   endif
245 | 
246 |   " Make line wrapping possible by resetting the 'cpo' option, first saving it
247 |   let s:save_cpo = &cpo
248 |   set cpo&vim
249 | 
250 |   AddTabularPattern! asterisk /*/l1
251 | 
252 |   AddTabularPipeline! remove_leading_spaces /^ /
253 |                   \ map(a:lines, "substitute(v:val, '^ *', '', '')")
254 | 
255 |   " Restore the saved value of 'cpo'
256 |   let &cpo = s:save_cpo
257 |   unlet s:save_cpo
258 | <
259 | ==============================================================================
260 | vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl:
261 | 


--------------------------------------------------------------------------------
/vimfiles/plugin/php-doc.vim:
--------------------------------------------------------------------------------
  1 | " PDV (phpDocumentor for Vim)
  2 | " ===========================
  3 | "
  4 | " Version: 1.0.0
  5 | " 
  6 | " Copyright 2005 by Tobias Schlitt <toby@php.net>
  7 | " Inspired by phpDoc script for Vim by Vidyut Luther (http://www.phpcult.com/).
  8 | "
  9 | " Provided under the GPL (http://www.gnu.org/copyleft/gpl.html).
 10 | "
 11 | " This script provides functions to generate phpDocumentor conform
 12 | " documentation blocks for your PHP code. The script currently
 13 | " documents:
 14 | " 
 15 | " - Classes
 16 | " - Methods/Functions
 17 | " - Attributes
 18 | "
 19 | " All of those supporting all PHP 4 and 5 syntax elements. 
 20 | "
 21 | " Beside that it allows you to define default values for phpDocumentor tags 
 22 | " like @version (I use $id$ here), @author, @license and so on. 
 23 | "
 24 | " For function/method parameters and attributes, the script tries to guess the 
 25 | " type as good as possible from PHP5 type hints or default values (array, bool, 
 26 | " int, string...).
 27 | "
 28 | " You can use this script by mapping the function PhpDoc() to any
 29 | " key combination. Hit this on the line where the element to document
 30 | " resides and the doc block will be created directly above that line.
 31 | " 
 32 | " Installation
 33 | " ============
 34 | " 
 35 | " For example include into your .vimrc:
 36 | " 
 37 | " source ~/.vim/php-doc.vim
 38 | " imap <C-o> :set paste<CR>:call PhpDoc()<CR>:set nopaste<CR>i
 39 | "
 40 | " This includes the script and maps the combination <ctrl>+o (only in
 41 | " insert mode) to the doc function. 
 42 | "
 43 | " Changelog
 44 | " =========
 45 | "
 46 | " Version 1.0.0
 47 | " -------------
 48 | "
 49 | "  * Created the initial version of this script while playing around with VIM
 50 | "  scripting the first time and trying to fix Vidyut's solution, which
 51 | "  resulted in a complete rewrite.
 52 | "
 53 | " Version 1.1.0
 54 | " -------------
 55 | "  * Fixed bug with call-by-reference parameters. 
 56 | " 
 57 | 
 58 | if has ("user_commands")
 59 | 
 60 | " {{{ Globals
 61 | 
 62 | " After phpDoc standard
 63 | let g:pdv_cfg_CommentHead = "/**"
 64 | let g:pdv_cfg_Comment1 = " * "
 65 | let g:pdv_cfg_Commentn = " * "
 66 | let g:pdv_cfg_CommentTail = " */"
 67 | let g:pdv_cfg_CommentSingle = "//"
 68 | 
 69 | " Default values
 70 | let g:pdv_cfg_Type = "mixed"
 71 | " let g:pdv_cfg_Package = "Framework"
 72 | let g:pdv_cfg_Package = "Webdav"
 73 | let g:pdv_cfg_Version = "//autogen//"
 74 | let g:pdv_cfg_Author = ""
 75 | let g:pdv_cfg_Copyright = "Copyright (C) 2005-2007 eZ systems as. All rights reserved."
 76 | let g:pdv_cfg_License = "http://ez.no/licenses/new_bsd New BSD License"
 77 | 
 78 | " TOB: let g:pdv_cfg_Type = "mixed"
 79 | " TOB: let g:pdv_cfg_Package = ""
 80 | " TOB: let g:pdv_cfg_Version = "$id$"
 81 | " TOB: let g:pdv_cfg_Author = "Tobias Schlitt <toby@php.net>"
 82 | " TOB: let g:pdv_cfg_Copyright = "1997-2005 The PHP Group"
 83 | " TOB: let g:pdv_cfg_License = "PHP Version 3.0 {@link http://www.php.net/license/3_0.txt}"
 84 | 
 85 | let g:pdv_cfg_ReturnVal = "void"
 86 | 
 87 | " Wether to create @uses tags for implementation of interfaces and inheritance
 88 | let g:pdv_cfg_Uses = 0
 89 | " TOB: let g:pdv_cfg_Uses = 1
 90 | 
 91 | " Options
 92 | " :set paste before documenting (1|0)? Recommended.
 93 | let g:pdv_cfg_paste = 1
 94 | 
 95 | " Wether for PHP5 code PHP4 tags should be set, like @access,... (1|0)?
 96 | let g:pdv_cfg_php4always = 0
 97 | " TOB: let g:pdv_cfg_php4always = 1
 98 |  
 99 | " Wether to guess scopes after PEAR coding standards:
100 | " $_foo/_bar() == <private|protected> (1|0)?
101 | let g:pdv_cfg_php4guess = 1
102 | 
103 | " If you selected 1 for the last value, this scope identifier will be used for
104 | " the identifiers having an _ in the first place.
105 | let g:pdv_cfg_php4guessval = "protected"
106 | 
107 | "
108 | " Regular expressions 
109 | " 
110 | 
111 | let g:pdv_re_comment = ' *\*/ *'
112 | 
113 | " (private|protected|public)
114 | let g:pdv_re_scope = '\(private\|protected\|public\)'
115 | " (static)
116 | let g:pdv_re_static = '\(static\)'
117 | " (abstract)
118 | let g:pdv_re_abstract = '\(abstract\)'
119 | " (final)
120 | let g:pdv_re_final = '\(final\)'
121 | 
122 | " [:space:]*(private|protected|public|static|abstract)*[:space:]+[:identifier:]+\([:params:]\)
123 | let g:pdv_re_func = '^\s*\([a-zA-Z ]*\)function\s\+\([^ (]\+\)\s*(\s*\(.*\)\s*)\s*[{;]\?$'
124 | " [:typehint:]*[:space:]*$[:identifier]\([:space:]*=[:space:]*[:value:]\)?
125 | let g:pdv_re_param = ' *\([^ &]*\) *&\?\$\([A-Za-z_][A-Za-z0-9_]*\) *=\? *\(.*\)\?$'
126 | 
127 | " [:space:]*(private|protected|public\)[:space:]*$[:identifier:]+\([:space:]*=[:space:]*[:value:]+\)*;
128 | let g:pdv_re_attribute = '^\s*\(\(private\|public\|protected\|var\|static\)\+\)\s*\$\([^ ;=]\+\)[ =]*\(.*\);\?$'
129 | 
130 | " [:spacce:]*(abstract|final|)[:space:]*(class|interface)+[:space:]+\(extends ([:identifier:])\)?[:space:]*\(implements ([:identifier:][, ]*)+\)?
131 | let g:pdv_re_class = '^\s*\([a-zA-Z]*\)\s*\(interface\|class\)\s*\([^ ]\+\)\s*\(extends\)\?\s*\([a-zA-Z0-9]*\)\?\s*\(implements*\)\? *\([a-zA-Z0-9_ ,]*\)\?.*$'
132 | 
133 | let g:pdv_re_array  = "^array *(.*"
134 | " FIXME (retest regex!)
135 | let g:pdv_re_float  = '^[0-9]*\.[0-9]\+'
136 | let g:pdv_re_int    = '^[0-9]\+'
137 | let g:pdv_re_string = "['\"].*"
138 | let g:pdv_re_bool = "\(true\|false\)"
139 | 
140 | let g:pdv_re_indent = '^\s*'
141 | 
142 | " Shortcuts for editing the text:
143 | let g:pdv_cfg_BOL = "norm! o"
144 | let g:pdv_cfg_EOL = ""
145 | 
146 | " }}}  
147 | 
148 |  " {{{ PhpDocSingle()
149 |  " Document a single line of code ( does not check if doc block already exists )
150 | 
151 | func! PhpDocSingle()
152 |     let l:endline = line(".") + 1
153 |     call PhpDoc()
154 |     exe "norm! " . l:endline . "G$"
155 | endfunc
156 | 
157 | " }}}
158 |  " {{{ PhpDocRange()
159 |  " Documents a whole range of code lines ( does not add defualt doc block to
160 |  " unknown types of lines ). Skips elements where a docblock is already
161 |  " present.
162 | func! PhpDocRange() range
163 |     let l:line = a:firstline
164 |     let l:endLine = a:lastline
165 | 	let l:elementName = ""
166 |     while l:line <= l:endLine
167 |         " TODO: Replace regex check for existing doc with check more lines
168 |         " above...
169 |         if (getline(l:line) =~ g:pdv_re_func || getline(l:line) =~ g:pdv_re_attribute || getline(l:line) =~ g:pdv_re_class) && getline(l:line - 1) !~ g:pdv_re_comment
170 | 			let l:docLines = 0
171 | 			" Ensure we are on the correct line to run PhpDoc()
172 |             exe "norm! " . l:line . "G$"
173 | 			" No matter what, this returns the element name
174 |             let l:elementName = PhpDoc()
175 |             let l:endLine = l:endLine + (line(".") - l:line) + 1
176 |             let l:line = line(".") + 1 
177 |         endif
178 |         let l:line = l:line + 1
179 |     endwhile
180 | endfunc
181 | 
182 |  " }}}
183 | " {{{ PhpDocFold()
184 | 
185 | " func! PhpDocFold(name)
186 | " 	let l:startline = line(".")
187 | " 	let l:currentLine = l:startLine
188 | " 	let l:commentHead = escape(g:pdv_cfg_CommentHead, "*.");
189 | "     let l:txtBOL = g:pdv_cfg_BOL . matchstr(l:name, '^\s*')
190 | " 	" Search above for comment start
191 | " 	while (l:currentLine > 1)
192 | " 		if (matchstr(l:commentHead, getline(l:currentLine)))
193 | " 			break;
194 | " 		endif
195 | " 		let l:currentLine = l:currentLine + 1
196 | " 	endwhile
197 | " 	" Goto 1 line above and open a newline
198 | "     exe "norm! " . (l:currentLine - 1) . "Go\<ESC>"
199 | " 	" Write the fold comment
200 | "     exe l:txtBOL . g:pdv_cfg_CommentSingle . " {"."{{ " . a:name . g:pdv_cfg_EOL
201 | " 	" Add another newline below that
202 | " 	exe "norm! o\<ESC>"
203 | " 	" Search for our comment line
204 | " 	let l:currentLine = line(".")
205 | " 	while (l:currentLine <= line("$"))
206 | " 		" HERE!!!!
207 | " 	endwhile
208 | " 	
209 | " 
210 | " endfunc
211 | 
212 | 
213 | " }}}
214 | 
215 | " {{{ PhpDoc()
216 | 
217 | func! PhpDoc()
218 |     " Needed for my .vimrc: Switch off all other enhancements while generating docs
219 |     let l:paste = &g:paste
220 |     let &g:paste = g:pdv_cfg_paste == 1 ? 1 : &g:paste
221 |     
222 |     let l:line = getline(".")
223 |     let l:result = ""
224 | 
225 |     if l:line =~ g:pdv_re_func
226 |         let l:result = PhpDocFunc()
227 | 
228 |     elseif l:line =~ g:pdv_re_attribute
229 |         let l:result = PhpDocVar()
230 | 
231 |     elseif l:line =~ g:pdv_re_class
232 |         let l:result = PhpDocClass()
233 | 
234 |     else
235 |         let l:result = PhpDocDefault()
236 | 
237 |     endif
238 | 
239 | "	if g:pdv_cfg_folds == 1
240 | "		PhpDocFolds(l:result)
241 | "	endif
242 | 
243 |     let &g:paste = l:paste
244 | 
245 |     return l:result
246 | endfunc
247 | 
248 | " }}}
249 | " {{{  PhpDocFunc()  
250 | 
251 | func! PhpDocFunc()
252 | 	" Line for the comment to begin
253 | 	let commentline = line (".") - 1
254 | 
255 | 	let l:name = substitute (getline ("."), '^\(.*\)\/\/.*$', '\1', "")
256 | 
257 |     "exe g:pdv_cfg_BOL . "DEBUG:" . name. g:pdv_cfg_EOL
258 | 
259 | 	" First some things to make it more easy for us:
260 | 	" tab -> space && space+ -> space
261 | 	" let l:name = substitute (l:name, '\t', ' ', "")
262 | 	" Orphan. We're now using \s everywhere...
263 | 
264 | 	" Now we have to split DECL in three parts:
265 | 	" \[(skopemodifier\)]\(funcname\)\(parameters\)
266 |     let l:indent = matchstr(l:name, g:pdv_re_indent)
267 | 	
268 | 	let l:modifier = substitute (l:name, g:pdv_re_func, '\1', "g")
269 | 	let l:funcname = substitute (l:name, g:pdv_re_func, '\2', "g")
270 | 	let l:parameters = substitute (l:name, g:pdv_re_func, '\3', "g") . ","
271 |     let l:scope = PhpDocScope(l:modifier, l:funcname)
272 |     let l:static = g:pdv_cfg_php4always == 1 ? matchstr(l:modifier, g:pdv_re_static) : ""
273 | 	let l:abstract = g:pdv_cfg_php4always == 1 ? matchstr(l:modifier, g:pdv_re_abstract) : ""
274 | 	let l:final = g:pdv_cfg_php4always == 1 ? matchstr(l:modifier, g:pdv_re_final) : ""
275 |     
276 |     exe "norm! " . commentline . "G$"
277 |     
278 |     " Local indent
279 |     let l:txtBOL = g:pdv_cfg_BOL . l:indent
280 | 	
281 |     exe l:txtBOL . g:pdv_cfg_CommentHead . g:pdv_cfg_EOL
282 | 	exe l:txtBOL . g:pdv_cfg_Comment1 . funcname . " " . g:pdv_cfg_EOL
283 |     exe l:txtBOL . g:pdv_cfg_Commentn . g:pdv_cfg_EOL
284 | 
285 | 	while (l:parameters != ",") && (l:parameters != "")
286 | 		" Save 1st parameter
287 | 		let _p = substitute (l:parameters, '\([^,]*\) *, *\(.*\)', '\1', "")
288 | 		" Remove this one from list
289 | 		let l:parameters = substitute (l:parameters, '\([^,]*\) *, *\(.*\)', '\2', "")
290 | 		" PHP5 type hint?
291 | 		let l:paramtype = substitute (_p, g:pdv_re_param, '\1', "")
292 | 		" Parameter name
293 | 		let l:paramname = substitute (_p, g:pdv_re_param, '\2', "")
294 | 		" Parameter default
295 | 		let l:paramdefault = substitute (_p, g:pdv_re_param, '\3', "")
296 | 
297 |         if l:paramtype == ""
298 |             let l:paramtype = PhpDocType(l:paramdefault)
299 |         endif
300 |         
301 |         if l:paramtype != ""
302 |             let l:paramtype = " " . l:paramtype
303 |         endif
304 | 		exe l:txtBOL . g:pdv_cfg_Commentn . "@param" . l:paramtype . " $" . l:paramname . " " . g:pdv_cfg_EOL
305 | 	endwhile
306 | 
307 | 	if l:static != ""
308 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@static" . g:pdv_cfg_EOL
309 |     endif
310 | 	if l:abstract != ""
311 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@abstract" . g:pdv_cfg_EOL
312 |     endif
313 | 	if l:final != ""
314 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@final" . g:pdv_cfg_EOL
315 |     endif
316 |     if l:scope != ""
317 |     	exe l:txtBOL . g:pdv_cfg_Commentn . "@access " . l:scope . g:pdv_cfg_EOL
318 |     endif
319 | 	exe l:txtBOL . g:pdv_cfg_Commentn . "@return " . g:pdv_cfg_ReturnVal . g:pdv_cfg_EOL
320 | 
321 | 	" Close the comment block.
322 | 	exe l:txtBOL . g:pdv_cfg_CommentTail . g:pdv_cfg_EOL
323 |     return l:modifier ." ". l:funcname
324 | endfunc
325 | 
326 | " }}}  
327 |  " {{{  PhpDocVar() 
328 | 
329 | func! PhpDocVar()
330 | 	" Line for the comment to begin
331 | 	let commentline = line (".") - 1
332 | 
333 | 	let l:name = substitute (getline ("."), '^\(.*\)\/\/.*$', '\1', "")
334 | 
335 | 	" Now we have to split DECL in three parts:
336 | 	" \[(skopemodifier\)]\(funcname\)\(parameters\)
337 | 	" let l:name = substitute (l:name, '\t', ' ', "")
338 | 	" Orphan. We're now using \s everywhere...
339 | 
340 |     let l:indent = matchstr(l:name, g:pdv_re_indent)
341 | 
342 | 	let l:modifier = substitute (l:name, g:pdv_re_attribute, '\1', "g")
343 | 	let l:varname = substitute (l:name, g:pdv_re_attribute, '\3', "g")
344 | 	let l:default = substitute (l:name, g:pdv_re_attribute, '\4', "g")
345 |     let l:scope = PhpDocScope(l:modifier, l:varname)
346 | 
347 |     let l:static = g:pdv_cfg_php4always == 1 ? matchstr(l:modifier, g:pdv_re_static) : ""
348 | 
349 |     let l:type = PhpDocType(l:default)
350 |     
351 |     exe "norm! " . commentline . "G$"
352 |     
353 |     " Local indent
354 |     let l:txtBOL = g:pdv_cfg_BOL . l:indent
355 | 	
356 |     exe l:txtBOL . g:pdv_cfg_CommentHead . g:pdv_cfg_EOL
357 | 	exe l:txtBOL . g:pdv_cfg_Comment1 . l:varname . " " . g:pdv_cfg_EOL
358 |     exe l:txtBOL . g:pdv_cfg_Commentn . g:pdv_cfg_EOL
359 |     if l:static != ""
360 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@static" . g:pdv_cfg_EOL
361 |     endif
362 |     exe l:txtBOL . g:pdv_cfg_Commentn . "@var " . l:type . g:pdv_cfg_EOL
363 |     if l:scope != ""
364 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@access " . l:scope . g:pdv_cfg_EOL
365 |     endif
366 | 	
367 |     " Close the comment block.
368 | 	exe l:txtBOL . g:pdv_cfg_CommentTail . g:pdv_cfg_EOL
369 | 	return l:modifier ." ". l:varname
370 | endfunc
371 | 
372 | " }}}
373 | "  {{{  PhpDocClass()
374 | 
375 | func! PhpDocClass()
376 | 	" Line for the comment to begin
377 | 	let commentline = line (".") - 1
378 | 
379 | 	let l:name = substitute (getline ("."), '^\(.*\)\/\/.*$', '\1', "")
380 | 
381 |     "exe g:pdv_cfg_BOL . "DEBUG:" . name. g:pdv_cfg_EOL
382 | 
383 | 	" First some things to make it more easy for us:
384 | 	" tab -> space && space+ -> space
385 | 	" let l:name = substitute (l:name, '\t', ' ', "")
386 | 	" Orphan. We're now using \s everywhere...
387 | 
388 | 	" Now we have to split DECL in three parts:
389 | 	" \[(skopemodifier\)]\(classname\)\(parameters\)
390 |     let l:indent = matchstr(l:name, g:pdv_re_indent)
391 | 	
392 | 	let l:modifier = substitute (l:name, g:pdv_re_class, '\1', "g")
393 | 	let l:classname = substitute (l:name, g:pdv_re_class, '\3', "g")
394 | 	let l:extends = g:pdv_cfg_Uses == 1 ? substitute (l:name, g:pdv_re_class, '\5', "g") : ""
395 | 	let l:interfaces = g:pdv_cfg_Uses == 1 ? substitute (l:name, g:pdv_re_class, '\7', "g") . "," : ""
396 | 
397 | 	let l:abstract = g:pdv_cfg_php4always == 1 ? matchstr(l:modifier, g:pdv_re_abstract) : ""
398 | 	let l:final = g:pdv_cfg_php4always == 1 ?  matchstr(l:modifier, g:pdv_re_final) : ""
399 |     
400 |     exe "norm! " . commentline . "G$"
401 |     
402 |     " Local indent
403 |     let l:txtBOL = g:pdv_cfg_BOL . l:indent
404 | 	
405 |     exe l:txtBOL . g:pdv_cfg_CommentHead . g:pdv_cfg_EOL
406 | 	exe l:txtBOL . g:pdv_cfg_Comment1 . l:classname . " " . g:pdv_cfg_EOL
407 |     exe l:txtBOL . g:pdv_cfg_Commentn . g:pdv_cfg_EOL
408 |     if l:extends != "" && l:extends != "implements"
409 |     	exe l:txtBOL . g:pdv_cfg_Commentn . "@uses " . l:extends . g:pdv_cfg_EOL
410 |     endif
411 | 
412 | 	while (l:interfaces != ",") && (l:interfaces != "")
413 | 		" Save 1st parameter
414 | 		let interface = substitute (l:interfaces, '\([^, ]*\) *, *\(.*\)', '\1', "")
415 | 		" Remove this one from list
416 | 		let l:interfaces = substitute (l:interfaces, '\([^, ]*\) *, *\(.*\)', '\2', "")
417 | 		exe l:txtBOL . g:pdv_cfg_Commentn . "@uses " . l:interface . g:pdv_cfg_EOL
418 | 	endwhile
419 | 
420 | 	if l:abstract != ""
421 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@abstract" . g:pdv_cfg_EOL
422 |     endif
423 | 	if l:final != ""
424 |         exe l:txtBOL . g:pdv_cfg_Commentn . "@final" . g:pdv_cfg_EOL
425 |     endif
426 | 	exe l:txtBOL . g:pdv_cfg_Commentn . "@package " . g:pdv_cfg_Package . g:pdv_cfg_EOL
427 | 	exe l:txtBOL . g:pdv_cfg_Commentn . "@version " . g:pdv_cfg_Version . g:pdv_cfg_EOL
428 | 	exe l:txtBOL . g:pdv_cfg_Commentn . "@copyright " . g:pdv_cfg_Copyright . g:pdv_cfg_EOL
429 | 	exe l:txtBOL . g:pdv_cfg_Commentn . "@author " . g:pdv_cfg_Author g:pdv_cfg_EOL
430 | 	exe l:txtBOL . g:pdv_cfg_Commentn . "@license " . g:pdv_cfg_License . g:pdv_cfg_EOL
431 | 
432 | 	" Close the comment block.
433 | 	exe l:txtBOL . g:pdv_cfg_CommentTail . g:pdv_cfg_EOL
434 | 	return l:modifier ." ". l:classname
435 | endfunc
436 | 
437 | " }}} 
438 | " {{{ PhpDocScope() 
439 | 
440 | func! PhpDocScope(modifiers, identifier)
441 | " exe g:pdv_cfg_BOL . DEBUG: . a:modifiers . g:pdv_cfg_EOL
442 |     let l:scope  = ""
443 |     if  matchstr (a:modifiers, g:pdv_re_scope) != "" 
444 |         if g:pdv_cfg_php4always == 1
445 |             let l:scope = matchstr (a:modifiers, g:pdv_re_scope)
446 |         else
447 |             let l:scope = "x"
448 |         endif
449 |     endif
450 |     if l:scope =~ "^\s*$" && g:pdv_cfg_php4guess
451 |         if a:identifier[0] == "_"
452 |             let l:scope = g:pdv_cfg_php4guessval
453 |         else
454 |             let l:scope = "public"
455 |         endif
456 |     endif
457 |     return l:scope != "x" ? l:scope : ""
458 | endfunc
459 | 
460 | " }}}
461 | " {{{ PhpDocType()
462 | 
463 | func! PhpDocType(typeString)
464 |     let l:type = ""
465 |     if a:typeString =~ g:pdv_re_array 
466 |         let l:type = "array"
467 |     endif
468 |     if a:typeString =~ g:pdv_re_float 
469 |         let l:type = "float"
470 |     endif
471 |     if a:typeString =~ g:pdv_re_int 
472 |         let l:type = "int"
473 |     endif
474 |     if a:typeString =~ g:pdv_re_string
475 |         let l:type = "string"
476 |     endif
477 |     if a:typeString =~ g:pdv_re_bool
478 |         let l:type = "bool"
479 |     endif
480 | 	if l:type == ""
481 | 		let l:type = g:pdv_cfg_Type
482 | 	endif
483 |     return l:type
484 | endfunc
485 |     
486 | "  }}} 
487 | " {{{  PhpDocDefault()
488 | 
489 | func! PhpDocDefault()
490 | 	" Line for the comment to begin
491 | 	let commentline = line (".") - 1
492 |     
493 |     let l:indent = matchstr(getline("."), '^\ *')
494 |     
495 |     exe "norm! " . commentline . "G$"
496 |     
497 |     " Local indent
498 |     let l:txtBOL = g:pdv_cfg_BOL . indent
499 | 
500 |     exe l:txtBOL . g:pdv_cfg_CommentHead . g:pdv_cfg_EOL
501 |     exe l:txtBOL . g:pdv_cfg_Commentn . " " . g:pdv_cfg_EOL
502 | 	
503 |     " Close the comment block.
504 | 	exe l:txtBOL . g:pdv_cfg_CommentTail . g:pdv_cfg_EOL
505 | endfunc
506 | 
507 | " }}}
508 | 
509 | endif " user_commands
510 | 


--------------------------------------------------------------------------------
/vimfiles/doc/NERD_tree.txt:
--------------------------------------------------------------------------------
   1 | *NERD_tree.txt*   A tree explorer plugin that owns your momma!
   2 | 
   3 | 
   4 | 
   5 |     omg its ... ~
   6 | 
   7 |     ________  ________   _   ____________  ____     __________  ____________~
   8 |    /_  __/ / / / ____/  / | / / ____/ __ \/ __ \   /_  __/ __ \/ ____/ ____/~
   9 |     / / / /_/ / __/    /  |/ / __/ / /_/ / / / /    / / / /_/ / __/ / __/   ~
  10 |    / / / __  / /___   / /|  / /___/ _, _/ /_/ /    / / / _, _/ /___/ /___   ~
  11 |   /_/ /_/ /_/_____/  /_/ |_/_____/_/ |_/_____/    /_/ /_/ |_/_____/_____/   ~
  12 | 
  13 | 
  14 |                               Reference Manual~
  15 | 
  16 | 
  17 | 
  18 | 
  19 | ==============================================================================
  20 | CONTENTS                                                   *NERDTree-contents*
  21 | 
  22 |     1.Intro...................................|NERDTree|
  23 |     2.Functionality provided..................|NERDTreeFunctionality|
  24 |         2.1.Global commands...................|NERDTreeGlobalCommands|
  25 |         2.2.Bookmarks.........................|NERDTreeBookmarks|
  26 |             2.2.1.The bookmark table..........|NERDTreeBookmarkTable|
  27 |             2.2.2.Bookmark commands...........|NERDTreeBookmarkCommands|
  28 |             2.2.3.Invalid bookmarks...........|NERDTreeInvalidBookmarks|
  29 |         2.3.NERD tree mappings................|NERDTreeMappings|
  30 |         2.4.The NERD tree menu................|NERDTreeMenu|
  31 |     3.Options.................................|NERDTreeOptions|
  32 |         3.1.Option summary....................|NERDTreeOptionSummary|
  33 |         3.2.Option details....................|NERDTreeOptionDetails|
  34 |     4.The NERD tree API.......................|NERDTreeAPI|
  35 |         4.1.Key map API.......................|NERDTreeKeymapAPI|
  36 |         4.2.Menu API..........................|NERDTreeMenuAPI|
  37 |     5.About...................................|NERDTreeAbout|
  38 |     6.Changelog...............................|NERDTreeChangelog|
  39 |     7.Credits.................................|NERDTreeCredits|
  40 |     8.License.................................|NERDTreeLicense|
  41 | 
  42 | ==============================================================================
  43 | 1. Intro                                                            *NERDTree*
  44 | 
  45 | What is this "NERD tree"??
  46 | 
  47 | The NERD tree allows you to explore your filesystem and to open files and
  48 | directories. It presents the filesystem to you in the form of a tree which you
  49 | manipulate with the keyboard and/or mouse. It also allows you to perform
  50 | simple filesystem operations.
  51 | 
  52 | The following features and functionality are provided by the NERD tree:
  53 |     * Files and directories are displayed in a hierarchical tree structure
  54 |     * Different highlighting is provided for the following types of nodes:
  55 |         * files
  56 |         * directories
  57 |         * sym-links
  58 |         * windows .lnk files
  59 |         * read-only files
  60 |         * executable files
  61 |     * Many (customisable) mappings are provided to manipulate the tree:
  62 |         * Mappings to open/close/explore directory nodes
  63 |         * Mappings to open files in new/existing windows/tabs
  64 |         * Mappings to change the current root of the tree
  65 |         * Mappings to navigate around the tree
  66 |         * ...
  67 |     * Directories and files can be bookmarked.
  68 |     * Most NERD tree navigation can also be done with the mouse
  69 |     * Filtering of tree content (can be toggled at runtime)
  70 |         * custom file filters to prevent e.g. vim backup files being displayed
  71 |         * optional displaying of hidden files (. files)
  72 |         * files can be "turned off" so that only directories are displayed
  73 |     * The position and size of the NERD tree window can be customised
  74 |     * The order in which the nodes in the tree are listed can be customised.
  75 |     * A model of your filesystem is created/maintained as you explore it. This
  76 |       has several advantages:
  77 |         * All filesystem information is cached and is only re-read on demand
  78 |         * If you revisit a part of the tree that you left earlier in your
  79 |           session, the directory nodes will be opened/closed as you left them
  80 |     * The script remembers the cursor position and window position in the NERD
  81 |       tree so you can toggle it off (or just close the tree window) and then
  82 |       reopen it (with NERDTreeToggle) the NERD tree window will appear exactly
  83 |       as you left it
  84 |     * You can have a separate NERD tree for each tab, share trees across tabs,
  85 |       or a mix of both.
  86 |     * By default the script overrides the default file browser (netw), so if
  87 |       you :edit a directory a (slighly modified) NERD tree will appear in the
  88 |       current window
  89 |     * A programmable menu system is provided (simulates right clicking on a
  90 |       node)
  91 |         * one default menu plugin is provided to perform basic filesytem
  92 |           operations (create/delete/move/copy files/directories)
  93 |     * There's an API for adding your own keymappings
  94 | 
  95 | 
  96 | ==============================================================================
  97 | 2. Functionality provided                              *NERDTreeFunctionality*
  98 | 
  99 | ------------------------------------------------------------------------------
 100 | 2.1. Global Commands                                  *NERDTreeGlobalCommands*
 101 | 
 102 | :NERDTree [<start-directory> | <bookmark>]                         *:NERDTree*
 103 |     Opens a fresh NERD tree. The root of the tree depends on the argument
 104 |     given. There are 3 cases: If no argument is given, the current directory
 105 |     will be used.  If a directory is given, that will be used. If a bookmark
 106 |     name is given, the corresponding directory will be used.  For example: >
 107 |         :NERDTree /home/marty/vim7/src
 108 |         :NERDTree foo   (foo is the name of a bookmark)
 109 | <
 110 | :NERDTreeFromBookmark <bookmark>                       *:NERDTreeFromBookmark*
 111 |     Opens a fresh NERD tree with the root initialized to the dir for
 112 |     <bookmark>.  This only reason to use this command over :NERDTree is for
 113 |     the completion (which is for bookmarks rather than directories).
 114 | 
 115 | :NERDTreeToggle [<start-directory> | <bookmark>]             *:NERDTreeToggle*
 116 |     If a NERD tree already exists for this tab, it is reopened and rendered
 117 |     again.  If no NERD tree exists for this tab then this command acts the
 118 |     same as the |:NERDTree| command.
 119 | 
 120 | :NERDTreeMirror                                              *:NERDTreeMirror*
 121 |     Shares an existing NERD tree, from another tab, in the current tab.
 122 |     Changes made to one tree are reflected in both as they are actually the
 123 |     same buffer.
 124 | 
 125 |     If only one other NERD tree exists, that tree is automatically mirrored. If
 126 |     more than one exists, the script will ask which tree to mirror.
 127 | 
 128 | :NERDTreeClose                                                *:NERDTreeClose*
 129 |     Close the NERD tree in this tab.
 130 | 
 131 | :NERDTreeFind                                                  *:NERDTreeFind*
 132 |     Find the current file in the tree. If no tree exists for the current tab,
 133 |     or the file is not under the current root, then initialize a new tree where
 134 |     the root is the directory of the current file.
 135 | 
 136 | ------------------------------------------------------------------------------
 137 | 2.2. Bookmarks                                             *NERDTreeBookmarks*
 138 | 
 139 | Bookmarks in the NERD tree are a way to tag files or directories of interest.
 140 | For example, you could use bookmarks to tag all of your project directories.
 141 | 
 142 | ------------------------------------------------------------------------------
 143 | 2.2.1. The Bookmark Table                              *NERDTreeBookmarkTable*
 144 | 
 145 | If the bookmark table is active (see |NERDTree-B| and
 146 | |'NERDTreeShowBookmarks'|), it will be rendered above the tree. You can double
 147 | click bookmarks or use the |NERDTree-o| mapping to activate them. See also,
 148 | |NERDTree-t| and |NERDTree-T|
 149 | 
 150 | ------------------------------------------------------------------------------
 151 | 2.2.2. Bookmark commands                            *NERDTreeBookmarkCommands*
 152 | 
 153 | Note that the following commands are only available in the NERD tree buffer.
 154 | 
 155 | :Bookmark <name>
 156 |     Bookmark the current node as <name>. If there is already a <name>
 157 |     bookmark, it is overwritten. <name> must not contain spaces.
 158 | 
 159 | :BookmarkToRoot <bookmark>
 160 |     Make the directory corresponding to <bookmark> the new root. If a treenode
 161 |     corresponding to <bookmark> is already cached somewhere in the tree then
 162 |     the current tree will be used, otherwise a fresh tree will be opened.
 163 |     Note that if <bookmark> points to a file then its parent will be used
 164 |     instead.
 165 | 
 166 | :RevealBookmark <bookmark>
 167 |     If the node is cached under the current root then it will be revealed
 168 |     (i.e. directory nodes above it will be opened) and the cursor will be
 169 |     placed on it.
 170 | 
 171 | :OpenBookmark <bookmark>
 172 |     <bookmark> must point to a file. The file is opened as though |NERDTree-o|
 173 |     was applied. If the node is cached under the current root then it will be
 174 |     revealed and the cursor will be placed on it.
 175 | 
 176 | :ClearBookmarks [<bookmarks>]
 177 |     Remove all the given bookmarks. If no bookmarks are given then remove all
 178 |     bookmarks on the current node.
 179 | 
 180 | :ClearAllBookmarks
 181 |     Remove all bookmarks.
 182 | 
 183 | :ReadBookmarks
 184 |     Re-read the bookmarks in the |'NERDTreeBookmarksFile'|.
 185 | 
 186 | See also |:NERDTree| and |:NERDTreeFromBookmark|.
 187 | 
 188 | ------------------------------------------------------------------------------
 189 | 2.2.3. Invalid Bookmarks                            *NERDTreeInvalidBookmarks*
 190 | 
 191 | If invalid bookmarks are detected, the script will issue an error message and
 192 | the invalid bookmarks will become unavailable for use.
 193 | 
 194 | These bookmarks will still be stored in the bookmarks file (see
 195 | |'NERDTreeBookmarksFile'|), down the bottom. There will always be a blank line
 196 | after the valid bookmarks but before the invalid ones.
 197 | 
 198 | Each line in the bookmarks file represents one bookmark. The proper format is:
 199 | <bookmark name><space><full path to the bookmark location>
 200 | 
 201 | After you have corrected any invalid bookmarks, either restart vim, or go
 202 | :ReadBookmarks from the NERD tree window.
 203 | 
 204 | ------------------------------------------------------------------------------
 205 | 2.3. NERD tree Mappings                                     *NERDTreeMappings*
 206 | 
 207 | Default  Description~                                             help-tag~
 208 | Key~
 209 | 
 210 | o.......Open files, directories and bookmarks....................|NERDTree-o|
 211 | go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go|
 212 | t.......Open selected node/bookmark in a new tab.................|NERDTree-t|
 213 | T.......Same as 't' but keep the focus on the current tab........|NERDTree-T|
 214 | i.......Open selected file in a split window.....................|NERDTree-i|
 215 | gi......Same as i, but leave the cursor on the NERDTree..........|NERDTree-gi|
 216 | s.......Open selected file in a new vsplit.......................|NERDTree-s|
 217 | gs......Same as s, but leave the cursor on the NERDTree..........|NERDTree-gs|
 218 | O.......Recursively open the selected directory..................|NERDTree-O|
 219 | x.......Close the current nodes parent...........................|NERDTree-x|
 220 | X.......Recursively close all children of the current node.......|NERDTree-X|
 221 | e.......Edit the current dif.....................................|NERDTree-e|
 222 | 
 223 | <CR>...............same as |NERDTree-o|.
 224 | double-click.......same as the |NERDTree-o| map.
 225 | middle-click.......same as |NERDTree-i| for files, same as
 226 |                    |NERDTree-e| for dirs.
 227 | 
 228 | D.......Delete the current bookmark .............................|NERDTree-D|
 229 | 
 230 | P.......Jump to the root node....................................|NERDTree-P|
 231 | p.......Jump to current nodes parent.............................|NERDTree-p|
 232 | K.......Jump up inside directories at the current tree depth.....|NERDTree-K|
 233 | J.......Jump down inside directories at the current tree depth...|NERDTree-J|
 234 | <C-J>...Jump down to the next sibling of the current directory...|NERDTree-C-J|
 235 | <C-K>...Jump up to the previous sibling of the current directory.|NERDTree-C-K|
 236 | 
 237 | C.......Change the tree root to the selected dir.................|NERDTree-C|
 238 | u.......Move the tree root up one directory......................|NERDTree-u|
 239 | U.......Same as 'u' except the old root node is left open........|NERDTree-U|
 240 | r.......Recursively refresh the current directory................|NERDTree-r|
 241 | R.......Recursively refresh the current root.....................|NERDTree-R|
 242 | m.......Display the NERD tree menu...............................|NERDTree-m|
 243 | cd......Change the CWD to the dir of the selected node...........|NERDTree-cd|
 244 | 
 245 | I.......Toggle whether hidden files displayed....................|NERDTree-I|
 246 | f.......Toggle whether the file filters are used.................|NERDTree-f|
 247 | F.......Toggle whether files are displayed.......................|NERDTree-F|
 248 | B.......Toggle whether the bookmark table is displayed...........|NERDTree-B|
 249 | 
 250 | q.......Close the NERDTree window................................|NERDTree-q|
 251 | A.......Zoom (maximize/minimize) the NERDTree window.............|NERDTree-A|
 252 | ?.......Toggle the display of the quick help.....................|NERDTree-?|
 253 | 
 254 | ------------------------------------------------------------------------------
 255 |                                                                   *NERDTree-o*
 256 | Default key: o
 257 | Map option: NERDTreeMapActivateNode
 258 | Applies to: files and directories.
 259 | 
 260 | If a file node is selected, it is opened in the previous window.
 261 | 
 262 | If a directory is selected it is opened or closed depending on its current
 263 | state.
 264 | 
 265 | If a bookmark that links to a directory is selected then that directory
 266 | becomes the new root.
 267 | 
 268 | If a bookmark that links to a file is selected then that file is opened in the
 269 | previous window.
 270 | 
 271 | ------------------------------------------------------------------------------
 272 |                                                                  *NERDTree-go*
 273 | Default key: go
 274 | Map option: None
 275 | Applies to: files.
 276 | 
 277 | If a file node is selected, it is opened in the previous window, but the
 278 | cursor does not move.
 279 | 
 280 | The key combo for this mapping is always "g" + NERDTreeMapActivateNode (see
 281 | |NERDTree-o|).
 282 | 
 283 | ------------------------------------------------------------------------------
 284 |                                                                   *NERDTree-t*
 285 | Default key: t
 286 | Map option: NERDTreeMapOpenInTab
 287 | Applies to: files and directories.
 288 | 
 289 | Opens the selected file in a new tab. If a directory is selected, a fresh
 290 | NERD Tree for that directory is opened in a new tab.
 291 | 
 292 | If a bookmark which points to a directory is selected, open a NERD tree for
 293 | that directory in a new tab. If the bookmark points to a file, open that file
 294 | in a new tab.
 295 | 
 296 | ------------------------------------------------------------------------------
 297 |                                                                   *NERDTree-T*
 298 | Default key: T
 299 | Map option: NERDTreeMapOpenInTabSilent
 300 | Applies to: files and directories.
 301 | 
 302 | The same as |NERDTree-t| except that the focus is kept in the current tab.
 303 | 
 304 | ------------------------------------------------------------------------------
 305 |                                                                   *NERDTree-i*
 306 | Default key: i
 307 | Map option: NERDTreeMapOpenSplit
 308 | Applies to: files.
 309 | 
 310 | Opens the selected file in a new split window and puts the cursor in the new
 311 | window.
 312 | 
 313 | ------------------------------------------------------------------------------
 314 |                                                                  *NERDTree-gi*
 315 | Default key: gi
 316 | Map option: None
 317 | Applies to: files.
 318 | 
 319 | The same as |NERDTree-i| except that the cursor is not moved.
 320 | 
 321 | The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see
 322 | |NERDTree-i|).
 323 | 
 324 | ------------------------------------------------------------------------------
 325 |                                                                   *NERDTree-s*
 326 | Default key: s
 327 | Map option: NERDTreeMapOpenVSplit
 328 | Applies to: files.
 329 | 
 330 | Opens the selected file in a new vertically split window and puts the cursor in
 331 | the new window.
 332 | 
 333 | ------------------------------------------------------------------------------
 334 |                                                                  *NERDTree-gs*
 335 | Default key: gs
 336 | Map option: None
 337 | Applies to: files.
 338 | 
 339 | The same as |NERDTree-s| except that the cursor is not moved.
 340 | 
 341 | The key combo for this mapping is always "g" + NERDTreeMapOpenVSplit (see
 342 | |NERDTree-s|).
 343 | 
 344 | ------------------------------------------------------------------------------
 345 |                                                                   *NERDTree-O*
 346 | Default key: O
 347 | Map option: NERDTreeMapOpenRecursively
 348 | Applies to: directories.
 349 | 
 350 | Recursively opens the selelected directory.
 351 | 
 352 | All files and directories are cached, but if a directory would not be
 353 | displayed due to file filters (see |'NERDTreeIgnore'| |NERDTree-f|) or the
 354 | hidden file filter (see |'NERDTreeShowHidden'|) then its contents are not
 355 | cached. This is handy, especially if you have .svn directories.
 356 | 
 357 | ------------------------------------------------------------------------------
 358 |                                                                   *NERDTree-x*
 359 | Default key: x
 360 | Map option: NERDTreeMapCloseDir
 361 | Applies to: files and directories.
 362 | 
 363 | Closes the parent of the selected node.
 364 | 
 365 | ------------------------------------------------------------------------------
 366 |                                                                   *NERDTree-X*
 367 | Default key: X
 368 | Map option: NERDTreeMapCloseChildren
 369 | Applies to: directories.
 370 | 
 371 | Recursively closes all children of the selected directory.
 372 | 
 373 | Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping.
 374 | 
 375 | ------------------------------------------------------------------------------
 376 |                                                                   *NERDTree-e*
 377 | Default key: e
 378 | Map option: NERDTreeMapOpenExpl
 379 | Applies to: files and directories.
 380 | 
 381 | |:edit|s the selected directory, or the selected file's directory. This could
 382 | result in a NERD tree or a netrw being opened, depending on
 383 | |'NERDTreeHijackNetrw'|.
 384 | 
 385 | ------------------------------------------------------------------------------
 386 |                                                                   *NERDTree-D*
 387 | Default key: D
 388 | Map option: NERDTreeMapDeleteBookmark
 389 | Applies to: lines in the bookmarks table
 390 | 
 391 | Deletes the currently selected bookmark.
 392 | 
 393 | ------------------------------------------------------------------------------
 394 |                                                                   *NERDTree-P*
 395 | Default key: P
 396 | Map option: NERDTreeMapJumpRoot
 397 | Applies to: no restrictions.
 398 | 
 399 | Jump to the tree root.
 400 | 
 401 | ------------------------------------------------------------------------------
 402 |                                                                   *NERDTree-p*
 403 | Default key: p
 404 | Map option: NERDTreeMapJumpParent
 405 | Applies to: files and directories.
 406 | 
 407 | Jump to the parent node of the selected node.
 408 | 
 409 | ------------------------------------------------------------------------------
 410 |                                                                   *NERDTree-K*
 411 | Default key: K
 412 | Map option: NERDTreeMapJumpFirstChild
 413 | Applies to: files and directories.
 414 | 
 415 | Jump to the first child of the current nodes parent.
 416 | 
 417 | If the cursor is already on the first node then do the following:
 418 |     * loop back thru the siblings of the current nodes parent until we find an
 419 |       open dir with children
 420 |     * go to the first child of that node
 421 | 
 422 | ------------------------------------------------------------------------------
 423 |                                                                   *NERDTree-J*
 424 | Default key: J
 425 | Map option: NERDTreeMapJumpLastChild
 426 | Applies to: files and directories.
 427 | 
 428 | Jump to the last child of the current nodes parent.
 429 | 
 430 | If the cursor is already on the last node then do the following:
 431 |     * loop forward thru the siblings of the current nodes parent until we find
 432 |       an open dir with children
 433 |     * go to the last child of that node
 434 | 
 435 | ------------------------------------------------------------------------------
 436 |                                                                 *NERDTree-C-J*
 437 | Default key: <C-J>
 438 | Map option: NERDTreeMapJumpNextSibling
 439 | Applies to: files and directories.
 440 | 
 441 | Jump to the next sibling of the selected node.
 442 | 
 443 | ------------------------------------------------------------------------------
 444 |                                                                 *NERDTree-C-K*
 445 | Default key: <C-K>
 446 | Map option: NERDTreeMapJumpPrevSibling
 447 | Applies to: files and directories.
 448 | 
 449 | Jump to the previous sibling of the selected node.
 450 | 
 451 | ------------------------------------------------------------------------------
 452 |                                                                   *NERDTree-C*
 453 | Default key: C
 454 | Map option: NERDTreeMapChdir
 455 | Applies to: directories.
 456 | 
 457 | Make the selected directory node the new tree root. If a file is selected, its
 458 | parent is used.
 459 | 
 460 | ------------------------------------------------------------------------------
 461 |                                                                   *NERDTree-u*
 462 | Default key: u
 463 | Map option: NERDTreeMapUpdir
 464 | Applies to: no restrictions.
 465 | 
 466 | Move the tree root up a dir (like doing a "cd ..").
 467 | 
 468 | ------------------------------------------------------------------------------
 469 |                                                                   *NERDTree-U*
 470 | Default key: U
 471 | Map option: NERDTreeMapUpdirKeepOpen
 472 | Applies to: no restrictions.
 473 | 
 474 | Like |NERDTree-u| except that the old tree root is kept open.
 475 | 
 476 | ------------------------------------------------------------------------------
 477 |                                                                   *NERDTree-r*
 478 | Default key: r
 479 | Map option: NERDTreeMapRefresh
 480 | Applies to: files and directories.
 481 | 
 482 | If a dir is selected, recursively refresh that dir, i.e. scan the filesystem
 483 | for changes and represent them in the tree.
 484 | 
 485 | If a file node is selected then the above is done on it's parent.
 486 | 
 487 | ------------------------------------------------------------------------------
 488 |                                                                   *NERDTree-R*
 489 | Default key: R
 490 | Map option: NERDTreeMapRefreshRoot
 491 | Applies to: no restrictions.
 492 | 
 493 | Recursively refresh the tree root.
 494 | 
 495 | ------------------------------------------------------------------------------
 496 |                                                                   *NERDTree-m*
 497 | Default key: m
 498 | Map option: NERDTreeMapMenu
 499 | Applies to: files and directories.
 500 | 
 501 | Display the NERD tree menu. See |NERDTreeMenu| for details.
 502 | 
 503 | ------------------------------------------------------------------------------
 504 |                                                                  *NERDTree-cd*
 505 | Default key: cd
 506 | Map option: NERDTreeMapChdir
 507 | Applies to: files and directories.
 508 | 
 509 | Change vims current working directory to that of the selected node.
 510 | 
 511 | ------------------------------------------------------------------------------
 512 |                                                                   *NERDTree-I*
 513 | Default key: I
 514 | Map option: NERDTreeMapToggleHidden
 515 | Applies to: no restrictions.
 516 | 
 517 | Toggles whether hidden files (i.e. "dot files") are displayed.
 518 | 
 519 | ------------------------------------------------------------------------------
 520 |                                                                   *NERDTree-f*
 521 | Default key: f
 522 | Map option: NERDTreeMapToggleFilters
 523 | Applies to: no restrictions.
 524 | 
 525 | Toggles whether file filters are used. See |'NERDTreeIgnore'| for details.
 526 | 
 527 | ------------------------------------------------------------------------------
 528 |                                                                   *NERDTree-F*
 529 | Default key: F
 530 | Map option: NERDTreeMapToggleFiles
 531 | Applies to: no restrictions.
 532 | 
 533 | Toggles whether file nodes are displayed.
 534 | 
 535 | ------------------------------------------------------------------------------
 536 |                                                                   *NERDTree-B*
 537 | Default key: B
 538 | Map option: NERDTreeMapToggleBookmarks
 539 | Applies to: no restrictions.
 540 | 
 541 | Toggles whether the bookmarks table is displayed.
 542 | 
 543 | ------------------------------------------------------------------------------
 544 |                                                                   *NERDTree-q*
 545 | Default key: q
 546 | Map option: NERDTreeMapQuit
 547 | Applies to: no restrictions.
 548 | 
 549 | Closes the NERDtree window.
 550 | 
 551 | ------------------------------------------------------------------------------
 552 |                                                                   *NERDTree-A*
 553 | Default key: A
 554 | Map option: NERDTreeMapToggleZoom
 555 | Applies to: no restrictions.
 556 | 
 557 | Maximize (zoom) and minimize the NERDtree window.
 558 | 
 559 | ------------------------------------------------------------------------------
 560 |                                                                   *NERDTree-?*
 561 | Default key: ?
 562 | Map option: NERDTreeMapHelp
 563 | Applies to: no restrictions.
 564 | 
 565 | Toggles whether the quickhelp is displayed.
 566 | 
 567 | ------------------------------------------------------------------------------
 568 | 2.3. The NERD tree menu                                         *NERDTreeMenu*
 569 | 
 570 | The NERD tree has a menu that can be programmed via the an API (see
 571 | |NERDTreeMenuAPI|). The idea is to simulate the "right click" menus that most
 572 | file explorers have.
 573 | 
 574 | The script comes with two default menu plugins: exec_menuitem.vim and
 575 | fs_menu.vim. fs_menu.vim adds some basic filesystem operations to the menu for
 576 | creating/deleting/moving/copying files and dirs. exec_menuitem.vim provides a
 577 | menu item to execute executable files.
 578 | 
 579 | Related tags: |NERDTree-m| |NERDTreeApi|
 580 | 
 581 | ==============================================================================
 582 | 3. Customisation                                             *NERDTreeOptions*
 583 | 
 584 | 
 585 | ------------------------------------------------------------------------------
 586 | 3.1. Customisation summary                             *NERDTreeOptionSummary*
 587 | 
 588 | The script provides the following options that can customise the behaviour the
 589 | NERD tree. These options should be set in your vimrc.
 590 | 
 591 | |'loaded_nerd_tree'|            Turns off the script.
 592 | 
 593 | |'NERDChristmasTree'|           Tells the NERD tree to make itself colourful
 594 |                                 and pretty.
 595 | 
 596 | |'NERDTreeAutoCenter'|          Controls whether the NERD tree window centers
 597 |                                 when the cursor moves within a specified
 598 |                                 distance to the top/bottom of the window.
 599 | |'NERDTreeAutoCenterThreshold'| Controls the sensitivity of autocentering.
 600 | 
 601 | |'NERDTreeCaseSensitiveSort'|   Tells the NERD tree whether to be case
 602 |                                 sensitive or not when sorting nodes.
 603 | 
 604 | |'NERDTreeChDirMode'|           Tells the NERD tree if/when it should change
 605 |                                 vim's current working directory.
 606 | 
 607 | |'NERDTreeHighlightCursorline'| Tell the NERD tree whether to highlight the
 608 |                                 current cursor line.
 609 | 
 610 | |'NERDTreeHijackNetrw'|         Tell the NERD tree whether to replace the netrw
 611 |                                 autocommands for exploring local directories.
 612 | 
 613 | |'NERDTreeIgnore'|              Tells the NERD tree which files to ignore.
 614 | 
 615 | |'NERDTreeBookmarksFile'|       Where the bookmarks are stored.
 616 | 
 617 | |'NERDTreeMouseMode'|           Tells the NERD tree how to handle mouse
 618 |                                 clicks.
 619 | 
 620 | |'NERDTreeQuitOnOpen'|          Closes the tree window after opening a file.
 621 | 
 622 | |'NERDTreeShowBookmarks'|       Tells the NERD tree whether to display the
 623 |                                 bookmarks table on startup.
 624 | 
 625 | |'NERDTreeShowFiles'|           Tells the NERD tree whether to display files
 626 |                                 in the tree on startup.
 627 | 
 628 | |'NERDTreeShowHidden'|          Tells the NERD tree whether to display hidden
 629 |                                 files on startup.
 630 | 
 631 | |'NERDTreeShowLineNumbers'|     Tells the NERD tree whether to display line
 632 |                                 numbers in the tree window.
 633 | 
 634 | |'NERDTreeSortOrder'|           Tell the NERD tree how to sort the nodes in
 635 |                                 the tree.
 636 | 
 637 | |'NERDTreeStatusline'|          Set a statusline for NERD tree windows.
 638 | 
 639 | |'NERDTreeWinPos'|              Tells the script where to put the NERD tree
 640 |                                 window.
 641 | 
 642 | |'NERDTreeWinSize'|             Sets the window size when the NERD tree is
 643 |                                 opened.
 644 | 
 645 | |'NERDTreeMinimalUI'|           Disables display of the 'Bookmarks' label and 
 646 |                                 'Press ? for help' text.
 647 | 
 648 | |'NERDTreeDirArrows'|           Tells the NERD tree to use arrows instead of
 649 |                                 + ~ chars when displaying directories.
 650 | 
 651 | ------------------------------------------------------------------------------
 652 | 3.2. Customisation details                             *NERDTreeOptionDetails*
 653 | 
 654 | To enable any of the below options you should put the given line in your
 655 | ~/.vimrc
 656 | 
 657 |                                                           *'loaded_nerd_tree'*
 658 | If this plugin is making you feel homicidal, it may be a good idea to turn it
 659 | off with this line in your vimrc: >
 660 |     let loaded_nerd_tree=1
 661 | <
 662 | ------------------------------------------------------------------------------
 663 |                                                          *'NERDChristmasTree'*
 664 | Values: 0 or 1.
 665 | Default: 1.
 666 | 
 667 | If this option is set to 1 then some extra syntax highlighting elements are
 668 | added to the nerd tree to make it more colourful.
 669 | 
 670 | Set it to 0 for a more vanilla looking tree.
 671 | 
 672 | ------------------------------------------------------------------------------
 673 |                                                         *'NERDTreeAutoCenter'*
 674 | Values: 0 or 1.
 675 | Default: 1
 676 | 
 677 | If set to 1, the NERD tree window will center around the cursor if it moves to
 678 | within |'NERDTreeAutoCenterThreshold'| lines of the top/bottom of the window.
 679 | 
 680 | This is ONLY done in response to tree navigation mappings,
 681 | i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-C-K| |NERDTree-p|
 682 | |NERDTree-P|
 683 | 
 684 | The centering is done with a |zz| operation.
 685 | 
 686 | ------------------------------------------------------------------------------
 687 |                                                *'NERDTreeAutoCenterThreshold'*
 688 | Values: Any natural number.
 689 | Default: 3
 690 | 
 691 | This option controls the "sensitivity" of the NERD tree auto centering. See
 692 | |'NERDTreeAutoCenter'| for details.
 693 | 
 694 | ------------------------------------------------------------------------------
 695 |                                                  *'NERDTreeCaseSensitiveSort'*
 696 | Values: 0 or 1.
 697 | Default: 0.
 698 | 
 699 | By default the NERD tree does not sort nodes case sensitively, i.e. nodes
 700 | could appear like this: >
 701 |     bar.c
 702 |     Baz.c
 703 |     blarg.c
 704 |     boner.c
 705 |     Foo.c
 706 | <
 707 | But, if you set this option to 1 then the case of the nodes will be taken into
 708 | account. The above nodes would then be sorted like this: >
 709 |     Baz.c
 710 |     Foo.c
 711 |     bar.c
 712 |     blarg.c
 713 |     boner.c
 714 | <
 715 | ------------------------------------------------------------------------------
 716 |                                                          *'NERDTreeChDirMode'*
 717 | 
 718 | Values: 0, 1 or 2.
 719 | Default: 0.
 720 | 
 721 | Use this option to tell the script when (if at all) to change the current
 722 | working directory (CWD) for vim.
 723 | 
 724 | If it is set to 0 then the CWD is never changed by the NERD tree.
 725 | 
 726 | If set to 1 then the CWD is changed when the NERD tree is first loaded to the
 727 | directory it is initialized in. For example, if you start the NERD tree with >
 728 |     :NERDTree /home/marty/foobar
 729 | <
 730 | then the CWD will be changed to /home/marty/foobar and will not be changed
 731 | again unless you init another NERD tree with a similar command.
 732 | 
 733 | If the option is set to 2 then it behaves the same as if set to 1 except that
 734 | the CWD is changed whenever the tree root is changed. For example, if the CWD
 735 | is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new
 736 | root then the CWD will become /home/marty/foobar/baz.
 737 | 
 738 | ------------------------------------------------------------------------------
 739 |                                                *'NERDTreeHighlightCursorline'*
 740 | Values: 0 or 1.
 741 | Default: 1.
 742 | 
 743 | If set to 1, the current cursor line in the NERD tree buffer will be
 744 | highlighted. This is done using the |'cursorline'| option.
 745 | 
 746 | ------------------------------------------------------------------------------
 747 |                                                        *'NERDTreeHijackNetrw'*
 748 | Values: 0 or 1.
 749 | Default: 1.
 750 | 
 751 | If set to 1, doing a >
 752 |     :edit <some directory>
 753 | <
 754 | will open up a "secondary" NERD tree instead of a netrw in the target window.
 755 | 
 756 | Secondary NERD trees behaves slighly different from a regular trees in the
 757 | following respects:
 758 |     1. 'o' will open the selected file in the same window as the tree,
 759 |        replacing it.
 760 |     2. you can have as many secondary tree as you want in the same tab.
 761 | 
 762 | ------------------------------------------------------------------------------
 763 |                                                             *'NERDTreeIgnore'*
 764 | Values: a list of regular expressions.
 765 | Default: ['\~$'].
 766 | 
 767 | This option is used to specify which files the NERD tree should ignore.  It
 768 | must be a list of regular expressions. When the NERD tree is rendered, any
 769 | files/dirs that match any of the regex's in 'NERDTreeIgnore' wont be
 770 | displayed.
 771 | 
 772 | For example if you put the following line in your vimrc: >
 773 |     let NERDTreeIgnore=['\.vim$', '\~$']
 774 | <
 775 | then all files ending in .vim or ~ will be ignored.
 776 | 
 777 | Note: to tell the NERD tree not to ignore any files you must use the following
 778 | line: >
 779 |     let NERDTreeIgnore=[]
 780 | <
 781 | 
 782 | The file filters can be turned on and off dynamically with the |NERDTree-f|
 783 | mapping.
 784 | 
 785 | ------------------------------------------------------------------------------
 786 |                                                      *'NERDTreeBookmarksFile'*
 787 | Values: a path
 788 | Default: $HOME/.NERDTreeBookmarks
 789 | 
 790 | This is where bookmarks are saved. See |NERDTreeBookmarkCommands|.
 791 | 
 792 | ------------------------------------------------------------------------------
 793 |                                                        *'NERDTreeMouseMode'*
 794 | Values: 1, 2 or 3.
 795 | Default: 1.
 796 | 
 797 | If set to 1 then a double click on a node is required to open it.
 798 | If set to 2 then a single click will open directory nodes, while a double
 799 | click will still be required for file nodes.
 800 | If set to 3 then a single click will open any node.
 801 | 
 802 | Note: a double click anywhere on a line that a tree node is on will
 803 | activate it, but all single-click activations must be done on name of the node
 804 | itself. For example, if you have the following node: >
 805 |     | | |-application.rb
 806 | <
 807 | then (to single click activate it) you must click somewhere in
 808 | 'application.rb'.
 809 | 
 810 | ------------------------------------------------------------------------------
 811 |                                                         *'NERDTreeQuitOnOpen'*
 812 | 
 813 | Values: 0 or 1.
 814 | Default: 0
 815 | 
 816 | If set to 1, the NERD tree window will close after opening a file with the
 817 | |NERDTree-o|, |NERDTree-i|, |NERDTree-t| and |NERDTree-T| mappings.
 818 | 
 819 | ------------------------------------------------------------------------------
 820 |                                                      *'NERDTreeShowBookmarks'*
 821 | Values: 0 or 1.
 822 | Default: 0.
 823 | 
 824 | If this option is set to 1 then the bookmarks table will be displayed.
 825 | 
 826 | This option can be toggled dynamically, per tree, with the |NERDTree-B|
 827 | mapping.
 828 | 
 829 | ------------------------------------------------------------------------------
 830 |                                                          *'NERDTreeShowFiles'*
 831 | Values: 0 or 1.
 832 | Default: 1.
 833 | 
 834 | If this option is set to 1 then files are displayed in the NERD tree. If it is
 835 | set to 0 then only directories are displayed.
 836 | 
 837 | This option can be toggled dynamically, per tree, with the |NERDTree-F|
 838 | mapping and is useful for drastically shrinking the tree when you are
 839 | navigating to a different part of the tree.
 840 | 
 841 | ------------------------------------------------------------------------------
 842 |                                                         *'NERDTreeShowHidden'*
 843 | Values: 0 or 1.
 844 | Default: 0.
 845 | 
 846 | This option tells vim whether to display hidden files by default. This option
 847 | can be dynamically toggled, per tree, with the |NERDTree-I| mapping.  Use one
 848 | of the follow lines to set this option: >
 849 |     let NERDTreeShowHidden=0
 850 |     let NERDTreeShowHidden=1
 851 | <
 852 | 
 853 | ------------------------------------------------------------------------------
 854 |                                                    *'NERDTreeShowLineNumbers'*
 855 | Values: 0 or 1.
 856 | Default: 0.
 857 | 
 858 | This option tells vim whether to display line numbers for the NERD tree
 859 | window.  Use one of the follow lines to set this option: >
 860 |     let NERDTreeShowLineNumbers=0
 861 |     let NERDTreeShowLineNumbers=1
 862 | <
 863 | 
 864 | ------------------------------------------------------------------------------
 865 |                                                          *'NERDTreeSortOrder'*
 866 | Values: a list of regular expressions.
 867 | Default: ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
 868 | 
 869 | This option is set to a list of regular expressions which are used to
 870 | specify the order of nodes under their parent.
 871 | 
 872 | For example, if the option is set to: >
 873 |     ['\.vim$', '\.c$', '\.h$', '*', 'foobar']
 874 | <
 875 | then all .vim files will be placed at the top, followed by all .c files then
 876 | all .h files. All files containing the string 'foobar' will be placed at the
 877 | end.  The star is a special flag: it tells the script that every node that
 878 | doesnt match any of the other regexps should be placed here.
 879 | 
 880 | If no star is present in 'NERDTreeSortOrder' then one is automatically
 881 | appended to the array.
 882 | 
 883 | The regex '\/$' should be used to match directory nodes.
 884 | 
 885 | After this sorting is done, the files in each group are sorted alphabetically.
 886 | 
 887 | Other examples: >
 888 |     (1) ['*', '\/$']
 889 |     (2) []
 890 |     (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$',  '\.bak$', '\~$']
 891 | <
 892 | 1. Directories will appear last, everything else will appear above.
 893 | 2. Everything will simply appear in alphabetical order.
 894 | 3. Dirs will appear first, then ruby and php. Swap files, bak files and vim
 895 |    backup files will appear last with everything else preceding them.
 896 | 
 897 | ------------------------------------------------------------------------------
 898 |                                                         *'NERDTreeStatusline'*
 899 | Values: Any valid statusline setting.
 900 | Default: %{b:NERDTreeRoot.path.strForOS(0)}
 901 | 
 902 | Tells the script what to use as the |'statusline'| setting for NERD tree
 903 | windows.
 904 | 
 905 | Note that the statusline is set using |:let-&| not |:set| so escaping spaces
 906 | isn't necessary.
 907 | 
 908 | Setting this option to -1 will will deactivate it so that your global
 909 | statusline setting is used instead.
 910 | 
 911 | ------------------------------------------------------------------------------
 912 |                                                             *'NERDTreeWinPos'*
 913 | Values: "left" or "right"
 914 | Default: "left".
 915 | 
 916 | This option is used to determine where NERD tree window is placed on the
 917 | screen.
 918 | 
 919 | This option makes it possible to use two different explorer plugins
 920 | simultaneously. For example, you could have the taglist plugin on the left of
 921 | the window and the NERD tree on the right.
 922 | 
 923 | ------------------------------------------------------------------------------
 924 |                                                            *'NERDTreeWinSize'*
 925 | Values: a positive integer.
 926 | Default: 31.
 927 | 
 928 | This option is used to change the size of the NERD tree when it is loaded.
 929 | 
 930 | ------------------------------------------------------------------------------
 931 |                                                          *'NERDTreeMinimalUI'*
 932 | Values: 0 or 1
 933 | Default: 0
 934 | 
 935 | This options disables the 'Bookmarks' label 'Press ? for help' text. Use one
 936 | of the following lines to set this option: >
 937 |     let NERDTreeMinimalUI=0
 938 |     let NERDTreeMinimalUI=1
 939 | <
 940 | 
 941 | ------------------------------------------------------------------------------
 942 |                                                            *'NERDTreeDirArrows'*
 943 | Values: 0 or 1
 944 | Default: 0.
 945 | 
 946 | This option is used to change the default look of directory nodes displayed in
 947 | the tree. When set to 0 it shows old-school bars (|), + and ~ chars. If set to
 948 | 1 it shows right and down arrows.  Use one of the follow lines to set this
 949 | option: >
 950 |     let NERDTreeDirArrows=0
 951 |     let NERDTreeDirArrows=1
 952 | <
 953 | 
 954 | ==============================================================================
 955 | 4. The NERD tree API                                             *NERDTreeAPI*
 956 | 
 957 | The NERD tree script allows you to add custom key mappings and menu items via
 958 | a set of API calls. Any scripts that use this API should be placed in
 959 | ~/.vim/nerdtree_plugin/ (*nix) or ~/vimfiles/nerdtree_plugin (windows).
 960 | 
 961 | The script exposes some prototype objects that can be used to manipulate the
 962 | tree and/or get information from it: >
 963 |     g:NERDTreePath
 964 |     g:NERDTreeDirNode
 965 |     g:NERDTreeFileNode
 966 |     g:NERDTreeBookmark
 967 | <
 968 | See the code/comments in NERD_tree.vim to find how to use these objects. The
 969 | following code conventions are used:
 970 |     * class members start with a capital letter
 971 |     * instance members start with a lower case letter
 972 |     * private members start with an underscore
 973 | 
 974 | See this blog post for more details:
 975 |  http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html
 976 | 
 977 | ------------------------------------------------------------------------------
 978 | 4.1. Key map API                                           *NERDTreeKeymapAPI*
 979 | 
 980 | NERDTreeAddKeyMap({options})                             *NERDTreeAddKeyMap()*
 981 |     Adds a new keymapping for all NERD tree buffers.
 982 |     {options} must be a dictionary, and must contain the following keys:
 983 |     "key" - the trigger key for the new mapping
 984 |     "callback" - the function the new mapping will be bound to
 985 |     "quickhelpText" - the text that will appear in the quickhelp (see
 986 |     |NERDTree-?|)
 987 | 
 988 |     Example: >
 989 |         call NERDTreeAddKeyMap({
 990 |                \ 'key': 'b',
 991 |                \ 'callback': 'NERDTreeEchoCurrentNode',
 992 |                \ 'quickhelpText': 'echo full path of current node' })
 993 | 
 994 |         function! NERDTreeEchoCurrentNode()
 995 |             let n = g:NERDTreeFileNode.GetSelected()
 996 |             if n != {}
 997 |                 echomsg 'Current node: ' . n.path.str()
 998 |             endif
 999 |         endfunction
1000 | <
1001 |     This code should sit in a file like ~/.vim/nerdtree_plugin/mymapping.vim.
1002 |     It adds a (rather useless) mapping on 'b' which echos the full path to the
1003 |     current node.
1004 | 
1005 | ------------------------------------------------------------------------------
1006 | 4.2. Menu API                                                *NERDTreeMenuAPI*
1007 | 
1008 | NERDTreeAddSubmenu({options})                           *NERDTreeAddSubmenu()*
1009 |     Creates and returns a new submenu.
1010 | 
1011 |     {options} must be a dictionary and must contain the following keys:
1012 |     "text" - the text of the submenu that the user will see
1013 |     "shortcut" - a shortcut key for the submenu (need not be unique)
1014 | 
1015 |     The following keys are optional:
1016 |     "isActiveCallback" - a function that will be called to determine whether
1017 |     this submenu item will be displayed or not. The callback function must return
1018 |     0 or 1.
1019 |     "parent" - the parent submenu of the new submenu (returned from a previous
1020 |     invocation of NERDTreeAddSubmenu()). If this key is left out then the new
1021 |     submenu will sit under the top level menu.
1022 | 
1023 |     See below for an example.
1024 | 
1025 | NERDTreeAddMenuItem({options})                         *NERDTreeAddMenuItem()*
1026 |     Adds a new menu item to the NERD tree menu (see |NERDTreeMenu|).
1027 | 
1028 |     {options} must be a dictionary and must contain the
1029 |     following keys:
1030 |     "text" - the text of the menu item which the user will see
1031 |     "shortcut" - a shortcut key for the menu item (need not be unique)
1032 |     "callback" - the function that will be called when the user activates the
1033 |     menu item.
1034 | 
1035 |     The following keys are optional:
1036 |     "isActiveCallback" - a function that will be called to determine whether
1037 |     this menu item will be displayed or not. The callback function must return
1038 |     0 or 1.
1039 |     "parent" - if the menu item belongs under a submenu then this key must be
1040 |     specified. This value for this key will be the object that
1041 |     was returned when the submenu was created with |NERDTreeAddSubmenu()|.
1042 | 
1043 |     See below for an example.
1044 | 
1045 | NERDTreeAddMenuSeparator([{options}])             *NERDTreeAddMenuSeparator()*
1046 |     Adds a menu separator (a row of dashes).
1047 | 
1048 |     {options} is an optional dictionary that may contain the following keys:
1049 |     "isActiveCallback" - see description in |NERDTreeAddMenuItem()|.
1050 | 
1051 | Below is an example of the menu API in action. >
1052 |     call NERDTreeAddMenuSeparator()
1053 | 
1054 |     call NERDTreeAddMenuItem({
1055 |                 \ 'text': 'a (t)op level menu item',
1056 |                 \ 'shortcut': 't',
1057 |                 \ 'callback': 'SomeFunction' })
1058 | 
1059 |     let submenu = NERDTreeAddSubmenu({
1060 |                 \ 'text': 'a (s)ub menu',
1061 |                 \ 'shortcut': 's' })
1062 | 
1063 |     call NERDTreeAddMenuItem({
1064 |                 \ 'text': '(n)ested item 1',
1065 |                 \ 'shortcut': 'n',
1066 |                 \ 'callback': 'SomeFunction',
1067 |                 \ 'parent': submenu })
1068 | 
1069 |     call NERDTreeAddMenuItem({
1070 |                 \ 'text': '(n)ested item 2',
1071 |                 \ 'shortcut': 'n',
1072 |                 \ 'callback': 'SomeFunction',
1073 |                 \ 'parent': submenu })
1074 | <
1075 | This will create the following menu: >
1076 |   --------------------
1077 |   a (t)op level menu item
1078 |   a (s)ub menu
1079 | <
1080 | Where selecting "a (s)ub menu" will lead to a second menu: >
1081 |   (n)ested item 1
1082 |   (n)ested item 2
1083 | <
1084 | When any of the 3 concrete menu items are selected the function "SomeFunction"
1085 | will be called.
1086 | 
1087 | ------------------------------------------------------------------------------
1088 | NERDTreeRender()                                            *NERDTreeRender()*
1089 |     Re-renders the NERD tree buffer. Useful if you change the state of the
1090 |     tree and you want to it to be reflected in the UI.
1091 | 
1092 | ==============================================================================
1093 | 5. About                                                       *NERDTreeAbout*
1094 | 
1095 | The author of the NERD tree is a terrible terrible monster called Martyzilla
1096 | who gobbles up small children with milk and sugar for breakfast.
1097 | 
1098 | He can be reached at martin.grenfell at gmail dot com. He would love to hear
1099 | from you, so feel free to send him suggestions and/or comments about this
1100 | plugin.  Don't be shy --- the worst he can do is slaughter you and stuff you in
1101 | the fridge for later ;)
1102 | 
1103 | The latest stable versions can be found at
1104 |     http://www.vim.org/scripts/script.php?script_id=1658
1105 | 
1106 | The latest dev versions are on github
1107 |     http://github.com/scrooloose/nerdtree
1108 | 
1109 | 
1110 | ==============================================================================
1111 | 6. Changelog                                               *NERDTreeChangelog*
1112 | 
1113 | 4.x.x
1114 |     - Fix a bug with :NERDTreeFind and symlinks. Thanks to Vitaly Bogdanov.
1115 | 
1116 | 4.1.0
1117 |     features:
1118 |     - NERDTreeFind to reveal the node for the current buffer in the tree,
1119 |       see |NERDTreeFind|. This effectively merges the FindInNERDTree plugin (by
1120 |       Doug McInnes) into the script.
1121 |     - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to Stefan
1122 |       Ritter and Rémi Prévost.
1123 |     - truncate the root node if wider than the tree window. Thanks to Victor
1124 |       Gonzalez.
1125 | 
1126 |     bugfixes:
1127 |     - really fix window state restoring
1128 |     - fix some win32 path escaping issues. Thanks to Stephan Baumeister, Ricky,
1129 |       jfilip1024, and Chris Chambers
1130 | 
1131 | 4.0.0
1132 |     - add a new programmable menu system (see :help NERDTreeMenu).
1133 |     - add new APIs to add menus/menu-items to the menu system as well as
1134 |       custom key mappings to the NERD tree buffer (see :help NERDTreeAPI).
1135 |     - removed the old API functions
1136 |     - added a mapping to maximize/restore the size of nerd tree window, thanks
1137 |       to Guillaume Duranceau for the patch. See :help NERDTree-A for details.
1138 | 
1139 |     - fix a bug where secondary nerd trees (netrw hijacked trees) and
1140 |       NERDTreeQuitOnOpen didnt play nicely, thanks to Curtis Harvey.
1141 |     - fix a bug where the script ignored directories whose name ended in a dot,
1142 |       thanks to Aggelos Orfanakos for the patch.
1143 |     - fix a bug when using the x mapping on the tree root, thanks to Bryan
1144 |       Venteicher for the patch.
1145 |     - fix a bug where the cursor position/window size of the nerd tree buffer
1146 |       wasnt being stored on closing the window, thanks to Richard Hart.
1147 |     - fix a bug where NERDTreeMirror would mirror the wrong tree
1148 | 
1149 | 3.1.1
1150 |     - fix a bug where a non-listed no-name buffer was getting created every
1151 |       time the tree windows was created, thanks to Derek Wyatt and owen1
1152 |     - make <CR> behave the same as the 'o' mapping
1153 |     - some helptag fixes in the doc, thanks strull
1154 |     - fix a bug when using :set nohidden and opening a file where the previous
1155 |       buf was modified. Thanks iElectric
1156 |     - other minor fixes
1157 | 
1158 | 3.1.0
1159 |     New features:
1160 |     - add mappings to open files in a vsplit, see :help NERDTree-s and :help
1161 |       NERDTree-gs
1162 |     - make the statusline for the nerd tree window default to something
1163 |       hopefully more useful. See :help 'NERDTreeStatusline'
1164 |     Bugfixes:
1165 |     - make the hijack netrw functionality work when vim is started with "vim
1166 |       <some dir>" (thanks to Alf Mikula for the patch).
1167 |     - fix a bug where the CWD wasnt being changed for some operations even when
1168 |       NERDTreeChDirMode==2 (thanks to Lucas S. Buchala)
1169 |     - add -bar to all the nerd tree :commands so they can chain with other
1170 |       :commands (thanks to tpope)
1171 |     - fix bugs when ignorecase was set (thanks to nach)
1172 |     - fix a bug with the relative path code (thanks to nach)
1173 |     - fix a bug where doing a :cd would cause :NERDTreeToggle to fail (thanks nach)
1174 | 
1175 | 
1176 | 3.0.1
1177 |     Bugfixes:
1178 |     - fix bugs with :NERDTreeToggle and :NERDTreeMirror when 'hidden
1179 |       was not set
1180 |     - fix a bug where :NERDTree <path> would fail if <path> was relative and
1181 |       didnt start with a ./ or ../  Thanks to James Kanze.
1182 |     - make the q mapping work with secondary (:e <dir>  style) trees,
1183 |       thanks to jamessan
1184 |     - fix a bunch of small bugs with secondary trees
1185 | 
1186 |     More insane refactoring.
1187 | 
1188 | 3.0.0
1189 |     - hijack netrw so that doing an :edit <directory>  will put a NERD tree in
1190 |       the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw'
1191 |     - allow sharing of trees across tabs, see :help :NERDTreeMirror
1192 |     - remove "top" and "bottom" as valid settings for NERDTreeWinPos
1193 |     - change the '<tab>' mapping to 'i'
1194 |     - change the 'H' mapping to 'I'
1195 |     - lots of refactoring
1196 | 
1197 | ==============================================================================
1198 | 7. Credits                                                   *NERDTreeCredits*
1199 | 
1200 | Thanks to the following people for testing, bug reports, ideas etc. Without
1201 | you I probably would have got bored of the hacking the NERD tree and
1202 | just downloaded pr0n instead.
1203 | 
1204 |     Tim Carey-Smith (halorgium)
1205 |     Vigil
1206 |     Nick Brettell
1207 |     Thomas Scott Urban
1208 |     Terrance Cohen
1209 |     Yegappan Lakshmanan
1210 |     Jason Mills
1211 |     Michael Geddes (frogonwheels)
1212 |     Yu Jun
1213 |     Michael Madsen
1214 |     AOYAMA Shotaro
1215 |     Zhang Weiwu
1216 |     Niels Aan de Brugh
1217 |     Olivier Yiptong
1218 |     Zhang Shuhan
1219 |     Cory Echols
1220 |     Piotr Czachur
1221 |     Yuan Jiang
1222 |     Matan Nassau
1223 |     Maxim Kim
1224 |     Charlton Wang
1225 |     Matt Wozniski (godlygeek)
1226 |     knekk
1227 |     Sean Chou
1228 |     Ryan Penn
1229 |     Simon Peter Nicholls
1230 |     Michael Foobar
1231 |     Tomasz Chomiuk
1232 |     Denis Pokataev
1233 |     Tim Pope (tpope)
1234 |     James Kanze
1235 |     James Vega (jamessan)
1236 |     Frederic Chanal (nach)
1237 |     Alf Mikula
1238 |     Lucas S. Buchala
1239 |     Curtis Harvey
1240 |     Guillaume Duranceau
1241 |     Richard Hart (hates)
1242 |     Doug McInnes
1243 |     Stefan Ritter
1244 |     Rémi Prévost
1245 |     Victor Gonzalez
1246 |     Stephan Baumeister
1247 |     Ricky
1248 |     jfilip1024
1249 |     Chris Chambers
1250 |     Vitaly Bogdanov
1251 | 
1252 | ==============================================================================
1253 | 8. License                                                   *NERDTreeLicense*
1254 | 
1255 | The NERD tree is released under the wtfpl.
1256 | See http://sam.zoy.org/wtfpl/COPYING.
1257 | 


--------------------------------------------------------------------------------