vim: runtime/pack/dist/opt/matchit/autoload/matchit.vim comparison

comparison runtime/pack/dist/opt/matchit/autoload/matchit.vim @ 26708:f0d7cb510ce3

Update runtime files Commit: https://github.com/vim/vim/commit/fa3b72348d88343390fbe212cfc230fec1602fc2 Author: Bram Moolenaar <Bram@vim.org> Date: Fri Dec 24 13:18:38 2021 +0000 Update runtime files

author	Bram Moolenaar <Bram@vim.org>
date	Fri, 24 Dec 2021 14:30:04 +0100
parents	d4deb2e50667
children	5825405e4e2c

comparison

equal deleted inserted replaced

-:d1af15dbf206
+:f0d7cb510ce3
 "  matchit.vim: (global plugin) Extended "%" matching
 "  autload script of matchit plugin, see ../plugin/matchit.vim
-"  Last Change: Mar 01, 2020
+"  Last Change: Jun 10, 2021
+" Neovim does not support scriptversion
+if has("vimscript-4")
+scriptversion 4
+endif
 let s:last_mps = ""
 let s:last_words = ":"
 let s:patBR = ""
 function s:RestoreOptions()
 " In s:CleanUp(), :execute "set" restore_options .
 let restore_options = ""
 if get(b:, 'match_ignorecase', &ic) != &ic
-let restore_options .= (&ic ? " " : " no") . "ignorecase"
+let restore_options ..= (&ic ? " " : " no") .. "ignorecase"
 let &ignorecase = b:match_ignorecase
 endif
 if &ve != ''
-let restore_options = " ve=" . &ve . restore_options
+let restore_options = " ve=" .. &ve .. restore_options
 set ve=
 endif
 return restore_options
 endfunction
 function matchit#Match_wrapper(word, forward, mode) range
 let restore_options = s:RestoreOptions()
+" In s:CleanUp(), we may need to check whether the cursor moved forward.
+let startpos = [line("."), col(".")]
+" if a count has been applied, use the default [count]% mode (see :h N%)
+if v:count
+exe "normal! " .. v:count .. "%"
+return s:CleanUp(restore_options, a:mode, startpos)
+end
+if a:mode =~# "v" && mode(1) =~# 'ni'
+exe "norm! gv"
+elseif a:mode == "o" && mode(1) !~# '[vV]'
+exe "norm! v"
 " If this function was called from Visual mode, make sure that the cursor
 " is at the correct end of the Visual range:
-if a:mode == "v"
+elseif a:mode == "v"
 execute "normal! gv\<Esc>"
-elseif a:mode == "o" && mode(1) !~# '[vV]'
+let startpos = [line("."), col(".")]
-exe "norm! v"
+endif
-elseif a:mode == "n" && mode(1) =~# 'ni'
-exe "norm! v"
-endif
-" In s:CleanUp(), we may need to check whether the cursor moved forward.
-let startpos = [line("."), col(".")]
-" Use default behavior if called with a count.
-if v:count
-exe "normal! " . v:count . "%"
-return s:CleanUp(restore_options, a:mode, startpos)
-end
 " First step:  if not already done, set the script variables
 "   s:do_BR   flag for whether there are backrefs
 "   s:pat     parsed version of b:match_words
 "   s:all     regexp based on s:pat and the default groups
 \ || exists("b:match_debug")
 let s:last_mps = &mps
 " quote the special chars in 'matchpairs', replace [,:] with \| and then
 " append the builtin pairs (/*, */, #if, #ifdef, #ifndef, #else, #elif,
 " #endif)
-let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
+let default = escape(&mps, '[$^.*~\\/?]') .. (strlen(&mps) ? "," : "") ..
 \ '\/\*:\*\/,#\s*if\%(n\=def\)\=:#\s*else\>:#\s*elif\>:#\s*endif\>'
 " s:all = pattern with all the keywords
-let match_words = match_words . (strlen(match_words) ? "," : "") . default
+let match_words = match_words .. (strlen(match_words) ? "," : "") .. default
 let s:last_words = match_words
