From: Ben Beltran Date: Wed, 5 Jun 2013 14:34:53 +0000 (-0500) Subject: A whole bunch of new additions to the submodules X-Git-Url: https://git.r.bdr.sh/rbdr/dotfiles/commitdiff_plain/e23d7a9f7363bdc69e95a1df31e093db15459fcf?ds=sidebyside;hp=547f6d2a3743174ff385ba239665b5de1964a043 A whole bunch of new additions to the submodules --- diff --git a/.gitmodules b/.gitmodules index c5abb8d..b572e5b 100644 --- a/.gitmodules +++ b/.gitmodules @@ -10,10 +10,36 @@ path = vim/bundle/vim-json url = git://github.com/elzr/vim-json.git -[submodule "vim-easymotion"] - path = vim/bundle/vim-easymotion - url = git://github.com/Lokaltog/vim-easymotion.git - -[submodule "LargeFile"] - path = vim/bundle/LargeFile - url = git://github.com/vim-scripts/LargeFile.git +[submodule "vim/bundle/vim-easymotion"] + path = vim/bundle/vim-easymotion + url = git://github.com/Lokaltog/vim-easymotion.git +[submodule "vim/bundle/LargeFile"] + path = vim/bundle/LargeFile + url = git://github.com/vim-scripts/LargeFile.git +[submodule "vim/bundle/Align"] + path = vim/bundle/Align + url = https://github.com/vim-scripts/Align +[submodule "vim/bundle/nerdcommenter"] + path = vim/bundle/nerdcommenter + url = git://github.com/scrooloose/nerdcommenter.git +[submodule "vim/bundle/nerdtree"] + path = vim/bundle/nerdtree + url = git://github.com/scrooloose/nerdtree.git +[submodule "vim/bundle/SearchComplete"] + path = vim/bundle/SearchComplete + url = git://github.com/vim-scripts/SearchComplete.git +[submodule "vim/bundle/ZoomWin"] + path = vim/bundle/ZoomWin + url = git://github.com/vim-scripts/ZoomWin.git +[submodule "vim/bundle/ag.vim"] + path = vim/bundle/ag.vim + url = git://github.com/rking/ag.vim.git +[submodule "vim/bundle/Colour-Sampler-Pack"] + path = vim/bundle/Colour-Sampler-Pack + url = git://github.com/vim-scripts/Colour-Sampler-Pack.git +[submodule "vim/bundle/delimitMate"] + path = vim/bundle/delimitMate + url = git://github.com/Raimondi/delimitMate.git +[submodule "vim/bundle/vim-endwise"] + path = vim/bundle/vim-endwise + url = git://github.com/tpope/vim-endwise.git diff --git a/tmux-powerline b/tmux-powerline new file mode 160000 index 0000000..9a1c6b1 --- /dev/null +++ b/tmux-powerline @@ -0,0 +1 @@ +Subproject commit 9a1c6b12748fa807fbbe0c032e57fe85712a6d47 diff --git a/vim/autoload/Align.vim b/vim/autoload/Align.vim deleted file mode 100644 index bce3542..0000000 --- a/vim/autoload/Align.vim +++ /dev/null @@ -1,1029 +0,0 @@ -" Align: tool to align multiple fields based on one or more separators -" Author: Charles E. Campbell, Jr. -" Date: Mar 03, 2009 -" Version: 35 -" GetLatestVimScripts: 294 1 :AutoInstall: Align.vim -" GetLatestVimScripts: 1066 1 :AutoInstall: cecutil.vim -" Copyright: Copyright (C) 1999-2007 Charles E. Campbell, Jr. {{{1 -" Permission is hereby granted to use and distribute this code, -" with or without modifications, provided that this copyright -" notice is copied with it. Like anything else that's free, -" Align.vim is provided *as is* and comes with no warranty -" of any kind, either expressed or implied. By using this -" plugin, you agree that in no event will the copyright -" holder be liable for any damages resulting from the use -" of this software. -" -" Romans 1:16,17a : For I am not ashamed of the gospel of Christ, for it is {{{1 -" the power of God for salvation for everyone who believes; for the Jew first, -" and also for the Greek. For in it is revealed God's righteousness from -" faith to faith. - -" --------------------------------------------------------------------- -" Load Once: {{{1 -if exists("g:loaded_Align") || &cp - finish -endif -let g:loaded_Align = "v35" -if v:version < 700 - echohl WarningMsg - echo "***warning*** this version of Align needs vim 7.0" - echohl Normal - finish -endif -let s:keepcpo= &cpo -set cpo&vim -"DechoTabOn - -" --------------------------------------------------------------------- -" Debugging Support: {{{1 -"if !exists("g:loaded_Decho") | runtime plugin/Decho.vim | endif - -" --------------------------------------------------------------------- -" Options: {{{1 -if !exists("g:Align_xstrlen") - if &enc == "latin1" || $LANG == "en_US.UTF-8" || !has("multi_byte") - let g:Align_xstrlen= 0 - else - let g:Align_xstrlen= 1 - endif -endif - -" --------------------------------------------------------------------- -" Align#AlignCtrl: enter alignment patterns here {{{1 -" -" Styles = all alignment-break patterns are equivalent -" C cycle through alignment-break pattern(s) -" l left-justified alignment -" r right-justified alignment -" c center alignment -" - skip separator, treat as part of field -" : treat rest of line as field -" + repeat previous [lrc] style -" < left justify separators -" > right justify separators -" | center separators -" -" Builds = s:AlignPat s:AlignCtrl s:AlignPatQty -" C s:AlignPat s:AlignCtrl s:AlignPatQty -" p s:AlignPrePad -" P s:AlignPostPad -" w s:AlignLeadKeep -" W s:AlignLeadKeep -" I s:AlignLeadKeep -" l s:AlignStyle -" r s:AlignStyle -" - s:AlignStyle -" + s:AlignStyle -" : s:AlignStyle -" c s:AlignStyle -" g s:AlignGPat -" v s:AlignVPat -" < s:AlignSep -" > s:AlignSep -" | s:AlignSep -fun! Align#AlignCtrl(...) - -" call Dfunc("AlignCtrl(...) a:0=".a:0) - - " save options that will be changed - let keep_search = @/ - let keep_ic = &ic - - " turn ignorecase off - set noic - - " clear visual mode so that old visual-mode selections don't - " get applied to new invocations of Align(). - if v:version < 602 - if !exists("s:Align_gavemsg") - let s:Align_gavemsg= 1 - echomsg "Align needs at least Vim version 6.2 to clear visual-mode selection" - endif - elseif exists("s:dovisclear") -" call Decho("clearing visual mode a:0=".a:0." a:1<".a:1.">") - let clearvmode= visualmode(1) - endif - - " set up a list akin to an argument list - if a:0 > 0 - let A= s:QArgSplitter(a:1) - else - let A=[0] - endif - - if A[0] > 0 - let style = A[1] - - " Check for bad separator patterns (zero-length matches) - " (but zero-length patterns for g/v is ok) - if style !~# '[gv]' - let ipat= 2 - while ipat <= A[0] - if "" =~ A[ipat] - echoerr "AlignCtrl: separator<".A[ipat]."> matches zero-length string" - let &ic= keep_ic -" call Dret("AlignCtrl") - return - endif - let ipat= ipat + 1 - endwhile - endif - endif - -" call Decho("AlignCtrl() A[0]=".A[0]) - if !exists("s:AlignStyle") - let s:AlignStyle= "l" - endif - if !exists("s:AlignPrePad") - let s:AlignPrePad= 0 - endif - if !exists("s:AlignPostPad") - let s:AlignPostPad= 0 - endif - if !exists("s:AlignLeadKeep") - let s:AlignLeadKeep= 'w' - endif - - if A[0] == 0 - " ---------------------- - " List current selection - " ---------------------- - if !exists("s:AlignPatQty") - let s:AlignPatQty= 0 - endif - echo "AlignCtrl<".s:AlignCtrl."> qty=".s:AlignPatQty." AlignStyle<".s:AlignStyle."> Padding<".s:AlignPrePad."|".s:AlignPostPad."> LeadingWS=".s:AlignLeadKeep." AlignSep=".s:AlignSep -" call Decho("AlignCtrl<".s:AlignCtrl."> qty=".s:AlignPatQty." AlignStyle<".s:AlignStyle."> Padding<".s:AlignPrePad."|".s:AlignPostPad."> LeadingWS=".s:AlignLeadKeep." AlignSep=".s:AlignSep) - if exists("s:AlignGPat") && !exists("s:AlignVPat") - echo "AlignGPat<".s:AlignGPat.">" - elseif !exists("s:AlignGPat") && exists("s:AlignVPat") - echo "AlignVPat<".s:AlignVPat.">" - elseif exists("s:AlignGPat") && exists("s:AlignVPat") - echo "AlignGPat<".s:AlignGPat."> AlignVPat<".s:AlignVPat.">" - endif - let ipat= 1 - while ipat <= s:AlignPatQty - echo "Pat".ipat."<".s:AlignPat_{ipat}.">" -" call Decho("Pat".ipat."<".s:AlignPat_{ipat}.">") - let ipat= ipat + 1 - endwhile - - else - " ---------------------------------- - " Process alignment control settings - " ---------------------------------- -" call Decho("process the alignctrl settings") -" call Decho("style<".style.">") - - if style ==? "default" - " Default: preserve initial leading whitespace, left-justified, - " alignment on '=', one space padding on both sides - if exists("s:AlignCtrlStackQty") - " clear AlignCtrl stack - while s:AlignCtrlStackQty > 0 - call Align#AlignPop() - endwhile - unlet s:AlignCtrlStackQty - endif - " Set AlignCtrl to its default value - call Align#AlignCtrl("Ilp1P1=<",'=') - call Align#AlignCtrl("g") - call Align#AlignCtrl("v") - let s:dovisclear = 1 - let &ic = keep_ic - let @/ = keep_search -" call Dret("AlignCtrl") - return - endif - - if style =~# 'm' - " map support: Do an AlignPush now and the next call to Align() - " will do an AlignPop at exit -" call Decho("style case m: do AlignPush") - call Align#AlignPush() - let s:DoAlignPop= 1 - endif - - " = : record a list of alignment patterns that are equivalent - if style =~# "=" -" call Decho("style case =: record list of equiv alignment patterns") - let s:AlignCtrl = '=' - if A[0] >= 2 - let s:AlignPatQty= 1 - let s:AlignPat_1 = A[2] - let ipat = 3 - while ipat <= A[0] - let s:AlignPat_1 = s:AlignPat_1.'\|'.A[ipat] - let ipat = ipat + 1 - endwhile - let s:AlignPat_1= '\('.s:AlignPat_1.'\)' -" call Decho("AlignCtrl<".s:AlignCtrl."> AlignPat<".s:AlignPat_1.">") - endif - - "c : cycle through alignment pattern(s) - elseif style =~# 'C' -" call Decho("style case C: cycle through alignment pattern(s)") - let s:AlignCtrl = 'C' - if A[0] >= 2 - let s:AlignPatQty= A[0] - 1 - let ipat = 1 - while ipat < A[0] - let s:AlignPat_{ipat}= A[ipat+1] -" call Decho("AlignCtrl<".s:AlignCtrl."> AlignQty=".s:AlignPatQty." AlignPat_".ipat."<".s:AlignPat_{ipat}.">") - let ipat= ipat + 1 - endwhile - endif - endif - - if style =~# 'p' - let s:AlignPrePad= substitute(style,'^.*p\(\d\+\).*$','\1','') -" call Decho("style case p".s:AlignPrePad.": pre-separator padding") - if s:AlignPrePad == "" - echoerr "AlignCtrl: 'p' needs to be followed by a numeric argument' - let @/ = keep_search - let &ic= keep_ic -" call Dret("AlignCtrl") - return - endif - endif - - if style =~# 'P' - let s:AlignPostPad= substitute(style,'^.*P\(\d\+\).*$','\1','') -" call Decho("style case P".s:AlignPostPad.": post-separator padding") - if s:AlignPostPad == "" - echoerr "AlignCtrl: 'P' needs to be followed by a numeric argument' - let @/ = keep_search - let &ic= keep_ic -" call Dret("AlignCtrl") - return - endif - endif - - if style =~# 'w' -" call Decho("style case w: ignore leading whitespace") - let s:AlignLeadKeep= 'w' - elseif style =~# 'W' -" call Decho("style case w: keep leading whitespace") - let s:AlignLeadKeep= 'W' - elseif style =~# 'I' -" call Decho("style case w: retain initial leading whitespace") - let s:AlignLeadKeep= 'I' - endif - - if style =~# 'g' - " first list item is a "g" selector pattern -" call Decho("style case g: global selector pattern") - if A[0] < 2 - if exists("s:AlignGPat") - unlet s:AlignGPat -" call Decho("unlet s:AlignGPat") - endif - else - let s:AlignGPat= A[2] -" call Decho("s:AlignGPat<".s:AlignGPat.">") - endif - elseif style =~# 'v' - " first list item is a "v" selector pattern -" call Decho("style case v: global selector anti-pattern") - if A[0] < 2 - if exists("s:AlignVPat") - unlet s:AlignVPat -" call Decho("unlet s:AlignVPat") - endif - else - let s:AlignVPat= A[2] -" call Decho("s:AlignVPat<".s:AlignVPat.">") - endif - endif - - "[-lrc+:] : set up s:AlignStyle - if style =~# '[-lrc+:]' -" call Decho("style case [-lrc+:]: field justification") - let s:AlignStyle= substitute(style,'[^-lrc:+]','','g') -" call Decho("AlignStyle<".s:AlignStyle.">") - endif - - "[<>|] : set up s:AlignSep - if style =~# '[<>|]' -" call Decho("style case [-lrc+:]: separator justification") - let s:AlignSep= substitute(style,'[^<>|]','','g') -" call Decho("AlignSep ".s:AlignSep) - endif - endif - - " sanity - if !exists("s:AlignCtrl") - let s:AlignCtrl= '=' - endif - - " restore search and options - let @/ = keep_search - let &ic= keep_ic - -" call Dret("AlignCtrl ".s:AlignCtrl.'p'.s:AlignPrePad.'P'.s:AlignPostPad.s:AlignLeadKeep.s:AlignStyle) - return s:AlignCtrl.'p'.s:AlignPrePad.'P'.s:AlignPostPad.s:AlignLeadKeep.s:AlignStyle -endfun - -" --------------------------------------------------------------------- -" s:MakeSpace: returns a string with spacecnt blanks {{{1 -fun! s:MakeSpace(spacecnt) -" call Dfunc("MakeSpace(spacecnt=".a:spacecnt.")") - let str = "" - let spacecnt = a:spacecnt - while spacecnt > 0 - let str = str . " " - let spacecnt = spacecnt - 1 - endwhile -" call Dret("MakeSpace <".str.">") - return str -endfun - -" --------------------------------------------------------------------- -" Align#Align: align selected text based on alignment pattern(s) {{{1 -fun! Align#Align(hasctrl,...) range -" call Dfunc("Align#Align(hasctrl=".a:hasctrl.",...) a:0=".a:0) - - " sanity checks - if string(a:hasctrl) != "0" && string(a:hasctrl) != "1" - echohl Error|echo 'usage: Align#Align(hasctrl<'.a:hasctrl.'> (should be 0 or 1),"separator(s)" (you have '.a:0.') )'|echohl None -" call Dret("Align#Align") - return - endif - if exists("s:AlignStyle") && s:AlignStyle == ":" - echohl Error |echo '(Align#Align) your AlignStyle is ":", which implies "do-no-alignment"!'|echohl None -" call Dret("Align#Align") - return - endif - - " set up a list akin to an argument list - if a:0 > 0 - let A= s:QArgSplitter(a:1) - else - let A=[0] - endif - - " if :Align! was used, then the first argument is (should be!) an AlignCtrl string - " Note that any alignment control set this way will be temporary. - let hasctrl= a:hasctrl -" call Decho("hasctrl=".hasctrl) - if a:hasctrl && A[0] >= 1 -" call Decho("Align! : using A[1]<".A[1]."> for AlignCtrl") - if A[1] =~ '[gv]' - let hasctrl= hasctrl + 1 - call Align#AlignCtrl('m') - call Align#AlignCtrl(A[1],A[2]) -" call Decho("Align! : also using A[2]<".A[2]."> for AlignCtrl") - elseif A[1] !~ 'm' - call Align#AlignCtrl(A[1]."m") - else - call Align#AlignCtrl(A[1]) - endif - endif - - " Check for bad separator patterns (zero-length matches) - let ipat= 1 + hasctrl - while ipat <= A[0] - if "" =~ A[ipat] - echoerr "Align: separator<".A[ipat]."> matches zero-length string" -" call Dret("Align#Align") - return - endif - let ipat= ipat + 1 - endwhile - - " record current search pattern for subsequent restoration - let keep_search= @/ - let keep_ic = &ic - let keep_report= &report - set noic report=10000 - - if A[0] > hasctrl - " Align will accept a list of separator regexps -" call Decho("A[0]=".A[0].": accepting list of separator regexp") - - if s:AlignCtrl =~# "=" - "= : consider all separators to be equivalent -" call Decho("AlignCtrl: record list of equivalent alignment patterns") - let s:AlignCtrl = '=' - let s:AlignPat_1 = A[1 + hasctrl] - let s:AlignPatQty= 1 - let ipat = 2 + hasctrl - while ipat <= A[0] - let s:AlignPat_1 = s:AlignPat_1.'\|'.A[ipat] - let ipat = ipat + 1 - endwhile - let s:AlignPat_1= '\('.s:AlignPat_1.'\)' -" call Decho("AlignCtrl<".s:AlignCtrl."> AlignPat<".s:AlignPat_1.">") - - elseif s:AlignCtrl =~# 'C' - "c : cycle through alignment pattern(s) -" call Decho("AlignCtrl: cycle through alignment pattern(s)") - let s:AlignCtrl = 'C' - let s:AlignPatQty= A[0] - hasctrl - let ipat = 1 - while ipat <= s:AlignPatQty - let s:AlignPat_{ipat}= A[(ipat + hasctrl)] -" call Decho("AlignCtrl<".s:AlignCtrl."> AlignQty=".s:AlignPatQty." AlignPat_".ipat."<".s:AlignPat_{ipat}.">") - let ipat= ipat + 1 - endwhile - endif - endif - - " Initialize so that begline - " is greater than the line's string length -> ragged right. - " Have to be careful about visualmode() -- it returns the last visual - " mode used whether or not it was used currently. - let begcol = virtcol("'<")-1 - let endcol = virtcol("'>")-1 - if begcol > endcol - let begcol = virtcol("'>")-1 - let endcol = virtcol("'<")-1 - endif -" call Decho("begcol=".begcol." endcol=".endcol) - let begline = a:firstline - let endline = a:lastline - if begline > endline - let begline = a:lastline - let endline = a:firstline - endif -" call Decho("begline=".begline." endline=".endline) - let fieldcnt = 0 - if (begline == line("'>") && endline == line("'<")) || (begline == line("'<") && endline == line("'>")) - let vmode= visualmode() -" call Decho("vmode=".vmode) - if vmode == "\" - if exists("g:Align_xstrlen") && g:Align_xstrlen - let ragged = ( col("'>") > s:Strlen(getline("'>")) || col("'<") > s:Strlen(getline("'<")) ) - else - let ragged = ( col("'>") > strlen(getline("'>")) || col("'<") > strlen(getline("'<")) ) - endif - else - let ragged= 1 - endif - else - let ragged= 1 - endif - if ragged - let begcol= 0 - endif -" call Decho("lines[".begline.",".endline."] col[".begcol.",".endcol."] ragged=".ragged." AlignCtrl<".s:AlignCtrl.">") - - " Keep user options - let etkeep = &l:et - let pastekeep= &l:paste - setlocal et paste - - " convert selected range of lines to use spaces instead of tabs - " but if first line's initial white spaces are to be retained - " then use 'em - if begcol <= 0 && s:AlignLeadKeep == 'I' - " retain first leading whitespace for all subsequent lines - let bgntxt= substitute(getline(begline),'^\(\s*\).\{-}$','\1','') -" call Decho("retaining 1st leading whitespace: bgntxt<".bgntxt.">") - set noet - endif - exe begline.",".endline."ret" - - " Execute two passes - " First pass: collect alignment data (max field sizes) - " Second pass: perform alignment - let pass= 1 - while pass <= 2 -" call Decho(" ") -" call Decho("---- Pass ".pass.": ----") - - let line= begline - while line <= endline - " Process each line - let txt = getline(line) -" call Decho(" ") -" call Decho("Pass".pass.": Line ".line." <".txt.">") - - " AlignGPat support: allows a selector pattern (akin to g/selector/cmd ) - if exists("s:AlignGPat") -" call Decho("Pass".pass.": AlignGPat<".s:AlignGPat.">") - if match(txt,s:AlignGPat) == -1 -" call Decho("Pass".pass.": skipping") - let line= line + 1 - continue - endif - endif - - " AlignVPat support: allows a selector pattern (akin to v/selector/cmd ) - if exists("s:AlignVPat") -" call Decho("Pass".pass.": AlignVPat<".s:AlignVPat.">") - if match(txt,s:AlignVPat) != -1 -" call Decho("Pass".pass.": skipping") - let line= line + 1 - continue - endif - endif - - " Always skip blank lines - if match(txt,'^\s*$') != -1 -" call Decho("Pass".pass.": skipping") - let line= line + 1 - continue - endif - - " Extract visual-block selected text (init bgntxt, endtxt) - if exists("g:Align_xstrlen") && g:Align_xstrlen - let txtlen= s:Strlen(txt) - else - let txtlen= strlen(txt) - endif - if begcol > 0 - " Record text to left of selected area - let bgntxt= strpart(txt,0,begcol) -" call Decho("Pass".pass.": record text to left: bgntxt<".bgntxt.">") - elseif s:AlignLeadKeep == 'W' - let bgntxt= substitute(txt,'^\(\s*\).\{-}$','\1','') -" call Decho("Pass".pass.": retaining all leading ws: bgntxt<".bgntxt.">") - elseif s:AlignLeadKeep == 'w' || !exists("bgntxt") - " No beginning text - let bgntxt= "" -" call Decho("Pass".pass.": no beginning text") - endif - if ragged - let endtxt= "" - else - " Elide any text lying outside selected columnar region - let endtxt= strpart(txt,endcol+1,txtlen-endcol) - let txt = strpart(txt,begcol,endcol-begcol+1) - endif -" call Decho(" ") -" call Decho("Pass".pass.": bgntxt<".bgntxt.">") -" call Decho("Pass".pass.": txt<". txt .">") -" call Decho("Pass".pass.": endtxt<".endtxt.">") - if !exists("s:AlignPat_{1}") - echohl Error|echo "no separators specified!"|echohl None -" call Dret("Align#Align") - return - endif - - " Initialize for both passes - let seppat = s:AlignPat_{1} - let ifield = 1 - let ipat = 1 - let bgnfield = 0 - let endfield = 0 - let alignstyle = s:AlignStyle - let doend = 1 - let newtxt = "" - let alignprepad = s:AlignPrePad - let alignpostpad= s:AlignPostPad - let alignsep = s:AlignSep - let alignophold = " " - let alignop = "l" -" call Decho("Pass".pass.": initial alignstyle<".alignstyle."> seppat<".seppat.">") - - " Process each field on the line - while doend > 0 - - " C-style: cycle through pattern(s) - if s:AlignCtrl == 'C' && doend == 1 - let seppat = s:AlignPat_{ipat} -" call Decho("Pass".pass.": processing field: AlignCtrl=".s:AlignCtrl." ipat=".ipat." seppat<".seppat.">") - let ipat = ipat + 1 - if ipat > s:AlignPatQty - let ipat = 1 - endif - endif - - " cyclic alignment/justification operator handling - let alignophold = alignop - let alignop = strpart(alignstyle,0,1) - if alignop == '+' || doend == 2 - let alignop= alignophold - else - let alignstyle = strpart(alignstyle,1).strpart(alignstyle,0,1) - let alignopnxt = strpart(alignstyle,0,1) - if alignop == ':' - let seppat = '$' - let doend = 2 -" call Decho("Pass".pass.": alignop<:> case: setting seppat<$> doend==2") - endif - endif - - " cylic separator alignment specification handling - let alignsepop= strpart(alignsep,0,1) - let alignsep = strpart(alignsep,1).alignsepop - - " mark end-of-field and the subsequent end-of-separator. - " Extend field if alignop is '-' - let endfield = match(txt,seppat,bgnfield) - let sepfield = matchend(txt,seppat,bgnfield) - let skipfield= sepfield -" call Decho("Pass".pass.": endfield=match(txt<".txt.">,seppat<".seppat.">,bgnfield=".bgnfield.")=".endfield) - while alignop == '-' && endfield != -1 - let endfield = match(txt,seppat,skipfield) - let sepfield = matchend(txt,seppat,skipfield) - let skipfield = sepfield - let alignop = strpart(alignstyle,0,1) - let alignstyle= strpart(alignstyle,1).strpart(alignstyle,0,1) -" call Decho("Pass".pass.": extend field: endfield<".strpart(txt,bgnfield,endfield-bgnfield)."> alignop<".alignop."> alignstyle<".alignstyle.">") - endwhile - let seplen= sepfield - endfield -" call Decho("Pass".pass.": seplen=[sepfield=".sepfield."] - [endfield=".endfield."]=".seplen) - - if endfield != -1 - if pass == 1 - " --------------------------------------------------------------------- - " Pass 1: Update FieldSize to max -" call Decho("Pass".pass.": before lead/trail remove: field<".strpart(txt,bgnfield,endfield-bgnfield).">") - let field = substitute(strpart(txt,bgnfield,endfield-bgnfield),'^\s*\(.\{-}\)\s*$','\1','') - if s:AlignLeadKeep == 'W' - let field = bgntxt.field - let bgntxt= "" - endif - if exists("g:Align_xstrlen") && g:Align_xstrlen - let fieldlen = s:Strlen(field) - else - let fieldlen = strlen(field) - endif - let sFieldSize = "FieldSize_".ifield - if !exists(sFieldSize) - let FieldSize_{ifield}= fieldlen -" call Decho("Pass".pass.": set FieldSize_{".ifield."}=".FieldSize_{ifield}." <".field.">") - elseif fieldlen > FieldSize_{ifield} - let FieldSize_{ifield}= fieldlen -" call Decho("Pass".pass.": oset FieldSize_{".ifield."}=".FieldSize_{ifield}." <".field.">") - endif - let sSepSize= "SepSize_".ifield - if !exists(sSepSize) - let SepSize_{ifield}= seplen -" call Decho(" set SepSize_{".ifield."}=".SepSize_{ifield}." <".field.">") - elseif seplen > SepSize_{ifield} - let SepSize_{ifield}= seplen -" call Decho("Pass".pass.": oset SepSize_{".ifield."}=".SepSize_{ifield}." <".field.">") - endif - - else - " --------------------------------------------------------------------- - " Pass 2: Perform Alignment - let prepad = strpart(alignprepad,0,1) - let postpad = strpart(alignpostpad,0,1) - let alignprepad = strpart(alignprepad,1).strpart(alignprepad,0,1) - let alignpostpad = strpart(alignpostpad,1).strpart(alignpostpad,0,1) - let field = substitute(strpart(txt,bgnfield,endfield-bgnfield),'^\s*\(.\{-}\)\s*$','\1','') - if s:AlignLeadKeep == 'W' - let field = bgntxt.field - let bgntxt= "" - endif - if doend == 2 - let prepad = 0 - let postpad= 0 - endif - if exists("g:Align_xstrlen") && g:Align_xstrlen - let fieldlen = s:Strlen(field) - else - let fieldlen = strlen(field) - endif - let sep = s:MakeSpace(prepad).strpart(txt,endfield,sepfield-endfield).s:MakeSpace(postpad) - if seplen < SepSize_{ifield} - if alignsepop == "<" - " left-justify separators - let sep = sep.s:MakeSpace(SepSize_{ifield}-seplen) - elseif alignsepop == ">" - " right-justify separators - let sep = s:MakeSpace(SepSize_{ifield}-seplen).sep - else - " center-justify separators - let sepleft = (SepSize_{ifield} - seplen)/2 - let sepright = SepSize_{ifield} - seplen - sepleft - let sep = s:MakeSpace(sepleft).sep.s:MakeSpace(sepright) - endif - endif - let spaces = FieldSize_{ifield} - fieldlen -" call Decho("Pass".pass.": Field #".ifield."<".field."> spaces=".spaces." be[".bgnfield.",".endfield."] pad=".prepad.','.postpad." FS_".ifield."<".FieldSize_{ifield}."> sep<".sep."> ragged=".ragged." doend=".doend." alignop<".alignop.">") - - " Perform alignment according to alignment style justification - if spaces > 0 - if alignop == 'c' - " center the field - let spaceleft = spaces/2 - let spaceright= FieldSize_{ifield} - spaceleft - fieldlen - let newtxt = newtxt.s:MakeSpace(spaceleft).field.s:MakeSpace(spaceright).sep - elseif alignop == 'r' - " right justify the field - let newtxt= newtxt.s:MakeSpace(spaces).field.sep - elseif ragged && doend == 2 - " left justify rightmost field (no trailing blanks needed) - let newtxt= newtxt.field - else - " left justfiy the field - let newtxt= newtxt.field.s:MakeSpace(spaces).sep - endif - elseif ragged && doend == 2 - " field at maximum field size and no trailing blanks needed - let newtxt= newtxt.field - else - " field is at maximum field size already - let newtxt= newtxt.field.sep - endif -" call Decho("Pass".pass.": newtxt<".newtxt.">") - endif " pass 1/2 - - " bgnfield indexes to end of separator at right of current field - " Update field counter - let bgnfield= sepfield - let ifield = ifield + 1 - if doend == 2 - let doend= 0 - endif - " handle end-of-text as end-of-field - elseif doend == 1 - let seppat = '$' - let doend = 2 - else - let doend = 0 - endif " endfield != -1 - endwhile " doend loop (as well as regularly separated fields) - - if pass == 2 - " Write altered line to buffer -" call Decho("Pass".pass.": bgntxt<".bgntxt."> line=".line) -" call Decho("Pass".pass.": newtxt<".newtxt.">") -" call Decho("Pass".pass.": endtxt<".endtxt.">") - call setline(line,bgntxt.newtxt.endtxt) - endif - - let line = line + 1 - endwhile " line loop - - let pass= pass + 1 - endwhile " pass loop -" call Decho("end of two pass loop") - - " Restore user options - let &l:et = etkeep - let &l:paste = pastekeep - - if exists("s:DoAlignPop") - " AlignCtrl Map support - call Align#AlignPop() - unlet s:DoAlignPop - endif - - " restore current search pattern - let @/ = keep_search - let &ic = keep_ic - let &report = keep_report - -" call Dret("Align#Align") - return -endfun - -" --------------------------------------------------------------------- -" Align#AlignPush: this command/function pushes an alignment control string onto a stack {{{1 -fun! Align#AlignPush() -" call Dfunc("AlignPush()") - - " initialize the stack - if !exists("s:AlignCtrlStackQty") - let s:AlignCtrlStackQty= 1 - else - let s:AlignCtrlStackQty= s:AlignCtrlStackQty + 1 - endif - - " construct an AlignCtrlStack entry - if !exists("s:AlignSep") - let s:AlignSep= '' - endif - let s:AlignCtrlStack_{s:AlignCtrlStackQty}= s:AlignCtrl.'p'.s:AlignPrePad.'P'.s:AlignPostPad.s:AlignLeadKeep.s:AlignStyle.s:AlignSep -" call Decho("AlignPush: AlignCtrlStack_".s:AlignCtrlStackQty."<".s:AlignCtrlStack_{s:AlignCtrlStackQty}.">") - - " push [GV] patterns onto their own stack - if exists("s:AlignGPat") - let s:AlignGPat_{s:AlignCtrlStackQty}= s:AlignGPat - else - let s:AlignGPat_{s:AlignCtrlStackQty}= "" - endif - if exists("s:AlignVPat") - let s:AlignVPat_{s:AlignCtrlStackQty}= s:AlignVPat - else - let s:AlignVPat_{s:AlignCtrlStackQty}= "" - endif - -" call Dret("AlignPush") -endfun - -" --------------------------------------------------------------------- -" Align#AlignPop: this command/function pops an alignment pattern from a stack {{{1 -" and into the AlignCtrl variables. -fun! Align#AlignPop() -" call Dfunc("Align#AlignPop()") - - " sanity checks - if !exists("s:AlignCtrlStackQty") - echoerr "AlignPush needs to be used prior to AlignPop" -" call Dret("Align#AlignPop <> : AlignPush needs to have been called first") - return "" - endif - if s:AlignCtrlStackQty <= 0 - unlet s:AlignCtrlStackQty - echoerr "AlignPush needs to be used prior to AlignPop" -" call Dret("Align#AlignPop <> : AlignPop needs to have been called first") - return "" - endif - - " pop top of AlignCtrlStack and pass value to AlignCtrl - let retval=s:AlignCtrlStack_{s:AlignCtrlStackQty} - unlet s:AlignCtrlStack_{s:AlignCtrlStackQty} - call Align#AlignCtrl(retval) - - " pop G pattern stack - if s:AlignGPat_{s:AlignCtrlStackQty} != "" - call Align#AlignCtrl('g',s:AlignGPat_{s:AlignCtrlStackQty}) - else - call Align#AlignCtrl('g') - endif - unlet s:AlignGPat_{s:AlignCtrlStackQty} - - " pop V pattern stack - if s:AlignVPat_{s:AlignCtrlStackQty} != "" - call Align#AlignCtrl('v',s:AlignVPat_{s:AlignCtrlStackQty}) - else - call Align#AlignCtrl('v') - endif - - unlet s:AlignVPat_{s:AlignCtrlStackQty} - let s:AlignCtrlStackQty= s:AlignCtrlStackQty - 1 - -" call Dret("Align#AlignPop <".retval."> : AlignCtrlStackQty=".s:AlignCtrlStackQty) - return retval -endfun - -" --------------------------------------------------------------------- -" Align#AlignReplaceQuotedSpaces: {{{1 -fun! Align#AlignReplaceQuotedSpaces() -" call Dfunc("AlignReplaceQuotedSpaces()") - - let l:line = getline(line(".")) - if exists("g:Align_xstrlen") && g:Align_xstrlen - let l:linelen = s:Strlen(l:line) - else - let l:linelen = strlen(l:line) - endif - let l:startingPos = 0 - let l:startQuotePos = 0 - let l:endQuotePos = 0 - let l:spacePos = 0 - let l:quoteRe = '\\\@, is needed. {{{1 -" However, doesn't split at all, so this function returns a list -" of arguments which has been: -" * split at whitespace -" * unless inside "..."s. One may escape characters with a backslash inside double quotes. -" along with a leading length-of-list. -" -" Examples: %Align "\"" will align on "s -" %Align " " will align on spaces -" -" The resulting list: qarglist[0] corresponds to a:0 -" qarglist[i] corresponds to a:{i} -fun! s:QArgSplitter(qarg) -" call Dfunc("s:QArgSplitter(qarg<".a:qarg.">)") - - if a:qarg =~ '".*"' - " handle "..." args, which may include whitespace - let qarglist = [] - let args = a:qarg -" call Decho("handle quoted arguments: args<".args.">") - while args != "" - let iarg = 0 - let arglen = strlen(args) -" call Decho("args[".iarg."]<".args[iarg]."> arglen=".arglen) - " find index to first not-escaped '"' - while args[iarg] != '"' && iarg < arglen - if args[iarg] == '\' - let args= strpart(args,1) - endif - let iarg= iarg + 1 - endwhile -" call Decho("args<".args."> iarg=".iarg." arglen=".arglen) - - if iarg > 0 - " handle left of quote or remaining section -" call Decho("handle left of quote or remaining section") - if args[iarg] == '"' - let qarglist= qarglist + split(strpart(args,0,iarg-1)) - else - let qarglist= qarglist + split(strpart(args,0,iarg)) - endif - let args = strpart(args,iarg) - let arglen = strlen(args) - - elseif iarg < arglen && args[0] == '"' - " handle "quoted" section -" call Decho("handle quoted section") - let iarg= 1 - while args[iarg] != '"' && iarg < arglen - if args[iarg] == '\' - let args= strpart(args,1) - endif - let iarg= iarg + 1 - endwhile -" call Decho("args<".args."> iarg=".iarg." arglen=".arglen) - if args[iarg] == '"' - call add(qarglist,strpart(args,1,iarg-1)) - let args= strpart(args,iarg+1) - else - let qarglist = qarglist + split(args) - let args = "" - endif - endif -" call Decho("qarglist".string(qarglist)." iarg=".iarg." args<".args.">") - endwhile - - else - " split at all whitespace - let qarglist= split(a:qarg) - endif - - let qarglistlen= len(qarglist) - let qarglist = insert(qarglist,qarglistlen) -" call Dret("s:QArgSplitter ".string(qarglist)) - return qarglist -endfun - -" --------------------------------------------------------------------- -" s:Strlen: this function returns the length of a string, even if its {{{1 -" using two-byte etc characters. -" Currently, its only used if g:Align_xstrlen is set to a -" nonzero value. Solution from Nicolai Weibull, vim docs -" (:help strlen()), Tony Mechelynck, and my own invention. -fun! s:Strlen(x) -" call Dfunc("s:Strlen(x<".a:x.">") - if g:Align_xstrlen == 1 - " number of codepoints (Latin a + combining circumflex is two codepoints) - " (comment from TM, solution from NW) - let ret= strlen(substitute(a:x,'.','c','g')) - - elseif g:Align_xstrlen == 2 - " number of spacing codepoints (Latin a + combining circumflex is one spacing - " codepoint; a hard tab is one; wide and narrow CJK are one each; etc.) - " (comment from TM, solution from TM) - let ret=strlen(substitute(a:x, '.\Z', 'x', 'g')) - - elseif g:Align_xstrlen == 3 - " virtual length (counting, for instance, tabs as anything between 1 and - " 'tabstop', wide CJK as 2 rather than 1, Arabic alif as zero when immediately - " preceded by lam, one otherwise, etc.) - " (comment from TM, solution from me) - let modkeep= &l:mod - exe "norm! o\" - call setline(line("."),a:x) - let ret= virtcol("$") - 1 - d - let &l:mod= modkeep - - else - " at least give a decent default - ret= strlen(a:x) - endif -" call Dret("s:Strlen ".ret) - return ret -endfun - -" --------------------------------------------------------------------- -" Set up default values: {{{1 -"call Decho("-- Begin AlignCtrl Initialization --") -call Align#AlignCtrl("default") -"call Decho("-- End AlignCtrl Initialization --") - -" --------------------------------------------------------------------- -" Restore: {{{1 -let &cpo= s:keepcpo -unlet s:keepcpo -" vim: ts=4 fdm=marker diff --git a/vim/autoload/AlignMaps.vim b/vim/autoload/AlignMaps.vim deleted file mode 100644 index ace2de8..0000000 --- a/vim/autoload/AlignMaps.vim +++ /dev/null @@ -1,330 +0,0 @@ -" AlignMaps.vim : support functions for AlignMaps -" Author: Charles E. Campbell, Jr. -" Date: Mar 03, 2009 -" Version: 41 -" --------------------------------------------------------------------- -" Load Once: {{{1 -if &cp || exists("g:loaded_AlignMaps") - finish -endif -let g:loaded_AlignMaps= "v41" -let s:keepcpo = &cpo -set cpo&vim - -" ===================================================================== -" Functions: {{{1 - -" --------------------------------------------------------------------- -" AlignMaps#WrapperStart: {{{2 -fun! AlignMaps#WrapperStart(vis) range -" call Dfunc("AlignMaps#WrapperStart(vis=".a:vis.")") - - if a:vis - norm! ' - endif - - if line("'y") == 0 || line("'z") == 0 || !exists("s:alignmaps_wrapcnt") || s:alignmaps_wrapcnt <= 0 -" call Decho("wrapper initialization") - let s:alignmaps_wrapcnt = 1 - let s:alignmaps_keepgd = &gdefault - let s:alignmaps_keepsearch = @/ - let s:alignmaps_keepch = &ch - let s:alignmaps_keepmy = SaveMark("'y") - let s:alignmaps_keepmz = SaveMark("'z") - let s:alignmaps_posn = SaveWinPosn(0) - " set up fencepost blank lines - put ='' - norm! mz'a - put! ='' - ky - let s:alignmaps_zline = line("'z") - exe "'y,'zs/@/\177/ge" - else -" call Decho("embedded wrapper") - let s:alignmaps_wrapcnt = s:alignmaps_wrapcnt + 1 - norm! 'yjma'zk - endif - - " change some settings to align-standard values - set nogd - set ch=2 - AlignPush - norm! 'zk -" call Dret("AlignMaps#WrapperStart : alignmaps_wrapcnt=".s:alignmaps_wrapcnt." my=".line("'y")." mz=".line("'z")) -endfun - -" --------------------------------------------------------------------- -" AlignMaps#WrapperEnd: {{{2 -fun! AlignMaps#WrapperEnd() range -" call Dfunc("AlignMaps#WrapperEnd() alignmaps_wrapcnt=".s:alignmaps_wrapcnt." my=".line("'y")." mz=".line("'z")) - - " remove trailing white space introduced by whatever in the modification zone - 'y,'zs/ \+$//e - - " restore AlignCtrl settings - AlignPop - - let s:alignmaps_wrapcnt= s:alignmaps_wrapcnt - 1 - if s:alignmaps_wrapcnt <= 0 - " initial wrapper ending - exe "'y,'zs/\177/@/ge" - - " if the 'z line hasn't moved, then go ahead and restore window position - let zstationary= s:alignmaps_zline == line("'z") - - " remove fencepost blank lines. - " restore 'a - norm! 'yjmakdd'zdd - - " restore original 'y, 'z, and window positioning - call RestoreMark(s:alignmaps_keepmy) - call RestoreMark(s:alignmaps_keepmz) - if zstationary > 0 - call RestoreWinPosn(s:alignmaps_posn) -" call Decho("restored window positioning") - endif - - " restoration of options - let &gd= s:alignmaps_keepgd - let &ch= s:alignmaps_keepch - let @/ = s:alignmaps_keepsearch - - " remove script variables - unlet s:alignmaps_keepch - unlet s:alignmaps_keepsearch - unlet s:alignmaps_keepmy - unlet s:alignmaps_keepmz - unlet s:alignmaps_keepgd - unlet s:alignmaps_posn - endif - -" call Dret("AlignMaps#WrapperEnd : alignmaps_wrapcnt=".s:alignmaps_wrapcnt." my=".line("'y")." mz=".line("'z")) -endfun - -" --------------------------------------------------------------------- -" AlignMaps#StdAlign: some semi-standard align calls {{{2 -fun! AlignMaps#StdAlign(mode) range -" call Dfunc("AlignMaps#StdAlign(mode=".a:mode.")") - if a:mode == 1 - " align on @ -" call Decho("align on @") - AlignCtrl mIp1P1=l @ - 'a,.Align - elseif a:mode == 2 - " align on @, retaining all initial white space on each line -" call Decho("align on @, retaining all initial white space on each line") - AlignCtrl mWp1P1=l @ - 'a,.Align - elseif a:mode == 3 - " like mode 2, but ignore /* */-style comments -" call Decho("like mode 2, but ignore /* */-style comments") - AlignCtrl v ^\s*/[/*] - AlignCtrl mWp1P1=l @ - 'a,.Align - else - echoerr "(AlignMaps) AlignMaps#StdAlign doesn't support mode#".a:mode - endif -" call Dret("AlignMaps#StdAlign") -endfun - -" --------------------------------------------------------------------- -" AlignMaps#CharJoiner: joins lines which end in the given character (spaces {{{2 -" at end are ignored) -fun! AlignMaps#CharJoiner(chr) -" call Dfunc("AlignMaps#CharJoiner(chr=".a:chr.")") - let aline = line("'a") - let rep = line(".") - aline - while rep > 0 - norm! 'a - while match(getline(aline),a:chr . "\s*$") != -1 && rep >= 0 - " while = at end-of-line, delete it and join with next - norm! 'a$ - j! - let rep = rep - 1 - endwhile - " update rep(eat) count - let rep = rep - 1 - if rep <= 0 - " terminate loop if at end-of-block - break - endif - " prepare for next line - norm! jma - let aline = line("'a") - endwhile -" call Dret("AlignMaps#CharJoiner") -endfun - -" --------------------------------------------------------------------- -" AlignMaps#Equals: supports \t= and \T= {{{2 -fun! AlignMaps#Equals() range -" call Dfunc("AlignMaps#Equals()") - 'a,'zs/\s\+\([*/+\-%|&\~^]\==\)/ \1/e - 'a,'zs@ \+\([*/+\-%|&\~^]\)=@\1=@ge - 'a,'zs/==/\="\\"/ge - 'a,'zs/\([!<>:]\)=/\=submatch(1)."\"/ge - norm g'zk - AlignCtrl mIp1P1=l = - AlignCtrl g = - 'a,'z-1Align - 'a,'z-1s@\([*/+\-%|&\~^!=]\)\( \+\)=@\2\1=@ge - 'a,'z-1s/\( \+\);/;\1/ge - if &ft == "c" || &ft == "cpp" -" call Decho("exception for ".&ft) - 'a,'z-1v/^\s*\/[*/]/s/\/[*/]/@&@/e - 'a,'z-1v/^\s*\/[*/]/s/\*\//@&/e - if exists("g:mapleader") - exe "norm 'zk" - call AlignMaps#StdAlign(1) - else - exe "norm 'zk" - call AlignMaps#StdAlign(1) - endif - 'y,'zs/^\(\s*\) @/\1/e - endif - 'a,'z-1s/\%x0f/=/ge - 'y,'zs/ @//eg -" call Dret("AlignMaps#Equals") -endfun - -" --------------------------------------------------------------------- -" AlignMaps#Afnc: useful for splitting one-line function beginnings {{{2 -" into one line per argument format -fun! AlignMaps#Afnc() -" call Dfunc("AlignMaps#Afnc()") - - " keep display quiet - let chkeep = &ch - let gdkeep = &gd - let vekeep = &ve - set ch=2 nogd ve= - - " will use marks y,z ; save current values - let mykeep = SaveMark("'y") - let mzkeep = SaveMark("'z") - - " Find beginning of function -- be careful to skip over comments - let cmmntid = synIDtrans(hlID("Comment")) - let stringid = synIDtrans(hlID("String")) - exe "norm! ]]" - while search(")","bW") != 0 -" call Decho("line=".line(".")." col=".col(".")) - let parenid= synIDtrans(synID(line("."),col("."),1)) - if parenid != cmmntid && parenid != stringid - break - endif - endwhile - norm! %my - s/(\s*\(\S\)/(\r \1/e - exe "norm! `y%" - s/)\s*\(\/[*/]\)/)\r\1/e - exe "norm! `y%mz" - 'y,'zs/\s\+$//e - 'y,'zs/^\s\+//e - 'y+1,'zs/^/ / - - " insert newline after every comma only one parenthesis deep - sil! exe "norm! `y\h" - let parens = 1 - let cmmnt = 0 - let cmmntline= -1 - while parens >= 1 -" call Decho("parens=".parens." @a=".@a) - exe 'norm! ma "ay`a ' - if @a == "(" - let parens= parens + 1 - elseif @a == ")" - let parens= parens - 1 - - " comment bypass: /* ... */ or //... - elseif cmmnt == 0 && @a == '/' - let cmmnt= 1 - elseif cmmnt == 1 - if @a == '/' - let cmmnt = 2 " //... - let cmmntline= line(".") - elseif @a == '*' - let cmmnt= 3 " /*... - else - let cmmnt= 0 - endif - elseif cmmnt == 2 && line(".") != cmmntline - let cmmnt = 0 - let cmmntline= -1 - elseif cmmnt == 3 && @a == '*' - let cmmnt= 4 - elseif cmmnt == 4 - if @a == '/' - let cmmnt= 0 " ...*/ - elseif @a != '*' - let cmmnt= 3 - endif - - elseif @a == "," && parens == 1 && cmmnt == 0 - exe "norm! i\\" - endif - endwhile - norm! `y%mz% - sil! 'y,'zg/^\s*$/d - - " perform substitutes to mark fields for Align - sil! 'y+1,'zv/^\//s/^\s\+\(\S\)/ \1/e - sil! 'y+1,'zv/^\//s/\(\S\)\s\+/\1 /eg - sil! 'y+1,'zv/^\//s/\* \+/*/ge - sil! 'y+1,'zv/^\//s/\w\zs\s*\*/ */ge - " func - " ws <- declaration -> <-ptr -> <-var-> <-[array][] -> <-glop-> <-end-> - sil! 'y+1,'zv/^\//s/^\s*\(\(\K\k*\s*\)\+\)\s\+\([(*]*\)\s*\(\K\k*\)\s*\(\(\[.\{-}]\)*\)\s*\(.\{-}\)\=\s*\([,)]\)\s*$/ \1@#\3@\4\5@\7\8/e - sil! 'y+1,'z+1g/^\s*\/[*/]/norm! kJ - sil! 'y+1,'z+1s%/[*/]%@&@%ge - sil! 'y+1,'z+1s%*/%@&%ge - AlignCtrl mIp0P0=l @ - sil! 'y+1,'zAlign - sil! 'y,'zs%@\(/[*/]\)@%\t\1 %e - sil! 'y,'zs%@\*/% */%e - sil! 'y,'zs/@\([,)]\)/\1/ - sil! 'y,'zs/@/ / - AlignCtrl mIlrp0P0= # @ - sil! 'y+1,'zAlign - sil! 'y+1,'zs/#/ / - sil! 'y+1,'zs/@// - sil! 'y+1,'zs/\(\s\+\)\([,)]\)/\2\1/e - - " Restore - call RestoreMark(mykeep) - call RestoreMark(mzkeep) - let &ch= chkeep - let &gd= gdkeep - let &ve= vekeep - -" call Dret("AlignMaps#Afnc") -endfun - -" --------------------------------------------------------------------- -" AlignMaps#FixMultiDec: converts a type arg,arg,arg; line to multiple lines {{{2 -fun! AlignMaps#FixMultiDec() -" call Dfunc("AlignMaps#FixMultiDec()") - - " save register x - let xkeep = @x - let curline = getline(".") -" call Decho("curline<".curline.">") - - " Get the type. I'm assuming one type per line (ie. int x; double y; on one line will not be handled properly) - let @x=substitute(curline,'^\(\s*[a-zA-Z_ \t][a-zA-Z0-9_ \t]*\)\s\+[(*]*\h.*$','\1','') -" call Decho("@x<".@x.">") - - " transform line - exe 's/,/;\r'.@x.' /ge' - - "restore register x - let @x= xkeep - -" call Dret("AlignMaps#FixMultiDec : my=".line("'y")." mz=".line("'z")) -endfun - -" --------------------------------------------------------------------- -" Restore: {{{1 -let &cpo= s:keepcpo -unlet s:keepcpo -" vim: ts=4 fdm=marker diff --git a/vim/autoload/ZoomWin.vim b/vim/autoload/ZoomWin.vim deleted file mode 100644 index d2d993f..0000000 --- a/vim/autoload/ZoomWin.vim +++ /dev/null @@ -1,380 +0,0 @@ -" ZoomWin: Brief-like ability to zoom into/out-of a window -" Author: Charles Campbell -" original version by Ron Aaron -" Date: Jan 26, 2009 -" Version: 23 -" History: see :help zoomwin-history {{{1 -" GetLatestVimScripts: 508 1 :AutoInstall: ZoomWin.vim - -" --------------------------------------------------------------------- -" Load Once: {{{1 -if &cp || exists("g:loaded_ZoomWin") - finish -endif -if v:version < 702 - echohl WarningMsg - echo "***warning*** this version of ZoomWin needs vim 7.2" - echohl Normal - finish -endif -let s:keepcpo = &cpo -let g:loaded_ZoomWin = "v23" -set cpo&vim -"DechoTabOn - -" ===================================================================== -" Functions: {{{1 - -" --------------------------------------------------------------------- -" ZoomWin#ZoomWin: toggles between a single-window and a multi-window layout {{{2 -" The original version was by Ron Aaron. -fun! ZoomWin#ZoomWin() -" let g:decho_hide= 1 "Decho -" call Dfunc("ZoomWin#ZoomWin() winbufnr(2)=".winbufnr(2)) - - " if the vim doesn't have +mksession, only a partial zoom is available {{{3 - if !has("mksession") - if !exists("s:partialzoom") - echomsg "missing the +mksession feature; only a partial zoom is available" - let s:partialzoom= 0 - endif - if v:version < 630 - echoerr "***sorry*** you need an updated vim, preferably with +mksession" - elseif s:partialzoom - " partial zoom out - let s:partialzoom= 0 - exe s:winrestore - else - " partial zoom in - let s:partialzoom= 1 - let s:winrestore = winrestcmd() - res - endif -" call Dret("ZoomWin#ZoomWin : partialzoom=".s:partialzoom) - return - endif - - " Close certain windows {{{3 - call s:ZoomWinPreserve(0) - - " save options. Force window minimum height/width to be >= 1 {{{3 - let keep_hidden = &hidden - let keep_write = &write - - if v:version < 603 - if &wmh == 0 || &wmw == 0 - let keep_wmh = &wmh - let keep_wmw = &wmw - silent! set wmh=1 wmw=1 - endif - endif - set hidden write - - if winbufnr(2) == -1 - " there's only one window - restore to multiple-windows mode {{{3 -" call Decho("there's only one window - restore to multiple windows") - - if exists("s:sessionfile") && filereadable(s:sessionfile) - " save position in current one-window-only -" call Decho("save position in current one-window-only in sponly") - let sponly = s:SavePosn(0) - let s:origline = line(".") - let s:origcol = virtcol(".") - - " source session file to restore window layout - let ei_keep= &ei - set ei=all - exe 'silent! so '.fnameescape(s:sessionfile) -" Decho("@@<".@@.">") - let v:this_session= s:sesskeep - - if exists("s:savedposn1") - " restore windows' positioning and buffers -" call Decho("restore windows, positions, buffers") - windo call s:RestorePosn(s:savedposn{winnr()})|unlet s:savedposn{winnr()} - call s:GotoWinNum(s:winkeep) - unlet s:winkeep - endif - - if line(".") != s:origline || virtcol(".") != s:origcol - " If the cursor hasn't moved from the original position, - " then let the position remain what it was in the original - " multi-window layout. -" call Decho("restore position using sponly") - call s:RestorePosn(sponly) - endif - - " delete session file and variable holding its name -" call Decho("delete session file") - call delete(s:sessionfile) - unlet s:sessionfile - let &ei=ei_keep - endif - - else " there's more than one window - go to only-one-window mode {{{3 -" call Decho("there's multiple windows - goto one-window-only") - - let s:winkeep = winnr() - let s:sesskeep = v:this_session - - " doesn't work with the command line window (normal mode q:) - if &bt == "nofile" && expand("%") == (v:version < 702 ? 'command-line' : '[Command Line]') - echoerr "***error*** ZoomWin#ZoomWin doesn't work with the ".expand("%")." window" -" call Dret("ZoomWin#ZoomWin : ".expand('%')." window error") - return - endif -" call Decho("1: @@<".@@.">") - - " disable all events (autocmds) -" call Decho("disable events") - let ei_keep= &ei - set ei=all -" call Decho("2: @@<".@@.">") - - " save window positioning commands -" call Decho("save window positioning commands") - windo let s:savedposn{winnr()}= s:SavePosn(1) - call s:GotoWinNum(s:winkeep) - - " set up name of session file -" call Decho("3: @@<".@@.">") - let s:sessionfile= tempname() -" call Decho("4: @@<".@@.">") - - " save session -" call Decho("save session") - let ssop_keep = &ssop - let &ssop = 'blank,help,winsize,folds,globals,localoptions,options' -" call Decho("5: @@<".@@.">") - exe 'mksession! '.fnameescape(s:sessionfile) -" call Decho("6: @@<".@@.">") - let keepyy= @@ - let keepy0= @0 - let keepy1= @1 - let keepy2= @2 - let keepy3= @3 - let keepy4= @4 - let keepy5= @5 - let keepy6= @6 - let keepy7= @7 - let keepy8= @8 - let keepy9= @9 - set lz ei=all bh= - if v:version >= 700 - try - exe "keepalt keepmarks new! ".fnameescape(s:sessionfile) - catch /^Vim\%((\a\+)\)\=:E/ - echoerr "Too many windows" - silent! call delete(s:sessionfile) - unlet s:sessionfile -" call Dret("ZoomWin#ZoomWin : too many windows") - return - endtry - silent! keepjumps keepmarks v/wincmd\|split\|resize/d - keepalt w! - keepalt bw! - else - exe "new! ".fnameescape(s:sessionfile) - v/wincmd\|split\|resize/d - w! - bw! - endif - let @@= keepyy - let @0= keepy0 - let @1= keepy1 - let @2= keepy2 - let @3= keepy3 - let @4= keepy4 - let @5= keepy5 - let @6= keepy6 - let @7= keepy7 - let @8= keepy8 - let @9= keepy9 - call histdel('search', -1) - let @/ = histget('search', -1) -" call Decho("7: @@<".@@.">") - - " restore user's session options and restore event handling -" call Decho("restore user session options and event handling") - set nolz - let &ssop = ssop_keep - silent! only! -" call Decho("8: @@<".@@.">") - let &ei = ei_keep - echomsg expand("%") -" call Decho("9: @@<".@@.">") - endif - - " restore user option settings {{{3 -" call Decho("restore user option settings") - let &hidden= keep_hidden - let &write = keep_write - if v:version < 603 - if exists("keep_wmw") - let &wmh= keep_wmh - let &wmw= keep_wmw - endif - endif - - " Re-open certain windows {{{3 - call s:ZoomWinPreserve(1) - -" call Dret("ZoomWin#ZoomWin") -endfun - -" --------------------------------------------------------------------- -" SavePosn: this function sets up a savedposn variable that {{{2 -" has the commands necessary to restore the view -" of the current window. -fun! s:SavePosn(savewinhoriz) -" call Dfunc("SavePosn(savewinhoriz=".a:savewinhoriz.") file<".expand("%").">") - let swline = line(".") - if swline == 1 && getline(1) == "" - " empty buffer - let savedposn= "silent b ".winbufnr(0) -" call Dret("SavePosn savedposn<".savedposn.">") - return savedposn - endif - let swcol = col(".") - let swwline = winline()-1 - let swwcol = virtcol(".") - wincol() - let savedposn = "silent b ".winbufnr(0)."|".swline."|silent norm! z\" - if swwline > 0 - let savedposn= savedposn.":silent norm! ".swwline."\\:silent norm! zs\" - endif - let savedposn= savedposn.":silent call cursor(".swline.",".swcol.")\" - - if a:savewinhoriz - if swwcol > 0 - let savedposn= savedposn.":silent norm! ".swwcol."zl\" - endif - - " handle certain special settings for the multi-window savedposn call - " bufhidden buftype buflisted - let settings= "" - if &bh != "" - let settings="bh=".&bh - setlocal bh=hide - endif - if !&bl - let settings= settings." nobl" - setlocal bl - endif - if &bt != "" - let settings= settings." bt=".&bt - setlocal bt= - endif - if settings != "" - let savedposn= savedposn.":setlocal ".settings."\" - endif - - endif -" call Dret("SavePosn savedposn<".savedposn.">") - return savedposn -endfun - -" --------------------------------------------------------------------- -" s:RestorePosn: this function restores noname and scratch windows {{{2 -fun! s:RestorePosn(savedposn) -" call Dfunc("RestorePosn(savedposn<".a:savedposn.">) file<".expand("%").">") - if &scb - setlocal noscb - exe a:savedposn - setlocal scb - else - exe a:savedposn - endif -" call Dret("RestorePosn") -endfun - -" --------------------------------------------------------------------- -" CleanupSessionFile: if you exit Vim before cleaning up the {{{2 -" supposed-to-be temporary session file -fun! ZoomWin#CleanupSessionFile() -" call Dfunc("ZoomWin#CleanupSessionFile()") - if exists("s:sessionfile") && filereadable(s:sessionfile) -" call Decho("sessionfile exists and is readable; deleting it") - silent! call delete(s:sessionfile) - unlet s:sessionfile - endif -" call Dret("ZoomWin#CleanupSessionFile") -endfun - -" --------------------------------------------------------------------- -" GotoWinNum: this function puts cursor into specified window {{{2 -fun! s:GotoWinNum(winnum) -" call Dfunc("GotoWinNum(winnum=".a:winnum.") winnr=".winnr()) - if a:winnum != winnr() - exe a:winnum."wincmd w" - endif -" call Dret("GotoWinNum") -endfun - - -" --------------------------------------------------------------------- -" ZoomWinPreserve: This function, largely written by David Fishburn, {{{2 -" allows ZoomWin to "preserve" certain windows: -" -" TagList, by Yegappan Lakshmanan -" http://vim.sourceforge.net/scripts/script.php?script_id=273 -" -" WinManager, by Srinath Avadhanula -" http://vim.sourceforge.net/scripts/script.php?script_id=95 -" -" It does so by closing the associated window upon entry to ZoomWin -" and re-opening it upon exit by using commands provided by the -" utilities themselves. -fun! s:ZoomWinPreserve(open) -" call Dfunc("ZoomWinPreserve(open=".a:open.")") - - if a:open == 0 - - " Close Taglist - if exists('g:zoomwin_preserve_taglist') && exists('g:loaded_taglist') - " If taglist window is open then close it. - let s:taglist_winnum = bufwinnr(g:TagList_title) - if s:taglist_winnum != -1 - " Close the window - exec "silent! Tlist" - endif - endif - - " Close Winmanager - if exists('g:zoomwin_preserve_winmanager') && exists('g:loaded_winmanager') - " If the winmanager window is open then close it. - let s:is_winmgr_vis = IsWinManagerVisible() - if s:is_winmgr_vis == 1 - exec "WMClose" - endif - endif - - else - - " Re-open Taglist - if exists('g:zoomwin_preserve_taglist') && exists('g:loaded_taglist') - " If taglist window was open, open it again - if s:taglist_winnum != -1 - exec "silent! Tlist" - endif - endif - - " Re-Open Winmanager - if exists('g:zoomwin_preserve_winmanager') && exists('g:loaded_winmanager') - " If the winmanager window is open then close it. - if s:is_winmgr_vis == 1 - exec "WManager" - endif - endif - endif - -" call Dret("ZoomWinPreserve") -endfun - -" ===================================================================== -" Restore: {{{1 -let &cpo= s:keepcpo -unlet s:keepcpo - -" --------------------------------------------------------------------- -" Modelines: {{{1 -" vim: ts=4 fdm=marker diff --git a/vim/autoload/delimitMate.vim b/vim/autoload/delimitMate.vim deleted file mode 100644 index bd10975..0000000 --- a/vim/autoload/delimitMate.vim +++ /dev/null @@ -1,586 +0,0 @@ -" File: autoload/delimitMate.vim -" Version: 2.6 -" Modified: 2011-01-14 -" Description: This plugin provides auto-completion for quotes, parens, etc. -" Maintainer: Israel Chauca F. -" Manual: Read ":help delimitMate". -" ============================================================================ - -" Utilities {{{ - -let delimitMate_loaded = 1 - -function! delimitMate#ShouldJump() "{{{ - " Returns 1 if the next character is a closing delimiter. - let col = col('.') - let lcol = col('$') - let char = getline('.')[col - 1] - - " Closing delimiter on the right. - for cdel in b:_l_delimitMate_right_delims + b:_l_delimitMate_quotes_list - if char == cdel - return 1 - endif - endfor - - " Closing delimiter with space expansion. - let nchar = getline('.')[col] - if b:_l_delimitMate_expand_space && char == " " - for cdel in b:_l_delimitMate_right_delims + b:_l_delimitMate_quotes_list - if nchar == cdel - return 1 - endif - endfor - endif - - " Closing delimiter with CR expansion. - let uchar = getline(line('.') + 1)[0] - if b:_l_delimitMate_expand_cr && char == "" - for cdel in b:_l_delimitMate_right_delims + b:_l_delimitMate_quotes_list - if uchar == cdel - return 1 - endif - endfor - endif - - return 0 -endfunction "}}} - -function! delimitMate#IsEmptyPair(str) "{{{ - for pair in b:_l_delimitMate_matchpairs_list - if a:str == join( split( pair, ':' ),'' ) - return 1 - endif - endfor - for quote in b:_l_delimitMate_quotes_list - if a:str == quote . quote - return 1 - endif - endfor - return 0 -endfunction "}}} - -function! delimitMate#IsCRExpansion() " {{{ - let nchar = getline(line('.')-1)[-1:] - let schar = getline(line('.')+1)[:0] - let isEmpty = getline('.') == "" - if index(b:_l_delimitMate_left_delims, nchar) > -1 && - \ index(b:_l_delimitMate_left_delims, nchar) == index(b:_l_delimitMate_right_delims, schar) && - \ isEmpty - return 1 - elseif index(b:_l_delimitMate_quotes_list, nchar) > -1 && - \ index(b:_l_delimitMate_quotes_list, nchar) == index(b:_l_delimitMate_quotes_list, schar) && - \ isEmpty - return 1 - else - return 0 - endif -endfunction " }}} delimitMate#IsCRExpansion() - -function! delimitMate#IsSpaceExpansion() " {{{ - let line = getline('.') - let col = col('.')-2 - if col > 0 - let pchar = line[col - 1] - let nchar = line[col + 2] - let isSpaces = (line[col] == line[col+1] && line[col] == " ") - - if index(b:_l_delimitMate_left_delims, pchar) > -1 && - \ index(b:_l_delimitMate_left_delims, pchar) == index(b:_l_delimitMate_right_delims, nchar) && - \ isSpaces - return 1 - elseif index(b:_l_delimitMate_quotes_list, pchar) > -1 && - \ index(b:_l_delimitMate_quotes_list, pchar) == index(b:_l_delimitMate_quotes_list, nchar) && - \ isSpaces - return 1 - endif - endif - return 0 -endfunction " }}} IsSpaceExpansion() - -function! delimitMate#WithinEmptyPair() "{{{ - let cur = strpart( getline('.'), col('.')-2, 2 ) - return delimitMate#IsEmptyPair( cur ) -endfunction "}}} - -function! delimitMate#WriteBefore(str) "{{{ - let len = len(a:str) - let line = getline('.') - let col = col('.')-2 - if col < 0 - call setline('.',line[(col+len+1):]) - else - call setline('.',line[:(col)].line[(col+len+1):]) - endif - return a:str -endfunction " }}} - -function! delimitMate#WriteAfter(str) "{{{ - let len = len(a:str) - let line = getline('.') - let col = col('.')-2 - if (col) < 0 - call setline('.',a:str.line) - else - call setline('.',line[:(col)].a:str.line[(col+len):]) - endif - return '' -endfunction " }}} - -function! delimitMate#GetSyntaxRegion(line, col) "{{{ - return synIDattr(synIDtrans(synID(a:line, a:col, 1)), 'name') -endfunction " }}} - -function! delimitMate#GetCurrentSyntaxRegion() "{{{ - let col = col('.') - if col == col('$') - let col = col - 1 - endif - return delimitMate#GetSyntaxRegion(line('.'), col) -endfunction " }}} - -function! delimitMate#GetCurrentSyntaxRegionIf(char) "{{{ - let col = col('.') - let origin_line = getline('.') - let changed_line = strpart(origin_line, 0, col - 1) . a:char . strpart(origin_line, col - 1) - call setline('.', changed_line) - let region = delimitMate#GetSyntaxRegion(line('.'), col) - call setline('.', origin_line) - return region -endfunction "}}} - -function! delimitMate#IsForbidden(char) "{{{ - if b:_l_delimitMate_excluded_regions_enabled == 0 - return 0 - endif - "let result = index(b:_l_delimitMate_excluded_regions_list, delimitMate#GetCurrentSyntaxRegion()) >= 0 - if index(b:_l_delimitMate_excluded_regions_list, delimitMate#GetCurrentSyntaxRegion()) >= 0 - "echom "Forbidden 1!" - return 1 - endif - let region = delimitMate#GetCurrentSyntaxRegionIf(a:char) - "let result = index(b:_l_delimitMate_excluded_regions_list, region) >= 0 - "return result || region == 'Comment' - "echom "Forbidden 2!" - return index(b:_l_delimitMate_excluded_regions_list, region) >= 0 -endfunction "}}} - -function! delimitMate#FlushBuffer() " {{{ - let b:_l_delimitMate_buffer = [] - return '' -endfunction " }}} - -function! delimitMate#BalancedParens(char) "{{{ - " Returns: - " = 0 => Parens balanced. - " > 0 => More opening parens. - " < 0 => More closing parens. - - let line = getline('.') - let col = col('.') - 2 - let col = col >= 0 ? col : 0 - let list = split(line, '\zs') - let left = b:_l_delimitMate_left_delims[index(b:_l_delimitMate_right_delims, a:char)] - let right = a:char - let opening = 0 - let closing = 0 - - " If the cursor is not at the beginning, count what's behind it. - if col > 0 - " Find the first opening paren: - let start = index(list, left) - " Must be before cursor: - let start = start < col ? start : col - 1 - " Now count from the first opening until the cursor, this will prevent - " extra closing parens from being counted. - let opening = count(list[start : col - 1], left) - let closing = count(list[start : col - 1], right) - " I don't care if there are more closing parens than opening parens. - let closing = closing > opening ? opening : closing - endif - - " Evaluate parens from the cursor to the end: - let opening += count(list[col :], left) - let closing += count(list[col :], right) - - "echom "–––––––––" - "echom line - "echom col - ""echom left.":".a:char - "echom string(list) - "echom string(list[start : col - 1]) . " : " . string(list[col :]) - "echom opening . " - " . closing . " = " . (opening - closing) - - " Return the found balance: - return opening - closing -endfunction "}}} - -function! delimitMate#RmBuffer(num) " {{{ - if len(b:_l_delimitMate_buffer) > 0 - call remove(b:_l_delimitMate_buffer, 0, (a:num-1)) - endif - return "" -endfunction " }}} - -" }}} - -" Doers {{{ -function! delimitMate#SkipDelim(char) "{{{ - if delimitMate#IsForbidden(a:char) - return a:char - endif - let col = col('.') - 1 - let line = getline('.') - if col > 0 - let cur = line[col] - let pre = line[col-1] - else - let cur = line[col] - let pre = "" - endif - if pre == "\\" - " Escaped character - return a:char - elseif cur == a:char - " Exit pair - "return delimitMate#WriteBefore(a:char) - return a:char . delimitMate#Del() - elseif delimitMate#IsEmptyPair( pre . a:char ) - " Add closing delimiter and jump back to the middle. - call insert(b:_l_delimitMate_buffer, a:char) - return delimitMate#WriteAfter(a:char) - else - " Nothing special here, return the same character. - return a:char - endif -endfunction "}}} - -function! delimitMate#ParenDelim(char) " {{{ - if delimitMate#IsForbidden(a:char) - return '' - endif - " Try to balance matchpairs - if b:_l_delimitMate_balance_matchpairs && - \ delimitMate#BalancedParens(a:char) <= 0 - return '' - endif - let line = getline('.') - let col = col('.')-2 - let left = b:_l_delimitMate_left_delims[index(b:_l_delimitMate_right_delims,a:char)] - let smart_matchpairs = substitute(b:_l_delimitMate_smart_matchpairs, '\\!', left, 'g') - let smart_matchpairs = substitute(smart_matchpairs, '\\#', a:char, 'g') - "echom left.':'.smart_matchpairs . ':' . matchstr(line[col+1], smart_matchpairs) - if b:_l_delimitMate_smart_matchpairs != '' && - \ line[col+1:] =~ smart_matchpairs - return '' - elseif (col) < 0 - call setline('.',a:char.line) - call insert(b:_l_delimitMate_buffer, a:char) - else - "echom string(col).':'.line[:(col)].'|'.line[(col+1):] - call setline('.',line[:(col)].a:char.line[(col+1):]) - call insert(b:_l_delimitMate_buffer, a:char) - endif - return '' -endfunction " }}} - -function! delimitMate#QuoteDelim(char) "{{{ - if delimitMate#IsForbidden(a:char) - return a:char - endif - let line = getline('.') - let col = col('.') - 2 - if line[col] == "\\" - " Seems like a escaped character, insert one quotation mark. - return a:char - elseif line[col + 1] == a:char && - \ index(b:_l_delimitMate_nesting_quotes, a:char) < 0 - " Get out of the string. - return a:char . delimitMate#Del() - elseif (line[col] =~ '\w' && a:char == "'") || - \ (b:_l_delimitMate_smart_quotes && - \ (line[col] =~ '\w' || - \ line[col + 1] =~ '\w')) - " Seems like an apostrophe or a smart quote case, insert a single quote. - return a:char - elseif (line[col] == a:char && line[col + 1 ] != a:char) && b:_l_delimitMate_smart_quotes - " Seems like we have an unbalanced quote, insert one quotation mark and jump to the middle. - call insert(b:_l_delimitMate_buffer, a:char) - return delimitMate#WriteAfter(a:char) - else - " Insert a pair and jump to the middle. - call insert(b:_l_delimitMate_buffer, a:char) - call delimitMate#WriteAfter(a:char) - return a:char - endif -endfunction "}}} - -function! delimitMate#JumpOut(char) "{{{ - if delimitMate#IsForbidden(a:char) - return a:char - endif - let line = getline('.') - let col = col('.')-2 - if line[col+1] == a:char - return a:char . delimitMate#Del() - else - return a:char - endif -endfunction " }}} - -function! delimitMate#JumpAny(key) " {{{ - if delimitMate#IsForbidden('') - return a:key - endif - if !delimitMate#ShouldJump() - return a:key - endif - " Let's get the character on the right. - let char = getline('.')[col('.')-1] - if char == " " - " Space expansion. - "let char = char . getline('.')[col('.')] . delimitMate#Del() - return char . getline('.')[col('.')] . delimitMate#Del() . delimitMate#Del() - "call delimitMate#RmBuffer(1) - elseif char == "" - " CR expansion. - "let char = "\" . getline(line('.') + 1)[0] . "\" - let b:_l_delimitMate_buffer = [] - return "\" . getline(line('.') + 1)[0] . "\" - else - "call delimitMate#RmBuffer(1) - return char . delimitMate#Del() - endif -endfunction " delimitMate#JumpAny() }}} - -function! delimitMate#JumpMany() " {{{ - let line = getline('.')[col('.') - 1 : ] - let len = len(line) - let rights = "" - let found = 0 - let i = 0 - while i < len - let char = line[i] - if index(b:_l_delimitMate_quotes_list, char) >= 0 || - \ index(b:_l_delimitMate_right_delims, char) >= 0 - let rights .= "\" - let found = 1 - elseif found == 0 - let rights .= "\" - else - break - endif - let i += 1 - endwhile - if found == 1 - return rights - else - return '' - endif -endfunction " delimitMate#JumpMany() }}} - -function! delimitMate#ExpandReturn() "{{{ - if delimitMate#IsForbidden("") - return "\" - endif - if delimitMate#WithinEmptyPair() - " Expand: - call delimitMate#FlushBuffer() - "return "\a\x\\k$\"_xa" - return "\\\o" - else - return "\" - endif -endfunction "}}} - -function! delimitMate#ExpandSpace() "{{{ - if delimitMate#IsForbidden("\") - return "\" - endif - if delimitMate#WithinEmptyPair() - " Expand: - call insert(b:_l_delimitMate_buffer, 's') - return delimitMate#WriteAfter(' ') . "\" - else - return "\" - endif -endfunction "}}} - -function! delimitMate#BS() " {{{ - if delimitMate#IsForbidden("") - return "\" - endif - if delimitMate#WithinEmptyPair() - "call delimitMate#RmBuffer(1) - return "\" . delimitMate#Del() -" return "\\\" - elseif delimitMate#IsSpaceExpansion() - "call delimitMate#RmBuffer(1) - return "\" . delimitMate#Del() - elseif delimitMate#IsCRExpansion() - return "\\" - else - return "\" - endif -endfunction " }}} delimitMate#BS() - -function! delimitMate#Del() " {{{ - if len(b:_l_delimitMate_buffer) > 0 - let line = getline('.') - let col = col('.') - 2 - call delimitMate#RmBuffer(1) - call setline('.', line[:col] . line[col+2:]) - return '' - else - return "\" - endif -endfunction " }}} - -function! delimitMate#Finish(move_back) " {{{ - let len = len(b:_l_delimitMate_buffer) - if len > 0 - let buffer = join(b:_l_delimitMate_buffer, '') - let len2 = len(buffer) - " Reset buffer: - let b:_l_delimitMate_buffer = [] - let line = getline('.') - let col = col('.') -2 - "echom 'col: ' . col . '-' . line[:col] . "|" . line[col+len+1:] . '%' . buffer - if col < 0 - call setline('.', line[col+len2+1:]) - else - call setline('.', line[:col] . line[col+len2+1:]) - endif - let i = 1 - let lefts = "" - while i <= len && a:move_back - let lefts = lefts . "\" - let i += 1 - endwhile - return substitute(buffer, "s", "\", 'g') . lefts - endif - return '' -endfunction " }}} - -" }}} - -" Tools: {{{ -function! delimitMate#TestMappings() "{{{ - let options = sort(keys(delimitMate#OptionsList())) - let optoutput = ['delimitMate Report', '==================', '', '* Options: ( ) default, (g) global, (b) buffer',''] - for option in options - exec 'call add(optoutput, ''('.(exists('b:delimitMate_'.option) ? 'b' : exists('g:delimitMate_'.option) ? 'g' : ' ').') delimitMate_''.option.'' = ''.string(b:_l_delimitMate_'.option.'))' - endfor - call append(line('$'), optoutput + ['--------------------','']) - - " Check if mappings were set. {{{ - let imaps = b:_l_delimitMate_right_delims - let imaps = imaps + ( b:_l_delimitMate_autoclose ? b:_l_delimitMate_left_delims : [] ) - let imaps = imaps + - \ b:_l_delimitMate_quotes_list + - \ b:_l_delimitMate_apostrophes_list + - \ ['', '', '', '', ''] + - \ ['', '', '', '', '', ''] + - \ ['', '', '', '', '', '', 'g'] - let imaps = imaps + ( b:_l_delimitMate_expand_cr ? [''] : [] ) - let imaps = imaps + ( b:_l_delimitMate_expand_space ? [''] : [] ) - - let vmaps = - \ b:_l_delimitMate_right_delims + - \ b:_l_delimitMate_left_delims + - \ b:_l_delimitMate_quotes_list - - let ibroken = [] - for map in imaps - if maparg(map, "i") !~? 'delimitMate' - let output = '' - if map == '|' - let map = '' - endif - redir => output | execute "verbose imap ".map | redir END - let ibroken = ibroken + [map.": is not set:"] + split(output, '\n') - endif - endfor - - unlet! output - if ibroken == [] - let output = ['* Mappings:', '', 'All mappings were set-up.', '--------------------', '', ''] - else - let output = ['* Mappings:', ''] + ibroken + ['--------------------', ''] - endif - call append('$', output+['* Showcase:', '']) - " }}} - if b:_l_delimitMate_autoclose - " {{{ - for i in range(len(b:_l_delimitMate_left_delims)) - exec "normal Go0\Open: " . b:_l_delimitMate_left_delims[i]. "|" - exec "normal o0\Delete: " . b:_l_delimitMate_left_delims[i] . "\|" - exec "normal o0\Exit: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "|" - if b:_l_delimitMate_expand_space == 1 - exec "normal o0\Space: " . b:_l_delimitMate_left_delims[i] . " |" - exec "normal o0\Delete space: " . b:_l_delimitMate_left_delims[i] . " \|" - endif - if b:_l_delimitMate_expand_cr == 1 - exec "normal o0\Car return: " . b:_l_delimitMate_left_delims[i] . "\|" - exec "normal Go0\Delete car return: " . b:_l_delimitMate_left_delims[i] . "\0\\|" - endif - call append(line('$'), '') - endfor - for i in range(len(b:_l_delimitMate_quotes_list)) - exec "normal Go0\Open: " . b:_l_delimitMate_quotes_list[i] . "|" - exec "normal o0\Delete: " . b:_l_delimitMate_quotes_list[i] . "\|" - exec "normal o0\Exit: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "|" - if b:_l_delimitMate_expand_space == 1 - exec "normal o0\Space: " . b:_l_delimitMate_quotes_list[i] . " |" - exec "normal o0\Delete space: " . b:_l_delimitMate_quotes_list[i] . " \|" - endif - if b:_l_delimitMate_expand_cr == 1 - exec "normal o0\Car return: " . b:_l_delimitMate_quotes_list[i] . "\|" - exec "normal Go0\Delete car return: " . b:_l_delimitMate_quotes_list[i] . "\\|" - endif - call append(line('$'), '') - endfor - "}}} - else - "{{{ - for i in range(len(b:_l_delimitMate_left_delims)) - exec "normal GoOpen & close: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "|" - exec "normal oDelete: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "\|" - exec "normal oExit: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . b:_l_delimitMate_right_delims[i] . "|" - if b:_l_delimitMate_expand_space == 1 - exec "normal oSpace: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . " |" - exec "normal oDelete space: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . " \|" - endif - if b:_l_delimitMate_expand_cr == 1 - exec "normal oCar return: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "\|" - exec "normal GoDelete car return: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "\\|" - endif - call append(line('$'), '') - endfor - for i in range(len(b:_l_delimitMate_quotes_list)) - exec "normal GoOpen & close: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "|" - exec "normal oDelete: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "\|" - exec "normal oExit: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "|" - if b:_l_delimitMate_expand_space == 1 - exec "normal oSpace: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . " |" - exec "normal oDelete space: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . " \|" - endif - if b:_l_delimitMate_expand_cr == 1 - exec "normal oCar return: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "\|" - exec "normal GoDelete car return: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "\\|" - endif - call append(line('$'), '') - endfor - endif "}}} - redir => setoptions | set | filetype | redir END - call append(line('$'), split(setoptions,"\n") - \ + ['--------------------']) - setlocal nowrap -endfunction "}}} - -function! delimitMate#OptionsList() "{{{ - return {'autoclose' : 1,'matchpairs': &matchpairs, 'quotes' : '" '' `', 'nesting_quotes' : [], 'expand_cr' : 0, 'expand_space' : 0, 'smart_quotes' : 1, 'smart_matchpairs' : '\w', 'balance_matchpairs' : 0, 'excluded_regions' : 'Comment', 'excluded_ft' : '', 'apostrophes' : ''} -endfunction " delimitMate#OptionsList }}} -"}}} - -" vim:foldmethod=marker:foldcolumn=4 diff --git a/vim/bundle/Align b/vim/bundle/Align new file mode 160000 index 0000000..787662f --- /dev/null +++ b/vim/bundle/Align @@ -0,0 +1 @@ +Subproject commit 787662fe90cd057942bc5b682fd70c87e1a9dd77 diff --git a/vim/bundle/Colour-Sampler-Pack b/vim/bundle/Colour-Sampler-Pack new file mode 160000 index 0000000..05cded8 --- /dev/null +++ b/vim/bundle/Colour-Sampler-Pack @@ -0,0 +1 @@ +Subproject commit 05cded87b2ef29aaa9e930230bb88e23abff4441 diff --git a/vim/bundle/LargeFile b/vim/bundle/LargeFile new file mode 160000 index 0000000..2b654ca --- /dev/null +++ b/vim/bundle/LargeFile @@ -0,0 +1 @@ +Subproject commit 2b654cad2c8e253f844b87e4b768db3a205da280 diff --git a/vim/bundle/SearchComplete b/vim/bundle/SearchComplete new file mode 160000 index 0000000..d85ccf8 --- /dev/null +++ b/vim/bundle/SearchComplete @@ -0,0 +1 @@ +Subproject commit d85ccf8c6c1fa88feff0c56b8fe271b7d91bd292 diff --git a/vim/bundle/ZoomWin b/vim/bundle/ZoomWin new file mode 160000 index 0000000..cf21ce1 --- /dev/null +++ b/vim/bundle/ZoomWin @@ -0,0 +1 @@ +Subproject commit cf21ce1f4bfec10fe7e446c08e9e647a2a234e03 diff --git a/vim/bundle/ag.vim b/vim/bundle/ag.vim new file mode 160000 index 0000000..b0d5073 --- /dev/null +++ b/vim/bundle/ag.vim @@ -0,0 +1 @@ +Subproject commit b0d50730dbf692168307adef625f1378553730df diff --git a/vim/bundle/delimitMate b/vim/bundle/delimitMate new file mode 160000 index 0000000..f2efe43 --- /dev/null +++ b/vim/bundle/delimitMate @@ -0,0 +1 @@ +Subproject commit f2efe4331b74a4e1157729106cd7950ed6bbf4a8 diff --git a/vim/bundle/nerdcommenter b/vim/bundle/nerdcommenter new file mode 160000 index 0000000..0b3d928 --- /dev/null +++ b/vim/bundle/nerdcommenter @@ -0,0 +1 @@ +Subproject commit 0b3d928dce8262dedfc2f83b9aeb59a94e4f0ae4 diff --git a/vim/bundle/nerdtree b/vim/bundle/nerdtree new file mode 160000 index 0000000..b0bb781 --- /dev/null +++ b/vim/bundle/nerdtree @@ -0,0 +1 @@ +Subproject commit b0bb781fc73ef40365e4c996a16f04368d64fc9d diff --git a/vim/bundle/vim-easymotion b/vim/bundle/vim-easymotion new file mode 160000 index 0000000..667a668 --- /dev/null +++ b/vim/bundle/vim-easymotion @@ -0,0 +1 @@ +Subproject commit 667a668e114e9ec0e5d4cbcb0962d835b23614c4 diff --git a/vim/bundle/vim-endwise b/vim/bundle/vim-endwise new file mode 160000 index 0000000..9f05e4c --- /dev/null +++ b/vim/bundle/vim-endwise @@ -0,0 +1 @@ +Subproject commit 9f05e4c0c6163ec52010b0e1e6f66605ae42302d diff --git a/vim/doc/Align.txt b/vim/doc/Align.txt deleted file mode 100644 index c447372..0000000 --- a/vim/doc/Align.txt +++ /dev/null @@ -1,1469 +0,0 @@ -*align.txt* The Alignment Tool Mar 04, 2009 - -Author: Charles E. Campbell, Jr. - (remove NOSPAM from Campbell's email first) -Copyright: (c) 2004-2008 by Charles E. Campbell, Jr. *Align-copyright* - The VIM LICENSE applies to Align.vim, AlignMaps.vim, and Align.txt - (see |copyright|) except use "Align and AlignMaps" instead of "Vim" - NO WARRANTY, EXPRESS OR IMPLIED. USE AT-YOUR-OWN-RISK. - -============================================================================== -1. Contents *align* *align-contents* {{{1 - - 1. Contents.................: |align-contents| - 2. Alignment Manual.........: |align-manual| - 3. Alignment Usage..........: |align-usage| - Alignment Concepts.......: |align-concepts| - Alignment Commands.......: |align-commands| - Alignment Control........: |align-control| - Separators.............: |alignctrl-separators| - Initial Whitespace.....: |alignctrl-w| |alignctrl-W| |alignctrl-I| - Justification..........: |alignctrl-l| |alignctrl-r| |alignctrl-c| - Justification Control..: |alignctrl--| |alignctrl-+| |alignctrl-:| - Cyclic/Sequential......: |alignctrl-=| |alignctrl-C| - Separator Justification: |alignctrl-<| |alignctrl->| |alignctrl-|| - Line (de)Selection.....: |alignctrl-g| |alignctrl-v| - Temporary Settings.....: |alignctrl-m| - Padding................: |alignctrl-p| |alignctrl-P| - Current Options........: |alignctrl-settings| |alignctrl-| - Alignment................: |align-align| - 4. Alignment Maps...........: |align-maps| - \a,....................: |alignmap-a,| - \a?....................: |alignmap-a?| - \a<....................: |alignmap-a<| - \abox..................: |alignmap-abox| - \acom..................: |alignmap-acom| - \anum..................: |alignmap-anum| - \ascom.................: |alignmap-ascom| - \adec..................: |alignmap-adec| - \adef..................: |alignmap-adef| - \afnc..................: |alignmap-afnc| - \adcom.................: |alignmap-adcom| - \aocom.................: |alignmap-aocom| - \tsp...................: |alignmap-tsp| - \tsq...................: |alignmap-tsq| - \tt....................: |alignmap-tt| - \t=....................: |alignmap-t=| - \T=....................: |alignmap-T=| - \Htd...................: |alignmap-Htd| - 5. Alignment Tool History...: |align-history| - -============================================================================== -2. Align Manual *alignman* *alignmanual* *align-manual* {{{1 - - Align comes as a vimball; simply typing > - vim Align.vba.gz - :so % -< should put its components where they belong. The components are: > - .vim/plugin/AlignPlugin.vim - .vim/plugin/AlignMapsPlugin.vim - .vim/plugin/cecutil.vim - .vim/autoload/Align.vim - .vim/autoload/AlignMaps.vim - .vim/doc/Align.txt -< To see a user's guide, see |align-userguide| - To see examples, see |alignctrl| and |alignmaps| -> -/=============+=========+=====================================================\ -|| \ Default/ || -|| Commands \ Value/ Explanation || -|| | | || -++==============+====+=======================================================++ -|| AlignCtrl | | =Clrc-+:pPIWw [..list-of-separator-patterns..] || -|| | +-------------------------------------------------------+| -|| | | may be called as a command or as a function: || -|| | | :AlignCtrl =lp0P0W & \\ || -|| | | :call Align#AlignCtrl('=lp0P0W','&','\\') || -|| | | || -|| | +-------------------------------------------------------++ -|| 1st arg | = | = all separator patterns are equivalent and are || -|| | | simultaneously active. Patterns are |regexp|. || -|| | | C cycle through separator patterns. Patterns are || -|| | | |regexp| and are active sequentially. || -|| | | || -|| | < | < left justify separator Separators are justified, || -|| | | > right justify separator too. Separator styles || -|| | | | center separator are cyclic. || -|| | | || -|| | l | l left justify Justification styles are always || -|| | | r right justify cyclic (ie. lrc would mean left j., || -|| | | c center then right j., then center, repeat. || -|| | | - skip this separator || -|| | | + re-use last justification method || -|| | | : treat rest of text as a field || -|| | | || -|| | p1 | p### pad separator on left by # blanks || -|| | P1 | P### pad separator on right by # blanks || -|| | | || -|| | I | I preserve and apply first line's leading white || -|| | | space to all lines || -|| | | W preserve leading white space on every line, even || -|| | | if it varies from line to line || -|| | | w don't preserve leading white space || -|| | | || -|| | | g second argument is a selection pattern -- only || -|| | | align on lines that have a match (inspired by || -|| | | :g/selection pattern/command) || -|| | | v second argument is a selection pattern -- only || -|| | | align on lines that _don't_ have a match (inspired || -|| | | by :v/selection pattern/command) || -|| | | || -|| | | m Map support: AlignCtrl will immediately do an || -|| | | AlignPush() and the next call to Align() will do || -|| | | an AlignPop at the end. This feature allows maps || -|| | | to preserve user settings. || -|| | | || -|| | | default || -|| | | AlignCtrl default || -|| | | will clear the AlignCtrl || -|| | | stack & set the default: AlignCtrl "Ilp1P1=" '=' || -|| | | || -|| +----+-------------------------------------------------------+| -|| More args | More arguments are interpreted as describing separators || -|| +------------------------------------------------------------+| -|| No args | AlignCtrl will display its current settings || -||==============+============================================================+| -||[range]Align | [..list-of-separators..] || -||[range]Align! | [AlignCtrl settings] [..list-of-separators..] || -|| +------------------------------------------------------------+| -|| | Aligns text over the given range. The range may be || -|| | selected via visual mode (v, V, or ctrl-v) or via || -|| | the command line. The Align operation may be invoked || -|| | as a command or as a function; as a function, the first || -|| | argument is 0=separators only, 1=AlignCtrl option string || -|| | followed by a list of separators. || -|| | :[range]Align || -|| | :[range]Align [list of separators] || -|| | :[range]call Align#Align(0) || -|| | :[range]call Align#Align(0,"list","of","separators",...) || -\=============================================================================/ - -============================================================================== -3. Alignment Usage *alignusage* *align-usage* *align-userguide* {{{1 - - -ALIGNMENT CONCEPTS *align-concept* *align-concepts* {{{2 - - The typical text to be aligned is considered to be: - - * composed of two or more fields - * separated by one or more separator pattern(s): - * two or more lines -> - ws field ws separator ws field ws separator ... - ws field ws separator ws field ws separator ... -< - where "ws" stands for "white space" such as blanks and/or tabs, - and "fields" are arbitrary text. For example, consider > - - x= y= z= 3; - xx= yy= zz= 4; - zzz= yyy= zzz= 5; - a= b= c= 3; -< - Assume that it is desired to line up all the "=" signs; these, - then, are the separators. The fields are composed of all the - alphameric text. Assuming they lie on lines 1-4, one may align - those "=" signs with: > - :AlignCtrl l - :1,4Align = -< The result is: > - x = y = z = 3; - xx = yy = zz = 4; - zzz = yyy = zzz = 5; - a = b = c = 3; - -< Note how each "=" sign is surrounded by a single space; the - default padding is p1P1 (p1 means one space before the separator, - and P1 means one space after it). If you wish to change the - padding, say to no padding, use (see |alignctrl-p|) > - :AlignCtrl lp0P0 - -< Next, note how each field is left justified; that's what the "l" - (a small letter "ell") does. If right-justification of the fields - had been desired, an "r" could've been used: > - :AlignCtrl r -< yielding > - x = y = z = 3; - xx = yy = zz = 4; - zzz = yyy = zzz = 5; - a = b = c = 3; -< There are many more options available for field justification: see - |alignctrl-c| and |alignctrl--|. - - Separators, although commonly only one character long, are actually - specified by regular expressions (see |regexp|), and one may left - justify, right justify, or center them, too (see |alignctrl-<|). - - Assume that for some reason a left-right-left-right-... justification - sequence was wished. This wish is simply achieved with > - :AlignCtrl lr - :1,4Align = -< because the justification commands are considered to be "cylic"; ie. - lr is the same as lrlrlrlrlrlrlr... - - There's a lot more discussed under |alignctrl|; hopefully the examples - there will help, too. - - -ALIGNMENT COMMANDS *align-command* *align-commands* {{{2 - - The script includes two primary commands and two - minor commands: - - AlignCtrl : this command/function sets up alignment options - which persist until changed for later Align calls. - It controls such things as: how to specify field - separators, initial white space, padding about - separators, left/right/center justification, etc. > - ex. AlignCtrl wp0P1 - Interpretation: during subsequent alignment - operations, preserve each line's initial - whitespace. Use no padding before separators - but provide one padding space after separators. -< - Align : this command/function operates on the range given it to - align text based on one or more separator patterns. The - patterns may be provided via AlignCtrl or via Align - itself. > - - ex. :%Align , - Interpretation: align all commas over the entire - file. -< The :Align! format permits alignment control commands - to precede the alignment patterns. > - ex. :%Align! p2P2 = -< This will align all "=" in the file with two padding - spaces on both sides of each "=" sign. - - NOTE ON USING PATTERNS WITH ALIGN:~ - Align and AlignCtrl use || to obtain their - input patterns and they use an internal function to - split arguments at whitespace unless inside "..."s. - One may escape characters inside a double-quote string - by preceding such characters with a backslash. - - AlignPush : this command/function pushes the current AlignCtrl - state onto an internal stack. > - ex. :AlignPush - Interpretation: save the current AlignCtrl - settings, whatever they may be. They'll - also remain as the current settings until - AlignCtrl is used to change them. -< - AlignPop : this command/function pops the current AlignCtrl - state from an internal stack. > - ex. :AlignPop - Interpretation: presumably AlignPush was - used (at least once) previously; this command - restores the AlignCtrl settings when AlignPush - was last used. -< Also see |alignctrl-m| for a way to automatically do - an AlignPop after an Align (primarily this is for maps). - -ALIGNMENT OPTIONS *align-option* *align-options* {{{2 - *align-utf8* *align-utf* *align-codepoint* *align-strlen* *align-multibyte* - - For those of you who are using 2-byte (or more) characters such as are - available with utf-8, Align now provides a special option which you - may choose based upon your needs: - - Use Built-in strlen() ~ -> - let g:Align_xstrlen= 0 - -< This is the fastest method, but it doesn't handle multibyte characters - well. It is the default for: - - enc=latin1 - vim compiled without multi-byte support - $LANG is en_US.UTF-8 (assuming USA english) - - Number of codepoints (Latin a + combining circumflex is two codepoints)~ -> - let g:Align_xstrlen= 1 (default) -< - Number of spacing codepoints (Latin a + combining circumflex is one~ - spacing codepoint; a hard tab is one; wide and narrow CJK are one~ - each; etc.)~ -> - let g:Align_xstrlen= 2 -< - Virtual length (counting, for instance, tabs as anything between 1 and~ - 'tabstop', wide CJK as 2 rather than 1, Arabic alif as zero when~ - immediately preceded by lam, one otherwise, etc.)~ -> - let g:Align_xstrlen= 3 -< - By putting one of these settings into your <.vimrc>, Align will use an - internal (interpreted) function to determine a string's length instead - of the Vim's built-in |strlen()| function. Since the function is - interpreted, Align will run a bit slower but will handle such strings - correctly. The last setting (g:Align_xstrlen= 3) probably will run - the slowest but be the most accurate. (thanks to Tony Mechelynck for - these) - - -ALIGNMENT CONTROL *alignctrl* *align-control* {{{2 - - This command doesn't do the alignment operation itself; instead, it - controls subsequent alignment operation(s). - - The first argument to AlignCtrl is a string which may contain one or - more alignment control settings. Most of the settings are specified - by single letters; the exceptions are the p# and P# commands which - interpret a digit following the p or P as specifying padding about the - separator. - - The typical text line is considered to be composed of two or more - fields separated by one or more separator pattern(s): > - - ws field ws separator ws field ws separator ... -< - where "ws" stands for "white space" such as blanks and/or tabs. - - - SEPARATORS *alignctrl-separators* {{{3 - - As a result, separators may not have white space (tabs or blanks) on - their outsides (ie. ": :" is fine as a separator, but " :: " is - not). Usually such separators are not needed, although a map has been - provided which works around this limitation and aligns on whitespace - (see |alignmap-tsp|). - - However, if you really need to have separators with leading or - trailing whitespace, consider handling them by performing a substitute - first (ie. s/ :: /@/g), do the alignment on the temporary pattern - (ie. @), and then perform a substitute to revert the separators back - to their desired condition (ie. s/@/ :: /g). - - The Align#Align() function will first convert tabs over the region into - spaces and then apply alignment control. Except for initial white - space, white space surrounding the fields is ignored. One has three - options just for handling initial white space: - - - --- *alignctrl-w* - wWI INITIAL WHITE SPACE *alignctrl-W* {{{3 - --- *alignctrl-I* - w : ignore all selected lines' initial white space - W : retain all selected lines' initial white space - I : retain only the first line's initial white space and - re-use it for subsequent lines - - Example: Leading white space options: > - +---------------+-------------------+-----------------+ - |AlignCtrl w= :=| AlignCtrl W= := | AlignCtrl I= := | - +------------------+---------------+-------------------+-----------------+ - | Original | w option | W option | I option | - +------------------+---------------+-------------------+-----------------+ - | a := baaa |a := baaa | a : = baaa | a := baaa | - | caaaa := deeee |caaaa := deeee | caaaa : = deeee| caaaa := deeee| - | ee := f |ee := f | ee : = f | ee := f | - +------------------+---------------+-------------------+-----------------+ -< - The original has at least one leading white space on every line. - Using Align with w eliminated each line's leading white space. - Using Align with W preserved each line's leading white space. - Using Align with I applied the first line's leading white space - (three spaces) to each line. - - - ------ *alignctrl-l* - lrc-+: FIELD JUSTIFICATION *alignctrl-r* {{{3 - ------ *alignctrl-c* - - With "lrc", the fields will be left-justified, right-justified, or - centered as indicated by the justification specifiers (lrc). The - "lrc" options are re-used by cycling through them as needed: - - l means llllll.... - r means rrrrrr.... - lr means lrlrlr.... - llr means llrllr.... - - Example: Justification options: Align = > - +------------+-------------------+-------------------+-------------------+ - | Original | AlignCtrl l | AlignCtrl r | AlignCtrl lr | - +------------+-------------------+-------------------+-------------------+ - | a=bb=ccc=1 |a = bb = ccc = 1| a = bb = ccc = 1|a = bb = ccc = 1| - | ccc=a=bb=2 |ccc = a = bb = 2|ccc = a = bb = 2|ccc = a = bb = 2| - | dd=eee=f=3 |dd = eee = f = 3| dd = eee = f = 3|dd = eee = f = 3| - +------------+-------------------+-------------------+-------------------+ - | Alignment |l l l l| r r r r|l r l r| - +------------+-------------------+-------------------+-------------------+ -< - AlignCtrl l : The = separator is repeatedly re-used, as the - cycle only consists of one character (the "l"). - Every time left-justification is used for fields. - AlignCtrl r : The = separator is repeatedly re-used, as the - cycle only consists of one character (the "l"). - Every time right-justification is used for fields - AlignCtrl lr: Again, the "=" separator is repeatedly re-used, - but the fields are justified alternately between - left and right. - - Even more separator control is available. With "-+:": - - - : skip treating the separator as a separator. *alignctrl--* - + : repeat use of the last "lrc" justification *alignctrl-+* - : : treat the rest of the line as a single field *alignctrl-:* - - Example: More justification options: Align = > - +------------+---------------+--------------------+---------------+ - | Original | AlignCtrl -l | AlignCtrl rl+ | AlignCtrl l: | - +------------+---------------+--------------------+---------------+ - | a=bb=ccc=1 |a=bb = ccc=1 | a = bb = ccc = 1 |a = bb=ccc=1 | - | ccc=a=bb=2 |ccc=a = bb=2 |ccc = a = bb = 2 |ccc = a=bb=2 | - | dd=eee=f=3 |dd=eee = f=3 | dd = eee = f = 3 |dd = eee=f=3 | - +------------+---------------+--------------------+---------------+ - | Alignment |l l | r l l l |l l | - +------------+---------------+--------------------+---------------+ -< - In the first example in "More justification options": - - The first "=" separator is skipped by the "-" specification, - and so "a=bb", "ccc=a", and "dd=eee" are considered as single fields. - - The next "=" separator has its (left side) field left-justified. - Due to the cyclic nature of separator patterns, the "-l" - specification is equivalent to "-l-l-l ...". - - Hence the next specification is a "skip", so "ccc=1", etc are fields. - - In the second example in "More justification options": - - The first field is right-justified, the second field is left - justified, and all remaining fields repeat the last justification - command (ie. they are left justified, too). - - Hence rl+ is equivalent to rlllllllll ... - (whereas plain rl is equivalent to rlrlrlrlrl ... ). - - In the third example in "More justification options": - - The text following the first separator is treated as a single field. - - Thus using the - and : operators one can apply justification to a - single separator. - - ex. 1st separator only: AlignCtrl l: - 2nd separator only: AlignCtrl -l: - 3rd separator only: AlignCtrl --l: - etc. - - - --- *alignctrl-=* - =C CYCLIC VS ALL-ACTIVE SEPARATORS *alignctrl-C* {{{3 - --- - - The separators themselves may be considered as equivalent and - simultaneously active ("=") or sequentially cycled through ("C"). - Separators are regular expressions (|regexp|) and are specified as the - second, third, etc arguments. When the separator patterns are - equivalent and simultaneously active, there will be one pattern - constructed: > - - AlignCtrl ... pat1 pat2 pat3 - \(pat1\|pat2\|pat3\) -< - Each separator pattern is thus equivalent and simultaneously active. - The cyclic separator AlignCtrl option stores a list of patterns, only - one of which is active for each field at a time. - - Example: Equivalent/Simultaneously-Active vs Cyclic Separators > - +-------------+------------------+---------------------+----------------------+ - | Original | AlignCtrl = = + -| AlignCtrl = = | AlignCtrl C = + - | - +-------------+------------------+---------------------+----------------------+ - |a = b + c - d|a = b + c - d |a = b + c - d |a = b + c - d | - |x = y = z + 2|x = y = z + 2 |x = y = z + 2|x = y = z + 2 | - |w = s - t = 0|w = s - t = 0 |w = s - t = 0 |w = s - t = 0 | - +-------------+------------------+---------------------+----------------------+ -< - The original is initially aligned with all operators (=+-) being - considered as equivalent and simultaneously active field separators. - Thus the "AlignCtrl = = + -" example shows no change. - - The second example only accepts the '=' as a field separator; - consequently "b + c - d" is now a single field. - - The third example illustrates cyclic field separators and is analyzed - in the following illustration: > - - field1 separator field2 separator field3 separator field4 - a = b + c - d - x = y = z + 2 - w = s - t = 0 -< - The word "cyclic" is used because the patterns form a cycle of use; in - the above case, its = + - = + - = + - = + -... - - Example: Cyclic separators > - Label : this is some text discussing ":"s | ex. abc:def:ghi - Label : this is some text with a ":" in it | ex. abc:def -< - apply AlignCtrl lWC : | | - (select lines)Align > - Label : this is some text discussing ":"s | ex. abc:def:ghi - Label : this is some text with a ":" in it | ex. abcd:efg -< - In the current example, - : is the first separator So the first ":"s are aligned - | is the second separator but subsequent ":"s are not. - | is the third separator The "|"s are aligned, too. - : is the fourth separator Since there aren't two bars, - | is the fifth separator the subsequent potential cycles - | is the sixth separator don't appear. - ... - - In this case it would probably have been a better idea to have used > - AlignCtrl WCl: : | -< as that alignment control would guarantee that no more cycling - would be used after the vertical bar. - - Example: Cyclic separators - - Original: > - a| b&c | (d|e) & f-g-h - aa| bb&cc | (dd|ee) & ff-gg-hh - aaa| bbb&ccc | (ddd|eee) & fff-ggg-hhh -< - AlignCtrl C | | & - > - a | b&c | (d|e) & f - g-h - aa | bb&cc | (dd|ee) & ff - gg-hh - aaa | bbb&ccc | (ddd|eee) & fff - ggg-hhh -< - In this example, - the first and second separators are "|", - the third separator is "&", and - the fourth separator is "-", - - (cycling) - the fifth and sixth separators are "|", - the seventh separator is "&", and - the eighth separator is "-", etc. - - Thus the first "&"s are (not yet) separators, and hence are treated as - part of the field. Ignoring white space for the moment, the AlignCtrl - shown here means that Align will work with > - - field | field | field & field - field | field | field & field - ... -< - - --- *alignctrl-<* - <>| SEPARATOR JUSTIFICATION *alignctrl->* {{{3 - --- *alignctrl-|* - - Separators may be of differing lengths as shown in the example below. - Hence they too may be justified left, right, or centered. - Furthermore, separator justification specifications are cyclic: - - < means <<<<<... justify separator(s) to the left - > means >>>>>... justify separator(s) to the right - | means |||||... center separator(s) - - Example: Separator Justification: Align -\+ > - +-----------------+ - | Original | - +-----------------+ - | a - bbb - c | - | aa -- bb -- ccc | - | aaa --- b --- cc| - +---------------------+-+-----------------+-+---------------------+ - | AlignCtrl < | AlignCtrl > | AlignCtrl | | - +---------------------+---------------------+---------------------+ - | a - bbb - c | a - bbb - c | a - bbb - c | - | aa -- bb -- ccc | aa -- bb -- ccc | aa -- bb -- ccc | - | aaa --- b --- cc | aaa --- b --- cc | aaa --- b --- cc | - +---------------------+---------------------+---------------------+ -< - - --- *alignctrl-g* - gv SELECTIVE APPLICATION *alignctrl-v* {{{3 - --- - - - These two options provide a way to select (g) or to deselect (v) lines - based on a pattern. Ideally :g/pat/Align would work; unfortunately - it results in Align#Align() being called on each line satisfying the - pattern separately. > - - AlignCtrl g pattern -< - Align will only consider those lines which have the given pattern. > - - AlignCtrl v pattern -< - Align will only consider those lines without the given pattern. As an - example of use, consider the following example: > - - :AlignCtrl v ^\s*/\* - Original :Align = :Align = - +----------------+------------------+----------------+ - |one= 2; |one = 2; |one = 2; | - |three= 4; |three = 4; |three = 4; | - |/* skip=this */ |/* skip = this */ |/* skip=this */ | - |five= 6; |five = 6; |five = 6; | - +----------------+------------------+----------------+ -< - The first "Align =" aligned with all "="s, including that one in the - "skip=this" comment. - - The second "Align =" had a AlignCtrl v-pattern which caused it to skip - (ignore) the "skip=this" line when aligning. - - To remove AlignCtrl's g and v patterns, use (as appropriate) > - - AlignCtrl g - AlignCtrl v -< - To see what g/v patterns are currently active, just use the reporting - capability of an unadorned call to AlignCtrl: > - - AlignCtrl -< - - --- - m MAP SUPPORT *alignctrl-m* {{{3 - --- - - This option primarily supports the development of maps. The - Align#AlignCtrl() call will first do an Align#AlignPush() (ie. retain - current alignment control settings). The next Align#Align() will, in - addition to its alignment job, finish up with an Align#AlignPop(). - Thus the Align#AlignCtrl settings that follow the "m" are only - temporarily in effect for just the next Align#Align(). - - - --- - p### *alignctrl-p* - P### PADDING *alignctrl-P* {{{3 - --- - - These two options control pre-padding and post-padding with blanks - about the separator. One may pad separators with zero to nine spaces; - the padding number(s) is/are treated as a cyclic parameter. Thus one - may specify padding separately for each field or re-use a padding - pattern. > - - Example: AlignCtrl p102P0 - +---------+----------------------------------+ - | Original| a=b=c=d=e=f=g=h=1 | - | Align = | a =b=c =d =e=f =g =h=1 | - +---------+----------------------------------+ - | prepad | 1 0 2 1 0 2 1 0 | - +---------+----------------------------------+ -< - This example will cause Align to: - - pre-pad the first "=" with a single blank, - pre-pad the second "=" with no blanks, - pre-pad the third "=" with two blanks, - pre-pad the fourth "=" with a single blank, - pre-pad the fifth "=" with no blanks, - pre-pad the sixth "=" with two blanks, - etc. - - --------------- *alignctrl-settings* - No option given DISPLAY STATUS *alignctrl-* {{{3 - --------------- *alignctrl-no-option* - - AlignCtrl, when called with no arguments, will display the current - alignment control settings. A typical display is shown below: > - - AlignCtrl<=> qty=1 AlignStyle Padding<1|1> - Pat1<\(=\)> -< - Interpreting, this means that the separator patterns are all - equivalent; in this case, there's only one (qty=1). Fields will be - padded on the right with spaces (left justification), and separators - will be padded on each side with a single space. - - To change one of these items, see: - - AlignCtrl......|alignctrl| - qty............|align-concept| - AlignStyle.....|alignctrl--| |alignctrl-+| |alignctrl-:||alignctrl-c| - Padding........|alignctrl-p| |alignctrl-P| - - One may get a string which can be fed back into AlignCtrl: > - - :let alignctrl= Align#AlignCtrl() -< - This form will put a string describing the current AlignCtrl options, - except for the "g" and "v" patterns, into a variable. The - Align#AlignCtrl() function will still echo its settings, however. One - can feed any non-supported "option" to AlignCtrl() to prevent this, - however: > - - :let alignctrl= Align#AlignCtrl("d") -< - -ALIGNMENT *align-align* {{{2 - - Once the alignment control has been determined, the user specifies a - range of lines for the Align command/function to do its thing. - Alignment is often done on a line-range basis, but one may also - restrict alignment to a visual block using ctrl-v. For any visual - mode, one types the colon (:) and then "Align". One may, of course, - specify a range of lines: > - - :[range]Align [list-of-separators] -< - where the |:range| is the usual Vim-powered set of possibilities; the - list of separators is the same as the AlignCtrl capability. There is - only one list of separators, but either AlignCtrl or Align can be used - to specify that list. - - An alternative form of the Align command can handle both alignment - control and the separator list: > - - :[range]Align! [alignment-control-string] [list-of-separators] -< - The alignment control string will be applied only for this particular - application of Align (it uses |alignctrl-m|). The "g pattern" and - "v pattern" alignment controls (see |alignctrl-g| and |alignctrl-v|) - are also available via this form of the Align command. - - Align makes two passes over the text to be aligned. The first pass - determines how many fields there are and determines the maximum sizes - of each field; these sizes are then stored in a vector. The second - pass pads the field (left/right/centered as specified) to bring its - length up to the maximum size of the field. Then the separator and - its AlignCtrl-specified padding is appended. - - Pseudo-Code:~ - During pass 1 - | For all fields in the current line - || Determine current separator - || Examine field specified by current separator - || Determine length of field and save if largest thus far - Initialize newline based on initial whitespace option (wWI) - During pass 2 - | For all fields in current line - || Determine current separator - || Extract field specified by current separator - || Prepend/append padding as specified by AlignCtrl - || (right/left/center)-justify to fit field into max-size field - || Append separator with AlignCtrl-specified separator padding - || Delete current line, install newly aligned line - - The g and v AlignCtrl patterns cause the passes not to consider lines - for alignment, either by requiring that the g-pattern be present or - that the v-pattern not be present. - - The whitespace on either side of a separator is ignored. - - -============================================================================== -4. Alignment Maps *alignmaps* *align-maps* {{{1 - - There are a number of maps using Align#AlignCtrl() and Align#Align() - in the file. This file may also be put into the - plugins subdirectory. Since AlignCtrl and Align supercede textab and - its file, the maps either have a leading "t" (for - "textab") or the more complicated ones an "a" (for "alignment") for - backwards compatibility. - - The maps are shown below with a leading backslash (\). Actually, the - construct is used (see |mapleader|), so the maps' leading - kick-off character is easily customized. - - Furthermore, all AlignMapsPlugin.vim maps use the construct (see - ||and |usr_41.txt|). Hence, if one wishes to override the - mapping entirely, one may do that, too. As an example: > - map ACOM AM_acom -< would have \ACOM do what \acom previously did (assuming that the - mapleader has been left at its default value of a backslash). - - \a, : useful for breaking up comma-separated - declarations prior to \adec |alignmap-a,| - \a( : aligns ( and , (useful for prototypes) *alignmap-a(* - \a? : aligns (...)? ...:... expressions on ? and : |alignmap-a?| - \a< : aligns << and >> for c++ |alignmap-a<| - \a= : aligns := assignments |alignmap-a=| - \abox : draw a C-style comment box around text lines |alignmap-abox| - \acom : useful for aligning comments |alignmap-acom| - \adcom: useful for aligning comments in declarations |alignmap-adcom| - \anum : useful for aligning numbers |alignmap-anum| - NOTE: For the visual-mode use of \anum, is needed! - See http://mysite.verizon.net/astronaut/vim/index.html#VIS - \aenum: align a European-style number |alignmap-anum| - \aunum: align a USA-style number |alignmap-anum| - \adec : useful for aligning declarations |alignmap-adec| - \adef : useful for aligning definitions |alignmap-adef| - \afnc : useful for aligning ansi-c style functions' - argument lists |alignmap-afnc| - \adcom: a variant of \acom, restricted to comment |alignmap-adcom| - containing lines only, but also only for - those which don't begin with a comment. - Good for certain declaration styles. - \aocom: a variant of \acom, restricted to comment |alignmap-aocom| - containing lines only - \tab : align a table based on tabs *alignmap-tab* - (converts to spaces) - \tml : useful for aligning the trailing backslashes |alignmap-tml| - used to continue lines (shell programming, etc) - \tsp : use Align to make a table separated by blanks |alignmap-tsp| - (left justified) - \ts, : like \t, but swaps whitespace on the right of *alignmap-ts,* - the commas to their left - \ts: : like \t: but swaps whitespace on the right of *alignmap-ts:* - the colons to their left - \ts< : like \t< but swaps whitespace on the right of *alignmap-ts<* - the less-than signs to their left - \ts= : like \t= but swaps whitespace on the right of *alignmap-ts=* - the equals signs to their left - \Tsp : use Align to make a table separated by blanks |alignmap-Tsp| - (right justified) - \tsq : use Align to make a table separated by blanks |alignmap-tsq| - (left justified) -- "strings" are not split up - \tt : useful for aligning LaTeX tabular tables |alignmap-tt| - \Htd : tabularizes html tables: |alignmap-Htd| - ...field... ...field... - - *alignmap-t|* *alignmap-t#* *alignmap-t,* *alignmap-t:* - *alignmap-t;* *alignmap-t<* *alignmap-t?* *alignmap-t~* - *alignmap-m=* - \tx : make a left-justified alignment on - character "x" where "x" is: ,:<=@|# |alignmap-t=| - \Tx : make a right-justified alignment on - character "x" where "x" is: ,:<=@# |alignmap-T=| - \m= : like \t= but aligns with %... style comments - - The leading backslash is actually (see |mapleader| for how to - customize the leader to be whatever you like). These maps use the - package and are defined in the file. - Although the maps use AlignCtrl options, they typically use the "m" - option which pushes the options (AlignPush). The associated Align - call which follows will then AlignPop the user's original options - back. - - ALIGNMENT MAP USE WITH MARK AND MOVE~ - In the examples below, one may select the text with a "ma" at the - first line, move to the last line, then execute the map. - - ALIGNMENT MAP USE WITH VISUAL MODE~ - Alternatively, one may select the text with the "V" visual mode - command. - - ALIGNMENT MAP USE WITH MENUS~ - One may use the mark-and-move style (ma, move, use the menu) or - the visual mode style (use the V visual mode, move, then select - the alignment map with menu selection). The alignment map menu - items are under DrChip.AlignMaps . - - One may even change the top level menu name to whatever is wished; by - default, its > - let g:DrChipTopLvlMenu= "DrChip." -< If you set the variable to the empty string (""), then no menu items - will be produced. Of course, one must have a vim with +menu, the gui - must be running, and |'go'| must have the menu bar suboption (ie. m - must be included). - - COMPLEX ALIGNMENT MAP METHOD~ - - For those complex alignment maps which do alignment on constructs - (e.g. \acom, \adec, etc), a series of substitutes is used to insert - "@" symbols in appropriate locations. Align#Align() is then used to - do alignment directly on "@"s; then it is followed by further - substitutes to do clean-up. However, the maps \WS and \WE, used by - every map supported by AlignMaps, protect any original embedded "@" - symbols by first converting them to characters, doing the - requested job, and then converting them back. > - - \WS calls AlignMaps#WrapperStart() - \WE calls AlignMaps#WrapperEnd() -< - - --------------------------- - Alignment Map Examples: \a, *alignmap-a,* {{{3 - --------------------------- - - Original: illustrates comma-separated declaration splitting: > - int a,b,c; - struct ABC_str abc,def; -< - Becomes: > - int a; - int b; - int c; - struct ABC_str abc; - struct ABC_str def; -< - - --------------------------- - Alignment Map Examples: \a? *alignmap-a?* {{{3 - --------------------------- - - Original: illustrates ()?: aligning > - printf("<%s>\n", - (x == ABC)? "abc" : - (x == DEFG)? "defg" : - (x == HIJKL)? "hijkl" : "???"); -< - Becomes: select "(x == ..." lines, then \a? > - printf("<%s>\n", - (x == ABC)? "abc" : - (x == DEFG)? "defg" : - (x == HIJKL)? "hijkl" : "???"); -< - - --------------------------- - Alignment Map Examples: \a< *alignmap-a<* {{{3 - --------------------------- - - Original: illustrating aligning of << and >> > - cin << x; - cin << y; - cout << "this is x=" << x; - cout << "but y=" << y << "is not"; -< - Becomes: select "(x == ..." lines, then \a< > - cin << x; - cin << y; - cout << "this is x=" << x; - cout << "but y=" << y << "is not"; -< - - --------------------------- - Alignment Map Examples: \a= *alignmap-a=* {{{3 - --------------------------- - - Original: illustrates how to align := assignments > - aa:=bb:=cc:=1; - a:=b:=c:=1; - aaa:=bbb:=ccc:=1; -< - Bcomes: select the three assignment lines, then \a:= > - aa := bb := cc := 1; - a := b := c := 1; - aaa := bbb := ccc := 1; -< - - --------------------------- - Alignment Map Examples: \abox *alignmap-abox* {{{3 - --------------------------- - - Original: illustrates how to comment-box some text > - This is some plain text - which will - soon be surrounded by a - comment box. -< - Becomes: Select "This..box." with ctrl-v, press \abox > - /*************************** - * This is some plain text * - * which will * - * soon be surrounded by a * - * comment box. * - ***************************/ -< - - --------------------------- - Alignment Map Examples: \acom *alignmap-acom* {{{3 - --------------------------- - - Original: illustrates aligning C-style comments (works for //, too) > - if(itworks) { /* this */ - then= dothis; /* is a */ - } /* set of three comments */ -< - Becomes: Select the three lines, press \acom > - if(itworks) { /* this */ - then= dothis; /* is a */ - } /* set of three comments */ -< - Also see |alignmap-aocom| - - - --------------------------- - Alignment Map Examples: \anum *alignmap-anum* {{{3 - --------------------------- - - Original: illustrates how to get numbers lined up > - -1.234 .5678 -.901e-4 - 1.234 5.678 9.01e-4 - 12.34 56.78 90.1e-4 - 123.4 567.8 901.e-4 -< - Becomes: Go to first line, ma. Go to last line, press \anum > - -1.234 .5678 -.901e-4 - 1.234 5.678 9.01e-4 - 12.34 56.78 90.1e-4 - 123.4 567.8 901.e-4 -< - Original: > - | -1.234 .5678 -.901e-4 | - | 1.234 5.678 9.01e-4 | - | 12.34 56.78 90.1e-4 | - | 123.4 567.8 901.e-4 | -< - Becomes: Select the numbers with ctrl-v (visual-block mode), > - press \anum - | -1.234 .5678 -.901e-4 | - | 1.234 5.678 9.01e-4 | - | 12.34 56.78 90.1e-4 | - | 123.4 567.8 901.e-4 | -< - Original: > - -1,234 ,5678 -,901e-4 - 1,234 5,678 9,01e-4 - 12,34 56,78 90,1e-4 - 123,4 567,8 901,e-4 -< - Becomes: Go to first line, ma. Go to last line, press \anum > - -1,234 ,5678 -,901e-4 - 1,234 5,678 9,01e-4 - 12,34 56,78 90,1e-4 - 123,4 567,8 901,e-4 -< - In addition: - \aenum is provided to support European-style numbers - \aunum is provided to support USA-style numbers - - One may get \aenum behavior for \anum > - let g:alignmaps_euronumber= 1 -< or \aunum behavior for \anum if one puts > - let g:alignmaps_usanumber= 1 -< in one's <.vimrc>. - - - --------------------------- - Alignment Map Examples: \ascom *alignmap-ascom* {{{3 - --------------------------- - - Original: > - /* A Title */ - int x; /* this is a comment */ - int yzw; /* this is another comment*/ -< - Becomes: Select the three lines, press \ascom > - /* A Title */ - int x; /* this is a comment */ - int yzw; /* this is another comment */ -< - - --------------------------- - Alignment Map Examples: \adec *alignmap-adec* {{{3 - --------------------------- - - Original: illustrates how to clean up C/C++ declarations > - int a; - float b; - double *c=NULL; - char x[5]; - struct abc_str abc; - struct abc_str *pabc; - int a; /* a */ - float b; /* b */ - double *c=NULL; /* b */ - char x[5]; /* x[5] */ - struct abc_str abc; /* abc */ - struct abc_str *pabc; /* pabc */ - static int a; /* a */ - static float b; /* b */ - static double *c=NULL; /* b */ - static char x[5]; /* x[5] */ - static struct abc_str abc; /* abc */ - static struct abc_str *pabc; /* pabc */ -< - Becomes: Select the declarations text, then \adec > - int a; - float b; - double *c = NULL; - char x[5]; - struct abc_str abc; - struct abc_str *pabc; - int a; /* a */ - float b; /* b */ - double *c = NULL; /* b */ - char x[5]; /* x[5] */ - struct abc_str abc; /* abc */ - struct abc_str *pabc; /* pabc */ - static int a; /* a */ - static float b; /* b */ - static double *c = NULL; /* b */ - static char x[5]; /* x[5] */ - static struct abc_str abc; /* abc */ - static struct abc_str *pabc; /* pabc */ -< - - --------------------------- - Alignment Map Examples: \adef *alignmap-adef* {{{3 - --------------------------- - - Original: illustrates how to line up #def'initions > - #define ONE 1 - #define TWO 22 - #define THREE 333 - #define FOUR 4444 -< - Becomes: Select four definition lines, apply \adef > - # define ONE 1 - # define TWO 22 - # define THREE 333 - # define FOUR 4444 -< - - --------------------------- - Alignment Map Examples: \afnc *alignmap-afnc* {{{3 - --------------------------- - - This map is an exception to the usual selection rules. - It uses "]]" to find the function body's leading "{". - Just put the cursor anywhere in the function arguments and - the entire function declaration should be processed. - - Because "]]" looks for that "{" in the first column, the - "original" and "becomes" examples are in the first column, - too. - - Original: illustrates lining up ansi-c style function definitions > - int f( - struct abc_str ***a, /* one */ - long *b, /* two */ - int c) /* three */ - { - } -< - Becomes: put cursor anywhere before the '{', press \afnc > - int f( - struct abc_str ***a, /* one */ - long *b, /* two */ - int c) /* three */ - { - } -< - - --------------------------- - Alignment Map Examples: \adcom *alignmap-adcom* {{{3 - --------------------------- - - Original: illustrates aligning comments that don't begin - lines (optionally after some whitespace). > - struct { - /* this is a test */ - int x; /* of how */ - double y; /* to use adcom */ - }; -< - Becomes: Select the inside lines of the structure, - then press \adcom. The comment-only - line is ignored but the other two comments - get aligned. > - struct { - /* this is a test */ - int x; /* of how */ - double y; /* to use adcom */ - }; -< - - --------------------------- - Alignment Map Examples: \aocom *alignmap-aocom* {{{3 - --------------------------- - - Original: illustrates how to align C-style comments (works for //, too) - but restricted only to aligning with those lines containing - comments. See the difference from \acom (|alignmap-acom|). > - if(itworks) { /* this comment */ - then= dothis; - } /* only appears on two lines */ -< - Becomes: Select the three lines, press \aocom > - if(itworks) { /* this comment */ - then= dothis; - } /* only appears on two lines */ -< - Also see |alignmap-acom| - - - --------------------------- *alignmap-Tsp* - Alignment Map Examples: \tsp *alignmap-tsp* {{{3 - --------------------------- - - Normally Align can't use white spaces for field separators as such - characters are ignored surrounding field separators. The \tsp and - \Tsp maps get around this limitation. - - Original: > - one two three four five - six seven eight nine ten - eleven twelve thirteen fourteen fifteen -< - Becomes: Select the lines, \tsp > - one two three four five - six seven eight nine ten - eleven twelve thirteen fourteen fifteen -< - Becomes: Select the lines, \Tsp > - one two three four five - six seven eight nine ten - eleven twelve thirteen fourteen fifteen -< - - --------------------------- - Alignment Map Examples: \tsq *alignmap-tsq* {{{3 - --------------------------- - - The \tsp map is useful for aligning tables based on white space, - but sometimes one wants double-quoted strings to act as a single - object in spite of embedded spaces. The \tsq map was invented - to support this. (thanks to Leif Wickland) - - Original: > - "one two" three - four "five six" -< - Becomes: Select the lines, \tsq > - "one two" three - four "five six" -< - - --------------------------- - Alignment Map Examples: \tt *alignmap-tt* {{{3 - --------------------------- - - Original: illustrates aligning a LaTex Table > - \begin{tabular}{||c|l|r||} - \hline\hline - one&two&three\\ \hline - four&five&six\\ - seven&eight&nine\\ - \hline\hline - \end{tabular} -< - Becomes: Select the three lines inside the table > - (ie. one..,four..,seven..) and press \tt - \begin{tabular}{||c|l|r||} - \hline\hline - one & two & three \\ \hline - four & five & six \\ - seven & eight & nine \\ - \hline\hline - \end{tabular} -< - - ---------------------------- - Alignment Map Examples: \tml *alignmap-tml* {{{3 - ---------------------------- - - Original: illustrates aligning multi-line continuation marks > - one \ - two three \ - four five six \ - seven \\ \ - eight \nine \ - ten \ -< - Becomes: > - one \ - two three \ - four five six \ - seven \\ \ - eight \nine \ - ten \ -< - - --------------------------- - Alignment Map Examples: \t= *alignmap-t=* {{{3 - --------------------------- - - Original: illustrates left-justified aligning of = > - aa=bb=cc=1;/*one*/ - a=b=c=1;/*two*/ - aaa=bbb=ccc=1;/*three*/ -< - Becomes: Select the three equations, press \t= > - aa = bb = cc = 1; /* one */ - a = b = c = 1; /* two */ - aaa = bbb = ccc = 1; /* three */ -< - - --------------------------- - Alignment Map Examples: \T= *alignmap-T=* {{{3 - --------------------------- - - Original: illustrates right-justified aligning of = > - aa=bb=cc=1; /* one */ - a=b=c=1; /* two */ - aaa=bbb=ccc=1; /* three */ -< - Becomes: Select the three equations, press \T= > - aa = bb = cc = 1; /* one */ - a = b = c = 1; /* two */ - aaa = bbb = ccc = 1; /* three */ -< - - --------------------------- - Alignment Map Examples: \Htd *alignmap-Htd* {{{3 - --------------------------- - - Original: for aligning tables with html > - ...field one......field two... - ...field three......field four... -< - Becomes: Select ... lines, press \Htd > - ...field one... ...field two... - ...field three... ...field four... -< -============================================================================== -4. Alignment Tools' History *align-history* {{{1 - -ALIGN HISTORY {{{2 - 35 : Nov 02, 2008 * g:loaded_AlignPlugin testing to prevent re-loading - installed - Nov 19, 2008 * new sanity check for an AlignStyle of just ":" - Jan 08, 2009 * save&restore of |'mod'| now done with local - variant - 34 : Jul 08, 2008 * using :AlignCtrl before entering any alignment - control commands was causing an error. - 33 : Sep 20, 2007 * s:Strlen() introduced to support various ways - used to represent characters and their effects - on string lengths. See |align-strlen|. - * Align now accepts "..." -- so it can accept - whitespace as separators. - 32 : Aug 18, 2007 * uses || instead of || plus a - custom argument splitter to allow patterns with - backslashes to slide in unaltered. - 31 : Aug 06, 2007 * :[range]Align! [AlignCtrl settings] pattern(s) - implemented. - 30 : Feb 12, 2007 * now uses |setline()| - 29 : Jan 18, 2006 * cecutil updated to use keepjumps - Feb 23, 2006 * Align now converted to vim 7.0 style using - auto-loading functions. - 28 : Aug 17, 2005 * report option workaround - Oct 24, 2005 * AlignCtrl l: wasn't behaving as expected; fixed - 27 : Apr 15, 2005 : cpo workaround - ignorecase workaround - 26 : Aug 20, 2004 : loaded_align now also indicates version number - GetLatestVimScripts :AutoInstall: now supported - 25 : Jul 27, 2004 : For debugging, uses Dfunc(), Dret(), and Decho() - 24 : Mar 03, 2004 : (should've done this earlier!) visualmode(1) - not supported until v6.2, now Align will avoid - calling it for earlier versions. Visualmode - clearing won't take place then, of course. - 23 : Oct 07, 2003 : Included Leif Wickland's ReplaceQuotedSpaces() - function which supports \tsq - 22 : Jan 29, 2003 : Now requires 6.1.308 or later to clear visualmode() - 21 : Jan 10, 2003 : BugFix: similar problem to #19; new code - bypasses "norm! v\" until initialization - is over. - 20 : Dec 30, 2002 : BugFix: more on "unable to highlight" fixed - 19 : Nov 21, 2002 : BugFix: some terminals gave an "unable to highlight" - message at startup; Hari Krishna Dara tracked it - down; a silent! now included to prevent noise. - 18 : Nov 04, 2002 : BugFix: re-enabled anti-repeated-loading - 17 : Nov 04, 2002 : BugFix: forgot to have AlignPush() push s:AlignSep - AlignCtrl now clears visual-block mode when used so - that Align won't try to use old visual-block - selection marks '< '> - 16 : Sep 18, 2002 : AlignCtrl <>| options implemented (separator - justification) - 15 : Aug 22, 2002 : bug fix: AlignCtrl's ":" now acts as a modifier of - the preceding alignment operator (lrc) - 14 : Aug 20, 2002 : bug fix: AlignCtrl default now keeps &ic unchanged - bug fix: Align, on end-field, wasn't using correct - alignop bug fix: Align, on end-field, was appending - padding - 13 : Aug 19, 2002 : bug fix: zero-length g/v patterns are accepted - bug fix: always skip blank lines - bug fix: AlignCtrl default now also clears g and v - patterns - 12 : Aug 16, 2002 : moved keep_ic above zero-length pattern checks - added "AlignCtrl default" - fixed bug with last field getting separator spaces - at end line - 11 : Jul 08, 2002 : prevent separator patterns which match zero length - -+: included as additional alignment/justification - styles - 10 : Jun 26, 2002 : =~# used instead of =~ (for matching case) - ignorecase option handled - 9 : Jun 25, 2002 : implemented cyclic padding - -ALIGNMENT MAP HISTORY *alignmap-history* {{{2 - v41 Nov 02, 2008 * g:loaded_AlignMapsPlugin testing to prevent - re-loading installed - * AlignMaps now use 0x0f (ctrl-p) for special - character substitutions (instead of 0xff). - Seems to avoid some problems with having to - use Strlen(). - * bug fixed with \ts, - * new maps: \ts; \ts, \ts: \ts< \ts= \a( - v40 Oct 21, 2008 * Modified AlignMaps so that its maps use s - and