Mercurial > vim
annotate runtime/autoload/syntaxcomplete.vim @ 24248:883d7ceffd97 v8.2.2665
patch 8.2.2665: test failures
Commit: https://github.com/vim/vim/commit/7b45d46cf7db0d2d7a4defc2d81b233a2c672b74
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat Mar 27 19:09:02 2021 +0100
patch 8.2.2665: test failures
Problem: Test failures.
Solution: Check more specific feature. Add missing change.
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Sat, 27 Mar 2021 19:15:03 +0100 |
parents | ef454a7f485d |
children | e3ec2ec8841a |
rev | line source |
---|---|
625 | 1 " Vim completion script |
2 " Language: All languages, uses existing syntax highlighting rules | |
2072 | 3 " Maintainer: David Fishburn <dfishburn dot vim at gmail dot com> |
24024 | 4 " Version: 14.0 |
5 " Last Change: 2020 Dec 30 | |
3996 | 6 " Usage: For detailed help, ":help ft-syntax-omni" |
625 | 7 |
2072 | 8 " History |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
9 " |
24024 | 10 " Version 14.0 |
11 " - Fixed issue with single quotes and is_keyword | |
12 " https://github.com/vim/vim/issues/7463 | |
13 " | |
4437 | 14 " Version 13.0 |
15 " - Extended the option omni_syntax_group_include_{filetype} | |
16 " to accept a comma separated list of regex's rather than | |
17 " string. For example, for the javascript filetype you could | |
18 " use: | |
19 " let g:omni_syntax_group_include_javascript = 'javascript\w\+,jquery\w\+' | |
20 " - Some syntax files (perl.vim) use the match // syntax as a mechanism | |
21 " to identify keywords. This update attempts to parse the | |
22 " match syntax and pull out syntax items which are at least | |
23 " 3 words or more. | |
24 " | |
25 " Version 12.0 | |
26 " - It is possible to have '-' as part of iskeyword, when | |
27 " checking for character ranges, tighten up the regex. | |
28 " E688: More targets than List items. | |
29 " | |
3996 | 30 " Version 11.0 |
4437 | 31 " - Corrected which characters required escaping during |
3996 | 32 " substitution calls. |
33 " | |
3920 | 34 " Version 10.0 |
4437 | 35 " - Cycle through all the character ranges specified in the |
3920 | 36 " iskeyword option and build a list of valid word separators. |
3996 | 37 " Prior to this change, only actual characters were used, |
38 " where for example ASCII "45" == "-". If "45" were used | |
39 " in iskeyword the hyphen would not be picked up. | |
3920 | 40 " This introduces a new option, since the character ranges |
41 " specified could be multibyte: | |
42 " let g:omni_syntax_use_single_byte = 1 | |
4437 | 43 " - This by default will only allow single byte ASCII |
3920 | 44 " characters to be added and an additional check to ensure |
45 " the charater is printable (see documentation for isprint). | |
46 " | |
47 " Version 9.0 | |
4437 | 48 " - Add the check for cpo. |
3920 | 49 " |
3224 | 50 " Version 8.0 |
4437 | 51 " - Updated SyntaxCSyntaxGroupItems() |
3224 | 52 " - Some additional syntax items were also allowed |
53 " on nextgroup= lines which were ignored by default. | |
54 " Now these lines are processed independently. | |
55 " | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
56 " Version 7.0 |
4437 | 57 " - Updated syntaxcomplete#OmniSyntaxList() |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
58 " - Looking up the syntax groups defined from a syntax file |
3996 | 59 " looked for only 1 format of {filetype}GroupName, but some |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
60 " syntax writers use this format as well: |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
61 " {b:current_syntax}GroupName |
4437 | 62 " - OmniSyntaxList() will now check for both if the first |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
63 " method does not find a match. |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
64 " |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
65 " Version 6.0 |
4437 | 66 " - Added syntaxcomplete#OmniSyntaxList() |
3996 | 67 " - Allows other plugins to use this for their own |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
68 " purposes. |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
69 " - It will return a List of all syntax items for the |
3996 | 70 " syntax group name passed in. |
71 " - XPTemplate for SQL will use this function via the | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
72 " sqlcomplete plugin to populate a Choose box. |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
73 " |
2072 | 74 " Version 5.0 |
4437 | 75 " - Updated SyntaxCSyntaxGroupItems() |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
76 " - When processing a list of syntax groups, the final group |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
77 " was missed in function SyntaxCSyntaxGroupItems. |
2072 | 78 " |
625 | 79 " Set completion with CTRL-X CTRL-O to autoloaded function. |
785 | 80 " This check is in place in case this script is |
3996 | 81 " sourced directly instead of using the autoload feature. |
702 | 82 if exists('+omnifunc') |
785 | 83 " Do not set the option if already set since this |
84 " results in an E117 warning. | |
85 if &omnifunc == "" | |
86 setlocal omnifunc=syntaxcomplete#Complete | |
87 endif | |
625 | 88 endif |
89 | |
90 if exists('g:loaded_syntax_completion') | |
3996 | 91 finish |
625 | 92 endif |
4437 | 93 let g:loaded_syntax_completion = 130 |
3920 | 94 |
95 " Turn on support for line continuations when creating the script | |
96 let s:cpo_save = &cpo | |
97 set cpo&vim | |
871 | 98 |
99 " Set ignorecase to the ftplugin standard | |
1121 | 100 " This is the default setting, but if you define a buffer local |
101 " variable you can override this on a per filetype. | |
871 | 102 if !exists('g:omni_syntax_ignorecase') |
103 let g:omni_syntax_ignorecase = &ignorecase | |
104 endif | |
625 | 105 |
1121 | 106 " Indicates whether we should use the iskeyword option to determine |
107 " how to split words. | |
108 " This is the default setting, but if you define a buffer local | |
109 " variable you can override this on a per filetype. | |
110 if !exists('g:omni_syntax_use_iskeyword') | |
111 let g:omni_syntax_use_iskeyword = 1 | |
112 endif | |
113 | |
3920 | 114 " When using iskeyword, this setting controls whether the characters |
115 " should be limited to single byte characters. | |
116 if !exists('g:omni_syntax_use_single_byte') | |
117 let g:omni_syntax_use_single_byte = 1 | |
118 endif | |
119 | |
120 " When using iskeyword, this setting controls whether the characters | |
121 " should be limited to single byte characters. | |
122 if !exists('g:omni_syntax_use_iskeyword_numeric') | |
123 let g:omni_syntax_use_iskeyword_numeric = 1 | |
124 endif | |
125 | |
1121 | 126 " Only display items in the completion window that are at least |
127 " this many characters in length. | |
128 " This is the default setting, but if you define a buffer local | |
129 " variable you can override this on a per filetype. | |
130 if !exists('g:omni_syntax_minimum_length') | |
131 let g:omni_syntax_minimum_length = 0 | |
132 endif | |
133 | |
625 | 134 " This script will build a completion list based on the syntax |
135 " elements defined by the files in $VIMRUNTIME/syntax. | |
4437 | 136 " let s:syn_remove_words = 'match,matchgroup=,contains,'. |
137 let s:syn_remove_words = 'matchgroup=,contains,'. | |
3224 | 138 \ 'links to,start=,end=' |
139 " \ 'links to,start=,end=,nextgroup=' | |
625 | 140 |
141 let s:cache_name = [] | |
142 let s:cache_list = [] | |
785 | 143 let s:prepended = '' |
625 | 144 |
145 " This function is used for the 'omnifunc' option. | |
146 function! syntaxcomplete#Complete(findstart, base) | |
147 | |
1121 | 148 " Only display items in the completion window that are at least |
149 " this many characters in length | |
150 if !exists('b:omni_syntax_ignorecase') | |
151 if exists('g:omni_syntax_ignorecase') | |
152 let b:omni_syntax_ignorecase = g:omni_syntax_ignorecase | |
153 else | |
154 let b:omni_syntax_ignorecase = &ignorecase | |
155 endif | |
156 endif | |
157 | |
625 | 158 if a:findstart |
159 " Locate the start of the item, including "." | |
160 let line = getline('.') | |
161 let start = col('.') - 1 | |
162 let lastword = -1 | |
163 while start > 0 | |
1121 | 164 " if line[start - 1] =~ '\S' |
165 " let start -= 1 | |
166 " elseif line[start - 1] =~ '\.' | |
167 if line[start - 1] =~ '\k' | |
625 | 168 let start -= 1 |
1121 | 169 let lastword = a:findstart |
625 | 170 else |
171 break | |
172 endif | |
173 endwhile | |
174 | |
175 " Return the column of the last word, which is going to be changed. | |
176 " Remember the text that comes before it in s:prepended. | |
177 if lastword == -1 | |
178 let s:prepended = '' | |
179 return start | |
180 endif | |
1121 | 181 let s:prepended = strpart(line, start, (col('.') - 1) - start) |
182 return start | |
625 | 183 endif |
184 | |
1121 | 185 " let base = s:prepended . a:base |
24024 | 186 " let base = s:prepended |
187 let base = substitute(s:prepended, "'", "''", 'g') | |
625 | 188 |
871 | 189 let filetype = substitute(&filetype, '\.', '_', 'g') |
190 let list_idx = index(s:cache_name, filetype, 0, &ignorecase) | |
625 | 191 if list_idx > -1 |
192 let compl_list = s:cache_list[list_idx] | |
193 else | |
871 | 194 let compl_list = OmniSyntaxList() |
195 let s:cache_name = add( s:cache_name, filetype ) | |
196 let s:cache_list = add( s:cache_list, compl_list ) | |
625 | 197 endif |
198 | |
199 " Return list of matches. | |
200 | |
1121 | 201 if base != '' |
202 " let compstr = join(compl_list, ' ') | |
203 " let expr = (b:omni_syntax_ignorecase==0?'\C':'').'\<\%('.base.'\)\@!\w\+\s*' | |
204 " let compstr = substitute(compstr, expr, '', 'g') | |
205 " let compl_list = split(compstr, '\s\+') | |
206 | |
207 " Filter the list based on the first few characters the user | |
208 " entered | |
209 let expr = 'v:val '.(g:omni_syntax_ignorecase==1?'=~?':'=~#')." '^".escape(base, '\\/.*$^~[]').".*'" | |
210 let compl_list = filter(deepcopy(compl_list), expr) | |
625 | 211 endif |
212 | |
213 return compl_list | |
214 endfunc | |
215 | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
216 function! syntaxcomplete#OmniSyntaxList(...) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
217 if a:0 > 0 |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
218 let parms = [] |
3996 | 219 if 3 == type(a:1) |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
220 let parms = a:1 |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
221 elseif 1 == type(a:1) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
222 let parms = split(a:1, ',') |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
223 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
224 return OmniSyntaxList( parms ) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
225 else |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
226 return OmniSyntaxList() |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
227 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
228 endfunc |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
229 |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
230 function! OmniSyntaxList(...) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
231 let list_parms = [] |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
232 if a:0 > 0 |
3996 | 233 if 3 == type(a:1) |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
234 let list_parms = a:1 |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
235 elseif 1 == type(a:1) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
236 let list_parms = split(a:1, ',') |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
237 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
238 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
239 |
871 | 240 " Default to returning a dictionary, if use_dictionary is set to 0 |
241 " a list will be returned. | |
242 " let use_dictionary = 1 | |
243 " if a:0 > 0 && a:1 != '' | |
244 " let use_dictionary = a:1 | |
245 " endif | |
246 | |
1121 | 247 " Only display items in the completion window that are at least |
248 " this many characters in length | |
249 if !exists('b:omni_syntax_use_iskeyword') | |
250 if exists('g:omni_syntax_use_iskeyword') | |
251 let b:omni_syntax_use_iskeyword = g:omni_syntax_use_iskeyword | |
252 else | |
253 let b:omni_syntax_use_iskeyword = 1 | |
254 endif | |
255 endif | |
256 | |
257 " Only display items in the completion window that are at least | |
258 " this many characters in length | |
259 if !exists('b:omni_syntax_minimum_length') | |
260 if exists('g:omni_syntax_minimum_length') | |
261 let b:omni_syntax_minimum_length = g:omni_syntax_minimum_length | |
262 else | |
263 let b:omni_syntax_minimum_length = 0 | |
264 endif | |
265 endif | |
266 | |
625 | 267 let saveL = @l |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
268 let filetype = substitute(&filetype, '\.', '_', 'g') |
3996 | 269 |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
270 if empty(list_parms) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
271 " Default the include group to include the requested syntax group |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
272 let syntax_group_include_{filetype} = '' |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
273 " Check if there are any overrides specified for this filetype |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
274 if exists('g:omni_syntax_group_include_'.filetype) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
275 let syntax_group_include_{filetype} = |
3996 | 276 \ substitute( g:omni_syntax_group_include_{filetype},'\s\+','','g') |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
277 let list_parms = split(g:omni_syntax_group_include_{filetype}, ',') |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
278 if syntax_group_include_{filetype} =~ '\w' |
3996 | 279 let syntax_group_include_{filetype} = |
280 \ substitute( syntax_group_include_{filetype}, | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
281 \ '\s*,\s*', '\\|', 'g' |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
282 \ ) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
283 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
284 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
285 else |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
286 " A specific list was provided, use it |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
287 endif |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
288 |
625 | 289 " Loop through all the syntax groupnames, and build a |
3996 | 290 " syntax file which contains these names. This can |
625 | 291 " work generically for any filetype that does not already |
292 " have a plugin defined. | |
293 " This ASSUMES the syntax groupname BEGINS with the name | |
3996 | 294 " of the filetype. From my casual viewing of the vim7\syntax |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
295 " directory this is true for almost all syntax definitions. |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
296 " As an example, the SQL syntax groups have this pattern: |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
297 " sqlType |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
298 " sqlOperators |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
299 " sqlKeyword ... |
4437 | 300 if !empty(list_parms) && empty(substitute(join(list_parms), '[a-zA-Z ]', '', 'g')) |
301 " If list_parms only includes word characters, use it to limit | |
302 " the syntax elements. | |
303 " If using regex syntax list will fail to find those items, so | |
304 " simply grab the who syntax list. | |
305 redir @l | |
306 silent! exec 'syntax list '.join(list_parms) | |
307 redir END | |
308 else | |
309 redir @l | |
310 silent! exec 'syntax list' | |
311 redir END | |
312 endif | |
625 | 313 |
702 | 314 let syntax_full = "\n".@l |
625 | 315 let @l = saveL |
316 | |
3996 | 317 if syntax_full =~ 'E28' |
702 | 318 \ || syntax_full =~ 'E411' |
319 \ || syntax_full =~ 'E415' | |
320 \ || syntax_full =~ 'No Syntax items' | |
321 return [] | |
322 endif | |
323 | |
871 | 324 let filetype = substitute(&filetype, '\.', '_', 'g') |
325 | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
326 let list_exclude_groups = [] |
3996 | 327 if a:0 > 0 |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
328 " Do nothing since we have specific a specific list of groups |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
329 else |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
330 " Default the exclude group to nothing |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
331 let syntax_group_exclude_{filetype} = '' |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
332 " Check if there are any overrides specified for this filetype |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
333 if exists('g:omni_syntax_group_exclude_'.filetype) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
334 let syntax_group_exclude_{filetype} = |
3996 | 335 \ substitute( g:omni_syntax_group_exclude_{filetype},'\s\+','','g') |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
336 let list_exclude_groups = split(g:omni_syntax_group_exclude_{filetype}, ',') |
3996 | 337 if syntax_group_exclude_{filetype} =~ '\w' |
338 let syntax_group_exclude_{filetype} = | |
339 \ substitute( syntax_group_exclude_{filetype}, | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
340 \ '\s*,\s*', '\\|', 'g' |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
341 \ ) |
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
342 endif |
702 | 343 endif |
344 endif | |
345 | |
4437 | 346 if empty(list_parms) |
347 let list_parms = [&filetype.'\w\+'] | |
348 endif | |
625 | 349 |
4437 | 350 let syn_list = '' |
351 let index = 0 | |
352 for group_regex in list_parms | |
353 " Sometimes filetypes can be composite names, like c.doxygen | |
354 " Loop through each individual part looking for the syntax | |
355 " items specific to each individual filetype. | |
356 " let ftindex = 0 | |
357 " let ftindex = match(syntax_full, group_regex, ftindex) | |
871 | 358 |
4437 | 359 " while ftindex > -1 |
360 " let ft_part_name = matchstr( syntax_full, '\w\+', ftindex ) | |
361 | |
362 " Syntax rules can contain items for more than just the current | |
363 " filetype. They can contain additional items added by the user | |
364 " via autocmds or their vimrc. | |
365 " Some syntax files can be combined (html, php, jsp). | |
366 " We want only items that begin with the filetype we are interested in. | |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
367 let next_group_regex = '\n' . |
4437 | 368 \ '\zs'.group_regex.'\ze'. |
3996 | 369 \ '\s\+xxx\s\+' |
2434
86532ee3ea41
Updated runtime files. Add logcheck filetype plugin. (James Vega)
Bram Moolenaar <bram@vim.org>
parents:
2072
diff
changeset
|
370 let index = match(syntax_full, next_group_regex, index) |
3996 | 371 |
4437 | 372 " For the matched group name, strip off any of the regex special |
373 " characters and see if we get a match with the current syntax | |
374 if index == -1 && exists('b:current_syntax') && substitute(group_regex, '[^a-zA-Z ]\+.*', '', 'g') !~ '^'.b:current_syntax | |
375 " There appears to be two standards when writing syntax files. | |
376 " Either items begin as: | |
377 " syn keyword {filetype}Keyword values ... | |
378 " let b:current_syntax = "sql" | |
379 " let b:current_syntax = "sqlanywhere" | |
380 " Or | |
381 " syn keyword {syntax_filename}Keyword values ... | |
382 " let b:current_syntax = "mysql" | |
383 " So, we will make the format of finding the syntax group names | |
384 " a bit more flexible and look for both if the first fails to | |
385 " find a match. | |
386 let next_group_regex = '\n' . | |
387 \ '\zs'.b:current_syntax.'\w\+\ze'. | |
388 \ '\s\+xxx\s\+' | |
389 let index = 0 | |
390 let index = match(syntax_full, next_group_regex, index) | |
871 | 391 endif |
625 | 392 |
4437 | 393 while index > -1 |
394 let group_name = matchstr( syntax_full, '\w\+', index ) | |
395 | |
396 let get_syn_list = 1 | |
397 for exclude_group_name in list_exclude_groups | |
398 if '\<'.exclude_group_name.'\>' =~ '\<'.group_name.'\>' | |
399 let get_syn_list = 0 | |
400 endif | |
401 endfor | |
402 | |
403 " This code is no longer needed in version 6.0 since we have | |
404 " augmented the syntax list command to only retrieve the syntax | |
405 " groups we are interested in. | |
406 " | |
407 " if get_syn_list == 1 | |
408 " if syntax_group_include_{filetype} != '' | |
409 " if '\<'.syntax_group_include_{filetype}.'\>' !~ '\<'.group_name.'\>' | |
410 " let get_syn_list = 0 | |
411 " endif | |
412 " endif | |
413 " endif | |
414 | |
415 if get_syn_list == 1 | |
416 " Pass in the full syntax listing, plus the group name we | |
417 " are interested in. | |
418 let extra_syn_list = s:SyntaxCSyntaxGroupItems(group_name, syntax_full) | |
419 let syn_list = syn_list . extra_syn_list . "\n" | |
420 endif | |
421 | |
422 let index = index + strlen(group_name) | |
423 let index = match(syntax_full, next_group_regex, index) | |
424 endwhile | |
425 | |
426 " let ftindex = ftindex + len(ft_part_name) | |
427 " let ftindex = match( syntax_full, group_regex, ftindex ) | |
428 " endwhile | |
429 endfor | |
430 | |
431 " " Sometimes filetypes can be composite names, like c.doxygen | |
432 " " Loop through each individual part looking for the syntax | |
433 " " items specific to each individual filetype. | |
434 " let syn_list = '' | |
435 " let ftindex = 0 | |
436 " let ftindex = match(&filetype, '\w\+', ftindex) | |
437 | |
438 " while ftindex > -1 | |
439 " let ft_part_name = matchstr( &filetype, '\w\+', ftindex ) | |
871 | 440 |
4437 | 441 " " Syntax rules can contain items for more than just the current |
442 " " filetype. They can contain additional items added by the user | |
443 " " via autocmds or their vimrc. | |
444 " " Some syntax files can be combined (html, php, jsp). | |
445 " " We want only items that begin with the filetype we are interested in. | |
446 " let next_group_regex = '\n' . | |
447 " \ '\zs'.ft_part_name.'\w\+\ze'. | |
448 " \ '\s\+xxx\s\+' | |
449 " let index = 0 | |
450 " let index = match(syntax_full, next_group_regex, index) | |
451 | |
452 " if index == -1 && exists('b:current_syntax') && ft_part_name != b:current_syntax | |
453 " " There appears to be two standards when writing syntax files. | |
454 " " Either items begin as: | |
455 " " syn keyword {filetype}Keyword values ... | |
456 " " let b:current_syntax = "sql" | |
457 " " let b:current_syntax = "sqlanywhere" | |
458 " " Or | |
459 " " syn keyword {syntax_filename}Keyword values ... | |
460 " " let b:current_syntax = "mysql" | |
461 " " So, we will make the format of finding the syntax group names | |
462 " " a bit more flexible and look for both if the first fails to | |
463 " " find a match. | |
464 " let next_group_regex = '\n' . | |
465 " \ '\zs'.b:current_syntax.'\w\+\ze'. | |
466 " \ '\s\+xxx\s\+' | |
467 " let index = 0 | |
468 " let index = match(syntax_full, next_group_regex, index) | |
469 " endif | |
470 | |
471 " while index > -1 | |
472 " let group_name = matchstr( syntax_full, '\w\+', index ) | |
473 | |
474 " let get_syn_list = 1 | |
475 " for exclude_group_name in list_exclude_groups | |
476 " if '\<'.exclude_group_name.'\>' =~ '\<'.group_name.'\>' | |
477 " let get_syn_list = 0 | |
478 " endif | |
479 " endfor | |
480 | |
481 " " This code is no longer needed in version 6.0 since we have | |
482 " " augmented the syntax list command to only retrieve the syntax | |
483 " " groups we are interested in. | |
484 " " | |
485 " " if get_syn_list == 1 | |
486 " " if syntax_group_include_{filetype} != '' | |
487 " " if '\<'.syntax_group_include_{filetype}.'\>' !~ '\<'.group_name.'\>' | |
488 " " let get_syn_list = 0 | |
489 " " endif | |
490 " " endif | |
491 " " endif | |
492 | |
493 " if get_syn_list == 1 | |
494 " " Pass in the full syntax listing, plus the group name we | |
495 " " are interested in. | |
496 " let extra_syn_list = s:SyntaxCSyntaxGroupItems(group_name, syntax_full) | |
497 " let syn_list = syn_list . extra_syn_list . "\n" | |
498 " endif | |
499 | |
500 " let index = index + strlen(group_name) | |
501 " let index = match(syntax_full, next_group_regex, index) | |
502 " endwhile | |
503 | |
504 " let ftindex = ftindex + len(ft_part_name) | |
505 " let ftindex = match( &filetype, '\w\+', ftindex ) | |
506 " endwhile | |
625 | 507 |
702 | 508 " Convert the string to a List and sort it. |
509 let compl_list = sort(split(syn_list)) | |
510 | |
511 if &filetype == 'vim' | |
512 let short_compl_list = [] | |
513 for i in range(len(compl_list)) | |
514 if i == len(compl_list)-1 | |
515 let next = i | |
516 else | |
517 let next = i + 1 | |
518 endif | |
519 if compl_list[next] !~ '^'.compl_list[i].'.$' | |
520 let short_compl_list += [compl_list[i]] | |
521 endif | |
522 endfor | |
523 | |
524 return short_compl_list | |
525 else | |
526 return compl_list | |
527 endif | |
625 | 528 endfunction |
529 | |
818 | 530 function! s:SyntaxCSyntaxGroupItems( group_name, syntax_full ) |
702 | 531 |
532 let syn_list = "" | |
625 | 533 |
702 | 534 " From the full syntax listing, strip out the portion for the |
535 " request group. | |
536 " Query: | |
537 " \n - must begin with a newline | |
538 " a:group_name - the group name we are interested in | |
539 " \s\+xxx\s\+ - group names are always followed by xxx | |
540 " \zs - start the match | |
541 " .\{-} - everything ... | |
542 " \ze - end the match | |
2072 | 543 " \( - start a group or 2 potential matches |
702 | 544 " \n\w - at the first newline starting with a character |
2072 | 545 " \| - 2nd potential match |
546 " \%$ - matches end of the file or string | |
547 " \) - end a group | |
3996 | 548 let syntax_group = matchstr(a:syntax_full, |
2072 | 549 \ "\n".a:group_name.'\s\+xxx\s\+\zs.\{-}\ze\(\n\w\|\%$\)' |
871 | 550 \ ) |
702 | 551 |
552 if syntax_group != "" | |
625 | 553 " let syn_list = substitute( @l, '^.*xxx\s*\%(contained\s*\)\?', "", '' ) |
702 | 554 " let syn_list = substitute( @l, '^.*xxx\s*', "", '' ) |
625 | 555 |
24024 | 556 " We only want the words for the lines beginning with |
625 | 557 " containedin, but there could be other items. |
3996 | 558 |
625 | 559 " Tried to remove all lines that do not begin with contained |
560 " but this does not work in all cases since you can have | |
561 " contained nextgroup=... | |
562 " So this will strip off the ending of lines with known | |
563 " keywords. | |
3996 | 564 let syn_list = substitute( |
871 | 565 \ syntax_group, '\<\('. |
566 \ substitute( | |
567 \ escape(s:syn_remove_words, '\\/.*$^~[]') | |
568 \ , ',', '\\|', 'g' | |
569 \ ). | |
570 \ '\).\{-}\%($\|'."\n".'\)' | |
3996 | 571 \ , "\n", 'g' |
871 | 572 \ ) |
625 | 573 |
4437 | 574 " Attempt to deal with lines using the match syntax |
575 " javaScriptDocTags xxx match /@\(param\|argument\|requires\|file\)\>/ | |
576 " Though it can use any types of regex, so this plugin will attempt | |
577 " to restrict it | |
578 " 1. Only use \( or \%( constructs remove all else | |
579 " 2 Remove and []s | |
580 " 3. Account for match //constructs | |
581 " \%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\? | |
582 " 4. Hope for the best | |
583 " | |
584 " | |
585 let syn_list_old = syn_list | |
586 while syn_list =~ '\<match\>\s\+\/' | |
587 if syn_list =~ 'perlElseIfError' | |
588 let syn_list = syn_list | |
589 endif | |
590 " Check if the match has words at least 3 characters long | |
591 if syn_list =~ '\<match \/\zs.\{-}\<\w\{3,}\>.\{-}\ze\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+' | |
592 " Remove everything after / and before the first \( | |
593 let syn_list = substitute( syn_list, '\<match \/\zs.\{-}\ze\\%\?(.\{-}\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' ) | |
594 " Remove everything after \) and up to the ending / | |
595 let syn_list = substitute( syn_list, '\<match \/.\{-}\\)\zs.\{-}\ze\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' ) | |
596 | |
597 " Remove any character classes | |
598 " let syn_list = substitute( syn_list, '\<match /\zs.\{-}\[[^]]*\].\{-}\ze\/ ', '', 'g' ) | |
599 let syn_list = substitute( syn_list, '\%(\<match \/[^/]\{-}\)\@<=\[[^]]*\]\ze.\{-}\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?', '', 'g' ) | |
600 " Remove any words < 3 characters | |
601 let syn_list = substitute( syn_list, '\%(\<match \/[^/]\{-}\)\@<=\<\w\{1,2}\>\ze.\{-}\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' ) | |
602 " Remove all non-word characters | |
603 " let syn_list = substitute( syn_list, '\<match /\zs.\{-}\<\W\+\>.\{-}\ze\/ ', "", 'g' ) | |
604 " let syn_list = substitute( syn_list, '\%(\<match \/[^/]\{-}\)\@<=\W\+\ze.\{-}\/ ', ' ', 'g' ) | |
17758 | 605 " Do this by using the outer substitute() call to gather all |
4437 | 606 " text between the match /.../ tags. |
607 " The inner substitute() call operates on the text selected | |
608 " and replaces all non-word characters. | |
609 let syn_list = substitute( syn_list, '\<match \/\zs\(.\{-}\)\ze\\\@<!\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+' | |
610 \ , '\=substitute(submatch(1), "\\W\\+", " ", "g")' | |
611 \ , 'g' ) | |
612 " Remove the match / / syntax | |
613 let syn_list = substitute( syn_list, '\<match \/\(.\{-}\)\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '\1', 'g' ) | |
614 else | |
615 " No words long enough, remove the match | |
616 " Remove the match syntax | |
617 " let syn_list = substitute( syn_list, '\<match \/[^\/]*\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' ) | |
618 let syn_list = substitute( syn_list, '\<match \/\%(.\{-}\)\?\/\%(\%(ms\|me\|hs\|he\|rs\|re\|lc\)\S\+\)\?\s\+', '', 'g' ) | |
619 endif | |
620 if syn_list =~ '\<match\>\s\+\/' | |
621 " Problem removing the match / / tags | |
622 let syn_list = '' | |
623 endif | |
624 endwhile | |
625 | |
626 | |
3224 | 627 " Now strip off the newline + blank space + contained. |
628 " Also include lines with nextgroup=@someName skip_key_words syntax_element | |
4437 | 629 " \ syn_list, '\%(^\|\n\)\@<=\s*\<\(contained\|nextgroup=\)' |
630 " \ syn_list, '\%(^\|\n\)\@<=\s*\<\(contained\|nextgroup=[@a-zA-Z,]*\)' | |
3996 | 631 let syn_list = substitute( |
4437 | 632 \ syn_list, '\<\(contained\|nextgroup=[@a-zA-Z,]*\)' |
3996 | 633 \ , "", 'g' |
3224 | 634 \ ) |
635 | |
636 " This can leave lines like this | |
637 " =@vimMenuList skipwhite onoremenu | |
638 " Strip the special option keywords first | |
639 " :h :syn-skipwhite* | |
3996 | 640 let syn_list = substitute( |
3224 | 641 \ syn_list, '\<\(skipwhite\|skipnl\|skipempty\)\>' |
3996 | 642 \ , "", 'g' |
3224 | 643 \ ) |
644 | |
645 " Now remove the remainder of the nextgroup=@someName lines | |
3996 | 646 let syn_list = substitute( |
3224 | 647 \ syn_list, '\%(^\|\n\)\@<=\s*\(@\w\+\)' |
3996 | 648 \ , "", 'g' |
871 | 649 \ ) |
625 | 650 |
1121 | 651 if b:omni_syntax_use_iskeyword == 0 |
652 " There are a number of items which have non-word characters in | |
653 " them, *'T_F1'*. vim.vim is one such file. | |
654 " This will replace non-word characters with spaces. | |
655 let syn_list = substitute( syn_list, '[^0-9A-Za-z_ ]', ' ', 'g' ) | |
656 else | |
3920 | 657 if g:omni_syntax_use_iskeyword_numeric == 1 |
658 " iskeyword can contain value like this | |
659 " 38,42,43,45,47-58,60-62,64-90,97-122,_,+,-,*,/,%,<,=,>,:,$,?,!,@-@,94 | |
660 " Numeric values convert to their ASCII equivalent using the | |
661 " nr2char() function. | |
662 " & 38 | |
3996 | 663 " * 42 |
3920 | 664 " + 43 |
3996 | 665 " - 45 |
3920 | 666 " ^ 94 |
3996 | 667 " Iterate through all numeric specifications and convert those |
3920 | 668 " to their ascii equivalent ensuring the character is printable. |
669 " If so, add it to the list. | |
670 let accepted_chars = '' | |
671 for item in split(&iskeyword, ',') | |
4437 | 672 if item =~ '\d-\d' |
3996 | 673 " This is a character range (ie 47-58), |
3920 | 674 " cycle through each character within the range |
675 let [b:start, b:end] = split(item, '-') | |
676 for range_item in range( b:start, b:end ) | |
677 if range_item <= 127 || g:omni_syntax_use_single_byte == 0 | |
678 if nr2char(range_item) =~ '\p' | |
679 let accepted_chars = accepted_chars . nr2char(range_item) | |
680 endif | |
681 endif | |
682 endfor | |
683 elseif item =~ '^\d\+$' | |
684 " Only numeric, translate to a character | |
685 if item < 127 || g:omni_syntax_use_single_byte == 0 | |
686 if nr2char(item) =~ '\p' | |
687 let accepted_chars = accepted_chars . nr2char(item) | |
688 endif | |
689 endif | |
690 else | |
691 if char2nr(item) < 127 || g:omni_syntax_use_single_byte == 0 | |
692 if item =~ '\p' | |
693 let accepted_chars = accepted_chars . item | |
694 endif | |
695 endif | |
696 endif | |
697 endfor | |
698 " Escape special regex characters | |
3996 | 699 " Looks like the wrong chars are escaped. In a collection, |
700 " :h /[] | |
701 " only `]', `\', `-' and `^' are special: | |
702 " let accepted_chars = escape(accepted_chars, '\\/.*$^~[]' ) | |
703 let accepted_chars = escape(accepted_chars, ']\-^' ) | |
3920 | 704 " Remove all characters that are not acceptable |
705 let syn_list = substitute( syn_list, '[^A-Za-z'.accepted_chars.']', ' ', 'g' ) | |
706 else | |
707 let accept_chars = ','.&iskeyword.',' | |
708 " Remove all character ranges | |
709 " let accept_chars = substitute(accept_chars, ',[^,]\+-[^,]\+,', ',', 'g') | |
710 let accept_chars = substitute(accept_chars, ',\@<=[^,]\+-[^,]\+,', '', 'g') | |
711 " Remove all numeric specifications | |
712 " let accept_chars = substitute(accept_chars, ',\d\{-},', ',', 'g') | |
713 let accept_chars = substitute(accept_chars, ',\@<=\d\{-},', '', 'g') | |
714 " Remove all commas | |
715 let accept_chars = substitute(accept_chars, ',', '', 'g') | |
716 " Escape special regex characters | |
3996 | 717 " Looks like the wrong chars are escaped. In a collection, |
718 " :h /[] | |
719 " only `]', `\', `-' and `^' are special: | |
720 " let accept_chars = escape(accept_chars, '\\/.*$^~[]' ) | |
721 let accept_chars = escape(accept_chars, ']\-^' ) | |
3920 | 722 " Remove all characters that are not acceptable |
723 let syn_list = substitute( syn_list, '[^0-9A-Za-z_'.accept_chars.']', ' ', 'g' ) | |
724 endif | |
1121 | 725 endif |
726 | |
727 if b:omni_syntax_minimum_length > 0 | |
728 " If the user specified a minimum length, enforce it | |
729 let syn_list = substitute(' '.syn_list.' ', ' \S\{,'.b:omni_syntax_minimum_length.'}\ze ', ' ', 'g') | |
730 endif | |
625 | 731 else |
732 let syn_list = '' | |
733 endif | |
734 | |
735 return syn_list | |
736 endfunction | |
3920 | 737 |
738 function! OmniSyntaxShowChars(spec) | |
739 let result = [] | |
740 for item in split(a:spec, ',') | |
741 if len(item) > 1 | |
742 if item == '@-@' | |
743 call add(result, char2nr(item)) | |
744 else | |
745 call extend(result, call('range', split(item, '-'))) | |
746 endif | |
747 else | |
748 if item == '@' " assume this is [A-Za-z] | |
749 for [c1, c2] in [['A', 'Z'], ['a', 'z']] | |
750 call extend(result, range(char2nr(c1), char2nr(c2))) | |
751 endfor | |
752 else | |
753 call add(result, char2nr(item)) | |
754 endif | |
755 endif | |
756 endfor | |
757 return join(map(result, 'nr2char(v:val)'), ', ') | |
758 endfunction | |
759 let &cpo = s:cpo_save | |
760 unlet s:cpo_save |