Modularized ruby-refactoring, matchit
This commit is contained in:
yan
Yan Pritzker
parent
ff55f778a3
commit
372e405d02
6
.gitmodules
vendored
6
.gitmodules
vendored
@ -79,3 +79,9 @@
|
|||||||
[submodule "vim/bundle/vim-ruby-vim-ruby"]
|
[submodule "vim/bundle/vim-ruby-vim-ruby"]
|
||||||
path = vim/bundle/vim-ruby-vim-ruby
|
path = vim/bundle/vim-ruby-vim-ruby
|
||||||
url = https://github.com/vim-ruby/vim-ruby.git
|
url = https://github.com/vim-ruby/vim-ruby.git
|
||||||
|
[submodule "vim/bundle/ecomba-vim-ruby-refactoring"]
|
||||||
|
path = vim/bundle/ecomba-vim-ruby-refactoring
|
||||||
|
url = https://github.com/ecomba/vim-ruby-refactoring
|
||||||
|
[submodule "vim/bundle/vim-scripts-matchit.zip"]
|
||||||
|
path = vim/bundle/vim-scripts-matchit.zip
|
||||||
|
url = https://github.com/vim-scripts/matchit.zip.git
|
||||||
|
|||||||
1
vim/bundle/ecomba-vim-ruby-refactoring
Submodule
1
vim/bundle/ecomba-vim-ruby-refactoring
Submodule
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 5a06bf807d439f71c47c0f640fefbd46ffe10e18
|
||||||
1
vim/bundle/vim-scripts-matchit.zip
Submodule
1
vim/bundle/vim-scripts-matchit.zip
Submodule
@ -0,0 +1 @@
|
|||||||
|
Subproject commit ced6c409c9beeb0b4142d21906606bd194411d1d
|
||||||
@ -1,310 +0,0 @@
|
|||||||
" File: greplace.vim
|
|
||||||
" Script to search and replace pattern across multiple files
|
|
||||||
" Author: Yegappan Lakshmanan (yegappan AT yahoo DOT com)
|
|
||||||
" Version: 1.0 Beta1
|
|
||||||
" Last Modified: March 3, 2007
|
|
||||||
"
|
|
||||||
if exists("loaded_greplace")
|
|
||||||
finish
|
|
||||||
endif
|
|
||||||
let loaded_greplace = 1
|
|
||||||
|
|
||||||
" Requires Vim 7.0 and above
|
|
||||||
if v:version < 700
|
|
||||||
finish
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Line continuation used here
|
|
||||||
let s:cpo_save = &cpo
|
|
||||||
set cpo&vim
|
|
||||||
|
|
||||||
if &isfname =~ '['
|
|
||||||
let s:gRepl_bufname = '[Global\ Replace]'
|
|
||||||
else
|
|
||||||
let s:gRepl_bufname = '\[Global\ Replace\]'
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Character to use to quote patterns
|
|
||||||
if !exists("Greplace_Shell_Quote_Char")
|
|
||||||
if has("win32") || has("win16") || has("win95")
|
|
||||||
let Greplace_Shell_Quote_Char = ''
|
|
||||||
else
|
|
||||||
let Greplace_Shell_Quote_Char = "'"
|
|
||||||
endif
|
|
||||||
endif
|
|
||||||
|
|
||||||
let s:save_qf_list = {}
|
|
||||||
|
|
||||||
function! s:warn_msg(msg)
|
|
||||||
echohl WarningMsg
|
|
||||||
echomsg a:msg
|
|
||||||
echohl None
|
|
||||||
endfunction
|
|
||||||
|
|
||||||
highlight GReplaceText term=reverse cterm=reverse gui=reverse
|
|
||||||
|
|
||||||
function! s:gReplace()
|
|
||||||
if empty(s:save_qf_list)
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
let change_all = v:cmdbang
|
|
||||||
|
|
||||||
let changeset = {}
|
|
||||||
|
|
||||||
" Parse the replace buffer contents and get a List of changed lines
|
|
||||||
let lines = getbufline('%', 1, '$')
|
|
||||||
for l in lines
|
|
||||||
if l !~ '[^:]\+:\d\+:.*'
|
|
||||||
continue
|
|
||||||
endif
|
|
||||||
|
|
||||||
let match_l = matchlist(l, '\([^:]\+\):\(\d\+\):\(.*\)')
|
|
||||||
let fname = match_l[1]
|
|
||||||
let lnum = match_l[2]
|
|
||||||
let text = match_l[3]
|
|
||||||
|
|
||||||
let key = fname . ':' . lnum
|
|
||||||
if s:save_qf_list[key].text == text
|
|
||||||
" This line is not changed
|
|
||||||
continue
|
|
||||||
endif
|
|
||||||
|
|
||||||
let fname = s:save_qf_list[key].fname
|
|
||||||
if !has_key(changeset, fname)
|
|
||||||
let changeset[fname] = {}
|
|
||||||
endif
|
|
||||||
|
|
||||||
let changeset[fname][lnum] = text
|
|
||||||
endfor
|
|
||||||
|
|
||||||
if empty(changeset)
|
|
||||||
" The replace buffer is not changed by the user
|
|
||||||
call s:warn_msg('Error: No changes in the replace buffer')
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Make the changes made by the user to the buffers
|
|
||||||
for f in keys(changeset)
|
|
||||||
let f_l = changeset[f]
|
|
||||||
if !filereadable(f)
|
|
||||||
continue
|
|
||||||
endif
|
|
||||||
silent! exe 'hide edit ' . f
|
|
||||||
|
|
||||||
let change_buf_all = 0 " Accept all the changes in this buffer
|
|
||||||
|
|
||||||
for lnum in keys(f_l)
|
|
||||||
exe lnum
|
|
||||||
|
|
||||||
let cur_ltext = getline(lnum)
|
|
||||||
let new_ltext = f_l[lnum]
|
|
||||||
|
|
||||||
let s_idx =0
|
|
||||||
while cur_ltext[s_idx] == new_ltext[s_idx]
|
|
||||||
let s_idx += 1
|
|
||||||
endwhile
|
|
||||||
|
|
||||||
let e_idx1 = strlen(cur_ltext) - 1
|
|
||||||
let e_idx2 = strlen(new_ltext) - 1
|
|
||||||
while e_idx1 >= 0 && cur_ltext[e_idx1] == new_ltext[e_idx2]
|
|
||||||
let e_idx1 -= 1
|
|
||||||
let e_idx2 -= 1
|
|
||||||
endwhile
|
|
||||||
|
|
||||||
let e_idx1 += 2
|
|
||||||
|
|
||||||
if (s_idx + 1) == e_idx1
|
|
||||||
" If there is nothing to highlight, then highlight the
|
|
||||||
" last character
|
|
||||||
let e_idx1 += 1
|
|
||||||
endif
|
|
||||||
|
|
||||||
let hl_pat = '/\%'.lnum.'l\%>'.s_idx.'v.*\%<'.e_idx1.'v/'
|
|
||||||
exe '2match GReplaceText ' . hl_pat
|
|
||||||
redraw!
|
|
||||||
|
|
||||||
try
|
|
||||||
let change_line = 0
|
|
||||||
|
|
||||||
if !change_all && !change_buf_all
|
|
||||||
let new_text_frag = strpart(new_ltext, s_idx,
|
|
||||||
\ e_idx2 - s_idx + 1)
|
|
||||||
|
|
||||||
echo "Replace with '" . new_text_frag . "' (y/n/a/b/q)?"
|
|
||||||
let ans = 'x'
|
|
||||||
while ans !~? '[ynab]'
|
|
||||||
let ans = nr2char(getchar())
|
|
||||||
if ans == 'q' || ans == "\<Esc>" " Quit
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
endwhile
|
|
||||||
if ans == 'a' " Accept all
|
|
||||||
let change_all = 1
|
|
||||||
endif
|
|
||||||
if ans == 'b' " Accept changes in the current buffer
|
|
||||||
let change_buf_all = 1
|
|
||||||
endif
|
|
||||||
if ans == 'y' " Yes
|
|
||||||
let change_line = 1
|
|
||||||
endif
|
|
||||||
endif
|
|
||||||
|
|
||||||
if change_all || change_buf_all || change_line
|
|
||||||
call setline(lnum, f_l[lnum])
|
|
||||||
endif
|
|
||||||
finally
|
|
||||||
2match none
|
|
||||||
endtry
|
|
||||||
endfor
|
|
||||||
endfor
|
|
||||||
endfunction
|
|
||||||
|
|
||||||
function! s:gReplace_show_matches()
|
|
||||||
let qf = getqflist()
|
|
||||||
if empty(qf)
|
|
||||||
call s:warn_msg('Error: Quickfix list is empty')
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
let new_qf = {}
|
|
||||||
|
|
||||||
" Populate the buffer with the current quickfix list
|
|
||||||
let lines = []
|
|
||||||
for l in qf
|
|
||||||
if l.valid && l.lnum > 0 && l.bufnr > 0
|
|
||||||
let fname = fnamemodify(bufname(l.bufnr), ':.')
|
|
||||||
let buf_text = fname . ':' . l.lnum . ':' . l.text
|
|
||||||
let k = fname . ':' . l.lnum
|
|
||||||
let new_qf[k] = {}
|
|
||||||
let new_qf[k].fname = fnamemodify(bufname(l.bufnr), ':p')
|
|
||||||
let new_qf[k].text = l.text
|
|
||||||
else
|
|
||||||
let buf_text = l.text
|
|
||||||
endif
|
|
||||||
|
|
||||||
call add(lines, buf_text)
|
|
||||||
endfor
|
|
||||||
|
|
||||||
if empty(lines)
|
|
||||||
" No valid matching lines
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
let w = bufwinnr(s:gRepl_bufname)
|
|
||||||
if w == -1
|
|
||||||
" Create a new window
|
|
||||||
silent! exe 'new ' . s:gRepl_bufname
|
|
||||||
else
|
|
||||||
exe w . 'wincmd w'
|
|
||||||
|
|
||||||
" Discard the contents of the buffer
|
|
||||||
%d _
|
|
||||||
endif
|
|
||||||
|
|
||||||
call append(0, '#')
|
|
||||||
call append(1, '# Modify the contents of this buffer and then')
|
|
||||||
call append(2, '# use the ":Greplace" command to merge the changes.')
|
|
||||||
call append(3, '#')
|
|
||||||
call append(4, lines)
|
|
||||||
|
|
||||||
call cursor(5, 1)
|
|
||||||
setlocal buftype=nofile
|
|
||||||
setlocal bufhidden=wipe
|
|
||||||
setlocal nomodified
|
|
||||||
|
|
||||||
command! -buffer -nargs=0 -bang Greplace call s:gReplace()
|
|
||||||
|
|
||||||
let s:save_qf_list = new_qf
|
|
||||||
endfunction
|
|
||||||
|
|
||||||
" gSearch
|
|
||||||
" Search for a pattern in a group of files using ':grep'
|
|
||||||
function! s:gSearch(type, ...)
|
|
||||||
let grep_opt = '-r'
|
|
||||||
let pattern = ''
|
|
||||||
let filenames = ''
|
|
||||||
|
|
||||||
" Parse the arguments
|
|
||||||
" grep command-line flags are specified using the "-flag" format
|
|
||||||
" the next argument is assumed to be the pattern
|
|
||||||
" and the next arguments are assumed to be filenames or file patterns
|
|
||||||
let argcnt = 1
|
|
||||||
while argcnt <= a:0
|
|
||||||
if &grepprg =~ 'findstr' && a:{argcnt} =~ '^/'
|
|
||||||
let grep_opt = grep_opt . ' ' . a:{argcnt}
|
|
||||||
elseif a:{argcnt} =~ '^-'
|
|
||||||
let grep_opt = grep_opt . ' ' . a:{argcnt}
|
|
||||||
elseif pattern == ''
|
|
||||||
let pattern = a:{argcnt}
|
|
||||||
else
|
|
||||||
let filenames = filenames . ' ' . a:{argcnt}
|
|
||||||
endif
|
|
||||||
let argcnt += 1
|
|
||||||
endwhile
|
|
||||||
|
|
||||||
" If search pattern is not specified on command-line, ask for it
|
|
||||||
if pattern == ''
|
|
||||||
let pattern = input('Search pattern: ', expand('<cword>'))
|
|
||||||
if pattern == ''
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Quote the supplied pattern
|
|
||||||
let pattern = g:Greplace_Shell_Quote_Char . pattern .
|
|
||||||
\ g:Greplace_Shell_Quote_Char
|
|
||||||
endif
|
|
||||||
|
|
||||||
if a:type == 'grep'
|
|
||||||
if filenames == ''
|
|
||||||
let filenames = input('Search in files: ', '*', 'file')
|
|
||||||
endif
|
|
||||||
elseif a:type == 'args'
|
|
||||||
" Search in all the filenames in the argument list
|
|
||||||
let arg_cnt = argc()
|
|
||||||
|
|
||||||
if arg_cnt == 0
|
|
||||||
call s:warn_msg('Error: Argument list is empty')
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
let filenames = ''
|
|
||||||
for i in range(0, arg_cnt - 1)
|
|
||||||
let filenames .= ' ' . argv(i)
|
|
||||||
endfor
|
|
||||||
else
|
|
||||||
" Get a list of all the buffer names
|
|
||||||
let filenames = ''
|
|
||||||
for i in range(1, bufnr('$'))
|
|
||||||
let bname = bufname(i)
|
|
||||||
if bufexists(i) && buflisted(i) && filereadable(bname) &&
|
|
||||||
\ getbufvar(i, '&buftype') == ''
|
|
||||||
let filenames .= ' ' . bufname(i)
|
|
||||||
endif
|
|
||||||
endfor
|
|
||||||
endif
|
|
||||||
|
|
||||||
if filenames == ''
|
|
||||||
call s:warn_msg('Error: No valid file names')
|
|
||||||
return
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Use ! after grep, so that Vim doesn't automatically jump to the
|
|
||||||
" first match
|
|
||||||
let grep_cmd = 'grep! ' . grep_opt . ' ' . pattern . ' ' . filenames
|
|
||||||
|
|
||||||
" Run the grep and get the matches
|
|
||||||
silent! exe grep_cmd
|
|
||||||
|
|
||||||
call s:gReplace_show_matches()
|
|
||||||
endfunction
|
|
||||||
|
|
||||||
command! -nargs=0 Gqfopen call s:gReplace_show_matches()
|
|
||||||
command! -nargs=* -complete=file Gsearch call s:gSearch('grep', <f-args>)
|
|
||||||
command! -nargs=* Gargsearch call s:gSearch('args', <f-args>)
|
|
||||||
command! -nargs=* Gbuffersearch call s:gSearch('buffer', <f-args>)
|
|
||||||
|
|
||||||
" restore 'cpo'
|
|
||||||
let &cpo = s:cpo_save
|
|
||||||
unlet s:cpo_save
|
|
||||||
|
|
||||||
@ -1,812 +0,0 @@
|
|||||||
" matchit.vim: (global plugin) Extended "%" matching
|
|
||||||
" Last Change: Fri Jan 25 10:00 AM 2008 EST
|
|
||||||
" Maintainer: Benji Fisher PhD <benji@member.AMS.org>
|
|
||||||
" Version: 1.13.2, for Vim 6.3+
|
|
||||||
" URL: http://www.vim.org/script.php?script_id=39
|
|
||||||
|
|
||||||
" Documentation:
|
|
||||||
" The documentation is in a separate file, matchit.txt .
|
|
||||||
|
|
||||||
" Credits:
|
|
||||||
" Vim editor by Bram Moolenaar (Thanks, Bram!)
|
|
||||||
" Original script and design by Raul Segura Acevedo
|
|
||||||
" Support for comments by Douglas Potts
|
|
||||||
" Support for back references and other improvements by Benji Fisher
|
|
||||||
" Support for many languages by Johannes Zellner
|
|
||||||
" Suggestions for improvement, bug reports, and support for additional
|
|
||||||
" languages by Jordi-Albert Batalla, Neil Bird, Servatius Brandt, Mark
|
|
||||||
" Collett, Stephen Wall, Dany St-Amant, Yuheng Xie, and Johannes Zellner.
|
|
||||||
|
|
||||||
" Debugging:
|
|
||||||
" If you'd like to try the built-in debugging commands...
|
|
||||||
" :MatchDebug to activate debugging for the current buffer
|
|
||||||
" This saves the values of several key script variables as buffer-local
|
|
||||||
" variables. See the MatchDebug() function, below, for details.
|
|
||||||
|
|
||||||
" TODO: I should think about multi-line patterns for b:match_words.
|
|
||||||
" This would require an option: how many lines to scan (default 1).
|
|
||||||
" This would be useful for Python, maybe also for *ML.
|
|
||||||
" TODO: Maybe I should add a menu so that people will actually use some of
|
|
||||||
" the features that I have implemented.
|
|
||||||
" TODO: Eliminate the MultiMatch function. Add yet another argument to
|
|
||||||
" Match_wrapper() instead.
|
|
||||||
" TODO: Allow :let b:match_words = '\(\(foo\)\(bar\)\):\3\2:end\1'
|
|
||||||
" TODO: Make backrefs safer by using '\V' (very no-magic).
|
|
||||||
" TODO: Add a level of indirection, so that custom % scripts can use my
|
|
||||||
" work but extend it.
|
|
||||||
|
|
||||||
" allow user to prevent loading
|
|
||||||
" and prevent duplicate loading
|
|
||||||
if exists("loaded_matchit") || &cp
|
|
||||||
finish
|
|
||||||
endif
|
|
||||||
let loaded_matchit = 1
|
|
||||||
let s:last_mps = ""
|
|
||||||
let s:last_words = ":"
|
|
||||||
|
|
||||||
let s:save_cpo = &cpo
|
|
||||||
set cpo&vim
|
|
||||||
|
|
||||||
nnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'n') <CR>
|
|
||||||
nnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'n') <CR>
|
|
||||||
vnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'v') <CR>m'gv``
|
|
||||||
vnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'v') <CR>m'gv``
|
|
||||||
onoremap <silent> % v:<C-U>call <SID>Match_wrapper('',1,'o') <CR>
|
|
||||||
onoremap <silent> g% v:<C-U>call <SID>Match_wrapper('',0,'o') <CR>
|
|
||||||
|
|
||||||
" Analogues of [{ and ]} using matching patterns:
|
|
||||||
nnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "n") <CR>
|
|
||||||
nnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "n") <CR>
|
|
||||||
vmap [% <Esc>[%m'gv``
|
|
||||||
vmap ]% <Esc>]%m'gv``
|
|
||||||
" vnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "v") <CR>m'gv``
|
|
||||||
" vnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "v") <CR>m'gv``
|
|
||||||
onoremap <silent> [% v:<C-U>call <SID>MultiMatch("bW", "o") <CR>
|
|
||||||
onoremap <silent> ]% v:<C-U>call <SID>MultiMatch("W", "o") <CR>
|
|
||||||
|
|
||||||
" text object:
|
|
||||||
vmap a% <Esc>[%v]%
|
|
||||||
|
|
||||||
" Auto-complete mappings: (not yet "ready for prime time")
|
|
||||||
" TODO Read :help write-plugin for the "right" way to let the user
|
|
||||||
" specify a key binding.
|
|
||||||
" let g:match_auto = '<C-]>'
|
|
||||||
" let g:match_autoCR = '<C-CR>'
|
|
||||||
" if exists("g:match_auto")
|
|
||||||
" execute "inoremap " . g:match_auto . ' x<Esc>"=<SID>Autocomplete()<CR>Pls'
|
|
||||||
" endif
|
|
||||||
" if exists("g:match_autoCR")
|
|
||||||
" execute "inoremap " . g:match_autoCR . ' <CR><C-R>=<SID>Autocomplete()<CR>'
|
|
||||||
" endif
|
|
||||||
" if exists("g:match_gthhoh")
|
|
||||||
" execute "inoremap " . g:match_gthhoh . ' <C-O>:call <SID>Gthhoh()<CR>'
|
|
||||||
" endif " gthhoh = "Get the heck out of here!"
|
|
||||||
|
|
||||||
let s:notslash = '\\\@<!\%(\\\\\)*'
|
|
||||||
|
|
||||||
function! s:Match_wrapper(word, forward, mode) range
|
|
||||||
" In s:CleanUp(), :execute "set" restore_options .
|
|
||||||
let restore_options = (&ic ? " " : " no") . "ignorecase"
|
|
||||||
if exists("b:match_ignorecase")
|
|
||||||
let &ignorecase = b:match_ignorecase
|
|
||||||
endif
|
|
||||||
let restore_options = " ve=" . &ve . restore_options
|
|
||||||
set ve=
|
|
||||||
" 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"
|
|
||||||
execute "normal! gv\<Esc>"
|
|
||||||
endif
|
|
||||||
" In s:CleanUp(), we may need to check whether the cursor moved forward.
|
|
||||||
let startline = line(".")
|
|
||||||
let startcol = col(".")
|
|
||||||
" Use default behavior if called with a count.
|
|
||||||
if v:count
|
|
||||||
exe "normal! " . v:count . "%"
|
|
||||||
return s:CleanUp(restore_options, a:mode, startline, startcol)
|
|
||||||
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
|
|
||||||
"
|
|
||||||
if !exists("b:match_words") || b:match_words == ""
|
|
||||||
let match_words = ""
|
|
||||||
" Allow b:match_words = "GetVimMatchWords()" .
|
|
||||||
elseif b:match_words =~ ":"
|
|
||||||
let match_words = b:match_words
|
|
||||||
else
|
|
||||||
execute "let match_words =" b:match_words
|
|
||||||
endif
|
|
||||||
" Thanks to Preben "Peppe" Guldberg and Bram Moolenaar for this suggestion!
|
|
||||||
if (match_words != s:last_words) || (&mps != s:last_mps) ||
|
|
||||||
\ exists("b:match_debug")
|
|
||||||
let s:last_words = match_words
|
|
||||||
let s:last_mps = &mps
|
|
||||||
" The next several lines were here before
|
|
||||||
" BF started messing with this script.
|
|
||||||
" quote the special chars in 'matchpairs', replace [,:] with \| and then
|
|
||||||
" append the builtin pairs (/*, */, #if, #ifdef, #else, #elif, #endif)
|
|
||||||
" let default = substitute(escape(&mps, '[$^.*~\\/?]'), '[,:]\+',
|
|
||||||
" \ '\\|', 'g').'\|\/\*\|\*\/\|#if\>\|#ifdef\>\|#else\>\|#elif\>\|#endif\>'
|
|
||||||
let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
|
|
||||||
\ '\/\*:\*\/,#if\%(def\)\=:#else\>:#elif\>:#endif\>'
|
|
||||||
" s:all = pattern with all the keywords
|
|
||||||
let match_words = match_words . (strlen(match_words) ? "," : "") . default
|
|
||||||
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 = '\%(' . s:all . '\)'
|
|
||||||
" let s:all = '\%(' . substitute(s:all, '\\\ze[,:]', '', 'g') . '\)'
|
|
||||||
if exists("b:match_debug")
|
|
||||||
let b:match_pat = s:pat
|
|
||||||
endif
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Second step: set the following local variables:
|
|
||||||
" matchline = line on which the cursor started
|
|
||||||
" curcol = number of characters before match
|
|
||||||
" prefix = regexp for start of line to start of match
|
|
||||||
" suffix = regexp for end of match to end of line
|
|
||||||
" Require match to end on or after the cursor and prefer it to
|
|
||||||
" start on or before the cursor.
|
|
||||||
let matchline = getline(startline)
|
|
||||||
if a:word != ''
|
|
||||||
" word given
|
|
||||||
if a:word !~ s:all
|
|
||||||
echohl WarningMsg|echo 'Missing rule for word:"'.a:word.'"'|echohl NONE
|
|
||||||
return s:CleanUp(restore_options, a:mode, startline, startcol)
|
|
||||||
endif
|
|
||||||
let matchline = a:word
|
|
||||||
let curcol = 0
|
|
||||||
let prefix = '^\%('
|
|
||||||
let suffix = '\)$'
|
|
||||||
" Now the case when "word" is not given
|
|
||||||
else " Find the match that ends on or after the cursor and set curcol.
|
|
||||||
let regexp = s:Wholematch(matchline, s:all, startcol-1)
|
|
||||||
let curcol = match(matchline, regexp)
|
|
||||||
" If there is no match, give up.
|
|
||||||
if curcol == -1
|
|
||||||
return s:CleanUp(restore_options, a:mode, startline, startcol)
|
|
||||||
endif
|
|
||||||
let endcol = matchend(matchline, regexp)
|
|
||||||
let suf = strlen(matchline) - endcol
|
|
||||||
let prefix = (curcol ? '^.*\%' . (curcol + 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
|
|
||||||
|
|
||||||
" Third step: Find the group and single word that match, and the original
|
|
||||||
" (backref) versions of these. Then, resolve the backrefs.
|
|
||||||
" Set the following local variable:
|
|
||||||
" group = colon-separated list of patterns, one of which matches
|
|
||||||
" = ini:mid:fin or ini:fin
|
|
||||||
"
|
|
||||||
" Reconstruct the version with unresolved backrefs.
|
|
||||||
let patBR = substitute(match_words.',',
|
|
||||||
\ s:notslash.'\zs[,:]*,[,:]*', ',', 'g')
|
|
||||||
let patBR = substitute(patBR, s:notslash.'\zs:\{2,}', ':', 'g')
|
|
||||||
" 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, patBR)
|
|
||||||
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 b:match_iniBR = strpart(groupBR, 0, i-1)
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Fourth step: Set the arguments for searchpair().
|
|
||||||
let i = 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 fin = strpart(group, j)
|
|
||||||
"Un-escape the remaining , and : characters.
|
|
||||||
let ini = substitute(ini, s:notslash . '\zs\\\(:\|,\)', '\1', 'g')
|
|
||||||
let mid = substitute(mid, 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 mid = substitute(mid, 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
|
|
||||||
\ || !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
|
|
||||||
\ || !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
|
|
||||||
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
|
|
||||||
endif
|
|
||||||
|
|
||||||
" Fifth step: actually start moving the cursor and call searchpair().
|
|
||||||
" Later, :execute restore_cursor to get to the original screen.
|
|
||||||
let restore_cursor = virtcol(".") . "|"
|
|
||||||
normal! g0
|
|
||||||
let restore_cursor = line(".") . "G" . virtcol(".") . "|zs" . restore_cursor
|
|
||||||
normal! H
|
|
||||||
let restore_cursor = "normal!" . line(".") . "Gzt" . restore_cursor
|
|
||||||
execute restore_cursor
|
|
||||||
call cursor(0, curcol + 1)
|
|
||||||
" normal! 0
|
|
||||||
" if curcol
|
|
||||||
" execute "normal!" . curcol . "l"
|
|
||||||
" endif
|
|
||||||
if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
|
|
||||||
let skip = "0"
|
|
||||||
else
|
|
||||||
execute "if " . skip . "| let skip = '0' | endif"
|
|
||||||
endif
|
|
||||||
let sp_return = searchpair(ini, mid, fin, flag, skip)
|
|
||||||
let final_position = "call cursor(" . line(".") . "," . col(".") . ")"
|
|
||||||
" Restore cursor position and original screen.
|
|
||||||
execute restore_cursor
|
|
||||||
normal! m'
|
|
||||||
if sp_return > 0
|
|
||||||
execute final_position
|
|
||||||
endif
|
|
||||||
return s:CleanUp(restore_options, a:mode, startline, startcol, 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, startline, startcol, ...)
|
|
||||||
execute "set" a:options
|
|
||||||
" Open folds, if appropriate.
|
|
||||||
if a:mode != "o"
|
|
||||||
if &foldopen =~ "percent"
|
|
||||||
normal! zv
|
|
||||||
endif
|
|
||||||
" In Operator-pending mode, we want to include the whole match
|
|
||||||
" (for example, d%).
|
|
||||||
" This is only a problem if we end up moving in the forward direction.
|
|
||||||
elseif (a:startline < line(".")) ||
|
|
||||||
\ (a:startline == line(".") && a:startcol < col("."))
|
|
||||||
if a:0
|
|
||||||
" Check whether the match is a single character. If not, move to the
|
|
||||||
" end of the match.
|
|
||||||
let matchline = getline(".")
|
|
||||||
let currcol = col(".")
|
|
||||||
let regexp = s:Wholematch(matchline, a:1, currcol-1)
|
|
||||||
let endcol = matchend(matchline, regexp)
|
|
||||||
if endcol > currcol " This is NOT off by one!
|
|
||||||
execute "normal!" . (endcol - currcol) . "l"
|
|
||||||
endif
|
|
||||||
endif " a:0
|
|
||||||
endif " a:mode != "o" && etc.
|
|
||||||
return 0
|
|
||||||
endfun
|
|
||||||
|
|
||||||
" Example (simplified HTML patterns): if
|
|
||||||
" a:groupBR = '<\(\k\+\)>:</\1>'
|
|
||||||
" a:prefix = '^.\{3}\('
|
|
||||||
" 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 .
|
|
||||||
\ substitute(a:group, s:notslash . '\zs:', '\\|', 'g') . a:suffix
|
|
||||||
return a:group
|
|
||||||
endif
|
|
||||||
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 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 table = ""
|
|
||||||
let d = 0
|
|
||||||
while d < 10
|
|
||||||
if tailBR =~ s:notslash . '\\' . d
|
|
||||||
" let table[d] = d
|
|
||||||
let table = table . d
|
|
||||||
else
|
|
||||||
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,
|
|
||||||
\ '\'.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 tailBR = substitute(tailBR, s:notslash . '\zs\\' . d,
|
|
||||||
\ escape(backref, '\\'), 'g')
|
|
||||||
endif
|
|
||||||
let d = d-1
|
|
||||||
endwhile
|
|
||||||
if exists("b:match_debug")
|
|
||||||
if s:do_BR
|
|
||||||
let b:match_table = table
|
|
||||||
let b:match_word = word
|
|
||||||
else
|
|
||||||
let b:match_table = ""
|
|
||||||
let b:match_word = ""
|
|
||||||
endif
|
|
||||||
endif
|
|
||||||
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(groups, s:notslash . '\zs:\{2,}', ':', 'g')
|
|
||||||
let parsed = ""
|
|
||||||
while groups =~ '[^,:]'
|
|
||||||
let i = 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 groups = strpart(groups, j)
|
|
||||||
let parsed = parsed . ini
|
|
||||||
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 parsed = parsed . ":" . s:Resolve(ini, word, "word")
|
|
||||||
endwhile " Now, tail has been used up.
|
|
||||||
let parsed = parsed . ","
|
|
||||||
endwhile " groups =~ '[^,:]'
|
|
||||||
let parsed = substitute(parsed, ',$', '', '')
|
|
||||||
return parsed
|
|
||||||
endfun
|
|
||||||
|
|
||||||
" TODO I think this can be simplified and/or made more efficient.
|
|
||||||
" TODO What should I do if a:start is out of range?
|
|
||||||
" Return a regexp that matches all of a:string, such that
|
|
||||||
" matchstr(a:string, regexp) represents the match for a:pat that starts
|
|
||||||
" as close to a:start as possible, before being preferred to after, and
|
|
||||||
" ends after a:start .
|
|
||||||
" Usage:
|
|
||||||
" 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 prefix = (a:start ? '\(^.*\%<' . (a:start + 2) . 'c\)\zs' : '^')
|
|
||||||
let len = strlen(a:string)
|
|
||||||
let suffix = (a:start+1 < len ? '\(\%>'.(a:start+1).'c.*$\)\@=' : '$')
|
|
||||||
if a:string !~ prefix . group . suffix
|
|
||||||
let prefix = ''
|
|
||||||
endif
|
|
||||||
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 '\)'.
|
|
||||||
" One argument: s:Ref(string, d, "start") returns the index of the start
|
|
||||||
" of the d'th '\(' and any other argument returns the length of the group.
|
|
||||||
" Two arguments: s:Ref(string, d, "foo", "bar") returns a string to be
|
|
||||||
" executed, having the effect of
|
|
||||||
" :let foo = s:Ref(string, d, "start")
|
|
||||||
" :let bar = s:Ref(string, d, "len")
|
|
||||||
fun! s:Ref(string, d, ...)
|
|
||||||
let len = strlen(a:string)
|
|
||||||
if a:d == 0
|
|
||||||
let start = 0
|
|
||||||
else
|
|
||||||
let cnt = a:d
|
|
||||||
let match = a:string
|
|
||||||
while cnt
|
|
||||||
let cnt = cnt - 1
|
|
||||||
let index = matchend(match, s:notslash . '\\(')
|
|
||||||
if index == -1
|
|
||||||
return ""
|
|
||||||
endif
|
|
||||||
let match = strpart(match, index)
|
|
||||||
endwhile
|
|
||||||
let start = len - strlen(match)
|
|
||||||
if a:0 == 1 && a:1 == "start"
|
|
||||||
return start - 2
|
|
||||||
endif
|
|
||||||
let cnt = 1
|
|
||||||
while cnt
|
|
||||||
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 cnt = stridx('0(', match[index]) + cnt
|
|
||||||
let match = strpart(match, index+1)
|
|
||||||
endwhile
|
|
||||||
let start = start - 2
|
|
||||||
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
|
|
||||||
else
|
|
||||||
return strpart(a:string, start, len)
|
|
||||||
endif
|
|
||||||
endfun
|
|
||||||
|
|
||||||
" Count the number of disjoint copies of pattern in string.
|
|
||||||
" If the pattern is a literal string and contains no '0' or '1' characters
|
|
||||||
" 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, pat, 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)
|
|
||||||
while index != -1
|
|
||||||
let result = result + 1
|
|
||||||
let foo = strpart(foo, index)
|
|
||||||
let index = matchend(foo, pat)
|
|
||||||
endwhile
|
|
||||||
return result
|
|
||||||
endfun
|
|
||||||
|
|
||||||
" s:Resolve('\(a\)\(b\)', '\(c\)\2\1\1\2') should return table.word, where
|
|
||||||
" word = '\(c\)\(b\)\(a\)\3\2' and table = '-32-------'. That is, the first
|
|
||||||
" '\1' in target is replaced by '\(a\)' in word, table[1] = 3, and this
|
|
||||||
" indicates that all other instances of '\1' in target are to be replaced
|
|
||||||
" 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 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,
|
|
||||||
" replace any \(\) groups in backref with :1, :2, ... if they
|
|
||||||
" correspond to the first, second, ... group already inserted
|
|
||||||
" into backref. Later, replace :1 with \1 and so on. The group
|
|
||||||
" number w+b within backref corresponds to the group number
|
|
||||||
" s within a:source.
|
|
||||||
" w = number of '\(' in word before the current one
|
|
||||||
let w = s:Count(
|
|
||||||
\ substitute(strpart(word, 0, i-1), '\\\\', '', 'g'), '\(', '1')
|
|
||||||
let b = 1 " number of the current '\(' in backref
|
|
||||||
let s = d " number of the current '\(' in a:source
|
|
||||||
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)
|
|
||||||
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]
|
|
||||||
\ . 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 i = matchend(word, s:notslash . '\\\d') - 1
|
|
||||||
endwhile
|
|
||||||
let word = substitute(word, s:notslash . '\zs:', '\\', 'g')
|
|
||||||
if a:output == "table"
|
|
||||||
return table
|
|
||||||
elseif a:output == "word"
|
|
||||||
return word
|
|
||||||
else
|
|
||||||
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 i = matchend(tail, s:notslash . a:comma)
|
|
||||||
if a:0
|
|
||||||
let alttail = (a:1 =~ a:comma."$" ? a:1 : a:1 . 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')
|
|
||||||
endif
|
|
||||||
while a:string !~ a:prefix . currpat . a:suffix
|
|
||||||
let tail = strpart(tail, i)
|
|
||||||
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')
|
|
||||||
endif
|
|
||||||
if a:0
|
|
||||||
let alttail = strpart(alttail, j)
|
|
||||||
let j = matchend(alttail, s:notslash . a:comma)
|
|
||||||
endif
|
|
||||||
endwhile
|
|
||||||
if a:0
|
|
||||||
let current = current . a:comma . strpart(alttail, 0, j-1)
|
|
||||||
endif
|
|
||||||
return current
|
|
||||||
endfun
|
|
||||||
|
|
||||||
" Call this function to turn on debugging information. Every time the main
|
|
||||||
" script is run, buffer variables will be saved. These can be used directly
|
|
||||||
" or viewed using the menu items below.
|
|
||||||
if !exists(":MatchDebug")
|
|
||||||
command! -nargs=0 MatchDebug call s:Match_debug()
|
|
||||||
endif
|
|
||||||
|
|
||||||
fun! s:Match_debug()
|
|
||||||
let b:match_debug = 1 " Save debugging information.
|
|
||||||
" pat = all of b:match_words with backrefs parsed
|
|
||||||
amenu &Matchit.&pat :echo b:match_pat<CR>
|
|
||||||
" match = bit of text that is recognized as a match
|
|
||||||
amenu &Matchit.&match :echo b:match_match<CR>
|
|
||||||
" curcol = cursor column of the start of the matching text
|
|
||||||
amenu &Matchit.&curcol :echo b:match_col<CR>
|
|
||||||
" wholeBR = matching group, original version
|
|
||||||
amenu &Matchit.wh&oleBR :echo b:match_wholeBR<CR>
|
|
||||||
" iniBR = 'if' piece, original version
|
|
||||||
amenu &Matchit.ini&BR :echo b:match_iniBR<CR>
|
|
||||||
" ini = 'if' piece, with all backrefs resolved from match
|
|
||||||
amenu &Matchit.&ini :echo b:match_ini<CR>
|
|
||||||
" 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>
|
|
||||||
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
|
|
||||||
" let m = MultiMatch("bW", "n") ... execute m
|
|
||||||
" will return to the original position. If there is a problem, do not
|
|
||||||
" move the cursor and return "", unless a count is given, in which case
|
|
||||||
" go up or down as many levels as possible and again return "".
|
|
||||||
" TODO This relies on the same patterns as % matching. It might be a good
|
|
||||||
" idea to give it its own matching patterns.
|
|
||||||
fun! s:MultiMatch(spflag, mode)
|
|
||||||
if !exists("b:match_words") || b:match_words == ""
|
|
||||||
return ""
|
|
||||||
end
|
|
||||||
let restore_options = (&ic ? "" : "no") . "ignorecase"
|
|
||||||
if exists("b:match_ignorecase")
|
|
||||||
let &ignorecase = b:match_ignorecase
|
|
||||||
endif
|
|
||||||
let startline = line(".")
|
|
||||||
let startcol = col(".")
|
|
||||||
|
|
||||||
" 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
|
|
||||||
" This part is copied and slightly modified from s:Match_wrapper().
|
|
||||||
let default = escape(&mps, '[$^.*~\\/?]') . (strlen(&mps) ? "," : "") .
|
|
||||||
\ '\/\*:\*\/,#if\%(def\)\=:#else\>:#elif\>:#endif\>'
|
|
||||||
" Allow b:match_words = "GetVimMatchWords()" .
|
|
||||||
if b:match_words =~ ":"
|
|
||||||
let match_words = b:match_words
|
|
||||||
else
|
|
||||||
execute "let match_words =" b:match_words
|
|
||||||
endif
|
|
||||||
if (match_words != s:last_words) || (&mps != s:last_mps) ||
|
|
||||||
\ exists("b:match_debug")
|
|
||||||
let s:last_words = match_words
|
|
||||||
let s:last_mps = &mps
|
|
||||||
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 . (strlen(s:pat)?",":"") . default,
|
|
||||||
\ '[,:]\+','\\|','g') . '\)'
|
|
||||||
if exists("b:match_debug")
|
|
||||||
let b:match_pat = s:pat
|
|
||||||
endif
|
|
||||||
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 s:Match_wrapper().
|
|
||||||
" - maybe even more functionality should be split off
|
|
||||||
" - into separate functions!
|
|
||||||
let cdefault = (s:pat =~ '[^,]$' ? "," : "") . default
|
|
||||||
let open = substitute(s:pat . cdefault,
|
|
||||||
\ s:notslash . '\zs:.\{-}' . s:notslash . ',', '\\),\\(', 'g')
|
|
||||||
let open = '\(' . substitute(open, s:notslash . '\zs:.*$', '\\)', '')
|
|
||||||
let close = substitute(s:pat . cdefault,
|
|
||||||
\ s:notslash . '\zs,.\{-}' . s:notslash . ':', '\\),\\(', 'g')
|
|
||||||
let close = substitute(close, '^.\{-}' . s:notslash . ':', '\\(', '') . '\)'
|
|
||||||
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
|
|
||||||
else
|
|
||||||
let skip = 's:comment\|string'
|
|
||||||
endif
|
|
||||||
let skip = s:ParseSkip(skip)
|
|
||||||
" let restore_cursor = line(".") . "G" . virtcol(".") . "|"
|
|
||||||
" normal! H
|
|
||||||
" let restore_cursor = "normal!" . line(".") . "Gzt" . restore_cursor
|
|
||||||
let restore_cursor = virtcol(".") . "|"
|
|
||||||
normal! g0
|
|
||||||
let restore_cursor = line(".") . "G" . virtcol(".") . "|zs" . restore_cursor
|
|
||||||
normal! H
|
|
||||||
let restore_cursor = "normal!" . line(".") . "Gzt" . restore_cursor
|
|
||||||
execute restore_cursor
|
|
||||||
|
|
||||||
" Third step: call searchpair().
|
|
||||||
" Replace '\('--but not '\\('--with '\%(' and ',' with '\|'.
|
|
||||||
let openpat = substitute(open, '\(\\\@<!\(\\\\\)*\)\@<=\\(', '\\%(', 'g')
|
|
||||||
let openpat = substitute(openpat, ',', '\\|', 'g')
|
|
||||||
let closepat = substitute(close, '\(\\\@<!\(\\\\\)*\)\@<=\\(', '\\%(', 'g')
|
|
||||||
let closepat = substitute(closepat, ',', '\\|', 'g')
|
|
||||||
if skip =~ 'synID' && !(has("syntax") && exists("g:syntax_on"))
|
|
||||||
let skip = '0'
|
|
||||||
else
|
|
||||||
execute "if " . skip . "| let skip = '0' | endif"
|
|
||||||
endif
|
|
||||||
mark '
|
|
||||||
let level = v:count1
|
|
||||||
while level
|
|
||||||
if searchpair(openpat, '', closepat, a:spflag, skip) < 1
|
|
||||||
call s:CleanUp(restore_options, a:mode, startline, startcol)
|
|
||||||
return ""
|
|
||||||
endif
|
|
||||||
let level = level - 1
|
|
||||||
endwhile
|
|
||||||
|
|
||||||
" Restore options and return a string to restore the original position.
|
|
||||||
call s:CleanUp(restore_options, a:mode, startline, startcol)
|
|
||||||
return restore_cursor
|
|
||||||
endfun
|
|
||||||
|
|
||||||
" Search backwards for "if" or "while" or "<tag>" or ...
|
|
||||||
" and return "endif" or "endwhile" or "</tag>" or ... .
|
|
||||||
" For now, this uses b:match_words and the same script variables
|
|
||||||
" as s:Match_wrapper() . Later, it may get its own patterns,
|
|
||||||
" either from a buffer variable or passed as arguments.
|
|
||||||
" fun! s:Autocomplete()
|
|
||||||
" echo "autocomplete not yet implemented :-("
|
|
||||||
" if !exists("b:match_words") || b:match_words == ""
|
|
||||||
" return ""
|
|
||||||
" end
|
|
||||||
" let startpos = s:MultiMatch("bW")
|
|
||||||
"
|
|
||||||
" if startpos == ""
|
|
||||||
" return ""
|
|
||||||
" endif
|
|
||||||
" " - TODO: figure out whether 'if' or '<tag>' matched, and construct
|
|
||||||
" " - the appropriate closing.
|
|
||||||
" let matchline = getline(".")
|
|
||||||
" let curcol = col(".") - 1
|
|
||||||
" " - TODO: Change the s:all argument if there is a new set of match pats.
|
|
||||||
" let regexp = s:Wholematch(matchline, s:all, curcol)
|
|
||||||
" let suf = strlen(matchline) - matchend(matchline, regexp)
|
|
||||||
" let prefix = (curcol ? '^.\{' . curcol . '}\%(' : '^\%(')
|
|
||||||
" let suffix = (suf ? '\).\{' . suf . '}$' : '\)$')
|
|
||||||
" " Reconstruct the version with unresolved backrefs.
|
|
||||||
" let patBR = substitute(b:match_words.',', '[,:]*,[,:]*', ',', 'g')
|
|
||||||
" let patBR = substitute(patBR, ':\{2,}', ':', "g")
|
|
||||||
" " Now, set group and groupBR to the matching group: 'if:endif' or
|
|
||||||
" " 'while:endwhile' or whatever.
|
|
||||||
" let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, patBR)
|
|
||||||
" 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
|
|
||||||
" let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline)
|
|
||||||
" endif
|
|
||||||
" " let g:group = group
|
|
||||||
"
|
|
||||||
" " - TODO: Construct the closing from group.
|
|
||||||
" let fake = "end" . expand("<cword>")
|
|
||||||
" execute startpos
|
|
||||||
" return fake
|
|
||||||
" endfun
|
|
||||||
|
|
||||||
" Close all open structures. "Get the heck out of here!"
|
|
||||||
" fun! s:Gthhoh()
|
|
||||||
" let close = s:Autocomplete()
|
|
||||||
" while strlen(close)
|
|
||||||
" put=close
|
|
||||||
" let close = s:Autocomplete()
|
|
||||||
" endwhile
|
|
||||||
" endfun
|
|
||||||
|
|
||||||
" Parse special strings as typical skip arguments for searchpair():
|
|
||||||
" s:foo becomes (current syntax item) =~ foo
|
|
||||||
" S:foo becomes (current syntax item) !~ foo
|
|
||||||
" r:foo becomes (line before cursor) =~ foo
|
|
||||||
" 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') =~? '" .
|
|
||||||
\ strpart(skip,2) . "'"
|
|
||||||
elseif skip[0] == "S"
|
|
||||||
let skip = "synIDattr(synID(line('.'),col('.'),1),'name') !~? '" .
|
|
||||||
\ 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
|
|
||||||
endif
|
|
||||||
return skip
|
|
||||||
endfun
|
|
||||||
|
|
||||||
let &cpo = s:save_cpo
|
|
||||||
|
|
||||||
" vim:sts=2:sw=2:
|
|
||||||
Loading…
Reference in New Issue
Block a user