Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Merge

  • Loading branch information...
commit 97193e85050b7f22cbde55c2532e29670297fe6d 2 parents 337e5d7 + 1c46ba8
@derekwyatt authored
Showing with 299 additions and 77,848 deletions.
  1. +3 −2 bundle/install_ensime.sh
  2. +0 −68 bundle/vim-aftercolors/plugin/AfterColors.vim
  3. +0 −1,029 bundle/vim-align/autoload/Align.vim
  4. +0 −330 bundle/vim-align/autoload/AlignMaps.vim
  5. +0 −1,469 bundle/vim-align/doc/Align.txt
  6. +0 −85 bundle/vim-align/doc/tags
  7. +0 −246 bundle/vim-align/plugin/AlignMapsPlugin.vim
  8. +0 −41 bundle/vim-align/plugin/AlignPlugin.vim
  9. +0 −510 bundle/vim-align/plugin/cecutil.vim
  10. +0 −626 bundle/vim-bufkill/plugin/bufkill.vim
  11. +0 −14,112 bundle/vim-cref/doc/crefvim.txt
  12. +0 −1,742 bundle/vim-cref/doc/crefvimdoc.txt
  13. +0 −30,720 bundle/vim-cref/doc/stlrefvim.txt
  14. +0 −1,629 bundle/vim-cref/doc/tags
  15. +0 −356 bundle/vim-cref/plugin/crefvim.vim
  16. +0 −361 bundle/vim-cref/plugin/stlrefvim.vim
  17. +0 −547 bundle/vim-easygrep/doc/EasyGrep.txt
  18. +0 −36 bundle/vim-easygrep/doc/tags
  19. +0 −2,236 bundle/vim-easygrep/plugin/EasyGrep.vim
  20. +0 −72 bundle/vim-easygrep/plugin/EasyGrepFileAssociations
  21. +0 −643 bundle/vim-filtering/plugin/filtering.vim
  22. +0 −1,980 bundle/vim-genutils/autoload/genutils.vim
  23. +0 −1,047 bundle/vim-genutils/plugin/genutils.vim
  24. +0 −682 bundle/vim-histwin/autoload/histwin.vim
  25. +0 −380 bundle/vim-histwin/doc/histwin.txt
  26. +0 −15 bundle/vim-histwin/doc/tags
  27. +0 −42 bundle/vim-histwin/plugin/histwinPlugin.vim
  28. +0 −406 bundle/vim-matchit/doc/matchit.txt
  29. +0 −50 bundle/vim-matchit/doc/tags
  30. +0 −812 bundle/vim-matchit/plugin/matchit.vim
  31. +0 −146 bundle/vim-netdict/doc/netdict.txt
  32. +0 −586 bundle/vim-netdict/plugin/netdict.vim
  33. +0 −62 bundle/vim-netdict/syntax/netdict.vim
  34. +0 −3,720 bundle/vim-perforce/autoload/perforce.vim
  35. +0 −260 bundle/vim-perforce/autoload/perforceutils.vim
  36. +0 −2,441 bundle/vim-perforce/doc/perforce.txt
  37. +0 −245 bundle/vim-perforce/doc/tags
  38. +0 −59 bundle/vim-perforce/ftplugin/perforce.vim
  39. +0 −15 bundle/vim-perforce/ftplugin/selectbuf_perforce.vim
  40. +0 −396 bundle/vim-perforce/perforce/bakup.sh
  41. +0 −24 bundle/vim-perforce/perforce/p4Utils.sh
  42. +0 −97 bundle/vim-perforce/perforce/perforcebugrep.vim
  43. +0 −335 bundle/vim-perforce/perforce/perforcemenu.vim
  44. +0 −39 bundle/vim-perforce/perforce/perforceutils.vim
  45. +0 −125 bundle/vim-perforce/perforce/restor.sh
  46. +0 −375 bundle/vim-perforce/plugin/perforce.vim
  47. +0 −184 bundle/vim-perforce/syntax/perforce.vim
  48. +0 −11 bundle/vim-sokoban/VimSokoban/level1.sok
  49. +0 −16 bundle/vim-sokoban/VimSokoban/level10.sok
  50. +0 −15 bundle/vim-sokoban/VimSokoban/level11.sok
  51. +0 −13 bundle/vim-sokoban/VimSokoban/level12.sok
  52. +0 −13 bundle/vim-sokoban/VimSokoban/level13.sok
  53. +0 −16 bundle/vim-sokoban/VimSokoban/level14.sok
  54. +0 −16 bundle/vim-sokoban/VimSokoban/level15.sok
  55. +0 −15 bundle/vim-sokoban/VimSokoban/level16.sok
  56. +0 −14 bundle/vim-sokoban/VimSokoban/level17.sok
  57. +0 −13 bundle/vim-sokoban/VimSokoban/level18.sok
  58. +0 −16 bundle/vim-sokoban/VimSokoban/level19.sok
  59. +0 −10 bundle/vim-sokoban/VimSokoban/level2.sok
  60. +0 −16 bundle/vim-sokoban/VimSokoban/level20.sok
  61. +0 −15 bundle/vim-sokoban/VimSokoban/level21.sok
  62. +0 −16 bundle/vim-sokoban/VimSokoban/level22.sok
  63. +0 −14 bundle/vim-sokoban/VimSokoban/level23.sok
  64. +0 −16 bundle/vim-sokoban/VimSokoban/level24.sok
  65. +0 −16 bundle/vim-sokoban/VimSokoban/level25.sok
  66. +0 −12 bundle/vim-sokoban/VimSokoban/level26.sok
  67. +0 −13 bundle/vim-sokoban/VimSokoban/level27.sok
  68. +0 −15 bundle/vim-sokoban/VimSokoban/level28.sok
  69. +0 −13 bundle/vim-sokoban/VimSokoban/level29.sok
  70. +0 −10 bundle/vim-sokoban/VimSokoban/level3.sok
  71. +0 −14 bundle/vim-sokoban/VimSokoban/level30.sok
  72. +0 −16 bundle/vim-sokoban/VimSokoban/level31.sok
  73. +0 −15 bundle/vim-sokoban/VimSokoban/level32.sok
  74. +0 −15 bundle/vim-sokoban/VimSokoban/level33.sok
  75. +0 −15 bundle/vim-sokoban/VimSokoban/level34.sok
  76. +0 −16 bundle/vim-sokoban/VimSokoban/level35.sok
  77. +0 −16 bundle/vim-sokoban/VimSokoban/level36.sok
  78. +0 −15 bundle/vim-sokoban/VimSokoban/level37.sok
  79. +0 −11 bundle/vim-sokoban/VimSokoban/level38.sok
  80. +0 −16 bundle/vim-sokoban/VimSokoban/level39.sok
  81. +0 −14 bundle/vim-sokoban/VimSokoban/level4.sok
  82. +0 −16 bundle/vim-sokoban/VimSokoban/level40.sok
  83. +0 −15 bundle/vim-sokoban/VimSokoban/level41.sok
  84. +0 −13 bundle/vim-sokoban/VimSokoban/level42.sok
  85. +0 −11 bundle/vim-sokoban/VimSokoban/level43.sok
  86. +0 −15 bundle/vim-sokoban/VimSokoban/level44.sok
  87. +0 −14 bundle/vim-sokoban/VimSokoban/level45.sok
  88. +0 −16 bundle/vim-sokoban/VimSokoban/level46.sok
  89. +0 −11 bundle/vim-sokoban/VimSokoban/level47.sok
  90. +0 −16 bundle/vim-sokoban/VimSokoban/level48.sok
  91. +0 −15 bundle/vim-sokoban/VimSokoban/level49.sok
  92. +0 −13 bundle/vim-sokoban/VimSokoban/level5.sok
  93. +0 −16 bundle/vim-sokoban/VimSokoban/level50.sok
  94. +0 −12 bundle/vim-sokoban/VimSokoban/level51.sok
  95. +0 −17 bundle/vim-sokoban/VimSokoban/level52.sok
  96. +0 −12 bundle/vim-sokoban/VimSokoban/level53.sok
  97. +0 −12 bundle/vim-sokoban/VimSokoban/level54.sok
  98. +0 −12 bundle/vim-sokoban/VimSokoban/level55.sok
  99. +0 −12 bundle/vim-sokoban/VimSokoban/level56.sok
  100. +0 −12 bundle/vim-sokoban/VimSokoban/level57.sok
  101. +0 −12 bundle/vim-sokoban/VimSokoban/level58.sok
  102. +0 −12 bundle/vim-sokoban/VimSokoban/level59.sok
  103. +0 −11 bundle/vim-sokoban/VimSokoban/level6.sok
  104. +0 −12 bundle/vim-sokoban/VimSokoban/level60.sok
  105. +0 −12 bundle/vim-sokoban/VimSokoban/level61.sok
  106. +0 −12 bundle/vim-sokoban/VimSokoban/level62.sok
  107. +0 −12 bundle/vim-sokoban/VimSokoban/level63.sok
  108. +0 −12 bundle/vim-sokoban/VimSokoban/level64.sok
  109. +0 −12 bundle/vim-sokoban/VimSokoban/level65.sok
  110. +0 −12 bundle/vim-sokoban/VimSokoban/level66.sok
  111. +0 −12 bundle/vim-sokoban/VimSokoban/level67.sok
  112. +0 −12 bundle/vim-sokoban/VimSokoban/level68.sok
  113. +0 −12 bundle/vim-sokoban/VimSokoban/level69.sok
  114. +0 −12 bundle/vim-sokoban/VimSokoban/level7.sok
  115. +0 −12 bundle/vim-sokoban/VimSokoban/level70.sok
  116. +0 −12 bundle/vim-sokoban/VimSokoban/level71.sok
  117. +0 −12 bundle/vim-sokoban/VimSokoban/level72.sok
  118. +0 −12 bundle/vim-sokoban/VimSokoban/level73.sok
  119. +0 −12 bundle/vim-sokoban/VimSokoban/level74.sok
  120. +0 −12 bundle/vim-sokoban/VimSokoban/level75.sok
  121. +0 −12 bundle/vim-sokoban/VimSokoban/level76.sok
  122. +0 −15 bundle/vim-sokoban/VimSokoban/level77.sok
  123. +0 −12 bundle/vim-sokoban/VimSokoban/level78.sok
  124. +0 −12 bundle/vim-sokoban/VimSokoban/level79.sok
  125. +0 −16 bundle/vim-sokoban/VimSokoban/level8.sok
  126. +0 −13 bundle/vim-sokoban/VimSokoban/level80.sok
  127. +0 −13 bundle/vim-sokoban/VimSokoban/level81.sok
  128. +0 −13 bundle/vim-sokoban/VimSokoban/level82.sok
  129. +0 −13 bundle/vim-sokoban/VimSokoban/level83.sok
  130. +0 −12 bundle/vim-sokoban/VimSokoban/level84.sok
  131. +0 −16 bundle/vim-sokoban/VimSokoban/level85.sok
  132. +0 −10 bundle/vim-sokoban/VimSokoban/level86.sok
  133. +0 −14 bundle/vim-sokoban/VimSokoban/level87.sok
  134. +0 −16 bundle/vim-sokoban/VimSokoban/level88.sok
  135. +0 −17 bundle/vim-sokoban/VimSokoban/level89.sok
  136. +0 −14 bundle/vim-sokoban/VimSokoban/level9.sok
  137. +0 −17 bundle/vim-sokoban/VimSokoban/level90.sok
  138. +0 −907 bundle/vim-sokoban/plugin/sokoban.vim
  139. +0 −313 bundle/vim-tetris/plugin/tetris.vim
  140. +0 −147 bundle/vim-visincr/autoload/calutil.vim
  141. +0 −922 bundle/vim-visincr/autoload/visincr.vim
  142. +0 −70 bundle/vim-visincr/doc/tags
  143. +0 −488 bundle/vim-visincr/doc/visincr.txt
  144. +0 −88 bundle/vim-visincr/plugin/visincrPlugin.vim
  145. +0 −1,656 bundle/vim-visincr/visincr.vba
  146. +0 −93 bundle/vim-wiked/syntax/wiki.vim
  147. +0 −380 bundle/vim-zoomwin/autoload/ZoomWin.vim
  148. +0 −121 bundle/vim-zoomwin/doc/ZoomWin.txt
  149. +0 −6 bundle/vim-zoomwin/doc/tags
  150. +0 −49 bundle/vim-zoomwin/plugin/ZoomWinPlugin.vim
  151. +2 −0  data/vimside/.gitignore
  152. +79 −0 data/vimside/ensime_config.vim
  153. +156 −0 data/vimside/options_user.vim
  154. +3 −0  spell/en.utf-8.add
  155. BIN  spell/en.utf-8.add.spl
  156. +39 −0 xpt-personal/ftplugin/java/java.xpt.vim
  157. +17 −4 xpt-personal/ftplugin/tex/tex.xpt.vim
