stefan/vimsuite
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

+ matchit.vim

Browse Source 
+ matchit syntax für a2l
blockdiff.vim: update (+ commands)

git-svn-id: https://vimsuite.svn.sourceforge.net/svnroot/vimsuite/trunk@150 eb2d0018-73a3-4aeb-bfe9-1def61c9ec69
This commit is contained in:
stefan 2007-12-13 15:27:09 +00:00
parent 32d20899df
commit 6a1ca9231a
17 changed files with 11624 additions and 9638 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
vimfiles.stefan/ftplugin/a2l.vim
View File

@ -11,3 +11,7 @@ let b:commentstring = '//'
" Grep options
"let b:GrepFiles = '*.py'
" matchit.vim
let b:match_words = '/begin\>:/end\>'

3
vimfiles.stefan/plugin/changelog.vim
View File

@ -15,6 +15,9 @@ endif
function s:ReportRev(Rev)
if a:Rev >= '148'
echo 'Neu seit Rev: 148'
echo 'BlockDiff: Commands ergänzt'
echo 'Matchit: syntax für a2l'
elseif a:Rev >= '145'
echo 'Neu seit Rev: 145'
echo 'BlockDiff: Markieren -> BlockDiff -> Markieren -> BlockDiff -> neuer Tab'

19
vimfiles.stefan/plugin/vimsuite.vim
View File

@ -693,6 +693,25 @@ function FindDeclaration()
endfunction
" indent a wordNum to position
command -range -nargs=+ IndentWordNum call IndentWords(<f-args>, <line1>, <line2>)
" handle range
function IndentWords(wordNum, pos, fromline, toline)
let cursorLine = line(".")
let cursorCol = col(".")
if (a:fromline > 1)
call cursor(a:fromline-1, 255)
else
call cursor(a:fromline, 1)
endif
let line_nr = a:fromline
while (line_nr <= a:toline)
call cursor(line_nr, 1)
call IndentWordNum(a:wordNum, a:pos)
let line_nr = line_nr + 1
endwhile
call cursor(cursorLine, cursorCol)
endfunction
" handle one line
function IndentWordNum(wordNum, pos)
" store cursor postion
let cursorLine = line(".")

382
vimfiles.stefan/spell/bmsk.add
View File

File diff suppressed because it is too large Load Diff

BIN
vimfiles.stefan/spell/bmsk.add.spl
View File

Binary file not shown.

8
vimfiles/GetLatest/GetLatestVimScripts.dat
View File

@ -1,6 +1,6 @@
ScriptID SourceID Filename
--------------------------
1075 7738 netrw.vim
1075 8042 netrw.vim
1502 7078 vimball.vim
1008 3118 srec.vim (ftplugin)
1009 3119 srec.vim (syntax file)
@ -22,7 +22,9 @@ ScriptID SourceID Filename
1462 5612 dtd2xml
1046 4249 Lusty Explorer
2043 7805 VimPdb (debugging python)
1776 7810 Vimgrep Replace
2048 7815 BlockDiff
1776 7902 Vimgrep Replace
2048 7817 BlockDiff
39 7637 matchit.vim
2092 8041 reloaded.vim (matrix colorscheme)
642 7080 getscript.vim
642 7080 :AutoInstall: GetLatestVimScripts.vim

379
vimfiles/autoload/netrw.vim
View File

