remove unecessary vim plugins

2 files changed, 0 insertions, 1124 deletions

diff --git a/Editor/vim/plugin/cecutil.vim b/Editor/vim/plugin/cecutil.vim
deleted file mode 100644
index b720044..0000000
--- a/Editor/vim/plugin/cecutil.vim
+++ /dev/null
@@ -1,536 +0,0 @@
-" cecutil.vim : save/restore window position
-"               save/restore mark position
-"               save/restore selected user maps
-"  Author:	Charles E. Campbell
-"  Version:	18i	NOT RELEASED
-"  Date:	Oct 21, 2013
-"
-"  Saving Restoring Destroying Marks: {{{1
-"       call SaveMark(markname)       let savemark= SaveMark(markname)
-"       call RestoreMark(markname)    call RestoreMark(savemark)
-"       call DestroyMark(markname)
-"       commands: SM RM DM
-"
-"  Saving Restoring Destroying Window Position: {{{1
-"       call SaveWinPosn()        let winposn= SaveWinPosn()
-"       call RestoreWinPosn()     call RestoreWinPosn(winposn)
-"		\swp : save current window/buffer's position
-"		\rwp : restore current window/buffer's previous position
-"       commands: SWP RWP
-"
-"  Saving And Restoring User Maps: {{{1
-"       call SaveUserMaps(mapmode,maplead,mapchx,suffix)
-"       call RestoreUserMaps(suffix)
-"
-" GetLatestVimScripts: 1066 1 :AutoInstall: cecutil.vim
-"
-" You believe that God is one. You do well. The demons also {{{1
-" believe, and shudder. But do you want to know, vain man, that
-" faith apart from works is dead?  (James 2:19,20 WEB)
-"redraw!|call inputsave()|call input("Press <cr> to continue")|call inputrestore()
-
-" ---------------------------------------------------------------------
-" Load Once: {{{1
-if &cp || exists("g:loaded_cecutil")
- finish
-endif
-let g:loaded_cecutil = "v18h"
-let s:keepcpo        = &cpo
-set cpo&vim
-"DechoRemOn
-
-" =======================
-"  Public Interface: {{{1
-" =======================
-
-" ---------------------------------------------------------------------
-"  Map Interface: {{{2
-if !hasmapto('<Plug>SaveWinPosn')
- map <unique> <Leader>swp <Plug>SaveWinPosn
-endif
-if !hasmapto('<Plug>RestoreWinPosn')
- map <unique> <Leader>rwp <Plug>RestoreWinPosn
-endif
-nmap <silent> <Plug>SaveWinPosn		:call SaveWinPosn()<CR>
-nmap <silent> <Plug>RestoreWinPosn	:call RestoreWinPosn()<CR>
-
-" ---------------------------------------------------------------------
-" Command Interface: {{{2
-com! -bar -nargs=0 SWP	call SaveWinPosn()
-com! -bar -nargs=? RWP	call RestoreWinPosn(<args>)
-com! -bar -nargs=1 SM	call SaveMark(<q-args>)
-com! -bar -nargs=1 RM	call RestoreMark(<q-args>)
-com! -bar -nargs=1 DM	call DestroyMark(<q-args>)
-
-com! -bar -nargs=1 WLR	call s:WinLineRestore(<q-args>)
-
-if v:version < 630
- let s:modifier= "sil! "
-else
- let s:modifier= "sil! keepj "
-endif
-
-" ===============
-" Functions: {{{1
-" ===============
-
-" ---------------------------------------------------------------------
-" SaveWinPosn: {{{2
-"    let winposn= SaveWinPosn()  will save window position in winposn variable
-"    call SaveWinPosn()          will save window position in b:cecutil_winposn{b:cecutil_iwinposn}
-"    let winposn= SaveWinPosn(0) will *only* save window position in winposn variable (no stacking done)
-fun! SaveWinPosn(...)
-"  echomsg "Decho: SaveWinPosn() a:0=".a:0
-  if line("$") == 1 && getline(1) == ""
-"   echomsg "Decho: SaveWinPosn : empty buffer"
-   return ""
-  endif
-  let so_keep   = &l:so
-  let siso_keep = &siso
-  let ss_keep   = &l:ss
-  setlocal so=0 siso=0 ss=0
-
-  let swline = line(".")                           " save-window line in file
-  let swcol  = col(".")                            " save-window column in file
-  if swcol >= col("$")
-   let swcol= swcol + virtcol(".") - virtcol("$")  " adjust for virtual edit (cursor past end-of-line)
-  endif
-  let swwline   = winline() - 1                    " save-window window line
-  let swwcol    = virtcol(".") - wincol()          " save-window window column
-  let savedposn = ""
-"  echomsg "Decho: sw[".swline.",".swcol."] sww[".swwline.",".swwcol."]"
-  let savedposn = "call GoWinbufnr(".winbufnr(0).")"
-  let savedposn = savedposn."|".s:modifier.swline
-  let savedposn = savedposn."|".s:modifier."norm! 0z\<cr>"
-  if swwline > 0
-   let savedposn= savedposn.":".s:modifier."call s:WinLineRestore(".(swwline+1).")\<cr>"
-  endif
-  if swwcol > 0
-   let savedposn= savedposn.":".s:modifier."norm! 0".swwcol."zl\<cr>"
-  endif
-  let savedposn = savedposn.":".s:modifier."call cursor(".swline.",".swcol.")\<cr>"
-
-  " save window position in
-  " b:cecutil_winposn_{iwinposn} (stack)
-  " only when SaveWinPosn() is used
-  if a:0 == 0
-   if !exists("b:cecutil_iwinposn")
-	let b:cecutil_iwinposn= 1
-   else
-	let b:cecutil_iwinposn= b:cecutil_iwinposn + 1
-   endif
-"   echomsg "Decho: saving posn to SWP stack"
-   let b:cecutil_winposn{b:cecutil_iwinposn}= savedposn
-  endif
-
-  let &l:so = so_keep
-  let &siso = siso_keep
-  let &l:ss = ss_keep
-
-"  if exists("b:cecutil_iwinposn")                                                                  " Decho
-"   echomsg "Decho: b:cecutil_winpos{".b:cecutil_iwinposn."}[".b:cecutil_winposn{b:cecutil_iwinposn}."]"
-"  else                                                                                             " Decho
-"   echomsg "Decho: b:cecutil_iwinposn doesn't exist"
-"  endif                                                                                            " Decho
-"  echomsg "Decho: SaveWinPosn [".savedposn."]"
-  return savedposn
-endfun
-
-" ---------------------------------------------------------------------
-" RestoreWinPosn: {{{2
-"      call RestoreWinPosn()
-"      call RestoreWinPosn(winposn)
-fun! RestoreWinPosn(...)
-"  echomsg "Decho: RestoreWinPosn() a:0=".a:0
-"  echomsg "Decho: getline(1)<".getline(1).">"
-"  echomsg "Decho: line(.)=".line(".")
-  if line("$") == 1 && getline(1) == ""
-"   echomsg "Decho: RestoreWinPosn : empty buffer"
-   return ""
-  endif
-  let so_keep   = &l:so
-  let siso_keep = &l:siso
-  let ss_keep   = &l:ss
-  setlocal so=0 siso=0 ss=0
-
-  if a:0 == 0 || a:1 == ""
-   " use saved window position in b:cecutil_winposn{b:cecutil_iwinposn} if it exists
-   if exists("b:cecutil_iwinposn") && exists("b:cecutil_winposn{b:cecutil_iwinposn}")
-"    echomsg "Decho: using stack b:cecutil_winposn{".b:cecutil_iwinposn."}<".b:cecutil_winposn{b:cecutil_iwinposn}.">"
-	try
-	 exe s:modifier.b:cecutil_winposn{b:cecutil_iwinposn}
-	catch /^Vim\%((\a\+)\)\=:E749/
-	 " ignore empty buffer error messages
-	endtry
-	" normally drop top-of-stack by one
-	" but while new top-of-stack doesn't exist
-	" drop top-of-stack index by one again
-	if b:cecutil_iwinposn >= 1
-	 unlet b:cecutil_winposn{b:cecutil_iwinposn}
-	 let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
-	 while b:cecutil_iwinposn >= 1 && !exists("b:cecutil_winposn{b:cecutil_iwinposn}")
-	  let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
-	 endwhile
-	 if b:cecutil_iwinposn < 1
-	  unlet b:cecutil_iwinposn
-	 endif
-	endif
-   else
-	echohl WarningMsg
-	echomsg "***warning*** need to SaveWinPosn first!"
-	echohl None
-   endif
-
-  else	 " handle input argument
-"   echomsg "Decho: using input a:1<".a:1.">"
-   " use window position passed to this function
-   exe a:1
-   " remove a:1 pattern from b:cecutil_winposn{b:cecutil_iwinposn} stack
-   if exists("b:cecutil_iwinposn")
-	let jwinposn= b:cecutil_iwinposn
-	while jwinposn >= 1                     " search for a:1 in iwinposn..1
-	 if exists("b:cecutil_winposn{jwinposn}")    " if it exists
-	  if a:1 == b:cecutil_winposn{jwinposn}      " and the pattern matches
-	   unlet b:cecutil_winposn{jwinposn}            " unlet it
-	   if jwinposn == b:cecutil_iwinposn            " if at top-of-stack
-		let b:cecutil_iwinposn= b:cecutil_iwinposn - 1      " drop stacktop by one
-	   endif
-	  endif
-	 endif
-	 let jwinposn= jwinposn - 1
-	endwhile
-   endif
-  endif
-
-  " Seems to be something odd: vertical motions after RWP
-  " cause jump to first column.  The following fixes that.
-  " Note: was using wincol()>1, but with signs, a cursor
-  " at column 1 yields wincol()==3.  Beeping ensued.
-  let vekeep= &ve
-  set ve=all
-  if virtcol('.') > 1
-   exe s:modifier."norm! hl"
-  elseif virtcol(".") < virtcol("$")
-   exe s:modifier."norm! lh"
-  endif
-  let &ve= vekeep
-
-  let &l:so   = so_keep
-  let &l:siso = siso_keep
-  let &l:ss   = ss_keep
-
-"  echomsg "Decho: RestoreWinPosn"
-endfun
-
-" ---------------------------------------------------------------------
-" s:WinLineRestore: {{{2
-fun! s:WinLineRestore(swwline)
-"  echomsg "Decho: s:WinLineRestore(swwline=".a:swwline.")"
-  while winline() < a:swwline
-   let curwinline= winline()
-   exe s:modifier."norm! \<c-y>"
-   if curwinline == winline()
-	break
-   endif
-  endwhile
-"  echomsg "Decho: s:WinLineRestore"
-endfun
-
-" ---------------------------------------------------------------------
-" GoWinbufnr: go to window holding given buffer (by number) {{{2
-"   Prefers current window; if its buffer number doesn't match,
-"   then will try from topleft to bottom right
-fun! GoWinbufnr(bufnum)
-"  call Dfunc("GoWinbufnr(".a:bufnum.")")
-  if winbufnr(0) == a:bufnum
-"   call Dret("GoWinbufnr : winbufnr(0)==a:bufnum")
-   return
-  endif
-  winc t
-  let first=1
-  while winbufnr(0) != a:bufnum && (first || winnr() != 1)
-  	winc w
-	let first= 0
-   endwhile
-"  call Dret("GoWinbufnr")
-endfun
-
-" ---------------------------------------------------------------------
-" SaveMark: sets up a string saving a mark position. {{{2
-"           For example, SaveMark("a")
-"           Also sets up a global variable, g:savemark_{markname}
-fun! SaveMark(markname)
-"  call Dfunc("SaveMark(markname<".a:markname.">)")
-  let markname= a:markname
-  if strpart(markname,0,1) !~ '\a'
-   let markname= strpart(markname,1,1)
-  endif
-"  call Decho("markname=".markname)
-
-  let lzkeep  = &lz
-  set lz
-
-  if 1 <= line("'".markname) && line("'".markname) <= line("$")
-   let winposn               = SaveWinPosn(0)
-   exe s:modifier."norm! `".markname
-   let savemark              = SaveWinPosn(0)
-   let g:savemark_{markname} = savemark
-   let savemark              = markname.savemark
-   call RestoreWinPosn(winposn)
-  else
-   let g:savemark_{markname} = ""
-   let savemark              = ""
-  endif
-
-  let &lz= lzkeep
-
-"  call Dret("SaveMark : savemark<".savemark.">")
-  return savemark
-endfun
-
-" ---------------------------------------------------------------------
-" RestoreMark: {{{2
-"   call RestoreMark("a")  -or- call RestoreMark(savemark)
-fun! RestoreMark(markname)
-"  call Dfunc("RestoreMark(markname<".a:markname.">)")
-
-  if strlen(a:markname) <= 0
-"   call Dret("RestoreMark : no such mark")
-   return
-  endif
-  let markname= strpart(a:markname,0,1)
-  if markname !~ '\a'
-   " handles 'a -> a styles
-   let markname= strpart(a:markname,1,1)
-  endif
-"  call Decho("markname=".markname." strlen(a:markname)=".strlen(a:markname))
-
-  let lzkeep  = &lz
-  set lz
-  let winposn = SaveWinPosn(0)
-
-  if strlen(a:markname) <= 2
-   if exists("g:savemark_{markname}") && strlen(g:savemark_{markname}) != 0
-	" use global variable g:savemark_{markname}
-"	call Decho("use savemark list")
-	call RestoreWinPosn(g:savemark_{markname})
-	exe "norm! m".markname
-   endif
-  else
-   " markname is a savemark command (string)
-"	call Decho("use savemark command")
-   let markcmd= strpart(a:markname,1)
-   call RestoreWinPosn(markcmd)
-   exe "norm! m".markname
-  endif
-
-  call RestoreWinPosn(winposn)
-  let &lz       = lzkeep
-
-"  call Dret("RestoreMark")
-endfun
-
-" ---------------------------------------------------------------------
-" DestroyMark: {{{2
-"   call DestroyMark("a")  -- destroys mark
-fun! DestroyMark(markname)
-"  call Dfunc("DestroyMark(markname<".a:markname.">)")
-
-  " save options and set to standard values
-  let reportkeep= &report
-  let lzkeep    = &lz
-  set lz report=10000
-
-  let markname= strpart(a:markname,0,1)
-  if markname !~ '\a'
-   " handles 'a -> a styles
-   let markname= strpart(a:markname,1,1)
-  endif
-"  call Decho("markname=".markname)
-
-  let curmod  = &mod
-  let winposn = SaveWinPosn(0)
-  1
-  let lineone = getline(".")
-  exe "k".markname
-  d
-  put! =lineone
-  let &mod    = curmod
-  call RestoreWinPosn(winposn)
-
-  " restore options to user settings
-  let &report = reportkeep
-  let &lz     = lzkeep
-
-"  call Dret("DestroyMark")
-endfun
-
-" ---------------------------------------------------------------------
-" QArgSplitter: to avoid \ processing by <f-args>, <q-args> is needed. {{{2
-" However, <q-args> doesn't split at all, so this one returns a list
-" with splits at all whitespace (only!), plus a leading length-of-list.
-" The resulting list:  qarglist[0] corresponds to a:0
-"                      qarglist[i] corresponds to a:{i}
-fun! QArgSplitter(qarg)
-"  call Dfunc("QArgSplitter(qarg<".a:qarg.">)")
-  let qarglist    = split(a:qarg)
-  let qarglistlen = len(qarglist)
-  let qarglist    = insert(qarglist,qarglistlen)
-"  call Dret("QArgSplitter ".string(qarglist))
-  return qarglist
-endfun
-
-" ---------------------------------------------------------------------
-" ListWinPosn: {{{2
-"fun! ListWinPosn()                                                        " Decho 
-"  if !exists("b:cecutil_iwinposn") || b:cecutil_iwinposn == 0             " Decho 
-"   call Decho("nothing on SWP stack")                                     " Decho
-"  else                                                                    " Decho
-"   let jwinposn= b:cecutil_iwinposn                                       " Decho 
-"   while jwinposn >= 1                                                    " Decho 
-"    if exists("b:cecutil_winposn{jwinposn}")                              " Decho 
-"     call Decho("winposn{".jwinposn."}<".b:cecutil_winposn{jwinposn}.">") " Decho 
-"    else                                                                  " Decho 
-"     call Decho("winposn{".jwinposn."} -- doesn't exist")                 " Decho 
-"    endif                                                                 " Decho 
-"    let jwinposn= jwinposn - 1                                            " Decho 
-"   endwhile                                                               " Decho 
-"  endif                                                                   " Decho
-"endfun                                                                    " Decho 
-"com! -nargs=0 LWP	call ListWinPosn()                                    " Decho 
-
-" ---------------------------------------------------------------------
-" SaveUserMaps: this function sets up a script-variable (s:restoremap) {{{2
-"          which can be used to restore user maps later with
-"          call RestoreUserMaps()
-"
-"          mapmode - see :help maparg for details (n v o i c l "")
-"                    ex. "n" = Normal
-"                    The letters "b" and "u" are optional prefixes;
-"                    The "u" means that the map will also be unmapped
-"                    The "b" means that the map has a <buffer> qualifier
-"                    ex. "un"  = Normal + unmapping
-"                    ex. "bn"  = Normal + <buffer>
-"                    ex. "bun" = Normal + <buffer> + unmapping
-"                    ex. "ubn" = Normal + <buffer> + unmapping
-"          maplead - see mapchx
-"          mapchx  - "<something>" handled as a single map item.
-"                    ex. "<left>"
-"                  - "string" a string of single letters which are actually
-"                    multiple two-letter maps (using the maplead:
-"                    maplead . each_character_in_string)
-"                    ex. maplead="\" and mapchx="abc" saves user mappings for
-"                        \a, \b, and \c
-"                    Of course, if maplead is "", then for mapchx="abc",
-"                    mappings for a, b, and c are saved.
-"                  - :something  handled as a single map item, w/o the ":"
-"                    ex.  mapchx= ":abc" will save a mapping for "abc"
-"          suffix  - a string unique to your plugin
-"                    ex.  suffix= "DrawIt"
-fun! SaveUserMaps(mapmode,maplead,mapchx,suffix)
-"  call Dfunc("SaveUserMaps(mapmode<".a:mapmode."> maplead<".a:maplead."> mapchx<".a:mapchx."> suffix<".a:suffix.">)")
-
-  if !exists("s:restoremap_{a:suffix}")
-   " initialize restoremap_suffix to null string
-   let s:restoremap_{a:suffix}= ""
-  endif
-
-  " set up dounmap: if 1, then save and unmap  (a:mapmode leads with a "u")
-  "                 if 0, save only
-  let mapmode  = a:mapmode
-  let dounmap  = 0
-  let dobuffer = ""
-  while mapmode =~ '^[bu]'
-   if     mapmode =~ '^u'
-    let dounmap = 1
-    let mapmode = strpart(a:mapmode,1)
-   elseif mapmode =~ '^b'
-    let dobuffer = "<buffer> "
-    let mapmode  = strpart(a:mapmode,1)
-   endif
-  endwhile
-"  call Decho("dounmap=".dounmap."  dobuffer<".dobuffer.">")
- 
-  " save single map :...something...
-  if strpart(a:mapchx,0,1) == ':'
-"   call Decho("save single map :...something...")
-   let amap= strpart(a:mapchx,1)
-   if amap == "|" || amap == "\<c-v>"
-    let amap= "\<c-v>".amap
-   endif
-   let amap                    = a:maplead.amap
-   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:sil! ".mapmode."unmap ".dobuffer.amap
-   if maparg(amap,mapmode) != ""
-    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
-	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:".mapmode."map ".dobuffer.amap." ".maprhs
-   endif
-   if dounmap
-	exe "sil! ".mapmode."unmap ".dobuffer.amap
-   endif
- 
-  " save single map <something>
-  elseif strpart(a:mapchx,0,1) == '<'
-"   call Decho("save single map <something>")
-   let amap       = a:mapchx
-   if amap == "|" || amap == "\<c-v>"
-    let amap= "\<c-v>".amap
-"	call Decho("amap[[".amap."]]")
-   endif
-   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|sil! ".mapmode."unmap ".dobuffer.amap
-   if maparg(a:mapchx,mapmode) != ""
-    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
-	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
-   endif
-   if dounmap
-	exe "sil! ".mapmode."unmap ".dobuffer.amap
-   endif
- 
-  " save multiple maps
-  else
-"   call Decho("save multiple maps")
-   let i= 1
-   while i <= strlen(a:mapchx)
-    let amap= a:maplead.strpart(a:mapchx,i-1,1)
-	if amap == "|" || amap == "\<c-v>"
-	 let amap= "\<c-v>".amap
-	endif
-	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|sil! ".mapmode."unmap ".dobuffer.amap
-    if maparg(amap,mapmode) != ""
-     let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
-	 let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
-    endif
-	if dounmap
-	 exe "sil! ".mapmode."unmap ".dobuffer.amap
-	endif
-    let i= i + 1
-   endwhile
-  endif
-"  call Dret("SaveUserMaps : restoremap_".a:suffix.": ".s:restoremap_{a:suffix})
-endfun
-
-" ---------------------------------------------------------------------
-" RestoreUserMaps: {{{2
-"   Used to restore user maps saved by SaveUserMaps()
-fun! RestoreUserMaps(suffix)
-"  call Dfunc("RestoreUserMaps(suffix<".a:suffix.">)")
-  if exists("s:restoremap_{a:suffix}")
-   let s:restoremap_{a:suffix}= substitute(s:restoremap_{a:suffix},'|\s*$','','e')
-   if s:restoremap_{a:suffix} != ""
-"   	call Decho("exe ".s:restoremap_{a:suffix})
-    exe "sil! ".s:restoremap_{a:suffix}
-   endif
-   unlet s:restoremap_{a:suffix}
-  endif
-"  call Dret("RestoreUserMaps")
-endfun
-
-" ==============
-"  Restore: {{{1
-" ==============
-let &cpo= s:keepcpo
-unlet s:keepcpo
-
-" ================
-"  Modelines: {{{1
-" ================
-" vim: ts=4 fdm=marker
diff --git a/Editor/vim/plugin/surround.vim b/Editor/vim/plugin/surround.vim
deleted file mode 100644
index 05b1c5c..0000000
--- a/Editor/vim/plugin/surround.vim
+++ /dev/null
@@ -1,588 +0,0 @@
-" surround.vim - Surroundings
-" Author:       Tim Pope <http://tpo.pe/>
-" Version:      2.0
-" GetLatestVimScripts: 1697 1 :AutoInstall: surround.vim
-
-if exists("g:loaded_surround") || &cp || v:version < 700
-  finish
-endif
-let g:loaded_surround = 1
-
-" Input functions {{{1
-
-function! s:getchar()
-  let c = getchar()
-  if c =~ '^\d\+$'
-    let c = nr2char(c)
-  endif
-  return c
-endfunction
-
-function! s:inputtarget()
-  let c = s:getchar()
-  while c =~ '^\d\+$'
-    let c .= s:getchar()
-  endwhile
-  if c == " "
-    let c .= s:getchar()
-  endif
-  if c =~ "\<Esc>\|\<C-C>\|\0"
-    return ""
-  else
-    return c
-  endif
-endfunction
-
-function! s:inputreplacement()
-  let c = s:getchar()
-  if c == " "
-    let c .= s:getchar()
-  endif
-  if c =~ "\<Esc>" || c =~ "\<C-C>"
-    return ""
-  else
-    return c
-  endif
-endfunction
-
-function! s:beep()
-  exe "norm! \<Esc>"
-  return ""
-endfunction
-
-function! s:redraw()
-  redraw
-  return ""
-endfunction
-
-" }}}1
-
-" Wrapping functions {{{1
-
-function! s:extractbefore(str)
-  if a:str =~ '\r'
-    return matchstr(a:str,'.*\ze\r')
-  else
-    return matchstr(a:str,'.*\ze\n')
-  endif
-endfunction
-
-function! s:extractafter(str)
-  if a:str =~ '\r'
-    return matchstr(a:str,'\r\zs.*')
-  else
-    return matchstr(a:str,'\n\zs.*')
-  endif
-endfunction
-
-function! s:fixindent(str,spc)
-  let str = substitute(a:str,'\t',repeat(' ',&sw),'g')
-  let spc = substitute(a:spc,'\t',repeat(' ',&sw),'g')
-  let str = substitute(str,'\(\n\|\%^\).\@=','\1'.spc,'g')
-  if ! &et
-    let str = substitute(str,'\s\{'.&ts.'\}',"\t",'g')
-  endif
-  return str
-endfunction
-
-function! s:process(string)
-  let i = 0
-  for i in range(7)
-    let repl_{i} = ''
-    let m = matchstr(a:string,nr2char(i).'.\{-\}\ze'.nr2char(i))
-    if m != ''
-      let m = substitute(strpart(m,1),'\r.*','','')
-      let repl_{i} = input(substitute(m,':\s*$','','').': ')
-    endif
-  endfor
-  let s = ""
-  let i = 0
-  while i < strlen(a:string)
-    let char = strpart(a:string,i,1)
-    if char2nr(char) < 8
-      let next = stridx(a:string,char,i+1)
-      if next == -1
-        let s .= char
-      else
-        let insertion = repl_{char2nr(char)}
-        let subs = strpart(a:string,i+1,next-i-1)
-        let subs = matchstr(subs,'\r.*')
-        while subs =~ '^\r.*\r'
-          let sub = matchstr(subs,"^\r\\zs[^\r]*\r[^\r]*")
-          let subs = strpart(subs,strlen(sub)+1)
-          let r = stridx(sub,"\r")
-          let insertion = substitute(insertion,strpart(sub,0,r),strpart(sub,r+1),'')
-        endwhile
-        let s .= insertion
-        let i = next
-      endif
-    else
-      let s .= char
-    endif
-    let i += 1
-  endwhile
-  return s
-endfunction
-
-function! s:wrap(string,char,type,...)
-  let keeper = a:string
-  let newchar = a:char
-  let s:tag = ""
-  let type = a:type
-  let linemode = type ==# 'V' ? 1 : 0
-  let special = a:0 ? a:1 : 0
-  let before = ""
-  let after  = ""
-  if type ==# "V"
-    let initspaces = matchstr(keeper,'\%^\s*')
-  else
-    let initspaces = matchstr(getline('.'),'\%^\s*')
-  endif
-  let pairs = "b()B{}r[]a<>"
-  let extraspace = ""
-  if newchar =~ '^ '
-    let newchar = strpart(newchar,1)
-    let extraspace = ' '
-  endif
-  let idx = stridx(pairs,newchar)
-  if newchar == ' '
-    let before = ''
-    let after  = ''
-  elseif exists("b:surround_".char2nr(newchar))
-    let all    = s:process(b:surround_{char2nr(newchar)})
-    let before = s:extractbefore(all)
-    let after  =  s:extractafter(all)
-  elseif exists("g:surround_".char2nr(newchar))
-    let all    = s:process(g:surround_{char2nr(newchar)})
-    let before = s:extractbefore(all)
-    let after  =  s:extractafter(all)
-  elseif newchar ==# "p"
-    let before = "\n"
-    let after  = "\n\n"
-  elseif newchar ==# 's'
-    let before = ' '
-    let after  = ''
-  elseif newchar ==# ':'
-    let before = ':'
-    let after = ''
-  elseif newchar =~# "[tT\<C-T><,]"
-    let dounmapp = 0
-    let dounmapb = 0
-    if !maparg(">","c")
-      let dounmapb = 1
-      " Hide from AsNeeded
-      exe "cn"."oremap > <CR>"
-    endif
-    let default = ""
-    if newchar ==# "T"
-      if !exists("s:lastdel")
-        let s:lastdel = ""
-      endif
-      let default = matchstr(s:lastdel,'<\zs.\{-\}\ze>')
-    endif
-    let tag = input("<",default)
-    echo "<".substitute(tag,'>*$','>','')
-    if dounmapb
-      silent! cunmap >
-    endif
-    let s:tag = tag
-    if tag != ""
-      let tag = substitute(tag,'>*$','','')
-      let s:tag = tag . '>'
-      let before = '<'.tag.'>'
-      if tag =~ '/$'
-        let after = ''
-      else
-        let after  = '</'.substitute(tag,' .*','','').'>'
-      endif
-      if newchar == "\<C-T>" || newchar == ","
-        if type ==# "v" || type ==# "V"
-          let before .= "\n\t"
-        endif
-        if type ==# "v"
-          let after  = "\n". after
-        endif
-      endif
-    endif
-  elseif newchar ==# 'l' || newchar == '\'
-    " LaTeX
-    let env = input('\begin{')
-    let env = '{' . env
-    let env .= s:closematch(env)
-    echo '\begin'.env
-    if env != ""
-      let before = '\begin'.env
-      let after  = '\end'.matchstr(env,'[^}]*').'}'
-    endif
-  elseif newchar ==# 'f' || newchar ==# 'F'
-    let fnc = input('function: ')
-    if fnc != ""
-      let before = substitute(fnc,'($','','').'('
-      let after  = ')'
-      if newchar ==# 'F'
-        let before .= ' '
-        let after = ' ' . after
-      endif
-    endif
-  elseif newchar ==# "\<C-F>"
-    let fnc = input('function: ')
-    let before = '('.fnc.' '
-    let after = ')'
-  elseif idx >= 0
-    let spc = (idx % 3) == 1 ? " " : ""
-    let idx = idx / 3 * 3
-    let before = strpart(pairs,idx+1,1) . spc
-    let after  = spc . strpart(pairs,idx+2,1)
-  elseif newchar == "\<C-[>" || newchar == "\<C-]>"
-    let before = "{\n\t"
-    let after  = "\n}"
-  elseif newchar !~ '\a'
-    let before = newchar
-    let after  = newchar
-  else
-    let before = ''
-    let after  = ''
-  endif
-  let after  = substitute(after ,'\n','\n'.initspaces,'g')
-  if type ==# 'V' || (special && type ==# "v")
-    let before = substitute(before,' \+$','','')
-    let after  = substitute(after ,'^ \+','','')
-    if after !~ '^\n'
-      let after  = initspaces.after
-    endif
-    if keeper !~ '\n$' && after !~ '^\n'
-      let keeper .= "\n"
-    elseif keeper =~ '\n$' && after =~ '^\n'
-      let after = strpart(after,1)
-    endif
-    if before !~ '\n\s*$'
-      let before .= "\n"
-      if special
-        let before .= "\t"
-      endif
-    endif
-  endif
-  if type ==# 'V'
-    let before = initspaces.before
-  endif
-  if before =~ '\n\s*\%$'
-    if type ==# 'v'
-      let keeper = initspaces.keeper
-    endif
-    let padding = matchstr(before,'\n\zs\s\+\%$')
-    let before  = substitute(before,'\n\s\+\%$','\n','')
-    let keeper = s:fixindent(keeper,padding)
-  endif
-  if type ==# 'V'
-    let keeper = before.keeper.after
-  elseif type =~ "^\<C-V>"
-    " Really we should be iterating over the buffer
-    let repl = substitute(before,'[\\~]','\\&','g').'\1'.substitute(after,'[\\~]','\\&','g')
-    let repl = substitute(repl,'\n',' ','g')
-    let keeper = substitute(keeper."\n",'\(.\{-\}\)\(\n\)',repl.'\n','g')
-    let keeper = substitute(keeper,'\n\%$','','')
-  else
-    let keeper = before.extraspace.keeper.extraspace.after
-  endif
-  return keeper
-endfunction
-
-function! s:wrapreg(reg,char,...)
-  let orig = getreg(a:reg)
-  let type = substitute(getregtype(a:reg),'\d\+$','','')
-  let special = a:0 ? a:1 : 0
-  let new = s:wrap(orig,a:char,type,special)
-  call setreg(a:reg,new,type)
-endfunction
-" }}}1
-
-function! s:insert(...) " {{{1
-  " Optional argument causes the result to appear on 3 lines, not 1
-  let linemode = a:0 ? a:1 : 0
-  let char = s:inputreplacement()
-  while char == "\<CR>" || char == "\<C-S>"
-    " TODO: use total count for additional blank lines
-    let linemode += 1
-    let char = s:inputreplacement()
-  endwhile
-  if char == ""
-    return ""
-  endif
-  let cb_save = &clipboard
-  set clipboard-=unnamed clipboard-=unnamedplus
-  let reg_save = @@
-  call setreg('"',"\r",'v')
-  call s:wrapreg('"',char,linemode)
-  " If line mode is used and the surrounding consists solely of a suffix,
-  " remove the initial newline.  This fits a use case of mine but is a
-  " little inconsistent.  Is there anyone that would prefer the simpler
-  " behavior of just inserting the newline?
-  if linemode && match(getreg('"'),'^\n\s*\zs.*') == 0
-    call setreg('"',matchstr(getreg('"'),'^\n\s*\zs.*'),getregtype('"'))
-  endif
-  " This can be used to append a placeholder to the end
-  if exists("g:surround_insert_tail")
-    call setreg('"',g:surround_insert_tail,"a".getregtype('"'))
-  endif
-  if col('.') >= col('$')
-    norm! ""p
-  else
-    norm! ""P
-  endif
-  if linemode
-    call s:reindent()
-  endif
-  norm! `]
-  call search('\r','bW')
-  let @@ = reg_save
-  let &clipboard = cb_save
-  return "\<Del>"
-endfunction " }}}1
-
-function! s:reindent() " {{{1
-  if exists("b:surround_indent") ? b:surround_indent : (!exists("g:surround_indent") || g:surround_indent)
-    silent norm! '[=']
-  endif
-endfunction " }}}1
-
-function! s:dosurround(...) " {{{1
-  let scount = v:count1
-  let char = (a:0 ? a:1 : s:inputtarget())
-  let spc = ""
-  if char =~ '^\d\+'
-    let scount = scount * matchstr(char,'^\d\+')
-    let char = substitute(char,'^\d\+','','')
-  endif
-  if char =~ '^ '
-    let char = strpart(char,1)
-    let spc = 1
-  endif
-  if char == 'a'
-    let char = '>'
-  endif
-  if char == 'r'
-    let char = ']'
-  endif
-  let newchar = ""
-  if a:0 > 1
-    let newchar = a:2
-    if newchar == "\<Esc>" || newchar == "\<C-C>" || newchar == ""
-      return s:beep()
-    endif
-  endif
-  let cb_save = &clipboard
-  set clipboard-=unnamed clipboard-=unnamedplus
-  let append = ""
-  let original = getreg('"')
-  let otype = getregtype('"')
-  call setreg('"',"")
-  let strcount = (scount == 1 ? "" : scount)
-  if char == '/'
-    exe 'norm! '.strcount.'[/d'.strcount.']/'
-  elseif char =~# '[[:punct:]]' && char !~# '[][(){}<>"''`]'
-    exe 'norm! T'.char
-    if getline('.')[col('.')-1] == char
-      exe 'norm! l'
-    endif
-    exe 'norm! dt'.char
-  else
-    exe 'norm! d'.strcount.'i'.char
-  endif
-  let keeper = getreg('"')
-  let okeeper = keeper " for reindent below
-  if keeper == ""
-    call setreg('"',original,otype)
-    let &clipboard = cb_save
-    return ""
-  endif
-  let oldline = getline('.')
-  let oldlnum = line('.')
-  if char ==# "p"
-    call setreg('"','','V')
-  elseif char ==# "s" || char ==# "w" || char ==# "W"
-    " Do nothing
-    call setreg('"','')
-  elseif char =~ "[\"'`]"
-    exe "norm! i \<Esc>d2i".char
-    call setreg('"',substitute(getreg('"'),' ','',''))
-  elseif char == '/'
-    norm! "_x
-    call setreg('"','/**/',"c")
-    let keeper = substitute(substitute(keeper,'^/\*\s\=','',''),'\s\=\*$','','')
-  elseif char =~# '[[:punct:]]' && char !~# '[][(){}<>]'
-    exe 'norm! F'.char
-    exe 'norm! df'.char
-  else
-    " One character backwards
-    call search('.','bW')
-    exe "norm! da".char
-  endif
-  let removed = getreg('"')
-  let rem2 = substitute(removed,'\n.*','','')
-  let oldhead = strpart(oldline,0,strlen(oldline)-strlen(rem2))
-  let oldtail = strpart(oldline,  strlen(oldline)-strlen(rem2))
-  let regtype = getregtype('"')
-  if char =~# '[\[({<T]' || spc
-    let keeper = substitute(keeper,'^\s\+','','')
-    let keeper = substitute(keeper,'\s\+$','','')
-  endif
-  if col("']") == col("$") && col('.') + 1 == col('$')
-    if oldhead =~# '^\s*$' && a:0 < 2
-      let keeper = substitute(keeper,'\%^\n'.oldhead.'\(\s*.\{-\}\)\n\s*\%$','\1','')
-    endif
-    let pcmd = "p"
-  else
-    let pcmd = "P"
-  endif
-  if line('.') + 1 < oldlnum && regtype ==# "V"
-    let pcmd = "p"
-  endif
-  call setreg('"',keeper,regtype)
-  if newchar != ""
-    call s:wrapreg('"',newchar)
-  endif
-  silent exe 'norm! ""'.pcmd.'`['
-  if removed =~ '\n' || okeeper =~ '\n' || getreg('"') =~ '\n'
-    call s:reindent()
-  endif
-  if getline('.') =~ '^\s\+$' && keeper =~ '^\s*\n'
-    silent norm! cc
-  endif
-  call setreg('"',original,otype)
-  let s:lastdel = removed
-  let &clipboard = cb_save
-  if newchar == ""
-    silent! call repeat#set("\<Plug>Dsurround".char,scount)
-  else
-    silent! call repeat#set("\<Plug>Csurround".char.newchar.s:tag,scount)
-  endif
-endfunction " }}}1
-
-function! s:changesurround() " {{{1
-  let a = s:inputtarget()
-  if a == ""
-    return s:beep()
-  endif
-  let b = s:inputreplacement()
-  if b == ""
-    return s:beep()
-  endif
-  call s:dosurround(a,b)
-endfunction " }}}1
-
-function! s:opfunc(type,...) " {{{1
-  let char = s:inputreplacement()
-  if char == ""
-    return s:beep()
-  endif
-  let reg = '"'
-  let sel_save = &selection
-  let &selection = "inclusive"
-  let cb_save  = &clipboard
-  set clipboard-=unnamed clipboard-=unnamedplus
-  let reg_save = getreg(reg)
-  let reg_type = getregtype(reg)
-  let type = a:type
-  if a:type == "char"
-    silent exe 'norm! v`[o`]"'.reg.'y'
-    let type = 'v'
-  elseif a:type == "line"
-    silent exe 'norm! `[V`]"'.reg.'y'
-    let type = 'V'
-  elseif a:type ==# "v" || a:type ==# "V" || a:type ==# "\<C-V>"
-    let &selection = sel_save
-    let ve = &virtualedit
-    if !(a:0 && a:1)
-      set virtualedit=
-    endif
-    silent exe 'norm! gv"'.reg.'y'
-    let &virtualedit = ve
-  elseif a:type =~ '^\d\+$'
-    let type = 'v'
-    silent exe 'norm! ^v'.a:type.'$h"'.reg.'y'
-    if mode() ==# 'v'
-      norm! v
-      return s:beep()
-    endif
-  else
-    let &selection = sel_save
-    let &clipboard = cb_save
-    return s:beep()
-  endif
-  let keeper = getreg(reg)
-  if type ==# "v" && a:type !=# "v"
-    let append = matchstr(keeper,'\_s\@<!\s*$')
-    let keeper = substitute(keeper,'\_s\@<!\s*$','','')
-  endif
-  call setreg(reg,keeper,type)
-  call s:wrapreg(reg,char,a:0 && a:1)
-  if type ==# "v" && a:type !=# "v" && append != ""
-    call setreg(reg,append,"ac")
-  endif
-  silent exe 'norm! gv'.(reg == '"' ? '' : '"' . reg).'p`['
-  if type ==# 'V' || (getreg(reg) =~ '\n' && type ==# 'v')
-    call s:reindent()
-  endif
-  call setreg(reg,reg_save,reg_type)
-  let &selection = sel_save
-  let &clipboard = cb_save
-  if a:type =~ '^\d\+$'
-    silent! call repeat#set("\<Plug>Y".(a:0 && a:1 ? "S" : "s")."surround".char.s:tag,a:type)
-  else
-    silent! call repeat#set("\<Plug>SurroundRepeat".char.s:tag)
-  endif
-endfunction
-
-function! s:opfunc2(arg)
-  call s:opfunc(a:arg,1)
-endfunction " }}}1
-
-function! s:closematch(str) " {{{1
-  " Close an open (, {, [, or < on the command line.
-  let tail = matchstr(a:str,'.[^\[\](){}<>]*$')
-  if tail =~ '^\[.\+'
-    return "]"
-  elseif tail =~ '^(.\+'
-    return ")"
-  elseif tail =~ '^{.\+'
-    return "}"
-  elseif tail =~ '^<.+'
-    return ">"
-  else
-    return ""
-  endif
-endfunction " }}}1
-
-nnoremap <silent> <Plug>SurroundRepeat .
-nnoremap <silent> <Plug>Dsurround  :<C-U>call <SID>dosurround(<SID>inputtarget())<CR>
-nnoremap <silent> <Plug>Csurround  :<C-U>call <SID>changesurround()<CR>
-nnoremap <silent> <Plug>Yssurround :<C-U>call <SID>opfunc(v:count1)<CR>
-nnoremap <silent> <Plug>YSsurround :<C-U>call <SID>opfunc2(v:count1)<CR>
-" <C-U> discards the numerical argument but there's not much we can do with it
-nnoremap <silent> <Plug>Ysurround  :<C-U>set opfunc=<SID>opfunc<CR>g@
-nnoremap <silent> <Plug>YSurround  :<C-U>set opfunc=<SID>opfunc2<CR>g@
-vnoremap <silent> <Plug>VSurround  :<C-U>call <SID>opfunc(visualmode(),visualmode() ==# 'V' ? 1 : 0)<CR>
-vnoremap <silent> <Plug>VgSurround :<C-U>call <SID>opfunc(visualmode(),visualmode() ==# 'V' ? 0 : 1)<CR>
-inoremap <silent> <Plug>Isurround  <C-R>=<SID>insert()<CR>
-inoremap <silent> <Plug>ISurround  <C-R>=<SID>insert(1)<CR>
-
-if !exists("g:surround_no_mappings") || ! g:surround_no_mappings
-  nmap ds  <Plug>Dsurround
-  nmap cs  <Plug>Csurround
-  nmap ys  <Plug>Ysurround
-  nmap yS  <Plug>YSurround
-  nmap yss <Plug>Yssurround
-  nmap ySs <Plug>YSsurround
-  nmap ySS <Plug>YSsurround
-  xmap S   <Plug>VSurround
-  xmap gS  <Plug>VgSurround
-  if !exists("g:surround_no_insert_mappings") || ! g:surround_no_insert_mappings
-    if !hasmapto("<Plug>Isurround","i") && "" == mapcheck("<C-S>","i")
-      imap    <C-S> <Plug>Isurround
-    endif
-    imap      <C-G>s <Plug>Isurround
-    imap      <C-G>S <Plug>ISurround
-  endif
-endif
-
-" vim:set ft=vim sw=2 sts=2 et: