opensourcemirror
/
neovim
mirror of https://github.com/neovim/neovim.git
1
0
Fork 0
Code Issues Releases Wiki Activity

vim-patch:314dd79cac2a 

Update runtime files.
314dd79cac
This commit is contained in:
Justin M. Keyes 2019-07-29 03:16:37 +02:00
parent b5cb6c743a
commit 57fa9add79
15 changed files with 173 additions and 918 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
runtime/autoload/paste.vim
View File

@ -1,35 +1,25 @@
" Vim support file to help with paste mappings and menus " Vim support file to help with paste mappings and menus
" Maintainer: Bram Moolenaar <Bram@vim.org> " Maintainer: Bram Moolenaar <Bram@vim.org>
" Last Change: 2017 Aug 30 " Last Change: 2019 Jan 27
" Define the string to use for items that are present both in Edit, Popup and " Define the string to use for items that are present both in Edit, Popup and
" Toolbar menu. Also used in mswin.vim and macmap.vim. " Toolbar menu. Also used in mswin.vim and macmap.vim.
" Pasting blockwise and linewise selections is not possible in Insert and let paste#paste_cmd = {'n': ":call paste#Paste()<CR>"}
" Visual mode without the +virtualedit feature. They are pasted as if they let paste#paste_cmd['v'] = '"-c<Esc>' . paste#paste_cmd['n']
" were characterwise instead. Add to that some tricks to leave the cursor in let paste#paste_cmd['i'] = "\<c-\>\<c-o>\"+gP"
" the right position, also for "gi".
if has("virtualedit")
let paste#paste_cmd = {'n': ":call paste#Paste()<CR>"}
let paste#paste_cmd['v'] = '"-c<Esc>' . paste#paste_cmd['n']
let paste#paste_cmd['i'] = "\<c-\>\<c-o>\"+gP"
func! paste#Paste() func! paste#Paste()
let ove = &ve let ove = &ve
set ve=all set ve=all
normal! `^ normal! `^
if @+ != '' if @+ != ''
normal! "+gP normal! "+gP
endif endif
let c = col(".") let c = col(".")
normal! i normal! i
if col(".") < c " compensate for i<ESC> moving the cursor left if col(".") < c " compensate for i<ESC> moving the cursor left
normal! l normal! l
endif endif
let &ve = ove let &ve = ove
endfunc endfunc
else
let paste#paste_cmd = {'n': "\"=@+.'xy'<CR>gPFx\"_2x"}
let paste#paste_cmd['v'] = '"-c<Esc>gix<Esc>' . paste#paste_cmd['n'] . '"_x'
let paste#paste_cmd['i'] = 'x<Esc>' . paste#paste_cmd['n'] . '"_s'
endif

2
runtime/bugreport.vim
View File

@ -2,7 +2,7 @@
:" information about the environment of a possible bug in Vim. :" information about the environment of a possible bug in Vim.
:" :"
:" Maintainer: Bram Moolenaar <Bram@vim.org> :" Maintainer: Bram Moolenaar <Bram@vim.org>
:" Last change: 2005 Jun 12 :" Last change: 2019 Jan 27
:" :"
:" To use inside Vim: :" To use inside Vim:
:" :so $VIMRUNTIME/bugreport.vim :" :so $VIMRUNTIME/bugreport.vim

7
runtime/doc/eval.txt
View File

@ -5505,13 +5505,6 @@ line({expr}) The result is a Number, which is the line number of the file
line(".") line number of the cursor line(".") line number of the cursor
line("'t") line number of mark t line("'t") line number of mark t
line("'" . marker) line number of mark marker line("'" . marker) line number of mark marker
< *last-position-jump*
This autocommand jumps to the last known position in a file
just after opening it, if the '" mark is set: >
:au BufReadPost *
\ if line("'\"") > 1 && line("'\"") <= line("$") && &ft !~# 'commit'
\ | exe "normal! g`\""
\ | endif
line2byte({lnum}) *line2byte()* line2byte({lnum}) *line2byte()*
Return the byte count from the start of the buffer for line Return the byte count from the start of the buffer for line

10
runtime/doc/options.txt
View File

@ -295,12 +295,12 @@ files. You use this command: >
:setlocal makeprg=perlmake :setlocal makeprg=perlmake
You can switch back to using the global value by making the local value empty: > You can switch back to using the global value by making the local value empty: >
:setlocal makeprg= :setlocal makeprg=
This only works for a string option. For a boolean option you need to use the This only works for a string option. For a number or boolean option you need
"<" flag, like this: > to use the "<" flag, like this: >
:setlocal autoread< :setlocal autoread<
Note that for non-boolean options using "<" copies the global value to the Note that for non-boolean and non-number options using "<" copies the global
local value, it doesn't switch back to using the global value (that matters value to the local value, it doesn't switch back to using the global value
when the global value changes later). You can also use: > (that matters when the global value changes later). You can also use: >
:set path< :set path<
This will make the local value of 'path' empty, so that the global value is This will make the local value of 'path' empty, so that the global value is
used. Thus it does the same as: > used. Thus it does the same as: >

16
runtime/doc/pi_matchit.txt
View File

