Adding upstream version 2:9.1.0016.upstream/2%9.1.0016

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 810 insertions, 0 deletions

diff --git a/runtime/autoload/syntaxcomplete.vim b/runtime/autoload/syntaxcomplete.vim
new file mode 100644
index 0000000..396193d
--- /dev/null
+++ b/runtime/autoload/syntaxcomplete.vim
@@ -0,0 +1,810 @@
+" 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