<h2>Editing File: /usr/share/vim/vim80/autoload/syntaxcomplete.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; Vim completion script
&quot; Language:    All languages, uses existing syntax highlighting rules
&quot; Maintainer:  David Fishburn &lt;dfishburn dot vim at gmail dot com&gt;
&quot; Version:     13.0
&quot; Last Change: 2013 May 14
&quot; Usage:       For detailed help, &quot;:help ft-syntax-omni&quot;

&quot; History
&quot;
&quot; Version 13.0
&quot;   - Extended the option omni_syntax_group_include_{filetype}
&quot;     to accept a comma separated list of regex's rather than
&quot;     string.  For example, for the javascript filetype you could
&quot;     use:
&quot;        let g:omni_syntax_group_include_javascript = 'javascript\w\+,jquery\w\+'
&quot;   - Some syntax files (perl.vim) use the match // syntax as a mechanism
&quot;     to identify keywords.  This update attempts to parse the
&quot;     match syntax and pull out syntax items which are at least
&quot;     3 words or more.
&quot;
&quot; Version 12.0
&quot;   - It is possible to have '-' as part of iskeyword, when
&quot;     checking for character ranges, tighten up the regex.
&quot;     E688: More targets than List items.
&quot;
&quot; Version 11.0
&quot;   - Corrected which characters required escaping during
&quot;     substitution calls.
&quot;
&quot; Version 10.0
&quot;   - Cycle through all the character ranges specified in the
&quot;     iskeyword option and build a list of valid word separators.
&quot;     Prior to this change, only actual characters were used,
&quot;     where for example ASCII &quot;45&quot; == &quot;-&quot;.  If &quot;45&quot; were used
&quot;     in iskeyword the hyphen would not be picked up.
&quot;     This introduces a new option, since the character ranges
&quot;     specified could be multibyte:
&quot;         let g:omni_syntax_use_single_byte = 1
&quot;   - This by default will only allow single byte ASCII
&quot;     characters to be added and an additional check to ensure
&quot;     the charater is printable (see documentation for isprint).
&quot;
&quot; Version 9.0
&quot;   - Add the check for cpo.
&quot;
&quot; Version 8.0
&quot;   - Updated SyntaxCSyntaxGroupItems()
&quot;         - Some additional syntax items were also allowed
&quot;           on nextgroup= lines which were ignored by default.
&quot;           Now these lines are processed independently.
&quot;
&quot; Version 7.0
&quot;   - Updated syntaxcomplete#OmniSyntaxList()
&quot;         - Looking up the syntax groups defined from a syntax file
&quot;           looked for only 1 format of {filetype}GroupName, but some
&quot;           syntax writers use this format as well:
&quot;               {b:current_syntax}GroupName
&quot;   -       OmniSyntaxList() will now check for both if the first
&quot;           method does not find a match.
&quot;
&quot; Version 6.0
&quot;   - Added syntaxcomplete#OmniSyntaxList()
&quot;         - Allows other plugins to use this for their own
&quot;           purposes.
&quot;         - It will return a List of all syntax items for the
&quot;           syntax group name passed in.
&quot;         - XPTemplate for SQL will use this function via the
&quot;           sqlcomplete plugin to populate a Choose box.
&quot;
&quot; Version 5.0
&quot;   - Updated SyntaxCSyntaxGroupItems()
&quot;         - When processing a list of syntax groups, the final group
&quot;           was missed in function SyntaxCSyntaxGroupItems.
&quot;
&quot; Set completion with CTRL-X CTRL-O to autoloaded function.
&quot; This check is in place in case this script is
&quot; sourced directly instead of using the autoload feature.
if exists('+omnifunc')
    &quot; Do not set the option if already set since this
    &quot; results in an E117 warning.
    if &amp;omnifunc == &quot;&quot;
        setlocal omnifunc=syntaxcomplete#Complete
    endif
endif

if exists('g:loaded_syntax_completion')
    finish
endif
let g:loaded_syntax_completion = 130

&quot; Turn on support for line continuations when creating the script
let s:cpo_save = &amp;cpo
set cpo&amp;vim