@ -1,6 +1,6 @@
*pi_matchit.txt* Extended "%" matching *pi_matchit.txt* Extended "%" matching
For Vim version 6.3. Last change: 2018 Dec 31 For Vim version 8.1. Last change: 2019 Jan 28
*matchit* *matchit.vim* *matchit* *matchit.vim*
@ -62,12 +62,8 @@ for how to specify matching patterns.
MODES: *matchit-modes* *matchit-v_%* *matchit-o_%* MODES: *matchit-modes* *matchit-v_%* *matchit-o_%*
Mostly, % and related motions (|g%| and |[%| and |]%|) work just like built-in Mostly, % and related motions (|g%| and |[%| and |]%|) should just work like built-in
motion commands in |Operator-pending| and |Visual| modes. However, you |motion| commands in |Operator-pending| and |Visual| modes (as of 8.1.648)
cannot make these motions |linewise| or |characterwise|, since the |:omap|s
that define them start with "v" in order to make the default behavior
inclusive. (See |o_v|.) In other words, "dV%" will not work. The
work-around is to go through Visual mode: "V%d" will work.
LANGUAGES: *matchit-languages* LANGUAGES: *matchit-languages*
@ -353,12 +349,6 @@ The back reference '\'.d refers to the same thing as '\'.b:match_table[d] in
============================================================================== ==============================================================================
5. Known Bugs and Limitations *matchit-bugs* 5. Known Bugs and Limitations *matchit-bugs*
The various |:vmap|s defined in the script (%, |g%|, |[%|, |]%|, |a%|) may
have undesired effects in Select mode |Select-mode-mapping|. At least, if you
want to replace the selection with any character in "ag%[]" there will be a
pause of |'updatetime'| first. E.g., "yV%" would normally work linewise, but
the plugin mapping makes it characterwise.
It would be nice if "\0" were recognized as the entire pattern. That is, it It would be nice if "\0" were recognized as the entire pattern. That is, it
would be nice if "foo:\end\0" had the same effect as "\(foo\):\end\1". would be nice if "foo:\end\0" had the same effect as "\(foo\):\end\1".

58
runtime/doc/usr_05.txt
View File

@ -11,12 +11,13 @@ Vim's capabilities. Or define your own macros.
|05.1| The vimrc file |05.1| The vimrc file
|05.2| The example vimrc file explained |05.2| The example vimrc file explained
|05.3| Simple mappings |05.3| The defaults.vim file explained
|05.4| Adding a package |05.4| Simple mappings
|05.5| Adding a plugin |05.5| Adding a package
|05.6| Adding a help file |05.6| Adding a plugin
|05.7| The option window |05.7| Adding a help file
|05.8| Often used options |05.8| The option window
|05.9| Often used options
Next chapter: |usr_06.txt| Using syntax highlighting Next chapter: |usr_06.txt| Using syntax highlighting
Previous chapter: |usr_04.txt| Making small changes Previous chapter: |usr_04.txt| Making small changes
@ -172,21 +173,12 @@ This switches on three very clever mechanisms:
automatically. Vim comes with these indent rules for a number of automatically. Vim comes with these indent rules for a number of
filetypes. See |:filetype-indent-on| and 'indentexpr'. filetypes. See |:filetype-indent-on| and 'indentexpr'.
>
autocmd FileType text setlocal textwidth=78
This makes Vim break text to avoid lines getting longer than 78 characters. *restore-cursor* *last-position-jump* >
But only for files that have been detected to be plain text. There are autocmd BufReadPost *
actually two parts here. "autocmd FileType text" is an autocommand. This \ if line("'\"") >= 1 && line("'\"") <= line("$") && &ft !~# 'commit'
defines that when the file type is set to "text" the following command is \ | exe "normal! g`\""
automatically executed. "setlocal textwidth=78" sets the 'textwidth' option \ | endif
to 78, but only locally in one file.
*restore-cursor* >
autocmd BufReadPost *
\ if line("'\"") > 1 && line("'\"") <= line("$") |
\ exe "normal! g`\"" |
\ endif
Another autocommand. This time it is used after reading any file. The Another autocommand. This time it is used after reading any file. The
complicated stuff after it checks if the '" mark is defined, and jumps to it complicated stuff after it checks if the '" mark is defined, and jumps to it
@ -195,8 +187,22 @@ from the previous line. That avoids a line getting very long.
See |line-continuation|. This only works in a Vim script file, not when See |line-continuation|. This only works in a Vim script file, not when
typing commands at the command-line. typing commands at the command-line.
>
command DiffOrig vert new | set bt=nofile | r ++edit # | 0d_ | diffthis
\ | wincmd p | diffthis
This adds the ":DiffOrig" command. Use this in a modified buffer to see the
differences with the file it was loaded from. See |diff|.
>
set nolangremap
Prevent that the langmap option applies to characters that result from a
mapping. If set (default), this may break plugins (but it's backward
compatible). See 'langremap'.
============================================================================== ==============================================================================
*05.3* Simple mappings *05.4* Simple mappings
A mapping enables you to bind a set of Vim commands to a single key. Suppose, A mapping enables you to bind a set of Vim commands to a single key. Suppose,
for example, that you need to surround certain words with curly braces. In for example, that you need to surround certain words with curly braces. In
@ -243,7 +249,7 @@ The ":map" command (with no arguments) lists your current mappings. At
least the ones for Normal mode. More about mappings in section |40.1|. least the ones for Normal mode. More about mappings in section |40.1|.
============================================================================== ==============================================================================
*05.4* Adding a package *add-package* *vimball-install* *05.5* Adding a package *add-package* *vimball-install*
A package is a set of files that you can add to Vim. There are two kinds of A package is a set of files that you can add to Vim. There are two kinds of
packages: optional and automatically loaded on startup. packages: optional and automatically loaded on startup.
@ -283,7 +289,7 @@ an archive or as a repository. For an archive you can follow these steps:
More information about packages can be found here: |packages|. More information about packages can be found here: |packages|.
============================================================================== ==============================================================================
*05.5* Adding a plugin *add-plugin* *plugin* *05.6* Adding a plugin *add-plugin* *plugin*
Vim's functionality can be extended by adding plugins. A plugin is nothing Vim's functionality can be extended by adding plugins. A plugin is nothing
more than a Vim script file that is loaded automatically when Vim starts. You more than a Vim script file that is loaded automatically when Vim starts. You
@ -420,7 +426,7 @@ Further reading:
|new-filetype| How to detect a new file type. |new-filetype| How to detect a new file type.
============================================================================== ==============================================================================
*05.6* Adding a help file *add-local-help* *05.7* Adding a help file *add-local-help*
If you are lucky, the plugin you installed also comes with a help file. We If you are lucky, the plugin you installed also comes with a help file. We
will explain how to install the help file, so that you can easily find help will explain how to install the help file, so that you can easily find help
@ -453,7 +459,7 @@ them through the tag.
For writing a local help file, see |write-local-help|. For writing a local help file, see |write-local-help|.
============================================================================== ==============================================================================
*05.7* The option window *05.8* The option window
If you are looking for an option that does what you want, you can search in If you are looking for an option that does what you want, you can search in
the help files here: |options|. Another way is by using this command: > the help files here: |options|. Another way is by using this command: >
@ -492,7 +498,7 @@ border. This is what the 'scrolloff' option does, it specifies an offset
from the window border where scrolling starts. from the window border where scrolling starts.
============================================================================== ==============================================================================
*05.8* Often used options *05.9* Often used options
There are an awful lot of options. Most of them you will hardly ever use. There are an awful lot of options. Most of them you will hardly ever use.
Some of the more useful ones will be mentioned here. Don't forget you can Some of the more useful ones will be mentioned here. Don't forget you can

