]> git.r.bdr.sh - rbdr/dotfiles/blob - vim/autoload/Align.vim
Delete a bunch of stuff, better arrange submodules
[rbdr/dotfiles] / vim / autoload / Align.vim
1 " Align: tool to align multiple fields based on one or more separators
2 " Author: Charles E. Campbell, Jr.
3 " Date: Mar 03, 2009
4 " Version: 35
5 " GetLatestVimScripts: 294 1 :AutoInstall: Align.vim
6 " GetLatestVimScripts: 1066 1 :AutoInstall: cecutil.vim
7 " Copyright: Copyright (C) 1999-2007 Charles E. Campbell, Jr. {{{1
8 " Permission is hereby granted to use and distribute this code,
9 " with or without modifications, provided that this copyright
10 " notice is copied with it. Like anything else that's free,
11 " Align.vim is provided *as is* and comes with no warranty
12 " of any kind, either expressed or implied. By using this
13 " plugin, you agree that in no event will the copyright
14 " holder be liable for any damages resulting from the use
15 " of this software.
16 "
17 " Romans 1:16,17a : For I am not ashamed of the gospel of Christ, for it is {{{1
18 " the power of God for salvation for everyone who believes; for the Jew first,
19 " and also for the Greek. For in it is revealed God's righteousness from
20 " faith to faith.
21
22 " ---------------------------------------------------------------------
23 " Load Once: {{{1
24 if exists("g:loaded_Align") || &cp
25 finish
26 endif
27 let g:loaded_Align = "v35"
28 if v:version < 700
29 echohl WarningMsg
30 echo "***warning*** this version of Align needs vim 7.0"
31 echohl Normal
32 finish
33 endif
34 let s:keepcpo= &cpo
35 set cpo&vim
36 "DechoTabOn
37
38 " ---------------------------------------------------------------------
39 " Debugging Support: {{{1
40 "if !exists("g:loaded_Decho") | runtime plugin/Decho.vim | endif
41
42 " ---------------------------------------------------------------------
43 " Options: {{{1
44 if !exists("g:Align_xstrlen")
45 if &enc == "latin1" || $LANG == "en_US.UTF-8" || !has("multi_byte")
46 let g:Align_xstrlen= 0
47 else
48 let g:Align_xstrlen= 1
49 endif
50 endif
51
52 " ---------------------------------------------------------------------
53 " Align#AlignCtrl: enter alignment patterns here {{{1
54 "
55 " Styles = all alignment-break patterns are equivalent
56 " C cycle through alignment-break pattern(s)
57 " l left-justified alignment
58 " r right-justified alignment
59 " c center alignment
60 " - skip separator, treat as part of field
61 " : treat rest of line as field
62 " + repeat previous [lrc] style
63 " < left justify separators
64 " > right justify separators
65 " | center separators
66 "
67 " Builds = s:AlignPat s:AlignCtrl s:AlignPatQty
68 " C s:AlignPat s:AlignCtrl s:AlignPatQty
69 " p s:AlignPrePad
70 " P s:AlignPostPad
71 " w s:AlignLeadKeep
72 " W s:AlignLeadKeep
73 " I s:AlignLeadKeep
74 " l s:AlignStyle
75 " r s:AlignStyle
76 " - s:AlignStyle
77 " + s:AlignStyle
78 " : s:AlignStyle
79 " c s:AlignStyle
80 " g s:AlignGPat
81 " v s:AlignVPat
82 " < s:AlignSep
83 " > s:AlignSep
84 " | s:AlignSep
85 fun! Align#AlignCtrl(...)
86
87 " call Dfunc("AlignCtrl(...) a:0=".a:0)
88
89 " save options that will be changed
90 let keep_search = @/
91 let keep_ic = &ic
92
93 " turn ignorecase off
94 set noic
95
96 " clear visual mode so that old visual-mode selections don't
97 " get applied to new invocations of Align().
98 if v:version < 602
99 if !exists("s:Align_gavemsg")
100 let s:Align_gavemsg= 1
101 echomsg "Align needs at least Vim version 6.2 to clear visual-mode selection"
102 endif
103 elseif exists("s:dovisclear")
104 " call Decho("clearing visual mode a:0=".a:0." a:1<".a:1.">")
105 let clearvmode= visualmode(1)
106 endif
107
108 " set up a list akin to an argument list
109 if a:0 > 0
110 let A= s:QArgSplitter(a:1)
111 else
112 let A=[0]
113 endif
114
115 if A[0] > 0
116 let style = A[1]
117
118 " Check for bad separator patterns (zero-length matches)
119 " (but zero-length patterns for g/v is ok)
120 if style !~# '[gv]'
121 let ipat= 2
122 while ipat <= A[0]
123 if "" =~ A[ipat]
124 echoerr "AlignCtrl: separator<".A[ipat]."> matches zero-length string"
125 let &ic= keep_ic
126 " call Dret("AlignCtrl")
127 return
128 endif
129 let ipat= ipat + 1
130 endwhile
131 endif
132 endif
133
134 " call Decho("AlignCtrl() A[0]=".A[0])
135 if !exists("s:AlignStyle")
136 let s:AlignStyle= "l"
137 endif
138 if !exists("s:AlignPrePad")
139 let s:AlignPrePad= 0
140 endif
141 if !exists("s:AlignPostPad")
142 let s:AlignPostPad= 0
143 endif
144 if !exists("s:AlignLeadKeep")
145 let s:AlignLeadKeep= 'w'
146 endif
147
148 if A[0] == 0
149 " ----------------------
150 " List current selection
151 " ----------------------
152 if !exists("s:AlignPatQty")
153 let s:AlignPatQty= 0
154 endif
155 echo "AlignCtrl<".s:AlignCtrl."> qty=".s:AlignPatQty." AlignStyle<".s:AlignStyle."> Padding<".s:AlignPrePad."|".s:AlignPostPad."> LeadingWS=".s:AlignLeadKeep." AlignSep=".s:AlignSep
156 " call Decho("AlignCtrl<".s:AlignCtrl."> qty=".s:AlignPatQty." AlignStyle<".s:AlignStyle."> Padding<".s:AlignPrePad."|".s:AlignPostPad."> LeadingWS=".s:AlignLeadKeep." AlignSep=".s:AlignSep)
157 if exists("s:AlignGPat") && !exists("s:AlignVPat")
158 echo "AlignGPat<".s:AlignGPat.">"
159 elseif !exists("s:AlignGPat") && exists("s:AlignVPat")
160 echo "AlignVPat<".s:AlignVPat.">"
161 elseif exists("s:AlignGPat") && exists("s:AlignVPat")
162 echo "AlignGPat<".s:AlignGPat."> AlignVPat<".s:AlignVPat.">"
163 endif
164 let ipat= 1
165 while ipat <= s:AlignPatQty
166 echo "Pat".ipat."<".s:AlignPat_{ipat}.">"
167 " call Decho("Pat".ipat."<".s:AlignPat_{ipat}.">")
168 let ipat= ipat + 1
169 endwhile
170
171 else
172 " ----------------------------------
173 " Process alignment control settings
174 " ----------------------------------
175 " call Decho("process the alignctrl settings")
176 " call Decho("style<".style.">")
177
178 if style ==? "default"
179 " Default: preserve initial leading whitespace, left-justified,
180 " alignment on '=', one space padding on both sides
181 if exists("s:AlignCtrlStackQty")
182 " clear AlignCtrl stack
183 while s:AlignCtrlStackQty > 0
184 call Align#AlignPop()
185 endwhile
186 unlet s:AlignCtrlStackQty
187 endif
188 " Set AlignCtrl to its default value
189 call Align#AlignCtrl("Ilp1P1=<",'=')
190 call Align#AlignCtrl("g")
191 call Align#AlignCtrl("v")
192 let s:dovisclear = 1
193 let &ic = keep_ic
194 let @/ = keep_search
195 " call Dret("AlignCtrl")
196 return
197 endif
198
199 if style =~# 'm'
200 " map support: Do an AlignPush now and the next call to Align()
201 " will do an AlignPop at exit
202 " call Decho("style case m: do AlignPush")
203 call Align#AlignPush()
204 let s:DoAlignPop= 1
205 endif
206
207 " = : record a list of alignment patterns that are equivalent
208 if style =~# "="
209 " call Decho("style case =: record list of equiv alignment patterns")
210 let s:AlignCtrl = '='
211 if A[0] >= 2
212 let s:AlignPatQty= 1
213 let s:AlignPat_1 = A[2]
214 let ipat = 3
215 while ipat <= A[0]
216 let s:AlignPat_1 = s:AlignPat_1.'\|'.A[ipat]
217 let ipat = ipat + 1
218 endwhile
219 let s:AlignPat_1= '\('.s:AlignPat_1.'\)'
220 " call Decho("AlignCtrl<".s:AlignCtrl."> AlignPat<".s:AlignPat_1.">")
221 endif
222
223 "c : cycle through alignment pattern(s)
224 elseif style =~# 'C'
225 " call Decho("style case C: cycle through alignment pattern(s)")
226 let s:AlignCtrl = 'C'
227 if A[0] >= 2
228 let s:AlignPatQty= A[0] - 1
229 let ipat = 1
230 while ipat < A[0]
231 let s:AlignPat_{ipat}= A[ipat+1]
232 " call Decho("AlignCtrl<".s:AlignCtrl."> AlignQty=".s:AlignPatQty." AlignPat_".ipat."<".s:AlignPat_{ipat}.">")
233 let ipat= ipat + 1
234 endwhile
235 endif
236 endif
237
238 if style =~# 'p'
239 let s:AlignPrePad= substitute(style,'^.*p\(\d\+\).*$','\1','')
240 " call Decho("style case p".s:AlignPrePad.": pre-separator padding")
241 if s:AlignPrePad == ""
242 echoerr "AlignCtrl: 'p' needs to be followed by a numeric argument'
243 let @/ = keep_search
244 let &ic= keep_ic
245 " call Dret("AlignCtrl")
246 return
247 endif
248 endif
249
250 if style =~# 'P'
251 let s:AlignPostPad= substitute(style,'^.*P\(\d\+\).*$','\1','')
252 " call Decho("style case P".s:AlignPostPad.": post-separator padding")
253 if s:AlignPostPad == ""
254 echoerr "AlignCtrl: 'P' needs to be followed by a numeric argument'
255 let @/ = keep_search
256 let &ic= keep_ic
257 " call Dret("AlignCtrl")
258 return
259 endif
260 endif
261
262 if style =~# 'w'
263 " call Decho("style case w: ignore leading whitespace")
264 let s:AlignLeadKeep= 'w'
265 elseif style =~# 'W'
266 " call Decho("style case w: keep leading whitespace")
267 let s:AlignLeadKeep= 'W'
268 elseif style =~# 'I'
269 " call Decho("style case w: retain initial leading whitespace")
270 let s:AlignLeadKeep= 'I'
271 endif
272
273 if style =~# 'g'
274 " first list item is a "g" selector pattern
275 " call Decho("style case g: global selector pattern")
276 if A[0] < 2
277 if exists("s:AlignGPat")
278 unlet s:AlignGPat
279 " call Decho("unlet s:AlignGPat")
280 endif
281 else
282 let s:AlignGPat= A[2]
283 " call Decho("s:AlignGPat<".s:AlignGPat.">")
284 endif
285 elseif style =~# 'v'
286 " first list item is a "v" selector pattern
287 " call Decho("style case v: global selector anti-pattern")
288 if A[0] < 2
289 if exists("s:AlignVPat")
290 unlet s:AlignVPat
291 " call Decho("unlet s:AlignVPat")
292 endif
293 else
294 let s:AlignVPat= A[2]
295 " call Decho("s:AlignVPat<".s:AlignVPat.">")
296 endif
297 endif
298
299 "[-lrc+:] : set up s:AlignStyle
300 if style =~# '[-lrc+:]'
301 " call Decho("style case [-lrc+:]: field justification")
302 let s:AlignStyle= substitute(style,'[^-lrc:+]','','g')
303 " call Decho("AlignStyle<".s:AlignStyle.">")
304 endif
305
306 "[<>|] : set up s:AlignSep
307 if style =~# '[<>|]'
308 " call Decho("style case [-lrc+:]: separator justification")
309 let s:AlignSep= substitute(style,'[^<>|]','','g')
310 " call Decho("AlignSep ".s:AlignSep)
311 endif
312 endif
313
314 " sanity
315 if !exists("s:AlignCtrl")
316 let s:AlignCtrl= '='
317 endif
318
319 " restore search and options
320 let @/ = keep_search
321 let &ic= keep_ic
322
323 " call Dret("AlignCtrl ".s:AlignCtrl.'p'.s:AlignPrePad.'P'.s:AlignPostPad.s:AlignLeadKeep.s:AlignStyle)
324 return s:AlignCtrl.'p'.s:AlignPrePad.'P'.s:AlignPostPad.s:AlignLeadKeep.s:AlignStyle
325 endfun
326
327 " ---------------------------------------------------------------------
328 " s:MakeSpace: returns a string with spacecnt blanks {{{1
329 fun! s:MakeSpace(spacecnt)
330 " call Dfunc("MakeSpace(spacecnt=".a:spacecnt.")")
331 let str = ""
332 let spacecnt = a:spacecnt
333 while spacecnt > 0
334 let str = str . " "
335 let spacecnt = spacecnt - 1
336 endwhile
337 " call Dret("MakeSpace <".str.">")
338 return str
339 endfun
340
341 " ---------------------------------------------------------------------
342 " Align#Align: align selected text based on alignment pattern(s) {{{1
343 fun! Align#Align(hasctrl,...) range
344 " call Dfunc("Align#Align(hasctrl=".a:hasctrl.",...) a:0=".a:0)
345
346 " sanity checks
347 if string(a:hasctrl) != "0" && string(a:hasctrl) != "1"
348 echohl Error|echo 'usage: Align#Align(hasctrl<'.a:hasctrl.'> (should be 0 or 1),"separator(s)" (you have '.a:0.') )'|echohl None
349 " call Dret("Align#Align")
350 return
351 endif
352 if exists("s:AlignStyle") && s:AlignStyle == ":"
353 echohl Error |echo '(Align#Align) your AlignStyle is ":", which implies "do-no-alignment"!'|echohl None
354 " call Dret("Align#Align")
355 return
356 endif
357
358 " set up a list akin to an argument list
359 if a:0 > 0
360 let A= s:QArgSplitter(a:1)
361 else
362 let A=[0]
363 endif
364
365 " if :Align! was used, then the first argument is (should be!) an AlignCtrl string
366 " Note that any alignment control set this way will be temporary.
367 let hasctrl= a:hasctrl
368 " call Decho("hasctrl=".hasctrl)
369 if a:hasctrl && A[0] >= 1
370 " call Decho("Align! : using A[1]<".A[1]."> for AlignCtrl")
371 if A[1] =~ '[gv]'
372 let hasctrl= hasctrl + 1
373 call Align#AlignCtrl('m')
374 call Align#AlignCtrl(A[1],A[2])
375 " call Decho("Align! : also using A[2]<".A[2]."> for AlignCtrl")
376 elseif A[1] !~ 'm'
377 call Align#AlignCtrl(A[1]."m")
378 else
379 call Align#AlignCtrl(A[1])
380 endif
381 endif
382
383 " Check for bad separator patterns (zero-length matches)
384 let ipat= 1 + hasctrl
385 while ipat <= A[0]
386 if "" =~ A[ipat]
387 echoerr "Align: separator<".A[ipat]."> matches zero-length string"
388 " call Dret("Align#Align")
389 return
390 endif
391 let ipat= ipat + 1
392 endwhile
393
394 " record current search pattern for subsequent restoration
395 let keep_search= @/
396 let keep_ic = &ic
397 let keep_report= &report
398 set noic report=10000
399
400 if A[0] > hasctrl
401 " Align will accept a list of separator regexps
402 " call Decho("A[0]=".A[0].": accepting list of separator regexp")
403
404 if s:AlignCtrl =~# "="
405 "= : consider all separators to be equivalent
406 " call Decho("AlignCtrl: record list of equivalent alignment patterns")
407 let s:AlignCtrl = '='
408 let s:AlignPat_1 = A[1 + hasctrl]
409 let s:AlignPatQty= 1
410 let ipat = 2 + hasctrl
411 while ipat <= A[0]
412 let s:AlignPat_1 = s:AlignPat_1.'\|'.A[ipat]
413 let ipat = ipat + 1
414 endwhile
415 let s:AlignPat_1= '\('.s:AlignPat_1.'\)'
416 " call Decho("AlignCtrl<".s:AlignCtrl."> AlignPat<".s:AlignPat_1.">")
417
418 elseif s:AlignCtrl =~# 'C'
419 "c : cycle through alignment pattern(s)
420 " call Decho("AlignCtrl: cycle through alignment pattern(s)")
421 let s:AlignCtrl = 'C'
422 let s:AlignPatQty= A[0] - hasctrl
423 let ipat = 1
424 while ipat <= s:AlignPatQty
425 let s:AlignPat_{ipat}= A[(ipat + hasctrl)]
426 " call Decho("AlignCtrl<".s:AlignCtrl."> AlignQty=".s:AlignPatQty." AlignPat_".ipat."<".s:AlignPat_{ipat}.">")
427 let ipat= ipat + 1
428 endwhile
429 endif
430 endif
431
432 " Initialize so that begline<endline and begcol<endcol.
433 " Ragged right: check if the column associated with '< or '>
434 " is greater than the line's string length -> ragged right.
435 " Have to be careful about visualmode() -- it returns the last visual
436 " mode used whether or not it was used currently.
437 let begcol = virtcol("'<")-1
438 let endcol = virtcol("'>")-1
439 if begcol > endcol
440 let begcol = virtcol("'>")-1
441 let endcol = virtcol("'<")-1
442 endif
443 " call Decho("begcol=".begcol." endcol=".endcol)
444 let begline = a:firstline
445 let endline = a:lastline
446 if begline > endline
447 let begline = a:lastline
448 let endline = a:firstline
449 endif
450 " call Decho("begline=".begline." endline=".endline)
451 let fieldcnt = 0
452 if (begline == line("'>") && endline == line("'<")) || (begline == line("'<") && endline == line("'>"))
453 let vmode= visualmode()
454 " call Decho("vmode=".vmode)
455 if vmode == "\<c-v>"
456 if exists("g:Align_xstrlen") && g:Align_xstrlen
457 let ragged = ( col("'>") > s:Strlen(getline("'>")) || col("'<") > s:Strlen(getline("'<")) )
458 else
459 let ragged = ( col("'>") > strlen(getline("'>")) || col("'<") > strlen(getline("'<")) )
460 endif
461 else
462 let ragged= 1
463 endif
464 else
465 let ragged= 1
466 endif
467 if ragged
468 let begcol= 0
469 endif
470 " call Decho("lines[".begline.",".endline."] col[".begcol.",".endcol."] ragged=".ragged." AlignCtrl<".s:AlignCtrl.">")
471
472 " Keep user options
473 let etkeep = &l:et
474 let pastekeep= &l:paste
475 setlocal et paste
476
477 " convert selected range of lines to use spaces instead of tabs
478 " but if first line's initial white spaces are to be retained
479 " then use 'em
480 if begcol <= 0 && s:AlignLeadKeep == 'I'
481 " retain first leading whitespace for all subsequent lines
482 let bgntxt= substitute(getline(begline),'^\(\s*\).\{-}$','\1','')
483 " call Decho("retaining 1st leading whitespace: bgntxt<".bgntxt.">")
484 set noet
485 endif
486 exe begline.",".endline."ret"
487
488 " Execute two passes
489 " First pass: collect alignment data (max field sizes)
490 " Second pass: perform alignment
491 let pass= 1
492 while pass <= 2
493 " call Decho(" ")
494 " call Decho("---- Pass ".pass.": ----")
495
496 let line= begline
497 while line <= endline
498 " Process each line
499 let txt = getline(line)
500 " call Decho(" ")
501 " call Decho("Pass".pass.": Line ".line." <".txt.">")
502
503 " AlignGPat support: allows a selector pattern (akin to g/selector/cmd )
504 if exists("s:AlignGPat")
505 " call Decho("Pass".pass.": AlignGPat<".s:AlignGPat.">")
506 if match(txt,s:AlignGPat) == -1
507 " call Decho("Pass".pass.": skipping")
508 let line= line + 1
509 continue
510 endif
511 endif
512
513 " AlignVPat support: allows a selector pattern (akin to v/selector/cmd )
514 if exists("s:AlignVPat")
515 " call Decho("Pass".pass.": AlignVPat<".s:AlignVPat.">")
516 if match(txt,s:AlignVPat) != -1
517 " call Decho("Pass".pass.": skipping")
518 let line= line + 1
519 continue
520 endif
521 endif
522
523 " Always skip blank lines
524 if match(txt,'^\s*$') != -1
525 " call Decho("Pass".pass.": skipping")
526 let line= line + 1
527 continue
528 endif
529
530 " Extract visual-block selected text (init bgntxt, endtxt)
531 if exists("g:Align_xstrlen") && g:Align_xstrlen
532 let txtlen= s:Strlen(txt)
533 else
534 let txtlen= strlen(txt)
535 endif
536 if begcol > 0
537 " Record text to left of selected area
538 let bgntxt= strpart(txt,0,begcol)
539 " call Decho("Pass".pass.": record text to left: bgntxt<".bgntxt.">")
540 elseif s:AlignLeadKeep == 'W'
541 let bgntxt= substitute(txt,'^\(\s*\).\{-}$','\1','')
542 " call Decho("Pass".pass.": retaining all leading ws: bgntxt<".bgntxt.">")
543 elseif s:AlignLeadKeep == 'w' || !exists("bgntxt")
544 " No beginning text
545 let bgntxt= ""
546 " call Decho("Pass".pass.": no beginning text")
547 endif
548 if ragged
549 let endtxt= ""
550 else
551 " Elide any text lying outside selected columnar region
552 let endtxt= strpart(txt,endcol+1,txtlen-endcol)
553 let txt = strpart(txt,begcol,endcol-begcol+1)
554 endif
555 " call Decho(" ")
556 " call Decho("Pass".pass.": bgntxt<".bgntxt.">")
557 " call Decho("Pass".pass.": txt<". txt .">")
558 " call Decho("Pass".pass.": endtxt<".endtxt.">")
559 if !exists("s:AlignPat_{1}")
560 echohl Error|echo "no separators specified!"|echohl None
561 " call Dret("Align#Align")
562 return
563 endif
564
565 " Initialize for both passes
566 let seppat = s:AlignPat_{1}
567 let ifield = 1
568 let ipat = 1
569 let bgnfield = 0
570 let endfield = 0
571 let alignstyle = s:AlignStyle
572 let doend = 1
573 let newtxt = ""
574 let alignprepad = s:AlignPrePad
575 let alignpostpad= s:AlignPostPad
576 let alignsep = s:AlignSep
577 let alignophold = " "
578 let alignop = "l"
579 " call Decho("Pass".pass.": initial alignstyle<".alignstyle."> seppat<".seppat.">")
580
581 " Process each field on the line
582 while doend > 0
583
584 " C-style: cycle through pattern(s)
585 if s:AlignCtrl == 'C' && doend == 1
586 let seppat = s:AlignPat_{ipat}
587 " call Decho("Pass".pass.": processing field: AlignCtrl=".s:AlignCtrl." ipat=".ipat." seppat<".seppat.">")
588 let ipat = ipat + 1
589 if ipat > s:AlignPatQty
590 let ipat = 1
591 endif
592 endif
593
594 " cyclic alignment/justification operator handling
595 let alignophold = alignop
596 let alignop = strpart(alignstyle,0,1)
597 if alignop == '+' || doend == 2
598 let alignop= alignophold
599 else
600 let alignstyle = strpart(alignstyle,1).strpart(alignstyle,0,1)
601 let alignopnxt = strpart(alignstyle,0,1)
602 if alignop == ':'
603 let seppat = '$'
604 let doend = 2
605 " call Decho("Pass".pass.": alignop<:> case: setting seppat<$> doend==2")
606 endif
607 endif
608
609 " cylic separator alignment specification handling
610 let alignsepop= strpart(alignsep,0,1)
611 let alignsep = strpart(alignsep,1).alignsepop
612
613 " mark end-of-field and the subsequent end-of-separator.
614 " Extend field if alignop is '-'
615 let endfield = match(txt,seppat,bgnfield)
616 let sepfield = matchend(txt,seppat,bgnfield)
617 let skipfield= sepfield
618 " call Decho("Pass".pass.": endfield=match(txt<".txt.">,seppat<".seppat.">,bgnfield=".bgnfield.")=".endfield)
619 while alignop == '-' && endfield != -1
620 let endfield = match(txt,seppat,skipfield)
621 let sepfield = matchend(txt,seppat,skipfield)
622 let skipfield = sepfield
623 let alignop = strpart(alignstyle,0,1)
624 let alignstyle= strpart(alignstyle,1).strpart(alignstyle,0,1)
625 " call Decho("Pass".pass.": extend field: endfield<".strpart(txt,bgnfield,endfield-bgnfield)."> alignop<".alignop."> alignstyle<".alignstyle.">")
626 endwhile
627 let seplen= sepfield - endfield
628 " call Decho("Pass".pass.": seplen=[sepfield=".sepfield."] - [endfield=".endfield."]=".seplen)
629
630 if endfield != -1
631 if pass == 1
632 " ---------------------------------------------------------------------
633 " Pass 1: Update FieldSize to max
634 " call Decho("Pass".pass.": before lead/trail remove: field<".strpart(txt,bgnfield,endfield-bgnfield).">")
635 let field = substitute(strpart(txt,bgnfield,endfield-bgnfield),'^\s*\(.\{-}\)\s*$','\1','')
636 if s:AlignLeadKeep == 'W'
637 let field = bgntxt.field
638 let bgntxt= ""
639 endif
640 if exists("g:Align_xstrlen") && g:Align_xstrlen
641 let fieldlen = s:Strlen(field)
642 else
643 let fieldlen = strlen(field)
644 endif
645 let sFieldSize = "FieldSize_".ifield
646 if !exists(sFieldSize)
647 let FieldSize_{ifield}= fieldlen
648 " call Decho("Pass".pass.": set FieldSize_{".ifield."}=".FieldSize_{ifield}." <".field.">")
649 elseif fieldlen > FieldSize_{ifield}
650 let FieldSize_{ifield}= fieldlen
651 " call Decho("Pass".pass.": oset FieldSize_{".ifield."}=".FieldSize_{ifield}." <".field.">")
652 endif
653 let sSepSize= "SepSize_".ifield
654 if !exists(sSepSize)
655 let SepSize_{ifield}= seplen
656 " call Decho(" set SepSize_{".ifield."}=".SepSize_{ifield}." <".field.">")
657 elseif seplen > SepSize_{ifield}
658 let SepSize_{ifield}= seplen
659 " call Decho("Pass".pass.": oset SepSize_{".ifield."}=".SepSize_{ifield}." <".field.">")
660 endif
661
662 else
663 " ---------------------------------------------------------------------
664 " Pass 2: Perform Alignment
665 let prepad = strpart(alignprepad,0,1)
666 let postpad = strpart(alignpostpad,0,1)
667 let alignprepad = strpart(alignprepad,1).strpart(alignprepad,0,1)
668 let alignpostpad = strpart(alignpostpad,1).strpart(alignpostpad,0,1)
669 let field = substitute(strpart(txt,bgnfield,endfield-bgnfield),'^\s*\(.\{-}\)\s*$','\1','')
670 if s:AlignLeadKeep == 'W'
671 let field = bgntxt.field
672 let bgntxt= ""
673 endif
674 if doend == 2
675 let prepad = 0
676 let postpad= 0
677 endif
678 if exists("g:Align_xstrlen") && g:Align_xstrlen
679 let fieldlen = s:Strlen(field)
680 else
681 let fieldlen = strlen(field)
682 endif
683 let sep = s:MakeSpace(prepad).strpart(txt,endfield,sepfield-endfield).s:MakeSpace(postpad)
684 if seplen < SepSize_{ifield}
685 if alignsepop == "<"
686 " left-justify separators
687 let sep = sep.s:MakeSpace(SepSize_{ifield}-seplen)
688 elseif alignsepop == ">"
689 " right-justify separators
690 let sep = s:MakeSpace(SepSize_{ifield}-seplen).sep
691 else
692 " center-justify separators
693 let sepleft = (SepSize_{ifield} - seplen)/2
694 let sepright = SepSize_{ifield} - seplen - sepleft
695 let sep = s:MakeSpace(sepleft).sep.s:MakeSpace(sepright)
696 endif
697 endif
698 let spaces = FieldSize_{ifield} - fieldlen
699 " 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.">")
700
701 " Perform alignment according to alignment style justification
702 if spaces > 0
703 if alignop == 'c'
704 " center the field
705 let spaceleft = spaces/2
706 let spaceright= FieldSize_{ifield} - spaceleft - fieldlen
707 let newtxt = newtxt.s:MakeSpace(spaceleft).field.s:MakeSpace(spaceright).sep
708 elseif alignop == 'r'
709 " right justify the field
710 let newtxt= newtxt.s:MakeSpace(spaces).field.sep
711 elseif ragged && doend == 2
712 " left justify rightmost field (no trailing blanks needed)
713 let newtxt= newtxt.field
714 else
715 " left justfiy the field
716 let newtxt= newtxt.field.s:MakeSpace(spaces).sep
717 endif
718 elseif ragged && doend == 2
719 " field at maximum field size and no trailing blanks needed
720 let newtxt= newtxt.field
721 else
722 " field is at maximum field size already
723 let newtxt= newtxt.field.sep
724 endif
725 " call Decho("Pass".pass.": newtxt<".newtxt.">")
726 endif " pass 1/2
727
728 " bgnfield indexes to end of separator at right of current field
729 " Update field counter
730 let bgnfield= sepfield
731 let ifield = ifield + 1
732 if doend == 2
733 let doend= 0
734 endif
735 " handle end-of-text as end-of-field
736 elseif doend == 1
737 let seppat = '$'
738 let doend = 2
739 else
740 let doend = 0
741 endif " endfield != -1
742 endwhile " doend loop (as well as regularly separated fields)
743
744 if pass == 2
745 " Write altered line to buffer
746 " call Decho("Pass".pass.": bgntxt<".bgntxt."> line=".line)
747 " call Decho("Pass".pass.": newtxt<".newtxt.">")
748 " call Decho("Pass".pass.": endtxt<".endtxt.">")
749 call setline(line,bgntxt.newtxt.endtxt)
750 endif
751
752 let line = line + 1
753 endwhile " line loop
754
755 let pass= pass + 1
756 endwhile " pass loop
757 " call Decho("end of two pass loop")
758
759 " Restore user options
760 let &l:et = etkeep
761 let &l:paste = pastekeep
762
763 if exists("s:DoAlignPop")
764 " AlignCtrl Map support
765 call Align#AlignPop()
766 unlet s:DoAlignPop
767 endif
768
769 " restore current search pattern
770 let @/ = keep_search
771 let &ic = keep_ic
772 let &report = keep_report
773
774 " call Dret("Align#Align")
775 return
776 endfun
777
778 " ---------------------------------------------------------------------
779 " Align#AlignPush: this command/function pushes an alignment control string onto a stack {{{1
780 fun! Align#AlignPush()
781 " call Dfunc("AlignPush()")
782
783 " initialize the stack
784 if !exists("s:AlignCtrlStackQty")
785 let s:AlignCtrlStackQty= 1
786 else
787 let s:AlignCtrlStackQty= s:AlignCtrlStackQty + 1
788 endif
789
790 " construct an AlignCtrlStack entry
791 if !exists("s:AlignSep")
792 let s:AlignSep= ''
793 endif
794 let s:AlignCtrlStack_{s:AlignCtrlStackQty}= s:AlignCtrl.'p'.s:AlignPrePad.'P'.s:AlignPostPad.s:AlignLeadKeep.s:AlignStyle.s:AlignSep
795 " call Decho("AlignPush: AlignCtrlStack_".s:AlignCtrlStackQty."<".s:AlignCtrlStack_{s:AlignCtrlStackQty}.">")
796
797 " push [GV] patterns onto their own stack
798 if exists("s:AlignGPat")
799 let s:AlignGPat_{s:AlignCtrlStackQty}= s:AlignGPat
800 else
801 let s:AlignGPat_{s:AlignCtrlStackQty}= ""
802 endif
803 if exists("s:AlignVPat")
804 let s:AlignVPat_{s:AlignCtrlStackQty}= s:AlignVPat
805 else
806 let s:AlignVPat_{s:AlignCtrlStackQty}= ""
807 endif
808
809 " call Dret("AlignPush")
810 endfun
811
812 " ---------------------------------------------------------------------
813 " Align#AlignPop: this command/function pops an alignment pattern from a stack {{{1
814 " and into the AlignCtrl variables.
815 fun! Align#AlignPop()
816 " call Dfunc("Align#AlignPop()")
817
818 " sanity checks
819 if !exists("s:AlignCtrlStackQty")
820 echoerr "AlignPush needs to be used prior to AlignPop"
821 " call Dret("Align#AlignPop <> : AlignPush needs to have been called first")
822 return ""
823 endif
824 if s:AlignCtrlStackQty <= 0
825 unlet s:AlignCtrlStackQty
826 echoerr "AlignPush needs to be used prior to AlignPop"
827 " call Dret("Align#AlignPop <> : AlignPop needs to have been called first")
828 return ""
829 endif
830
831 " pop top of AlignCtrlStack and pass value to AlignCtrl
832 let retval=s:AlignCtrlStack_{s:AlignCtrlStackQty}
833 unlet s:AlignCtrlStack_{s:AlignCtrlStackQty}
834 call Align#AlignCtrl(retval)
835
836 " pop G pattern stack
837 if s:AlignGPat_{s:AlignCtrlStackQty} != ""
838 call Align#AlignCtrl('g',s:AlignGPat_{s:AlignCtrlStackQty})
839 else
840 call Align#AlignCtrl('g')
841 endif
842 unlet s:AlignGPat_{s:AlignCtrlStackQty}
843
844 " pop V pattern stack
845 if s:AlignVPat_{s:AlignCtrlStackQty} != ""
846 call Align#AlignCtrl('v',s:AlignVPat_{s:AlignCtrlStackQty})
847 else
848 call Align#AlignCtrl('v')
849 endif
850
851 unlet s:AlignVPat_{s:AlignCtrlStackQty}
852 let s:AlignCtrlStackQty= s:AlignCtrlStackQty - 1
853
854 " call Dret("Align#AlignPop <".retval."> : AlignCtrlStackQty=".s:AlignCtrlStackQty)
855 return retval
856 endfun
857
858 " ---------------------------------------------------------------------
859 " Align#AlignReplaceQuotedSpaces: {{{1
860 fun! Align#AlignReplaceQuotedSpaces()
861 " call Dfunc("AlignReplaceQuotedSpaces()")
862
863 let l:line = getline(line("."))
864 if exists("g:Align_xstrlen") && g:Align_xstrlen
865 let l:linelen = s:Strlen(l:line)
866 else
867 let l:linelen = strlen(l:line)
868 endif
869 let l:startingPos = 0
870 let l:startQuotePos = 0
871 let l:endQuotePos = 0
872 let l:spacePos = 0
873 let l:quoteRe = '\\\@<!"'
874
875 " "call Decho("in replace spaces. line=" . line('.'))
876 while (1)
877 let l:startQuotePos = match(l:line, l:quoteRe, l:startingPos)
878 if (l:startQuotePos < 0)
879 " "call Decho("No more quotes to the end of line")
880 break
881 endif
882 let l:endQuotePos = match(l:line, l:quoteRe, l:startQuotePos + 1)
883 if (l:endQuotePos < 0)
884 " "call Decho("Mismatched quotes")
885 break
886 endif
887 let l:spaceReplaceRe = '^.\{' . (l:startQuotePos + 1) . '}.\{-}\zs\s\ze.*.\{' . (linelen - l:endQuotePos) . '}$'
888 " "call Decho('spaceReplaceRe="' . l:spaceReplaceRe . '"')
889 let l:newStr = substitute(l:line, l:spaceReplaceRe, '%', '')
890 while (l:newStr != l:line)
891 " "call Decho('newstr="' . l:newStr . '"')
892 let l:line = l:newStr
893 let l:newStr = substitute(l:line, l:spaceReplaceRe, '%', '')
894 endwhile
895 let l:startingPos = l:endQuotePos + 1
896 endwhile
897 call setline(line('.'), l:line)
898
899 " call Dret("AlignReplaceQuotedSpaces")
900 endfun
901
902 " ---------------------------------------------------------------------
903 " s:QArgSplitter: to avoid \ processing by <f-args>, <q-args> is needed. {{{1
904 " However, <q-args> doesn't split at all, so this function returns a list
905 " of arguments which has been:
906 " * split at whitespace
907 " * unless inside "..."s. One may escape characters with a backslash inside double quotes.
908 " along with a leading length-of-list.
909 "
910 " Examples: %Align "\"" will align on "s
911 " %Align " " will align on spaces
912 "
913 " The resulting list: qarglist[0] corresponds to a:0
914 " qarglist[i] corresponds to a:{i}
915 fun! s:QArgSplitter(qarg)
916 " call Dfunc("s:QArgSplitter(qarg<".a:qarg.">)")
917
918 if a:qarg =~ '".*"'
919 " handle "..." args, which may include whitespace
920 let qarglist = []
921 let args = a:qarg
922 " call Decho("handle quoted arguments: args<".args.">")
923 while args != ""
924 let iarg = 0
925 let arglen = strlen(args)
926 " call Decho("args[".iarg."]<".args[iarg]."> arglen=".arglen)
927 " find index to first not-escaped '"'
928 while args[iarg] != '"' && iarg < arglen
929 if args[iarg] == '\'
930 let args= strpart(args,1)
931 endif
932 let iarg= iarg + 1
933 endwhile
934 " call Decho("args<".args."> iarg=".iarg." arglen=".arglen)
935
936 if iarg > 0
937 " handle left of quote or remaining section
938 " call Decho("handle left of quote or remaining section")
939 if args[iarg] == '"'
940 let qarglist= qarglist + split(strpart(args,0,iarg-1))
941 else
942 let qarglist= qarglist + split(strpart(args,0,iarg))
943 endif
944 let args = strpart(args,iarg)
945 let arglen = strlen(args)
946
947 elseif iarg < arglen && args[0] == '"'
948 " handle "quoted" section
949 " call Decho("handle quoted section")
950 let iarg= 1
951 while args[iarg] != '"' && iarg < arglen
952 if args[iarg] == '\'
953 let args= strpart(args,1)
954 endif
955 let iarg= iarg + 1
956 endwhile
957 " call Decho("args<".args."> iarg=".iarg." arglen=".arglen)
958 if args[iarg] == '"'
959 call add(qarglist,strpart(args,1,iarg-1))
960 let args= strpart(args,iarg+1)
961 else
962 let qarglist = qarglist + split(args)
963 let args = ""
964 endif
965 endif
966 " call Decho("qarglist".string(qarglist)." iarg=".iarg." args<".args.">")
967 endwhile
968
969 else
970 " split at all whitespace
971 let qarglist= split(a:qarg)
972 endif
973
974 let qarglistlen= len(qarglist)
975 let qarglist = insert(qarglist,qarglistlen)
976 " call Dret("s:QArgSplitter ".string(qarglist))
977 return qarglist
978 endfun
979
980 " ---------------------------------------------------------------------
981 " s:Strlen: this function returns the length of a string, even if its {{{1
982 " using two-byte etc characters.
983 " Currently, its only used if g:Align_xstrlen is set to a
984 " nonzero value. Solution from Nicolai Weibull, vim docs
985 " (:help strlen()), Tony Mechelynck, and my own invention.
986 fun! s:Strlen(x)
987 " call Dfunc("s:Strlen(x<".a:x.">")
988 if g:Align_xstrlen == 1
989 " number of codepoints (Latin a + combining circumflex is two codepoints)
990 " (comment from TM, solution from NW)
991 let ret= strlen(substitute(a:x,'.','c','g'))
992
993 elseif g:Align_xstrlen == 2
994 " number of spacing codepoints (Latin a + combining circumflex is one spacing
995 " codepoint; a hard tab is one; wide and narrow CJK are one each; etc.)
996 " (comment from TM, solution from TM)
997 let ret=strlen(substitute(a:x, '.\Z', 'x', 'g'))
998
999 elseif g:Align_xstrlen == 3
1000 " virtual length (counting, for instance, tabs as anything between 1 and
1001 " 'tabstop', wide CJK as 2 rather than 1, Arabic alif as zero when immediately
1002 " preceded by lam, one otherwise, etc.)
1003 " (comment from TM, solution from me)
1004 let modkeep= &l:mod
1005 exe "norm! o\<esc>"
1006 call setline(line("."),a:x)
1007 let ret= virtcol("$") - 1
1008 d
1009 let &l:mod= modkeep
1010
1011 else
1012 " at least give a decent default
1013 ret= strlen(a:x)
1014 endif
1015 " call Dret("s:Strlen ".ret)
1016 return ret
1017 endfun
1018
1019 " ---------------------------------------------------------------------
1020 " Set up default values: {{{1
1021 "call Decho("-- Begin AlignCtrl Initialization --")
1022 call Align#AlignCtrl("default")
1023 "call Decho("-- End AlignCtrl Initialization --")
1024
1025 " ---------------------------------------------------------------------
1026 " Restore: {{{1
1027 let &cpo= s:keepcpo
1028 unlet s:keepcpo
1029 " vim: ts=4 fdm=marker