-if match_words !~ s:notslash . '\\\d'
+if match_words !~ s:notslash .. '\\\d'
 let s:do_BR = 0
 let s:pat = match_words
 else
 let s:do_BR = 1
 let s:pat = s:ParseWords(match_words)
 endif
-let s:all = substitute(s:pat, s:notslash . '\zs[,:]\+', '\\|', 'g')
+let s:all = substitute(s:pat, s:notslash .. '\zs[,:]\+', '\\|', 'g')
 " Just in case there are too many '\(...)' groups inside the pattern, make
 " sure to use \%(...) groups, so that error E872 can be avoided
 let s:all = substitute(s:all, '\\(', '\\%(', 'g')
-let s:all = '\%(' . s:all . '\)'
+let s:all = '\%(' .. s:all .. '\)'
 if exists("b:match_debug")
 let b:match_pat = s:pat
 endif
 " Reconstruct the version with unresolved backrefs.
-let s:patBR = substitute(match_words.',',
+let s:patBR = substitute(match_words .. ',',
-\ s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
+\ s:notslash .. '\zs[,:]*,[,:]*', ',', 'g')
-let s:patBR = substitute(s:patBR, s:notslash.'\zs:\{2,}', ':', 'g')
+let s:patBR = substitute(s:patBR, s:notslash .. '\zs:\{2,}', ':', 'g')
 endif
 " Second step:  set the following local variables:
 "     matchline = line on which the cursor started
 "     curcol    = number of characters before match
 else  " Find the match that ends on or after the cursor and set curcol.
 let regexp = s:Wholematch(matchline, s:all, startpos[1]-1)
 let curcol = match(matchline, regexp)
 " If there is no match, give up.
 if curcol == -1
+" Make sure macros abort properly
+"exe "norm! \<esc>"
+call feedkeys("\e", 'tni')
 return s:CleanUp(restore_options, a:mode, startpos)
 endif
 let endcol = matchend(matchline, regexp)
 let suf = strlen(matchline) - endcol
-let prefix = (curcol ? '^.*\%'  . (curcol + 1) . 'c\%(' : '^\%(')
+let prefix = (curcol ? '^.*\%' .. (curcol + 1) .. 'c\%(' : '^\%(')
-let suffix = (suf ? '\)\%' . (endcol + 1) . 'c.*$'  : '\)$')
+let suffix = (suf ? '\)\%' .. (endcol + 1) .. 'c.*$'  : '\)$')
 endif
 if exists("b:match_debug")
 let b:match_match = matchstr(matchline, regexp)
 let b:match_col = curcol+1
 endif
 "
 " Now, set group and groupBR to the matching group: 'if:endif' or
 " 'while:endwhile' or whatever.  A bit of a kluge:  s:Choose() returns
 " group . "," . groupBR, and we pick it apart.
 let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, s:patBR)
-let i = matchend(group, s:notslash . ",")
+let i = matchend(group, s:notslash .. ",")
 let groupBR = strpart(group, i)
 let group = strpart(group, 0, i-1)
 " Now, matchline =~ prefix . substitute(group,':','\|','g') . suffix
 if s:do_BR " Do the hard part:  resolve those backrefs!
 let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline)
 endif
 if exists("b:match_debug")
 let b:match_wholeBR = groupBR
-let i = matchend(groupBR, s:notslash . ":")
+let i = matchend(groupBR, s:notslash .. ":")
 let b:match_iniBR = strpart(groupBR, 0, i-1)
 endif
 " Fourth step:  Set the arguments for searchpair().
-let i = matchend(group, s:notslash . ":")
+let i = matchend(group, s:notslash .. ":")
-let j = matchend(group, '.*' . s:notslash . ":")
+let j = matchend(group, '.*' .. s:notslash .. ":")
 let ini = strpart(group, 0, i-1)
