|
15735
|
1 " matchit.vim: (global plugin) Extended "%" matching
|
|
|
2 " autload script of matchit plugin, see ../plugin/matchit.vim
|
|
18456
|
3 " Last Change: 2019 Oct 24
|
|
15735
|
4
|
|
|
5 let s:last_mps = ""
|
|
|
6 let s:last_words = ":"
|
|
|
7 let s:patBR = ""
|
|
|
8
|
|
|
9 let s:save_cpo = &cpo
|
|
|
10 set cpo&vim
|
|
|
11
|
|
|
12 " Auto-complete mappings: (not yet "ready for prime time")
|
|
|
13 " TODO Read :help write-plugin for the "right" way to let the user
|
|
|
14 " specify a key binding.
|
|
|
15 " let g:match_auto = '<C-]>'
|
|
|
16 " let g:match_autoCR = '<C-CR>'
|
|
|
17 " if exists("g:match_auto")
|
|
|
18 " execute "inoremap " . g:match_auto . ' x<Esc>"=<SID>Autocomplete()<CR>Pls'
|
|
|
19 " endif
|
|
|
20 " if exists("g:match_autoCR")
|
|
|
21 " execute "inoremap " . g:match_autoCR . ' <CR><C-R>=<SID>Autocomplete()<CR>'
|
|
|
22 " endif
|
|
|
23 " if exists("g:match_gthhoh")
|
|
|
24 " execute "inoremap " . g:match_gthhoh . ' <C-O>:call <SID>Gthhoh()<CR>'
|
|
|
25 " endif " gthhoh = "Get the heck out of here!"
|
|
|
26
|
|
|
27 let s:notslash = '\\\@1<!\%(\\\\\)*'
|
|
|
28
|
|
|
29 function s:RestoreOptions()
|
|
|
30 " In s:CleanUp(), :execute "set" restore_options .
|
|
|
31 let restore_options = ""
|
|
|
32 if get(b:, 'match_ignorecase', &ic) != &ic
|
|
|
33 let restore_options .= (&ic ? " " : " no") . "ignorecase"
|
|
|
34 let &ignorecase = b:match_ignorecase
|
|
|
35 endif
|
|
|
36 if &ve != ''
|
|
|
37 let restore_options = " ve=" . &ve . restore_options
|
|
|
38 set ve=
|
|
|
39 endif
|
|
|
40 return restore_options
|
|
|
41 endfunction
|
|
|
42
|
|
|
43 function matchit#Match_wrapper(word, forward, mode) range
|
|
|
44 let restore_options = s:RestoreOptions()
|
|
|
45 " If this function was called from Visual mode, make sure that the cursor
|
|
|
46 " is at the correct end of the Visual range:
|
|
|
47 if a:mode == "v"
|
|
|
48 execute "normal! gv\<Esc>"
|
|
|
49 elseif a:mode == "o" && mode(1) !~# '[vV]'
|
|
|
50 exe "norm! v"
|
|
|
51 endif
|
|
|
52 " In s:CleanUp(), we may need to check whether the cursor moved forward.
|
|
|
53 let startpos = [line("."), col(".")]
|
|
|
54 " Use default behavior if called with a count.
|
|
|
55 if v:count
|
|
|
56 exe "normal! " . v:count . "%"
|
|
|
57 return s:CleanUp(restore_options, a:mode, startpos)
|
|
|
58 end
|
|
|
59
|
|
|
60 " First step: if not already done, set the script variables
|
|
|
61 " s:do_BR flag for whether there are backrefs
|
|
|
62 " s:pat parsed version of b:match_words
|
|
|
63 " s:all regexp based on s:pat and the default groups
|
|
|
64 if !exists("b:match_words") || b:match_words == ""
|
|
|
65 let match_words = ""
|
|
|
66 elseif b:match_words =~ ":"
|
|
|
67 let match_words = b:match_words
|
|
|
68 else
|
|
|
69 " Allow b:match_words = "GetVimMatchWords()" .
|
|
|
70 execute "let match_words =" b:match_words
|
|
|
71 endif
|
|
|
72 " Thanks to Preben "Peppe" Guldberg and Bram Moolenaar for this suggestion!
|
|
|
73 if (match_words != s:last_words) || (&mps != s:last_mps)
|
|
|
74 \ || exists("b:match_debug")
|
|
|
75 let s:last_mps = &mps
|
|
|
76 " quote the special chars in 'matchpairs', replace [,:] with \| and then
|
|
|
77 " append the builtin pairs (/*, */, #if, #ifdef, #ifndef, #else, #elif,
|
|
|
78 " #endif)
|
|
|
79 let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
|
|
|
80 \ '\/\*:\*\/,#\s*if\%(n\=def\)\=:#\s*else\>:#\s*elif\>:#\s*endif\>'
|
|
|
81 " s:all = pattern with all the keywords
|
|
|
82 let match_words = match_words . (strlen(match_words) ? "," : "") . default
|
|
|
83 let s:last_words = match_words
|
|
|
84 if match_words !~ s:notslash . '\\\d'
|
|
|
85 let s:do_BR = 0
|
|
|
86 let s:pat = match_words
|
|
|
87 else
|
|
|
88 let s:do_BR = 1
|
|
|
89 let s:pat = s:ParseWords(match_words)
|
|
|
90 endif
|
|
|
91 let s:all = substitute(s:pat, s:notslash . '\zs[,:]\+', '\\|', 'g')
|
|
|
92 " Just in case there are too many '\(...)' groups inside the pattern, make
|
|
|
93 " sure to use \%(...) groups, so that error E872 can be avoided
|
|
|
94 let s:all = substitute(s:all, '\\(', '\\%(', 'g')
|
|
|
95 let s:all = '\%(' . s:all . '\)'
|
|
|
96 if exists("b:match_debug")
|
|
|
97 let b:match_pat = s:pat
|
|
|
98 endif
|
|
|
99 " Reconstruct the version with unresolved backrefs.
|
|
|
100 let s:patBR = substitute(match_words.',',
|
|
|
101 \ s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
|
|
|
102 let s:patBR = substitute(s:patBR, s:notslash.'\zs:\{2,}', ':', 'g')
|
|
|
103 endif
|
|
|
104
|
|
|
105 " Second step: set the following local variables:
|
|
|
106 " matchline = line on which the cursor started
|
|
|
107 " curcol = number of characters before match
|
|
|
108 " prefix = regexp for start of line to start of match
|
|
|
109 " suffix = regexp for end of match to end of line
|
|
|
110 " Require match to end on or after the cursor and prefer it to
|
|
|
111 " start on or before the cursor.
|
|
|
112 let matchline = getline(startpos[0])
|
|
|
113 if a:word != ''
|
|
|
114 " word given
|
|
|
115 if a:word !~ s:all
|
|
|
116 echohl WarningMsg|echo 'Missing rule for word:"'.a:word.'"'|echohl NONE
|
|
|
117 return s:CleanUp(restore_options, a:mode, startpos)
|
|
|
118 endif
|
|
|
119 let matchline = a:word
|
|
|
120 let curcol = 0
|
|
|
121 let prefix = '^\%('
|
|
|
122 let suffix = '\)$'
|
|
|
123 " Now the case when "word" is not given
|
|
|
124 else " Find the match that ends on or after the cursor and set curcol.
|
|
|
125 let regexp = s:Wholematch(matchline, s:all, startpos[1]-1)
|
|
|
126 let curcol = match(matchline, regexp)
|
|
|
127 " If there is no match, give up.
|
|
|
128 if curcol == -1
|
|
|
129 return s:CleanUp(restore_options, a:mode, startpos)
|
|
|
130 endif
|
|
|
131 let endcol = matchend(matchline, regexp)
|
|
|
132 let suf = strlen(matchline) - endcol
|
|
|
133 let prefix = (curcol ? '^.*\%' . (curcol + 1) . 'c\%(' : '^\%(')
|
|
|
134 let suffix = (suf ? '\)\%' . (endcol + 1) . 'c.*$' : '\)$')
|
|
|
135 endif
|
|
|
136 if exists("b:match_debug")
|
|
|
137 let b:match_match = matchstr(matchline, regexp)
|
|
|
138 let b:match_col = curcol+1
|
|
|
139 endif
|
|
|
140
|
|
|
141 " Third step: Find the group and single word that match, and the original
|
|
|
142 " (backref) versions of these. Then, resolve the backrefs.
|
|
|
143 " Set the following local variable:
|
|
|
144 " group = colon-separated list of patterns, one of which matches
|
|
|
145 " = ini:mid:fin or ini:fin
|
|
|
146 "
|
|
|
147 " Now, set group and groupBR to the matching group: 'if:endif' or
|
|
|
148 " 'while:endwhile' or whatever. A bit of a kluge: s:Choose() returns
|
|
|
149 " group . "," . groupBR, and we pick it apart.
|
|
|
150 let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, s:patBR)
|
|
|
151 let i = matchend(group, s:notslash . ",")
|
|
|
152 let groupBR = strpart(group, i)
|
|
|
153 let group = strpart(group, 0, i-1)
|
|
|
154 " Now, matchline =~ prefix . substitute(group,':','\|','g') . suffix
|
|
|
155 if s:do_BR " Do the hard part: resolve those backrefs!
|
|
|
156 let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline)
|
|
|
157 endif
|
|
|
158 if exists("b:match_debug")
|
|
|
159 let b:match_wholeBR = groupBR
|
|
|
160 let i = matchend(groupBR, s:notslash . ":")
|
|
|
161 let b:match_iniBR = strpart(groupBR, 0, i-1)
|
|
|
162 endif
|
|
|
163
|
|
|
164 " Fourth step: Set the arguments for searchpair().
|
|
|
165 let i = matchend(group, s:notslash . ":")
|
|
|
166 let j = matchend(group, '.*' . s:notslash . ":")
|
|
|
167 let ini = strpart(group, 0, i-1)
|
|
|
168 let mid = substitute(strpart(group, i,j-i-1), s:notslash.'\zs:', '\\|', 'g')
|
|
|
169 let fin = strpart(group, j)
|
|
|
170 "Un-escape the remaining , and : characters.
|
|
|
171 let ini = substitute(ini, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
|
|
|
172 let mid = substitute(mid, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
|
|
|
173 let fin = substitute(fin, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
|
|
|
174 " searchpair() requires that these patterns avoid \(\) groups.
|
|
|
175 let ini = substitute(ini, s:notslash . '\zs\\(', '\\%(', 'g')
|
|
|
176 let mid = substitute(mid, s:notslash . '\zs\\(', '\\%(', 'g')
|
|
|
177 let fin = substitute(fin, s:notslash . '\zs\\(', '\\%(', 'g')
|
|
|
178 " Set mid. This is optimized for readability, not micro-efficiency!
|
|
|
179 if a:forward && matchline =~ prefix . fin . suffix
|
|
|
180 \ || !a:forward && matchline =~ prefix . ini . suffix
|
|
|
181 let mid = ""
|
|
|
182 endif
|
|
|
183 " Set flag. This is optimized for readability, not micro-efficiency!
|
|
|
184 if a:forward && matchline =~ prefix . fin . suffix
|
|
|
185 \ || !a:forward && matchline !~ prefix . ini . suffix
|
|
|
186 let flag = "bW"
|
|
|
187 else
|
|
|
188 let flag = "W"
|
|
|
189 endif
|
|
|
190 " Set skip.
|
|
|
191 if exists("b:match_skip")
|
|
|
192 let skip = b:match_skip
|
|
|
193 elseif exists("b:match_comment") " backwards compatibility and testing!
|
|
|
194 let skip = "r:" . b:match_comment
|
|
|
195 else
|
|
|
196 let skip = 's:comment\|string'
|
|
|
197 endif
|
|
|
198 let skip = s:ParseSkip(skip)
|
|
|
199 if exists("b:match_debug")
|
|
|
200 let b:match_ini = ini
|
|
|
201 let b:match_tail = (strlen(mid) ? mid.'\|' : '') . fin
|
|
|
202 endif
|
|
|
203
|
|
|
204 " Fifth step: actually start moving the cursor and call searchpair().
|
|
|
205 " Later, :execute restore_cursor to get to the original screen.
|
|
|
206 let view = winsaveview()
|
|
|
207 call cursor(0, curcol + 1)
|
|
|
208 if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
|
|
|
209 let skip = "0"
|
|
|
210 else
|
|
|
211 execute "if " . skip . "| let skip = '0' | endif"
|
|
|
212 endif
|
|
|
213 let sp_return = searchpair(ini, mid, fin, flag, skip)
|
|
18456
|
214 if &selection isnot# 'inclusive' && a:mode == 'v'
|
|
|
215 " move cursor one pos to the right, because selection is not inclusive
|
|
|
216 " add virtualedit=onemore, to make it work even when the match ends the " line
|
|
|
217 if !(col('.') < col('$')-1)
|
|
|
218 set ve=onemore
|
|
|
219 endif
|
|
|
220 norm! l
|
|
|
221 endif
|
|
15735
|
222 let final_position = "call cursor(" . line(".") . "," . col(".") . ")"
|
|
|
223 " Restore cursor position and original screen.
|
|
|
224 call winrestview(view)
|
|
|
225 normal! m'
|
|
|
226 if sp_return > 0
|
|
|
227 execute final_position
|
|
|
228 endif
|
|
|
229 return s:CleanUp(restore_options, a:mode, startpos, mid.'\|'.fin)
|
|
|
230 endfun
|
|
|
231
|
|
|
232 " Restore options and do some special handling for Operator-pending mode.
|
|
|
233 " The optional argument is the tail of the matching group.
|
|
|
234 fun! s:CleanUp(options, mode, startpos, ...)
|
|
|
235 if strlen(a:options)
|
|
|
236 execute "set" a:options
|
|
|
237 endif
|
|
|
238 " Open folds, if appropriate.
|
|
|
239 if a:mode != "o"
|
|
|
240 if &foldopen =~ "percent"
|
|
|
241 normal! zv
|
|
|
242 endif
|
|
|
243 " In Operator-pending mode, we want to include the whole match
|
|
|
244 " (for example, d%).
|
|
|
245 " This is only a problem if we end up moving in the forward direction.
|
|
|
246 elseif (a:startpos[0] < line(".")) ||
|
|
|
247 \ (a:startpos[0] == line(".") && a:startpos[1] < col("."))
|
|
|
248 if a:0
|
|
|
249 " Check whether the match is a single character. If not, move to the
|
|
|
250 " end of the match.
|
|
|
251 let matchline = getline(".")
|
|
|
252 let currcol = col(".")
|
|
|
253 let regexp = s:Wholematch(matchline, a:1, currcol-1)
|
|
|
254 let endcol = matchend(matchline, regexp)
|
|
|
255 if endcol > currcol " This is NOT off by one!
|
|
|
256 call cursor(0, endcol)
|
|
|
257 endif
|
|
|
258 endif " a:0
|
|
|
259 endif " a:mode != "o" && etc.
|
|
|
260 return 0
|
|
|
261 endfun
|
|
|
262
|
|
|
263 " Example (simplified HTML patterns): if
|
|
|
264 " a:groupBR = '<\(\k\+\)>:</\1>'
|
|
|
265 " a:prefix = '^.\{3}\('
|
|
|
266 " a:group = '<\(\k\+\)>:</\(\k\+\)>'
|
|
|
267 " a:suffix = '\).\{2}$'
|
|
|
268 " a:matchline = "123<tag>12" or "123</tag>12"
|
|
|
269 " then extract "tag" from a:matchline and return "<tag>:</tag>" .
|
|
|
270 fun! s:InsertRefs(groupBR, prefix, group, suffix, matchline)
|
|
|
271 if a:matchline !~ a:prefix .
|
|
|
272 \ substitute(a:group, s:notslash . '\zs:', '\\|', 'g') . a:suffix
|
|
|
273 return a:group
|
|
|
274 endif
|
|
|
275 let i = matchend(a:groupBR, s:notslash . ':')
|
|
|
276 let ini = strpart(a:groupBR, 0, i-1)
|
|
|
277 let tailBR = strpart(a:groupBR, i)
|
|
|
278 let word = s:Choose(a:group, a:matchline, ":", "", a:prefix, a:suffix,
|
|
|
279 \ a:groupBR)
|
|
|
280 let i = matchend(word, s:notslash . ":")
|
|
|
281 let wordBR = strpart(word, i)
|
|
|
282 let word = strpart(word, 0, i-1)
|
|
|
283 " Now, a:matchline =~ a:prefix . word . a:suffix
|
|
|
284 if wordBR != ini
|
|
|
285 let table = s:Resolve(ini, wordBR, "table")
|
|
|
286 else
|
|
|
287 let table = ""
|
|
|
288 let d = 0
|
|
|
289 while d < 10
|
|
|
290 if tailBR =~ s:notslash . '\\' . d
|
|
|
291 let table = table . d
|
|
|
292 else
|
|
|
293 let table = table . "-"
|
|
|
294 endif
|
|
|
295 let d = d + 1
|
|
|
296 endwhile
|
|
|
297 endif
|
|
|
298 let d = 9
|
|
|
299 while d
|
|
|
300 if table[d] != "-"
|
|
|
301 let backref = substitute(a:matchline, a:prefix.word.a:suffix,
|
|
|
302 \ '\'.table[d], "")
|
|
|
303 " Are there any other characters that should be escaped?
|
|
|
304 let backref = escape(backref, '*,:')
|
|
|
305 execute s:Ref(ini, d, "start", "len")
|
|
|
306 let ini = strpart(ini, 0, start) . backref . strpart(ini, start+len)
|
|
|
307 let tailBR = substitute(tailBR, s:notslash . '\zs\\' . d,
|
|
|
308 \ escape(backref, '\\&'), 'g')
|
|
|
309 endif
|
|
|
310 let d = d-1
|
|
|
311 endwhile
|
|
|
312 if exists("b:match_debug")
|
|
|
313 if s:do_BR
|
|
|
314 let b:match_table = table
|
|
|
315 let b:match_word = word
|
|
|
316 else
|
|
|
317 let b:match_table = ""
|
|
|
318 let b:match_word = ""
|
|
|
319 endif
|
|
|
320 endif
|
|
|
321 return ini . ":" . tailBR
|
|
|
322 endfun
|
|
|
323
|
|
|
324 " Input a comma-separated list of groups with backrefs, such as
|
|
|
325 " a:groups = '\(foo\):end\1,\(bar\):end\1'
|
|
|
326 " and return a comma-separated list of groups with backrefs replaced:
|
|
|
327 " return '\(foo\):end\(foo\),\(bar\):end\(bar\)'
|
|
|
328 fun! s:ParseWords(groups)
|
|
|
329 let groups = substitute(a:groups.",", s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
|
|
|
330 let groups = substitute(groups, s:notslash . '\zs:\{2,}', ':', 'g')
|
|
|
331 let parsed = ""
|
|
|
332 while groups =~ '[^,:]'
|
|
|
333 let i = matchend(groups, s:notslash . ':')
|
|
|
334 let j = matchend(groups, s:notslash . ',')
|
|
|
335 let ini = strpart(groups, 0, i-1)
|
|
|
336 let tail = strpart(groups, i, j-i-1) . ":"
|
|
|
337 let groups = strpart(groups, j)
|
|
|
338 let parsed = parsed . ini
|
|
|
339 let i = matchend(tail, s:notslash . ':')
|
|
|
340 while i != -1
|
|
|
341 " In 'if:else:endif', ini='if' and word='else' and then word='endif'.
|
|
|
342 let word = strpart(tail, 0, i-1)
|
|
|
343 let tail = strpart(tail, i)
|
|
|
344 let i = matchend(tail, s:notslash . ':')
|
|
|
345 let parsed = parsed . ":" . s:Resolve(ini, word, "word")
|
|
|
346 endwhile " Now, tail has been used up.
|
|
|
347 let parsed = parsed . ","
|
|
|
348 endwhile " groups =~ '[^,:]'
|
|
|
349 let parsed = substitute(parsed, ',$', '', '')
|
|
|
350 return parsed
|
|
|
351 endfun
|
|
|
352
|
|
|
353 " TODO I think this can be simplified and/or made more efficient.
|
|
|
354 " TODO What should I do if a:start is out of range?
|
|
|
355 " Return a regexp that matches all of a:string, such that
|
|
|
356 " matchstr(a:string, regexp) represents the match for a:pat that starts
|
|
|
357 " as close to a:start as possible, before being preferred to after, and
|
|
|
358 " ends after a:start .
|
|
|
359 " Usage:
|
|
|
360 " let regexp = s:Wholematch(getline("."), 'foo\|bar', col(".")-1)
|
|
|
361 " let i = match(getline("."), regexp)
|
|
|
362 " let j = matchend(getline("."), regexp)
|
|
|
363 " let match = matchstr(getline("."), regexp)
|
|
|
364 fun! s:Wholematch(string, pat, start)
|
|
|
365 let group = '\%(' . a:pat . '\)'
|
|
|
366 let prefix = (a:start ? '\(^.*\%<' . (a:start + 2) . 'c\)\zs' : '^')
|
|
|
367 let len = strlen(a:string)
|
|
|
368 let suffix = (a:start+1 < len ? '\(\%>'.(a:start+1).'c.*$\)\@=' : '$')
|
|
|
369 if a:string !~ prefix . group . suffix
|
|
|
370 let prefix = ''
|
|
|
371 endif
|
|
|
372 return prefix . group . suffix
|
|
|
373 endfun
|
|
|
374
|
|
|
375 " No extra arguments: s:Ref(string, d) will
|
|
|
376 " find the d'th occurrence of '\(' and return it, along with everything up
|
|
|
377 " to and including the matching '\)'.
|
|
|
378 " One argument: s:Ref(string, d, "start") returns the index of the start
|
|
|
379 " of the d'th '\(' and any other argument returns the length of the group.
|
|
|
380 " Two arguments: s:Ref(string, d, "foo", "bar") returns a string to be
|
|
|
381 " executed, having the effect of
|
|
|
382 " :let foo = s:Ref(string, d, "start")
|
|
|
383 " :let bar = s:Ref(string, d, "len")
|
|
|
384 fun! s:Ref(string, d, ...)
|
|
|
385 let len = strlen(a:string)
|
|
|
386 if a:d == 0
|
|
|
387 let start = 0
|
|
|
388 else
|
|
|
389 let cnt = a:d
|
|
|
390 let match = a:string
|
|
|
391 while cnt
|
|
|
392 let cnt = cnt - 1
|
|
|
393 let index = matchend(match, s:notslash . '\\(')
|
|
|
394 if index == -1
|
|
|
395 return ""
|
|
|
396 endif
|
|
|
397 let match = strpart(match, index)
|
|
|
398 endwhile
|
|
|
399 let start = len - strlen(match)
|
|
|
400 if a:0 == 1 && a:1 == "start"
|
|
|
401 return start - 2
|
|
|
402 endif
|
|
|
403 let cnt = 1
|
|
|
404 while cnt
|
|
|
405 let index = matchend(match, s:notslash . '\\(\|\\)') - 1
|
|
|
406 if index == -2
|
|
|
407 return ""
|
|
|
408 endif
|
|
|
409 " Increment if an open, decrement if a ')':
|
|
|
410 let cnt = cnt + (match[index]=="(" ? 1 : -1) " ')'
|
|
|
411 let match = strpart(match, index+1)
|
|
|
412 endwhile
|
|
|
413 let start = start - 2
|
|
|
414 let len = len - start - strlen(match)
|
|
|
415 endif
|
|
|
416 if a:0 == 1
|
|
|
417 return len
|
|
|
418 elseif a:0 == 2
|
|
|
419 return "let " . a:1 . "=" . start . "| let " . a:2 . "=" . len
|
|
|
420 else
|
|
|
421 return strpart(a:string, start, len)
|
|
|
422 endif
|
|
|
423 endfun
|
|
|
424
|
|
|
425 " Count the number of disjoint copies of pattern in string.
|
|
|
426 " If the pattern is a literal string and contains no '0' or '1' characters
|
|
|
427 " then s:Count(string, pattern, '0', '1') should be faster than
|
|
|
428 " s:Count(string, pattern).
|
|
|
429 fun! s:Count(string, pattern, ...)
|
|
|
430 let pat = escape(a:pattern, '\\')
|
|
|
431 if a:0 > 1
|
|
|
432 let foo = substitute(a:string, '[^'.a:pattern.']', "a:1", "g")
|
|
|
433 let foo = substitute(a:string, pat, a:2, "g")
|
|
|
434 let foo = substitute(foo, '[^' . a:2 . ']', "", "g")
|
|
|
435 return strlen(foo)
|
|
|
436 endif
|
|
|
437 let result = 0
|
|
|
438 let foo = a:string
|
|
|
439 let index = matchend(foo, pat)
|
|
|
440 while index != -1
|
|
|
441 let result = result + 1
|
|
|
442 let foo = strpart(foo, index)
|
|
|
443 let index = matchend(foo, pat)
|
|
|
444 endwhile
|
|
|
445 return result
|
|
|
446 endfun
|
|
|
447
|
|
|
448 " s:Resolve('\(a\)\(b\)', '\(c\)\2\1\1\2') should return table.word, where
|
|
|
449 " word = '\(c\)\(b\)\(a\)\3\2' and table = '-32-------'. That is, the first
|
|
|
450 " '\1' in target is replaced by '\(a\)' in word, table[1] = 3, and this
|
|
|
451 " indicates that all other instances of '\1' in target are to be replaced
|
|
|
452 " by '\3'. The hard part is dealing with nesting...
|
|
|
453 " Note that ":" is an illegal character for source and target,
|
|
|
454 " unless it is preceded by "\".
|
|
|
455 fun! s:Resolve(source, target, output)
|
|
|
456 let word = a:target
|
|
|
457 let i = matchend(word, s:notslash . '\\\d') - 1
|
|
|
458 let table = "----------"
|
|
|
459 while i != -2 " There are back references to be replaced.
|
|
|
460 let d = word[i]
|
|
|
461 let backref = s:Ref(a:source, d)
|
|
|
462 " The idea is to replace '\d' with backref. Before we do this,
|
|
|
463 " replace any \(\) groups in backref with :1, :2, ... if they
|
|
|
464 " correspond to the first, second, ... group already inserted
|
|
|
465 " into backref. Later, replace :1 with \1 and so on. The group
|
|
|
466 " number w+b within backref corresponds to the group number
|
|
|
467 " s within a:source.
|
|
|
468 " w = number of '\(' in word before the current one
|
|
|
469 let w = s:Count(
|
|
|
470 \ substitute(strpart(word, 0, i-1), '\\\\', '', 'g'), '\(', '1')
|
|
|
471 let b = 1 " number of the current '\(' in backref
|
|
|
472 let s = d " number of the current '\(' in a:source
|
|
|
473 while b <= s:Count(substitute(backref, '\\\\', '', 'g'), '\(', '1')
|
|
|
474 \ && s < 10
|
|
|
475 if table[s] == "-"
|
|
|
476 if w + b < 10
|
|
|
477 " let table[s] = w + b
|
|
|
478 let table = strpart(table, 0, s) . (w+b) . strpart(table, s+1)
|
|
|
479 endif
|
|
|
480 let b = b + 1
|
|
|
481 let s = s + 1
|
|
|
482 else
|
|
|
483 execute s:Ref(backref, b, "start", "len")
|
|
|
484 let ref = strpart(backref, start, len)
|
|
|
485 let backref = strpart(backref, 0, start) . ":". table[s]
|
|
|
486 \ . strpart(backref, start+len)
|
|
|
487 let s = s + s:Count(substitute(ref, '\\\\', '', 'g'), '\(', '1')
|
|
|
488 endif
|
|
|
489 endwhile
|
|
|
490 let word = strpart(word, 0, i-1) . backref . strpart(word, i+1)
|
|
|
491 let i = matchend(word, s:notslash . '\\\d') - 1
|
|
|
492 endwhile
|
|
|
493 let word = substitute(word, s:notslash . '\zs:', '\\', 'g')
|
|
|
494 if a:output == "table"
|
|
|
495 return table
|
|
|
496 elseif a:output == "word"
|
|
|
497 return word
|
|
|
498 else
|
|
|
499 return table . word
|
|
|
500 endif
|
|
|
501 endfun
|
|
|
502
|
|
|
503 " Assume a:comma = ",". Then the format for a:patterns and a:1 is
|
|
|
504 " a:patterns = "<pat1>,<pat2>,..."
|
|
|
505 " a:1 = "<alt1>,<alt2>,..."
|
|
|
506 " If <patn> is the first pattern that matches a:string then return <patn>
|
|
|
507 " if no optional arguments are given; return <patn>,<altn> if a:1 is given.
|
|
|
508 fun! s:Choose(patterns, string, comma, branch, prefix, suffix, ...)
|
|
|
509 let tail = (a:patterns =~ a:comma."$" ? a:patterns : a:patterns . a:comma)
|
|
|
510 let i = matchend(tail, s:notslash . a:comma)
|
|
|
511 if a:0
|
|
|
512 let alttail = (a:1 =~ a:comma."$" ? a:1 : a:1 . a:comma)
|
|
|
513 let j = matchend(alttail, s:notslash . a:comma)
|
|
|
514 endif
|
|
|
515 let current = strpart(tail, 0, i-1)
|
|
|
516 if a:branch == ""
|
|
|
517 let currpat = current
|
|
|
518 else
|
|
|
519 let currpat = substitute(current, s:notslash . a:branch, '\\|', 'g')
|
|
|
520 endif
|
|
|
521 while a:string !~ a:prefix . currpat . a:suffix
|
|
|
522 let tail = strpart(tail, i)
|
|
|
523 let i = matchend(tail, s:notslash . a:comma)
|
|
|
524 if i == -1
|
|
|
525 return -1
|
|
|
526 endif
|
|
|
527 let current = strpart(tail, 0, i-1)
|
|
|
528 if a:branch == ""
|
|
|
529 let currpat = current
|
|
|
530 else
|
|
|
531 let currpat = substitute(current, s:notslash . a:branch, '\\|', 'g')
|
|
|
532 endif
|
|
|
533 if a:0
|
|
|
534 let alttail = strpart(alttail, j)
|
|
|
535 let j = matchend(alttail, s:notslash . a:comma)
|
|
|
536 endif
|
|
|
537 endwhile
|
|
|
538 if a:0
|
|
|
539 let current = current . a:comma . strpart(alttail, 0, j-1)
|
|
|
540 endif
|
|
|
541 return current
|
|
|
542 endfun
|
|
|
543
|
|
|
544 fun! matchit#Match_debug()
|
|
|
545 let b:match_debug = 1 " Save debugging information.
|
|
|
546 " pat = all of b:match_words with backrefs parsed
|
|
|
547 amenu &Matchit.&pat :echo b:match_pat<CR>
|
|
|
548 " match = bit of text that is recognized as a match
|
|
|
549 amenu &Matchit.&match :echo b:match_match<CR>
|
|
|
550 " curcol = cursor column of the start of the matching text
|
|
|
551 amenu &Matchit.&curcol :echo b:match_col<CR>
|
|
|
552 " wholeBR = matching group, original version
|
|
|
553 amenu &Matchit.wh&oleBR :echo b:match_wholeBR<CR>
|
|
|
554 " iniBR = 'if' piece, original version
|
|
|
555 amenu &Matchit.ini&BR :echo b:match_iniBR<CR>
|
|
|
556 " ini = 'if' piece, with all backrefs resolved from match
|
|
|
557 amenu &Matchit.&ini :echo b:match_ini<CR>
|
|
|
558 " tail = 'else\|endif' piece, with all backrefs resolved from match
|
|
|
559 amenu &Matchit.&tail :echo b:match_tail<CR>
|
|
|
560 " fin = 'endif' piece, with all backrefs resolved from match
|
|
|
561 amenu &Matchit.&word :echo b:match_word<CR>
|
|
|
562 " '\'.d in ini refers to the same thing as '\'.table[d] in word.
|
|
|
563 amenu &Matchit.t&able :echo '0:' . b:match_table . ':9'<CR>
|
|
|
564 endfun
|
|
|
565
|
|
|
566 " Jump to the nearest unmatched "(" or "if" or "<tag>" if a:spflag == "bW"
|
|
|
567 " or the nearest unmatched "</tag>" or "endif" or ")" if a:spflag == "W".
|
|
|
568 " Return a "mark" for the original position, so that
|
|
|
569 " let m = MultiMatch("bW", "n") ... call winrestview(m)
|
|
|
570 " will return to the original position. If there is a problem, do not
|
|
|
571 " move the cursor and return {}, unless a count is given, in which case
|
|
|
572 " go up or down as many levels as possible and again return {}.
|
|
|
573 " TODO This relies on the same patterns as % matching. It might be a good
|
|
|
574 " idea to give it its own matching patterns.
|
|
|
575 fun! matchit#MultiMatch(spflag, mode)
|
|
|
576 let restore_options = s:RestoreOptions()
|
|
|
577 let startpos = [line("."), col(".")]
|
|
|
578 " save v:count1 variable, might be reset from the restore_cursor command
|
|
|
579 let level = v:count1
|
|
|
580 if a:mode == "o" && mode(1) !~# '[vV]'
|
|
|
581 exe "norm! v"
|
|
|
582 endif
|
|
|
583
|
|
|
584 " First step: if not already done, set the script variables
|
|
|
585 " s:do_BR flag for whether there are backrefs
|
|
|
586 " s:pat parsed version of b:match_words
|
|
|
587 " s:all regexp based on s:pat and the default groups
|
|
|
588 " This part is copied and slightly modified from matchit#Match_wrapper().
|
|
|
589 if !exists("b:match_words") || b:match_words == ""
|
|
|
590 let match_words = ""
|
|
|
591 " Allow b:match_words = "GetVimMatchWords()" .
|
|
|
592 elseif b:match_words =~ ":"
|
|
|
593 let match_words = b:match_words
|
|
|
594 else
|
|
|
595 execute "let match_words =" b:match_words
|
|
|
596 endif
|
|
|
597 if (match_words != s:last_words) || (&mps != s:last_mps) ||
|
|
|
598 \ exists("b:match_debug")
|
|
|
599 let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
|
|
|
600 \ '\/\*:\*\/,#\s*if\%(n\=def\)\=:#\s*else\>:#\s*elif\>:#\s*endif\>'
|
|
|
601 let s:last_mps = &mps
|
|
|
602 let match_words = match_words . (strlen(match_words) ? "," : "") . default
|
|
|
603 let s:last_words = match_words
|
|
|
604 if match_words !~ s:notslash . '\\\d'
|
|
|
605 let s:do_BR = 0
|
|
|
606 let s:pat = match_words
|
|
|
607 else
|
|
|
608 let s:do_BR = 1
|
|
|
609 let s:pat = s:ParseWords(match_words)
|
|
|
610 endif
|
|
|
611 let s:all = '\%(' . substitute(s:pat, '[,:]\+', '\\|', 'g') . '\)'
|
|
|
612 if exists("b:match_debug")
|
|
|
613 let b:match_pat = s:pat
|
|
|
614 endif
|
|
|
615 " Reconstruct the version with unresolved backrefs.
|
|
|
616 let s:patBR = substitute(match_words.',',
|
|
|
617 \ s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
|
|
|
618 let s:patBR = substitute(s:patBR, s:notslash.'\zs:\{2,}', ':', 'g')
|
|
|
619 endif
|
|
|
620
|
|
|
621 " Second step: figure out the patterns for searchpair()
|
|
|
622 " and save the screen, cursor position, and 'ignorecase'.
|
|
|
623 " - TODO: A lot of this is copied from matchit#Match_wrapper().
|
|
|
624 " - maybe even more functionality should be split off
|
|
|
625 " - into separate functions!
|
|
|
626 let openlist = split(s:pat . ',', s:notslash . '\zs:.\{-}' . s:notslash . ',')
|
|
|
627 let midclolist = split(',' . s:pat, s:notslash . '\zs,.\{-}' . s:notslash . ':')
|
|
|
628 call map(midclolist, {-> split(v:val, s:notslash . ':')})
|
|
|
629 let closelist = []
|
|
|
630 let middlelist = []
|
|
|
631 call map(midclolist, {i,v -> [extend(closelist, v[-1 : -1]),
|
|
|
632 \ extend(middlelist, v[0 : -2])]})
|
|
|
633 call map(openlist, {i,v -> v =~# s:notslash . '\\|' ? '\%(' . v . '\)' : v})
|
|
|
634 call map(middlelist, {i,v -> v =~# s:notslash . '\\|' ? '\%(' . v . '\)' : v})
|
|
|
635 call map(closelist, {i,v -> v =~# s:notslash . '\\|' ? '\%(' . v . '\)' : v})
|
|
|
636 let open = join(openlist, ',')
|
|
|
637 let middle = join(middlelist, ',')
|
|
|
638 let close = join(closelist, ',')
|
|
|
639 if exists("b:match_skip")
|
|
|
640 let skip = b:match_skip
|
|
|
641 elseif exists("b:match_comment") " backwards compatibility and testing!
|
|
|
642 let skip = "r:" . b:match_comment
|
|
|
643 else
|
|
|
644 let skip = 's:comment\|string'
|
|
|
645 endif
|
|
|
646 let skip = s:ParseSkip(skip)
|
|
|
647 let view = winsaveview()
|
|
|
648
|
|
|
649 " Third step: call searchpair().
|
|
|
650 " Replace '\('--but not '\\('--with '\%(' and ',' with '\|'.
|
|
|
651 let openpat = substitute(open, '\%(' . s:notslash . '\)\@<=\\(', '\\%(', 'g')
|
|
|
652 let openpat = substitute(openpat, ',', '\\|', 'g')
|
|
|
653 let closepat = substitute(close, '\%(' . s:notslash . '\)\@<=\\(', '\\%(', 'g')
|
|
|
654 let closepat = substitute(closepat, ',', '\\|', 'g')
|
|
|
655 let middlepat = substitute(middle, '\%(' . s:notslash . '\)\@<=\\(', '\\%(', 'g')
|
|
|
656 let middlepat = substitute(middlepat, ',', '\\|', 'g')
|
|
|
657
|
|
|
658 if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
|
|
|
659 let skip = '0'
|
|
|
660 else
|
|
|
661 try
|
|
|
662 execute "if " . skip . "| let skip = '0' | endif"
|
|
|
663 catch /^Vim\%((\a\+)\)\=:E363/
|
|
|
664 " We won't find anything, so skip searching, should keep Vim responsive.
|
|
|
665 return {}
|
|
|
666 endtry
|
|
|
667 endif
|
|
|
668 mark '
|
|
|
669 while level
|
|
|
670 if searchpair(openpat, middlepat, closepat, a:spflag, skip) < 1
|
|
|
671 call s:CleanUp(restore_options, a:mode, startpos)
|
|
|
672 return {}
|
|
|
673 endif
|
|
|
674 let level = level - 1
|
|
|
675 endwhile
|
|
|
676
|
|
|
677 " Restore options and return a string to restore the original position.
|
|
|
678 call s:CleanUp(restore_options, a:mode, startpos)
|
|
|
679 return view
|
|
|
680 endfun
|
|
|
681
|
|
|
682 " Search backwards for "if" or "while" or "<tag>" or ...
|
|
|
683 " and return "endif" or "endwhile" or "</tag>" or ... .
|
|
|
684 " For now, this uses b:match_words and the same script variables
|
|
|
685 " as matchit#Match_wrapper() . Later, it may get its own patterns,
|
|
|
686 " either from a buffer variable or passed as arguments.
|
|
|
687 " fun! s:Autocomplete()
|
|
|
688 " echo "autocomplete not yet implemented :-("
|
|
|
689 " if !exists("b:match_words") || b:match_words == ""
|
|
|
690 " return ""
|
|
|
691 " end
|
|
|
692 " let startpos = matchit#MultiMatch("bW")
|
|
|
693 "
|
|
|
694 " if startpos == ""
|
|
|
695 " return ""
|
|
|
696 " endif
|
|
|
697 " " - TODO: figure out whether 'if' or '<tag>' matched, and construct
|
|
|
698 " " - the appropriate closing.
|
|
|
699 " let matchline = getline(".")
|
|
|
700 " let curcol = col(".") - 1
|
|
|
701 " " - TODO: Change the s:all argument if there is a new set of match pats.
|
|
|
702 " let regexp = s:Wholematch(matchline, s:all, curcol)
|
|
|
703 " let suf = strlen(matchline) - matchend(matchline, regexp)
|
|
|
704 " let prefix = (curcol ? '^.\{' . curcol . '}\%(' : '^\%(')
|
|
|
705 " let suffix = (suf ? '\).\{' . suf . '}$' : '\)$')
|
|
|
706 " " Reconstruct the version with unresolved backrefs.
|
|
|
707 " let patBR = substitute(b:match_words.',', '[,:]*,[,:]*', ',', 'g')
|
|
|
708 " let patBR = substitute(patBR, ':\{2,}', ':', "g")
|
|
|
709 " " Now, set group and groupBR to the matching group: 'if:endif' or
|
|
|
710 " " 'while:endwhile' or whatever.
|
|
|
711 " let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, patBR)
|
|
|
712 " let i = matchend(group, s:notslash . ",")
|
|
|
713 " let groupBR = strpart(group, i)
|
|
|
714 " let group = strpart(group, 0, i-1)
|
|
|
715 " " Now, matchline =~ prefix . substitute(group,':','\|','g') . suffix
|
|
|
716 " if s:do_BR
|
|
|
717 " let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline)
|
|
|
718 " endif
|
|
|
719 " " let g:group = group
|
|
|
720 "
|
|
|
721 " " - TODO: Construct the closing from group.
|
|
|
722 " let fake = "end" . expand("<cword>")
|
|
|
723 " execute startpos
|
|
|
724 " return fake
|
|
|
725 " endfun
|
|
|
726
|
|
|
727 " Close all open structures. "Get the heck out of here!"
|
|
|
728 " fun! s:Gthhoh()
|
|
|
729 " let close = s:Autocomplete()
|
|
|
730 " while strlen(close)
|
|
|
731 " put=close
|
|
|
732 " let close = s:Autocomplete()
|
|
|
733 " endwhile
|
|
|
734 " endfun
|
|
|
735
|
|
|
736 " Parse special strings as typical skip arguments for searchpair():
|
|
|
737 " s:foo becomes (current syntax item) =~ foo
|
|
|
738 " S:foo becomes (current syntax item) !~ foo
|
|
|
739 " r:foo becomes (line before cursor) =~ foo
|
|
|
740 " R:foo becomes (line before cursor) !~ foo
|
|
|
741 fun! s:ParseSkip(str)
|
|
|
742 let skip = a:str
|
|
|
743 if skip[1] == ":"
|
|
|
744 if skip[0] == "s"
|
|
|
745 let skip = "synIDattr(synID(line('.'),col('.'),1),'name') =~? '" .
|
|
|
746 \ strpart(skip,2) . "'"
|
|
|
747 elseif skip[0] == "S"
|
|
|
748 let skip = "synIDattr(synID(line('.'),col('.'),1),'name') !~? '" .
|
|
|
749 \ strpart(skip,2) . "'"
|
|
|
750 elseif skip[0] == "r"
|
|
|
751 let skip = "strpart(getline('.'),0,col('.'))=~'" . strpart(skip,2). "'"
|
|
|
752 elseif skip[0] == "R"
|
|
|
753 let skip = "strpart(getline('.'),0,col('.'))!~'" . strpart(skip,2). "'"
|
|
|
754 endif
|
|
|
755 endif
|
|
|
756 return skip
|
|
|
757 endfun
|
|
|
758
|
|
|
759 let &cpo = s:save_cpo
|
|
|
760 unlet s:save_cpo
|
|
|
761
|
|
|
762 " vim:sts=2:sw=2:et:
|
