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
|
---|