-let mid = substitute(strpart(group, i,j-i-1), s:notslash.'\zs:', '\\|', 'g')
+let mid = substitute(strpart(group, i,j-i-1), s:notslash .. '\zs:', '\\|', 'g')
 let fin = strpart(group, j)
 "Un-escape the remaining , and : characters.
-let ini = substitute(ini, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
+let ini = substitute(ini, s:notslash .. '\zs\\\(:\|,\)', '\1', 'g')
-let mid = substitute(mid, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
+let mid = substitute(mid, s:notslash .. '\zs\\\(:\|,\)', '\1', 'g')
-let fin = substitute(fin, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
+let fin = substitute(fin, s:notslash .. '\zs\\\(:\|,\)', '\1', 'g')
 " searchpair() requires that these patterns avoid \(\) groups.
-let ini = substitute(ini, s:notslash . '\zs\\(', '\\%(', 'g')
+let ini = substitute(ini, s:notslash .. '\zs\\(', '\\%(', 'g')
-let mid = substitute(mid, s:notslash . '\zs\\(', '\\%(', 'g')
+let mid = substitute(mid, s:notslash .. '\zs\\(', '\\%(', 'g')
-let fin = substitute(fin, s:notslash . '\zs\\(', '\\%(', 'g')
+let fin = substitute(fin, s:notslash .. '\zs\\(', '\\%(', 'g')
 " Set mid.  This is optimized for readability, not micro-efficiency!
-if a:forward && matchline =~ prefix . fin . suffix
+if a:forward && matchline =~ prefix .. fin .. suffix
-\ || !a:forward && matchline =~ prefix . ini . suffix
+\ || !a:forward && matchline =~ prefix .. ini .. suffix
 let mid = ""
 endif
 " Set flag.  This is optimized for readability, not micro-efficiency!
-if a:forward && matchline =~ prefix . fin . suffix
+if a:forward && matchline =~ prefix .. fin .. suffix
-\ || !a:forward && matchline !~ prefix . ini . suffix
+\ || !a:forward && matchline !~ prefix .. ini .. suffix
 let flag = "bW"
 else
 let flag = "W"
 endif
 " Set skip.
 if exists("b:match_skip")
 let skip = b:match_skip
 elseif exists("b:match_comment") " backwards compatibility and testing!
-let skip = "r:" . b:match_comment
+let skip = "r:" .. b:match_comment
 else
 let skip = 's:comment\|string'
 endif
 let skip = s:ParseSkip(skip)
 if exists("b:match_debug")
 let b:match_ini = ini
-let b:match_tail = (strlen(mid) ? mid.'\|' : '') . fin
+let b:match_tail = (strlen(mid) ? mid .. '\|' : '') .. fin
 endif
 " Fifth step:  actually start moving the cursor and call searchpair().
 " Later, :execute restore_cursor to get to the original screen.
 let view = winsaveview()
 call cursor(0, curcol + 1)
 if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
 let skip = "0"
 else
-execute "if " . skip . "| let skip = '0' | endif"
+execute "if " .. skip .. "| let skip = '0' | endif"
 endif
 let sp_return = searchpair(ini, mid, fin, flag, skip)
 if &selection isnot# 'inclusive' && a:mode == 'v'
 " move cursor one pos to the right, because selection is not inclusive
-" add virtualedit=onemore, to make it work even when the match ends the " line
+" add virtualedit=onemore, to make it work even when the match ends the
+" line
 if !(col('.') < col('$')-1)
-set ve=onemore
+let eolmark=1 " flag to set a mark on eol (since we cannot move there)
 endif
 norm! l
 endif
-let final_position = "call cursor(" . line(".") . "," . col(".") . ")"
+let final_position = "call cursor(" .. line(".") .. "," .. col(".") .. ")"
 " Restore cursor position and original screen.
 call winrestview(view)
 normal! m'
 if sp_return > 0
 execute final_position
 endif
-return s:CleanUp(restore_options, a:mode, startpos, mid.'\|'.fin)
+if exists('eolmark') && eolmark
+call setpos("''", [0, line('.'), col('$'), 0]) " set mark on the eol
+endif
+return s:CleanUp(restore_options, a:mode, startpos, mid .. '\|' .. fin)
 endfun
 " Restore options and do some special handling for Operator-pending mode.
 " The optional argument is the tail of the matching group.
 fun! s:CleanUp(options, mode, startpos, ...)
 "   a:group     = '<\(\k\+\)>:</\(\k\+\)>'
 "   a:suffix    = '\).\{2}$'
 "   a:matchline =  "123<tag>12" or "123</tag>12"
 " then extract "tag" from a:matchline and return "<tag>:</tag>" .
 fun! s:InsertRefs(groupBR, prefix, group, suffix, matchline)
-if a:matchline !~ a:prefix .
+if a:matchline !~ a:prefix ..
-\ substitute(a:group, s:notslash . '\zs:', '\\|', 'g') . a:suffix
+\ substitute(a:group, s:notslash .. '\zs:', '\\|', 'g') .. a:suffix
 return a:group
 endif
-let i = matchend(a:groupBR, s:notslash . ':')
+let i = matchend(a:groupBR, s:notslash .. ':')
 let ini = strpart(a:groupBR, 0, i-1)
 let tailBR = strpart(a:groupBR, i)
 let word = s:Choose(a:group, a:matchline, ":", "", a:prefix, a:suffix,
 \ a:groupBR)
-let i = matchend(word, s:notslash . ":")
+let i = matchend(word, s:notslash .. ":")
 let wordBR = strpart(word, i)
 let word = strpart(word, 0, i-1)
 " Now, a:matchline =~ a:prefix . word . a:suffix
 if wordBR != ini
 let table = s:Resolve(ini, wordBR, "table")
 else
 let table = ""
 let d = 0
 while d < 10
-if tailBR =~ s:notslash . '\\' . d
+if tailBR =~ s:notslash .. '\\' .. d
-let table = table . d
+let table = table .. d
 else
-let table = table . "-"
+let table = table .. "-"
 endif
 let d = d + 1
 endwhile
 endif
 let d = 9
 while d
 if table[d] != "-"
-let backref = substitute(a:matchline, a:prefix.word.a:suffix,
+let backref = substitute(a:matchline, a:prefix .. word .. a:suffix,
-\ '\'.table[d], "")
+\ '\' .. table[d], "")
 " Are there any other characters that should be escaped?
 let backref = escape(backref, '*,:')
 execute s:Ref(ini, d, "start", "len")
-let ini = strpart(ini, 0, start) . backref . strpart(ini, start+len)
+let ini = strpart(ini, 0, start) .. backref .. strpart(ini, start+len)
-let tailBR = substitute(tailBR, s:notslash . '\zs\\' . d,
+let tailBR = substitute(tailBR, s:notslash .. '\zs\\' .. d,
 \ escape(backref, '\\&'), 'g')
 endif
 let d = d-1
 endwhile
 if exists("b:match_debug")
 else
 let b:match_table = ""
 let b:match_word = ""
 endif
 endif
-return ini . ":" . tailBR
+return ini .. ":" .. tailBR
 endfun
 " Input a comma-separated list of groups with backrefs, such as
 "   a:groups = '\(foo\):end\1,\(bar\):end\1'
 " and return a comma-separated list of groups with backrefs replaced:
 "   return '\(foo\):end\(foo\),\(bar\):end\(bar\)'
 fun! s:ParseWords(groups)
-let groups = substitute(a:groups.",", s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
+let groups = substitute(a:groups .. ",", s:notslash .. '\zs[,:]*,[,:]*', ',', 'g')
-let groups = substitute(groups, s:notslash . '\zs:\{2,}', ':', 'g')
+let groups = substitute(groups, s:notslash .. '\zs:\{2,}', ':', 'g')
 let parsed = ""
 while groups =~ '[^,:]'
-let i = matchend(groups, s:notslash . ':')
+let i = matchend(groups, s:notslash .. ':')
-let j = matchend(groups, s:notslash . ',')
+let j = matchend(groups, s:notslash .. ',')
 let ini = strpart(groups, 0, i-1)
-let tail = strpart(groups, i, j-i-1) . ":"
+let tail = strpart(groups, i, j-i-1) .. ":"
 let groups = strpart(groups, j)
-let parsed = parsed . ini
+let parsed = parsed .. ini
-let i = matchend(tail, s:notslash . ':')
+let i = matchend(tail, s:notslash .. ':')
 while i != -1
 " In 'if:else:endif', ini='if' and word='else' and then word='endif'.
 let word = strpart(tail, 0, i-1)
 let tail = strpart(tail, i)
-let i = matchend(tail, s:notslash . ':')
+let i = matchend(tail, s:notslash .. ':')
-let parsed = parsed . ":" . s:Resolve(ini, word, "word")
+let parsed = parsed .. ":" .. s:Resolve(ini, word, "word")
 endwhile " Now, tail has been used up.
-let parsed = parsed . ","
+let parsed = parsed .. ","
 endwhile " groups =~ '[^,:]'
 let parsed = substitute(parsed, ',$', '', '')
 return parsed
 endfun
 " let regexp = s:Wholematch(getline("."), 'foo\|bar', col(".")-1)
 " let i      = match(getline("."), regexp)
 " let j      = matchend(getline("."), regexp)
 " let match  = matchstr(getline("."), regexp)
 fun! s:Wholematch(string, pat, start)
-let group = '\%(' . a:pat . '\)'
+let group = '\%(' .. a:pat .. '\)'
-let prefix = (a:start ? '\(^.*\%<' . (a:start + 2) . 'c\)\zs' : '^')
+let prefix = (a:start ? '\(^.*\%<' .. (a:start + 2) .. 'c\)\zs' : '^')
 let len = strlen(a:string)
-let suffix = (a:start+1 < len ? '\(\%>'.(a:start+1).'c.*$\)\@=' : '$')
+let suffix = (a:start+1 < len ? '\(\%>' .. (a:start+1) .. 'c.*$\)\@=' : '$')
-if a:string !~ prefix . group . suffix
+if a:string !~ prefix .. group .. suffix
 let prefix = ''
 endif
-return prefix . group . suffix
+return prefix .. group .. suffix
 endfun
 " No extra arguments:  s:Ref(string, d) will
 " find the d'th occurrence of '\(' and return it, along with everything up
 " to and including the matching '\)'.
 else
 let cnt = a:d
 let match = a:string
 while cnt
 let cnt = cnt - 1
-let index = matchend(match, s:notslash . '\\(')
+let index = matchend(match, s:notslash .. '\\(')
 if index == -1
 return ""
 endif
 let match = strpart(match, index)
 endwhile
 if a:0 == 1 && a:1 == "start"
 return start - 2
 endif
 let cnt = 1
 while cnt
-let index = matchend(match, s:notslash . '\\(\|\\)') - 1
+let index = matchend(match, s:notslash .. '\\(\|\\)') - 1
 if index == -2
 return ""
 endif
 " Increment if an open, decrement if a ')':
 let cnt = cnt + (match[index]=="(" ? 1 : -1)  " ')'
 let len = len - start - strlen(match)
 endif
 if a:0 == 1
 return len
 elseif a:0 == 2
-return "let " . a:1 . "=" . start . "| let " . a:2 . "=" . len
+return "let " .. a:1 .. "=" .. start .. "| let " .. a:2 .. "=" .. len
 else
 return strpart(a:string, start, len)
 endif
 endfun
 " then s:Count(string, pattern, '0', '1') should be faster than
 " s:Count(string, pattern).
 fun! s:Count(string, pattern, ...)
 let pat = escape(a:pattern, '\\')
 if a:0 > 1
-let foo = substitute(a:string, '[^'.a:pattern.']', "a:1", "g")
+let foo = substitute(a:string, '[^' .. a:pattern .. ']', "a:1", "g")
 let foo = substitute(a:string, pat, a:2, "g")
-let foo = substitute(foo, '[^' . a:2 . ']', "", "g")
+let foo = substitute(foo, '[^' .. a:2 .. ']', "", "g")
 return strlen(foo)
 endif
 let result = 0
 let foo = a:string
 let index = matchend(foo, pat)
 " by '\3'.  The hard part is dealing with nesting...
 " Note that ":" is an illegal character for source and target,
 " unless it is preceded by "\".
 fun! s:Resolve(source, target, output)
 let word = a:target
-let i = matchend(word, s:notslash . '\\\d') - 1
+let i = matchend(word, s:notslash .. '\\\d') - 1
 let table = "----------"
 while i != -2 " There are back references to be replaced.
 let d = word[i]
 let backref = s:Ref(a:source, d)
 " The idea is to replace '\d' with backref.  Before we do this,
 while b <= s:Count(substitute(backref, '\\\\', '', 'g'), '\(', '1')
 \ && s < 10
 if table[s] == "-"
 if w + b < 10
 " let table[s] = w + b
-let table = strpart(table, 0, s) . (w+b) . strpart(table, s+1)
+let table = strpart(table, 0, s) .. (w+b) .. strpart(table, s+1)
 endif
 let b = b + 1
 let s = s + 1
 else
 execute s:Ref(backref, b, "start", "len")
 let ref = strpart(backref, start, len)
-let backref = strpart(backref, 0, start) . ":". table[s]
+let backref = strpart(backref, 0, start) .. ":" .. table[s]
-\ . strpart(backref, start+len)
+\ .. strpart(backref, start+len)
 let s = s + s:Count(substitute(ref, '\\\\', '', 'g'), '\(', '1')
 endif
 endwhile
-let word = strpart(word, 0, i-1) . backref . strpart(word, i+1)
+let word = strpart(word, 0, i-1) .. backref .. strpart(word, i+1)
-let i = matchend(word, s:notslash . '\\\d') - 1
+let i = matchend(word, s:notslash .. '\\\d') - 1
 endwhile
-let word = substitute(word, s:notslash . '\zs:', '\\', 'g')
+let word = substitute(word, s:notslash .. '\zs:', '\\', 'g')
 if a:output == "table"
 return table
 elseif a:output == "word"
 return word
 else
-return table . word
+return table .. word
 endif
 endfun
 " Assume a:comma = ",".  Then the format for a:patterns and a:1 is
 "   a:patterns = "<pat1>,<pat2>,..."
 "   a:1 = "<alt1>,<alt2>,..."
 " If <patn> is the first pattern that matches a:string then return <patn>
 " if no optional arguments are given; return <patn>,<altn> if a:1 is given.
 fun! s:Choose(patterns, string, comma, branch, prefix, suffix, ...)
-let tail = (a:patterns =~ a:comma."$" ? a:patterns : a:patterns . a:comma)
+let tail = (a:patterns =~ a:comma .. "$" ? a:patterns : a:patterns .. a:comma)
-let i = matchend(tail, s:notslash . a:comma)
+let i = matchend(tail, s:notslash .. a:comma)
 if a:0
-let alttail = (a:1 =~ a:comma."$" ? a:1 : a:1 . a:comma)
+let alttail = (a:1 =~ a:comma .. "$" ? a:1 : a:1 .. a:comma)
-let j = matchend(alttail, s:notslash . a:comma)
+let j = matchend(alttail, s:notslash .. a:comma)
 endif
 let current = strpart(tail, 0, i-1)
 if a:branch == ""
 let currpat = current
 else
-let currpat = substitute(current, s:notslash . a:branch, '\\|', 'g')
+let currpat = substitute(current, s:notslash .. a:branch, '\\|', 'g')
 endif
-while a:string !~ a:prefix . currpat . a:suffix
+while a:string !~ a:prefix .. currpat .. a:suffix
 let tail = strpart(tail, i)
-let i = matchend(tail, s:notslash . a:comma)
+let i = matchend(tail, s:notslash .. a:comma)
 if i == -1
 return -1
 endif
 let current = strpart(tail, 0, i-1)
 if a:branch == ""
 let currpat = current
 else
-let currpat = substitute(current, s:notslash . a:branch, '\\|', 'g')
+let currpat = substitute(current, s:notslash .. a:branch, '\\|', 'g')
 endif
 if a:0
 let alttail = strpart(alttail, j)
-let j = matchend(alttail, s:notslash . a:comma)
+let j = matchend(alttail, s:notslash .. a:comma)
 endif
 endwhile
 if a:0
-let current = current . a:comma . strpart(alttail, 0, j-1)
+let current = current .. a:comma .. strpart(alttail, 0, j-1)
 endif
 return current
 endfun
 fun! matchit#Match_debug()
 " tail = 'else\|endif' piece, with all backrefs resolved from match
 amenu &Matchit.&tail  :echo b:match_tail<CR>
 " fin = 'endif' piece, with all backrefs resolved from match
 amenu &Matchit.&word  :echo b:match_word<CR>
 " '\'.d in ini refers to the same thing as '\'.table[d] in word.
-amenu &Matchit.t&able :echo '0:' . b:match_table . ':9'<CR>
+amenu &Matchit.t&able :echo '0:' .. b:match_table .. ':9'<CR>
 endfun
 " Jump to the nearest unmatched "(" or "if" or "<tag>" if a:spflag == "bW"
 " or the nearest unmatched "</tag>" or "endif" or ")" if a:spflag == "W".
 " Return a "mark" for the original position, so that
 else
 execute "let match_words =" b:match_words
 endif
 if (match_words != s:last_words) || (&mps != s:last_mps) ||
 \ exists("b:match_debug")
-let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
+let default = escape(&mps, '[$^.*~\\/?]') .. (strlen(&mps) ? "," : "") ..
 \ '\/\*:\*\/,#\s*if\%(n\=def\)\=:#\s*else\>:#\s*elif\>:#\s*endif\>'
 let s:last_mps = &mps
-let match_words = match_words . (strlen(match_words) ? "," : "") . default
+let match_words = match_words .. (strlen(match_words) ? "," : "") .. default
 let s:last_words = match_words
-if match_words !~ s:notslash . '\\\d'
+if match_words !~ s:notslash .. '\\\d'
 let s:do_BR = 0
 let s:pat = match_words
 else
 let s:do_BR = 1
 let s:pat = s:ParseWords(match_words)
 endif
-let s:all = '\%(' . substitute(s:pat, '[,:]\+', '\\|', 'g') . '\)'
+let s:all = '\%(' .. substitute(s:pat, '[,:]\+', '\\|', 'g') .. '\)'
 if exists("b:match_debug")
 let b:match_pat = s:pat
 endif
 " Reconstruct the version with unresolved backrefs.
-let s:patBR = substitute(match_words.',',
+let s:patBR = substitute(match_words .. ',',
-\ s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
+\ s:notslash .. '\zs[,:]*,[,:]*', ',', 'g')
-let s:patBR = substitute(s:patBR, s:notslash.'\zs:\{2,}', ':', 'g')
+let s:patBR = substitute(s:patBR, s:notslash .. '\zs:\{2,}', ':', 'g')
 endif
 " Second step:  figure out the patterns for searchpair()
 " and save the screen, cursor position, and 'ignorecase'.
 " - TODO:  A lot of this is copied from matchit#Match_wrapper().
 " - maybe even more functionality should be split off
 " - into separate functions!
-let openlist = split(s:pat . ',', s:notslash . '\zs:.\{-}' . s:notslash . ',')
+let openlist = split(s:pat .. ',', s:notslash .. '\zs:.\{-}' .. s:notslash .. ',')
-let midclolist = split(',' . s:pat, s:notslash . '\zs,.\{-}' . s:notslash . ':')
+let midclolist = split(',' .. s:pat, s:notslash .. '\zs,.\{-}' .. s:notslash .. ':')
-call map(midclolist, {-> split(v:val, s:notslash . ':')})
+call map(midclolist, {-> split(v:val, s:notslash .. ':')})
 let closelist = []
 let middlelist = []
 call map(midclolist, {i,v -> [extend(closelist, v[-1 : -1]),
 \ extend(middlelist, v[0 : -2])]})
-call map(openlist,   {i,v -> v =~# s:notslash . '\\|' ? '\%(' . v . '\)' : v})
+call map(openlist,   {i,v -> v =~# s:notslash .. '\\|' ? '\%(' .. v .. '\)' : v})
-call map(middlelist, {i,v -> v =~# s:notslash . '\\|' ? '\%(' . v . '\)' : v})
+call map(middlelist, {i,v -> v =~# s:notslash .. '\\|' ? '\%(' .. v .. '\)' : v})
-call map(closelist,  {i,v -> v =~# s:notslash . '\\|' ? '\%(' . v . '\)' : v})
+call map(closelist,  {i,v -> v =~# s:notslash .. '\\|' ? '\%(' .. v .. '\)' : v})
 let open   = join(openlist, ',')
 let middle = join(middlelist, ',')
 let close  = join(closelist, ',')
 if exists("b:match_skip")
 let skip = b:match_skip
 elseif exists("b:match_comment") " backwards compatibility and testing!
-let skip = "r:" . b:match_comment
+let skip = "r:" .. b:match_comment
 else
 let skip = 's:comment\|string'
 endif
 let skip = s:ParseSkip(skip)
 let view = winsaveview()
 " Third step: call searchpair().
 " Replace '\('--but not '\\('--with '\%(' and ',' with '\|'.
-let openpat = substitute(open, '\%(' . s:notslash . '\)\@<=\\(', '\\%(', 'g')
+let openpat = substitute(open, '\%(' .. s:notslash .. '\)\@<=\\(', '\\%(', 'g')
 let openpat = substitute(openpat, ',', '\\|', 'g')
-let closepat = substitute(close, '\%(' . s:notslash . '\)\@<=\\(', '\\%(', 'g')
+let closepat = substitute(close, '\%(' .. s:notslash .. '\)\@<=\\(', '\\%(', 'g')
 let closepat = substitute(closepat, ',', '\\|', 'g')
-let middlepat = substitute(middle, '\%(' . s:notslash . '\)\@<=\\(', '\\%(', 'g')
+let middlepat = substitute(middle, '\%(' .. s:notslash .. '\)\@<=\\(', '\\%(', 'g')
 let middlepat = substitute(middlepat, ',', '\\|', 'g')
 if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
 let skip = '0'
 else
 try
-execute "if " . skip . "| let skip = '0' | endif"
+execute "if " .. skip .. "| let skip = '0' | endif"
 catch /^Vim\%((\a\+)\)\=:E363/
 " We won't find anything, so skip searching, should keep Vim responsive.
 return {}
 endtry
 endif
 "   R:foo becomes (line before cursor) !~ foo
 fun! s:ParseSkip(str)
 let skip = a:str
 if skip[1] == ":"
 if skip[0] == "s"
-let skip = "synIDattr(synID(line('.'),col('.'),1),'name') =~? '" .
+let skip = "synIDattr(synID(line('.'),col('.'),1),'name') =~? '" ..
-\ strpart(skip,2) . "'"
+\ strpart(skip,2) .. "'"
 elseif skip[0] == "S"
-let skip = "synIDattr(synID(line('.'),col('.'),1),'name') !~? '" .
+let skip = "synIDattr(synID(line('.'),col('.'),1),'name') !~? '" ..
-\ strpart(skip,2) . "'"
+\ strpart(skip,2) .. "'"
 elseif skip[0] == "r"
 let skip = "strpart(getline('.'),0,col('.'))=~'" . strpart(skip,2). "'"
 elseif skip[0] == "R"
 let skip = "strpart(getline('.'),0,col('.'))!~'" . strpart(skip,2). "'"
 endif

Mercurial > vim

comparison runtime/pack/dist/opt/matchit/autoload/matchit.vim @ 26708:f0d7cb510ce3