View
5 bundle/install_ensime.sh
@@ -1,5 +1,6 @@
#!/bin/bash
-curl http://cloud.github.com/downloads/aemoncannon/ensime/ensime_2.9.2-0.9.8.1.tar.gz | \
+mkdir -p ensime
+cd ensime
+curl http://cloud.github.com/downloads/aemoncannon/ensime/ensime_2.10.0-SNAPSHOT-0.9.7.tar.gz | \
tar zxvf -
-mv ensime_2.9.2-0.9.8.1 ensime
View
68 bundle/vim-aftercolors/plugin/AfterColors.vim
@@ -1,68 +0,0 @@
-" Vim Plugin: AfterColors.vim:
-" Provides: Automatic sourcing of after/colors/ scripts.
-" Author: Peter Hodge <toomuchphp-vim@yahoo.com>
-" URL: http://www.vim.org/scripts/script.php?script_id=1641
-" Version: 1.3
-" Last Update: May 13, 2008
-" Requires: Vim 6 or later (preferably 7) with autocommand support
-"
-"
-" Minor Bug: if you just add your 'after/colors' scripts to
-" 'vimfiles/after/colors/myColorsName.vim', when you go to
-" use CTRL-D after the 'colors' command, vim will list
-" 'myColorsName' twice, because it doesn't know that one of them
-" is an 'after' script. I have sent an email to Bram regarding this
-" bug, but as a work-around, I have made it possible that you can
-" also put your scripts in an 'after_colors' folder:
-" vimfiles/after_colors/myColorsName.vim
-" or
-" vimfiles/after/after_colors/myColorsName.vim
-"
-"
-" Note: because you generally choose your colorscheme in
-" _vimrc and plugins are loaded afterwards, the sequence files
-" are loaded on startup may be a little confusing at first:
-" -- Vim Load Sequence --
-" 1 - _vimrc
-" 2 - vimfiles/colors/myColorsName.vim
-" 3 - vimfiles/plugins/[plugins]
-" 4 - vimfiles/plugins/AfterColors.vim
-" 5 - vimfiles/plugins/[more plugins]
-" 6 - vimfiles/after_colors/myColorsName.vim
-
-" requires vim 6 at least
-if version <= 600 || exists('loaded_AfterColors') || ! has("autocmd")
- finish
-endif
-
-let g:loaded_AfterColors = 1
-
-" provide ability for an 'after/colors' file using autocommands
-augroup AfterColorsPlugin
- autocmd!
-
- " source the 'after' colors scripts only after vim has finished everything
- " else, because there are many things which will reset the colors
- if exists('##VimEnter')
- autocmd VimEnter * call <SID>AfterColorsScript()
- endif
-
- " if this vim has the 'Colorscheme' event, we can hook onto it to ensure
- " that the 'after' colors are reloaded when the colorscheme is changed
- if exists('##ColorScheme')
- autocmd ColorScheme * call <SID>AfterColorsScript()
- endif
-
-augroup end
-
-function! <SID>AfterColorsScript()
- if exists('g:colors_name') && strlen(g:colors_name)
- " allow two places to store after/colors scripts
- execute 'runtime! after/colors/' . g:colors_name . '.vim'
- execute 'runtime! after_colors/' . g:colors_name . '.vim'
-
- " allow global colors in 'common.vim'
- execute 'runtime! after/colors/common.vim'
- execute 'runtime! after_colors/common.vim'
- endif
-endfunction
View
1,029 bundle/vim-align/autoload/Align.vim
@@ -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
View
330 bundle/vim-align/autoload/AlignMaps.vim
@@ -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
View
1,469 bundle/vim-align/doc/Align.txt
@@ -1,1469 +0,0 @@
-*align.txt* The Alignment Tool Mar 04, 2009
-
-Author: Charles E. Campbell, Jr. <NdrOchip@ScampbellPfamily.AbizM>
- (remove NOSPAM from Campbell's email first)
-Copyright: (c) 2004-2008 by Charles E. Campbell, Jr. *Align-copyright*
- The VIM LICENSE applies to Align.vim, AlignMaps.vim, and Align.txt
- (see |copyright|) except use "Align and AlignMaps" instead of "Vim"
- NO WARRANTY, EXPRESS OR IMPLIED. USE AT-YOUR-OWN-RISK.
-
-==============================================================================
-1. Contents *align* *align-contents* {{{1
-
- 1. Contents.................: |align-contents|
- 2. Alignment Manual.........: |align-manual|
- 3. Alignment Usage..........: |align-usage|
- Alignment Concepts.......: |align-concepts|
- Alignment Commands.......: |align-commands|
- Alignment Control........: |align-control|
- Separators.............: |alignctrl-separators|
- Initial Whitespace.....: |alignctrl-w| |alignctrl-W| |alignctrl-I|
- Justification..........: |alignctrl-l| |alignctrl-r| |alignctrl-c|
- Justification Control..: |alignctrl--| |alignctrl-+| |alignctrl-:|
- Cyclic/Sequential......: |alignctrl-=| |alignctrl-C|
- Separator Justification: |alignctrl-<| |alignctrl->| |alignctrl-||
- Line (de)Selection.....: |alignctrl-g| |alignctrl-v|
- Temporary Settings.....: |alignctrl-m|
- Padding................: |alignctrl-p| |alignctrl-P|
- Current Options........: |alignctrl-settings| |alignctrl-|
- Alignment................: |align-align|
- 4. Alignment Maps...........: |align-maps|
- \a,....................: |alignmap-a,|
- \a?....................: |alignmap-a?|
- \a<....................: |alignmap-a<|
- \abox..................: |alignmap-abox|
- \acom..................: |alignmap-acom|
- \anum..................: |alignmap-anum|
- \ascom.................: |alignmap-ascom|
- \adec..................: |alignmap-adec|
- \adef..................: |alignmap-adef|
- \afnc..................: |alignmap-afnc|
- \adcom.................: |alignmap-adcom|
- \aocom.................: |alignmap-aocom|
- \tsp...................: |alignmap-tsp|
- \tsq...................: |alignmap-tsq|
- \tt....................: |alignmap-tt|
- \t=....................: |alignmap-t=|
- \T=....................: |alignmap-T=|
- \Htd...................: |alignmap-Htd|
- 5. Alignment Tool History...: |align-history|
-
-==============================================================================
-2. Align Manual *alignman* *alignmanual* *align-manual* {{{1
-
- Align comes as a vimball; simply typing >
- vim Align.vba.gz
- :so %
-< should put its components where they belong. The components are: >
- .vim/plugin/AlignPlugin.vim
- .vim/plugin/AlignMapsPlugin.vim
- .vim/plugin/cecutil.vim
- .vim/autoload/Align.vim
- .vim/autoload/AlignMaps.vim
- .vim/doc/Align.txt
-< To see a user's guide, see |align-userguide|
- To see examples, see |alignctrl| and |alignmaps|
->
-/=============+=========+=====================================================\
-|| \ Default/ ||
-|| Commands \ Value/ Explanation ||
-|| | | ||
-++==============+====+=======================================================++
-|| AlignCtrl | | =Clrc-+:pPIWw [..list-of-separator-patterns..] ||
-|| | +-------------------------------------------------------+|
-|| | | may be called as a command or as a function: ||
-|| | | :AlignCtrl =lp0P0W & \\ ||
-|| | | :call Align#AlignCtrl('=lp0P0W','&','\\') ||
-|| | | ||
-|| | +-------------------------------------------------------++
-|| 1st arg | = | = all separator patterns are equivalent and are ||
-|| | | simultaneously active. Patterns are |regexp|. ||
-|| | | C cycle through separator patterns. Patterns are ||
-|| | | |regexp| and are active sequentially. ||
-|| | | ||
-|| | < | < left justify separator Separators are justified, ||
-|| | | > right justify separator too. Separator styles ||
-|| | | | center separator are cyclic. ||
-|| | | ||
-|| | l | l left justify Justification styles are always ||
-|| | | r right justify cyclic (ie. lrc would mean left j., ||
-|| | | c center then right j., then center, repeat. ||
-|| | | - skip this separator ||
-|| | | + re-use last justification method ||
-|| | | : treat rest of text as a field ||
-|| | | ||
-|| | p1 | p### pad separator on left by # blanks ||
-|| | P1 | P### pad separator on right by # blanks ||
-|| | | ||
-|| | I | I preserve and apply first line's leading white ||
-|| | | space to all lines ||
-|| | | W preserve leading white space on every line, even ||
-|| | | if it varies from line to line ||
-|| | | w don't preserve leading white space ||
-|| | | ||
-|| | | g second argument is a selection pattern -- only ||
-|| | | align on lines that have a match (inspired by ||
-|| | | :g/selection pattern/command) ||
-|| | | v second argument is a selection pattern -- only ||
-|| | | align on lines that _don't_ have a match (inspired ||
-|| | | by :v/selection pattern/command) ||
-|| | | ||
-|| | | m Map support: AlignCtrl will immediately do an ||
-|| | | AlignPush() and the next call to Align() will do ||
-|| | | an AlignPop at the end. This feature allows maps ||
-|| | | to preserve user settings. ||
-|| | | ||
-|| | | default ||
-|| | | AlignCtrl default ||
-|| | | will clear the AlignCtrl ||
-|| | | stack & set the default: AlignCtrl "Ilp1P1=" '=' ||
-|| | | ||
-|| +----+-------------------------------------------------------+|
-|| More args | More arguments are interpreted as describing separators ||
-|| +------------------------------------------------------------+|
-|| No args | AlignCtrl will display its current settings ||
-||==============+============================================================+|
-||[range]Align | [..list-of-separators..] ||
-||[range]Align! | [AlignCtrl settings] [..list-of-separators..] ||
-|| +------------------------------------------------------------+|
-|| | Aligns text over the given range. The range may be ||
-|| | selected via visual mode (v, V, or ctrl-v) or via ||
-|| | the command line. The Align operation may be invoked ||
-|| | as a command or as a function; as a function, the first ||
-|| | argument is 0=separators only, 1=AlignCtrl option string ||
-|| | followed by a list of separators. ||
-|| | :[range]Align ||
-|| | :[range]Align [list of separators] ||
-|| | :[range]call Align#Align(0) ||
-|| | :[range]call Align#Align(0,"list","of","separators",...) ||
-\=============================================================================/
-
-==============================================================================
-3. Alignment Usage *alignusage* *align-usage* *align-userguide* {{{1
-
-
-ALIGNMENT CONCEPTS *align-concept* *align-concepts* {{{2
-
- The typical text to be aligned is considered to be:
-
- * composed of two or more fields
- * separated by one or more separator pattern(s):
- * two or more lines
->
- ws field ws separator ws field ws separator ...
- ws field ws separator ws field ws separator ...
-<
- where "ws" stands for "white space" such as blanks and/or tabs,
- and "fields" are arbitrary text. For example, consider >
-
- x= y= z= 3;
- xx= yy= zz= 4;
- zzz= yyy= zzz= 5;
- a= b= c= 3;
-<
- Assume that it is desired to line up all the "=" signs; these,
- then, are the separators. The fields are composed of all the
- alphameric text. Assuming they lie on lines 1-4, one may align
- those "=" signs with: >
- :AlignCtrl l
- :1,4Align =
-< The result is: >
- x = y = z = 3;
- xx = yy = zz = 4;
- zzz = yyy = zzz = 5;
- a = b = c = 3;
-
-< Note how each "=" sign is surrounded by a single space; the
- default padding is p1P1 (p1 means one space before the separator,
- and P1 means one space after it). If you wish to change the
- padding, say to no padding, use (see |alignctrl-p|) >
- :AlignCtrl lp0P0
-
-< Next, note how each field is left justified; that's what the "l"
- (a small letter "ell") does. If right-justification of the fields
- had been desired, an "r" could've been used: >
- :AlignCtrl r
-< yielding >
- x = y = z = 3;
- xx = yy = zz = 4;
- zzz = yyy = zzz = 5;
- a = b = c = 3;
-< There are many more options available for field justification: see
- |alignctrl-c| and |alignctrl--|.
-
- Separators, although commonly only one character long, are actually
- specified by regular expressions (see |regexp|), and one may left
- justify, right justify, or center them, too (see |alignctrl-<|).
-
- Assume that for some reason a left-right-left-right-... justification
- sequence was wished. This wish is simply achieved with >
- :AlignCtrl lr
- :1,4Align =
-< because the justification commands are considered to be "cylic"; ie.
- lr is the same as lrlrlrlrlrlrlr...
-
- There's a lot more discussed under |alignctrl|; hopefully the examples
- there will help, too.
-
-
-ALIGNMENT COMMANDS *align-command* *align-commands* {{{2
-
- The <Align.vim> script includes two primary commands and two
- minor commands:
-
- AlignCtrl : this command/function sets up alignment options
- which persist until changed for later Align calls.
- It controls such things as: how to specify field
- separators, initial white space, padding about
- separators, left/right/center justification, etc. >
- ex. AlignCtrl wp0P1
- Interpretation: during subsequent alignment
- operations, preserve each line's initial
- whitespace. Use no padding before separators
- but provide one padding space after separators.
-<
- Align : this command/function operates on the range given it to
- align text based on one or more separator patterns. The
- patterns may be provided via AlignCtrl or via Align
- itself. >
-
- ex. :%Align ,
- Interpretation: align all commas over the entire
- file.
-< The :Align! format permits alignment control commands
- to precede the alignment patterns. >
- ex. :%Align! p2P2 =
-< This will align all "=" in the file with two padding
- spaces on both sides of each "=" sign.
-
- NOTE ON USING PATTERNS WITH ALIGN:~
- Align and AlignCtrl use |<q-args>| to obtain their
- input patterns and they use an internal function to
- split arguments at whitespace unless inside "..."s.
- One may escape characters inside a double-quote string
- by preceding such characters with a backslash.
-
- AlignPush : this command/function pushes the current AlignCtrl
- state onto an internal stack. >
- ex. :AlignPush
- Interpretation: save the current AlignCtrl
- settings, whatever they may be. They'll
- also remain as the current settings until
- AlignCtrl is used to change them.
-<
- AlignPop : this command/function pops the current AlignCtrl
- state from an internal stack. >
- ex. :AlignPop
- Interpretation: presumably AlignPush was
- used (at least once) previously; this command
- restores the AlignCtrl settings when AlignPush
- was last used.
-< Also see |alignctrl-m| for a way to automatically do
- an AlignPop after an Align (primarily this is for maps).
-
-ALIGNMENT OPTIONS *align-option* *align-options* {{{2
- *align-utf8* *align-utf* *align-codepoint* *align-strlen* *align-multibyte*
-
- For those of you who are using 2-byte (or more) characters such as are
- available with utf-8, Align now provides a special option which you
- may choose based upon your needs:
-
- Use Built-in strlen() ~
->
- let g:Align_xstrlen= 0
-
-< This is the fastest method, but it doesn't handle multibyte characters
- well. It is the default for:
-
- enc=latin1
- vim compiled without multi-byte support
- $LANG is en_US.UTF-8 (assuming USA english)
-
- Number of codepoints (Latin a + combining circumflex is two codepoints)~
->
- let g:Align_xstrlen= 1 (default)
-<
- Number of spacing codepoints (Latin a + combining circumflex is one~
- spacing codepoint; a hard tab is one; wide and narrow CJK are one~
- each; etc.)~
->
- let g:Align_xstrlen= 2
-<
- Virtual length (counting, for instance, tabs as anything between 1 and~
- 'tabstop', wide CJK as 2 rather than 1, Arabic alif as zero when~
- immediately preceded by lam, one otherwise, etc.)~
->
- let g:Align_xstrlen= 3
-<
- By putting one of these settings into your <.vimrc>, Align will use an
- internal (interpreted) function to determine a string's length instead
- of the Vim's built-in |strlen()| function. Since the function is
- interpreted, Align will run a bit slower but will handle such strings
- correctly. The last setting (g:Align_xstrlen= 3) probably will run
- the slowest but be the most accurate. (thanks to Tony Mechelynck for
- these)
-
-
-ALIGNMENT CONTROL *alignctrl* *align-control* {{{2
-
- This command doesn't do the alignment operation itself; instead, it
- controls subsequent alignment operation(s).
-
- The first argument to AlignCtrl is a string which may contain one or
- more alignment control settings. Most of the settings are specified
- by single letters; the exceptions are the p# and P# commands which
- interpret a digit following the p or P as specifying padding about the
- separator.
-
- The typical text line is considered to be composed of two or more
- fields separated by one or more separator pattern(s): >
-
- ws field ws separator ws field ws separator ...
-<
- where "ws" stands for "white space" such as blanks and/or tabs.
-
-
- SEPARATORS *alignctrl-separators* {{{3
-
- As a result, separators may not have white space (tabs or blanks) on
- their outsides (ie. ": :" is fine as a separator, but " :: " is
- not). Usually such separators are not needed, although a map has been
- provided which works around this limitation and aligns on whitespace
- (see |alignmap-tsp|).
-
- However, if you really need to have separators with leading or
- trailing whitespace, consider handling them by performing a substitute
- first (ie. s/ :: /@/g), do the alignment on the temporary pattern
- (ie. @), and then perform a substitute to revert the separators back
- to their desired condition (ie. s/@/ :: /g).
-
- The Align#Align() function will first convert tabs over the region into
- spaces and then apply alignment control. Except for initial white
- space, white space surrounding the fields is ignored. One has three
- options just for handling initial white space:
-
-
- --- *alignctrl-w*
- wWI INITIAL WHITE SPACE *alignctrl-W* {{{3
- --- *alignctrl-I*
- w : ignore all selected lines' initial white space
- W : retain all selected lines' initial white space
- I : retain only the first line's initial white space and
- re-use it for subsequent lines
-
- Example: Leading white space options: >
- +---------------+-------------------+-----------------+
- |AlignCtrl w= :=| AlignCtrl W= := | AlignCtrl I= := |
- +------------------+---------------+-------------------+-----------------+
- | Original | w option | W option | I option |
- +------------------+---------------+-------------------+-----------------+
- | a := baaa |a := baaa | a : = baaa | a := baaa |
- | caaaa := deeee |caaaa := deeee | caaaa : = deeee| caaaa := deeee|
- | ee := f |ee := f | ee : = f | ee := f |
- +------------------+---------------+-------------------+-----------------+
-<
- The original has at least one leading white space on every line.
- Using Align with w eliminated each line's leading white space.
- Using Align with W preserved each line's leading white space.
- Using Align with I applied the first line's leading white space
- (three spaces) to each line.
-
-
- ------ *alignctrl-l*
- lrc-+: FIELD JUSTIFICATION *alignctrl-r* {{{3
- ------ *alignctrl-c*
-
- With "lrc", the fields will be left-justified, right-justified, or
- centered as indicated by the justification specifiers (lrc). The
- "lrc" options are re-used by cycling through them as needed:
-
- l means llllll....
- r means rrrrrr....
- lr means lrlrlr....
- llr means llrllr....
-
- Example: Justification options: Align = >
- +------------+-------------------+-------------------+-------------------+
- | Original | AlignCtrl l | AlignCtrl r | AlignCtrl lr |
- +------------+-------------------+-------------------+-------------------+
- | a=bb=ccc=1 |a = bb = ccc = 1| a = bb = ccc = 1|a = bb = ccc = 1|
- | ccc=a=bb=2 |ccc = a = bb = 2|ccc = a = bb = 2|ccc = a = bb = 2|
- | dd=eee=f=3 |dd = eee = f = 3| dd = eee = f = 3|dd = eee = f = 3|
- +------------+-------------------+-------------------+-------------------+
- | Alignment |l l l l| r r r r|l r l r|
- +------------+-------------------+-------------------+-------------------+
-<
- AlignCtrl l : The = separator is repeatedly re-used, as the
- cycle only consists of one character (the "l").
- Every time left-justification is used for fields.
- AlignCtrl r : The = separator is repeatedly re-used, as the
- cycle only consists of one character (the "l").
- Every time right-justification is used for fields
- AlignCtrl lr: Again, the "=" separator is repeatedly re-used,
- but the fields are justified alternately between
- left and right.
-
- Even more separator control is available. With "-+:":
-
- - : skip treating the separator as a separator. *alignctrl--*
- + : repeat use of the last "lrc" justification *alignctrl-+*
- : : treat the rest of the line as a single field *alignctrl-:*
-
- Example: More justification options: Align = >
- +------------+---------------+--------------------+---------------+
- | Original | AlignCtrl -l | AlignCtrl rl+ | AlignCtrl l: |
- +------------+---------------+--------------------+---------------+
- | a=bb=ccc=1 |a=bb = ccc=1 | a = bb = ccc = 1 |a = bb=ccc=1 |
- | ccc=a=bb=2 |ccc=a = bb=2 |ccc = a = bb = 2 |ccc = a=bb=2 |
- | dd=eee=f=3 |dd=eee = f=3 | dd = eee = f = 3 |dd = eee=f=3 |
- +------------+---------------+--------------------+---------------+
- | Alignment |l l | r l l l |l l |
- +------------+---------------+--------------------+---------------+
-<
- In the first example in "More justification options":
-
- The first "=" separator is skipped by the "-" specification,
- and so "a=bb", "ccc=a", and "dd=eee" are considered as single fields.
-
- The next "=" separator has its (left side) field left-justified.
- Due to the cyclic nature of separator patterns, the "-l"
- specification is equivalent to "-l-l-l ...".
-
- Hence the next specification is a "skip", so "ccc=1", etc are fields.
-
- In the second example in "More justification options":
-
- The first field is right-justified, the second field is left
- justified, and all remaining fields repeat the last justification
- command (ie. they are left justified, too).
-
- Hence rl+ is equivalent to rlllllllll ...
- (whereas plain rl is equivalent to rlrlrlrlrl ... ).
-
- In the third example in "More justification options":
-
- The text following the first separator is treated as a single field.
-
- Thus using the - and : operators one can apply justification to a
- single separator.
-
- ex. 1st separator only: AlignCtrl l:
- 2nd separator only: AlignCtrl -l:
- 3rd separator only: AlignCtrl --l:
- etc.
-
-
- --- *alignctrl-=*
- =C CYCLIC VS ALL-ACTIVE SEPARATORS *alignctrl-C* {{{3
- ---
-
- The separators themselves may be considered as equivalent and
- simultaneously active ("=") or sequentially cycled through ("C").
- Separators are regular expressions (|regexp|) and are specified as the
- second, third, etc arguments. When the separator patterns are
- equivalent and simultaneously active, there will be one pattern
- constructed: >
-
- AlignCtrl ... pat1 pat2 pat3
- \(pat1\|pat2\|pat3\)
-<
- Each separator pattern is thus equivalent and simultaneously active.
- The cyclic separator AlignCtrl option stores a list of patterns, only
- one of which is active for each field at a time.
-
- Example: Equivalent/Simultaneously-Active vs Cyclic Separators >
- +-------------+------------------+---------------------+----------------------+
- | Original | AlignCtrl = = + -| AlignCtrl = = | AlignCtrl C = + - |
- +-------------+------------------+---------------------+----------------------+
- |a = b + c - d|a = b + c - d |a = b + c - d |a = b + c - d |
- |x = y = z + 2|x = y = z + 2 |x = y = z + 2|x = y = z + 2 |
- |w = s - t = 0|w = s - t = 0 |w = s - t = 0 |w = s - t = 0 |
- +-------------+------------------+---------------------+----------------------+
-<
- The original is initially aligned with all operators (=+-) being
- considered as equivalent and simultaneously active field separators.
- Thus the "AlignCtrl = = + -" example shows no change.
-
- The second example only accepts the '=' as a field separator;
- consequently "b + c - d" is now a single field.
-
- The third example illustrates cyclic field separators and is analyzed
- in the following illustration: >
-
- field1 separator field2 separator field3 separator field4
- a = b + c - d
- x = y = z + 2
- w = s - t = 0
-<
- The word "cyclic" is used because the patterns form a cycle of use; in
- the above case, its = + - = + - = + - = + -...
-
- Example: Cyclic separators >
- Label : this is some text discussing ":"s | ex. abc:def:ghi
- Label : this is some text with a ":" in it | ex. abc:def
-<
- apply AlignCtrl lWC : | |
- (select lines)Align >
- Label : this is some text discussing ":"s | ex. abc:def:ghi
- Label : this is some text with a ":" in it | ex. abcd:efg
-<
- In the current example,
- : is the first separator So the first ":"s are aligned
- | is the second separator but subsequent ":"s are not.
- | is the third separator The "|"s are aligned, too.
- : is the fourth separator Since there aren't two bars,
- | is the fifth separator the subsequent potential cycles
- | is the sixth separator don't appear.
- ...
-
- In this case it would probably have been a better idea to have used >
- AlignCtrl WCl: : |
-< as that alignment control would guarantee that no more cycling
- would be used after the vertical bar.
-
- Example: Cyclic separators
-
- Original: >
- a| b&c | (d|e) & f-g-h
- aa| bb&cc | (dd|ee) & ff-gg-hh
- aaa| bbb&ccc | (ddd|eee) & fff-ggg-hhh
-<
- AlignCtrl C | | & - >
- a | b&c | (d|e) & f - g-h
- aa | bb&cc | (dd|ee) & ff - gg-hh
- aaa | bbb&ccc | (ddd|eee) & fff - ggg-hhh
-<
- In this example,
- the first and second separators are "|",
- the third separator is "&", and
- the fourth separator is "-",
-
- (cycling)
- the fifth and sixth separators are "|",
- the seventh separator is "&", and
- the eighth separator is "-", etc.
-
- Thus the first "&"s are (not yet) separators, and hence are treated as
- part of the field. Ignoring white space for the moment, the AlignCtrl
- shown here means that Align will work with >
-
- field | field | field & field - field | field | field & field - ...
-<
-
- --- *alignctrl-<*
- <>| SEPARATOR JUSTIFICATION *alignctrl->* {{{3
- --- *alignctrl-|*
-
- Separators may be of differing lengths as shown in the example below.
- Hence they too may be justified left, right, or centered.
- Furthermore, separator justification specifications are cyclic:
-
- < means <<<<<... justify separator(s) to the left
- > means >>>>>... justify separator(s) to the right
- | means |||||... center separator(s)
-
- Example: Separator Justification: Align -\+ >
- +-----------------+
- | Original |
- +-----------------+
- | a - bbb - c |
- | aa -- bb -- ccc |
- | aaa --- b --- cc|
- +---------------------+-+-----------------+-+---------------------+
- | AlignCtrl < | AlignCtrl > | AlignCtrl | |
- +---------------------+---------------------+---------------------+
- | a - bbb - c | a - bbb - c | a - bbb - c |
- | aa -- bb -- ccc | aa -- bb -- ccc | aa -- bb -- ccc |
- | aaa --- b --- cc | aaa --- b --- cc | aaa --- b --- cc |
- +---------------------+---------------------+---------------------+
-<
-
- --- *alignctrl-g*
- gv SELECTIVE APPLICATION *alignctrl-v* {{{3
- ---
-
-
- These two options provide a way to select (g) or to deselect (v) lines
- based on a pattern. Ideally :g/pat/Align would work; unfortunately
- it results in Align#Align() being called on each line satisfying the
- pattern separately. >
-
- AlignCtrl g pattern
-<
- Align will only consider those lines which have the given pattern. >
-
- AlignCtrl v pattern
-<
- Align will only consider those lines without the given pattern. As an
- example of use, consider the following example: >
-
- :AlignCtrl v ^\s*/\*
- Original :Align = :Align =
- +----------------+------------------+----------------+
- |one= 2; |one = 2; |one = 2; |
- |three= 4; |three = 4; |three = 4; |
- |/* skip=this */ |/* skip = this */ |/* skip=this */ |
- |five= 6; |five = 6; |five = 6; |
- +----------------+------------------+----------------+
-<
- The first "Align =" aligned with all "="s, including that one in the
- "skip=this" comment.
-
- The second "Align =" had a AlignCtrl v-pattern which caused it to skip
- (ignore) the "skip=this" line when aligning.
-
- To remove AlignCtrl's g and v patterns, use (as appropriate) >
-
- AlignCtrl g
- AlignCtrl v
-<
- To see what g/v patterns are currently active, just use the reporting
- capability of an unadorned call to AlignCtrl: >
-
- AlignCtrl
-<
-
- ---
- m MAP SUPPORT *alignctrl-m* {{{3
- ---
-
- This option primarily supports the development of maps. The
- Align#AlignCtrl() call will first do an Align#AlignPush() (ie. retain
- current alignment control settings). The next Align#Align() will, in
- addition to its alignment job, finish up with an Align#AlignPop().
- Thus the Align#AlignCtrl settings that follow the "m" are only
- temporarily in effect for just the next Align#Align().
-
-
- ---
- p### *alignctrl-p*
- P### PADDING *alignctrl-P* {{{3
- ---
-
- These two options control pre-padding and post-padding with blanks
- about the separator. One may pad separators with zero to nine spaces;
- the padding number(s) is/are treated as a cyclic parameter. Thus one
- may specify padding separately for each field or re-use a padding
- pattern. >
-
- Example: AlignCtrl p102P0
- +---------+----------------------------------+
- | Original| a=b=c=d=e=f=g=h=1 |
- | Align = | a =b=c =d =e=f =g =h=1 |
- +---------+----------------------------------+
- | prepad | 1 0 2 1 0 2 1 0 |
- +---------+----------------------------------+
-<
- This example will cause Align to:
-
- pre-pad the first "=" with a single blank,
- pre-pad the second "=" with no blanks,
- pre-pad the third "=" with two blanks,
- pre-pad the fourth "=" with a single blank,
- pre-pad the fifth "=" with no blanks,
- pre-pad the sixth "=" with two blanks,
- etc.
-
- --------------- *alignctrl-settings*
- No option given DISPLAY STATUS *alignctrl-* {{{3
- --------------- *alignctrl-no-option*
-
- AlignCtrl, when called with no arguments, will display the current
- alignment control settings. A typical display is shown below: >
-
- AlignCtrl<=> qty=1 AlignStyle<l> Padding<1|1>
- Pat1<\(=\)>
-<
- Interpreting, this means that the separator patterns are all
- equivalent; in this case, there's only one (qty=1). Fields will be
- padded on the right with spaces (left justification), and separators
- will be padded on each side with a single space.
-
- To change one of these items, see:
-
- AlignCtrl......|alignctrl|
- qty............|align-concept|
- AlignStyle.....|alignctrl--| |alignctrl-+| |alignctrl-:||alignctrl-c|
- Padding........|alignctrl-p| |alignctrl-P|
-
- One may get a string which can be fed back into AlignCtrl: >
-
- :let alignctrl= Align#AlignCtrl()
-<
- This form will put a string describing the current AlignCtrl options,
- except for the "g" and "v" patterns, into a variable. The
- Align#AlignCtrl() function will still echo its settings, however. One
- can feed any non-supported "option" to AlignCtrl() to prevent this,
- however: >
-
- :let alignctrl= Align#AlignCtrl("d")
-<
-
-ALIGNMENT *align-align* {{{2
-
- Once the alignment control has been determined, the user specifies a
- range of lines for the Align command/function to do its thing.
- Alignment is often done on a line-range basis, but one may also
- restrict alignment to a visual block using ctrl-v. For any visual
- mode, one types the colon (:) and then "Align". One may, of course,
- specify a range of lines: >
-
- :[range]Align [list-of-separators]
-<
- where the |:range| is the usual Vim-powered set of possibilities; the
- list of separators is the same as the AlignCtrl capability. There is
- only one list of separators, but either AlignCtrl or Align can be used
- to specify that list.
-
- An alternative form of the Align command can handle both alignment
- control and the separator list: >
-
- :[range]Align! [alignment-control-string] [list-of-separators]
-<
- The alignment control string will be applied only for this particular
- application of Align (it uses |alignctrl-m|). The "g pattern" and
- "v pattern" alignment controls (see |alignctrl-g| and |alignctrl-v|)
- are also available via this form of the Align command.
-
- Align makes two passes over the text to be aligned. The first pass
- determines how many fields there are and determines the maximum sizes
- of each field; these sizes are then stored in a vector. The second
- pass pads the field (left/right/centered as specified) to bring its
- length up to the maximum size of the field. Then the separator and
- its AlignCtrl-specified padding is appended.
-
- Pseudo-Code:~
- During pass 1
- | For all fields in the current line
- || Determine current separator
- || Examine field specified by current separator
- || Determine length of field and save if largest thus far
- Initialize newline based on initial whitespace option (wWI)
- During pass 2
- | For all fields in current line
- || Determine current separator
- || Extract field specified by current separator
- || Prepend/append padding as specified by AlignCtrl
- || (right/left/center)-justify to fit field into max-size field
- || Append separator with AlignCtrl-specified separator padding
- || Delete current line, install newly aligned line
-
- The g and v AlignCtrl patterns cause the passes not to consider lines
- for alignment, either by requiring that the g-pattern be present or
- that the v-pattern not be present.
-
- The whitespace on either side of a separator is ignored.
-
-
-==============================================================================
-4. Alignment Maps *alignmaps* *align-maps* {{{1
-
- There are a number of maps using Align#AlignCtrl() and Align#Align()
- in the <AlignMapsPlugin.vim> file. This file may also be put into the
- plugins subdirectory. Since AlignCtrl and Align supercede textab and
- its <ttalign.vim> file, the maps either have a leading "t" (for
- "textab") or the more complicated ones an "a" (for "alignment") for
- backwards compatibility.
-
- The maps are shown below with a leading backslash (\). Actually, the
- <Leader> construct is used (see |mapleader|), so the maps' leading
- kick-off character is easily customized.
-
- Furthermore, all AlignMapsPlugin.vim maps use the <Plug> construct (see
- |<Plug>|and |usr_41.txt|). Hence, if one wishes to override the
- mapping entirely, one may do that, too. As an example: >
- map <Leader>ACOM <Plug>AM_acom
-< would have \ACOM do what \acom previously did (assuming that the
- mapleader has been left at its default value of a backslash).
-
- \a, : useful for breaking up comma-separated
- declarations prior to \adec |alignmap-a,|
- \a( : aligns ( and , (useful for prototypes) *alignmap-a(*
- \a? : aligns (...)? ...:... expressions on ? and : |alignmap-a?|
- \a< : aligns << and >> for c++ |alignmap-a<|
- \a= : aligns := assignments |alignmap-a=|
- \abox : draw a C-style comment box around text lines |alignmap-abox|
- \acom : useful for aligning comments |alignmap-acom|
- \adcom: useful for aligning comments in declarations |alignmap-adcom|
- \anum : useful for aligning numbers |alignmap-anum|
- NOTE: For the visual-mode use of \anum, <vis.vim> is needed!
- See http://mysite.verizon.net/astronaut/vim/index.html#VIS
- \aenum: align a European-style number |alignmap-anum|
- \aunum: align a USA-style number |alignmap-anum|
- \adec : useful for aligning declarations |alignmap-adec|
- \adef : useful for aligning definitions |alignmap-adef|
- \afnc : useful for aligning ansi-c style functions'
- argument lists |alignmap-afnc|
- \adcom: a variant of \acom, restricted to comment |alignmap-adcom|
- containing lines only, but also only for
- those which don't begin with a comment.
- Good for certain declaration styles.
- \aocom: a variant of \acom, restricted to comment |alignmap-aocom|
- containing lines only
- \tab : align a table based on tabs *alignmap-tab*
- (converts to spaces)
- \tml : useful for aligning the trailing backslashes |alignmap-tml|
- used to continue lines (shell programming, etc)
- \tsp : use Align to make a table separated by blanks |alignmap-tsp|
- (left justified)
- \ts, : like \t, but swaps whitespace on the right of *alignmap-ts,*
- the commas to their left
- \ts: : like \t: but swaps whitespace on the right of *alignmap-ts:*
- the colons to their left
- \ts< : like \t< but swaps whitespace on the right of *alignmap-ts<*
- the less-than signs to their left
- \ts= : like \t= but swaps whitespace on the right of *alignmap-ts=*
- the equals signs to their left
- \Tsp : use Align to make a table separated by blanks |alignmap-Tsp|
- (right justified)
- \tsq : use Align to make a table separated by blanks |alignmap-tsq|
- (left justified) -- "strings" are not split up
- \tt : useful for aligning LaTeX tabular tables |alignmap-tt|
- \Htd : tabularizes html tables: |alignmap-Htd|
- <TR><TD> ...field... </TD><TD> ...field... </TD></TR>
-
- *alignmap-t|* *alignmap-t#* *alignmap-t,* *alignmap-t:*
- *alignmap-t;* *alignmap-t<* *alignmap-t?* *alignmap-t~*
- *alignmap-m=*
- \tx : make a left-justified alignment on
- character "x" where "x" is: ,:<=@|# |alignmap-t=|
- \Tx : make a right-justified alignment on
- character "x" where "x" is: ,:<=@# |alignmap-T=|
- \m= : like \t= but aligns with %... style comments
-
- The leading backslash is actually <leader> (see |mapleader| for how to
- customize the leader to be whatever you like). These maps use the
- <Align.vim> package and are defined in the <AlignMaps.vim> file.
- Although the maps use AlignCtrl options, they typically use the "m"
- option which pushes the options (AlignPush). The associated Align
- call which follows will then AlignPop the user's original options
- back.
-
- ALIGNMENT MAP USE WITH MARK AND MOVE~
- In the examples below, one may select the text with a "ma" at the
- first line, move to the last line, then execute the map.
-
- ALIGNMENT MAP USE WITH VISUAL MODE~
- Alternatively, one may select the text with the "V" visual mode
- command.
-
- ALIGNMENT MAP USE WITH MENUS~
- One may use the mark-and-move style (ma, move, use the menu) or
- the visual mode style (use the V visual mode, move, then select
- the alignment map with menu selection). The alignment map menu
- items are under DrChip.AlignMaps .
-
- One may even change the top level menu name to whatever is wished; by
- default, its >
- let g:DrChipTopLvlMenu= "DrChip."
-< If you set the variable to the empty string (""), then no menu items
- will be produced. Of course, one must have a vim with +menu, the gui
- must be running, and |'go'| must have the menu bar suboption (ie. m
- must be included).
-
- COMPLEX ALIGNMENT MAP METHOD~
-
- For those complex alignment maps which do alignment on constructs
- (e.g. \acom, \adec, etc), a series of substitutes is used to insert
- "@" symbols in appropriate locations. Align#Align() is then used to
- do alignment directly on "@"s; then it is followed by further
- substitutes to do clean-up. However, the maps \WS and \WE, used by
- every map supported by AlignMaps, protect any original embedded "@"
- symbols by first converting them to <DEL> characters, doing the
- requested job, and then converting them back. >
-
- \WS calls AlignMaps#WrapperStart()
- \WE calls AlignMaps#WrapperEnd()
-<
-
- ---------------------------
- Alignment Map Examples: \a, *alignmap-a,* {{{3
- ---------------------------
-
- Original: illustrates comma-separated declaration splitting: >
- int a,b,c;
- struct ABC_str abc,def;
-<
- Becomes: >
- int a;
- int b;
- int c;
- struct ABC_str abc;
- struct ABC_str def;
-<
-
- ---------------------------
- Alignment Map Examples: \a? *alignmap-a?* {{{3
- ---------------------------
-
- Original: illustrates ()?: aligning >
- printf("<%s>\n",
- (x == ABC)? "abc" :
- (x == DEFG)? "defg" :
- (x == HIJKL)? "hijkl" : "???");
-<
- Becomes: select "(x == ..." lines, then \a? >
- printf("<%s>\n",
- (x == ABC)? "abc" :
- (x == DEFG)? "defg" :
- (x == HIJKL)? "hijkl" : "???");
-<
-
- ---------------------------
- Alignment Map Examples: \a< *alignmap-a<* {{{3
- ---------------------------
-
- Original: illustrating aligning of << and >> >
- cin << x;
- cin << y;
- cout << "this is x=" << x;
- cout << "but y=" << y << "is not";
-<
- Becomes: select "(x == ..." lines, then \a< >
- cin << x;
- cin << y;
- cout << "this is x=" << x;
- cout << "but y=" << y << "is not";
-<
-
- ---------------------------
- Alignment Map Examples: \a= *alignmap-a=* {{{3
- ---------------------------
-
- Original: illustrates how to align := assignments >
- aa:=bb:=cc:=1;
- a:=b:=c:=1;
- aaa:=bbb:=ccc:=1;
-<
- Bcomes: select the three assignment lines, then \a:= >
- aa := bb := cc := 1;
- a := b := c := 1;
- aaa := bbb := ccc := 1;
-<
-
- ---------------------------
- Alignment Map Examples: \abox *alignmap-abox* {{{3
- ---------------------------
-
- Original: illustrates how to comment-box some text >
- This is some plain text
- which will
- soon be surrounded by a
- comment box.
-<
- Becomes: Select "This..box." with ctrl-v, press \abox >
- /***************************
- * This is some plain text *
- * which will *
- * soon be surrounded by a *
- * comment box. *
- ***************************/
-<
-
- ---------------------------
- Alignment Map Examples: \acom *alignmap-acom* {{{3
- ---------------------------
-
- Original: illustrates aligning C-style comments (works for //, too) >
- if(itworks) { /* this */
- then= dothis; /* is a */