&quot; Set ignorecase to the ftplugin standard
&quot; This is the default setting, but if you define a buffer local
&quot; variable you can override this on a per filetype.
if !exists('g:omni_syntax_ignorecase')
    let g:omni_syntax_ignorecase = &amp;ignorecase
endif

&quot; Indicates whether we should use the iskeyword option to determine
&quot; how to split words.
&quot; This is the default setting, but if you define a buffer local
&quot; variable you can override this on a per filetype.
if !exists('g:omni_syntax_use_iskeyword')
    let g:omni_syntax_use_iskeyword = 1
endif

&quot; When using iskeyword, this setting controls whether the characters
&quot; should be limited to single byte characters.
if !exists('g:omni_syntax_use_single_byte')
    let g:omni_syntax_use_single_byte = 1
endif

&quot; When using iskeyword, this setting controls whether the characters
&quot; should be limited to single byte characters.
if !exists('g:omni_syntax_use_iskeyword_numeric')
    let g:omni_syntax_use_iskeyword_numeric = 1
endif

&quot; Only display items in the completion window that are at least
&quot; this many characters in length.
&quot; This is the default setting, but if you define a buffer local
&quot; variable you can override this on a per filetype.
if !exists('g:omni_syntax_minimum_length')
    let g:omni_syntax_minimum_length = 0
endif

&quot; This script will build a completion list based on the syntax
&quot; elements defined by the files in $VIMRUNTIME/syntax.
&quot; let s:syn_remove_words = 'match,matchgroup=,contains,'.
let s:syn_remove_words = 'matchgroup=,contains,'.
            \ 'links to,start=,end='
            &quot; \ 'links to,start=,end=,nextgroup='

let s:cache_name = []
let s:cache_list = []
let s:prepended  = ''

&quot; This function is used for the 'omnifunc' option.
function! syntaxcomplete#Complete(findstart, base)

    &quot; Only display items in the completion window that are at least
    &quot; this many characters in length
    if !exists('b:omni_syntax_ignorecase')
        if exists('g:omni_syntax_ignorecase')
            let b:omni_syntax_ignorecase = g:omni_syntax_ignorecase
        else
            let b:omni_syntax_ignorecase = &amp;ignorecase
        endif
    endif

    if a:findstart
        &quot; Locate the start of the item, including &quot;.&quot;
        let line = getline('.')
        let start = col('.') - 1
        let lastword = -1
        while start &gt; 0
            &quot; if line[start - 1] =~ '\S'
            &quot;     let start -= 1
            &quot; elseif line[start - 1] =~ '\.'
            if line[start - 1] =~ '\k'
                let start -= 1
                let lastword = a:findstart
            else
                break
            endif
        endwhile

        &quot; Return the column of the last word, which is going to be changed.
        &quot; 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

    &quot; let base = s:prepended . a:base
    let base = s:prepended

    let filetype = substitute(&amp;filetype, '\.', '_', 'g')
    let list_idx = index(s:cache_name, filetype, 0, &amp;ignorecase)
    if list_idx &gt; -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

    &quot; Return list of matches.

    if base != ''
        &quot; let compstr    = join(compl_list, ' ')
        &quot; let expr       = (b:omni_syntax_ignorecase==0?'\C':'').'\&lt;\%('.base.'\)\@!\w\+\s*'
        &quot; let compstr    = substitute(compstr, expr, '', 'g')
        &quot; let compl_list = split(compstr, '\s\+')

        &quot; Filter the list based on the first few characters the user
        &quot; entered
        let expr = 'v:val '.(g:omni_syntax_ignorecase==1?'=~?':'=~#').&quot; '^&quot;.escape(base, '\\/.*$^~[]').&quot;.*'&quot;
        let compl_list = filter(deepcopy(compl_list), expr)
    endif

    return compl_list
endfunc

