]>
Commit | Line | Data |
---|---|---|
0d23b6e5 BB |
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 |