@ -1,7 +1,7 @@
" netrw.vim: Handles file transfer and remote directory listing across
" AUTOLOAD SECTION
" Date: Oct 02, 2007
" Version: 114
" Date: Dec 12, 2007
" Version: 116
" Maintainer: Charles E Campbell, Jr <NdrOchip@ScampbellPfamily.AbizM-NOSPAM>
" GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim
" Copyright: Copyright (C) 1999-2007 Charles E. Campbell, Jr. {{{1
@ -14,8 +14,7 @@
" in no event will the copyright holder be liable for any damages
" resulting from the use of this software.
" of this software.
" COMBAK: worked with tmpfile s:GetTempname() in NetRead() NetWrite()
" !!NEEDS DEBUGGING && TESTING!!!
" note: worked with tmpfile s:GetTempname() in NetRead() NetWrite()
"redraw!|call inputsave()|call input("Press <cr> to continue")|call inputrestore()
"
" But be doers of the Word, and not only hearers, deluding your own selves {{{1
@ -30,7 +29,7 @@ if !exists("s:NOTE")
let s:WARNING = 1
let s:ERROR = 2
endif
let g:loaded_netrw = "v114"
let g:loaded_netrw = "v116"
if v:version < 700
call netrw#ErrorMsg(s:WARNING,"you need vim version 7.0 or later for version ".g:loaded_netrw." of netrw",1)
finish
@ -222,14 +221,14 @@ endif
if !exists("g:netrw_localmovecmd")
if has("win32") || has("win95") || has("win64") || has("win16")
if g:netrw_cygwin
let g:netrw_localcopycmd= "mv"
let g:netrw_localmovecmd= "mv"
else
let g:netrw_localcopycmd= "move"
let g:netrw_localmovecmd= "move"
endif
elseif has("unix") || has("macunix")
let g:netrw_localcopycmd= "mv"
let g:netrw_localmovecmd= "mv"
else
let g:netrw_localcopycmd= ""
let g:netrw_localmovecmd= ""
endif
endif
if !exists("g:netrw_local_rmdir")
@ -298,6 +297,8 @@ endif
if !exists("g:netrw_shq")
if exists("&shq") && &shq != ""
let g:netrw_shq= &shq
elseif exists("&sxq") && &sxq != ""
let g:netrw_shq= &sxq
elseif has("win32") || has("win95") || has("win64") || has("win16")
if g:netrw_cygwin
let g:netrw_shq= "'"
@ -443,14 +444,16 @@ endfun
" NetrwBrowse.
" vt: normally its "w:" or "s:" (a variable type)
fun! s:NetrwOptionSave(vt)
" call Dfunc("s:NetrwOptionSave(vt<".a:vt.">) win#".winnr()." buf#".bufnr("."))
" call Dfunc("s:NetrwOptionSave(vt<".a:vt.">) win#".winnr()." buf#".bufnr(".")."<".bufname(bufnr(".")).">")
" call Decho(a:vt."netrw_optionsave".(exists("{a:vt}netrw_optionsave")? ("=".{a:vt}netrw_optionsave) : " doesn't exist"))
if !exists("{a:vt}netrw_optionsave")
let {a:vt}netrw_optionsave= 1
" call Decho(a:vt."netrw_optionsave=".{a:vt}netrw_optionsave)
else
" call Dret("s:NetrwOptionSave : netoptionsave=".{a:vt}netrw_optionsave." (options already saved)")
" call Dret("s:NetrwOptionSave : options already saved")
return
endif
" call Decho("fo=".&fo.(exists("&acd")? " acd=".&acd : " acd doesn't exist"))
" Save current settings and current directory
let s:yykeep = @@
@ -480,7 +483,6 @@ fun! s:NetrwOptionSave(vt)
endif
if &go =~ 'a' | silent! let {a:vt}netrw_regstar = @* | endif
silent! let {a:vt}netrw_regslash= @/
" call s:NetrwSafeOptions()
" call Dret("s:NetrwOptionSave : win#".winnr()." buf#".bufnr("."))
endfun
@ -490,13 +492,22 @@ endfun
fun! s:NetrwOptionRestore(vt)
" call Dfunc("s:NetrwOptionRestore(vt<".a:vt.">) win#".winnr()." buf#".bufnr("."))
if !exists("{a:vt}netrw_optionsave")
" call Dret("s:NetrwOptionRestore : {a:vt}netrw_optionsave doesn't exist")
" call Dret("s:NetrwOptionRestore : ".a:vt."netrw_optionsave doesn't exist")
return
endif
unlet {a:vt}netrw_optionsave
if exists("&acd")
if exists("{a:vt}netrw_acdkeep") |let &l:acd = {a:vt}netrw_acdkeep |unlet {a:vt}netrw_acdkeep |endif
if exists("{a:vt}netrw_acdkeep")
" call Decho("g:netrw_keepdir=".g:netrw_keepdir.": getcwd<".getcwd()."> acd=".&acd)
let curdir = getcwd()
let &l:acd = {a:vt}netrw_acdkeep
unlet {a:vt}netrw_acdkeep
if &l:acd
" call Decho("exe cd ".escape(curdir,g:netrw_fname_escape))
exe "cd ".escape(curdir,g:netrw_fname_escape)
endif
endif
endif
if exists("{a:vt}netrw_aikeep") |let &l:ai = {a:vt}netrw_aikeep |unlet {a:vt}netrw_aikeep |endif
if exists("{a:vt}netrw_awkeep") |let &l:aw = {a:vt}netrw_awkeep |unlet {a:vt}netrw_awkeep |endif
@ -525,36 +536,36 @@ fun! s:NetrwOptionRestore(vt)
setlocal directory=
unlet {a:vt}netrw_swfkeep
elseif &l:swf != {a:vt}netrw_swfkeep
" following line causes a Press ENTER in windows -- can't seem to work around it!!! (COMBAK)
" following line causes a Press ENTER in windows -- can't seem to work around it!!!
silent! let &l:swf= {a:vt}netrw_swfkeep
unlet {a:vt}netrw_swfkeep
endif
endif
if exists("{a:vt}netrw_regstar") |silent! let @*= {a:vt}netrw_regstar |unlet {a:vt}netrw_regstar |endif
if exists("{a:vt}netrw_regslash")|silent! let @/= {a:vt}netrw_regslash|unlet {a:vt}netrw_regslash|endif
" call Decho("g:netrw_keepdir=".g:netrw_keepdir.": getcwd<".getcwd()."> acd=".&acd)
" call Decho("fo=".&fo.(exists("&acd")? " acd=".&acd : " acd doesn't exist"))
" call Dret("s:NetrwOptionRestore : win#".winnr()." buf#".bufnr("."))
endfun
" ---------------------------------------------------------------------
" s:NetrwSafeOptions: sets options to help netrw do its job {{{2
fun! s:NetrwSafeOptions()
" call Dfunc("s:NetrwSafeOptions()")
" call Dfunc("s:NetrwSafeOptions() win#".winnr()." buf#".bufnr(".")."<".bufname(bufnr(".")).">")
" call Decho("window's ft=".&ft)
setlocal cino=
setlocal com=
setlocal cpo-=aA
if exists("&acd")
setlocal noacd nocin noai noci magic nospell nohid wig= noaw
setlocal fo=nroql2
else
setlocal nocin noai noci magic nospell nohid wig= noaw
setlocal fo=nroql2
endif
if exists("&acd") | setlocal noacd | endif
setlocal nocin noai noci magic nospell nohid wig= noaw
setlocal fo=nroql2
setlocal tw=0
setlocal report=10000
if g:netrw_use_noswf && has("win32") && !has("win95")
setlocal noswf
endif
" call Decho("fo=".&fo.(exists("&acd")? " acd=".&acd : " acd doesn't exist"))
" call Dret("s:NetrwSafeOptions")
endfun
@ -756,7 +767,7 @@ fun! netrw#NetRead(mode,...)
elseif b:netrw_method == 2 " read with ftp + <.netrc>
" call Decho("read via ftp+.netrc (method #2)")
let netrw_fname= b:netrw_fname
new
call s:SaveBufVars()|new|call s:RestoreBufVars()
setlocal ff=unix
exe "put ='".g:netrw_ftpmode."'"
" call Decho("filter input: ".getline("."))
@ -780,7 +791,7 @@ fun! netrw#NetRead(mode,...)
call netrw#ErrorMsg(s:ERROR,getline(1),4)
let &debug= debugkeep
endif
bd!
call s:SaveBufVars()|bd!|call s:RestoreBufVars()
let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method)
let b:netrw_lastfile = choice
@ -790,7 +801,7 @@ fun! netrw#NetRead(mode,...)
" Construct execution string (four lines) which will be passed through filter
" call Decho("read via ftp+mipf (method #3)")
let netrw_fname= escape(b:netrw_fname,g:netrw_fname_escape)
new
call s:SaveBufVars()|new|call s:RestoreBufVars()
setlocal ff=unix
if exists("g:netrw_port") && g:netrw_port != ""
put ='open '.g:netrw_machine.' '.g:netrw_port
@ -803,10 +814,10 @@ fun! netrw#NetRead(mode,...)
if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid
" call Decho("filter input: ".getline("."))
put ='\"'.g:netrw_passwd.'\"'
put ='\"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline("."))
else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"'
put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline("."))
endif
@ -835,7 +846,7 @@ fun! netrw#NetRead(mode,...)
call netrw#ErrorMsg(s:ERROR,getline(1),5)
endif
endif
bd!
call s:SaveBufVars()|bd!|call s:RestoreBufVars()
let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method)
let b:netrw_lastfile = choice
@ -901,7 +912,7 @@ fun! netrw#NetRead(mode,...)
else
put ='open '.g:netrw_machine
endif
put ='user '.g:netrw_uid.' '.g:netrw_passwd
put ='user '.g:netrw_uid.' '.s:netrw_passwd
put ='get '.netrw_fname.' '.tmpfile
put ='quit'
@ -942,9 +953,9 @@ fun! netrw#NetRead(mode,...)
endif
" call Decho("read via fetch for ".netrw_option)
if exists("g:netrw_uid") && g:netrw_uid != "" && exists("g:netrw_passwd") && g:netrw_passwd != ""
" call Decho("executing: !".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_uid.':'.g:netrw_passwd.'@'.g:netrw_machine."/".netrw_fname)
exe g:netrw_silentxfer."!".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_uid.':'.g:netrw_passwd.'@'.g:netrw_machine."/".netrw_fname
if exists("g:netrw_uid") && g:netrw_uid != "" && exists("s:netrw_passwd") && s:netrw_passwd != ""
" call Decho("executing: !".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_uid.':'.s:netrw_passwd.'@'.g:netrw_machine."/".netrw_fname)
exe g:netrw_silentxfer."!".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_uid.':'.s:netrw_passwd.'@'.g:netrw_machine."/".netrw_fname
else
" call Decho("executing: !".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_machine."/".netrw_fname)
exe g:netrw_silentxfer."!".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_machine."/".netrw_fname
@ -1173,10 +1184,10 @@ fun! netrw#NetWrite(...) range
if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid
" call Decho("filter input: ".getline("."))
put ='\"'.g:netrw_passwd.'\"'
put ='\"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline("."))
else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"'
put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline("."))
endif
put ='put \"'.tmpfile.'\" \"'.netrw_fname.'\"'
@ -1236,7 +1247,7 @@ fun! netrw#NetWrite(...) range
else
put ='open '.g:netrw_machine
endif
put ='user '.g:netrw_uid.' '.g:netrw_passwd
put ='user '.g:netrw_uid.' '.s:netrw_passwd
put ='put '.tmpfile.' '.netrw_fname
" perform cadaver operation:
@ -1459,8 +1470,8 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
" Patterns:
" mipf : a:machine a:id password filename Use ftp
" mf : a:machine filename Use ftp + <.netrc> or g:netrw_uid g:netrw_passwd
" ftpurm : ftp://[user@]host[[#:]port]/filename Use ftp + <.netrc> or g:netrw_uid g:netrw_passwd
" mf : a:machine filename Use ftp + <.netrc> or g:netrw_uid s:netrw_passwd
" ftpurm : ftp://[user@]host[[#:]port]/filename Use ftp + <.netrc> or g:netrw_uid s:netrw_passwd
" rcpurm : rcp://[user@]host/filename Use rcp
" rcphf : [user@]host:filename Use rcp
" scpurm : scp://[user@]host[[#:]port]/filename Use scp
@ -1537,7 +1548,7 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
if userid != ""
let g:netrw_uid= userid
endif
if exists("g:netrw_uid") && exists("g:netrw_passwd")
if exists("g:netrw_uid") && exists("s:netrw_passwd")
let b:netrw_method = 3
else
if s:FileReadable(expand("$HOME/.netrc")) && !g:netrw_ignorenetrc
@ -1545,9 +1556,9 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
else
if !exists("g:netrw_uid") || g:netrw_uid == ""
call NetUserPass()
elseif !exists("g:netrw_passwd") || g:netrw_passwd == ""
elseif !exists("s:netrw_passwd") || s:netrw_passwd == ""
call NetUserPass(g:netrw_uid)
" else just use current g:netrw_uid and g:netrw_passwd
" else just use current g:netrw_uid and s:netrw_passwd
endif
let b:netrw_method= 3
endif
@ -1567,13 +1578,13 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
let b:netrw_method = 3
let g:netrw_machine = substitute(a:choice,mipf,'\1',"")
let g:netrw_uid = substitute(a:choice,mipf,'\2',"")
let g:netrw_passwd = substitute(a:choice,mipf,'\3',"")
let s:netrw_passwd = substitute(a:choice,mipf,'\3',"")
let b:netrw_fname = substitute(a:choice,mipf,'\4',"")
" Issue an ftp: "hostname [path/]filename"
elseif match(a:choice,mf) == 0
" call Decho("(ftp) host file")
if exists("g:netrw_uid") && exists("g:netrw_passwd")
if exists("g:netrw_uid") && exists("s:netrw_passwd")
let b:netrw_method = 3
let g:netrw_machine = substitute(a:choice,mf,'\1',"")
let b:netrw_fname = substitute(a:choice,mf,'\2',"")
@ -1625,8 +1636,8 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
" if exists("g:netrw_uid") "Decho
" call Decho("g:netrw_uid <".g:netrw_uid.">")
" endif "Decho
" if exists("g:netrw_passwd") "Decho
" call Decho("g:netrw_passwd <".g:netrw_passwd.">")
" if exists("s:netrw_passwd") "Decho
" call Decho("s:netrw_passwd <".s:netrw_passwd.">")
" endif "Decho
" call Decho("b:netrw_fname <".b:netrw_fname.">")
" call Dret("NetrwMethod : b:netrw_method=".b:netrw_method)
@ -1672,10 +1683,10 @@ fun! NetUserPass(...)
" get password
if a:0 <= 1 " via prompt
" call Decho("a:0=".a:0." case <=1:")
let g:netrw_passwd= inputsecret("Enter Password: ")
let s:netrw_passwd= inputsecret("Enter Password: ")
else " from command line
" call Decho("a:0=".a:0." case >1: a:2<".a:2.">")
let g:netrw_passwd=a:2
let s:netrw_passwd=a:2
endif
" call Dret("NetUserPass")
@ -1743,14 +1754,7 @@ fun! s:BrowserMaps(islocal)
nnoremap <buffer> <silent> <s-leftmouse> <leftmouse>:call <SID>NetrwMarkFile(1,<SID>NetrwGetWord())<cr>
exe 'nnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwLocalRm("'.b:netrw_curdir.'")<cr>'
exe 'vnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwLocalRm("'.b:netrw_curdir.'")<cr>'
if !g:netrw_noretmap
if !hasmapto("<Plug>NetrwReturn")
nmap <unique> <silent> <2-leftmouse> <Plug>NetrwReturn
endif
exe 'nnoremap <silent> <Plug>NetrwReturn :call netrw#LocalBrowseCheck("'.b:netrw_curdir.'")<cr>'
endif
endif
exe 'com! Rexplore call netrw#LocalBrowseCheck("'.escape(b:netrw_curdir,g:netrw_cd_escape).'")'
exe 'nnoremap <buffer> <silent> <del> :call <SID>NetrwLocalRm("'.b:netrw_curdir.'")<cr>'
exe 'vnoremap <buffer> <silent> <del> :call <SID>NetrwLocalRm("'.b:netrw_curdir.'")<cr>'
exe 'nnoremap <buffer> <silent> D :call <SID>NetrwLocalRm("'.b:netrw_curdir.'")<cr>'
@ -1808,14 +1812,7 @@ fun! s:BrowserMaps(islocal)
nnoremap <buffer> <silent> <s-leftmouse> <leftmouse>:call <SID>NetrwMarkFile(0,<SID>NetrwGetWord())<cr>
exe 'nnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwRemoteRm("'.s:user.s:machine.'","'.s:path.'")<cr>'
exe 'vnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwRemoteRm("'.s:user.s:machine.'","'.s:path.'")<cr>'
if !g:netrw_noretmap
if !hasmapto("<Plug>NetrwReturn")
nmap <unique> <silent> <2-leftmouse> <Plug>NetrwReturn
endif
exe 'nnoremap <silent> <Plug>NetrwReturn :call <SID>NetrwBrowse(0,"'.b:netrw_curdir.'")<cr>'
endif
endif
exe 'com! Rexplore call s:NetrwBrowse(0,"'.escape(b:netrw_curdir,g:netrw_cd_escape).'")'
exe 'nnoremap <buffer> <silent> <del> :call <SID>NetrwRemoteRm("'.s:user.s:machine.'","'.s:path.'")<cr>'
exe 'vnoremap <buffer> <silent> <del> :call <SID>NetrwRemoteRm("'.s:user.s:machine.'","'.s:path.'")<cr>'
exe 'nnoremap <buffer> <silent> d :call <SID>NetrwMakeDir("'.s:user.s:machine.'")<cr>'
@ -1825,12 +1822,13 @@ fun! s:BrowserMaps(islocal)
exe 'vnoremap <buffer> <silent> R :call <SID>NetrwRemoteRename("'.s:user.s:machine.'","'.s:path.'")<cr>'
nnoremap <buffer> <F1> :he netrw-browse-cmds<cr>
endif
call s:SetRexDir(a:islocal,b:netrw_curdir)
" call Dret("s:BrowserMaps")
endfun
" ---------------------------------------------------------------------
" s:NetrwBrowse: This function uses the command in g:netrw_list_cmd to get a list {{{2
" of the contents of a remote directory. It is assumed that the
" s:NetrwBrowse: This function uses the command in g:netrw_list_cmd to provide a {{{2
" list of the contents of a local or remote directory. It is assumed that the
" g:netrw_list_cmd has a string, USEPORT HOSTNAME, that needs to be substituted
" with the requested remote hostname first.
fun! s:NetrwBrowse(islocal,dirname)
@ -1845,9 +1843,11 @@ fun! s:NetrwBrowse(islocal,dirname)
endif
call s:NetrwOptionSave("w:")
call s:NetrwSafeOptions()
" clear any marked files
if exists("s:netrwmarkfilelist")
" call Decho("clearing marked files")
unlet s:netrwmarkfilelist
unlet s:netrwmarkfilemtch
2match none
@ -1855,7 +1855,7 @@ fun! s:NetrwBrowse(islocal,dirname)
if a:islocal && exists("w:netrw_acdkeep") && w:netrw_acdkeep
" call Decho("handle w:netrw_acdkeep:")
" call Decho("cd ".escape(a:dirname,g:netrw_cd_escape)." (due to 'acd')")
" call Decho("cd ".escape(a:dirname,g:netrw_cd_escape)." (due to w:netrw_acdkeep=".w:netrw_acdkeep." - acd=".&acd.")")
exe 'cd '.escape(a:dirname,g:netrw_cd_escape)
" call Decho("getcwd<".getcwd().">")
@ -1873,19 +1873,21 @@ fun! s:NetrwBrowse(islocal,dirname)
" remote-read the requested file into current buffer {{{3
mark '
call s:NetrwEnew(a:dirname)
let b:netrw_curdir= a:dirname
call s:NetrwSafeOptions()
setlocal ma noro
let b:netrw_curdir= a:dirname
" call Decho("exe silent! keepalt file ".s:method."://".s:user.s:machine."/".escape(s:path,g:netrw_cd_escape)." (bt=".&bt.")")
exe "silent! keepalt file ".s:method."://".s:user.s:machine."/".escape(s:path,g:netrw_cd_escape)
exe "silent keepalt doau BufReadPre ".s:fname
silent call netrw#NetRead(2,s:method."://".s:user.s:machine."/".s:path)
exe "silent keepalt doau BufReadPost ".s:fname
if s:path !~ '.tar.bz2$' && s:path !~ '.tar.gz'
" netrw.vim and tar.vim have already handled decompression of the tarball; avoiding gzip.vim error
exe "silent keepalt doau BufReadPost ".s:fname
endif
" save certain window-oriented variables into buffer-oriented variables {{{3
call s:SetBufWinVars()
call s:NetrwOptionRestore("w:")
setlocal nomod nowrap
setlocal noma nomod nowrap
" call Dret("NetrwBrowse : file<".s:fname.">")
return
@ -1901,6 +1903,8 @@ fun! s:NetrwBrowse(islocal,dirname)
call s:NetrwMenu(1) " set up menu {{{3
if s:NetrwGetBuffer(a:islocal,dirname) " set up buffer {{{3
call s:NetrwOptionRestore("w:")
setlocal noma nomod nowrap
" call Dret("NetrwBrowse : re-using buffer")
return
endif
@ -1937,7 +1941,7 @@ fun! s:NetrwBrowse(islocal,dirname)
" handle g:netrw_keepdir: set vim's current directory to netrw's notion of the current directory {{{3
if !g:netrw_keepdir
" call Decho("handle keepdir: (g:netrw_keepdir=".g:netrw_keepdir.")")
" call Decho("handle g:netrw_keepdir=".g:netrw_keepdir.": getcwd<".getcwd()."> acd=".&acd)
" call Decho('exe cd '.escape(b:netrw_curdir,g:netrw_cd_escape))
try
exe 'cd '.escape(b:netrw_curdir,g:netrw_cd_escape)
@ -1947,6 +1951,7 @@ fun! s:NetrwBrowse(islocal,dirname)
let b:netrw_curdir= w:netrw_prvdir
else
call s:NetrwOptionRestore("w:")
setlocal noma nomod nowrap
let b:netrw_curdir= dirname
" call Dret("NetrwBrowse : reusing buffer#".(exists("bufnum")? bufnum : 'N/A')."<".dirname."> getcwd<".getcwd().">")
return
@ -1983,6 +1988,7 @@ fun! s:NetrwBrowse(islocal,dirname)
call netrw#ErrorMsg(s:ERROR,"netrw doesn't understand your dirname<".dirname.">",20)
endif
call s:NetrwOptionRestore("w:")
setlocal noma nomod nowrap
" call Dret("NetrwBrowse : badly formatted dirname<".dirname.">")
return
endif
@ -1993,11 +1999,10 @@ fun! s:NetrwBrowse(islocal,dirname)
" -----------------------
" Directory Listing: {{{3
" -----------------------
setlocal noro ma
call s:BrowserMaps(a:islocal)
call s:PerformListing(a:islocal)
" call Dret("NetrwBrowse")
" call Dret("NetrwBrowse : did PerformListing")
return
endfun
@ -2073,7 +2078,6 @@ fun! s:NetrwGetBuffer(islocal,dirname)
if bufnum < 0 || !bufexists(bufnum)
" call Decho("get enew buffer")
call s:NetrwEnew(dirname)
call s:NetrwSafeOptions()
" name the buffer
if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST
" call Decho('silent! keepalt file NetrwTreeListing')
@ -2252,17 +2256,19 @@ endfun
fun! s:PerformListing(islocal)
" call Dfunc("s:PerformListing(islocal=".a:islocal.") buf(%)=".bufnr("%")."<".bufname("%").">")
" if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 " Decho
" call Decho("(netrw) Processing your browsing request...")
" endif " Decho
call s:NetrwSafeOptions()
setlocal noro ma
" call Decho('w:netrw_liststyle='.(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a'))
if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict")
" force a refresh for tree listings
" call Decho("force refresh for treelisting: clear buffer<".expand("%")."> with :%d")
setlocal ma noro
keepjumps %d
endif
" if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 " Decho
" call Decho("(netrw) Processing your browsing request...")
" endif " Decho
" call Decho('w:netrw_liststyle='.(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a'))
if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict")
" force a refresh for tree listings
" call Decho("force refresh for treelisting: clear buffer<".expand("%")."> with :%d")
keepjumps %d
endif
" save current directory on directory history list
call s:NetrwBookmarkDir(3,b:netrw_curdir)
@ -2442,10 +2448,12 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
endif
call s:NetrwOptionSave("s:")
call s:NetrwSafeOptions()
call netrw#NetrwSavePosn()
let nbcd_curpos = getpos('.')
let dirname = substitute(b:netrw_curdir,'\\','/','ge')
let newdir = a:newdir
let dolockout = 0
" set up o/s-dependent directory recognition pattern
if has("amiga")
@ -2479,7 +2487,8 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" this lets NetrwBrowseX avoid the edit
if a:0 < 1
" call Decho("dirname<".dirname."> netrw_cd_escape<".g:netrw_cd_escape."> browse_split=".g:netrw_browse_split)
" call Decho("about to edit<".escape(dirname,g:netrw_cd_escape)."> didsplit=".(exists("s:didsplit")? s:didsplit : "doesn't exist"))
" call Decho("set up windows for editing<".escape(dirname,g:netrw_cd_escape)."> didsplit=".(exists("s:didsplit")? s:didsplit : "doesn't exist"))
call s:NetrwOptionRestore("s:")
if !exists("s:didsplit")
if g:netrw_browse_split == 1
new
@ -2489,6 +2498,11 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
wincmd |
elseif g:netrw_browse_split == 3
tabnew
elseif g:netrw_browse_split == 4
if s:NetrwPrevWinOpen(2) == 3
" call Dret("s:NetrwBrowseChgDir")
return
endif
else
" handling a file, didn't split, so remove menu
" call Decho("handling a file+didn't split, so remove menu")
@ -2503,12 +2517,11 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" if its local only: LocalBrowseCheck() doesn't edit a file, but NetrwBrowse() will
if a:islocal
" call Decho("edit local file: exe e! ".escape(dirname,g:netrw_cd_escape))
call s:NetrwOptionRestore("s:")
setlocal ma nomod noro
exe "e! ".escape(dirname,g:netrw_cd_escape)
let dolockout= 1
else
setlocal ma nomod noro
call s:NetrwOptionRestore("s:")
" call Decho("remote file: NetrwBrowse will edit it")
let dolockout= 1
endif
endif
@ -2518,6 +2531,7 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" ---------------------------------
" call Decho('case "just go to new directory spec": newdir<'.newdir.'>')
let dirname= newdir
call s:SetRexDir(a:islocal,dirname)
call s:NetrwOptionRestore("s:")
elseif newdir == './'
@ -2525,7 +2539,7 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" refresh the directory list
" --------------------------
" call Decho('case "refresh directory listing": newdir == "./"')
call s:NetrwOptionRestore("s:")
call s:SetRexDir(a:islocal,dirname)
elseif newdir == '../'
" -------------------
@ -2564,7 +2578,7 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
endif
" call Decho("unix: dirname<".dirname."> (go up one dir)")
endif
call s:NetrwOptionRestore("s:")
call s:SetRexDir(a:islocal,dirname)
elseif exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict")
" call Decho('case liststyle is TREELIST and w:netrw_treedict exists')
@ -2621,12 +2635,19 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
let dirname= substitute(treedir,'/*$','/','')
" call Decho("go down one dir: treedir<".treedir.">")
endif
call s:SetRexDir(a:islocal,dirname)
else
" go down one directory
let dirname= s:ComposePath(dirname,newdir)
" call Decho("go down one dir: dirname<".dirname."> newdir<".newdir.">")
call s:NetrwOptionRestore("s:")
call s:SetRexDir(a:islocal,dirname)
endif
call s:NetrwOptionRestore("s:")
if dolockout
" call Decho("doing modification lockout settings: ma nomod noro")
setlocal ma nomod noro
endif
" call Dret("s:NetrwBrowseChgDir <".dirname."> : curpos<".string(getpos(".")).">")
@ -2797,6 +2818,9 @@ endfun
fun! s:NetrwMarkFile(islocal,fname)
" call Dfunc("s:NetrwMarkFile(islocal=".a:islocal." fname<".a:fname.">)")
" call Decho("b:netrw_curdir<".b:netrw_curdir.">")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
" call Decho("starting s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">")
@ -2806,7 +2830,7 @@ fun! s:NetrwMarkFile(islocal,fname)
" append filename to list
" call Decho("append filename<".a:fname."> to markfilelist<".string(s:netrwmarkfilelist).">")
call add(s:netrwmarkfilelist,a:fname)
let s:netrwmarkfilemtch= s:netrwmarkfilemtch.'\|\<'.a:fname.'\>'
let s:netrwmarkfilemtch= s:netrwmarkfilemtch.'\|\<'.escape(a:fname,'*./[\').'\>'
else
" remove filename from list
" call Decho("remove filename<".a:fname."> from markfilelist<".string(s:netrwmarkfilelist).">")
@ -2859,6 +2883,9 @@ endfun
fun! s:NetrwMarkFileCompress(islocal)
" call Dfunc("s:NetrwMarkFileCompress(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist") && exists("g:netrw_compress") && exists("g:netrw_decompress")
for fname in s:netrwmarkfilelist
@ -2908,6 +2935,9 @@ endfun
" 0=failure
fun! s:NetrwMarkFileCopy(islocal)
" call Dfunc("s:NetrwMarkFileCopy(islocal=".a:islocal.") target<".(exists("s:netrwmftgt")? s:netrwmftgt : '---').">")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
" call Decho("s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">")
@ -2930,7 +2960,7 @@ fun! s:NetrwMarkFileCopy(islocal)
if a:islocal && s:netrwmfloc
" local to local copy
" call Decho("local to local copy")
" call Decho("local to local copy: getcwd<".getcwd()."> b:netrw_curdir<".b:netrw_curdir.">")
if executable(g:netrw_localcopycmd)
" call Decho("let ret= system(".g:netrw_localcopycmd." ".fname." ".s:netrwmftgt.")")
let ret= system(g:netrw_localcopycmd." ".fname." ".s:netrwmftgt)
@ -2945,12 +2975,12 @@ fun! s:NetrwMarkFileCopy(islocal)
elseif !a:islocal && s:netrwmfloc
" remote to local copy
" call Decho("remote to local copy")
" call Decho("remote to local copy: getcwd<".getcwd()."> b:netrw_curdir<".b:netrw_curdir.">")
call netrw#NetrwObtain(a:islocal,fname,s:netrwmftgt)
elseif a:islocal && !s:netrwmfloc
" local to remote copy
" call Decho("local to remote copy")
" call Decho("local to remote copy: getcwd<".getcwd()."> b:netrw_curdir<".b:netrw_curdir.">")
call s:NetrwUpload(fname,s:netrwmftgt)
else
@ -2988,8 +3018,12 @@ endfun
" Either two or three files can be so handled.
fun! s:NetrwMarkFileDiff(islocal)
" call Dfunc("s:NetrwMarkFileDiff(islocal=".a:islocal.") b:netrw_curdir<".b:netrw_curdir.">")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
let curdir= b:netrw_curdir
let cnt= 0
for fname in s:netrwmarkfilelist
let cnt= cnt + 1
@ -3021,21 +3055,12 @@ endfun
" s:NetrwMarkFileEdit: put marked files on arg list and start editing them {{{2
fun! s:NetrwMarkFileEdit(islocal)
" call Dfunc("s:NetrwMarkFileEdit(islocal=".a:islocal.")")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
if a:islocal
exe 'com! Rexplore call netrw#LocalBrowseCheck("'.escape(b:netrw_curdir,g:netrw_cd_escape).'")'
if g:netrw_mousemaps == 1
silent! unmap <2-leftmouse>
exe 'nnoremap <unique> <silent> <2-leftmouse> :call netrw#LocalBrowseCheck("'.b:netrw_curdir.'")<cr>'
endif
else
exe 'com! Rexplore call s:NetrwBrowse(0,"'.escape(b:netrw_curdir,g:netrw_cd_escape).'")'
if g:netrw_mousemaps == 1
silent! unmap <2-leftmouse>
exe 'silent! nnoremap <unique> <silent> <2-leftmouse> :call <SID>NetrwBrowse(0,"'.b:netrw_curdir.'")<cr>'
endif
endif
call s:SetRexDir(a:islocal,b:netrw_curdir)
let flist= substitute(escape(join(s:netrwmarkfilelist,"\t"),' '),"\t",' ','g')
" unmark marked file list
unlet s:netrwmarkfilelist
@ -3053,6 +3078,9 @@ endfun
fun! s:NetrwMarkFileExe(islocal)
" call Dfunc("s:NetrwMarkFileExe(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
" get the command
@ -3101,6 +3129,9 @@ endfun
" s:NetrwMarkFileMove: execute arbitrary command on marked files, one at a time {{{2
fun! s:NetrwMarkFileMove(islocal)
" call Dfunc("s:NetrwMarkFileMove(islocal=".a:islocal.")")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
let svpos= netrw#NetrwSavePosn()
@ -3149,6 +3180,9 @@ endfun
" using the hardcopy command
fun! s:NetrwMarkFilePrint(islocal)
" call Dfunc("s:NetrwMarkFilePrint(islocal=".a:islocal.")")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
let netrwmarkfilelist= s:netrwmarkfilelist
unlet s:netrwmarkfilelist
@ -3173,6 +3207,9 @@ endfun
" issued).
fun! s:NetrwMarkFileRegexp(islocal)
" call Dfunc("s:NetrwMarkFileRegexp(islocal=".a:islocal.")")
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
" get the regular expression
call inputsave()
@ -3243,6 +3280,9 @@ endfun
fun! s:NetrwMarkFileTag(islocal)
" call Dfunc("s:NetrwMarkFileTag(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist")
" call Decho("s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">")
@ -3286,6 +3326,9 @@ endfun
fun! s:NetrwMarkFileTgt(islocal)
" call Dfunc("s:NetrwMarkFileTgt(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmftgt") || exists("s:netrwmfloc")
" call Decho("s:netrwmftgt<".s:netrwmftgt."> exists; removing it")
@ -3294,6 +3337,9 @@ fun! s:NetrwMarkFileTgt(islocal)
" call Decho("s:netrwmftgt doesn't exist; setting it to <".b:netrw_curdir.">")
let s:netrwmftgt = b:netrw_curdir
let s:netrwmfloc = a:islocal
if g:netrw_cygwin
let s:netrwmftgt= substitute(system("cygpath ".b:netrw_curdir),'\n$','','')
endif
endif
call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./'))
@ -3404,12 +3450,12 @@ fun! netrw#NetrwObtain(islocal,fname,...)
if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid
put ='\"'.g:netrw_passwd.'\"'
put ='\"'.s:netrw_passwd.'\"'
" call Decho('ftp: g:netrw_uid')
" call Decho('ftp: g:netrw_passwd')
" call Decho('ftp: s:netrw_passwd')
else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"'
" call Decho('user '.g:netrw_uid.' '.g:netrw_passwd)
put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
" call Decho('user '.g:netrw_uid.' '.s:netrw_passwd)
endif
if path != ""
@ -3516,6 +3562,7 @@ endfun
fun! s:NetrwPreview(path) range
" call Dfunc("NetrwPreview(path<".a:path.">)")
call s:NetrwOptionSave("s:")
call s:NetrwSafeOptions()
if has("quickfix")
if !isdirectory(a:path)
exe (g:netrw_preview? "vert " : "")."pedit ".escape(a:path,g:netrw_fname_escape)
@ -4147,9 +4194,9 @@ fun! s:NetrwRemoteFtpCmd(path,listcmd)
if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid
put ='\"'.g:netrw_passwd.'\"'
put ='\"'.s:netrw_passwd.'\"'
else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"'
put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
endif
if a:path != ""
@ -4632,10 +4679,9 @@ fun! s:NetrwMakeDir(usrhost)
" call Decho("netrw_origdir<".netrw_origdir.">: cd b:netrw_curdir<".b:netrw_curdir.">")
" call Decho("exe silent! !".g:netrw_local_mkdir.' '.g:netrw_shq.newdirname.g:netrw_shq)
exe "silent! !".g:netrw_local_mkdir.' '.g:netrw_shq.newdirname.g:netrw_shq
if !g:netrw_keepdir | exe 'keepjumps cd '.netrw_origdir | endif
if !g:netrw_keepdir
exe 'keepjumps cd '.netrw_origdir
" call Decho("netrw_keepdir=".g:netrw_keepdir.": cd ".netrw_origdir)
" call Decho("netrw_keepdir=".g:netrw_keepdir.": cd ".netrw_origdir." getcwd<".getcwd().">")
endif
endif
@ -4855,12 +4901,18 @@ endfun
" ---------------------------------------------------------------------
" s:NetrwPrevWinOpen: open file/directory in previous window. {{{2
" If there's only one window, then the window will first be split.
" Returns:
" choice = 0 : didn't have to choose
" choice = 1 : saved modified file in window first
" choice = 2 : didn't save modified file, opened window
" choice = 3 : cancel open
fun! s:NetrwPrevWinOpen(islocal)
" call Dfunc("NetrwPrevWinOpen(islocal=".a:islocal.")")
" get last window number and the word currently under the cursor
let lastwinnr = winnr("$")
let curword = s:NetrwGetWord()
let choice = 0
" call Decho("lastwinnr=".lastwinnr." curword<".curword.">")
let didsplit = 0
@ -4868,14 +4920,17 @@ fun! s:NetrwPrevWinOpen(islocal)
" if only one window, open a new one first
" call Decho("only one window, so open a new one (g:netrw_alto=".g:netrw_alto.")")
if g:netrw_preview
" call Decho("exe ".(g:netrw_alto? "top " : "bot ")."vert ".g:netrw_winsize."wincmd s")
exe (g:netrw_alto? "top " : "bot ")."vert ".g:netrw_winsize."wincmd s"
else
" call Decho("exe ".(g:netrw_alto? "bel " : "abo ").g:netrw_winsize."wincmd s")
exe (g:netrw_alto? "bel " : "abo ").g:netrw_winsize."wincmd s"
endif
let didsplit = 1
else
call s:SaveBufVars()
" call Decho("wincmd p")
wincmd p
call s:RestoreBufVars()
" if the previous window's buffer has been changed (is modified),
@ -4884,11 +4939,17 @@ fun! s:NetrwPrevWinOpen(islocal)
let bnr = winbufnr(0)
let bnrcnt = 0
if &mod
" call Decho("detected: prev window's buffer has been modified: bnr=".bnr." winnr#".winnr())
let eikeep= &ei
set ei=all
windo if winbufnr(0) == bnr | let bnrcnt=bnrcnt+1 | endif
" call Decho("bnr=".bnr." bnrcnt=".bnrcnt)
exe bnr."wincmd p"
let &ei= eikeep
" call Decho("bnr=".bnr." bnrcnt=".bnrcnt." buftype=".&bt." winnr#".winnr())
if bnrcnt == 1
let bufname= bufname(winbufnr(winnr()))
let choice= confirm("Save modified file<".bufname.">?","&Yes\n&No\n&Cancel")
" call Decho("bufname<".bufname."> choice=".choice." winnr#".winnr())
if choice == 1
" Yes -- write file & then browse
@ -4901,14 +4962,15 @@ fun! s:NetrwPrevWinOpen(islocal)
else
wincmd p
endif
" call Dret("NetrwPrevWinOpen : unable to write <".bufname.">")
return
" call Dret("NetrwPrevWinOpen ".choice." : unable to write <".bufname.">")
return choice
endif
elseif choice == 2
" No -- don't worry about changed file, just browse anyway
setlocal nomod
call netrw#ErrorMsg(s:WARNING,bufname." changes abandoned",31)
call netrw#ErrorMsg(s:WARNING,bufname." changes to ".bufname." abandoned",31)
wincmd p
else
" Cancel -- don't do this
@ -4917,19 +4979,22 @@ fun! s:NetrwPrevWinOpen(islocal)
else
wincmd p
endif
" call Dret("NetrwPrevWinOpen : cancelled")
return
" call Dret("NetrwPrevWinOpen ".choice." : cancelled")
return choice
endif
endif
endif
endif
if a:islocal
call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(a:islocal,curword))
else
call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,curword))
if a:islocal < 2
if a:islocal
call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(a:islocal,curword))
else
call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,curword))
endif
endif
" call Dret("NetrwPrevWinOpen")
" call Dret("NetrwPrevWinOpen ".choice)
return choice
endfun
" ---------------------------------------------------------------------
@ -5017,11 +5082,15 @@ endfun
" netrw#LocalBrowseCheck: {{{2
fun! netrw#LocalBrowseCheck(dirname)
" unfortunate interaction -- split window debugging can't be
" " used here, must use DechoRemOn or DechoTabOn -- the BufEnter
" used here, must use D-echoRemOn or D-echoTabOn -- the BufEnter
" event triggers another call to LocalBrowseCheck() when attempts
" to write to the DBG buffer are made.
" The &ft == "netrw" test was installed because the BufEnter event
" would hit when re-entering netrw windows, creating unexpected
" refreshes (and would do so in the middle of NetrwSaveOptions(), too)
" call Dfunc("LocalBrowseCheck(dirname<".a:dirname.">")
if isdirectory(a:dirname)
" call Decho("isdir=".isdirectory(a:dirname)." ft=".&ft." b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : " doesn't exist")."> dirname<".a:dirname.">")
if isdirectory(a:dirname) && (&ft != "netrw" || (exists("b:netrw_curdir") && b:netrw_curdir != a:dirname))
silent! call s:NetrwBrowse(1,a:dirname)
endif
" call Dret("LocalBrowseCheck")
@ -5481,7 +5550,6 @@ fun! netrw#Explore(indx,dosplit,style,...)
if a:dosplit || &modified || a:style == 6
" call Decho("case: dosplit=".a:dosplit." modified=".&modified." a:style=".a:style)
call s:SaveWinVars()
call s:NetrwOptionSave("s:")
if a:style == 0 " Explore, Sexplore
" call Decho("style=0: Explore or Sexplore")
@ -5514,7 +5582,6 @@ fun! netrw#Explore(indx,dosplit,style,...)
call s:RestoreBufVars()
endif
call s:RestoreWinVars()
call s:NetrwOptionRestore("s:")
endif
norm! 0
@ -5537,6 +5604,19 @@ fun! netrw#Explore(indx,dosplit,style,...)
endif
endif
if dirname =~ '/\*\*/'
" handle .../**/...
" call Decho("case Explore .../**/...")
let prefixdir = substitute(dirname,'^\(.\{-}\)\*\*.*$','\1','')
if prefixdir =~ '^/' || (prefixdir =~ '^\a:/' && (has("win32") || has("win95") || has("win64") || has("win16")))
let b:netrw_curdir = prefixdir
else
let b:netrw_curdir= getcwd().'/'.prefixdir
endif
let dirname = substitute(dirname,'^.\{-}\(\*\*/.*\)$','\1','')
" call Decho("pwd<".getcwd()."> dirname<".dirname.">")
endif
if dirname =~ '^\*/'
" Explore */pattern
" call Decho("case Explore */pattern")
@ -6073,9 +6153,7 @@ fun! s:GetTempfile(fname)
if g:netrw_cygwin != 0
let tmpfile = substitute(tmpfile,'^\(\a\):','/cygdrive/\1','e')
elseif has("win32") || has("win95") || has("win64") || has("win16")
if exists("+shellslash")
let tmpfile = substitute(tmpfile,'/',&ssl,'g')
else
if !exists("+shellslash") || !&ssl
let tmpfile = substitute(tmpfile,'/','\','g')
endif
else
@ -6159,7 +6237,7 @@ endfun
fun! s:NetrwEnew(curdir)
" call Dfunc("s:NetrwEnew(curdir<".a:curdir.">) buf#".bufnr("%")."<".bufname("%").">")
" grab a function-local copy of buffer variables
" grab a function-local-variable copy of buffer variables
if exists("b:netrw_bannercnt") |let netrw_bannercnt = b:netrw_bannercnt |endif
if exists("b:netrw_browser_active") |let netrw_browser_active = b:netrw_browser_active |endif
if exists("b:netrw_cpf") |let netrw_cpf = b:netrw_cpf |endif
@ -6177,6 +6255,7 @@ fun! s:NetrwEnew(curdir)
if exists("b:netrw_option") |let netrw_option = b:netrw_option |endif
if exists("b:netrw_prvdir") |let netrw_prvdir = b:netrw_prvdir |endif
call s:NetrwOptionRestore("w:")
if getline(2) =~ '^" Netrw Directory Listing'
" call Decho("generate a buffer with keepjumps keepalt enew! (1)")
keepjumps keepalt enew!
@ -6184,8 +6263,9 @@ fun! s:NetrwEnew(curdir)
" call Decho("generate a buffer with keepjumps enew! (2)")
keepjumps enew!
endif
call s:NetrwOptionSave("w:")
" copy function-local variables to buffer variable equivalents
" copy function-local-variables to buffer variable equivalents
if exists("netrw_bannercnt") |let b:netrw_bannercnt = netrw_bannercnt |endif
if exists("netrw_browser_active") |let b:netrw_browser_active = netrw_browser_active |endif
if exists("netrw_cpf") |let b:netrw_cpf = netrw_cpf |endif
@ -6342,6 +6422,33 @@ fun! s:SetBufWinVars()
" call Dret("s:SetBufWinVars")
endfun
" ---------------------------------------------------------------------
" s:SetRexDir: set directory for :Rexplore {{{2
fun! s:SetRexDir(islocal,dirname)
" call Dfunc("s:SetRexDir(islocal=".a:islocal." dirname<".a:dirname.">)")
" set up Rex and leftmouse-double-click
if a:islocal
exe 'com! Rexplore call netrw#LocalBrowseCheck("'.escape(a:dirname,g:netrw_cd_escape).'")'
if !g:netrw_noretmap
silent! unmap <2-leftmouse>
if !hasmapto("<Plug>NetrwReturn")
nmap <unique> <silent> <2-leftmouse> <Plug>NetrwReturn
endif
exe 'nnoremap <silent> <Plug>NetrwReturn :call netrw#LocalBrowseCheck("'.a:dirname.'")<cr>'
endif
else
exe 'com! Rexplore call s:NetrwBrowse(0,"'.escape(a:dirname,g:netrw_cd_escape).'")'
if !g:netrw_noretmap
silent! unmap <2-leftmouse>
if !hasmapto("<Plug>NetrwReturn")
nmap <unique> <silent> <2-leftmouse> <Plug>NetrwReturn
endif
exe 'nnoremap <silent> <Plug>NetrwReturn :call <SID>NetrwBrowse(0,"'.a:dirname.'")<cr>'
endif
endif
" call Dret("s:SetRexDir")
endfun
" ---------------------------------------------------------------------
" s:Strlen: this function returns the length of a string, even if its {{{1
" using two-byte etc characters. Depends on virtcol().

66
vimfiles/colors/reloaded.vim Normal file
View File

@ -0,0 +1,66 @@
" Vim color file
" Maintainer: connorberry@yahoo.com
" Last Change:
" URL: www.narwhale.org
set background=dark "or light
hi clear
if exists("syntax_on")
syntax reset
endif
let g:colors_name="reloaded"
hi LineNr term=bold gui=bold guifg=White guibg=DarkGray
hi Normal ctermfg=Green ctermbg=Black
hi Normal guifg=Green guibg=Black
hi NonText ctermfg=DarkGray ctermbg=Black
hi NonText guifg=DarkGray guibg=Black
hi Statement ctermfg=Green ctermbg=Black
hi Statement guifg=Green guibg=Black
hi Comment ctermfg=DarkGreen ctermbg=Black cterm=bold term=bold
hi Comment guifg=DarkGreen guibg=Black gui=bold term=bold
hi Constant ctermfg=Black ctermbg=Green
hi Constant guifg=Black guibg=Green
hi Identifier ctermfg=Green ctermbg=Black
hi Identifier guifg=Green guibg=Black
hi Type ctermfg=Green ctermbg=Black
hi Type guifg=Green guibg=Black
hi String ctermfg=Green ctermbg=DarkGreen
hi String guifg=Green guibg=DarkGreen
hi Boolean ctermfg=Green ctermbg=DarkGreen
hi Boolean guifg=Green guibg=DarkGreen
hi Number ctermfg=Green ctermbg=DarkGreen
hi Number guifg=Green guibg=DarkGreen
hi Folded ctermfg=DarkYellow ctermbg=Black cterm=underline term=none
hi Folded guifg=DarkYellow guibg=Black gui=underline term=none
hi Special ctermfg=Black ctermbg=DarkGreen
hi Special guifg=Black guibg=DarkGreen
hi PreProc ctermfg=DarkGreen ctermbg=Black cterm=bold term=bold
hi PreProc guifg=DarkGreen guibg=Black gui=bold term=bold
hi Scrollbar ctermfg=DarkYellow ctermbg=Black
hi Scrollbar guifg=DarkYellow guibg=Black
hi Cursor ctermfg=Black ctermbg=Green
hi Cursor guifg=Black guibg=Green
hi ErrorMsg ctermfg=Red ctermbg=Black cterm=bold term=bold
hi ErrorMsg guifg=Red guibg=Black gui=bold term=bold
hi WarningMsg ctermfg=Yellow ctermbg=Black
hi WarningMsg guifg=Yellow guibg=Black
hi VertSplit ctermfg=White ctermbg=Black
hi VertSplit guifg=White guibg=Black
hi Directory ctermfg=Green ctermbg=DarkBlue
hi Directory guifg=Green guibg=DarkBlue
hi Visual ctermfg=White ctermbg=DarkGray cterm=underline term=none
hi Visual guifg=White guibg=DarkGray gui=underline term=none
hi Title ctermfg=White ctermbg=DarkBlue
hi Title guifg=White guibg=DarkBlue
hi StatusLine term=bold cterm=bold,underline ctermfg=White ctermbg=Black
hi StatusLine term=bold gui=bold,underline guifg=White guibg=Black
hi StatusLineNC term=bold cterm=bold,underline ctermfg=Gray ctermbg=Black
hi StatusLineNC term=bold gui=bold,underline guifg=Gray guibg=Black
hi LineNr term=bold cterm=bold ctermfg=White ctermbg=DarkGray
hi LineNr term=bold gui=bold guifg=White guibg=DarkGray
hi cursorline ctermbg=White
hi cursorline guibg=DarkGray

406
vimfiles/doc/matchit.txt Normal file
View File

@ -0,0 +1,406 @@
*matchit.txt* Extended "%" matching
For instructions on installing this file, type
:help matchit-install
inside Vim.
For Vim version 6.3. Last change: 2007 Aug 29
VIM REFERENCE MANUAL by Benji Fisher
*matchit* *matchit.vim*
1. Extended matching with "%" |matchit-intro|
2. Activation |matchit-activate|
3. Configuration |matchit-configure|
4. Supporting a New Language |matchit-newlang|
5. Known Bugs and Limitations |matchit-bugs|
The functionality mentioned here is a plugin, see |add-plugin|.
This plugin is only available if 'compatible' is not set.
You can avoid loading this plugin by setting the "loaded_matchit" variable
in your |vimrc| file: >
:let loaded_matchit = 1
{Vi does not have any of this}
==============================================================================
1. Extended matching with "%" *matchit-intro*
*matchit-%*
% Cycle forward through matching groups, such as "if", "else", "endif",
as specified by |b:match_words|.
*g%* *v_g%* *o_g%*
g% Cycle backwards through matching groups, as specified by
|b:match_words|. For example, go from "if" to "endif" to "else".
*[%* *v_[%* *o_[%*
[% Go to [count] previous unmatched group, as specified by
|b:match_words|. Similar to |[{|.
*]%* *v_]%* *o_]%*
]% Go to [count] next unmatched group, as specified by
|b:match_words|. Similar to |]}|.
*v_a%*
a% In Visual mode, select the matching group, as specified by
|b:match_words|, containing the cursor. Similar to |v_a[|.
A [count] is ignored, and only the first character of the closing
pattern is selected.
In Vim, as in plain vi, the percent key, |%|, jumps the cursor from a brace,
bracket, or paren to its match. This can be configured with the 'matchpairs'
option. The matchit plugin extends this in several ways:
You can match whole words, such as "if" and "endif", not just
single characters. You can also specify a |regular-expression|.
You can define groups with more than two words, such as "if",
"else", "endif". Banging on the "%" key will cycle from the "if" to
the first "else", the next "else", ..., the closing "endif", and back
to the opening "if". Nested structures are skipped. Using |g%| goes
in the reverse direction.
By default, words inside comments and strings are ignored, unless
the cursor is inside a comment or string when you type "%". If the
only thing you want to do is modify the behavior of "%" so that it
behaves this way, you do not have to define |b:match_words|, since the
script uses the 'matchpairs' option as well as this variable.
See |matchit-details| for details on what the script does, and |b:match_words|
for how to specify matching patterns.
MODES: *matchit-modes* *matchit-v_%* *matchit-o_%*
Mostly, % and related motions (|g%| and |[%| and |]%|) work just like built-in
|motion| commands in |Operator-pending| and |Visual| modes. However, you
cannot make these motions |linewise| or |characterwise|, since the |:omap|s
that define them start with "v" in order to make the default behavior
inclusive. (See |o_v|.) In other words, "dV%" will not work. The
work-around is to go through Visual mode: "V%d" will work.
LANGUAGES: *matchit-languages*
Currently, the following languages are supported: Ada, ASP with VBS, Csh,
DTD, Entity, Essbase, Fortran, HTML, JSP (same as HTML), LaTeX, Lua, Pascal,
SGML, Shell, Tcsh, Vim, XML. Other languages may already have support via
the default |filetype-plugin|s in the standard vim distribution.
To support a new language, see |matchit-newlang| below.
DETAILS: *matchit-details* *matchit-parse*
Here is an outline of what matchit.vim does each time you hit the "%" key. If
there are |backref|s in |b:match_words| then the first step is to produce a
version in which these back references have been eliminated; if there are no
|backref|s then this step is skipped. This step is called parsing. For
example, "\(foo\|bar\):end\1" is parsed to yield
"\(foo\|bar\):end\(foo\|bar\)". This can get tricky, especially if there are
nested groups. If debugging is turned on, the parsed version is saved as
|b:match_pat|.
*matchit-choose*
Next, the script looks for a word on the current line that matches the pattern
just constructed. It includes the patterns from the 'matchpairs' option.
The goal is to do what you expect, which turns out to be a little complicated.
The script follows these rules:
Insist on a match that ends on or after the cursor.
Prefer a match that includes the cursor position (that is, one that
starts on or before the cursor).
Prefer a match that starts as close to the cursor as possible.
If more than one pattern in |b:match_words| matches, choose the one
that is listed first.
Examples:
Suppose you >
:let b:match_words = '<:>,<tag>:</tag>'
< and hit "%" with the cursor on or before the "<" in "a <tag> is born".
The pattern '<' comes first, so it is preferred over '<tag>', which
also matches. If the cursor is on the "t", however, then '<tag>' is
preferred, because this matches a bit of text containing the cursor.
If the two groups of patterns were reversed then '<' would never be
preferred.
Suppose you >
:let b:match_words = 'if:end if'
< (Note the space!) and hit "%" with the cursor at the end of "end if".
Then "if" matches, which is probably not what you want, but if the
cursor starts on the "end " then "end if" is chosen. (You can avoid
this problem by using a more complicated pattern.)
If there is no match, the cursor does not move. (Before version 1.13 of the
script, it would fall back on the usual behavior of |%|). If debugging is
turned on, the matched bit of text is saved as |b:match_match| and the cursor
column of the start of the match is saved as |b:match_col|.
Next, the script looks through |b:match_words| (original and parsed versions)
for the group and pattern that match. If debugging is turned on, the group is
saved as |b:match_ini| (the first pattern) and |b:match_tail| (the rest). If
there are |backref|s then, in addition, the matching pattern is saved as
|b:match_word| and a table of translations is saved as |b:match_table|. If
there are |backref|s, these are determined from the matching pattern and
|b:match_match| and substituted into each pattern in the matching group.
The script decides whether to search forwards or backwards and chooses
arguments for the |searchpair()| function. Then, the cursor is moved to the
start of the match, and |searchpair()| is called. By default, matching
structures inside strings and comments are ignored. This can be changed by
setting |b:match_skip|.
==============================================================================
2. Activation *matchit-activate*
You can use this script as a plugin, by copying it to your plugin directory.
See |add-global-plugin| for instructions. You can also add a line to your
|vimrc| file, such as >
:source $VIMRUNTIME/macros/matchit.vim
or >
:runtime macros/matchit.vim
Either way, the script should start working the next time you start up Vim.
(Earlier versions of the script did nothing unless a |buffer-variable| named
|b:match_words| was defined. Even earlier versions contained autocommands
that set this variable for various file types. Now, |b:match_words| is
defined in many of the default |filetype-plugin|s instead.)
For a new language, you can add autocommands to the script or to your vimrc
file, but the recommended method is to add a line such as >
let b:match_words = '\<foo\>:\<bar\>'
to the |filetype-plugin| for your language. See |b:match_words| below for how
this variable is interpreted.
TROUBLESHOOTING *matchit-troubleshoot*
The script should work in most installations of Vim. It may not work if Vim
was compiled with a minimal feature set, for example if the |+syntax| option
was not enabled. If your Vim has support for syntax compiled in, but you do
not have |syntax| highlighting turned on, matchit.vim should work, but it may
fail to skip matching groups in comments and strings. If the |filetype|
mechanism is turned off, the |b:match_words| variable will probably not be
defined automatically.
==============================================================================
3. Configuration *matchit-configure*
There are several variables that govern the behavior of matchit.vim. Note
that these are variables local to the buffer, not options, so use |:let| to
define them, not |:set|. Some of these variables have values that matter; for
others, it only matters whether the variable has been defined. All of these
can be defined in the |filetype-plugin| or autocommand that defines
|b:match_words| or "on the fly."
The main variable is |b:match_words|. It is described in the section below on
supporting a new language.
*MatchError* *matchit-hl* *matchit-highlight*
MatchError is the highlight group for error messages from the script. By
default, it is linked to WarningMsg. If you do not want to be bothered by
error messages, you can define this to be something invisible. For example,
if you use the GUI version of Vim and your command line is normally white, you
can do >
:hi MatchError guifg=white guibg=white
<
*b:match_ignorecase*
If you >
:let b:match_ignorecase = 1
then matchit.vim acts as if 'ignorecase' is set: for example, "end" and "END"
are equivalent. If you >
:let b:match_ignorecase = 0
then matchit.vim treats "end" and "END" differently. (There will be no
b:match_infercase option unless someone requests it.)
*b:match_debug*
Define b:match_debug if you want debugging information to be saved. See
|matchit-debug|, below.
*b:match_skip*
If b:match_skip is defined, it is passed as the skip argument to
|searchpair()|. This controls when matching structures are skipped, or
ignored. By default, they are ignored inside comments and strings, as
determined by the |syntax| mechanism. (If syntax highlighting is turned off,
nothing is skipped.) You can set b:match_skip to a string, which evaluates to
a non-zero, numerical value if the match is to be skipped or zero if the match
should not be skipped. In addition, the following special values are
supported by matchit.vim:
s:foo becomes (current syntax item) =~ foo
S:foo becomes (current syntax item) !~ foo
r:foo becomes (line before cursor) =~ foo
R:foo becomes (line before cursor) !~ foo
(The "s" is meant to suggest "syntax", and the "r" is meant to suggest
"regular expression".)
Examples:
You can get the default behavior with >
:let b:match_skip = 's:comment\|string'
<
If you want to skip matching structures unless they are at the start
of the line (ignoring whitespace) then you can >
:let b:match_skip = 'R:^\s*'
< Do not do this if strings or comments can span several lines, since
the normal syntax checking will not be done if you set b:match_skip.
In LaTeX, since "%" is used as the comment character, you can >
:let b:match_skip = 'r:%'
< Unfortunately, this will skip anything after "\%", an escaped "%". To
allow for this, and also "\\%" (an excaped backslash followed by the
comment character) you can >
:let b:match_skip = 'r:\(^\|[^\\]\)\(\\\\\)*%'
<
See the $VIMRUNTIME/ftplugin/vim.vim for an example that uses both
syntax and a regular expression.
==============================================================================
4. Supporting a New Language *matchit-newlang*
*b:match_words*
In order for matchit.vim to support a new language, you must define a suitable
pattern for |b:match_words|. You may also want to set some of the
|matchit-configure| variables, as described above. If your language has a
complicated syntax, or many keywords, you will need to know something about
Vim's |regular-expression|s.
The format for |b:match_words| is similar to that of the 'matchpairs' option:
it is a comma (,)-separated list of groups; each group is a colon(:)-separated
list of patterns (regular expressions). Commas and backslashes that are part
of a pattern should be escaped with backslashes ('\:' and '\,'). It is OK to
have only one group; the effect is undefined if a group has only one pattern.
A simple example is >
:let b:match_words = '\<if\>:\<endif\>,'
\ . '\<while\>:\<continue\>:\<break\>:\<endwhile\>'
(In Vim regular expressions, |\<| and |\>| denote word boundaries. Thus "if"
matches the end of "endif" but "\<if\>" does not.) Then banging on the "%"
key will bounce the cursor between "if" and the matching "endif"; and from
"while" to any matching "continue" or "break", then to the matching "endwhile"
and back to the "while". It is almost always easier to use |literal-string|s
(single quotes) as above: '\<if\>' rather than "\\<if\\>" and so on.
Exception: If the ":" character does not appear in b:match_words, then it is
treated as an expression to be evaluated. For example, >
:let b:match_words = 'GetMatchWords()'
allows you to define a function. This can return a different string depending
on the current syntax, for example.
Once you have defined the appropriate value of |b:match_words|, you will
probably want to have this set automatically each time you edit the
appropriate file type. The recommended way to do this is by adding the
definition to a |filetype-plugin| file.
Tips: Be careful that your initial pattern does not match your final pattern.
See the example above for the use of word-boundary expressions. It is usually
better to use ".\{-}" (as many as necessary) instead of ".*" (as many as
possible). See |\{-|. For example, in the string "<tag>label</tag>", "<.*>"
matches the whole string whereas "<.\{-}>" and "<[^>]*>" match "<tag>" and
"</tag>".
*matchit-spaces* *matchit-s:notend*
If "if" is to be paired with "end if" (Note the space!) then word boundaries
are not enough. Instead, define a regular expression s:notend that will match
anything but "end" and use it as follows: >
:let s:notend = '\%(\<end\s\+\)\@<!'
:let b:match_words = s:notend . '\<if\>:\<end\s\+if\>'
< *matchit-s:sol*
This is a simplified version of what is done for Ada. The s:notend is a
|script-variable|. Similarly, you may want to define a start-of-line regular
expression >
:let s:sol = '\%(^\|;\)\s*'
if keywords are only recognized after the start of a line or after a
semicolon (;), with optional white space.
*matchit-backref* *matchit-\1*
In any group, the expressions |\1|, |\2|, ..., |\9| refer to parts of the
INITIAL pattern enclosed in |\(|escaped parentheses|\)|. These are referred
to as back references, or backrefs. For example, >
:let b:match_words = '\<b\(o\+\)\>:\(h\)\1\>'
means that "bo" pairs with "ho" and "boo" pairs with "hoo" and so on. Note
that "\1" does not refer to the "\(h\)" in this example. If you have
"\(nested \(parentheses\)\) then "\d" refers to the d-th "\(" and everything
up to and including the matching "\)": in "\(nested\(parentheses\)\)", "\1"
refers to everything and "\2" refers to "\(parentheses\)". If you use a
variable such as |s:notend| or |s:sol| in the previous paragraph then remember
to count any "\(" patterns in this variable. You do not have to count groups
defined by |\%(\)|.
It should be possible to resolve back references from any pattern in the
group. For example, >
:let b:match_words = '\(foo\)\(bar\):more\1:and\2:end\1\2'
would not work because "\2" cannot be determined from "morefoo" and "\1"
cannot be determined from "andbar". On the other hand, >
:let b:match_words = '\(\(foo\)\(bar\)\):\3\2:end\1'
should work (and have the same effect as "foobar:barfoo:endfoobar"), although
this has not been thoroughly tested.
You can use |zero-width| patterns such as |\@<=| and |\zs|. (The latter has
not been thouroughly tested in matchit.vim.) For example, if the keyword "if"
must occur at the start of the line, with optional white space, you might use
the pattern "\(^\s*\)\@<=if" so that the cursor will end on the "i" instead of
at the start of the line. For another example, if HTML had only one tag then
one could >
:let b:match_words = '<:>,<\@<=tag>:<\@<=/tag>'
so that "%" can bounce between matching "<" and ">" pairs or (starting on
"tag" or "/tag") between matching tags. Without the |\@<=|, the script would
bounce from "tag" to the "<" in "</tag>", and another "%" would not take you
back to where you started.
DEBUGGING *matchit-debug* *:MatchDebug*
If you are having trouble figuring out the appropriate definition of
|b:match_words| then you can take advantage of the same information I use when
debugging the script. This is especially true if you are not sure whether
your patterns or my script are at fault! To make this more convenient, I have
made the command :MatchDebug, which defines the variable |b:match_debug| and
creates a Matchit menu. This menu makes it convenient to check the values of
the variables described below. You will probably also want to read
|matchit-details| above.
Defining the variable |b:match_debug| causes the script to set the following
variables, each time you hit the "%" key. Several of these are only defined
if |b:match_words| includes |backref|s.
*b:match_pat*
The b:match_pat variable is set to |b:match_words| with |backref|s parsed.
*b:match_match*
The b:match_match variable is set to the bit of text that is recognized as a
match.
*b:match_col*
The b:match_col variable is set to the cursor column of the start of the
matching text.
*b:match_wholeBR*
The b:match_wholeBR variable is set to the comma-separated group of patterns
that matches, with |backref|s unparsed.
*b:match_iniBR*
The b:match_iniBR variable is set to the first pattern in |b:match_wholeBR|.
*b:match_ini*
The b:match_ini variable is set to the first pattern in |b:match_wholeBR|,
with |backref|s resolved from |b:match_match|.
*b:match_tail*
The b:match_tail variable is set to the remaining patterns in
|b:match_wholeBR|, with |backref|s resolved from |b:match_match|.
*b:match_word*
The b:match_word variable is set to the pattern from |b:match_wholeBR| that
matches |b:match_match|.
*b:match_table*
The back reference '\'.d refers to the same thing as '\'.b:match_table[d] in
|b:match_word|.
==============================================================================
5. Known Bugs and Limitations *matchit-bugs*
Just because I know about a bug does not mean that it is on my todo list. I
try to respond to reports of bugs that cause real problems. If it does not
cause serious problems, or if there is a work-around, a bug may sit there for
a while. Moral: if a bug (known or not) bothers you, let me know.
The various |:vmap|s defined in the script (%, |g%|, |[%|, |]%|, |a%|) may
have undesired effects in Select mode |Select-mode-mapping|. At least, if you
want to replace the selection with any character in "ag%[]" there will be a
pause of |'updatetime'| first.
It would be nice if "\0" were recognized as the entire pattern. That is, it
would be nice if "foo:\end\0" had the same effect as "\(foo\):\end\1". I may
try to implement this in a future version. (This is not so easy to arrange as
you might think!)
==============================================================================
vim:tw=78:fo=tcq2:

195
vimfiles/doc/pi_netrw.txt
View File

@ -1,4 +1,4 @@
*pi_netrw.txt* For Vim version 7.1. Last change: 2007 Oct 02
*pi_netrw.txt* For Vim version 7.1. Last change: 2007 Dec 12
-----------------------------------------------------
NETRW REFERENCE MANUAL by Charles E. Campbell, Jr.
@ -146,9 +146,9 @@ EXTERNAL APPLICATIONS AND PROTOCOLS *netrw-externapp* {{{2
dav: *g:netrw_dav_cmd* = "cadaver"
fetch: *g:netrw_fetch_cmd* = "fetch -o" if fetch is available
ftp: *g:netrw_ftp_cmd* = "ftp"
http: *g:netrw_http_cmd* = "curl -o" if curl is available
http: g:netrw_http_cmd = "wget -q -O" else if wget is available
http: g:netrw_http_cmd = "fetch -o" else if fetch is available
http: *g:netrw_http_cmd* = "curl -o" if curl is available
http: g:netrw_http_cmd = "wget -q -O" elseif wget is available
http: g:netrw_http_cmd = "fetch -o" elseif fetch is available
rcp: *g:netrw_rcp_cmd* = "rcp"
rsync: *g:netrw_rsync_cmd* = "rsync -a"
scp: *g:netrw_scp_cmd* = "scp -q"
@ -233,7 +233,7 @@ CHANGING USERID AND PASSWORD *netrw-chgup* *netrw-userpass* {{{2
Attempts to use ftp will prompt you for a user-id and a password.
These will be saved in global variables g:netrw_uid and
g:netrw_passwd; subsequent uses of ftp will re-use those two items to
s:netrw_passwd; subsequent uses of ftp will re-use those two items to
simplify the further use of ftp. However, if you need to use a
different user id and/or password, you'll want to call NetUserPass()
first. To work around the need to enter passwords, check if your ftp
@ -271,8 +271,8 @@ NETRW VARIABLES AND SETTINGS *netrw-variables* {{{2
*g:netrw_ignorenetrc* =0 (default for linux, cygwin)
=1 If you have a <.netrc> file but it doesn't work and
you want it ignored, then set this variable as shown.
(default for Windows + cmd.exe)
you want it ignored, then set this variable as
shown. (default for Windows + cmd.exe)
*g:netrw_menu* =0 disable netrw's menu
=1 (default) netrw's menu enabled
@ -281,13 +281,13 @@ NETRW VARIABLES AND SETTINGS *netrw-variables* {{{2
be available (see |netrw-gx|)
*g:netrw_uid* (ftp) user-id, retained on a per-session basis
*g:netrw_passwd* (ftp) password, retained on a per-session basis
*s:netrw_passwd* (ftp) password, retained on a per-session basis
*g:netrw_preview* =0 (default) preview window shown in a horizontally
split window
=1 preview window shown in a vertically split window.
Affects the "previous window" (see |netrw-P|) the same
way.
Also affects the "previous window" (see |netrw-P|) in
the same way.
*g:netrw_shq* = "'" for Unix/Linux systems (ie. a single quote)
= "'" for Windows + cygwin systems (ie. a single quote)
@ -562,18 +562,18 @@ below, a {netfile} is an url to a remote file.
--cmd "source scp://HOSTNAME/.vimrc"
< *netrw-uidpass*
:call NetUserPass()
If b:netrw_uid and b:netrw_passwd don't exist,
this function query the user for them.
If g:netrw_uid and s:netrw_passwd don't exist,
this function will query the user for them.
:call NetUserPass("userid")
This call will set the b:netrw_uid and, if
This call will set the g:netrw_uid and, if
the password doesn't exist, will query the user for it.
:call NetUserPass("userid","passwd")
This call will set both the b:netrw_uid and b:netrw_passwd.
This call will set both the g:netrw_uid and s:netrw_passwd.
The user-id and password are used by ftp transfers. One may
effectively remove the user-id and password by using ""
strings.
effectively remove the user-id and password by using empty
strings (ie. "").
:NetrwSettings This command is described in |netrw-settings| -- used to
display netrw settings and change netrw behavior.
@ -637,7 +637,7 @@ temporarily.
g:netrw_fname Holds filename being accessed >
------------------------------------------------------------
<
*netrw-protocol*
*netrw-protocol*
Netrw supports a number of protocols. These protocols are invoked using the
variables listed below, and may be modified by the user.
@ -922,7 +922,23 @@ button. A doubly-clicked leftmouse button will return to the netrw browser
window (unless |g:netrw_noretmap| is used, or the double-click leftmouse map
is already defined before netrw is loaded).
Netrw attempts to speed up browsing, especially for remote browsing where one
may have to enter passwords, by keeping and re-using previously obtained
directory listing buffers. The |g:netrw_fastbrowse| variable is used to
control this behavior; one may have slow browsing (no buffer re-use), medium
speed browsing (re-use directory buffer listings only for remote directories),
and fast browsing (re-use directory buffer listings as often as possible).
The price for such re-use is that when changes are made (such as new files
are introduced into a directory), the listing may become out-of-date. One may
always refresh directory listing buffers by pressing ctrl-L (see
|netrw-ctrl-l|).
Related topics: |netrw-o| |netrw-p| |netrw-P| |netrw-t| |netrw-v|
Associated setting variables: |g:netrw_browse_split| |g:netrw_fastbrowse|
|g:netrw_ftp_list_cmd| |g:netrw_ftp_sizelist_cmd|
|g:netrw_ftp_timelist_cmd| |g:netrw_ssh_cmd|
|g:netrw_ssh_browse_reject| |g:netrw_use_noswf|
BROWSING WITH A HORIZONTALLY SPLIT WINDOW *netrw-o* *netrw-horiz* {{{2
@ -937,11 +953,13 @@ new window and cursor at the bottom, have
let g:netrw_alto = 1
in your <.vimrc>. (also see |netrw-t| |netrw-v| |g:netrw_alto|)
in your <.vimrc>. (also see |netrw-t| |netrw-v|)
There is only one tree listing buffer; using "o" on a displayed subdirectory
will split the screen, but the same buffer will be shown twice.
Associated setting variables: |g:netrw_alto| |g:netrw_winsize|
BROWSING WITH A NEW TAB *netrw-t* {{{2
@ -962,11 +980,12 @@ window and cursor at the right, have
let g:netrw_altv = 1
in your <.vimrc>. (also see: |netrw-o| |netrw-t| |g:netrw_altv|)
in your <.vimrc>. (also see: |netrw-o| |netrw-t|)
There is only one tree listing buffer; using "v" on a displayed subdirectory
will split the screen, but the same buffer will be shown twice.
Associated setting variable: |g:netrw_altv| |g:netrw_winsize|
CHANGE LISTING STYLE *netrw-i* {{{2
@ -992,6 +1011,9 @@ key while atop the directory name. There is only one tree listing buffer;
hence, using "v" or "o" on a subdirectory will only show the same buffer,
twice.
Associated setting variables: |g:netrw_liststyle| |g:netrw_maxfilenamelen|
|g:netrw_timefmt| |g:netrw_list_cmd|
CHANGING TO A BOOKMARKED DIRECTORY *netrw-gb* {{{2
@ -1019,7 +1041,7 @@ This map is the opposite of the "u" map. (see |netrw-u|) Use the
q map to list both the bookmarks and history. (see |netrw-q|)
NETRW CLEAN *netrw-clean*
NETRW CLEAN *netrw-clean* *:NetrwClean*
With :NetrwClean one may easily remove netrw from one's home directory;
more precisely, from the first directory on your |'runtimepath'|.
@ -1102,6 +1124,8 @@ If more such translations are necessary, please send me email: >
NdrOchip at ScampbellPfamily.AbizM - NOSPAM
with a request.
Associated setting variable: |g:netrw_browsex_viewer|
*netrw-curdir*
DELETING FILES OR DIRECTORIES *netrw-delete* *netrw-D* *netrw-del* {{{2
@ -1136,6 +1160,10 @@ to remove it again using the g:netrw_rmf_cmd variable. Its default value is:
g:netrw_rmf_cmd: ssh HOSTNAME rm -f
Associated setting variable: |g:netrw_local_rmdir| |g:netrw_rm_cmd|
|g:netrw_rmdir_cmd| |g:netrw_ssh_cmd|
*netrw-explore* *netrw-hexplore* *netrw-nexplore* *netrw-pexplore*
*netrw-rexplore* *netrw-sexplore* *netrw-texplore* *netrw-vexplore*
DIRECTORY EXPLORATION COMMANDS {{{2
@ -1233,6 +1261,12 @@ then Explore will use |:vimgrep| to find files like |netrw-starpat|;
however, Explore will also search subdirectories as well as the current
directory.
Associated setting variables: |g:netrw_keepdir| |g:netrw_browse_split|
|g:netrw_fastbrowse| |g:netrw_ftp_browse_reject|
|g:netrw_ftp_list_cmd| |g:netrw_ftp_sizelist_cmd|
|g:netrw_ftp_timelist_cmd| |g:netrw_list_cmd|
|g:netrw_liststyle|
EDIT FILE OR DIRECTORY HIDING LIST *netrw-ctrl-h* *netrw-edithide* {{{2
@ -1242,6 +1276,8 @@ delimited by commas. Files and/or directories satisfying these patterns will
either be hidden (ie. not shown) or be the only ones displayed (see
|netrw-a|).
Associated setting variable: |g:netrw_hide|
EDITING THE SORTING SEQUENCE *netrw-S* *netrw-sortsequence* {{{2
@ -1257,6 +1293,9 @@ will end up. One may change the sorting sequence by modifying the
g:netrw_sort_sequence variable (either manually or in your <.vimrc>) or by
using the "S" map.
Related topics: |g:netrw-s| |g:netrw-S|
Associated setting variable: |g:netrw_sort_sequence|
GOING UP *netrw--* {{{2
@ -1283,24 +1322,25 @@ match.
If no files have been marked via |netrw-mf|:
The "a" map allows the user to cycle about these three ways.
The "a" map allows the user to cycle through the three hiding modes.
The g:netrw_list_hide variable holds a comma delimited list of patterns (ex.
\.obj) which specify the hiding list. (also see |netrw-ctrl-h|) To set the
hiding list, use the <c-h> map. As an example, to hide files which begin with
a ".", one may use the <c-h> map to set the hiding list to '^\..*' (or one may
put let g:netrw_list_hide= '^\..*' in one's <.vimrc>). One may then use the
"a" key to show all files, hide matching files, or to show only the matching
files.
The |g:netrw_list_hide| variable holds a comma delimited list of patterns
based on regular expressions (ex. ^.*\.obj$,^\.) which specify the hiding list.
(also see |netrw-ctrl-h|) To set the hiding list, use the <c-h> map. As an
example, to hide files which begin with a ".", one may use the <c-h> map to
set the hiding list to '^\..*' (or one may put let g:netrw_list_hide= '^\..*'
in one's <.vimrc>). One may then use the "a" key to show all files, hide
matching files, or to show only the matching files.
Example: ^.*\.[ch]
Example: \.[ch]$
This hiding list command will hide/show all *.c and *.h files.
Example: ^.*\.c,^.*\.h
Example: \.c$,\.h$
This hiding list command will also hide/show all *.c and *.h
files.
Don't forget to use the "a" map to select the normal/hiding/show mode you want!
Don't forget to use the "a" map to select the mode (normal/hiding/show) you
want!
If files have been marked using |netrw-mf|, then this command will:
@ -1313,6 +1353,8 @@ If files have been marked using |netrw-mf|, then this command will:
and showing only non-hidden files.
endif
Associated setting variable: |g:netrw_list_hide|
*netrw-ctrl_h*
IMPROVING BROWSING *netrw-listhack* *netrw-ssh-hack* {{{2
@ -1373,6 +1415,8 @@ directory's name. A bare <CR> at that point will abort the making of the
directory. Attempts to make a local directory that already exists (as either
a file or a directory) will be detected, reported on, and ignored.
Associated setting variable: |g:netrw_local_mkdir| |g:netrw_mkdir_cmd|
MAKING THE BROWSING DIRECTORY THE CURRENT DIRECTORY *netrw-c* {{{2
@ -1388,6 +1432,8 @@ the two directories the same, use the "c" map (just type c). That map will
set Vim's notion of the current directory to netrw's current browsing
directory.
Associated setting variable: |g:netrw_keepdir|
MARKED FILES: ARBITRARY COMMAND *netrw-mx* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files)
@ -1409,12 +1455,16 @@ that's "gzip".
For decompression, netrw provides a |Dictionary| of suffices and their
associated decompressing utilities; see |g:netrw_decompress|.
Associated setting variables: |g:netrw_compress| |g:netrw_decompress|
MARKED FILES: COPYING *netrw-mc* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files)
Select a target directory with mT (|netrw-mt|). Then change directory,
Select a target directory with mt (|netrw-mt|). Then change directory,
select file(s) (see |netrw-mf|), and press "mc".
Associated setting variable: |g:netrw_localcopycmd| |g:netrw_ssh_cmd|
MARKED FILES: DIFF *netrw-md* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files)
@ -1433,6 +1483,8 @@ MARKED FILES: MOVING *netrw-mm* {{{2
Select a target directory with mT (|netrw-mt|). Then change directory,
select file(s) (see |netrw-mf|), and press "mm".
Associated setting variable: |g:netrw_localmovecmd| |g:netrw_ssh_cmd|
MARKED FILES: PRINTING *netrw-mp* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files)
@ -1449,7 +1501,11 @@ The "mt" mapping will apply the command in |g:netrw_ctags| (by default, its
netrw will use ssh (see |g:netrw_ssh_cmd|), and so ssh must be available for
this to work on remote systems. For your local system, see |ctags| on how to
get a version. I myself use hdrtags, currently available at
http://mysite.verizon.net/astronaut/src/index.html .
http://mysite.verizon.net/astronaut/src/index.html , and have >
let g:netrw_ctags= "hdrtag"
<
in my <.vimrc>.
When a remote set of files are tagged, the resulting tags file is "obtained";
ie. a copy is transferred to the local system's directory. The local tags
@ -1459,6 +1515,8 @@ preceded by the netrw-compatible url used to obtain it. When one subsequently
uses one of the go to tag actions (|tags|), the url will be used by netrw to
edit the desired file and go to the tag.
Associated setting variables: |g:netrw_ctags| |g:netrw_ssh_cmd|
MARKED FILES: SETTING TARGET DIRECTORY *netrw-mt* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files)
@ -1525,6 +1583,7 @@ your browsing preferences. (see also: |netrw-settings|)
=1: horizontally splitting the window first
=2: vertically splitting the window first
=3: open file in new tab
=4: act like "P" (ie. open previous window)
*g:netrw_browsex_viewer* specify user's preference for a viewer: >
"kfmclient exec"
@ -1616,6 +1675,7 @@ your browsing preferences. (see also: |netrw-settings|)
= 2: wide listing (multiple files in columns)
= 3: tree style listing
*g:netrw_list_hide* comma separated pattern list for hiding files
Patterns are regular expressions (see |regexp|)
default: ""
*g:netrw_localcopycmd* ="cp" Linux/Unix/MacOS/Cygwin
@ -1689,7 +1749,14 @@ your browsing preferences. (see also: |netrw-settings|)
let g:netrw_use_noswf= 0
in your .vimrc.
*g:netrw_timefmt* specify format string to strftime() (%c)
*g:netrw_timefmt* specify format string to vim's strftime().
The default, "%c", is "the preferred date
and time representation for the current
locale" according to my manpage entry for
strftime(); however, not all are satisfied
with it. Some alternatives:
"%a %d %b %Y %T",
" %a %Y-%m-%d %I-%M-%S %p"
default: "%c"
*g:netrw_winsize* specify initial size of new o/v windows
@ -1702,14 +1769,14 @@ your browsing preferences. (see also: |netrw-settings|)
NETRW BROWSING AND OPTION INCOMPATIBILITIES *netrw-incompatible* {{{2
Netrw will not work properly with >
Netrw has been designed to handle user options by saving them, setting the
options to something that's compatible with netrw's needs, and then restoring
them. However, the autochdir option: >
:set acd
:set fo=...ta...
<
If either of these options are present when browsing is attempted, netrw
will change them by using noacd and removing the ta suboptions from the
|'formatoptions'|.
is problematical. Autochdir sets the current directory to that containing the
file you edit; this apparently also applies to directories. In other words,
autochdir sets the current directory to that containing the "file" (even if
that "file" is itself a directory).
NETRW SETTINGS *netrw-settings* {{{2
@ -1814,6 +1881,9 @@ REVERSING SORTING ORDER *netrw-r* *netrw-reverse* {{{2
One may toggle between normal and reverse sorting order by pressing the
"r" key.
Related topics: |g:netrw-s|
Associated setting variable: |g:netrw_sort_direction|
SELECTING SORTING STYLE *netrw-s* *netrw-sort* {{{2
@ -1821,6 +1891,9 @@ One may select the sorting style by name, time, or (file) size. The "s" map
allows one to circulate amongst the three choices; the directory listing will
automatically be refreshed to reflect the selected style.
Related topics: |g:netrw-r| |g:netrw-S|
Associated setting variables: |g:netrw_sort_by| |g:netrw_sort_sequence|
10. Problems and Fixes *netrw-problems* {{{1
@ -1975,15 +2048,23 @@ automatically be refreshed to reflect the selected style.
8.3 Getting ready for public key authentication
<
How to use a private key with 'pscp': >
http://www.tartarus.org/~simon/puttydoc/Chapter5.html
5.2.4 Using public key authentication with PSCP
<
(Ben Schmidt) I find the ssh included with cwRsync is
brilliant, and install cwRsync or cwRsyncServer on most
Windows systems I come across these days. I guess COPSSH,
packed by the same person, is probably even better for use as
just ssh on Windows, and probably includes sftp, etc. which I
suspect the cwRsync doesn't, though it might
(cec) To make proper use of these suggestions above, you will
need to modify the following user-settable variables in your
.vimrc:
|g:netrw_ssh_cmd| |g:netrw_list_cmd| |g:netrw_mkdir_cmd|
|g:netrw_rm_cmd| |g:netrw_rmdir_cmd| |g:netrw_rmf_cmd|
|g:netrw_ssh_cmd| |g:netrw_list_cmd| |g:netrw_mkdir_cmd|
|g:netrw_rm_cmd| |g:netrw_rmdir_cmd| |g:netrw_rmf_cmd|
The first one (|g:netrw_ssh_cmd|) is the most important; most
of the others will use the string in g:netrw_ssh_cmd by
@ -2081,6 +2162,32 @@ which is loaded automatically at startup (assuming :set nocp).
==============================================================================
12. History *netrw-history* {{{1
v116: Nov 27, 2007 * netrw#LocalBrowseCheck() has &ft=="netrw"
check to prevent doing a directory listing
(was getting unexpected directory refreshes
in the middle of some function calls)
* NetrwOptionRestore moved after e! filename
in order to retain user options for editing
in s:NetrwBrowseChgDir()
Dec 12, 2007 * Bug fix -- netrw does a better job of retaining
user options when editing files under the aegis
of the browser
v115: Oct 04, 2007 * Erik Remmelzwaal pointed out that the use of
shellslash in s:GetTempfile() was incorrect
Oct 11, 2007 * Tracked down and eliminated a bug with editing
remote *.tar.gz and *.tar.bz2 files
Oct 11, 2007 * g:netrw_localmovecmd wasn't being initialized
properly, and g:netrw_localcopycmd was being
overwritten.
Oct 12, 2007 * Placed all :Rexplore and <2-leftmouse> setup
in a new support function (s:SetRexDir()).
Oct 15, 2007 * new: g:netrw_browse_split == 4; means <cr>
based selection will use previous window
Oct 20, 2007 * also checks on |'shellxquote'| to set g:netrw_shq
Oct 24, 2007 * Explore handles path/**/filename
Oct 27, 2007 * sourcing remote files often didn't work with ftp,
turns out that b:netrw_method was undefined, so
s:SaveBufVars and s:RestoreBufVars() fixed it.
v114: Sep 28, 2007 * mT, the map that invokes tags, has been improved
to support use of remote tags files.
Oct 02, 2007 * changed Netrw menu to use more submenus
@ -2258,7 +2365,7 @@ which is loaded automatically at startup (assuming :set nocp).
was preventing use of the "x" key with browsing.
Jun 05, 2006 * g:netrw_nogx available to prevent making the gx
map (see |g:netrw_nogx|)
* bugfix, Explore woulnd't change directory
* bugfix, Explore wouldn't change directory
properly (vim ., :Explore subdirname)
Jun 06, 2006 * moved history to 2nd line in Netrw menu
* fixed delete for unix-based systems

53
vimfiles/doc/tags
View File

@ -5,7 +5,9 @@
:LP LogiPat.txt /*:LP*
:LPF LogiPat.txt /*:LPF*
:LogiPat LogiPat.txt /*:LogiPat*
:MatchDebug matchit.txt /*:MatchDebug*
:MkVimball pi_vimball.txt /*:MkVimball*
:NetrwClean pi_netrw.txt /*:NetrwClean*
:Nexplore pi_netrw.txt /*:Nexplore*
:Pexplore pi_netrw.txt /*:Pexplore*
:Rexplore pi_netrw.txt /*:Rexplore*
@ -40,11 +42,27 @@ IX visincr.txt /*IX*
IYMD visincr.txt /*IYMD*
LogiPat() LogiPat.txt /*LogiPat()*
LogiPat-flags LogiPat.txt /*LogiPat-flags*
MatchError matchit.txt /*MatchError*
Nread pi_netrw.txt /*Nread*
Nsource pi_netrw.txt /*Nsource*
Nwrite pi_netrw.txt /*Nwrite*
TCommentDefineType() tComment.txt /*TCommentDefineType()*
Vimball-copyright pi_vimball.txt /*Vimball-copyright*
[% matchit.txt /*[%*
]% matchit.txt /*]%*
b:match_col matchit.txt /*b:match_col*
b:match_debug matchit.txt /*b:match_debug*
b:match_ignorecase matchit.txt /*b:match_ignorecase*
b:match_ini matchit.txt /*b:match_ini*
b:match_iniBR matchit.txt /*b:match_iniBR*
b:match_match matchit.txt /*b:match_match*
b:match_pat matchit.txt /*b:match_pat*
b:match_skip matchit.txt /*b:match_skip*
b:match_table matchit.txt /*b:match_table*
b:match_tail matchit.txt /*b:match_tail*
b:match_wholeBR matchit.txt /*b:match_wholeBR*
b:match_word matchit.txt /*b:match_word*
b:match_words matchit.txt /*b:match_words*
b:netrw_lastfile pi_netrw.txt /*b:netrw_lastfile*
crefvim crefvim.txt /*crefvim*
crefvim.txt crefvim.txt /*crefvim.txt*
@ -1279,6 +1297,7 @@ ex-visincr-IMDY visincr.txt /*ex-visincr-IMDY*
ex-visincr-IYMD visincr.txt /*ex-visincr-IYMD*
fetch pi_netrw.txt /*fetch*
ftp pi_netrw.txt /*ftp*
g% matchit.txt /*g%*
g:NetrwTopLvlMenu pi_netrw.txt /*g:NetrwTopLvlMenu*
g:netrw_alto pi_netrw.txt /*g:netrw_alto*
g:netrw_altv pi_netrw.txt /*g:netrw_altv*
@ -1314,7 +1333,6 @@ g:netrw_menu pi_netrw.txt /*g:netrw_menu*
g:netrw_mkdir_cmd pi_netrw.txt /*g:netrw_mkdir_cmd*
g:netrw_nogx pi_netrw.txt /*g:netrw_nogx*
g:netrw_noretmap pi_netrw.txt /*g:netrw_noretmap*
g:netrw_passwd pi_netrw.txt /*g:netrw_passwd*
g:netrw_preview pi_netrw.txt /*g:netrw_preview*
g:netrw_rcp_cmd pi_netrw.txt /*g:netrw_rcp_cmd*
g:netrw_rm_cmd pi_netrw.txt /*g:netrw_rm_cmd*
@ -1379,6 +1397,31 @@ logipat-manual LogiPat.txt /*logipat-manual*
logipat-operators LogiPat.txt /*logipat-operators*
logipat-pattern LogiPat.txt /*logipat-pattern*
logipat.txt LogiPat.txt /*logipat.txt*
matchit matchit.txt /*matchit*
matchit-% matchit.txt /*matchit-%*
matchit-\1 matchit.txt /*matchit-\\1*
matchit-activate matchit.txt /*matchit-activate*
matchit-backref matchit.txt /*matchit-backref*
matchit-bugs matchit.txt /*matchit-bugs*
matchit-choose matchit.txt /*matchit-choose*
matchit-configure matchit.txt /*matchit-configure*
matchit-debug matchit.txt /*matchit-debug*
matchit-details matchit.txt /*matchit-details*
matchit-highlight matchit.txt /*matchit-highlight*
matchit-hl matchit.txt /*matchit-hl*
matchit-intro matchit.txt /*matchit-intro*
matchit-languages matchit.txt /*matchit-languages*
matchit-modes matchit.txt /*matchit-modes*
matchit-newlang matchit.txt /*matchit-newlang*
matchit-o_% matchit.txt /*matchit-o_%*
matchit-parse matchit.txt /*matchit-parse*
matchit-s:notend matchit.txt /*matchit-s:notend*
matchit-s:sol matchit.txt /*matchit-s:sol*
matchit-spaces matchit.txt /*matchit-spaces*
matchit-troubleshoot matchit.txt /*matchit-troubleshoot*
matchit-v_% matchit.txt /*matchit-v_%*
matchit.txt matchit.txt /*matchit.txt*
matchit.vim matchit.txt /*matchit.vim*
netreadfixup pi_netrw.txt /*netreadfixup*
netrw pi_netrw.txt /*netrw*
netrw-- pi_netrw.txt /*netrw--*
@ -1521,6 +1564,9 @@ netrw-xfer pi_netrw.txt /*netrw-xfer*
netrw.vim pi_netrw.txt /*netrw.vim*
netrw_filehandler pi_netrw.txt /*netrw_filehandler*
network pi_netrw.txt /*network*
o_[% matchit.txt /*o_[%*
o_]% matchit.txt /*o_]%*
o_g% matchit.txt /*o_g%*
op-opAsRightShift crefvim.txt /*op-opAsRightShift*
opAsBitAnd crefvim.txt /*opAsBitAnd*
opAsBitOr crefvim.txt /*opAsBitOr*
@ -1530,6 +1576,7 @@ pi_netrw.txt pi_netrw.txt /*pi_netrw.txt*
pi_vimball.txt pi_vimball.txt /*pi_vimball.txt*
rcp pi_netrw.txt /*rcp*
rsync pi_netrw.txt /*rsync*
s:netrw_passwd pi_netrw.txt /*s:netrw_passwd*
scp pi_netrw.txt /*scp*
sftp pi_netrw.txt /*sftp*
tComment-Installation tComment.txt /*tComment-Installation*
@ -1537,6 +1584,10 @@ tComment-Key-Bindings tComment.txt /*tComment-Key-Bindings*
tComment-Usage tComment.txt /*tComment-Usage*
tComment-commands tComment.txt /*tComment-commands*
tComment.txt tComment.txt /*tComment.txt*
v_[% matchit.txt /*v_[%*
v_]% matchit.txt /*v_]%*
v_a% matchit.txt /*v_a%*
v_g% matchit.txt /*v_g%*
vba pi_vimball.txt /*vba*
vimball pi_vimball.txt /*vimball*
vimball-contents pi_vimball.txt /*vimball-contents*

36
vimfiles/plugin/blockdiff.vim
View File

@ -2,25 +2,38 @@
"
" Author: Timo Teifel
" Email: timo dot teifel at teifel dot net
" Version: 1.0
" Date: 22 Oct 2007
" Version: 1.1
" Date: 23 Oct 2007
" Licence: GPL v2.0
"
" Usage:
" - Select first block
" - Depending on the configuration, select:
" - Menu BlockDiff-> This\ is\ Block\ 1
" - Menu Tools->BlockDiff-> This\ is\ Block\ 1
" - Popup-Menu -> This\ is\ Block\ 1
" - :BlockDiff1
" - ,d1
" - select second block (may be in another file, but in the same
" Vim window)
" - Menu BlockDiff-> This\ is\ Block\ 2,\ start\ diff
" - Menu Tools->BlockDiff-> This\ is\ Block\ 2,\ start\ diff
" - Popup-Menu -> This\ is\ Block\ 2,\ start\ diff
" - :BlockDiff2
" - ,d2
" - Script opens a new tab, splits it and shows the diff between
" the two blocks.
" - Close the tab when done
"
" History:
" V1.0: Initial upload
" V1.1: Added commands and inclusion guard, Thanks to Ingo Karkat
" Avoid installing twice or when in compatible mode
if exists('g:loaded_blockdiff') || (v:version < 700)
finish
endif
let g:loaded_blockdiff = 1
let s:save_cpo = &cpo
set cpo&vim
@ -30,18 +43,21 @@ set cpo&vim
" Create menu entry:
vmenu BlockDiff.This\ is\ block\ 1 :call BlockDiff_GetBlock1()<CR>
vmenu BlockDiff.This\ is\ block\ 2,\ start\ diff :call BlockDiff_GetBlock2()<CR>
vmenu 40.352.10 &Tools.Bloc&kDiff.This\ is\ Block\ &1 :call BlockDiff_GetBlock1()<CR>
vmenu 40.352.20 &Tools.Bloc&kDiff.This\ is\ Block\ &2,\ start\ diff :call BlockDiff_GetBlock2()<CR>
" Create popup-menu-entry:
"vmenu PopUp.BlockDiff.This\ is\ block\ 1 :call BlockDiff_GetBlock1()<CR>
"vmenu PopUp.BlockDiff.This\ is\ block\ 2,\ start\ diff :call BlockDiff_GetBlock2()<CR>
"vmenu PopUp.BlockDiff.This\ is\ Block\ 1 :call BlockDiff_GetBlock1()<CR>
"vmenu PopUp.BlockDiff.This\ is\ Block\ 2,\ start\ diff :call BlockDiff_GetBlock2()<CR>
" Shortcuts
"vmap ,d1 :call BlockDiff_GetBlock1()<CR>
"vmap ,d2 :call BlockDiff_GetBlock2()<CR>
" Commands
command! -range BlockDiff1 :<line1>,<line2>call BlockDiff_GetBlock1()
command! -range BlockDiff2 :<line1>,<line2>call BlockDiff_GetBlock2()
" ---------- Code -------------------------------------------------------------
@ -61,7 +77,7 @@ fun! BlockDiff_GetBlock2() range
" Open new tab, paste second selected block
tabnew
normal p
normal P
" to prevent 'No write since last change' message:
se buftype=nowrite
diffthis
@ -70,7 +86,7 @@ fun! BlockDiff_GetBlock2() range
lefta vnew
" copy first block into unnamed register & paste
let @@ = s:block1
normal p
normal P
se buftype=nowrite
" start diff

811
vimfiles/plugin/matchit.vim Normal file
View File

@ -0,0 +1,811 @@
" matchit.vim: (global plugin) Extended "%" matching
" Last Change: Sun Sep 09 09:00 AM 2007 EDT
" Maintainer: Benji Fisher PhD <benji@member.AMS.org>
" Version: 1.13.1, for Vim 6.3+
" URL: http://www.vim.org/script.php?script_id=39
" Documentation:
" The documentation is in a separate file, matchit.txt .
" Credits:
" Vim editor by Bram Moolenaar (Thanks, Bram!)
" Original script and design by Raul Segura Acevedo
" Support for comments by Douglas Potts
" Support for back references and other improvements by Benji Fisher
" Support for many languages by Johannes Zellner
" Suggestions for improvement, bug reports, and support for additional
" languages by Jordi-Albert Batalla, Neil Bird, Servatius Brandt, Mark
" Collett, Stephen Wall, Dany St-Amant, Yuheng Xie, and Johannes Zellner.
" Debugging:
" If you'd like to try the built-in debugging commands...
" :MatchDebug to activate debugging for the current buffer
" This saves the values of several key script variables as buffer-local
" variables. See the MatchDebug() function, below, for details.
" TODO: I should think about multi-line patterns for b:match_words.
" This would require an option: how many lines to scan (default 1).
" This would be useful for Python, maybe also for *ML.
" TODO: Maybe I should add a menu so that people will actually use some of
" the features that I have implemented.
" TODO: Eliminate the MultiMatch function. Add yet another argument to
" Match_wrapper() instead.
" TODO: Allow :let b:match_words = '\(\(foo\)\(bar\)\):\3\2:end\1'
" TODO: Make backrefs safer by using '\V' (very no-magic).
" TODO: Add a level of indirection, so that custom % scripts can use my
" work but extend it.
" allow user to prevent loading
" and prevent duplicate loading
if exists("loaded_matchit") || &cp
finish
endif
let loaded_matchit = 1
let s:last_mps = ""
let s:last_words = ":"
let s:save_cpo = &cpo
set cpo&vim
nnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'n') <CR>
nnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'n') <CR>
vnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'v') <CR>m'gv``
vnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'v') <CR>m'gv``
onoremap <silent> % v:<C-U>call <SID>Match_wrapper('',1,'o') <CR>
onoremap <silent> g% v:<C-U>call <SID>Match_wrapper('',0,'o') <CR>
" Analogues of [{ and ]} using matching patterns:
nnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "n") <CR>
nnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "n") <CR>
vmap [% <Esc>[%m'gv``
vmap ]% <Esc>]%m'gv``
" vnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "v") <CR>m'gv``
" vnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "v") <CR>m'gv``
onoremap <silent> [% v:<C-U>call <SID>MultiMatch("bW", "o") <CR>
onoremap <silent> ]% v:<C-U>call <SID>MultiMatch("W", "o") <CR>
" text object:
vmap a% <Esc>[%v]%
" Auto-complete mappings: (not yet "ready for prime time")
" TODO Read :help write-plugin for the "right" way to let the user
" specify a key binding.
" let g:match_auto = '<C-]>'
" let g:match_autoCR = '<C-CR>'
" if exists("g:match_auto")
" execute "inoremap " . g:match_auto . ' x<Esc>"=<SID>Autocomplete()<CR>Pls'
" endif
" if exists("g:match_autoCR")
" execute "inoremap " . g:match_autoCR . ' <CR><C-R>=<SID>Autocomplete()<CR>'
" endif
" if exists("g:match_gthhoh")
" execute "inoremap " . g:match_gthhoh . ' <C-O>:call <SID>Gthhoh()<CR>'
" endif " gthhoh = "Get the heck out of here!"
let s:notslash = '\\\@<!\%(\\\\\)*'
function! s:Match_wrapper(word, forward, mode) range
" In s:CleanUp(), :execute "set" restore_options .
let restore_options = (&ic ? " " : " no") . "ignorecase"
if exists("b:match_ignorecase")
let &ignorecase = b:match_ignorecase
endif
let restore_options = " ve=" . &ve . restore_options
set ve=
" If this function was called from Visual mode, make sure that the cursor
" is at the correct end of the Visual range:
if a:mode == "v"
execute "normal! gv\<Esc>"
endif
" In s:CleanUp(), we may need to check whether the cursor moved forward.
let startline = line(".")
let startcol = col(".")
" Use default behavior if called with a count.
if v:count
exe "normal! " . v:count . "%"
return s:CleanUp(restore_options, a:mode, startline, startcol)
end
" First step: if not already done, set the script variables
" s:do_BR flag for whether there are backrefs
" s:pat parsed version of b:match_words
" s:all regexp based on s:pat and the default groups
"
if !exists("b:match_words") || b:match_words == ""
let match_words = ""
" Allow b:match_words = "GetVimMatchWords()" .
elseif b:match_words =~ ":"
let match_words = b:match_words
else
execute "let match_words =" b:match_words
endif
" Thanks to Preben "Peppe" Guldberg and Bram Moolenaar for this suggestion!
if (match_words != s:last_words) || (&mps != s:last_mps) ||
\ exists("b:match_debug")
let s:last_words = match_words
let s:last_mps = &mps
" The next several lines were here before
" BF started messing with this script.
" quote the special chars in 'matchpairs', replace [,:] with \| and then
" append the builtin pairs (/*, */, #if, #ifdef, #else, #elif, #endif)
" let default = substitute(escape(&mps, '[$^.*~\\/?]'), '[,:]\+',
" \ '\\|', 'g').'\|\/\*\|\*\/\|#if\>\|#ifdef\>\|#else\>\|#elif\>\|#endif\>'
let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
\ '\/\*:\*\/,#if\%(def\)\=:#else\>:#elif\>:#endif\>'
" s:all = pattern with all the keywords
let match_words = match_words . (strlen(match_words) ? "," : "") . default
if match_words !~ s:notslash . '\\\d'
let s:do_BR = 0
let s:pat = match_words
else
let s:do_BR = 1
let s:pat = s:ParseWords(match_words)
endif
let s:all = substitute(s:pat, s:notslash . '\zs[,:]\+', '\\|', 'g')
let s:all = '\%(' . s:all . '\)'
" let s:all = '\%(' . substitute(s:all, '\\\ze[,:]', '', 'g') . '\)'
if exists("b:match_debug")
let b:match_pat = s:pat
endif
endif
" Second step: set the following local variables:
" matchline = line on which the cursor started
" curcol = number of characters before match
" prefix = regexp for start of line to start of match
" suffix = regexp for end of match to end of line
" Require match to end on or after the cursor and prefer it to
" start on or before the cursor.
let matchline = getline(startline)
if a:word != ''
" word given
if a:word !~ s:all
echohl WarningMsg|echo 'Missing rule for word:"'.a:word.'"'|echohl NONE
return s:CleanUp(restore_options, a:mode, startline, startcol)
endif
let matchline = a:word
let curcol = 0
let prefix = '^\%('
let suffix = '\)$'
" Now the case when "word" is not given
else " Find the match that ends on or after the cursor and set curcol.
let regexp = s:Wholematch(matchline, s:all, startcol-1)
let curcol = match(matchline, regexp)
" If there is no match, give up.
if curcol == -1
return s:CleanUp(restore_options, a:mode, startline, startcol)
endif
let endcol = matchend(matchline, regexp)
let suf = strlen(matchline) - endcol
let prefix = (curcol ? '^.*\%' . (curcol + 1) . 'c\%(' : '^\%(')
let suffix = (suf ? '\)\%' . (endcol + 1) . 'c.*$' : '\)$')
endif
if exists("b:match_debug")
let b:match_match = matchstr(matchline, regexp)
let b:match_col = curcol+1
endif
" Third step: Find the group and single word that match, and the original
" (backref) versions of these. Then, resolve the backrefs.
" Set the following local variable:
" group = colon-separated list of patterns, one of which matches
" = ini:mid:fin or ini:fin
"
" Reconstruct the version with unresolved backrefs.
let patBR = substitute(match_words.',',
\ s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
let patBR = substitute(patBR, s:notslash.'\zs:\{2,}', ':', 'g')
" Now, set group and groupBR to the matching group: 'if:endif' or
" 'while:endwhile' or whatever. A bit of a kluge: s:Choose() returns
" group . "," . groupBR, and we pick it apart.
let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, patBR)
let i = matchend(group, s:notslash . ",")
let groupBR = strpart(group, i)
let group = strpart(group, 0, i-1)
" Now, matchline =~ prefix . substitute(group,':','\|','g') . suffix
if s:do_BR " Do the hard part: resolve those backrefs!
let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline)
endif
if exists("b:match_debug")
let b:match_wholeBR = groupBR
let i = matchend(groupBR, s:notslash . ":")
let b:match_iniBR = strpart(groupBR, 0, i-1)
endif
" Fourth step: Set the arguments for searchpair().
let i = matchend(group, s:notslash . ":")
let j = matchend(group, '.*' . s:notslash . ":")
let ini = strpart(group, 0, i-1)
let mid = substitute(strpart(group, i,j-i-1), s:notslash.'\zs:', '\\|', 'g')
let fin = strpart(group, j)
"Un-escape the remaining , and : characters.
let ini = substitute(ini, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
let mid = substitute(mid, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
let fin = substitute(fin, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
" searchpair() requires that these patterns avoid \(\) groups.
let ini = substitute(ini, s:notslash . '\zs\\(', '\\%(', 'g')
let mid = substitute(mid, s:notslash . '\zs\\(', '\\%(', 'g')
let fin = substitute(fin, s:notslash . '\zs\\(', '\\%(', 'g')
" Set mid. This is optimized for readability, not micro-efficiency!
if a:forward && matchline =~ prefix . fin . suffix
\ || !a:forward && matchline =~ prefix . ini . suffix
let mid = ""
endif
" Set flag. This is optimized for readability, not micro-efficiency!
if a:forward && matchline =~ prefix . fin . suffix
\ || !a:forward && matchline !~ prefix . ini . suffix
let flag = "bW"
else
let flag = "W"
endif
" Set skip.
if exists("b:match_skip")
let skip = b:match_skip
elseif exists("b:match_comment") " backwards compatibility and testing!
let skip = "r:" . b:match_comment
else
let skip = 's:comment\|string'
endif
let skip = s:ParseSkip(skip)
if exists("b:match_debug")
let b:match_ini = ini
let b:match_tail = (strlen(mid) ? mid.'\|' : '') . fin
endif
" Fifth step: actually start moving the cursor and call searchpair().
" Later, :execute restore_cursor to get to the original screen.
let restore_cursor = virtcol(".") . "|"
normal! g0
let restore_cursor = line(".") . "G" . virtcol(".") . "|zs" . restore_cursor
normal! H
let restore_cursor = "normal!" . line(".") . "Gzt" . restore_cursor
execute restore_cursor
call cursor(0, curcol + 1)
" normal! 0
" if curcol
" execute "normal!" . curcol . "l"
" endif
if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
let skip = "0"
else
execute "if " . skip . "| let skip = '0' | endif"
endif
let sp_return = searchpair(ini, mid, fin, flag, skip)
let final_position = "call cursor(" . line(".") . "," . col(".") . ")"
" Restore cursor position and original screen.
execute restore_cursor
normal! m'
if sp_return > 0
execute final_position
endif
return s:CleanUp(restore_options, a:mode, startline, startcol, mid.'\|'.fin)
endfun
" Restore options and do some special handling for Operator-pending mode.
" The optional argument is the tail of the matching group.
fun! s:CleanUp(options, mode, startline, startcol, ...)
execute "set" a:options
" Open folds, if appropriate.
if a:mode != "o"
if &foldopen =~ "percent"
normal! zv
endif
" In Operator-pending mode, we want to include the whole match
" (for example, d%).
" This is only a problem if we end up moving in the forward direction.
elseif (a:startline < line(".")) ||
\ (a:startline == line(".") && a:startcol < col("."))
if a:0
" Check whether the match is a single character. If not, move to the
" end of the match.
let matchline = getline(".")
let currcol = col(".")
let regexp = s:Wholematch(matchline, a:1, currcol-1)
let endcol = matchend(matchline, regexp)
if endcol > currcol " This is NOT off by one!
execute "normal!" . (endcol - currcol) . "l"
endif
endif " a:0
endif " a:mode != "o" && etc.
return 0
endfun
" Example (simplified HTML patterns): if
" a:groupBR = '<\(\k\+\)>:</\1>'
" a:prefix = '^.\{3}\('
" a:group = '<\(\k\+\)>:</\(\k\+\)>'
" a:suffix = '\).\{2}$'
" a:matchline = "123<tag>12" or "123</tag>12"
" then extract "tag" from a:matchline and return "<tag>:</tag>" .
fun! s:InsertRefs(groupBR, prefix, group, suffix, matchline)
if a:matchline !~ a:prefix .
\ substitute(a:group, s:notslash . '\zs:', '\\|', 'g') . a:suffix
return a:group
endif
let i = matchend(a:groupBR, s:notslash . ':')
let ini = strpart(a:groupBR, 0, i-1)
let tailBR = strpart(a:groupBR, i)
let word = s:Choose(a:group, a:matchline, ":", "", a:prefix, a:suffix,
\ a:groupBR)
let i = matchend(word, s:notslash . ":")
let wordBR = strpart(word, i)
let word = strpart(word, 0, i-1)
" Now, a:matchline =~ a:prefix . word . a:suffix
if wordBR != ini
let table = s:Resolve(ini, wordBR, "table")
else
" let table = "----------"
let table = ""
let d = 0
while d < 10
if tailBR =~ s:notslash . '\\' . d
" let table[d] = d
let table = table . d
else
let table = table . "-"
endif
let d = d + 1
endwhile
endif
let d = 9
while d
if table[d] != "-"
let backref = substitute(a:matchline, a:prefix.word.a:suffix,
\ '\'.table[d], "")
" Are there any other characters that should be escaped?
let backref = escape(backref, '*,:')
execute s:Ref(ini, d, "start", "len")
let ini = strpart(ini, 0, start) . backref . strpart(ini, start+len)
let tailBR = substitute(tailBR, s:notslash . '\zs\\' . d,
\ escape(backref, '\\'), 'g')
endif
let d = d-1
endwhile
if exists("b:match_debug")
if s:do_BR
let b:match_table = table
let b:match_word = word
else
let b:match_table = ""
let b:match_word = ""
endif
endif
return ini . ":" . tailBR
endfun
" Input a comma-separated list of groups with backrefs, such as
" a:groups = '\(foo\):end\1,\(bar\):end\1'
" and return a comma-separated list of groups with backrefs replaced:
" return '\(foo\):end\(foo\),\(bar\):end\(bar\)'
fun! s:ParseWords(groups)
let groups = substitute(a:groups.",", s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
let groups = substitute(groups, s:notslash . '\zs:\{2,}', ':', 'g')
let parsed = ""
while groups =~ '[^,:]'
let i = matchend(groups, s:notslash . ':')
let j = matchend(groups, s:notslash . ',')
let ini = strpart(groups, 0, i-1)
let tail = strpart(groups, i, j-i-1) . ":"
let groups = strpart(groups, j)
let parsed = parsed . ini
let i = matchend(tail, s:notslash . ':')
while i != -1
" In 'if:else:endif', ini='if' and word='else' and then word='endif'.
let word = strpart(tail, 0, i-1)
let tail = strpart(tail, i)
let i = matchend(tail, s:notslash . ':')
let parsed = parsed . ":" . s:Resolve(ini, word, "word")
endwhile " Now, tail has been used up.
let parsed = parsed . ","
endwhile " groups =~ '[^,:]'
return parsed
endfun
" TODO I think this can be simplified and/or made more efficient.
" TODO What should I do if a:start is out of range?
" Return a regexp that matches all of a:string, such that
" matchstr(a:string, regexp) represents the match for a:pat that starts
" as close to a:start as possible, before being preferred to after, and
" ends after a:start .
" Usage:
" let regexp = s:Wholematch(getline("."), 'foo\|bar', col(".")-1)
" let i = match(getline("."), regexp)
" let j = matchend(getline("."), regexp)
" let match = matchstr(getline("."), regexp)
fun! s:Wholematch(string, pat, start)
let group = '\%(' . a:pat . '\)'
let prefix = (a:start ? '\(^.*\%<' . (a:start + 2) . 'c\)\zs' : '^')
let len = strlen(a:string)
let suffix = (a:start+1 < len ? '\(\%>'.(a:start+1).'c.*$\)\@=' : '$')
if a:string !~ prefix . group . suffix
let prefix = ''
endif
return prefix . group . suffix
endfun
" No extra arguments: s:Ref(string, d) will
" find the d'th occurrence of '\(' and return it, along with everything up
" to and including the matching '\)'.
" One argument: s:Ref(string, d, "start") returns the index of the start
" of the d'th '\(' and any other argument returns the length of the group.
" Two arguments: s:Ref(string, d, "foo", "bar") returns a string to be
" executed, having the effect of
" :let foo = s:Ref(string, d, "start")
" :let bar = s:Ref(string, d, "len")
fun! s:Ref(string, d, ...)
let len = strlen(a:string)
if a:d == 0
let start = 0
else
let cnt = a:d
let match = a:string
while cnt
let cnt = cnt - 1
let index = matchend(match, s:notslash . '\\(')
if index == -1
return ""
endif
let match = strpart(match, index)
endwhile
let start = len - strlen(match)
if a:0 == 1 && a:1 == "start"
return start - 2
endif
let cnt = 1
while cnt
let index = matchend(match, s:notslash . '\\(\|\\)') - 1
if index == -2
return ""
endif
" Increment if an open, decrement if a ')':
let cnt = cnt + (match[index]=="(" ? 1 : -1) " ')'
" let cnt = stridx('0(', match[index]) + cnt
let match = strpart(match, index+1)
endwhile
let start = start - 2
let len = len - start - strlen(match)
endif
if a:0 == 1
return len
elseif a:0 == 2
return "let " . a:1 . "=" . start . "| let " . a:2 . "=" . len
else
return strpart(a:string, start, len)
endif
endfun
" Count the number of disjoint copies of pattern in string.
" If the pattern is a literal string and contains no '0' or '1' characters
" then s:Count(string, pattern, '0', '1') should be faster than
" s:Count(string, pattern).
fun! s:Count(string, pattern, ...)
let pat = escape(a:pattern, '\\')
if a:0 > 1
let foo = substitute(a:string, '[^'.a:pattern.']', "a:1", "g")
let foo = substitute(a:string, pat, a:2, "g")
let foo = substitute(foo, '[^' . a:2 . ']', "", "g")
return strlen(foo)
endif
let result = 0
let foo = a:string
let index = matchend(foo, pat)
while index != -1
let result = result + 1
let foo = strpart(foo, index)
let index = matchend(foo, pat)
endwhile
return result
endfun
" s:Resolve('\(a\)\(b\)', '\(c\)\2\1\1\2') should return table.word, where
" word = '\(c\)\(b\)\(a\)\3\2' and table = '-32-------'. That is, the first
" '\1' in target is replaced by '\(a\)' in word, table[1] = 3, and this
" indicates that all other instances of '\1' in target are to be replaced
" by '\3'. The hard part is dealing with nesting...
" Note that ":" is an illegal character for source and target,
" unless it is preceded by "\".
fun! s:Resolve(source, target, output)
let word = a:target
let i = matchend(word, s:notslash . '\\\d') - 1
let table = "----------"
while i != -2 " There are back references to be replaced.
let d = word[i]
let backref = s:Ref(a:source, d)
" The idea is to replace '\d' with backref. Before we do this,
" replace any \(\) groups in backref with :1, :2, ... if they
" correspond to the first, second, ... group already inserted
" into backref. Later, replace :1 with \1 and so on. The group
" number w+b within backref corresponds to the group number
" s within a:source.
" w = number of '\(' in word before the current one
let w = s:Count(
\ substitute(strpart(word, 0, i-1), '\\\\', '', 'g'), '\(', '1')
let b = 1 " number of the current '\(' in backref
let s = d " number of the current '\(' in a:source
while b <= s:Count(substitute(backref, '\\\\', '', 'g'), '\(', '1')
\ && s < 10
if table[s] == "-"
if w + b < 10
" let table[s] = w + b
let table = strpart(table, 0, s) . (w+b) . strpart(table, s+1)
endif
let b = b + 1
let s = s + 1
else
execute s:Ref(backref, b, "start", "len")
let ref = strpart(backref, start, len)
let backref = strpart(backref, 0, start) . ":". table[s]
\ . strpart(backref, start+len)
let s = s + s:Count(substitute(ref, '\\\\', '', 'g'), '\(', '1')
endif
endwhile
let word = strpart(word, 0, i-1) . backref . strpart(word, i+1)
let i = matchend(word, s:notslash . '\\\d') - 1
endwhile
let word = substitute(word, s:notslash . '\zs:', '\\', 'g')
if a:output == "table"
return table
elseif a:output == "word"
return word
else
return table . word
endif
endfun
" Assume a:comma = ",". Then the format for a:patterns and a:1 is
" a:patterns = "<pat1>,<pat2>,..."
" a:1 = "<alt1>,<alt2>,..."
" If <patn> is the first pattern that matches a:string then return <patn>
" if no optional arguments are given; return <patn>,<altn> if a:1 is given.
fun! s:Choose(patterns, string, comma, branch, prefix, suffix, ...)
let tail = (a:patterns =~ a:comma."$" ? a:patterns : a:patterns . a:comma)
let i = matchend(tail, s:notslash . a:comma)
if a:0
let alttail = (a:1 =~ a:comma."$" ? a:1 : a:1 . a:comma)
let j = matchend(alttail, s:notslash . a:comma)
endif
let current = strpart(tail, 0, i-1)
if a:branch == ""
let currpat = current
else
let currpat = substitute(current, s:notslash . a:branch, '\\|', 'g')
endif
while a:string !~ a:prefix . currpat . a:suffix
let tail = strpart(tail, i)
let i = matchend(tail, s:notslash . a:comma)
if i == -1
return -1
endif
let current = strpart(tail, 0, i-1)
if a:branch == ""
let currpat = current
else
let currpat = substitute(current, s:notslash . a:branch, '\\|', 'g')
endif
if a:0
let alttail = strpart(alttail, j)
let j = matchend(alttail, s:notslash . a:comma)
endif
endwhile
if a:0
let current = current . a:comma . strpart(alttail, 0, j-1)
endif
return current
endfun
" Call this function to turn on debugging information. Every time the main
" script is run, buffer variables will be saved. These can be used directly
" or viewed using the menu items below.
if !exists(":MatchDebug")
command! -nargs=0 MatchDebug call s:Match_debug()
endif
fun! s:Match_debug()
let b:match_debug = 1 " Save debugging information.
" pat = all of b:match_words with backrefs parsed
amenu &Matchit.&pat :echo b:match_pat<CR>
" match = bit of text that is recognized as a match
amenu &Matchit.&match :echo b:match_match<CR>
" curcol = cursor column of the start of the matching text
amenu &Matchit.&curcol :echo b:match_col<CR>
" wholeBR = matching group, original version
amenu &Matchit.wh&oleBR :echo b:match_wholeBR<CR>
" iniBR = 'if' piece, original version
amenu &Matchit.ini&BR :echo b:match_iniBR<CR>
" ini = 'if' piece, with all backrefs resolved from match
amenu &Matchit.&ini :echo b:match_ini<CR>
" tail = 'else\|endif' piece, with all backrefs resolved from match
amenu &Matchit.&tail :echo b:match_tail<CR>
" fin = 'endif' piece, with all backrefs resolved from match
amenu &Matchit.&word :echo b:match_word<CR>
" '\'.d in ini refers to the same thing as '\'.table[d] in word.
amenu &Matchit.t&able :echo '0:' . b:match_table . ':9'<CR>
endfun
" Jump to the nearest unmatched "(" or "if" or "<tag>" if a:spflag == "bW"
" or the nearest unmatched "</tag>" or "endif" or ")" if a:spflag == "W".
" Return a "mark" for the original position, so that
" let m = MultiMatch("bW", "n") ... execute m
" will return to the original position. If there is a problem, do not
" move the cursor and return "", unless a count is given, in which case
" go up or down as many levels as possible and again return "".
" TODO This relies on the same patterns as % matching. It might be a good
" idea to give it its own matching patterns.
fun! s:MultiMatch(spflag, mode)
if !exists("b:match_words") || b:match_words == ""
return ""
end
let restore_options = (&ic ? "" : "no") . "ignorecase"
if exists("b:match_ignorecase")
let &ignorecase = b:match_ignorecase
endif
let startline = line(".")
let startcol = col(".")
" First step: if not already done, set the script variables
" s:do_BR flag for whether there are backrefs
" s:pat parsed version of b:match_words
" s:all regexp based on s:pat and the default groups
" This part is copied and slightly modified from s:Match_wrapper().
let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
\ '\/\*:\*\/,#if\%(def\)\=:#else\>:#elif\>:#endif\>'
" Allow b:match_words = "GetVimMatchWords()" .
if b:match_words =~ ":"
let match_words = b:match_words
else
execute "let match_words =" b:match_words
endif
if (match_words != s:last_words) || (&mps != s:last_mps) ||
\ exists("b:match_debug")
let s:last_words = match_words
let s:last_mps = &mps
if match_words !~ s:notslash . '\\\d'
let s:do_BR = 0
let s:pat = match_words
else
let s:do_BR = 1
let s:pat = s:ParseWords(match_words)
endif
let s:all = '\%(' . substitute(s:pat . (strlen(s:pat)?",":"") . default,
\ '[,:]\+','\\|','g') . '\)'
if exists("b:match_debug")
let b:match_pat = s:pat
endif
endif
" Second step: figure out the patterns for searchpair()
" and save the screen, cursor position, and 'ignorecase'.
" - TODO: A lot of this is copied from s:Match_wrapper().
" - maybe even more functionality should be split off
" - into separate functions!
let cdefault = (s:pat =~ '[^,]$' ? "," : "") . default
let open = substitute(s:pat . cdefault,
\ s:notslash . '\zs:.\{-}' . s:notslash . ',', '\\),\\(', 'g')
let open = '\(' . substitute(open, s:notslash . '\zs:.*$', '\\)', '')
let close = substitute(s:pat . cdefault,
\ s:notslash . '\zs,.\{-}' . s:notslash . ':', '\\),\\(', 'g')
let close = substitute(close, '^.\{-}' . s:notslash . ':', '\\(', '') . '\)'
if exists("b:match_skip")
let skip = b:match_skip
elseif exists("b:match_comment") " backwards compatibility and testing!
let skip = "r:" . b:match_comment
else
let skip = 's:comment\|string'
endif
let skip = s:ParseSkip(skip)
" let restore_cursor = line(".") . "G" . virtcol(".") . "|"
" normal! H
" let restore_cursor = "normal!" . line(".") . "Gzt" . restore_cursor
let restore_cursor = virtcol(".") . "|"
normal! g0
let restore_cursor = line(".") . "G" . virtcol(".") . "|zs" . restore_cursor
normal! H
let restore_cursor = "normal!" . line(".") . "Gzt" . restore_cursor
execute restore_cursor
" Third step: call searchpair().
" Replace '\('--but not '\\('--with '\%(' and ',' with '\|'.
let openpat = substitute(open, '\(\\\@<!\(\\\\\)*\)\@<=\\(', '\\%(', 'g')
let openpat = substitute(openpat, ',', '\\|', 'g')
let closepat = substitute(close, '\(\\\@<!\(\\\\\)*\)\@<=\\(', '\\%(', 'g')
let closepat = substitute(closepat, ',', '\\|', 'g')
if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
let skip = '0'
else
execute "if " . skip . "| let skip = '0' | endif"
endif
mark '
let level = v:count1
while level
if searchpair(openpat, '', closepat, a:spflag, skip) < 1
call s:CleanUp(restore_options, a:mode, startline, startcol)
return ""
endif
let level = level - 1
endwhile
" Restore options and return a string to restore the original position.
call s:CleanUp(restore_options, a:mode, startline, startcol)
return restore_cursor
endfun
" Search backwards for "if" or "while" or "<tag>" or ...
" and return "endif" or "endwhile" or "</tag>" or ... .
" For now, this uses b:match_words and the same script variables
" as s:Match_wrapper() . Later, it may get its own patterns,
" either from a buffer variable or passed as arguments.
" fun! s:Autocomplete()
" echo "autocomplete not yet implemented :-("
" if !exists("b:match_words") || b:match_words == ""
" return ""
" end
" let startpos = s:MultiMatch("bW")
"
" if startpos == ""
" return ""
" endif
" " - TODO: figure out whether 'if' or '<tag>' matched, and construct
" " - the appropriate closing.
" let matchline = getline(".")
" let curcol = col(".") - 1
" " - TODO: Change the s:all argument if there is a new set of match pats.
" let regexp = s:Wholematch(matchline, s:all, curcol)
" let suf = strlen(matchline) - matchend(matchline, regexp)
" let prefix = (curcol ? '^.\{' . curcol . '}\%(' : '^\%(')
" let suffix = (suf ? '\).\{' . suf . '}$' : '\)$')
" " Reconstruct the version with unresolved backrefs.
" let patBR = substitute(b:match_words.',', '[,:]*,[,:]*', ',', 'g')
" let patBR = substitute(patBR, ':\{2,}', ':', "g")
" " Now, set group and groupBR to the matching group: 'if:endif' or
" " 'while:endwhile' or whatever.
" let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, patBR)
" let i = matchend(group, s:notslash . ",")
" let groupBR = strpart(group, i)
" let group = strpart(group, 0, i-1)
" " Now, matchline =~ prefix . substitute(group,':','\|','g') . suffix
" if s:do_BR
" let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline)
" endif
" " let g:group = group
"
" " - TODO: Construct the closing from group.
" let fake = "end" . expand("<cword>")
" execute startpos
" return fake
" endfun
" Close all open structures. "Get the heck out of here!"
" fun! s:Gthhoh()
" let close = s:Autocomplete()
" while strlen(close)
" put=close
" let close = s:Autocomplete()
" endwhile
" endfun
" Parse special strings as typical skip arguments for searchpair():
" s:foo becomes (current syntax item) =~ foo
" S:foo becomes (current syntax item) !~ foo
" r:foo becomes (line before cursor) =~ foo
" R:foo becomes (line before cursor) !~ foo
fun! s:ParseSkip(str)
let skip = a:str
if skip[1] == ":"
if skip[0] == "s"
let skip = "synIDattr(synID(line('.'),col('.'),1),'name') =~? '" .
\ strpart(skip,2) . "'"
elseif skip[0] == "S"
let skip = "synIDattr(synID(line('.'),col('.'),1),'name') !~? '" .
\ strpart(skip,2) . "'"
elseif skip[0] == "r"
let skip = "strpart(getline('.'),0,col('.'))=~'" . strpart(skip,2). "'"
elseif skip[0] == "R"
let skip = "strpart(getline('.'),0,col('.'))!~'" . strpart(skip,2). "'"
endif
endif
return skip
endfun
let &cpo = s:save_cpo
" vim:sts=2:sw=2:

2
vimfiles/plugin/netrwPlugin.vim
View File

@ -22,7 +22,7 @@
if &cp || exists("g:loaded_netrwPlugin")
finish
endif
let g:loaded_netrwPlugin = 1
let g:loaded_netrwPlugin = "v116"
let s:keepcpo = &cpo
if v:version < 700
echohl WarningMsg | echo "***netrw*** you need vim version 7.0 for this version of netrw" | echohl None

24
vimfiles/plugin/vgrepsup.vim
View File

@ -1,9 +1,10 @@
" Author: Michael Geddes ( vimmer at frog.wheelycreek.net )
"
" Created for zimnyx on IRC
" Version:0.2
" Version:0.3
"
" Do a global search replace on a directory.
" Gsub Do a global search replace on a directory.
" Bsub Do a buffer search replace.
"
"
" Copyright: Copyright me. Feel free to use, share, modify & distribute the
@ -28,7 +29,16 @@ fun! GlobSearchReplace( fileglob, sub, rep, flag)
endwhile
return countup
endfun
fun! s:CallGlobReplace(str)
fun! BufSearchReplace( fileglob, sub, rep, flag)
if a:fileglob != ''
echoerr 'Filter not supported'
else
exe 'bufdo %s/'.escape(a:sub, '/').'/'.escape(a:rep,'/').'/'.a:flag
end
endfun
fun! s:CallGlobReplace(func, str)
if strlen(a:str) == 0
echoerr 'Usage: /sub/rep/flags files'
return 0
@ -57,7 +67,7 @@ fun! s:CallGlobReplace(str)
let idx+=1
endwhile
if argidx == 2
echo ' argidx=2'
"echo ' argidx=2'
let idx+=1
while idx < strlen(str)
if str[idx]=~'\s'
@ -69,8 +79,10 @@ fun! s:CallGlobReplace(str)
endwhile
let argfileglob=str[idx : ]
endif
call GlobSearchReplace( argfileglob, arg0, arg1, argflags)
exe 'call '.a:func.'( argfileglob, arg0, arg1, argflags)'
" call GlobSearchReplace( argfileglob, arg0, arg1, argflags)
endfun
com! -nargs=1 Gsub :call s:CallGlobReplace(<q-args>)
com! -nargs=1 Gsub :call s:CallGlobReplace('GlobSearchReplace', <q-args>)
com! -nargs=1 Bsub :call s:CallGlobReplace('BufSearchReplace', <q-args>)

2
vimfiles/syntax/netrw.vim
View File

@ -47,7 +47,7 @@ syn match netrwVersion "(netrw.*)" contained
" ---------------------------------------------------------------------
" Highlighting Links: {{{1
if !exists("did_drchip_dbg_syntax")
if !exists("did_drchip_netrwlist_syntax")
let did_drchip_netrwlist_syntax= 1
hi link netrwClassify Function
hi link netrwCmdSep Delimiter