" Vim completion script
" Language: All languages, uses existing syntax highlighting rules
" Maintainer: David Fishburn <dfishburn dot vim at gmail dot com>
" Version: 13.0
" Last Change: 2013 May 14
" Usage: For detailed help, ":help ft-syntax-omni"

" History
"
" 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 charater 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 = 130

" 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)

 " Only display items in the completion window that are at least
 " 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 = &ignorecase
 endif
 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 = s:prepended

 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 = (b: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 '.(g: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! 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

 " Only display items in the completion window that are at least
 " 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

 " Only display items in the completion window that are at least
 " 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(&filetype, '\.', '_', 'g')

 if empty(list_parms)
 " 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('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
 " 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} = ''
 " 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 = [&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 )

 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 begining 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 substitue() 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 b: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.
 let syn_list = substitute( syn_list, '[^0-9A-Za-z_ ]', ' ', 'g' )
 else
 if g: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 || 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\+$'
 " Only numeric, translate to a character
 if item < 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) < 127 || g: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 b:omni_syntax_minimum_length > 0
 " 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) > 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