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 " Grep options
"let b:GrepFiles = '*.py' "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) function s:ReportRev(Rev)
if a:Rev >= '148' if a:Rev >= '148'
echo 'Neu seit Rev: 148'
echo 'BlockDiff: Commands ergänzt'
echo 'Matchit: syntax für a2l'
elseif a:Rev >= '145' elseif a:Rev >= '145'
echo 'Neu seit Rev: 145' echo 'Neu seit Rev: 145'
echo 'BlockDiff: Markieren -> BlockDiff -> Markieren -> BlockDiff -> neuer Tab' echo 'BlockDiff: Markieren -> BlockDiff -> Markieren -> BlockDiff -> neuer Tab'

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

@ -693,6 +693,25 @@ function FindDeclaration()
endfunction endfunction
" indent a wordNum to position " 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) function IndentWordNum(wordNum, pos)
" store cursor postion " store cursor postion
let cursorLine = line(".") 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 ScriptID SourceID Filename
-------------------------- --------------------------
1075 7738 netrw.vim 1075 8042 netrw.vim
1502 7078 vimball.vim 1502 7078 vimball.vim
1008 3118 srec.vim (ftplugin) 1008 3118 srec.vim (ftplugin)
1009 3119 srec.vim (syntax file) 1009 3119 srec.vim (syntax file)
@ -22,7 +22,9 @@ ScriptID SourceID Filename
1462 5612 dtd2xml 1462 5612 dtd2xml
1046 4249 Lusty Explorer 1046 4249 Lusty Explorer
2043 7805 VimPdb (debugging python) 2043 7805 VimPdb (debugging python)
1776 7810 Vimgrep Replace 1776 7902 Vimgrep Replace
2048 7815 BlockDiff 2048 7817 BlockDiff
39 7637 matchit.vim
2092 8041 reloaded.vim (matrix colorscheme)
642 7080 getscript.vim 642 7080 getscript.vim
642 7080 :AutoInstall: GetLatestVimScripts.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 " netrw.vim: Handles file transfer and remote directory listing across
" AUTOLOAD SECTION " AUTOLOAD SECTION
" Date: Oct 02, 2007 " Date: Dec 12, 2007
" Version: 114 " Version: 116
" Maintainer: Charles E Campbell, Jr <NdrOchip@ScampbellPfamily.AbizM-NOSPAM> " Maintainer: Charles E Campbell, Jr <NdrOchip@ScampbellPfamily.AbizM-NOSPAM>
" GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim " GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim
" Copyright: Copyright (C) 1999-2007 Charles E. Campbell, Jr. {{{1 " 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 " in no event will the copyright holder be liable for any damages
" resulting from the use of this software. " resulting from the use of this software.
" of this software. " of this software.
" COMBAK: worked with tmpfile s:GetTempname() in NetRead() NetWrite() " note: worked with tmpfile s:GetTempname() in NetRead() NetWrite()
" !!NEEDS DEBUGGING && TESTING!!!
"redraw!|call inputsave()|call input("Press <cr> to continue")|call inputrestore() "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 " 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:WARNING = 1
let s:ERROR = 2 let s:ERROR = 2
endif endif
let g:loaded_netrw = "v114" let g:loaded_netrw = "v116"
if v:version < 700 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) call netrw#ErrorMsg(s:WARNING,"you need vim version 7.0 or later for version ".g:loaded_netrw." of netrw",1)
finish finish
@ -222,14 +221,14 @@ endif
if !exists("g:netrw_localmovecmd") if !exists("g:netrw_localmovecmd")
if has("win32") || has("win95") || has("win64") || has("win16") if has("win32") || has("win95") || has("win64") || has("win16")
if g:netrw_cygwin if g:netrw_cygwin
let g:netrw_localcopycmd= "mv" let g:netrw_localmovecmd= "mv"
else else
let g:netrw_localcopycmd= "move" let g:netrw_localmovecmd= "move"
endif endif
elseif has("unix") || has("macunix") elseif has("unix") || has("macunix")
let g:netrw_localcopycmd= "mv" let g:netrw_localmovecmd= "mv"
else else
let g:netrw_localcopycmd= "" let g:netrw_localmovecmd= ""
endif endif
endif endif
if !exists("g:netrw_local_rmdir") if !exists("g:netrw_local_rmdir")
@ -298,6 +297,8 @@ endif
if !exists("g:netrw_shq") if !exists("g:netrw_shq")
if exists("&shq") && &shq != "" if exists("&shq") && &shq != ""
let g:netrw_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") elseif has("win32") || has("win95") || has("win64") || has("win16")
if g:netrw_cygwin if g:netrw_cygwin
let g:netrw_shq= "'" let g:netrw_shq= "'"
@ -443,14 +444,16 @@ endfun
" NetrwBrowse. " NetrwBrowse.
" vt: normally its "w:" or "s:" (a variable type) " vt: normally its "w:" or "s:" (a variable type)
fun! s:NetrwOptionSave(vt) 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") if !exists("{a:vt}netrw_optionsave")
let {a:vt}netrw_optionsave= 1 let {a:vt}netrw_optionsave= 1
" call Decho(a:vt."netrw_optionsave=".{a:vt}netrw_optionsave)
else else
" call Dret("s:NetrwOptionSave : netoptionsave=".{a:vt}netrw_optionsave." (options already saved)") " call Dret("s:NetrwOptionSave : options already saved")
return return
endif endif
" call Decho("fo=".&fo.(exists("&acd")? " acd=".&acd : " acd doesn't exist"))
" Save current settings and current directory " Save current settings and current directory
let s:yykeep = @@ let s:yykeep = @@
@ -480,7 +483,6 @@ fun! s:NetrwOptionSave(vt)
endif endif
if &go =~ 'a' | silent! let {a:vt}netrw_regstar = @* | endif if &go =~ 'a' | silent! let {a:vt}netrw_regstar = @* | endif
silent! let {a:vt}netrw_regslash= @/ silent! let {a:vt}netrw_regslash= @/
" call s:NetrwSafeOptions()
" call Dret("s:NetrwOptionSave : win#".winnr()." buf#".bufnr(".")) " call Dret("s:NetrwOptionSave : win#".winnr()." buf#".bufnr("."))
endfun endfun
@ -490,13 +492,22 @@ endfun
fun! s:NetrwOptionRestore(vt) fun! s:NetrwOptionRestore(vt)
" call Dfunc("s:NetrwOptionRestore(vt<".a:vt.">) win#".winnr()." buf#".bufnr(".")) " call Dfunc("s:NetrwOptionRestore(vt<".a:vt.">) win#".winnr()." buf#".bufnr("."))
if !exists("{a:vt}netrw_optionsave") 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 return
endif endif
unlet {a:vt}netrw_optionsave unlet {a:vt}netrw_optionsave
if exists("&acd") 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 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_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 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= setlocal directory=
unlet {a:vt}netrw_swfkeep unlet {a:vt}netrw_swfkeep
elseif &l:swf != {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 silent! let &l:swf= {a:vt}netrw_swfkeep
unlet {a:vt}netrw_swfkeep unlet {a:vt}netrw_swfkeep
endif endif
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_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 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(".")) " call Dret("s:NetrwOptionRestore : win#".winnr()." buf#".bufnr("."))
endfun endfun
" --------------------------------------------------------------------- " ---------------------------------------------------------------------
" s:NetrwSafeOptions: sets options to help netrw do its job {{{2 " s:NetrwSafeOptions: sets options to help netrw do its job {{{2
fun! s:NetrwSafeOptions() 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 cino=
setlocal com= setlocal com=
setlocal cpo-=aA setlocal cpo-=aA
if exists("&acd") if exists("&acd") | setlocal noacd | endif
setlocal noacd nocin noai noci magic nospell nohid wig= noaw setlocal nocin noai noci magic nospell nohid wig= noaw
setlocal fo=nroql2 setlocal fo=nroql2
else
setlocal nocin noai noci magic nospell nohid wig= noaw
setlocal fo=nroql2
endif
setlocal tw=0 setlocal tw=0
setlocal report=10000 setlocal report=10000
if g:netrw_use_noswf && has("win32") && !has("win95") if g:netrw_use_noswf && has("win32") && !has("win95")
setlocal noswf setlocal noswf
endif endif
" call Decho("fo=".&fo.(exists("&acd")? " acd=".&acd : " acd doesn't exist"))
" call Dret("s:NetrwSafeOptions") " call Dret("s:NetrwSafeOptions")
endfun endfun
@ -756,7 +767,7 @@ fun! netrw#NetRead(mode,...)
elseif b:netrw_method == 2 " read with ftp + <.netrc> elseif b:netrw_method == 2 " read with ftp + <.netrc>
" call Decho("read via ftp+.netrc (method #2)") " call Decho("read via ftp+.netrc (method #2)")
let netrw_fname= b:netrw_fname let netrw_fname= b:netrw_fname
new call s:SaveBufVars()|new|call s:RestoreBufVars()
setlocal ff=unix setlocal ff=unix
exe "put ='".g:netrw_ftpmode."'" exe "put ='".g:netrw_ftpmode."'"
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
@ -780,7 +791,7 @@ fun! netrw#NetRead(mode,...)
call netrw#ErrorMsg(s:ERROR,getline(1),4) call netrw#ErrorMsg(s:ERROR,getline(1),4)
let &debug= debugkeep let &debug= debugkeep
endif endif
bd! call s:SaveBufVars()|bd!|call s:RestoreBufVars()
let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method)
let b:netrw_lastfile = choice let b:netrw_lastfile = choice
@ -790,7 +801,7 @@ fun! netrw#NetRead(mode,...)
" Construct execution string (four lines) which will be passed through filter " Construct execution string (four lines) which will be passed through filter
" call Decho("read via ftp+mipf (method #3)") " call Decho("read via ftp+mipf (method #3)")
let netrw_fname= escape(b:netrw_fname,g:netrw_fname_escape) let netrw_fname= escape(b:netrw_fname,g:netrw_fname_escape)
new call s:SaveBufVars()|new|call s:RestoreBufVars()
setlocal ff=unix setlocal ff=unix
if exists("g:netrw_port") && g:netrw_port != "" if exists("g:netrw_port") && g:netrw_port != ""
put ='open '.g:netrw_machine.' '.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 if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid put =g:netrw_uid
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
put ='\"'.g:netrw_passwd.'\"' put ='\"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
else else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"' put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
endif endif
@ -835,7 +846,7 @@ fun! netrw#NetRead(mode,...)
call netrw#ErrorMsg(s:ERROR,getline(1),5) call netrw#ErrorMsg(s:ERROR,getline(1),5)
endif endif
endif endif
bd! call s:SaveBufVars()|bd!|call s:RestoreBufVars()
let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method)
let b:netrw_lastfile = choice let b:netrw_lastfile = choice
@ -901,7 +912,7 @@ fun! netrw#NetRead(mode,...)
else else
put ='open '.g:netrw_machine put ='open '.g:netrw_machine
endif endif
put ='user '.g:netrw_uid.' '.g:netrw_passwd put ='user '.g:netrw_uid.' '.s:netrw_passwd
put ='get '.netrw_fname.' '.tmpfile put ='get '.netrw_fname.' '.tmpfile
put ='quit' put ='quit'
@ -942,9 +953,9 @@ fun! netrw#NetRead(mode,...)
endif endif
" call Decho("read via fetch for ".netrw_option) " call Decho("read via fetch for ".netrw_option)
if exists("g:netrw_uid") && g:netrw_uid != "" && exists("g:netrw_passwd") && g:netrw_passwd != "" 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.':'.g:netrw_passwd.'@'.g:netrw_machine."/".netrw_fname) " 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.':'.g: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 else
" call Decho("executing: !".g:netrw_fetch_cmd." ".tmpfile." ".netrw_option."://".g:netrw_machine."/".netrw_fname) " 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 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 if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid put =g:netrw_uid
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
put ='\"'.g:netrw_passwd.'\"' put ='\"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
else else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"' put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
" call Decho("filter input: ".getline(".")) " call Decho("filter input: ".getline("."))
endif endif
put ='put \"'.tmpfile.'\" \"'.netrw_fname.'\"' put ='put \"'.tmpfile.'\" \"'.netrw_fname.'\"'
@ -1236,7 +1247,7 @@ fun! netrw#NetWrite(...) range
else else
put ='open '.g:netrw_machine put ='open '.g:netrw_machine
endif endif
put ='user '.g:netrw_uid.' '.g:netrw_passwd put ='user '.g:netrw_uid.' '.s:netrw_passwd
put ='put '.tmpfile.' '.netrw_fname put ='put '.tmpfile.' '.netrw_fname
" perform cadaver operation: " perform cadaver operation:
@ -1459,8 +1470,8 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
" Patterns: " Patterns:
" mipf : a:machine a:id password filename Use ftp " mipf : a:machine a:id password filename Use ftp
" mf : a:machine 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 g: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 " rcpurm : rcp://[user@]host/filename Use rcp
" rcphf : [user@]host:filename Use rcp " rcphf : [user@]host:filename Use rcp
" scpurm : scp://[user@]host[[#:]port]/filename Use scp " scpurm : scp://[user@]host[[#:]port]/filename Use scp
@ -1537,7 +1548,7 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
if userid != "" if userid != ""
let g:netrw_uid= userid let g:netrw_uid= userid
endif endif
if exists("g:netrw_uid") && exists("g:netrw_passwd") if exists("g:netrw_uid") && exists("s:netrw_passwd")
let b:netrw_method = 3 let b:netrw_method = 3
else else
if s:FileReadable(expand("$HOME/.netrc")) && !g:netrw_ignorenetrc if s:FileReadable(expand("$HOME/.netrc")) && !g:netrw_ignorenetrc
@ -1545,9 +1556,9 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
else else
if !exists("g:netrw_uid") || g:netrw_uid == "" if !exists("g:netrw_uid") || g:netrw_uid == ""
call NetUserPass() call NetUserPass()
elseif !exists("g:netrw_passwd") || g:netrw_passwd == "" elseif !exists("s:netrw_passwd") || s:netrw_passwd == ""
call NetUserPass(g:netrw_uid) 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 endif
let b:netrw_method= 3 let b:netrw_method= 3
endif endif
@ -1567,13 +1578,13 @@ fun! s:NetrwMethod(choice) " globals: method machine id passwd fname
let b:netrw_method = 3 let b:netrw_method = 3
let g:netrw_machine = substitute(a:choice,mipf,'\1',"") let g:netrw_machine = substitute(a:choice,mipf,'\1',"")
let g:netrw_uid = substitute(a:choice,mipf,'\2',"") 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',"") let b:netrw_fname = substitute(a:choice,mipf,'\4',"")
" Issue an ftp: "hostname [path/]filename" " Issue an ftp: "hostname [path/]filename"
elseif match(a:choice,mf) == 0 elseif match(a:choice,mf) == 0
" call Decho("(ftp) host file") " 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 b:netrw_method = 3
let g:netrw_machine = substitute(a:choice,mf,'\1',"") let g:netrw_machine = substitute(a:choice,mf,'\1',"")
let b:netrw_fname = substitute(a:choice,mf,'\2',"") 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 " if exists("g:netrw_uid") "Decho
" call Decho("g:netrw_uid <".g:netrw_uid.">") " call Decho("g:netrw_uid <".g:netrw_uid.">")
" endif "Decho " endif "Decho
" if exists("g:netrw_passwd") "Decho " if exists("s:netrw_passwd") "Decho
" call Decho("g:netrw_passwd <".g:netrw_passwd.">") " call Decho("s:netrw_passwd <".s:netrw_passwd.">")
" endif "Decho " endif "Decho
" call Decho("b:netrw_fname <".b:netrw_fname.">") " call Decho("b:netrw_fname <".b:netrw_fname.">")
" call Dret("NetrwMethod : b:netrw_method=".b:netrw_method) " call Dret("NetrwMethod : b:netrw_method=".b:netrw_method)
@ -1672,10 +1683,10 @@ fun! NetUserPass(...)
" get password " get password
if a:0 <= 1 " via prompt if a:0 <= 1 " via prompt
" call Decho("a:0=".a:0." case <=1:") " 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 else " from command line
" call Decho("a:0=".a:0." case >1: a:2<".a:2.">") " 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 endif
" call Dret("NetUserPass") " call Dret("NetUserPass")
@ -1743,14 +1754,7 @@ fun! s:BrowserMaps(islocal)
nnoremap <buffer> <silent> <s-leftmouse> <leftmouse>:call <SID>NetrwMarkFile(1,<SID>NetrwGetWord())<cr> 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 '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>' 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 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 'nnoremap <buffer> <silent> <del> :call <SID>NetrwLocalRm("'.b:netrw_curdir.'")<cr>'
exe 'vnoremap <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>' 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> 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 '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>' 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 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 '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 '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>' 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>' exe 'vnoremap <buffer> <silent> R :call <SID>NetrwRemoteRename("'.s:user.s:machine.'","'.s:path.'")<cr>'
nnoremap <buffer> <F1> :he netrw-browse-cmds<cr> nnoremap <buffer> <F1> :he netrw-browse-cmds<cr>
endif endif
call s:SetRexDir(a:islocal,b:netrw_curdir)
" call Dret("s:BrowserMaps") " call Dret("s:BrowserMaps")
endfun endfun
" --------------------------------------------------------------------- " ---------------------------------------------------------------------
" s:NetrwBrowse: This function uses the command in g:netrw_list_cmd to get a list {{{2 " s:NetrwBrowse: This function uses the command in g:netrw_list_cmd to provide a {{{2
" of the contents of a remote directory. It is assumed that the " 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 " g:netrw_list_cmd has a string, USEPORT HOSTNAME, that needs to be substituted
" with the requested remote hostname first. " with the requested remote hostname first.
fun! s:NetrwBrowse(islocal,dirname) fun! s:NetrwBrowse(islocal,dirname)
@ -1845,9 +1843,11 @@ fun! s:NetrwBrowse(islocal,dirname)
endif endif
call s:NetrwOptionSave("w:") call s:NetrwOptionSave("w:")
call s:NetrwSafeOptions()
" clear any marked files " clear any marked files
if exists("s:netrwmarkfilelist") if exists("s:netrwmarkfilelist")
" call Decho("clearing marked files")
unlet s:netrwmarkfilelist unlet s:netrwmarkfilelist
unlet s:netrwmarkfilemtch unlet s:netrwmarkfilemtch
2match none 2match none
@ -1855,7 +1855,7 @@ fun! s:NetrwBrowse(islocal,dirname)
if a:islocal && exists("w:netrw_acdkeep") && w:netrw_acdkeep if a:islocal && exists("w:netrw_acdkeep") && w:netrw_acdkeep
" call Decho("handle 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) exe 'cd '.escape(a:dirname,g:netrw_cd_escape)
" call Decho("getcwd<".getcwd().">") " call Decho("getcwd<".getcwd().">")
@ -1873,19 +1873,21 @@ fun! s:NetrwBrowse(islocal,dirname)
" remote-read the requested file into current buffer {{{3 " remote-read the requested file into current buffer {{{3
mark ' mark '
call s:NetrwEnew(a:dirname) call s:NetrwEnew(a:dirname)
let b:netrw_curdir= a:dirname
call s:NetrwSafeOptions()
setlocal ma noro 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.")") " 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 file ".s:method."://".s:user.s:machine."/".escape(s:path,g:netrw_cd_escape)
exe "silent keepalt doau BufReadPre ".s:fname exe "silent keepalt doau BufReadPre ".s:fname
silent call netrw#NetRead(2,s:method."://".s:user.s:machine."/".s:path) 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 " save certain window-oriented variables into buffer-oriented variables {{{3
call s:SetBufWinVars() call s:SetBufWinVars()
call s:NetrwOptionRestore("w:") call s:NetrwOptionRestore("w:")
setlocal nomod nowrap setlocal noma nomod nowrap
" call Dret("NetrwBrowse : file<".s:fname.">") " call Dret("NetrwBrowse : file<".s:fname.">")
return return
@ -1901,6 +1903,8 @@ fun! s:NetrwBrowse(islocal,dirname)
call s:NetrwMenu(1) " set up menu {{{3 call s:NetrwMenu(1) " set up menu {{{3
if s:NetrwGetBuffer(a:islocal,dirname) " set up buffer {{{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") " call Dret("NetrwBrowse : re-using buffer")
return return
endif 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 " handle g:netrw_keepdir: set vim's current directory to netrw's notion of the current directory {{{3
if !g:netrw_keepdir 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)) " call Decho('exe cd '.escape(b:netrw_curdir,g:netrw_cd_escape))
try try
exe 'cd '.escape(b:netrw_curdir,g:netrw_cd_escape) 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 let b:netrw_curdir= w:netrw_prvdir
else else
call s:NetrwOptionRestore("w:") call s:NetrwOptionRestore("w:")
setlocal noma nomod nowrap
let b:netrw_curdir= dirname let b:netrw_curdir= dirname
" call Dret("NetrwBrowse : reusing buffer#".(exists("bufnum")? bufnum : 'N/A')."<".dirname."> getcwd<".getcwd().">") " call Dret("NetrwBrowse : reusing buffer#".(exists("bufnum")? bufnum : 'N/A')."<".dirname."> getcwd<".getcwd().">")
return return
@ -1983,6 +1988,7 @@ fun! s:NetrwBrowse(islocal,dirname)
call netrw#ErrorMsg(s:ERROR,"netrw doesn't understand your dirname<".dirname.">",20) call netrw#ErrorMsg(s:ERROR,"netrw doesn't understand your dirname<".dirname.">",20)
endif endif
call s:NetrwOptionRestore("w:") call s:NetrwOptionRestore("w:")
setlocal noma nomod nowrap
" call Dret("NetrwBrowse : badly formatted dirname<".dirname.">") " call Dret("NetrwBrowse : badly formatted dirname<".dirname.">")
return return
endif endif
@ -1993,11 +1999,10 @@ fun! s:NetrwBrowse(islocal,dirname)
" ----------------------- " -----------------------
" Directory Listing: {{{3 " Directory Listing: {{{3
" ----------------------- " -----------------------
setlocal noro ma
call s:BrowserMaps(a:islocal) call s:BrowserMaps(a:islocal)
call s:PerformListing(a:islocal) call s:PerformListing(a:islocal)
" call Dret("NetrwBrowse") " call Dret("NetrwBrowse : did PerformListing")
return return
endfun endfun
@ -2073,7 +2078,6 @@ fun! s:NetrwGetBuffer(islocal,dirname)
if bufnum < 0 || !bufexists(bufnum) if bufnum < 0 || !bufexists(bufnum)
" call Decho("get enew buffer") " call Decho("get enew buffer")
call s:NetrwEnew(dirname) call s:NetrwEnew(dirname)
call s:NetrwSafeOptions()
" name the buffer " name the buffer
if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST
" call Decho('silent! keepalt file NetrwTreeListing') " call Decho('silent! keepalt file NetrwTreeListing')
@ -2252,17 +2256,19 @@ endfun
fun! s:PerformListing(islocal) fun! s:PerformListing(islocal)
" call Dfunc("s:PerformListing(islocal=".a:islocal.") buf(%)=".bufnr("%")."<".bufname("%").">") " call Dfunc("s:PerformListing(islocal=".a:islocal.") buf(%)=".bufnr("%")."<".bufname("%").">")
" if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 " Decho call s:NetrwSafeOptions()
" call Decho("(netrw) Processing your browsing request...") setlocal noro ma
" endif " Decho
" call Decho('w:netrw_liststyle='.(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a')) " if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 " Decho
if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") " call Decho("(netrw) Processing your browsing request...")
" force a refresh for tree listings " endif " Decho
" call Decho("force refresh for treelisting: clear buffer<".expand("%")."> with :%d")
setlocal ma noro " call Decho('w:netrw_liststyle='.(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a'))
keepjumps %d if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict")
endif " 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 " save current directory on directory history list
call s:NetrwBookmarkDir(3,b:netrw_curdir) call s:NetrwBookmarkDir(3,b:netrw_curdir)
@ -2442,10 +2448,12 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
endif endif
call s:NetrwOptionSave("s:") call s:NetrwOptionSave("s:")
call s:NetrwSafeOptions()
call netrw#NetrwSavePosn() call netrw#NetrwSavePosn()
let nbcd_curpos = getpos('.') let nbcd_curpos = getpos('.')
let dirname = substitute(b:netrw_curdir,'\\','/','ge') let dirname = substitute(b:netrw_curdir,'\\','/','ge')
let newdir = a:newdir let newdir = a:newdir
let dolockout = 0
" set up o/s-dependent directory recognition pattern " set up o/s-dependent directory recognition pattern
if has("amiga") if has("amiga")
@ -2479,7 +2487,8 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" this lets NetrwBrowseX avoid the edit " this lets NetrwBrowseX avoid the edit
if a:0 < 1 if a:0 < 1
" call Decho("dirname<".dirname."> netrw_cd_escape<".g:netrw_cd_escape."> browse_split=".g:netrw_browse_split) " 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 !exists("s:didsplit")
if g:netrw_browse_split == 1 if g:netrw_browse_split == 1
new new
@ -2489,6 +2498,11 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
wincmd | wincmd |
elseif g:netrw_browse_split == 3 elseif g:netrw_browse_split == 3
tabnew tabnew
elseif g:netrw_browse_split == 4
if s:NetrwPrevWinOpen(2) == 3
" call Dret("s:NetrwBrowseChgDir")
return
endif
else else
" handling a file, didn't split, so remove menu " handling a file, didn't split, so remove menu
" call Decho("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 its local only: LocalBrowseCheck() doesn't edit a file, but NetrwBrowse() will
if a:islocal if a:islocal
" call Decho("edit local file: exe e! ".escape(dirname,g:netrw_cd_escape)) " 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) exe "e! ".escape(dirname,g:netrw_cd_escape)
let dolockout= 1
else else
setlocal ma nomod noro " call Decho("remote file: NetrwBrowse will edit it")
call s:NetrwOptionRestore("s:") let dolockout= 1
endif endif
endif endif
@ -2518,6 +2531,7 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" --------------------------------- " ---------------------------------
" call Decho('case "just go to new directory spec": newdir<'.newdir.'>') " call Decho('case "just go to new directory spec": newdir<'.newdir.'>')
let dirname= newdir let dirname= newdir
call s:SetRexDir(a:islocal,dirname)
call s:NetrwOptionRestore("s:") call s:NetrwOptionRestore("s:")
elseif newdir == './' elseif newdir == './'
@ -2525,7 +2539,7 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
" refresh the directory list " refresh the directory list
" -------------------------- " --------------------------
" call Decho('case "refresh directory listing": newdir == "./"') " call Decho('case "refresh directory listing": newdir == "./"')
call s:NetrwOptionRestore("s:") call s:SetRexDir(a:islocal,dirname)
elseif newdir == '../' elseif newdir == '../'
" ------------------- " -------------------
@ -2564,7 +2578,7 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
endif endif
" call Decho("unix: dirname<".dirname."> (go up one dir)") " call Decho("unix: dirname<".dirname."> (go up one dir)")
endif 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") 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') " call Decho('case liststyle is TREELIST and w:netrw_treedict exists')
@ -2621,12 +2635,19 @@ fun! s:NetrwBrowseChgDir(islocal,newdir,...)
let dirname= substitute(treedir,'/*$','/','') let dirname= substitute(treedir,'/*$','/','')
" call Decho("go down one dir: treedir<".treedir.">") " call Decho("go down one dir: treedir<".treedir.">")
endif endif
call s:SetRexDir(a:islocal,dirname)
else else
" go down one directory " go down one directory
let dirname= s:ComposePath(dirname,newdir) let dirname= s:ComposePath(dirname,newdir)
" call Decho("go down one dir: dirname<".dirname."> newdir<".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 endif
" call Dret("s:NetrwBrowseChgDir <".dirname."> : curpos<".string(getpos(".")).">") " call Dret("s:NetrwBrowseChgDir <".dirname."> : curpos<".string(getpos(".")).">")
@ -2797,6 +2818,9 @@ endfun
fun! s:NetrwMarkFile(islocal,fname) fun! s:NetrwMarkFile(islocal,fname)
" call Dfunc("s:NetrwMarkFile(islocal=".a:islocal." fname<".a:fname.">)") " call Dfunc("s:NetrwMarkFile(islocal=".a:islocal." fname<".a:fname.">)")
" call Decho("b:netrw_curdir<".b:netrw_curdir.">") " 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") if exists("s:netrwmarkfilelist")
" call Decho("starting s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">") " call Decho("starting s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">")
@ -2806,7 +2830,7 @@ fun! s:NetrwMarkFile(islocal,fname)
" append filename to list " append filename to list
" call Decho("append filename<".a:fname."> to markfilelist<".string(s:netrwmarkfilelist).">") " call Decho("append filename<".a:fname."> to markfilelist<".string(s:netrwmarkfilelist).">")
call add(s:netrwmarkfilelist,a:fname) call add(s:netrwmarkfilelist,a:fname)
let s:netrwmarkfilemtch= s:netrwmarkfilemtch.'\|\<'.a:fname.'\>' let s:netrwmarkfilemtch= s:netrwmarkfilemtch.'\|\<'.escape(a:fname,'*./[\').'\>'
else else
" remove filename from list " remove filename from list
" call Decho("remove filename<".a:fname."> from markfilelist<".string(s:netrwmarkfilelist).">") " call Decho("remove filename<".a:fname."> from markfilelist<".string(s:netrwmarkfilelist).">")
@ -2859,6 +2883,9 @@ endfun
fun! s:NetrwMarkFileCompress(islocal) fun! s:NetrwMarkFileCompress(islocal)
" call Dfunc("s:NetrwMarkFileCompress(islocal=".a:islocal.")") " call Dfunc("s:NetrwMarkFileCompress(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn() 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") if exists("s:netrwmarkfilelist") && exists("g:netrw_compress") && exists("g:netrw_decompress")
for fname in s:netrwmarkfilelist for fname in s:netrwmarkfilelist
@ -2908,6 +2935,9 @@ endfun
" 0=failure " 0=failure
fun! s:NetrwMarkFileCopy(islocal) fun! s:NetrwMarkFileCopy(islocal)
" call Dfunc("s:NetrwMarkFileCopy(islocal=".a:islocal.") target<".(exists("s:netrwmftgt")? s:netrwmftgt : '---').">") " 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") if exists("s:netrwmarkfilelist")
" call Decho("s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">") " call Decho("s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">")
@ -2930,7 +2960,7 @@ fun! s:NetrwMarkFileCopy(islocal)
if a:islocal && s:netrwmfloc if a:islocal && s:netrwmfloc
" local to local copy " 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) if executable(g:netrw_localcopycmd)
" call Decho("let ret= system(".g:netrw_localcopycmd." ".fname." ".s:netrwmftgt.")") " call Decho("let ret= system(".g:netrw_localcopycmd." ".fname." ".s:netrwmftgt.")")
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 elseif !a:islocal && s:netrwmfloc
" remote to local copy " 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) call netrw#NetrwObtain(a:islocal,fname,s:netrwmftgt)
elseif a:islocal && !s:netrwmfloc elseif a:islocal && !s:netrwmfloc
" local to remote copy " 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) call s:NetrwUpload(fname,s:netrwmftgt)
else else
@ -2988,8 +3018,12 @@ endfun
" Either two or three files can be so handled. " Either two or three files can be so handled.
fun! s:NetrwMarkFileDiff(islocal) fun! s:NetrwMarkFileDiff(islocal)
" call Dfunc("s:NetrwMarkFileDiff(islocal=".a:islocal.") b:netrw_curdir<".b:netrw_curdir.">") " 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") if exists("s:netrwmarkfilelist")
let curdir= b:netrw_curdir let curdir= b:netrw_curdir
let cnt= 0 let cnt= 0
for fname in s:netrwmarkfilelist for fname in s:netrwmarkfilelist
let cnt= cnt + 1 let cnt= cnt + 1
@ -3021,21 +3055,12 @@ endfun
" s:NetrwMarkFileEdit: put marked files on arg list and start editing them {{{2 " s:NetrwMarkFileEdit: put marked files on arg list and start editing them {{{2
fun! s:NetrwMarkFileEdit(islocal) fun! s:NetrwMarkFileEdit(islocal)
" call Dfunc("s:NetrwMarkFileEdit(islocal=".a: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 exists("s:netrwmarkfilelist")
if a:islocal call s:SetRexDir(a:islocal,b:netrw_curdir)
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
let flist= substitute(escape(join(s:netrwmarkfilelist,"\t"),' '),"\t",' ','g') let flist= substitute(escape(join(s:netrwmarkfilelist,"\t"),' '),"\t",' ','g')
" unmark marked file list " unmark marked file list
unlet s:netrwmarkfilelist unlet s:netrwmarkfilelist
@ -3053,6 +3078,9 @@ endfun
fun! s:NetrwMarkFileExe(islocal) fun! s:NetrwMarkFileExe(islocal)
" call Dfunc("s:NetrwMarkFileExe(islocal=".a:islocal.")") " call Dfunc("s:NetrwMarkFileExe(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn() let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist") if exists("s:netrwmarkfilelist")
" get the command " get the command
@ -3101,6 +3129,9 @@ endfun
" s:NetrwMarkFileMove: execute arbitrary command on marked files, one at a time {{{2 " s:NetrwMarkFileMove: execute arbitrary command on marked files, one at a time {{{2
fun! s:NetrwMarkFileMove(islocal) fun! s:NetrwMarkFileMove(islocal)
" call Dfunc("s:NetrwMarkFileMove(islocal=".a: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") if exists("s:netrwmarkfilelist")
let svpos= netrw#NetrwSavePosn() let svpos= netrw#NetrwSavePosn()
@ -3149,6 +3180,9 @@ endfun
" using the hardcopy command " using the hardcopy command
fun! s:NetrwMarkFilePrint(islocal) fun! s:NetrwMarkFilePrint(islocal)
" call Dfunc("s:NetrwMarkFilePrint(islocal=".a: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") if exists("s:netrwmarkfilelist")
let netrwmarkfilelist= s:netrwmarkfilelist let netrwmarkfilelist= s:netrwmarkfilelist
unlet s:netrwmarkfilelist unlet s:netrwmarkfilelist
@ -3173,6 +3207,9 @@ endfun
" issued). " issued).
fun! s:NetrwMarkFileRegexp(islocal) fun! s:NetrwMarkFileRegexp(islocal)
" call Dfunc("s:NetrwMarkFileRegexp(islocal=".a: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 " get the regular expression
call inputsave() call inputsave()
@ -3243,6 +3280,9 @@ endfun
fun! s:NetrwMarkFileTag(islocal) fun! s:NetrwMarkFileTag(islocal)
" call Dfunc("s:NetrwMarkFileTag(islocal=".a:islocal.")") " call Dfunc("s:NetrwMarkFileTag(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn() let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmarkfilelist") if exists("s:netrwmarkfilelist")
" call Decho("s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">") " call Decho("s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">")
@ -3286,6 +3326,9 @@ endfun
fun! s:NetrwMarkFileTgt(islocal) fun! s:NetrwMarkFileTgt(islocal)
" call Dfunc("s:NetrwMarkFileTgt(islocal=".a:islocal.")") " call Dfunc("s:NetrwMarkFileTgt(islocal=".a:islocal.")")
let svpos= netrw#NetrwSavePosn() let svpos= netrw#NetrwSavePosn()
if a:islocal && exists("b:netrw_curdir")
exe "cd ".b:netrw_curdir
endif
if exists("s:netrwmftgt") || exists("s:netrwmfloc") if exists("s:netrwmftgt") || exists("s:netrwmfloc")
" call Decho("s:netrwmftgt<".s:netrwmftgt."> exists; removing it") " 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.">") " call Decho("s:netrwmftgt doesn't exist; setting it to <".b:netrw_curdir.">")
let s:netrwmftgt = b:netrw_curdir let s:netrwmftgt = b:netrw_curdir
let s:netrwmfloc = a:islocal let s:netrwmfloc = a:islocal
if g:netrw_cygwin
let s:netrwmftgt= substitute(system("cygpath ".b:netrw_curdir),'\n$','','')
endif
endif endif
call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) 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 if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid put =g:netrw_uid
put ='\"'.g:netrw_passwd.'\"' put ='\"'.s:netrw_passwd.'\"'
" call Decho('ftp: g:netrw_uid') " call Decho('ftp: g:netrw_uid')
" call Decho('ftp: g:netrw_passwd') " call Decho('ftp: s:netrw_passwd')
else else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"' put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
" call Decho('user '.g:netrw_uid.' '.g:netrw_passwd) " call Decho('user '.g:netrw_uid.' '.s:netrw_passwd)
endif endif
if path != "" if path != ""
@ -3516,6 +3562,7 @@ endfun
fun! s:NetrwPreview(path) range fun! s:NetrwPreview(path) range
" call Dfunc("NetrwPreview(path<".a:path.">)") " call Dfunc("NetrwPreview(path<".a:path.">)")
call s:NetrwOptionSave("s:") call s:NetrwOptionSave("s:")
call s:NetrwSafeOptions()
if has("quickfix") if has("quickfix")
if !isdirectory(a:path) if !isdirectory(a:path)
exe (g:netrw_preview? "vert " : "")."pedit ".escape(a:path,g:netrw_fname_escape) 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 if exists("g:netrw_ftp") && g:netrw_ftp == 1
put =g:netrw_uid put =g:netrw_uid
put ='\"'.g:netrw_passwd.'\"' put ='\"'.s:netrw_passwd.'\"'
else else
put ='user \"'.g:netrw_uid.'\" \"'.g:netrw_passwd.'\"' put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"'
endif endif
if a:path != "" 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("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) " 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 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 if !g:netrw_keepdir
exe 'keepjumps cd '.netrw_origdir 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
endif endif
@ -4855,12 +4901,18 @@ endfun
" --------------------------------------------------------------------- " ---------------------------------------------------------------------
" s:NetrwPrevWinOpen: open file/directory in previous window. {{{2 " s:NetrwPrevWinOpen: open file/directory in previous window. {{{2
" If there's only one window, then the window will first be split. " 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) fun! s:NetrwPrevWinOpen(islocal)
" call Dfunc("NetrwPrevWinOpen(islocal=".a:islocal.")") " call Dfunc("NetrwPrevWinOpen(islocal=".a:islocal.")")
" get last window number and the word currently under the cursor " get last window number and the word currently under the cursor
let lastwinnr = winnr("$") let lastwinnr = winnr("$")
let curword = s:NetrwGetWord() let curword = s:NetrwGetWord()
let choice = 0
" call Decho("lastwinnr=".lastwinnr." curword<".curword.">") " call Decho("lastwinnr=".lastwinnr." curword<".curword.">")
let didsplit = 0 let didsplit = 0
@ -4868,14 +4920,17 @@ fun! s:NetrwPrevWinOpen(islocal)
" if only one window, open a new one first " 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.")") " call Decho("only one window, so open a new one (g:netrw_alto=".g:netrw_alto.")")
if g:netrw_preview 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" exe (g:netrw_alto? "top " : "bot ")."vert ".g:netrw_winsize."wincmd s"
else 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" exe (g:netrw_alto? "bel " : "abo ").g:netrw_winsize."wincmd s"
endif endif
let didsplit = 1 let didsplit = 1
else else
call s:SaveBufVars() call s:SaveBufVars()
" call Decho("wincmd p")
wincmd p wincmd p
call s:RestoreBufVars() call s:RestoreBufVars()
" if the previous window's buffer has been changed (is modified), " if the previous window's buffer has been changed (is modified),
@ -4884,11 +4939,17 @@ fun! s:NetrwPrevWinOpen(islocal)
let bnr = winbufnr(0) let bnr = winbufnr(0)
let bnrcnt = 0 let bnrcnt = 0
if &mod 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 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 if bnrcnt == 1
let bufname= bufname(winbufnr(winnr())) let bufname= bufname(winbufnr(winnr()))
let choice= confirm("Save modified file<".bufname.">?","&Yes\n&No\n&Cancel") let choice= confirm("Save modified file<".bufname.">?","&Yes\n&No\n&Cancel")
" call Decho("bufname<".bufname."> choice=".choice." winnr#".winnr())
if choice == 1 if choice == 1
" Yes -- write file & then browse " Yes -- write file & then browse
@ -4901,14 +4962,15 @@ fun! s:NetrwPrevWinOpen(islocal)
else else
wincmd p wincmd p
endif endif
" call Dret("NetrwPrevWinOpen : unable to write <".bufname.">") " call Dret("NetrwPrevWinOpen ".choice." : unable to write <".bufname.">")
return return choice
endif endif
elseif choice == 2 elseif choice == 2
" No -- don't worry about changed file, just browse anyway " No -- don't worry about changed file, just browse anyway
setlocal nomod 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 else
" Cancel -- don't do this " Cancel -- don't do this
@ -4917,19 +4979,22 @@ fun! s:NetrwPrevWinOpen(islocal)
else else
wincmd p wincmd p
endif endif
" call Dret("NetrwPrevWinOpen : cancelled") " call Dret("NetrwPrevWinOpen ".choice." : cancelled")
return return choice
endif endif
endif endif
endif endif
endif endif
if a:islocal if a:islocal < 2
call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(a:islocal,curword)) if a:islocal
else call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(a:islocal,curword))
call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,curword)) else
call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,curword))
endif
endif endif
" call Dret("NetrwPrevWinOpen") " call Dret("NetrwPrevWinOpen ".choice)
return choice
endfun endfun
" --------------------------------------------------------------------- " ---------------------------------------------------------------------
@ -5017,11 +5082,15 @@ endfun
" netrw#LocalBrowseCheck: {{{2 " netrw#LocalBrowseCheck: {{{2
fun! netrw#LocalBrowseCheck(dirname) fun! netrw#LocalBrowseCheck(dirname)
" unfortunate interaction -- split window debugging can't be " 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 " event triggers another call to LocalBrowseCheck() when attempts
" to write to the DBG buffer are made. " 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.">") " 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) silent! call s:NetrwBrowse(1,a:dirname)
endif endif
" call Dret("LocalBrowseCheck") " call Dret("LocalBrowseCheck")
@ -5481,7 +5550,6 @@ fun! netrw#Explore(indx,dosplit,style,...)
if a:dosplit || &modified || a:style == 6 if a:dosplit || &modified || a:style == 6
" call Decho("case: dosplit=".a:dosplit." modified=".&modified." a:style=".a:style) " call Decho("case: dosplit=".a:dosplit." modified=".&modified." a:style=".a:style)
call s:SaveWinVars() call s:SaveWinVars()
call s:NetrwOptionSave("s:")
if a:style == 0 " Explore, Sexplore if a:style == 0 " Explore, Sexplore
" call Decho("style=0: Explore or Sexplore") " call Decho("style=0: Explore or Sexplore")
@ -5514,7 +5582,6 @@ fun! netrw#Explore(indx,dosplit,style,...)
call s:RestoreBufVars() call s:RestoreBufVars()
endif endif
call s:RestoreWinVars() call s:RestoreWinVars()
call s:NetrwOptionRestore("s:")
endif endif
norm! 0 norm! 0
@ -5537,6 +5604,19 @@ fun! netrw#Explore(indx,dosplit,style,...)
endif endif
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 =~ '^\*/' if dirname =~ '^\*/'
" Explore */pattern " Explore */pattern
" call Decho("case Explore */pattern") " call Decho("case Explore */pattern")
@ -6073,9 +6153,7 @@ fun! s:GetTempfile(fname)
if g:netrw_cygwin != 0 if g:netrw_cygwin != 0
let tmpfile = substitute(tmpfile,'^\(\a\):','/cygdrive/\1','e') let tmpfile = substitute(tmpfile,'^\(\a\):','/cygdrive/\1','e')
elseif has("win32") || has("win95") || has("win64") || has("win16") elseif has("win32") || has("win95") || has("win64") || has("win16")
if exists("+shellslash") if !exists("+shellslash") || !&ssl
let tmpfile = substitute(tmpfile,'/',&ssl,'g')
else
let tmpfile = substitute(tmpfile,'/','\','g') let tmpfile = substitute(tmpfile,'/','\','g')
endif endif
else else
@ -6159,7 +6237,7 @@ endfun
fun! s:NetrwEnew(curdir) fun! s:NetrwEnew(curdir)
" call Dfunc("s:NetrwEnew(curdir<".a:curdir.">) buf#".bufnr("%")."<".bufname("%").">") " 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_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_browser_active") |let netrw_browser_active = b:netrw_browser_active |endif
if exists("b:netrw_cpf") |let netrw_cpf = b:netrw_cpf |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_option") |let netrw_option = b:netrw_option |endif
if exists("b:netrw_prvdir") |let netrw_prvdir = b:netrw_prvdir |endif if exists("b:netrw_prvdir") |let netrw_prvdir = b:netrw_prvdir |endif
call s:NetrwOptionRestore("w:")
if getline(2) =~ '^" Netrw Directory Listing' if getline(2) =~ '^" Netrw Directory Listing'
" call Decho("generate a buffer with keepjumps keepalt enew! (1)") " call Decho("generate a buffer with keepjumps keepalt enew! (1)")
keepjumps keepalt enew! keepjumps keepalt enew!
@ -6184,8 +6263,9 @@ fun! s:NetrwEnew(curdir)
" call Decho("generate a buffer with keepjumps enew! (2)") " call Decho("generate a buffer with keepjumps enew! (2)")
keepjumps enew! keepjumps enew!
endif 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_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_browser_active") |let b:netrw_browser_active = netrw_browser_active |endif
if exists("netrw_cpf") |let b:netrw_cpf = netrw_cpf |endif if exists("netrw_cpf") |let b:netrw_cpf = netrw_cpf |endif
@ -6342,6 +6422,33 @@ fun! s:SetBufWinVars()
" call Dret("s:SetBufWinVars") " call Dret("s:SetBufWinVars")
endfun 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 " s:Strlen: this function returns the length of a string, even if its {{{1
" using two-byte etc characters. Depends on virtcol(). " 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. 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" dav: *g:netrw_dav_cmd* = "cadaver"
fetch: *g:netrw_fetch_cmd* = "fetch -o" if fetch is available fetch: *g:netrw_fetch_cmd* = "fetch -o" if fetch is available
ftp: *g:netrw_ftp_cmd* = "ftp" ftp: *g:netrw_ftp_cmd* = "ftp"
http: *g:netrw_http_cmd* = "curl -o" if curl is available 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 = "wget -q -O" elseif wget is available
http: g:netrw_http_cmd = "fetch -o" else if fetch is available http: g:netrw_http_cmd = "fetch -o" elseif fetch is available
rcp: *g:netrw_rcp_cmd* = "rcp" rcp: *g:netrw_rcp_cmd* = "rcp"
rsync: *g:netrw_rsync_cmd* = "rsync -a" rsync: *g:netrw_rsync_cmd* = "rsync -a"
scp: *g:netrw_scp_cmd* = "scp -q" 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. 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 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 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() 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 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) *g:netrw_ignorenetrc* =0 (default for linux, cygwin)
=1 If you have a <.netrc> file but it doesn't work and =1 If you have a <.netrc> file but it doesn't work and
you want it ignored, then set this variable as shown. you want it ignored, then set this variable as
(default for Windows + cmd.exe) shown. (default for Windows + cmd.exe)
*g:netrw_menu* =0 disable netrw's menu *g:netrw_menu* =0 disable netrw's menu
=1 (default) netrw's menu enabled =1 (default) netrw's menu enabled
@ -281,13 +281,13 @@ NETRW VARIABLES AND SETTINGS *netrw-variables* {{{2
be available (see |netrw-gx|) be available (see |netrw-gx|)
*g:netrw_uid* (ftp) user-id, retained on a per-session basis *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 *g:netrw_preview* =0 (default) preview window shown in a horizontally
split window split window
=1 preview window shown in a vertically split window. =1 preview window shown in a vertically split window.
Affects the "previous window" (see |netrw-P|) the same Also affects the "previous window" (see |netrw-P|) in
way. the same way.
*g:netrw_shq* = "'" for Unix/Linux systems (ie. a single quote) *g:netrw_shq* = "'" for Unix/Linux systems (ie. a single quote)
= "'" for Windows + cygwin 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" --cmd "source scp://HOSTNAME/.vimrc"
< *netrw-uidpass* < *netrw-uidpass*
:call NetUserPass() :call NetUserPass()
If b:netrw_uid and b:netrw_passwd don't exist, If g:netrw_uid and s:netrw_passwd don't exist,
this function query the user for them. this function will query the user for them.
:call NetUserPass("userid") :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. the password doesn't exist, will query the user for it.
:call NetUserPass("userid","passwd") :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 The user-id and password are used by ftp transfers. One may
effectively remove the user-id and password by using "" effectively remove the user-id and password by using empty
strings. strings (ie. "").
:NetrwSettings This command is described in |netrw-settings| -- used to :NetrwSettings This command is described in |netrw-settings| -- used to
display netrw settings and change netrw behavior. display netrw settings and change netrw behavior.
@ -637,7 +637,7 @@ temporarily.
g:netrw_fname Holds filename being accessed > g:netrw_fname Holds filename being accessed >
------------------------------------------------------------ ------------------------------------------------------------
< <
*netrw-protocol* *netrw-protocol*
Netrw supports a number of protocols. These protocols are invoked using the Netrw supports a number of protocols. These protocols are invoked using the
variables listed below, and may be modified by the user. 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 window (unless |g:netrw_noretmap| is used, or the double-click leftmouse map
is already defined before netrw is loaded). 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| 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 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 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 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. 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 BROWSING WITH A NEW TAB *netrw-t* {{{2
@ -962,11 +980,12 @@ window and cursor at the right, have
let g:netrw_altv = 1 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 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. 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 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, hence, using "v" or "o" on a subdirectory will only show the same buffer,
twice. 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 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|) 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; With :NetrwClean one may easily remove netrw from one's home directory;
more precisely, from the first directory on your |'runtimepath'|. 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 NdrOchip at ScampbellPfamily.AbizM - NOSPAM
with a request. with a request.
Associated setting variable: |g:netrw_browsex_viewer|
*netrw-curdir* *netrw-curdir*
DELETING FILES OR DIRECTORIES *netrw-delete* *netrw-D* *netrw-del* {{{2 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 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-explore* *netrw-hexplore* *netrw-nexplore* *netrw-pexplore*
*netrw-rexplore* *netrw-sexplore* *netrw-texplore* *netrw-vexplore* *netrw-rexplore* *netrw-sexplore* *netrw-texplore* *netrw-vexplore*
DIRECTORY EXPLORATION COMMANDS {{{2 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 however, Explore will also search subdirectories as well as the current
directory. 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 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 either be hidden (ie. not shown) or be the only ones displayed (see
|netrw-a|). |netrw-a|).
Associated setting variable: |g:netrw_hide|
EDITING THE SORTING SEQUENCE *netrw-S* *netrw-sortsequence* {{{2 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 g:netrw_sort_sequence variable (either manually or in your <.vimrc>) or by
using the "S" map. using the "S" map.
Related topics: |g:netrw-s| |g:netrw-S|
Associated setting variable: |g:netrw_sort_sequence|
GOING UP *netrw--* {{{2 GOING UP *netrw--* {{{2
@ -1283,24 +1322,25 @@ match.
If no files have been marked via |netrw-mf|: 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. The |g:netrw_list_hide| variable holds a comma delimited list of patterns
\.obj) which specify the hiding list. (also see |netrw-ctrl-h|) To set the based on regular expressions (ex. ^.*\.obj$,^\.) which specify the hiding list.
hiding list, use the <c-h> map. As an example, to hide files which begin with (also see |netrw-ctrl-h|) To set the hiding list, use the <c-h> map. As an
a ".", one may use the <c-h> map to set the hiding list to '^\..*' (or one may example, to hide files which begin with a ".", one may use the <c-h> map to
put let g:netrw_list_hide= '^\..*' in one's <.vimrc>). One may then use the set the hiding list to '^\..*' (or one may put let g:netrw_list_hide= '^\..*'
"a" key to show all files, hide matching files, or to show only the matching in one's <.vimrc>). One may then use the "a" key to show all files, hide
files. 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. 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 This hiding list command will also hide/show all *.c and *.h
files. 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: 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. and showing only non-hidden files.
endif endif
Associated setting variable: |g:netrw_list_hide|
*netrw-ctrl_h* *netrw-ctrl_h*
IMPROVING BROWSING *netrw-listhack* *netrw-ssh-hack* {{{2 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 directory. Attempts to make a local directory that already exists (as either
a file or a directory) will be detected, reported on, and ignored. 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 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 set Vim's notion of the current directory to netrw's current browsing
directory. directory.
Associated setting variable: |g:netrw_keepdir|
MARKED FILES: ARBITRARY COMMAND *netrw-mx* {{{2 MARKED FILES: ARBITRARY COMMAND *netrw-mx* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files) (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 For decompression, netrw provides a |Dictionary| of suffices and their
associated decompressing utilities; see |g:netrw_decompress|. associated decompressing utilities; see |g:netrw_decompress|.
Associated setting variables: |g:netrw_compress| |g:netrw_decompress|
MARKED FILES: COPYING *netrw-mc* {{{2 MARKED FILES: COPYING *netrw-mc* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files) (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". 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 MARKED FILES: DIFF *netrw-md* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files) (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 a target directory with mT (|netrw-mt|). Then change directory,
select file(s) (see |netrw-mf|), and press "mm". 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 MARKED FILES: PRINTING *netrw-mp* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files) (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 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 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 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"; 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 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 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. 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 MARKED FILES: SETTING TARGET DIRECTORY *netrw-mt* {{{2
(See |netrw-mf| and |netrw-mr| for how to mark files) (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 =1: horizontally splitting the window first
=2: vertically splitting the window first =2: vertically splitting the window first
=3: open file in new tab =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: > *g:netrw_browsex_viewer* specify user's preference for a viewer: >
"kfmclient exec" "kfmclient exec"
@ -1616,6 +1675,7 @@ your browsing preferences. (see also: |netrw-settings|)
= 2: wide listing (multiple files in columns) = 2: wide listing (multiple files in columns)
= 3: tree style listing = 3: tree style listing
*g:netrw_list_hide* comma separated pattern list for hiding files *g:netrw_list_hide* comma separated pattern list for hiding files
Patterns are regular expressions (see |regexp|)
default: "" default: ""
*g:netrw_localcopycmd* ="cp" Linux/Unix/MacOS/Cygwin *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 let g:netrw_use_noswf= 0
in your .vimrc. 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" default: "%c"
*g:netrw_winsize* specify initial size of new o/v windows *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 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 acd
:set fo=...ta... is problematical. Autochdir sets the current directory to that containing the
< file you edit; this apparently also applies to directories. In other words,
If either of these options are present when browsing is attempted, netrw autochdir sets the current directory to that containing the "file" (even if
will change them by using noacd and removing the ta suboptions from the that "file" is itself a directory).
|'formatoptions'|.
NETRW SETTINGS *netrw-settings* {{{2 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 One may toggle between normal and reverse sorting order by pressing the
"r" key. "r" key.
Related topics: |g:netrw-s|
Associated setting variable: |g:netrw_sort_direction|
SELECTING SORTING STYLE *netrw-s* *netrw-sort* {{{2 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 allows one to circulate amongst the three choices; the directory listing will
automatically be refreshed to reflect the selected style. 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 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 8.3 Getting ready for public key authentication
< <
How to use a private key with 'pscp': > How to use a private key with 'pscp': >
http://www.tartarus.org/~simon/puttydoc/Chapter5.html http://www.tartarus.org/~simon/puttydoc/Chapter5.html
5.2.4 Using public key authentication with PSCP 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 (cec) To make proper use of these suggestions above, you will
need to modify the following user-settable variables in your need to modify the following user-settable variables in your
.vimrc: .vimrc:
|g:netrw_ssh_cmd| |g:netrw_list_cmd| |g:netrw_mkdir_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| |g:netrw_rm_cmd| |g:netrw_rmdir_cmd| |g:netrw_rmf_cmd|
The first one (|g:netrw_ssh_cmd|) is the most important; most 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 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 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 v114: Sep 28, 2007 * mT, the map that invokes tags, has been improved
to support use of remote tags files. to support use of remote tags files.
Oct 02, 2007 * changed Netrw menu to use more submenus 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. was preventing use of the "x" key with browsing.
Jun 05, 2006 * g:netrw_nogx available to prevent making the gx Jun 05, 2006 * g:netrw_nogx available to prevent making the gx
map (see |g:netrw_nogx|) map (see |g:netrw_nogx|)
* bugfix, Explore woulnd't change directory * bugfix, Explore wouldn't change directory
properly (vim ., :Explore subdirname) properly (vim ., :Explore subdirname)
Jun 06, 2006 * moved history to 2nd line in Netrw menu Jun 06, 2006 * moved history to 2nd line in Netrw menu
* fixed delete for unix-based systems * fixed delete for unix-based systems

53
vimfiles/doc/tags
View File

@ -5,7 +5,9 @@
:LP LogiPat.txt /*:LP* :LP LogiPat.txt /*:LP*
:LPF LogiPat.txt /*:LPF* :LPF LogiPat.txt /*:LPF*
:LogiPat LogiPat.txt /*:LogiPat* :LogiPat LogiPat.txt /*:LogiPat*
:MatchDebug matchit.txt /*:MatchDebug*
:MkVimball pi_vimball.txt /*:MkVimball* :MkVimball pi_vimball.txt /*:MkVimball*
:NetrwClean pi_netrw.txt /*:NetrwClean*
:Nexplore pi_netrw.txt /*:Nexplore* :Nexplore pi_netrw.txt /*:Nexplore*
:Pexplore pi_netrw.txt /*:Pexplore* :Pexplore pi_netrw.txt /*:Pexplore*
:Rexplore pi_netrw.txt /*:Rexplore* :Rexplore pi_netrw.txt /*:Rexplore*
@ -40,11 +42,27 @@ IX visincr.txt /*IX*
IYMD visincr.txt /*IYMD* IYMD visincr.txt /*IYMD*
LogiPat() LogiPat.txt /*LogiPat()* LogiPat() LogiPat.txt /*LogiPat()*
LogiPat-flags LogiPat.txt /*LogiPat-flags* LogiPat-flags LogiPat.txt /*LogiPat-flags*
MatchError matchit.txt /*MatchError*
Nread pi_netrw.txt /*Nread* Nread pi_netrw.txt /*Nread*
Nsource pi_netrw.txt /*Nsource* Nsource pi_netrw.txt /*Nsource*
Nwrite pi_netrw.txt /*Nwrite* Nwrite pi_netrw.txt /*Nwrite*
TCommentDefineType() tComment.txt /*TCommentDefineType()* TCommentDefineType() tComment.txt /*TCommentDefineType()*
Vimball-copyright pi_vimball.txt /*Vimball-copyright* 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* b:netrw_lastfile pi_netrw.txt /*b:netrw_lastfile*
crefvim crefvim.txt /*crefvim* crefvim crefvim.txt /*crefvim*
crefvim.txt crefvim.txt /*crefvim.txt* 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* ex-visincr-IYMD visincr.txt /*ex-visincr-IYMD*
fetch pi_netrw.txt /*fetch* fetch pi_netrw.txt /*fetch*
ftp pi_netrw.txt /*ftp* ftp pi_netrw.txt /*ftp*
g% matchit.txt /*g%*
g:NetrwTopLvlMenu pi_netrw.txt /*g:NetrwTopLvlMenu* g:NetrwTopLvlMenu pi_netrw.txt /*g:NetrwTopLvlMenu*
g:netrw_alto pi_netrw.txt /*g:netrw_alto* g:netrw_alto pi_netrw.txt /*g:netrw_alto*
g:netrw_altv pi_netrw.txt /*g:netrw_altv* 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_mkdir_cmd pi_netrw.txt /*g:netrw_mkdir_cmd*
g:netrw_nogx pi_netrw.txt /*g:netrw_nogx* g:netrw_nogx pi_netrw.txt /*g:netrw_nogx*
g:netrw_noretmap pi_netrw.txt /*g:netrw_noretmap* 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_preview pi_netrw.txt /*g:netrw_preview*
g:netrw_rcp_cmd pi_netrw.txt /*g:netrw_rcp_cmd* g:netrw_rcp_cmd pi_netrw.txt /*g:netrw_rcp_cmd*
g:netrw_rm_cmd pi_netrw.txt /*g:netrw_rm_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-operators LogiPat.txt /*logipat-operators*
logipat-pattern LogiPat.txt /*logipat-pattern* logipat-pattern LogiPat.txt /*logipat-pattern*
logipat.txt LogiPat.txt /*logipat.txt* 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* netreadfixup pi_netrw.txt /*netreadfixup*
netrw pi_netrw.txt /*netrw* netrw pi_netrw.txt /*netrw*
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.vim pi_netrw.txt /*netrw.vim*
netrw_filehandler pi_netrw.txt /*netrw_filehandler* netrw_filehandler pi_netrw.txt /*netrw_filehandler*
network pi_netrw.txt /*network* 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* op-opAsRightShift crefvim.txt /*op-opAsRightShift*
opAsBitAnd crefvim.txt /*opAsBitAnd* opAsBitAnd crefvim.txt /*opAsBitAnd*
opAsBitOr crefvim.txt /*opAsBitOr* 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* pi_vimball.txt pi_vimball.txt /*pi_vimball.txt*
rcp pi_netrw.txt /*rcp* rcp pi_netrw.txt /*rcp*
rsync pi_netrw.txt /*rsync* rsync pi_netrw.txt /*rsync*
s:netrw_passwd pi_netrw.txt /*s:netrw_passwd*
scp pi_netrw.txt /*scp* scp pi_netrw.txt /*scp*
sftp pi_netrw.txt /*sftp* sftp pi_netrw.txt /*sftp*
tComment-Installation tComment.txt /*tComment-Installation* 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-Usage tComment.txt /*tComment-Usage*
tComment-commands tComment.txt /*tComment-commands* tComment-commands tComment.txt /*tComment-commands*
tComment.txt tComment.txt /*tComment.txt* 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* vba pi_vimball.txt /*vba*
vimball pi_vimball.txt /*vimball* vimball pi_vimball.txt /*vimball*
vimball-contents pi_vimball.txt /*vimball-contents* vimball-contents pi_vimball.txt /*vimball-contents*

36
vimfiles/plugin/blockdiff.vim
View File

@ -2,25 +2,38 @@
" "
" Author: Timo Teifel " Author: Timo Teifel
" Email: timo dot teifel at teifel dot net " Email: timo dot teifel at teifel dot net
" Version: 1.0 " Version: 1.1
" Date: 22 Oct 2007 " Date: 23 Oct 2007
" Licence: GPL v2.0 " Licence: GPL v2.0
" "
" Usage: " Usage:
" - Select first block " - Select first block
" - Depending on the configuration, select: " - Depending on the configuration, select:
" - Menu BlockDiff-> This\ is\ Block\ 1 " - Menu Tools->BlockDiff-> This\ is\ Block\ 1
" - Popup-Menu -> This\ is\ Block\ 1 " - Popup-Menu -> This\ is\ Block\ 1
" - :BlockDiff1
" - ,d1 " - ,d1
" - select second block (may be in another file, but in the same " - select second block (may be in another file, but in the same
" Vim window) " 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 " - Popup-Menu -> This\ is\ Block\ 2,\ start\ diff
" - :BlockDiff2
" - ,d2 " - ,d2
" - Script opens a new tab, splits it and shows the diff between " - Script opens a new tab, splits it and shows the diff between
" the two blocks. " the two blocks.
" - Close the tab when done " - 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 let s:save_cpo = &cpo
set cpo&vim set cpo&vim
@ -30,18 +43,21 @@ set cpo&vim
" Create menu entry: " Create menu entry:
vmenu BlockDiff.This\ is\ block\ 1 :call BlockDiff_GetBlock1()<CR> vmenu 40.352.10 &Tools.Bloc&kDiff.This\ is\ Block\ &1 :call BlockDiff_GetBlock1()<CR>
vmenu BlockDiff.This\ is\ block\ 2,\ start\ diff :call BlockDiff_GetBlock2()<CR> vmenu 40.352.20 &Tools.Bloc&kDiff.This\ is\ Block\ &2,\ start\ diff :call BlockDiff_GetBlock2()<CR>
" Create popup-menu-entry: " Create popup-menu-entry:
"vmenu PopUp.BlockDiff.This\ is\ block\ 1 :call BlockDiff_GetBlock1()<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> "vmenu PopUp.BlockDiff.This\ is\ Block\ 2,\ start\ diff :call BlockDiff_GetBlock2()<CR>
" Shortcuts " Shortcuts
"vmap ,d1 :call BlockDiff_GetBlock1()<CR> "vmap ,d1 :call BlockDiff_GetBlock1()<CR>
"vmap ,d2 :call BlockDiff_GetBlock2()<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 ------------------------------------------------------------- " ---------- Code -------------------------------------------------------------
@ -61,7 +77,7 @@ fun! BlockDiff_GetBlock2() range
" Open new tab, paste second selected block " Open new tab, paste second selected block
tabnew tabnew
normal p normal P
" to prevent 'No write since last change' message: " to prevent 'No write since last change' message:
se buftype=nowrite se buftype=nowrite
diffthis diffthis
@ -70,7 +86,7 @@ fun! BlockDiff_GetBlock2() range
lefta vnew lefta vnew
" copy first block into unnamed register & paste " copy first block into unnamed register & paste
let @@ = s:block1 let @@ = s:block1
normal p normal P
se buftype=nowrite se buftype=nowrite
" start diff " 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") if &cp || exists("g:loaded_netrwPlugin")
finish finish
endif endif
let g:loaded_netrwPlugin = 1 let g:loaded_netrwPlugin = "v116"
let s:keepcpo = &cpo let s:keepcpo = &cpo
if v:version < 700 if v:version < 700
echohl WarningMsg | echo "***netrw*** you need vim version 7.0 for this version of netrw" | echohl None 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 ) " Author: Michael Geddes ( vimmer at frog.wheelycreek.net )
" "
" Created for zimnyx on IRC " 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 " Copyright: Copyright me. Feel free to use, share, modify & distribute the
@ -28,7 +29,16 @@ fun! GlobSearchReplace( fileglob, sub, rep, flag)
endwhile endwhile
return countup return countup
endfun 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 if strlen(a:str) == 0
echoerr 'Usage: /sub/rep/flags files' echoerr 'Usage: /sub/rep/flags files'
return 0 return 0
@ -57,7 +67,7 @@ fun! s:CallGlobReplace(str)
let idx+=1 let idx+=1
endwhile endwhile
if argidx == 2 if argidx == 2
echo ' argidx=2' "echo ' argidx=2'
let idx+=1 let idx+=1
while idx < strlen(str) while idx < strlen(str)
if str[idx]=~'\s' if str[idx]=~'\s'
@ -69,8 +79,10 @@ fun! s:CallGlobReplace(str)
endwhile endwhile
let argfileglob=str[idx : ] let argfileglob=str[idx : ]
endif endif
call GlobSearchReplace( argfileglob, arg0, arg1, argflags) exe 'call '.a:func.'( argfileglob, arg0, arg1, argflags)'
" call GlobSearchReplace( argfileglob, arg0, arg1, argflags)
endfun 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 " Highlighting Links: {{{1
if !exists("did_drchip_dbg_syntax") if !exists("did_drchip_netrwlist_syntax")
let did_drchip_netrwlist_syntax= 1 let did_drchip_netrwlist_syntax= 1
hi link netrwClassify Function hi link netrwClassify Function
hi link netrwCmdSep Delimiter hi link netrwCmdSep Delimiter