A whole bunch of new additions to the submodules

4 files changed, 0 insertions, 2325 deletions

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<endline and begcol<endcol.
-  " Ragged right: check if the column associated with '< or '>
-  "               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 == "\<c-v>"
-	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       = '\\\@<!"'
-
-"  "call Decho("in replace spaces.  line=" . line('.'))
-  while (1)
-    let l:startQuotePos = match(l:line, l:quoteRe, l:startingPos)
-    if (l:startQuotePos < 0) 
-"      "call Decho("No more quotes to the end of line")
-      break
-    endif
-    let l:endQuotePos = match(l:line, l:quoteRe, l:startQuotePos + 1)
-    if (l:endQuotePos < 0)
-"      "call Decho("Mismatched quotes")
-      break
-    endif
-    let l:spaceReplaceRe = '^.\{' . (l:startQuotePos + 1) . '}.\{-}\zs\s\ze.*.\{' . (linelen - l:endQuotePos) . '}$'
-"    "call Decho('spaceReplaceRe="' . l:spaceReplaceRe . '"')
-    let l:newStr = substitute(l:line, l:spaceReplaceRe, '%', '')
-    while (l:newStr != l:line)
-"      "call Decho('newstr="' . l:newStr . '"')
-      let l:line = l:newStr
-      let l:newStr = substitute(l:line, l:spaceReplaceRe, '%', '')
-    endwhile
-    let l:startingPos = l:endQuotePos + 1
-  endwhile
-  call setline(line('.'), l:line)
-
-"  call Dret("AlignReplaceQuotedSpaces")
-endfun
-
-" ---------------------------------------------------------------------
-" s:QArgSplitter: to avoid \ processing by <f-args>, <q-args> is needed. {{{1
-" However, <q-args> 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\<esc>"
-   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! '<ma'>
-  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/==/\="\<Char-0x0f>\<Char-0x0f>"/ge
-  'a,'zs/\([!<>:]\)=/\=submatch(1)."\<Char-0x0f>"/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\<right>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\<CR>\<Esc>"
-   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\<cr>"
-  if swwline > 0
-   let savedposn= savedposn.":silent norm! ".swwline."\<c-y>\<cr>:silent norm! zs\<cr>"
-  endif
-  let savedposn= savedposn.":silent call cursor(".swline.",".swcol.")\<cr>"
-
-  if a:savewinhoriz
-   if swwcol > 0
-    let savedposn= savedposn.":silent norm! ".swwcol."zl\<cr>"
-   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."\<cr>"
-   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. <israelchauca@gmail.com>
-" 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 = "\<CR>" . getline(line('.') + 1)[0] . "\<Del>"
-		let b:_l_delimitMate_buffer = []
-		return "\<CR>" . getline(line('.') + 1)[0] . "\<Del>"
-	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 .= "\<Right>"
-			let found = 1
-		elseif found == 0
-			let rights .= "\<Right>"
-		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 "\<CR>"
-	endif
-	if delimitMate#WithinEmptyPair()
-		" Expand:
-		call delimitMate#FlushBuffer()
-		"return "\<Esc>a\<CR>x\<CR>\<Esc>k$\"_xa"
-		return "\<CR>\<UP>\<Esc>o"
-	else
-		return "\<CR>"
-	endif
-endfunction "}}}
-
-function! delimitMate#ExpandSpace() "{{{
-	if delimitMate#IsForbidden("\<Space>")
-		return "\<Space>"
-	endif
-	if delimitMate#WithinEmptyPair()
-		" Expand:
-		call insert(b:_l_delimitMate_buffer, 's')
-		return delimitMate#WriteAfter(' ') . "\<Space>"
-	else
-		return "\<Space>"
-	endif
-endfunction "}}}
-
-function! delimitMate#BS() " {{{
-	if delimitMate#IsForbidden("")
-		return "\<BS>"
-	endif
-	if delimitMate#WithinEmptyPair()
-		"call delimitMate#RmBuffer(1)
-		return "\<BS>" . delimitMate#Del()
-"        return "\<Right>\<BS>\<BS>"
-	elseif delimitMate#IsSpaceExpansion()
-		"call delimitMate#RmBuffer(1)
-		return "\<BS>" . delimitMate#Del()
-	elseif delimitMate#IsCRExpansion()
-		return "\<BS>\<Del>"
-	else
-		return "\<BS>"
-	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 "\<Del>"
-	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 . "\<Left>"
-			let i += 1
-		endwhile
-		return substitute(buffer, "s", "\<Space>", '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 +
-				\ ['<BS>', '<S-BS>', '<Del>', '<S-Tab>', '<Esc>'] +
-				\ ['<Up>', '<Down>', '<Left>', '<Right>', '<LeftMouse>', '<RightMouse>'] +
-				\ ['<Home>', '<End>', '<PageUp>', '<PageDown>', '<S-Down>', '<S-Up>', '<C-G>g']
-	let imaps = imaps + ( b:_l_delimitMate_expand_cr ?  ['<CR>'] : [] )
-	let imaps = imaps + ( b:_l_delimitMate_expand_space ?  ['<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 = '<Bar>'
-			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\<C-D>Open: " . b:_l_delimitMate_left_delims[i]. "|"
-			exec "normal o0\<C-D>Delete: " . b:_l_delimitMate_left_delims[i] . "\<BS>|"
-			exec "normal o0\<C-D>Exit: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "|"
-			if b:_l_delimitMate_expand_space == 1
-				exec "normal o0\<C-D>Space: " . b:_l_delimitMate_left_delims[i] . " |"
-				exec "normal o0\<C-D>Delete space: " . b:_l_delimitMate_left_delims[i] . " \<BS>|"
-			endif
-			if b:_l_delimitMate_expand_cr == 1
-				exec "normal o0\<C-D>Car return: " . b:_l_delimitMate_left_delims[i] . "\<CR>|"
-				exec "normal Go0\<C-D>Delete car return: " . b:_l_delimitMate_left_delims[i] . "\<CR>0\<C-D>\<BS>|"
-			endif
-			call append(line('$'), '')
-		endfor
-		for i in range(len(b:_l_delimitMate_quotes_list))
-			exec "normal Go0\<C-D>Open: " . b:_l_delimitMate_quotes_list[i]	. "|"
-			exec "normal o0\<C-D>Delete: " . b:_l_delimitMate_quotes_list[i] . "\<BS>|"
-			exec "normal o0\<C-D>Exit: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "|"
-			if b:_l_delimitMate_expand_space == 1
-				exec "normal o0\<C-D>Space: " . b:_l_delimitMate_quotes_list[i] . " |"
-				exec "normal o0\<C-D>Delete space: " . b:_l_delimitMate_quotes_list[i] . " \<BS>|"
-			endif
-			if b:_l_delimitMate_expand_cr == 1
-				exec "normal o0\<C-D>Car return: " . b:_l_delimitMate_quotes_list[i] . "\<CR>|"
-				exec "normal Go0\<C-D>Delete car return: " . b:_l_delimitMate_quotes_list[i] . "\<CR>\<BS>|"
-			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] . "\<BS>|"
-			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] . " \<BS>|"
-			endif
-			if b:_l_delimitMate_expand_cr == 1
-				exec "normal oCar return: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "\<CR>|"
-				exec "normal GoDelete car return: " . b:_l_delimitMate_left_delims[i] . b:_l_delimitMate_right_delims[i] . "\<CR>\<BS>|"
-			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] . "\<BS>|"
-			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] . " \<BS>|"
-			endif
-			if b:_l_delimitMate_expand_cr == 1
-				exec "normal oCar return: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "\<CR>|"
-				exec "normal GoDelete car return: " . b:_l_delimitMate_quotes_list[i] . b:_l_delimitMate_quotes_list[i] . "\<CR>\<BS>|"
-			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