2
runtime/doc/usr_11.txt
View File

@ -120,7 +120,7 @@ the resulting files if they are what you expected.
USING A SPECIFIC SWAP FILE USING A SPECIFIC SWAP FILE
If you know which swap file needs to be used, you can recover by giving the If you know which swap file needs to be used, you can recover by giving the
swap file name. Vim will then finds out the name of the original file from swap file name. Vim will then find out the name of the original file from
the swap file. the swap file.
Example: > Example: >

2
runtime/doc/usr_41.txt
View File

@ -770,7 +770,7 @@ System functions and manipulation of files:
systemlist() get the result of a shell command as a list systemlist() get the result of a shell command as a list
hostname() name of the system hostname() name of the system
readfile() read a file into a List of lines readfile() read a file into a List of lines
writefile() write a List of lines into a file writefile() write a List of lines or Blob into a file
Date and Time: *date-functions* *time-functions* Date and Time: *date-functions* *time-functions*
getftime() get last modification time of a file getftime() get last modification time of a file

3
runtime/filetype.vim
View File

@ -1,7 +1,7 @@
" Vim support file to detect file types " Vim support file to detect file types
" "
" Maintainer: Bram Moolenaar <Bram@vim.org> " Maintainer: Bram Moolenaar <Bram@vim.org>
" Last Change: 2019 Jan 18 " Last Change: 2019 Jan 28
" Listen very carefully, I will say this only once " Listen very carefully, I will say this only once
if exists("did_load_filetypes") if exists("did_load_filetypes")
@ -93,6 +93,7 @@ au BufNewFile,BufRead proftpd.conf* call s:StarSetf('apachestyle')
" Apache config file " Apache config file
au BufNewFile,BufRead .htaccess,*/etc/httpd/*.conf setf apache au BufNewFile,BufRead .htaccess,*/etc/httpd/*.conf setf apache
au BufNewFile,BufRead */etc/apache2/sites-*/*.com setf apache
" XA65 MOS6510 cross assembler " XA65 MOS6510 cross assembler
au BufNewFile,BufRead *.a65 setf a65 au BufNewFile,BufRead *.a65 setf a65

30
runtime/indent/sh.vim
View File

@ -3,10 +3,11 @@
" Maintainer: Christian Brabandt <cb@256bit.org> " Maintainer: Christian Brabandt <cb@256bit.org>
" Original Author: Nikolai Weibull <now@bitwi.se> " Original Author: Nikolai Weibull <now@bitwi.se>
" Previous Maintainer: Peter Aronoff <telemachus@arpinum.org> " Previous Maintainer: Peter Aronoff <telemachus@arpinum.org>
" Latest Revision: 2018-03-26 " Latest Revision: 2019-02-02
" License: Vim (see :h license) " License: Vim (see :h license)
" Repository: https://github.com/chrisbra/vim-sh-indent " Repository: https://github.com/chrisbra/vim-sh-indent
" Changelog: " Changelog:
" 20190201 - Better check for closing if sections
" 20180724 - make check for zsh syntax more rigid (needs word-boundaries) " 20180724 - make check for zsh syntax more rigid (needs word-boundaries)
" 20180326 - better support for line continuation " 20180326 - better support for line continuation
" 20180325 - better detection of function definitions " 20180325 - better detection of function definitions
@ -59,6 +60,7 @@ function! s:indent_value(option)
endfunction endfunction
function! GetShIndent() function! GetShIndent()
let curline = getline(v:lnum)
let lnum = prevnonblank(v:lnum - 1) let lnum = prevnonblank(v:lnum - 1)
if lnum == 0 if lnum == 0
return 0 return 0
@ -72,7 +74,7 @@ function! GetShIndent()
" Check contents of previous lines " Check contents of previous lines
if line =~ '^\s*\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\|foreach\)\>' || if line =~ '^\s*\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\|foreach\)\>' ||
\ (&ft is# 'zsh' && line =~ '\<\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\|foreach\)\>') \ (&ft is# 'zsh' && line =~ '\<\%(if\|then\|do\|else\|elif\|case\|while\|until\|for\|select\|foreach\)\>')
if line !~ '\<\%(fi\|esac\|done\|end\)\>\s*\%(#.*\)\=$' if !s:is_end_expression(line)
let ind += s:indent_value('default') let ind += s:indent_value('default')
endif endif
elseif s:is_case_label(line, pnum) elseif s:is_case_label(line, pnum)
@ -90,7 +92,10 @@ function! GetShIndent()
endif endif
elseif s:end_block(line) && !s:start_block(line) elseif s:end_block(line) && !s:start_block(line)
let ind -= s:indent_value('default') let ind -= s:indent_value('default')
elseif pnum != 0 && s:is_continuation_line(pline) && !s:end_block(getline(v:lnum)) elseif pnum != 0 &&
\ s:is_continuation_line(pline) &&
\ !s:end_block(curline) &&
\ !s:is_end_expression(curline)
" only add indent, if line and pline is in the same block " only add indent, if line and pline is in the same block
let i = v:lnum let i = v:lnum
let ind2 = indent(s:find_continued_lnum(pnum)) let ind2 = indent(s:find_continued_lnum(pnum))
@ -106,8 +111,15 @@ function! GetShIndent()
let pine = line let pine = line
" Check content of current line " Check content of current line
let line = getline(v:lnum) let line = curline
if line =~ '^\s*\%(then\|do\|else\|elif\|fi\|done\|end\)\>' || s:end_block(line) " Current line is a endif line, so get indent from start of "if condition" line
" TODO: should we do the same for other "end" lines?
if curline =~ '^\s*\%(fi\)\s*\%(#.*\)\=$'
let previous_line = search('if.\{-\};\s*then\s*\%(#.*\)\=$', 'bnW')
if previous_line > 0
let ind = indent(previous_line)
endif
elseif line =~ '^\s*\%(then\|do\|else\|elif\|done\|end\)\>' || s:end_block(line)
let ind -= s:indent_value('default') let ind -= s:indent_value('default')
elseif line =~ '^\s*esac\>' && s:is_case_empty(getline(v:lnum - 1)) elseif line =~ '^\s*esac\>' && s:is_case_empty(getline(v:lnum - 1))
let ind -= s:indent_value('default') let ind -= s:indent_value('default')
@ -210,8 +222,8 @@ endfunction
function! s:is_here_doc(line) function! s:is_here_doc(line)
if a:line =~ '^\w\+$' if a:line =~ '^\w\+$'
let here_pat = '<<-\?'. s:escape(a:line). '\$' let here_pat = '<<-\?'. s:escape(a:line). '\$'
return search(here_pat, 'bnW') > 0 return search(here_pat, 'bnW') > 0
endif endif
return 0 return 0
endfunction endfunction
@ -256,5 +268,9 @@ function! s:is_comment(line)
return a:line =~ '^\s*#' return a:line =~ '^\s*#'
endfunction endfunction
function! s:is_end_expression(line)
return a:line =~ '\<\%(fi\|esac\|done\|end\)\>\s*\%(#.*\)\=$'
endfunction
let &cpo = s:cpo_save let &cpo = s:cpo_save
unlet s:cpo_save unlet s:cpo_save

13
runtime/indent/xml.vim
View File

@ -1,9 +1,11 @@
" Language: xml " Language: xml
" Repository: https://github.com/chrisbra/vim-xml-ftplugin " Repository: https://github.com/chrisbra/vim-xml-ftplugin
" Last Changed: Dec 07th, 2018 " Last Changed: Jan 28, 2019
" Maintainer: Christian Brabandt <cb@256bit.org> " Maintainer: Christian Brabandt <cb@256bit.org>
" Previous Maintainer: Johannes Zellner <johannes@zellner.org> " Previous Maintainer: Johannes Zellner <johannes@zellner.org>
" Last Change: " Last Change:
" 20190128 - Make sure to find previous tag
" https://github.com/chrisbra/vim-xml-ftplugin/issues/4
" 20181116 - Fix indentation when tags start with a colon or an underscore " 20181116 - Fix indentation when tags start with a colon or an underscore
" https://github.com/vim/vim/pull/926 " https://github.com/vim/vim/pull/926
" 20181022 - Do not overwrite indentkeys setting " 20181022 - Do not overwrite indentkeys setting
@ -88,15 +90,16 @@ endfun
fun! XmlIndentGet(lnum, use_syntax_check) fun! XmlIndentGet(lnum, use_syntax_check)
" Find a non-empty line above the current line. " Find a non-empty line above the current line.
let plnum = prevnonblank(a:lnum - 1) let plnum = prevnonblank(a:lnum - 1)
" Find previous line with a tag (regardless whether open or closed)
let ptag = search('.\{-}<[/:A-Z_a-z]', 'bnw')
" Hit the start of the file, use zero indent. " Hit the start of the file, use zero indent.
if plnum == 0 if plnum == 0
return 0 return 0
endif endif
let syn_name = '' " Find previous line with a tag (regardless whether open or closed,
" but always start restrict the match to a line before the current one
let ptag_pattern = '\%(.\{-}<[/:A-Z_a-z]\)'. '\%(\&\%<'. line('.').'l\)'
let ptag = search(ptag_pattern, 'bnw')
let syn_name = ''
if a:use_syntax_check if a:use_syntax_check
let check_lnum = <SID>XmlIndentSynCheck(plnum) let check_lnum = <SID>XmlIndentSynCheck(plnum)
let check_alnum = <SID>XmlIndentSynCheck(a:lnum) let check_alnum = <SID>XmlIndentSynCheck(a:lnum)

22
runtime/menu.vim
View File

@ -2,7 +2,7 @@
" You can also use this as a start for your own set of menus. " You can also use this as a start for your own set of menus.
" "
" Maintainer: Bram Moolenaar <Bram@vim.org> " Maintainer: Bram Moolenaar <Bram@vim.org>
" Last Change: 2018 May 17 " Last Change: 2019 Jan 27
" Note that ":an" (short for ":anoremenu") is often used to make a menu work " Note that ":an" (short for ":anoremenu") is often used to make a menu work
" in all modes and avoid side effects from mappings defined by the user. " in all modes and avoid side effects from mappings defined by the user.
@ -853,17 +853,15 @@ an 70.300 &Window.&New<Tab>^Wn <C-W>n
an 70.310 &Window.S&plit<Tab>^Ws <C-W>s an 70.310 &Window.S&plit<Tab>^Ws <C-W>s
an 70.320 &Window.Sp&lit\ To\ #<Tab>^W^^ <C-W><C-^> an 70.320 &Window.Sp&lit\ To\ #<Tab>^W^^ <C-W><C-^>
an 70.330 &Window.Split\ &Vertically<Tab>^Wv <C-W>v an 70.330 &Window.Split\ &Vertically<Tab>^Wv <C-W>v
if has("vertsplit") an <silent> 70.332 &Window.Split\ File\ E&xplorer :call MenuExplOpen()<CR>
an <silent> 70.332 &Window.Split\ File\ E&xplorer :call MenuExplOpen()<CR> if !exists("*MenuExplOpen")
if !exists("*MenuExplOpen") fun MenuExplOpen()
fun MenuExplOpen() if @% == ""
if @% == "" 20vsp .
20vsp . else
else exe "20vsp " . s:FnameEscape(expand("%:p:h"))
exe "20vsp " . s:FnameEscape(expand("%:p:h")) endif
endif endfun
endfun
endif
endif endif
an 70.335 &Window.-SEP1- <Nop> an 70.335 &Window.-SEP1- <Nop>
an 70.340 &Window.&Close<Tab>^Wc :confirm close<CR> an 70.340 &Window.&Close<Tab>^Wc :confirm close<CR>

74
runtime/optwin.vim
View File

@ -1,7 +1,7 @@
" These commands create the option window. " These commands create the option window.
" "
" Maintainer: Bram Moolenaar <Bram@vim.org> " Maintainer: Bram Moolenaar <Bram@vim.org>
" Last Change: 2018 May 15 " Last Change: 2019 Jan 27
" If there already is an option window, jump to that one. " If there already is an option window, jump to that one.
let buf = bufnr('option-window') let buf = bufnr('option-window')
@ -395,11 +395,9 @@ endif
call <SID>Header("syntax, highlighting and spelling") call <SID>Header("syntax, highlighting and spelling")
call append("$", "background\t\"dark\" or \"light\"; the background color brightness") call append("$", "background\t\"dark\" or \"light\"; the background color brightness")
call <SID>OptionG("bg", &bg) call <SID>OptionG("bg", &bg)
if has("autocmd") call append("$", "filetype\ttype of file; triggers the FileType event when set")
call append("$", "filetype\ttype of file; triggers the FileType event when set") call append("$", "\t(local to buffer)")
call append("$", "\t(local to buffer)") call <SID>OptionL("ft")
call <SID>OptionL("ft")
endif
if has("syntax") if has("syntax")
call append("$", "syntax\tname of syntax highlighting used") call append("$", "syntax\tname of syntax highlighting used")
call append("$", "\t(local to buffer)") call append("$", "\t(local to buffer)")
@ -454,10 +452,8 @@ if has("statusline")
endif endif
call append("$", "equalalways\tmake all windows the same size when adding/removing windows") call append("$", "equalalways\tmake all windows the same size when adding/removing windows")
call <SID>BinOptionG("ea", &ea) call <SID>BinOptionG("ea", &ea)
if has("vertsplit") call append("$", "eadirection\tin which direction 'equalalways' works: \"ver\", \"hor\" or \"both\"")
call append("$", "eadirection\tin which direction 'equalalways' works: \"ver\", \"hor\" or \"both\"") call <SID>OptionG("ead", &ead)
call <SID>OptionG("ead", &ead)
endif
call append("$", "winheight\tminimal number of lines used for the current window") call append("$", "winheight\tminimal number of lines used for the current window")
call append("$", " \tset wh=" . &wh) call append("$", " \tset wh=" . &wh)
call append("$", "winminheight\tminimal number of lines used for any window") call append("$", "winminheight\tminimal number of lines used for any window")
@ -465,15 +461,13 @@ call append("$", " \tset wmh=" . &wmh)
call append("$", "winfixheight\tkeep the height of the window") call append("$", "winfixheight\tkeep the height of the window")
call append("$", "\t(local to window)") call append("$", "\t(local to window)")
call <SID>BinOptionL("wfh") call <SID>BinOptionL("wfh")
if has("vertsplit")
call append("$", "winfixwidth\tkeep the width of the window") call append("$", "winfixwidth\tkeep the width of the window")
call append("$", "\t(local to window)") call append("$", "\t(local to window)")
call <SID>BinOptionL("wfw") call <SID>BinOptionL("wfw")
call append("$", "winwidth\tminimal number of columns used for the current window") call append("$", "winwidth\tminimal number of columns used for the current window")
call append("$", " \tset wiw=" . &wiw) call append("$", " \tset wiw=" . &wiw)
call append("$", "winminwidth\tminimal number of columns used for any window") call append("$", "winminwidth\tminimal number of columns used for any window")
call append("$", " \tset wmw=" . &wmw) call append("$", " \tset wmw=" . &wmw)
endif
call append("$", "helpheight\tinitial height of the help window") call append("$", "helpheight\tinitial height of the help window")
call append("$", " \tset hh=" . &hh) call append("$", " \tset hh=" . &hh)
if has("quickfix") if has("quickfix")
@ -490,22 +484,16 @@ call append("$", "\tto a buffer")
call <SID>OptionG("swb", &swb) call <SID>OptionG("swb", &swb)
call append("$", "splitbelow\ta new window is put below the current one") call append("$", "splitbelow\ta new window is put below the current one")
call <SID>BinOptionG("sb", &sb) call <SID>BinOptionG("sb", &sb)
if has("vertsplit") call append("$", "splitright\ta new window is put right of the current one")
call append("$", "splitright\ta new window is put right of the current one") call <SID>BinOptionG("spr", &spr)
call <SID>BinOptionG("spr", &spr) call append("$", "scrollbind\tthis window scrolls together with other bound windows")
endif call append("$", "\t(local to window)")
if has("scrollbind") call <SID>BinOptionL("scb")
call append("$", "scrollbind\tthis window scrolls together with other bound windows") call append("$", "scrollopt\t\"ver\", \"hor\" and/or \"jump\"; list of options for 'scrollbind'")
call append("$", "\t(local to window)") call <SID>OptionG("sbo", &sbo)
call <SID>BinOptionL("scb") call append("$", "cursorbind\tthis window's cursor moves together with other bound windows")
call append("$", "scrollopt\t\"ver\", \"hor\" and/or \"jump\"; list of options for 'scrollbind'") call append("$", "\t(local to window)")
call <SID>OptionG("sbo", &sbo) call <SID>BinOptionL("crb")
endif
if has("cursorbind")
call append("$", "cursorbind\tthis window's cursor moves together with other bound windows")
call append("$", "\t(local to window)")
call <SID>BinOptionL("crb")
endif
if has("terminal") if has("terminal")
call append("$", "termsize\tsize of a terminal window") call append("$", "termsize\tsize of a terminal window")
call append("$", "\t(local to window)") call append("$", "\t(local to window)")
@ -1040,12 +1028,10 @@ if has("wildmenu")
call append("$", "wildmenu\tcommand-line completion shows a list of matches") call append("$", "wildmenu\tcommand-line completion shows a list of matches")
call <SID>BinOptionG("wmnu", &wmnu) call <SID>BinOptionG("wmnu", &wmnu)
endif endif
if has("vertsplit") call append("$", "cedit\tkey used to open the command-line window")
call append("$", "cedit\tkey used to open the command-line window") call <SID>OptionG("cedit", &cedit)
call <SID>OptionG("cedit", &cedit) call append("$", "cmdwinheight\theight of the command-line window")
call append("$", "cmdwinheight\theight of the command-line window") call <SID>OptionG("cwh", &cwh)
call <SID>OptionG("cwh", &cwh)
endif
call <SID>Header("executing external commands") call <SID>Header("executing external commands")
@ -1208,14 +1194,10 @@ endif
call <SID>Header("various") call <SID>Header("various")
if has("virtualedit") call append("$", "virtualedit\twhen to use virtual editing: \"block\", \"insert\" and/or \"all\"")
call append("$", "virtualedit\twhen to use virtual editing: \"block\", \"insert\" and/or \"all\"") call <SID>OptionG("ve", &ve)
call <SID>OptionG("ve", &ve) call append("$", "eventignore\tlist of autocommand events which are to be ignored")
endif call <SID>OptionG("ei", &ei)
if has("autocmd")
call append("$", "eventignore\tlist of autocommand events which are to be ignored")
call <SID>OptionG("ei", &ei)
endif
call append("$", "loadplugins\tload plugin scripts when starting up") call append("$", "loadplugins\tload plugin scripts when starting up")
call <SID>BinOptionG("lpl", &lpl) call <SID>BinOptionG("lpl", &lpl)
call append("$", "exrc\tenable reading .vimrc/.exrc/.gvimrc in the current directory") call append("$", "exrc\tenable reading .vimrc/.exrc/.gvimrc in the current directory")

802
runtime/plugin/matchit.vim
View File

@ -1,14 +1,13 @@
" matchit.vim: (global plugin) Extended "%" matching " matchit.vim: (global plugin) Extended "%" matching
" Last Change: 2018 Dec 31 " Maintainer: Christian Brabandt
" Maintainer: Benji Fisher PhD <benji@member.AMS.org> " Version: 1.15
" Version: 1.13.3, for Vim 6.3+ " Last Change: 2019 Jan 28
" Fix from Tommy Allen included. " Repository: https://github.com/chrisbra/matchit
" Fix from Fernando Torres included. " Previous URL:http://www.vim.org/script.php?script_id=39
" Improvement from Ken Takata included. " Previous Maintainer: Benji Fisher PhD <benji@member.AMS.org>
" URL: http://www.vim.org/script.php?script_id=39
" Documentation: " Documentation:
" The documentation is in a separate file, matchit.txt . " The documentation is in a separate file: ../doc/matchit.txt .
" Credits: " Credits:
" Vim editor by Bram Moolenaar (Thanks, Bram!) " Vim editor by Bram Moolenaar (Thanks, Bram!)
@ -39,778 +38,55 @@
" work but extend it. " work but extend it.
" Allow user to prevent loading and prevent duplicate loading. " Allow user to prevent loading and prevent duplicate loading.
if exists("loaded_matchit") || &cp if exists("g:loaded_matchit") || &cp
finish finish
endif endif
let loaded_matchit = 1 let g:loaded_matchit = 1
let s:last_mps = ""
let s:last_words = ":"
let s:patBR = ""
let s:save_cpo = &cpo let s:save_cpo = &cpo
set cpo&vim set cpo&vim
nnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'n') <CR> nnoremap <silent> <Plug>(MatchitNormalForward) :<C-U>call matchit#Match_wrapper('',1,'n')<CR>
nnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'n') <CR> nnoremap <silent> <Plug>(MatchitNormalBackward) :<C-U>call matchit#Match_wrapper('',0,'n')<CR>
vnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'v') <CR>m'gv`` vnoremap <silent> <Plug>(MatchitVisualForward) :<C-U>call matchit#Match_wrapper('',1,'v')<CR>m'gv``
vnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'v') <CR>m'gv`` vnoremap <silent> <Plug>(MatchitVisualBackward) :<C-U>call matchit#Match_wrapper('',0,'v')<CR>m'gv``
onoremap <silent> % v:<C-U>call <SID>Match_wrapper('',1,'o') <CR> onoremap <silent> <Plug>(MatchitOperationForward) :<C-U>call matchit#Match_wrapper('',1,'o')<CR>
onoremap <silent> g% v:<C-U>call <SID>Match_wrapper('',0,'o') <CR> onoremap <silent> <Plug>(MatchitOperationBackward) :<C-U>call matchit#Match_wrapper('',0,'o')<CR>
nmap <silent> % <Plug>(MatchitNormalForward)
nmap <silent> g% <Plug>(MatchitNormalBackward)
xmap <silent> % <Plug>(MatchitVisualForward)
xmap <silent> g% <Plug>(MatchitVisualBackward)
omap <silent> % <Plug>(MatchitOperationForward)
omap <silent> g% <Plug>(MatchitOperationBackward)
" Analogues of [{ and ]} using matching patterns: " Analogues of [{ and ]} using matching patterns:
nnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "n") <CR> nnoremap <silent> <Plug>(MatchitNormalMultiBackward) :<C-U>call matchit#MultiMatch("bW", "n")<CR>
nnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "n") <CR> nnoremap <silent> <Plug>(MatchitNormalMultiForward) :<C-U>call matchit#MultiMatch("W", "n")<CR>
vmap [% <Esc>[%m'gv`` vnoremap <silent> <Plug>(MatchitVisualMultiBackward) :<C-U>call matchit#MultiMatch("bW", "n")<CR>m'gv``
vmap ]% <Esc>]%m'gv`` vnoremap <silent> <Plug>(MatchitVisualMultiForward) :<C-U>call matchit#MultiMatch("W", "n")<CR>m'gv``
" vnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "v") <CR>m'gv`` onoremap <silent> <Plug>(MatchitOperationMultiBackward) :<C-U>call matchit#MultiMatch("bW", "o")<CR>
" vnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "v") <CR>m'gv`` onoremap <silent> <Plug>(MatchitOperationMultiForward) :<C-U>call matchit#MultiMatch("W", "o")<CR>
onoremap <silent> [% v:<C-U>call <SID>MultiMatch("bW", "o") <CR>
onoremap <silent> ]% v:<C-U>call <SID>MultiMatch("W", "o") <CR> nmap <silent> [% <Plug>(MatchitNormalMultiBackward)
nmap <silent> ]% <Plug>(MatchitNormalMultiForward)
xmap <silent> [% <Plug>(MatchitVisualMultiBackward)
xmap <silent> ]% <Plug>(MatchitVisualMultiForward)
omap <silent> [% <Plug>(MatchitOperationMultiBackward)
omap <silent> ]% <Plug>(MatchitOperationMultiForward)
" text object: " text object:
vmap a% <Esc>[%v]% vmap <silent> <Plug>(MatchitVisualTextObject) <Plug>(MatchitVisualMultiBackward)o<Plug>(MatchitVisualMultiForward)
xmap a% <Plug>(MatchitVisualTextObject)
" 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 = ""
if exists("b:match_ignorecase") && b:match_ignorecase != &ic
let restore_options .= (&ic ? " " : " no") . "ignorecase"
let &ignorecase = b:match_ignorecase
endif
if &ve != ''
let restore_options = " ve=" . &ve . restore_options
set ve=
endif
" 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_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) ? "," : "") .
\ '\/\*:\*\/,#\s*if\%(def\)\=:#\s*else\>:#\s*elif\>:#\s*endif\>'
" s:all = pattern with all the keywords
let match_words = match_words . (strlen(match_words) ? "," : "") . default
let s:last_words = match_words
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
" Reconstruct the version with unresolved backrefs.
let s:patBR = substitute(match_words.',',
\ s:notslash.'\zs[,:]*,[,:]*', ',', '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
" 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
"
" 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 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 view = winsaveview()
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.
call winrestview(view)
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, ...)
if strlen(a:options)
execute "set" a:options
endif
" 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!
call cursor(0, endcol)
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 " 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 " script is run, buffer variables will be saved. These can be used directly
" or viewed using the menu items below. " or viewed using the menu items below.
if !exists(":MatchDebug") if !exists(":MatchDebug")
command! -nargs=0 MatchDebug call s:Match_debug() command! -nargs=0 MatchDebug call matchit#Match_debug()
endif 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 = ""
if exists("b:match_ignorecase") && b:match_ignorecase != &ic
let restore_options .= (&ic ? " " : " no") . "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) ? "," : "") .
\ '\/\*:\*\/,#\s*if\%(def\)\=:#\s*else\>:#\s*elif\>:#\s*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
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 . (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 view = winsaveview()
" 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
try
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
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 view dict to restore the original position.
call s:CleanUp(restore_options, a:mode, startline, startcol)
return view
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 let &cpo = s:save_cpo
unlet s:save_cpo unlet s:save_cpo
" vim:sts=2:sw=2: " vim:sts=2:sw=2:et:

4
runtime/syntax/debchangelog.vim
View File

@ -3,7 +3,7 @@
" Maintainer: Debian Vim Maintainers " Maintainer: Debian Vim Maintainers
" Former Maintainers: Gerfried Fuchs <alfie@ist.org> " Former Maintainers: Gerfried Fuchs <alfie@ist.org>
" Wichert Akkerman <wakkerma@debian.org> " Wichert Akkerman <wakkerma@debian.org>
" Last Change: 2018 Oct 30 " Last Change: 2019 Jan 26
" URL: https://salsa.debian.org/vim-team/vim-debian/blob/master/syntax/debchangelog.vim " URL: https://salsa.debian.org/vim-team/vim-debian/blob/master/syntax/debchangelog.vim
" Standard syntax initialization " Standard syntax initialization
@ -14,7 +14,7 @@ endif
" Case doesn't matter for us " Case doesn't matter for us
syn case ignore syn case ignore
let s:urgency='urgency=\(low\|medium\|high\|critical\)\( [^[:space:],][^,]*\)\=' let s:urgency='urgency=\(low\|medium\|high\|emergency\|critical\)\( [^[:space:],][^,]*\)\='
let s:binNMU='binary-only=yes' let s:binNMU='binary-only=yes'
" Define some common expressions we can use later on " Define some common expressions we can use later on