mirror of
https://github.com/neovim/neovim.git
synced 2024-12-20 11:15:14 -07:00
811 lines
33 KiB
VimL
811 lines
33 KiB
VimL
" Vim completion script
|
|
" Language: All languages, uses existing syntax highlighting rules
|
|
" Maintainer: David Fishburn <dfishburn dot vim at gmail dot com>
|
|
" Version: 15.0
|
|
" Last Change: 2021 Apr 27
|
|
" Usage: For detailed help, ":help ft-syntax-omni"
|
|
|
|
" History
|
|
"
|
|
" Version 15.0
|
|
" - SyntaxComplete ignored all buffer specific overrides, always used global
|
|
" https://github.com/vim/vim/issues/8153
|
|
"
|
|
" Version 14.0
|
|
" - Fixed issue with single quotes and is_keyword
|
|
" https://github.com/vim/vim/issues/7463
|
|
"
|
|
" Version 13.0
|
|
" - Extended the option omni_syntax_group_include_{filetype}
|
|
" to accept a comma separated list of regex's rather than
|
|
" string. For example, for the javascript filetype you could
|
|
" use:
|
|
" let g:omni_syntax_group_include_javascript = 'javascript\w\+,jquery\w\+'
|
|
" - Some syntax files (perl.vim) use the match // syntax as a mechanism
|
|
" to identify keywords. This update attempts to parse the
|
|
" match syntax and pull out syntax items which are at least
|
|
" 3 words or more.
|
|
"
|
|
" Version 12.0
|
|
" - It is possible to have '-' as part of iskeyword, when
|
|
" checking for character ranges, tighten up the regex.
|
|
" E688: More targets than List items.
|
|
"
|
|
" Version 11.0
|
|
" - Corrected which characters required escaping during
|
|
" substitution calls.
|
|
"
|
|
" Version 10.0
|
|
" - Cycle through all the character ranges specified in the
|
|
" iskeyword option and build a list of valid word separators.
|
|
" Prior to this change, only actual characters were used,
|
|
" where for example ASCII "45" == "-". If "45" were used
|
|
" in iskeyword the hyphen would not be picked up.
|
|
" This introduces a new option, since the character ranges
|
|
" specified could be multibyte:
|
|
" let g:omni_syntax_use_single_byte = 1
|
|
" - This by default will only allow single byte ASCII
|
|
" characters to be added and an additional check to ensure
|
|
" the character is printable (see documentation for isprint).
|
|
"
|
|
" Version 9.0
|
|
" - Add the check for cpo.
|
|
"
|
|
" Version 8.0
|
|
" - Updated SyntaxCSyntaxGroupItems()
|
|
" - Some additional syntax items were also allowed
|
|
" on nextgroup= lines which were ignored by default.
|
|
" Now these lines are processed independently.
|
|
"
|
|
" Version 7.0
|
|
" - Updated syntaxcomplete#OmniSyntaxList()
|
|
" - Looking up the syntax groups defined from a syntax file
|
|
" looked for only 1 format of {filetype}GroupName, but some
|
|
" syntax writers use this format as well:
|
|
" {b:current_syntax}GroupName
|
|
" - OmniSyntaxList() will now check for both if the first
|
|
" method does not find a match.
|
|
"
|
|
" Version 6.0
|
|
" - Added syntaxcomplete#OmniSyntaxList()
|
|
" - Allows other plugins to use this for their own
|
|
" purposes.
|
|
" - It will return a List of all syntax items for the
|
|
" syntax group name passed in.
|
|
" - XPTemplate for SQL will use this function via the
|
|
" sqlcomplete plugin to populate a Choose box.
|
|
"
|
|
" Version 5.0
|
|
" - Updated SyntaxCSyntaxGroupItems()
|
|
" - When processing a list of syntax groups, the final group
|
|
" was missed in function SyntaxCSyntaxGroupItems.
|
|
"
|
|
" Set completion with CTRL-X CTRL-O to autoloaded function.
|
|
" This check is in place in case this script is
|
|
" sourced directly instead of using the autoload feature.
|
|
if exists('+omnifunc')
|
|
" Do not set the option if already set since this
|
|
" results in an E117 warning.
|
|
if &omnifunc == ""
|
|
setlocal omnifunc=syntaxcomplete#Complete
|
|
endif
|
|
endif
|
|
|
|
if exists('g:loaded_syntax_completion')
|
|
finish
|
|
endif
|
|
let g:loaded_syntax_completion = 150
|
|
|
|
" Turn on support for line continuations when creating the script
|
|
let s:cpo_save = &cpo
|
|
set cpo&vim
|
|
|
|
" Set ignorecase to the ftplugin standard
|
|
" This is the default setting, but if you define a buffer local
|
|
" variable you can override this on a per filetype.
|
|
if !exists('g:omni_syntax_ignorecase')
|
|
let g:omni_syntax_ignorecase = &ignorecase
|
|
endif
|
|
|
|
" Indicates whether we should use the iskeyword option to determine
|
|
" how to split words.
|
|
" This is the default setting, but if you define a buffer local
|
|
" variable you can override this on a per filetype.
|
|
if !exists('g:omni_syntax_use_iskeyword')
|
|
let g:omni_syntax_use_iskeyword = 1
|
|
endif
|
|
|
|
" When using iskeyword, this setting controls whether the characters
|
|
" should be limited to single byte characters.
|
|
if !exists('g:omni_syntax_use_single_byte')
|
|
let g:omni_syntax_use_single_byte = 1
|
|
endif
|
|
|
|
" When using iskeyword, this setting controls whether the characters
|
|
" should be limited to single byte characters.
|
|
if !exists('g:omni_syntax_use_iskeyword_numeric')
|
|
let g:omni_syntax_use_iskeyword_numeric = 1
|
|
endif
|
|
|
|
" Only display items in the completion window that are at least
|
|
" this many characters in length.
|
|
" This is the default setting, but if you define a buffer local
|
|
" variable you can override this on a per filetype.
|
|
if !exists('g:omni_syntax_minimum_length')
|
|
let g:omni_syntax_minimum_length = 0
|
|
endif
|
|
|
|
" This script will build a completion list based on the syntax
|
|
" elements defined by the files in $VIMRUNTIME/syntax.
|
|
" let s:syn_remove_words = 'match,matchgroup=,contains,'.
|
|
let s:syn_remove_words = 'matchgroup=,contains,'.
|
|
\ 'links to,start=,end='
|
|
" \ 'links to,start=,end=,nextgroup='
|
|
|
|
let s:cache_name = []
|
|
let s:cache_list = []
|
|
let s:prepended = ''
|
|
|
|
" This function is used for the 'omnifunc' option.
|
|
function! syntaxcomplete#Complete(findstart, base)
|
|
|
|
" Allow user to override ignorecase per buffer
|
|
let l:omni_syntax_ignorecase = g:omni_syntax_ignorecase
|
|
if exists('b:omni_syntax_ignorecase')
|
|
let l:omni_syntax_ignorecase = b:omni_syntax_ignorecase
|
|
endif
|
|
|
|
if a:findstart
|
|
" Locate the start of the item, including "."
|
|
let line = getline('.')
|
|
let start = col('.') - 1
|
|
let lastword = -1
|
|
while start > 0
|
|
" if line[start - 1] =~ '\S'
|
|
" let start -= 1
|
|
" elseif line[start - 1] =~ '\.'
|
|
if line[start - 1] =~ '\k'
|
|
let start -= 1
|
|
let lastword = a:findstart
|
|
else
|
|
break
|
|
endif
|
|
endwhile
|
|
|
|
" Return the column of the last word, which is going to be changed.
|
|
" Remember the text that comes before it in s:prepended.
|
|
if lastword == -1
|
|
let s:prepended = ''
|
|
return start
|
|
endif
|
|
let s:prepended = strpart(line, start, (col('.') - 1) - start)
|
|
return start
|
|
endif
|
|
|
|
" let base = s:prepended . a:base
|
|
let base = substitute(s:prepended, "'", "''", 'g')
|
|
|
|
let filetype = substitute(&filetype, '\.', '_', 'g')
|
|
let list_idx = index(s:cache_name, filetype, 0, &ignorecase)
|
|
if list_idx > -1
|
|
let compl_list = s:cache_list[list_idx]
|
|
else
|
|
let compl_list = OmniSyntaxList()
|
|
let s:cache_name = add( s:cache_name, filetype )
|
|
let s:cache_list = add( s:cache_list, compl_list )
|
|
endif
|
|
|
|
" Return list of matches.
|
|
|
|
if base != ''
|
|
" let compstr = join(compl_list, ' ')
|
|
" let expr = (l:omni_syntax_ignorecase==0?'\C':'').'\<\%('.base.'\)\@!\w\+\s*'
|
|
" let compstr = substitute(compstr, expr, '', 'g')
|
|
" let compl_list = split(compstr, '\s\+')
|
|
|
|
" Filter the list based on the first few characters the user
|
|
" entered
|
|
let expr = 'v:val '.(l:omni_syntax_ignorecase==1?'=~?':'=~#')." '^".escape(base, '\\/.*$^~[]').".*'"
|
|
let compl_list = filter(deepcopy(compl_list), expr)
|
|
endif
|
|
|
|
return compl_list
|
|
endfunc
|
|
|
|
function! syntaxcomplete#OmniSyntaxList(...)
|
|
if a:0 > 0
|
|
let parms = []
|
|
if 3 == type(a:1)
|
|
let parms = a:1
|
|
elseif 1 == type(a:1)
|
|
let parms = split(a:1, ',')
|
|
endif
|
|
return OmniSyntaxList( parms )
|
|
else
|
|
return OmniSyntaxList()
|
|
endif
|
|
endfunc
|
|
|
|
function! syntaxcomplete#OmniSyntaxClearCache()
|
|
let s:cache_name = []
|
|
let s:cache_list = []
|
|
endfunction
|
|
|
|
" To retrieve all syntax items regardless of syntax group:
|
|
" echo OmniSyntaxList( [] )
|
|
"
|
|
" To retrieve only the syntax items for the sqlOperator syntax group:
|
|
" echo OmniSyntaxList( ['sqlOperator'] )
|
|
"
|
|
" To retrieve all syntax items for both the sqlOperator and sqlType groups:
|
|
" echo OmniSyntaxList( ['sqlOperator', 'sqlType'] )
|
|
"
|
|
" A regular expression can also be used:
|
|
" echo OmniSyntaxList( ['sql\w\+'] )
|
|
"
|
|
" From within a plugin, you would typically assign the output to a List: >
|
|
" let myKeywords = []
|
|
" let myKeywords = OmniSyntaxList( ['sqlKeyword'] )
|
|
function! OmniSyntaxList(...)
|
|
let list_parms = []
|
|
if a:0 > 0
|
|
if 3 == type(a:1)
|
|
let list_parms = a:1
|
|
elseif 1 == type(a:1)
|
|
let list_parms = split(a:1, ',')
|
|
endif
|
|
endif
|
|
|
|
" Default to returning a dictionary, if use_dictionary is set to 0
|
|
" a list will be returned.
|
|
" let use_dictionary = 1
|
|
" if a:0 > 0 && a:1 != ''
|
|
" let use_dictionary = a:1
|
|
" endif
|
|
|
|
let saveL = @l
|
|
let filetype = substitute(&filetype, '\.', '_', 'g')
|
|
|
|
if empty(list_parms)
|
|
" Allow user to override per buffer
|
|
if exists('g:omni_syntax_group_include_'.filetype)
|
|
let l:omni_syntax_group_include_{filetype} = g:omni_syntax_group_include_{filetype}
|
|
endif
|
|
if exists('b:omni_syntax_group_include_'.filetype)
|
|
let l:omni_syntax_group_include_{filetype} = b:omni_syntax_group_include_{filetype}
|
|
endif
|
|
|
|
" Default the include group to include the requested syntax group
|
|
let syntax_group_include_{filetype} = ''
|
|
" Check if there are any overrides specified for this filetype
|
|
if exists('l:omni_syntax_group_include_'.filetype)
|
|
let syntax_group_include_{filetype} =
|
|
\ substitute( l:omni_syntax_group_include_{filetype},'\s\+','','g')
|
|
let list_parms = split(l:omni_syntax_group_include_{filetype}, ',')
|
|
if syntax_group_include_{filetype} =~ '\w'
|
|
let syntax_group_include_{filetype} =
|
|
\ substitute( syntax_group_include_{filetype},
|
|
\ '\s*,\s*', '\\|', 'g'
|
|
\ )
|
|
endif
|
|
endif
|
|
else
|
|
" A specific list was provided, use it
|
|
endif
|
|
|
|
" Loop through all the syntax groupnames, and build a
|
|
" syntax file which contains these names. This can
|
|
" work generically for any filetype that does not already
|
|
" have a plugin defined.
|
|
" This ASSUMES the syntax groupname BEGINS with the name
|
|
" of the filetype. From my casual viewing of the vim7\syntax
|
|
" directory this is true for almost all syntax definitions.
|
|
" As an example, the SQL syntax groups have this pattern:
|
|
" sqlType
|
|
" sqlOperators
|
|
" sqlKeyword ...
|
|
if !empty(list_parms) && empty(substitute(join(list_parms), '[a-zA-Z ]', '', 'g'))
|
|
" If list_parms only includes word characters, use it to limit
|
|
" the syntax elements.
|
|
" If using regex syntax list will fail to find those items, so
|
|
" simply grab the who syntax list.
|
|
redir @l
|
|
silent! exec 'syntax list '.join(list_parms)
|
|
redir END
|
|
else
|
|
redir @l
|
|
silent! exec 'syntax list'
|
|
redir END
|
|
endif
|
|
|
|
let syntax_full = "\n".@l
|
|
let @l = saveL
|
|
|
|
if syntax_full =~ 'E28'
|
|
\ || syntax_full =~ 'E411'
|
|
\ || syntax_full =~ 'E415'
|
|
\ || syntax_full =~ 'No Syntax items'
|
|
return []
|
|
endif
|
|
|
|
let filetype = substitute(&filetype, '\.', '_', 'g')
|
|
|
|
let list_exclude_groups = []
|
|
if a:0 > 0
|
|
" Do nothing since we have specific a specific list of groups
|
|
else
|
|
" Default the exclude group to nothing
|
|
let syntax_group_exclude_{filetype} = ''
|
|
|
|
" Allow user to override per buffer
|
|
if exists('g:omni_syntax_group_exclude_'.filetype)
|
|
let l:omni_syntax_group_exclude_{filetype} = g:omni_syntax_group_exclude_{filetype}
|
|
endif
|
|
if exists('b:omni_syntax_group_exclude_'.filetype)
|
|
let l:omni_syntax_group_exclude_{filetype} = b:omni_syntax_group_exclude_{filetype}
|
|
endif
|
|
|
|
" Check if there are any overrides specified for this filetype
|
|
if exists('l:omni_syntax_group_exclude_'.filetype)
|
|
let syntax_group_exclude_{filetype} =
|
|
\ substitute( l:omni_syntax_group_exclude_{filetype},'\s\+','','g')
|
|
let list_exclude_groups = split(l:omni_syntax_group_exclude_{filetype}, ',')
|
|
if syntax_group_exclude_{filetype} =~ '\w'
|
|
let syntax_group_exclude_{filetype} =
|
|
\ substitute( syntax_group_exclude_{filetype},
|
|
\ '\s*,\s*', '\\|', 'g'
|
|
\ )
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
if empty(list_parms)
|
|
let list_parms = [&filetype.'\w\+']
|
|
endif
|
|
|
|
let syn_list = ''
|
|
let index = 0
|
|
for group_regex in list_parms
|
|
" Sometimes filetypes can be composite names, like c.doxygen
|
|
" Loop through each individual part looking for the syntax
|
|
" items specific to each individual filetype.
|
|
" let ftindex = 0
|
|
" let ftindex = match(syntax_full, group_regex, ftindex)
|
|
|
|
" while ftindex > -1
|
|
" let ft_part_name = matchstr( syntax_full, '\w\+', ftindex )
|
|
|
|
" Syntax rules can contain items for more than just the current
|
|
" filetype. They can contain additional items added by the user
|
|
" via autocmds or their vimrc.
|
|
" Some syntax files can be combined (html, php, jsp).
|
|
" We want only items that begin with the filetype we are interested in.
|
|
let next_group_regex = '\n' .
|
|
\ '\zs'.group_regex.'\ze'.
|
|
\ '\s\+xxx\s\+'
|
|
let index = match(syntax_full, next_group_regex, index)
|
|
|
|
" For the matched group name, strip off any of the regex special
|
|
" characters and see if we get a match with the current syntax
|
|
if index == -1 && exists('b:current_syntax') && substitute(group_regex, '[^a-zA-Z ]\+.*', '', 'g') !~ '^'.b:current_syntax
|
|
" There appears to be two standards when writing syntax files.
|
|
" Either items begin as:
|
|
" syn keyword {filetype}Keyword values ...
|
|
" let b:current_syntax = "sql"
|
|
" let b:current_syntax = "sqlanywhere"
|
|
" Or
|
|
" syn keyword {syntax_filename}Keyword values ...
|
|
" let b:current_syntax = "mysql"
|
|
" So, we will make the format of finding the syntax group names
|
|
" a bit more flexible and look for both if the first fails to
|
|
" find a match.
|
|
let next_group_regex = '\n' .
|
|
\ '\zs'.b:current_syntax.'\w\+\ze'.
|
|
\ '\s\+xxx\s\+'
|
|
let index = 0
|
|
let index = match(syntax_full, next_group_regex, index)
|
|
endif
|
|
|
|
while index > -1
|
|
let group_name = matchstr( syntax_full, '\w\+', index )
|
|
|
|
let get_syn_list = 1
|
|
for exclude_group_name in list_exclude_groups
|
|
if '\<'.exclude_group_name.'\>' =~ '\<'.group_name.'\>'
|
|
let get_syn_list = 0
|
|
endif
|
|
endfor
|
|
|
|
" This code is no longer needed in version 6.0 since we have
|
|
" augmented the syntax list command to only retrieve the syntax
|
|
" groups we are interested in.
|
|
"
|
|
" if get_syn_list == 1
|
|
" if syntax_group_include_{filetype} != ''
|
|
" if '\<'.syntax_group_include_{filetype}.'\>' !~ '\<'.group_name.'\>'
|
|
" let get_syn_list = 0
|
|
" endif
|
|
" endif
|
|
" endif
|
|
|
|
if get_syn_list == 1
|
|
" Pass in the full syntax listing, plus the group name we
|
|
" are interested in.
|
|
let extra_syn_list = s:SyntaxCSyntaxGroupItems(group_name, syntax_full)
|
|
let syn_list = syn_list . extra_syn_list . "\n"
|
|
endif
|
|
|
|
let index = index + strlen(group_name)
|
|
let index = match(syntax_full, next_group_regex, index)
|
|
endwhile
|
|
|
|
" let ftindex = ftindex + len(ft_part_name)
|
|
" let ftindex = match( syntax_full, group_regex, ftindex )
|
|
" endwhile
|
|
endfor
|
|
|
|
" " Sometimes filetypes can be composite names, like c.doxygen
|
|
" " Loop through each individual part looking for the syntax
|
|
" " items specific to each individual filetype.
|
|
" let syn_list = ''
|
|
" let ftindex = 0
|
|
" let ftindex = match(&filetype, '\w\+', ftindex)
|
|
|
|
" while ftindex > -1
|
|
" let ft_part_name = matchstr( &filetype, '\w\+', ftindex )
|
|
|
|
" " Syntax rules can contain items for more than just the current
|
|
" " filetype. They can contain additional items added by the user
|
|
" " via autocmds or their vimrc.
|
|
" " Some syntax files can be combined (html, php, jsp).
|
|
" " We want only items that begin with the filetype we are interested in.
|
|
" let next_group_regex = '\n' .
|
|
" \ '\zs'.ft_part_name.'\w\+\ze'.
|
|
" \ '\s\+xxx\s\+'
|
|
" let index = 0
|
|
" let index = match(syntax_full, next_group_regex, index)
|
|
|
|
" if index == -1 && exists('b:current_syntax') && ft_part_name != b:current_syntax
|
|
" " There appears to be two standards when writing syntax files.
|
|
" " Either items begin as:
|
|
" " syn keyword {filetype}Keyword values ...
|
|
" " let b:current_syntax = "sql"
|
|
" " let b:current_syntax = "sqlanywhere"
|
|
" " Or
|
|
" " syn keyword {syntax_filename}Keyword values ...
|
|
" " let b:current_syntax = "mysql"
|
|
" " So, we will make the format of finding the syntax group names
|
|
" " a bit more flexible and look for both if the first fails to
|
|
" " find a match.
|
|
" let next_group_regex = '\n' .
|
|
" \ '\zs'.b:current_syntax.'\w\+\ze'.
|
|
" \ '\s\+xxx\s\+'
|
|
" let index = 0
|
|
" let index = match(syntax_full, next_group_regex, index)
|
|
" endif
|
|
|
|
" while index > -1
|
|
" let group_name = matchstr( syntax_full, '\w\+', index )
|
|
|
|
" let get_syn_list = 1
|
|
" for exclude_group_name in list_exclude_groups
|
|
" if '\<'.exclude_group_name.'\>' =~ '\<'.group_name.'\>'
|
|
" let get_syn_list = 0
|
|
" endif
|
|
" endfor
|
|
|
|
" " This code is no longer needed in version 6.0 since we have
|
|
" " augmented the syntax list command to only retrieve the syntax
|
|
" " groups we are interested in.
|
|
" "
|
|
" " if get_syn_list == 1
|
|
" " if syntax_group_include_{filetype} != ''
|
|
" " if '\<'.syntax_group_include_{filetype}.'\>' !~ '\<'.group_name.'\>'
|
|
" " let get_syn_list = 0
|
|
" " endif
|
|
" " endif
|
|
" " endif
|
|
|
|
" if get_syn_list == 1
|
|
" " Pass in the full syntax listing, plus the group name we
|
|
" " are interested in.
|
|
" let extra_syn_list = s:SyntaxCSyntaxGroupItems(group_name, syntax_full)
|
|
" let syn_list = syn_list . extra_syn_list . "\n"
|
|
" endif
|
|
|
|
" let index = index + strlen(group_name)
|
|
" let index = match(syntax_full, next_group_regex, index)
|
|
" endwhile
|
|
|
|
" let ftindex = ftindex + len(ft_part_name)
|
|
" let ftindex = match( &filetype, '\w\+', ftindex )
|
|
" endwhile
|
|
|
|
" Convert the string to a List and sort it.
|
|
let compl_list = sort(split(syn_list))
|
|
|
|
if &filetype == 'vim'
|
|
let short_compl_list = []
|
|
for i in range(len(compl_list))
|
|
if i == len(compl_list)-1
|
|
let next = i
|
|
else
|
|
let next = i + 1
|
|
endif
|
|
if compl_list[next] !~ '^'.compl_list[i].'.$'
|
|
let short_compl_list += [compl_list[i]]
|
|
endif
|
|
endfor
|
|
|
|
return short_compl_list
|
|
else
|
|
return compl_list
|
|
endif
|
|
endfunction
|
|
|
|
function! s:SyntaxCSyntaxGroupItems( group_name, syntax_full )
|
|
|
|
" Allow user to override iskeyword per buffer
|
|
let l:omni_syntax_use_iskeyword = g:omni_syntax_use_iskeyword
|
|
if exists('b:omni_syntax_use_iskeyword')
|
|
let l:omni_syntax_use_iskeyword = b:omni_syntax_use_iskeyword
|
|
endif
|
|
|
|
" Allow user to override iskeyword_numeric per buffer
|
|
let l:omni_syntax_use_iskeyword_numeric = g:omni_syntax_use_iskeyword_numeric
|
|
if exists('b:omni_syntax_use_iskeyword_numeric')
|
|
let l:omni_syntax_use_iskeyword_numeric = b:omni_syntax_use_iskeyword_numeric
|
|
endif
|
|
|
|
" Allow user to override iskeyword_numeric per buffer
|
|
let l:omni_syntax_use_single_byte = g:omni_syntax_use_single_byte
|
|
if exists('b:omni_syntax_use_single_byte')
|
|
let l:omni_syntax_use_single_byte = b:omni_syntax_use_single_byte
|
|
endif
|
|
|
|
" Allow user to override minimum_length per buffer
|
|
let l:omni_syntax_minimum_length = g:omni_syntax_minimum_length
|
|
if exists('b:omni_syntax_minimum_length')
|
|
let l:omni_syntax_minimum_length = b:omni_syntax_minimum_length
|
|
endif
|
|
|
|
let syn_list = ""
|
|
|
|
" From the full syntax listing, strip out the portion for the
|
|
" request group.
|
|
" Query:
|
|
" \n - must begin with a newline
|
|
" a:group_name - the group name we are interested in
|
|
" \s\+xxx\s\+ - group names are always followed by xxx
|
|
" \zs - start the match
|
|
" .\{-} - everything ...
|
|
" \ze - end the match
|
|
" \( - start a group or 2 potential matches
|
|
" \n\w - at the first newline starting with a character
|
|
" \| - 2nd potential match
|
|
" \%$ - matches end of the file or string
|
|
" \) - end a group
|
|
let syntax_group = matchstr(a:syntax_full,
|
|
\ "\n".a:group_name.'\s\+xxx\s\+\zs.\{-}\ze\(\n\w\|\%$\)'
|
|
\ )
|
|
|
|
if syntax_group != ""
|
|
" let syn_list = substitute( @l, '^.*xxx\s*\%(contained\s*\)\?', "", '' )
|
|
" let syn_list = substitute( @l, '^.*xxx\s*', "", '' )
|
|
|
|
" We only want the words for the lines beginning with
|
|
" containedin, but there could be other items.
|
|
|
|
" Tried to remove all lines that do not begin with contained
|
|
" but this does not work in all cases since you can have
|
|
" contained nextgroup=...
|
|
" So this will strip off the ending of lines with known
|
|
" keywords.
|
|
let syn_list = substitute(
|
|
\ syntax_group, '\<\('.
|
|
\ substitute(
|
|
\ escape(s:syn_remove_words, '\\/.*$^~[]')
|
|
\ , ',', '\\|', 'g'
|
|
\ ).
|
|
\ '\).\{-}\%($\|'."\n".'\)'
|
|
\ , "\n", 'g'
|
|
\ )
|
|
|
|
" Attempt to deal with lines using the match syntax
|
|
" javaScriptDocTags xxx match /@\(param\|argument\|requires\|file\)\>/
|
|
" Though it can use any types of regex, so this plugin will attempt
|
|
" to restrict it
|
|
" 1. Only use \( or \%( constructs remove all else
|
|
" 2 Remove and []s
|
|
" 3. Account for match //constructs
|
|
" \%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?
|
|
" 4. Hope for the best
|
|
"
|
|
"
|
|
let syn_list_old = syn_list
|
|
while syn_list =~ '\<match\>\s\+\/'
|
|
if syn_list =~ 'perlElseIfError'
|
|
let syn_list = syn_list
|
|
endif
|
|
" Check if the match has words at least 3 characters long
|
|
if syn_list =~ '\<match \/\zs.\{-}\<\w\{3,}\>.\{-}\ze\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+'
|
|
" Remove everything after / and before the first \(
|
|
let syn_list = substitute( syn_list, '\<match \/\zs.\{-}\ze\\%\?(.\{-}\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
|
|
" Remove everything after \) and up to the ending /
|
|
let syn_list = substitute( syn_list, '\<match \/.\{-}\\)\zs.\{-}\ze\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
|
|
|
|
" Remove any character classes
|
|
" let syn_list = substitute( syn_list, '\<match /\zs.\{-}\[[^]]*\].\{-}\ze\/ ', '', 'g' )
|
|
let syn_list = substitute( syn_list, '\%(\<match \/[^/]\{-}\)\@<=\[[^]]*\]\ze.\{-}\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?', '', 'g' )
|
|
" Remove any words < 3 characters
|
|
let syn_list = substitute( syn_list, '\%(\<match \/[^/]\{-}\)\@<=\<\w\{1,2}\>\ze.\{-}\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
|
|
" Remove all non-word characters
|
|
" let syn_list = substitute( syn_list, '\<match /\zs.\{-}\<\W\+\>.\{-}\ze\/ ', "", 'g' )
|
|
" let syn_list = substitute( syn_list, '\%(\<match \/[^/]\{-}\)\@<=\W\+\ze.\{-}\/ ', ' ', 'g' )
|
|
" Do this by using the outer substitute() call to gather all
|
|
" text between the match /.../ tags.
|
|
" The inner substitute() call operates on the text selected
|
|
" and replaces all non-word characters.
|
|
let syn_list = substitute( syn_list, '\<match \/\zs\(.\{-}\)\ze\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+'
|
|
\ , '\=substitute(submatch(1), "\\W\\+", " ", "g")'
|
|
\ , 'g' )
|
|
" Remove the match / / syntax
|
|
let syn_list = substitute( syn_list, '\<match \/\(.\{-}\)\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '\1', 'g' )
|
|
else
|
|
" No words long enough, remove the match
|
|
" Remove the match syntax
|
|
" let syn_list = substitute( syn_list, '\<match \/[^\/]*\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
|
|
let syn_list = substitute( syn_list, '\<match \/\%(.\{-}\)\?\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
|
|
endif
|
|
if syn_list =~ '\<match\>\s\+\/'
|
|
" Problem removing the match / / tags
|
|
let syn_list = ''
|
|
endif
|
|
endwhile
|
|
|
|
|
|
" Now strip off the newline + blank space + contained.
|
|
" Also include lines with nextgroup=@someName skip_key_words syntax_element
|
|
" \ syn_list, '\%(^\|\n\)\@<=\s*\<\(contained\|nextgroup=\)'
|
|
" \ syn_list, '\%(^\|\n\)\@<=\s*\<\(contained\|nextgroup=[@a-zA-Z,]*\)'
|
|
let syn_list = substitute(
|
|
\ syn_list, '\<\(contained\|nextgroup=[@a-zA-Z,]*\)'
|
|
\ , "", 'g'
|
|
\ )
|
|
|
|
" This can leave lines like this
|
|
" =@vimMenuList skipwhite onoremenu
|
|
" Strip the special option keywords first
|
|
" :h :syn-skipwhite*
|
|
let syn_list = substitute(
|
|
\ syn_list, '\<\(skipwhite\|skipnl\|skipempty\)\>'
|
|
\ , "", 'g'
|
|
\ )
|
|
|
|
" Now remove the remainder of the nextgroup=@someName lines
|
|
let syn_list = substitute(
|
|
\ syn_list, '\%(^\|\n\)\@<=\s*\(@\w\+\)'
|
|
\ , "", 'g'
|
|
\ )
|
|
|
|
if l:omni_syntax_use_iskeyword == 0
|
|
" There are a number of items which have non-word characters in
|
|
" them, *'T_F1'*. vim.vim is one such file.
|
|
" This will replace non-word characters with spaces.
|
|
" setlocal filetype=forth
|
|
" let g:omni_syntax_use_iskeyword = 1
|
|
" let g:omni_syntax_use_iskeyword_numeric = 1
|
|
" You will see entries like
|
|
" #>>
|
|
" (.local)
|
|
" These were found doing a grep in vim82\syntax
|
|
" grep iskeyword *
|
|
" forth.vim:setlocal iskeyword=!,@,33-35,%,$,38-64,A-Z,91-96,a-z,123-126,128-255
|
|
let syn_list = substitute( syn_list, '[^0-9A-Za-z_ ]', ' ', 'g' )
|
|
else
|
|
if l:omni_syntax_use_iskeyword_numeric == 1
|
|
" iskeyword can contain value like this
|
|
" 38,42,43,45,47-58,60-62,64-90,97-122,_,+,-,*,/,%,<,=,>,:,$,?,!,@-@,94
|
|
" Numeric values convert to their ASCII equivalent using the
|
|
" nr2char() function.
|
|
" & 38
|
|
" * 42
|
|
" + 43
|
|
" - 45
|
|
" ^ 94
|
|
" Iterate through all numeric specifications and convert those
|
|
" to their ascii equivalent ensuring the character is printable.
|
|
" If so, add it to the list.
|
|
let accepted_chars = ''
|
|
for item in split(&iskeyword, ',')
|
|
if item =~ '\d-\d'
|
|
" This is a character range (ie 47-58),
|
|
" cycle through each character within the range
|
|
let [b:start, b:end] = split(item, '-')
|
|
for range_item in range( b:start, b:end )
|
|
if range_item <= 127 || l:omni_syntax_use_single_byte == 0
|
|
if nr2char(range_item) =~ '\p'
|
|
let accepted_chars = accepted_chars . nr2char(range_item)
|
|
endif
|
|
endif
|
|
endfor
|
|
elseif item =~ '^\d\+$'
|
|
" Only numeric, translate to a character
|
|
if item < 127 || l:omni_syntax_use_single_byte == 0
|
|
if nr2char(item) =~ '\p'
|
|
let accepted_chars = accepted_chars . nr2char(item)
|
|
endif
|
|
endif
|
|
else
|
|
if char2nr(item) < 127 || l:omni_syntax_use_single_byte == 0
|
|
if item =~ '\p'
|
|
let accepted_chars = accepted_chars . item
|
|
endif
|
|
endif
|
|
endif
|
|
endfor
|
|
" Escape special regex characters
|
|
" Looks like the wrong chars are escaped. In a collection,
|
|
" :h /[]
|
|
" only `]', `\', `-' and `^' are special:
|
|
" let accepted_chars = escape(accepted_chars, '\\/.*$^~[]' )
|
|
let accepted_chars = escape(accepted_chars, ']\-^' )
|
|
" Remove all characters that are not acceptable
|
|
let syn_list = substitute( syn_list, '[^A-Za-z'.accepted_chars.']', ' ', 'g' )
|
|
else
|
|
let accept_chars = ','.&iskeyword.','
|
|
" Remove all character ranges
|
|
" let accept_chars = substitute(accept_chars, ',[^,]\+-[^,]\+,', ',', 'g')
|
|
let accept_chars = substitute(accept_chars, ',\@<=[^,]\+-[^,]\+,', '', 'g')
|
|
" Remove all numeric specifications
|
|
" let accept_chars = substitute(accept_chars, ',\d\{-},', ',', 'g')
|
|
let accept_chars = substitute(accept_chars, ',\@<=\d\{-},', '', 'g')
|
|
" Remove all commas
|
|
let accept_chars = substitute(accept_chars, ',', '', 'g')
|
|
" Escape special regex characters
|
|
" Looks like the wrong chars are escaped. In a collection,
|
|
" :h /[]
|
|
" only `]', `\', `-' and `^' are special:
|
|
" let accept_chars = escape(accept_chars, '\\/.*$^~[]' )
|
|
let accept_chars = escape(accept_chars, ']\-^' )
|
|
" Remove all characters that are not acceptable
|
|
let syn_list = substitute( syn_list, '[^0-9A-Za-z_'.accept_chars.']', ' ', 'g' )
|
|
endif
|
|
endif
|
|
|
|
if l:omni_syntax_minimum_length > 0
|
|
" If the user specified a minimum length, enforce it
|
|
let syn_list = substitute(' '.syn_list.' ', ' \S\{,'.l:omni_syntax_minimum_length.'}\ze ', ' ', 'g')
|
|
endif
|
|
else
|
|
let syn_list = ''
|
|
endif
|
|
|
|
return syn_list
|
|
endfunction
|
|
|
|
function! OmniSyntaxShowChars(spec)
|
|
let result = []
|
|
for item in split(a:spec, ',')
|
|
if len(item) > 1
|
|
if item == '@-@'
|
|
call add(result, char2nr(item))
|
|
else
|
|
call extend(result, call('range', split(item, '-')))
|
|
endif
|
|
else
|
|
if item == '@' " assume this is [A-Za-z]
|
|
for [c1, c2] in [['A', 'Z'], ['a', 'z']]
|
|
call extend(result, range(char2nr(c1), char2nr(c2)))
|
|
endfor
|
|
else
|
|
call add(result, char2nr(item))
|
|
endif
|
|
endif
|
|
endfor
|
|
return join(map(result, 'nr2char(v:val)'), ', ')
|
|
endfunction
|
|
|
|
let &cpo = s:cpo_save
|
|
unlet s:cpo_save
|