function! syntaxcomplete#OmniSyntaxList(...)
    if a:0 &gt; 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! OmniSyntaxList(...)
    let list_parms = []
    if a:0 &gt; 0
        if 3 == type(a:1)
            let list_parms = a:1
        elseif 1 == type(a:1)
            let list_parms = split(a:1, ',')
        endif
    endif

    &quot; Default to returning a dictionary, if use_dictionary is set to 0
    &quot; a list will be returned.
    &quot; let use_dictionary = 1
    &quot; if a:0 &gt; 0 &amp;&amp; a:1 != ''
    &quot;     let use_dictionary = a:1
    &quot; endif

    &quot; Only display items in the completion window that are at least
    &quot; this many characters in length
    if !exists('b:omni_syntax_use_iskeyword')
        if exists('g:omni_syntax_use_iskeyword')
            let b:omni_syntax_use_iskeyword = g:omni_syntax_use_iskeyword
        else
            let b:omni_syntax_use_iskeyword = 1
        endif
    endif

    &quot; Only display items in the completion window that are at least
    &quot; this many characters in length
    if !exists('b:omni_syntax_minimum_length')
        if exists('g:omni_syntax_minimum_length')
            let b:omni_syntax_minimum_length = g:omni_syntax_minimum_length
        else
            let b:omni_syntax_minimum_length = 0
        endif
    endif

    let saveL = @l
    let filetype = substitute(&amp;filetype, '\.', '_', 'g')

    if empty(list_parms)
        &quot; Default the include group to include the requested syntax group
        let syntax_group_include_{filetype} = ''
        &quot; Check if there are any overrides specified for this filetype
        if exists('g:omni_syntax_group_include_'.filetype)
            let syntax_group_include_{filetype} =
                        \ substitute( g:omni_syntax_group_include_{filetype},'\s\+','','g')
            let list_parms = split(g: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
        &quot; A specific list was provided, use it
    endif

    &quot; Loop through all the syntax groupnames, and build a
    &quot; syntax file which contains these names.  This can
    &quot; work generically for any filetype that does not already
    &quot; have a plugin defined.
    &quot; This ASSUMES the syntax groupname BEGINS with the name
    &quot; of the filetype.  From my casual viewing of the vim7\syntax
    &quot; directory this is true for almost all syntax definitions.
    &quot; As an example, the SQL syntax groups have this pattern:
    &quot;     sqlType
    &quot;     sqlOperators
    &quot;     sqlKeyword ...
    if !empty(list_parms) &amp;&amp; empty(substitute(join(list_parms), '[a-zA-Z ]', '', 'g'))
        &quot; If list_parms only includes word characters, use it to limit
        &quot; the syntax elements.
        &quot; If using regex syntax list will fail to find those items, so
        &quot; 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 = &quot;\n&quot;.@l
    let @l = saveL

    if syntax_full =~ 'E28'
                \ || syntax_full =~ 'E411'
                \ || syntax_full =~ 'E415'
                \ || syntax_full =~ 'No Syntax items'
        return []
    endif

    let filetype = substitute(&amp;filetype, '\.', '_', 'g')

    let list_exclude_groups = []
    if a:0 &gt; 0
        &quot; Do nothing since we have specific a specific list of groups
    else
        &quot; Default the exclude group to nothing
        let syntax_group_exclude_{filetype} = ''
        &quot; Check if there are any overrides specified for this filetype
        if exists('g:omni_syntax_group_exclude_'.filetype)
            let syntax_group_exclude_{filetype} =
                        \ substitute( g:omni_syntax_group_exclude_{filetype},'\s\+','','g')
            let list_exclude_groups = split(g: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 = [&amp;filetype.'\w\+']
    endif

    let syn_list = ''
    let index    = 0
    for group_regex in list_parms
        &quot; Sometimes filetypes can be composite names, like c.doxygen
        &quot; Loop through each individual part looking for the syntax
        &quot; items specific to each individual filetype.
        &quot; let ftindex  = 0
        &quot; let ftindex  = match(syntax_full, group_regex, ftindex)

        &quot; while ftindex &gt; -1
            &quot; let ft_part_name = matchstr( syntax_full, '\w\+', ftindex )

            &quot; Syntax rules can contain items for more than just the current
            &quot; filetype.  They can contain additional items added by the user
            &quot; via autocmds or their vimrc.
            &quot; Some syntax files can be combined (html, php, jsp).
            &quot; 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)

            &quot; For the matched group name, strip off any of the regex special
            &quot; characters and see if we get a match with the current syntax
            if index == -1 &amp;&amp; exists('b:current_syntax') &amp;&amp; substitute(group_regex, '[^a-zA-Z ]\+.*', '', 'g') !~ '^'.b:current_syntax
                &quot; There appears to be two standards when writing syntax files.
                &quot; Either items begin as:
                &quot;     syn keyword {filetype}Keyword         values ...
                &quot;     let b:current_syntax = &quot;sql&quot;
                &quot;     let b:current_syntax = &quot;sqlanywhere&quot;
                &quot; Or
                &quot;     syn keyword {syntax_filename}Keyword  values ...
                &quot;     let b:current_syntax = &quot;mysql&quot;
                &quot; So, we will make the format of finding the syntax group names
                &quot; a bit more flexible and look for both if the first fails to
                &quot; 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 &gt; -1
                let group_name = matchstr( syntax_full, '\w\+', index )

                let get_syn_list = 1
                for exclude_group_name in list_exclude_groups
                    if '\&lt;'.exclude_group_name.'\&gt;' =~ '\&lt;'.group_name.'\&gt;'
                        let get_syn_list = 0
                    endif
                endfor

                &quot; This code is no longer needed in version 6.0 since we have
                &quot; augmented the syntax list command to only retrieve the syntax
                &quot; groups we are interested in.
                &quot;
                &quot; if get_syn_list == 1
                &quot;     if syntax_group_include_{filetype} != ''
                &quot;         if '\&lt;'.syntax_group_include_{filetype}.'\&gt;' !~ '\&lt;'.group_name.'\&gt;'
                &quot;             let get_syn_list = 0
                &quot;         endif
                &quot;     endif
                &quot; endif

                if get_syn_list == 1
                    &quot; Pass in the full syntax listing, plus the group name we
                    &quot; are interested in.
                    let extra_syn_list = s:SyntaxCSyntaxGroupItems(group_name, syntax_full)
                    let syn_list = syn_list . extra_syn_list . &quot;\n&quot;
                endif

                let index = index + strlen(group_name)
                let index = match(syntax_full, next_group_regex, index)
            endwhile

            &quot; let ftindex  = ftindex + len(ft_part_name)
            &quot; let ftindex  = match( syntax_full, group_regex, ftindex )
        &quot; endwhile
    endfor

&quot;   &quot; Sometimes filetypes can be composite names, like c.doxygen
&quot;   &quot; Loop through each individual part looking for the syntax
&quot;   &quot; items specific to each individual filetype.
&quot;   let syn_list = ''
&quot;   let ftindex  = 0
&quot;   let ftindex  = match(&amp;filetype, '\w\+', ftindex)

&quot;   while ftindex &gt; -1
&quot;       let ft_part_name = matchstr( &amp;filetype, '\w\+', ftindex )

&quot;       &quot; Syntax rules can contain items for more than just the current
&quot;       &quot; filetype.  They can contain additional items added by the user
&quot;       &quot; via autocmds or their vimrc.
&quot;       &quot; Some syntax files can be combined (html, php, jsp).
&quot;       &quot; We want only items that begin with the filetype we are interested in.
&quot;       let next_group_regex = '\n' .
&quot;                   \ '\zs'.ft_part_name.'\w\+\ze'.
&quot;                   \ '\s\+xxx\s\+'
&quot;       let index    = 0
&quot;       let index    = match(syntax_full, next_group_regex, index)

&quot;       if index == -1 &amp;&amp; exists('b:current_syntax') &amp;&amp; ft_part_name != b:current_syntax
&quot;           &quot; There appears to be two standards when writing syntax files.
&quot;           &quot; Either items begin as:
&quot;           &quot;     syn keyword {filetype}Keyword         values ...
&quot;           &quot;     let b:current_syntax = &quot;sql&quot;
&quot;           &quot;     let b:current_syntax = &quot;sqlanywhere&quot;
&quot;           &quot; Or
&quot;           &quot;     syn keyword {syntax_filename}Keyword  values ...
&quot;           &quot;     let b:current_syntax = &quot;mysql&quot;
&quot;           &quot; So, we will make the format of finding the syntax group names
&quot;           &quot; a bit more flexible and look for both if the first fails to
&quot;           &quot; find a match.
&quot;           let next_group_regex = '\n' .
&quot;                       \ '\zs'.b:current_syntax.'\w\+\ze'.
&quot;                       \ '\s\+xxx\s\+'
&quot;           let index    = 0
&quot;           let index    = match(syntax_full, next_group_regex, index)
&quot;       endif

&quot;       while index &gt; -1
&quot;           let group_name = matchstr( syntax_full, '\w\+', index )

&quot;           let get_syn_list = 1
&quot;           for exclude_group_name in list_exclude_groups
&quot;               if '\&lt;'.exclude_group_name.'\&gt;' =~ '\&lt;'.group_name.'\&gt;'
&quot;                   let get_syn_list = 0
&quot;               endif
&quot;           endfor

&quot;           &quot; This code is no longer needed in version 6.0 since we have
&quot;           &quot; augmented the syntax list command to only retrieve the syntax
&quot;           &quot; groups we are interested in.
&quot;           &quot;
&quot;           &quot; if get_syn_list == 1
&quot;           &quot;     if syntax_group_include_{filetype} != ''
&quot;           &quot;         if '\&lt;'.syntax_group_include_{filetype}.'\&gt;' !~ '\&lt;'.group_name.'\&gt;'
&quot;           &quot;             let get_syn_list = 0
&quot;           &quot;         endif
&quot;           &quot;     endif
&quot;           &quot; endif

&quot;           if get_syn_list == 1
&quot;               &quot; Pass in the full syntax listing, plus the group name we
&quot;               &quot; are interested in.
&quot;               let extra_syn_list = s:SyntaxCSyntaxGroupItems(group_name, syntax_full)
&quot;               let syn_list = syn_list . extra_syn_list . &quot;\n&quot;
&quot;           endif

&quot;           let index = index + strlen(group_name)
&quot;           let index = match(syntax_full, next_group_regex, index)
&quot;       endwhile

&quot;       let ftindex  = ftindex + len(ft_part_name)
&quot;       let ftindex  = match( &amp;filetype, '\w\+', ftindex )
&quot;   endwhile

    &quot; Convert the string to a List and sort it.
    let compl_list = sort(split(syn_list))

    if &amp;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 )

    let syn_list = &quot;&quot;

    &quot; From the full syntax listing, strip out the portion for the
    &quot; request group.
    &quot; Query:
    &quot;     \n           - must begin with a newline
    &quot;     a:group_name - the group name we are interested in
    &quot;     \s\+xxx\s\+  - group names are always followed by xxx
    &quot;     \zs          - start the match
    &quot;     .\{-}        - everything ...
    &quot;     \ze          - end the match
    &quot;     \(           - start a group or 2 potential matches
    &quot;     \n\w         - at the first newline starting with a character
    &quot;     \|           - 2nd potential match
    &quot;     \%$          - matches end of the file or string
    &quot;     \)           - end a group
    let syntax_group = matchstr(a:syntax_full,
                \ &quot;\n&quot;.a:group_name.'\s\+xxx\s\+\zs.\{-}\ze\(\n\w\|\%$\)'
                \ )

    if syntax_group != &quot;&quot;
        &quot; let syn_list = substitute( @l, '^.*xxx\s*\%(contained\s*\)\?', &quot;&quot;, '' )
        &quot; let syn_list = substitute( @l, '^.*xxx\s*', &quot;&quot;, '' )

        &quot; We only want the words for the lines begining with
        &quot; containedin, but there could be other items.

        &quot; Tried to remove all lines that do not begin with contained
        &quot; but this does not work in all cases since you can have
        &quot;    contained nextgroup=...
        &quot; So this will strip off the ending of lines with known
        &quot; keywords.
        let syn_list = substitute(
                    \    syntax_group, '\&lt;\('.
                    \    substitute(
                    \      escape(s:syn_remove_words, '\\/.*$^~[]')
                    \      , ',', '\\|', 'g'
                    \    ).
                    \    '\).\{-}\%($\|'.&quot;\n&quot;.'\)'
                    \    , &quot;\n&quot;, 'g'
                    \  )

        &quot; Attempt to deal with lines using the match syntax
        &quot; javaScriptDocTags xxx match /@\(param\|argument\|requires\|file\)\&gt;/
        &quot; Though it can use any types of regex, so this plugin will attempt
        &quot; to restrict it
        &quot; 1.  Only use \( or \%( constructs remove all else
        &quot; 2   Remove and []s
        &quot; 3.  Account for match //constructs
        &quot;                       \%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?
        &quot; 4.  Hope for the best
        &quot;
        &quot;
        let syn_list_old = syn_list
        while syn_list =~ '\&lt;match\&gt;\s\+\/'
            if syn_list =~ 'perlElseIfError'
                let syn_list = syn_list
            endif
            &quot; Check if the match has words at least 3 characters long
            if syn_list =~ '\&lt;match \/\zs.\{-}\&lt;\w\{3,}\&gt;.\{-}\ze\\\@&lt;!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+'
                &quot; Remove everything after / and before the first \(
                let syn_list = substitute( syn_list, '\&lt;match \/\zs.\{-}\ze\\%\?(.\{-}\\\@&lt;!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
                &quot; Remove everything after \) and up to the ending /
                let syn_list = substitute( syn_list, '\&lt;match \/.\{-}\\)\zs.\{-}\ze\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )

                &quot; Remove any character classes
                &quot; let syn_list = substitute( syn_list, '\&lt;match /\zs.\{-}\[[^]]*\].\{-}\ze\/ ', '', 'g' )
                let syn_list = substitute( syn_list, '\%(\&lt;match \/[^/]\{-}\)\@&lt;=\[[^]]*\]\ze.\{-}\\\@&lt;!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?', '', 'g' )
                &quot; Remove any words &lt; 3 characters
                let syn_list = substitute( syn_list, '\%(\&lt;match \/[^/]\{-}\)\@&lt;=\&lt;\w\{1,2}\&gt;\ze.\{-}\\\@&lt;!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
                &quot; Remove all non-word characters
                &quot; let syn_list = substitute( syn_list, '\&lt;match /\zs.\{-}\&lt;\W\+\&gt;.\{-}\ze\/ ', &quot;&quot;, 'g' )
                &quot; let syn_list = substitute( syn_list, '\%(\&lt;match \/[^/]\{-}\)\@&lt;=\W\+\ze.\{-}\/ ', ' ', 'g' )
                &quot; Do this by using the outer substitue() call to gather all
                &quot; text between the match /.../ tags.
                &quot; The inner substitute() call operates on the text selected
                &quot; and replaces all non-word characters.
                let syn_list = substitute( syn_list, '\&lt;match \/\zs\(.\{-}\)\ze\\\@&lt;!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+'
                            \ , '\=substitute(submatch(1), &quot;\\W\\+&quot;, &quot; &quot;, &quot;g&quot;)'
                            \ , 'g' )
                &quot; Remove the match / / syntax
                let syn_list = substitute( syn_list, '\&lt;match \/\(.\{-}\)\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '\1', 'g' )
            else
                &quot; No words long enough, remove the match
                &quot; Remove the match syntax
                &quot; let syn_list = substitute( syn_list, '\&lt;match \/[^\/]*\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
                let syn_list = substitute( syn_list, '\&lt;match \/\%(.\{-}\)\?\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' )
            endif
            if syn_list =~ '\&lt;match\&gt;\s\+\/'
                &quot; Problem removing the match / / tags
                let syn_list = ''
            endif
        endwhile


        &quot; Now strip off the newline + blank space + contained.
        &quot; Also include lines with nextgroup=@someName skip_key_words syntax_element
                    &quot; \    syn_list, '\%(^\|\n\)\@&lt;=\s*\&lt;\(contained\|nextgroup=\)'
                    &quot; \    syn_list, '\%(^\|\n\)\@&lt;=\s*\&lt;\(contained\|nextgroup=[@a-zA-Z,]*\)'
        let syn_list = substitute(
                    \    syn_list, '\&lt;\(contained\|nextgroup=[@a-zA-Z,]*\)'
                    \    , &quot;&quot;, 'g'
                    \ )

        &quot; This can leave lines like this
        &quot;     =@vimMenuList  skipwhite onoremenu
        &quot; Strip the special option keywords first
        &quot;     :h :syn-skipwhite*
        let syn_list = substitute(
                    \    syn_list, '\&lt;\(skipwhite\|skipnl\|skipempty\)\&gt;'
                    \    , &quot;&quot;, 'g'
                    \ )

        &quot; Now remove the remainder of the nextgroup=@someName lines
        let syn_list = substitute(
                    \    syn_list, '\%(^\|\n\)\@&lt;=\s*\(@\w\+\)'
                    \    , &quot;&quot;, 'g'
                    \ )

        if b:omni_syntax_use_iskeyword == 0
            &quot; There are a number of items which have non-word characters in
            &quot; them, *'T_F1'*.  vim.vim is one such file.
            &quot; This will replace non-word characters with spaces.
            let syn_list = substitute( syn_list, '[^0-9A-Za-z_ ]', ' ', 'g' )
        else
            if g:omni_syntax_use_iskeyword_numeric == 1
                &quot; iskeyword can contain value like this
                &quot; 38,42,43,45,47-58,60-62,64-90,97-122,_,+,-,*,/,%,&lt;,=,&gt;,:,$,?,!,@-@,94
                &quot; Numeric values convert to their ASCII equivalent using the
                &quot; nr2char() function.
                &quot;     &amp;       38
                &quot;     *       42
                &quot;     +       43
                &quot;     -       45
                &quot;     ^       94
                &quot; Iterate through all numeric specifications and convert those
                &quot; to their ascii equivalent ensuring the character is printable.
                &quot; If so, add it to the list.
                let accepted_chars = ''
                for item in split(&amp;iskeyword, ',')
                    if item =~ '\d-\d'
                        &quot; This is a character range (ie 47-58),
                        &quot; 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 &lt;= 127 || g: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\+$'
                        &quot; Only numeric, translate to a character
                        if item &lt; 127 || g:omni_syntax_use_single_byte == 0
                            if nr2char(item) =~ '\p'
                                let accepted_chars = accepted_chars . nr2char(item)
                            endif
                        endif
                    else
                        if char2nr(item) &lt; 127 || g:omni_syntax_use_single_byte == 0
                            if item =~ '\p'
                                let accepted_chars = accepted_chars . item
                            endif
                        endif
                    endif
                endfor
                &quot; Escape special regex characters
                &quot; Looks like the wrong chars are escaped.  In a collection,
                &quot;      :h /[]
                &quot;      only `]', `\', `-' and `^' are special:
                &quot; let accepted_chars = escape(accepted_chars, '\\/.*$^~[]' )
                let accepted_chars = escape(accepted_chars, ']\-^' )
                &quot; Remove all characters that are not acceptable
                let syn_list = substitute( syn_list, '[^A-Za-z'.accepted_chars.']', ' ', 'g' )
            else
                let accept_chars = ','.&amp;iskeyword.','
                &quot; Remove all character ranges
                &quot; let accept_chars = substitute(accept_chars, ',[^,]\+-[^,]\+,', ',', 'g')
                let accept_chars = substitute(accept_chars, ',\@&lt;=[^,]\+-[^,]\+,', '', 'g')
                &quot; Remove all numeric specifications
                &quot; let accept_chars = substitute(accept_chars, ',\d\{-},', ',', 'g')
                let accept_chars = substitute(accept_chars, ',\@&lt;=\d\{-},', '', 'g')
                &quot; Remove all commas
                let accept_chars = substitute(accept_chars, ',', '', 'g')
                &quot; Escape special regex characters
                &quot; Looks like the wrong chars are escaped.  In a collection,
                &quot;      :h /[]
                &quot;      only `]', `\', `-' and `^' are special:
                &quot; let accept_chars = escape(accept_chars, '\\/.*$^~[]' )
                let accept_chars = escape(accept_chars, ']\-^' )
                &quot; Remove all characters that are not acceptable
                let syn_list = substitute( syn_list, '[^0-9A-Za-z_'.accept_chars.']', ' ', 'g' )
            endif
        endif

        if b:omni_syntax_minimum_length &gt; 0
            &quot; If the user specified a minimum length, enforce it
            let syn_list = substitute(' '.syn_list.' ', ' \S\{,'.b: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) &gt; 1
      if item == '@-@'
        call add(result, char2nr(item))
      else
        call extend(result, call('range', split(item, '-')))
      endif
    else
      if item == '@'  &quot; 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 &amp;cpo = s:cpo_save
unlet s:cpo_save
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fautoload'>Back to Directory</a>