1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * syntax.c: code for syntax highlighting
17 * Structure that stores information about a highlight group.
18 * The ID of a highlight group is also called group ID. It is the index in
19 * the highlight_ga array PLUS ONE.
23 char_u
*sg_name
; /* highlight group name */
24 char_u
*sg_name_u
; /* uppercase of sg_name */
25 /* for normal terminals */
26 int sg_term
; /* "term=" highlighting attributes */
27 char_u
*sg_start
; /* terminal string for start highl */
28 char_u
*sg_stop
; /* terminal string for stop highl */
29 int sg_term_attr
; /* Screen attr for term mode */
30 /* for color terminals */
31 int sg_cterm
; /* "cterm=" highlighting attr */
32 int sg_cterm_bold
; /* bold attr was set for light color */
33 int sg_cterm_fg
; /* terminal fg color number + 1 */
34 int sg_cterm_bg
; /* terminal bg color number + 1 */
35 int sg_cterm_attr
; /* Screen attr for color term mode */
37 /* for when using the GUI */
38 int sg_gui
; /* "gui=" highlighting attributes */
39 guicolor_T sg_gui_fg
; /* GUI foreground color handle */
40 char_u
*sg_gui_fg_name
;/* GUI foreground color name */
41 guicolor_T sg_gui_bg
; /* GUI background color handle */
42 char_u
*sg_gui_bg_name
;/* GUI background color name */
43 guicolor_T sg_gui_sp
; /* GUI special color handle */
44 char_u
*sg_gui_sp_name
;/* GUI special color name */
45 GuiFont sg_font
; /* GUI font handle */
47 GuiFontset sg_fontset
; /* GUI fontset handle */
49 char_u
*sg_font_name
; /* GUI font or fontset name */
50 int sg_gui_attr
; /* Screen attr for GUI mode */
52 int sg_link
; /* link to this highlight group ID */
53 int sg_set
; /* combination of SG_* flags */
55 scid_T sg_scriptID
; /* script in which the group was last set */
59 #define SG_TERM 1 /* term has been set */
60 #define SG_CTERM 2 /* cterm has been set */
61 #define SG_GUI 4 /* gui has been set */
62 #define SG_LINK 8 /* link has been set */
64 static garray_T highlight_ga
; /* highlight groups for 'highlight' option */
66 #define HL_TABLE() ((struct hl_group *)((highlight_ga.ga_data)))
68 #ifdef FEAT_CMDL_COMPL
69 /* Flags to indicate an additional string for highlight name completion. */
70 static int include_none
= 0; /* when 1 include "None" */
71 static int include_default
= 0; /* when 1 include "default" */
72 static int include_link
= 0; /* when 2 include "link" and "clear" */
76 * The "term", "cterm" and "gui" arguments can be any combination of the
77 * following names, separated by commas (but no spaces!).
79 static char *(hl_name_table
[]) =
80 {"bold", "standout", "underline", "undercurl",
81 "italic", "reverse", "inverse", "NONE"};
82 static int hl_attr_table
[] =
83 {HL_BOLD
, HL_STANDOUT
, HL_UNDERLINE
, HL_UNDERCURL
, HL_ITALIC
, HL_INVERSE
, HL_INVERSE
, 0};
85 static int get_attr_entry
__ARGS((garray_T
*table
, attrentry_T
*aep
));
86 static void syn_unadd_group
__ARGS((void));
87 static void set_hl_attr
__ARGS((int idx
));
88 static void highlight_list_one
__ARGS((int id
));
89 static int highlight_list_arg
__ARGS((int id
, int didh
, int type
, int iarg
, char_u
*sarg
, char *name
));
90 static int syn_add_group
__ARGS((char_u
*name
));
91 static int syn_list_header
__ARGS((int did_header
, int outlen
, int id
));
92 static int hl_has_settings
__ARGS((int idx
, int check_link
));
93 static void highlight_clear
__ARGS((int idx
));
96 static void gui_do_one_color
__ARGS((int idx
, int do_menu
, int do_tooltip
));
97 static int set_group_colors
__ARGS((char_u
*name
, guicolor_T
*fgp
, guicolor_T
*bgp
, int do_menu
, int use_norm
, int do_tooltip
));
98 static guicolor_T color_name2handle
__ARGS((char_u
*name
));
99 static GuiFont font_name2handle
__ARGS((char_u
*name
));
100 # ifdef FEAT_XFONTSET
101 static GuiFontset fontset_name2handle
__ARGS((char_u
*name
, int fixed_width
));
103 static void hl_do_font
__ARGS((int idx
, char_u
*arg
, int do_normal
, int do_menu
, int do_tooltip
));
107 * An attribute number is the index in attr_table plus ATTR_OFF.
109 #define ATTR_OFF (HL_ALL + 1)
111 #if defined(FEAT_SYN_HL) || defined(PROTO)
113 #define SYN_NAMELEN 50 /* maximum length of a syntax name */
115 /* different types of offsets that are possible */
116 #define SPO_MS_OFF 0 /* match start offset */
117 #define SPO_ME_OFF 1 /* match end offset */
118 #define SPO_HS_OFF 2 /* highl. start offset */
119 #define SPO_HE_OFF 3 /* highl. end offset */
120 #define SPO_RS_OFF 4 /* region start offset */
121 #define SPO_RE_OFF 5 /* region end offset */
122 #define SPO_LC_OFF 6 /* leading context offset */
125 static char *(spo_name_tab
[SPO_COUNT
]) =
126 {"ms=", "me=", "hs=", "he=", "rs=", "re=", "lc="};
129 * The patterns that are being searched for are stored in a syn_pattern.
130 * A match item consists of one pattern.
131 * A start/end item consists of n start patterns and m end patterns.
132 * A start/skip/end item consists of n start patterns, one skip pattern and m
134 * For the latter two, the patterns are always consecutive: start-skip-end.
136 * A character offset can be given for the matched text (_m_start and _m_end)
137 * and for the actually highlighted text (_h_start and _h_end).
139 typedef struct syn_pattern
141 char sp_type
; /* see SPTYPE_ defines below */
142 char sp_syncing
; /* this item used for syncing */
143 short sp_flags
; /* see HL_ defines below */
144 struct sp_syn sp_syn
; /* struct passed to in_id_list() */
145 short sp_syn_match_id
; /* highlight group ID of pattern */
146 char_u
*sp_pattern
; /* regexp to match, pattern */
147 regprog_T
*sp_prog
; /* regexp to match, program */
148 int sp_ic
; /* ignore-case flag for sp_prog */
149 short sp_off_flags
; /* see below */
150 int sp_offsets
[SPO_COUNT
]; /* offsets */
151 short *sp_cont_list
; /* cont. group IDs, if non-zero */
152 short *sp_next_list
; /* next group IDs, if non-zero */
153 int sp_sync_idx
; /* sync item index (syncing only) */
154 int sp_line_id
; /* ID of last line where tried */
155 int sp_startcol
; /* next match in sp_line_id line */
158 /* The sp_off_flags are computed like this:
159 * offset from the start of the matched text: (1 << SPO_XX_OFF)
160 * offset from the end of the matched text: (1 << (SPO_XX_OFF + SPO_COUNT))
161 * When both are present, only one is used.
164 #define SPTYPE_MATCH 1 /* match keyword with this group ID */
165 #define SPTYPE_START 2 /* match a regexp, start of item */
166 #define SPTYPE_END 3 /* match a regexp, end of item */
167 #define SPTYPE_SKIP 4 /* match a regexp, skip within item */
169 #define HL_CONTAINED 0x01 /* not used on toplevel */
170 #define HL_TRANSP 0x02 /* has no highlighting */
171 #define HL_ONELINE 0x04 /* match within one line only */
172 #define HL_HAS_EOL 0x08 /* end pattern that matches with $ */
173 #define HL_SYNC_HERE 0x10 /* sync point after this item (syncing only) */
174 #define HL_SYNC_THERE 0x20 /* sync point at current line (syncing only) */
175 #define HL_MATCH 0x40 /* use match ID instead of item ID */
176 #define HL_SKIPNL 0x80 /* nextgroup can skip newlines */
177 #define HL_SKIPWHITE 0x100 /* nextgroup can skip white space */
178 #define HL_SKIPEMPTY 0x200 /* nextgroup can skip empty lines */
179 #define HL_KEEPEND 0x400 /* end match always kept */
180 #define HL_EXCLUDENL 0x800 /* exclude NL from match */
181 #define HL_DISPLAY 0x1000 /* only used for displaying, not syncing */
182 #define HL_FOLD 0x2000 /* define fold */
183 #define HL_EXTEND 0x4000 /* ignore a keepend */
184 /* These don't fit in a short, thus can't be used for syntax items, only for
185 * si_flags and bs_flags. */
186 #define HL_MATCHCONT 0x8000 /* match continued from previous line */
187 #define HL_TRANS_CONT 0x10000L /* transparent item without contains arg */
189 #define SYN_ITEMS(buf) ((synpat_T *)((buf)->b_syn_patterns.ga_data))
191 #define NONE_IDX -2 /* value of sp_sync_idx for "NONE" */
194 * Flags for b_syn_sync_flags:
196 #define SF_CCOMMENT 0x01 /* sync on a C-style comment */
197 #define SF_MATCH 0x02 /* sync by matching a pattern */
199 #define SYN_STATE_P(ssp) ((bufstate_T *)((ssp)->ga_data))
201 #define MAXKEYWLEN 80 /* maximum length of a keyword */
204 * The attributes of the syntax item that has been recognized.
206 static int current_attr
= 0; /* attr of current syntax word */
208 static int current_id
= 0; /* ID of current char for syn_get_id() */
209 static int current_trans_id
= 0; /* idem, transparency removed */
212 typedef struct syn_cluster_S
214 char_u
*scl_name
; /* syntax cluster name */
215 char_u
*scl_name_u
; /* uppercase of scl_name */
216 short *scl_list
; /* IDs in this syntax cluster */
220 * Methods of combining two clusters
222 #define CLUSTER_REPLACE 1 /* replace first list with second */
223 #define CLUSTER_ADD 2 /* add second list to first */
224 #define CLUSTER_SUBTRACT 3 /* subtract second list from first */
226 #define SYN_CLSTR(buf) ((syn_cluster_T *)((buf)->b_syn_clusters.ga_data))
229 * Syntax group IDs have different types:
230 * 0 - 9999 normal syntax groups
231 * 10000 - 14999 ALLBUT indicator (current_syn_inc_tag added)
232 * 15000 - 19999 TOP indicator (current_syn_inc_tag added)
233 * 20000 - 24999 CONTAINED indicator (current_syn_inc_tag added)
234 * >= 25000 cluster IDs (subtract SYNID_CLUSTER for the cluster ID)
236 #define SYNID_ALLBUT 10000 /* syntax group ID for contains=ALLBUT */
237 #define SYNID_TOP 15000 /* syntax group ID for contains=TOP */
238 #define SYNID_CONTAINED 20000 /* syntax group ID for contains=CONTAINED */
239 #define SYNID_CLUSTER 25000 /* first syntax group ID for clusters */
242 * Annoying Hack(TM): ":syn include" needs this pointer to pass to
243 * expand_filename(). Most of the other syntax commands don't need it, so
244 * instead of passing it to them, we stow it here.
246 static char_u
**syn_cmdlinep
;
249 * Another Annoying Hack(TM): To prevent rules from other ":syn include"'d
250 * files from from leaking into ALLBUT lists, we assign a unique ID to the
251 * rules in each ":syn include"'d file.
253 static int current_syn_inc_tag
= 0;
254 static int running_syn_inc_tag
= 0;
257 * In a hashtable item "hi_key" points to "keyword" in a keyentry.
258 * This avoids adding a pointer to the hashtable item.
259 * KE2HIKEY() converts a var pointer to a hashitem key pointer.
260 * HIKEY2KE() converts a hashitem key pointer to a var pointer.
261 * HI2KE() converts a hashitem pointer to a var pointer.
263 static keyentry_T dumkey
;
264 #define KE2HIKEY(kp) ((kp)->keyword)
265 #define HIKEY2KE(p) ((keyentry_T *)((p) - (dumkey.keyword - (char_u *)&dumkey)))
266 #define HI2KE(hi) HIKEY2KE((hi)->hi_key)
269 * To reduce the time spent in keepend(), remember at which level in the state
270 * stack the first item with "keepend" is present. When "-1", there is no
271 * "keepend" on the stack.
273 static int keepend_level
= -1;
276 * For the current state we need to remember more than just the idx.
277 * When si_m_endpos.lnum is 0, the items other than si_idx are unknown.
278 * (The end positions have the column number of the next char)
280 typedef struct state_item
282 int si_idx
; /* index of syntax pattern or
284 int si_id
; /* highlight group ID for keywords */
285 int si_trans_id
; /* idem, transparency removed */
286 int si_m_lnum
; /* lnum of the match */
287 int si_m_startcol
; /* starting column of the match */
288 lpos_T si_m_endpos
; /* just after end posn of the match */
289 lpos_T si_h_startpos
; /* start position of the highlighting */
290 lpos_T si_h_endpos
; /* end position of the highlighting */
291 lpos_T si_eoe_pos
; /* end position of end pattern */
292 int si_end_idx
; /* group ID for end pattern or zero */
293 int si_ends
; /* if match ends before si_m_endpos */
294 int si_attr
; /* attributes in this state */
295 long si_flags
; /* HL_HAS_EOL flag in this state, and
296 * HL_SKIP* for si_next_list */
297 short *si_cont_list
; /* list of contained groups */
298 short *si_next_list
; /* nextgroup IDs after this item ends */
299 reg_extmatch_T
*si_extmatch
; /* \z(...\) matches from start
303 #define KEYWORD_IDX -1 /* value of si_idx for keywords */
304 #define ID_LIST_ALL (short *)-1 /* valid of si_cont_list for containing all
305 but contained groups */
308 * Struct to reduce the number of arguments to get_syn_options(), it's used
313 int flags
; /* flags for contained and transparent */
314 int keyword
; /* TRUE for ":syn keyword" */
315 int *sync_idx
; /* syntax item for "grouphere" argument, NULL
317 char has_cont_list
; /* TRUE if "cont_list" can be used */
318 short *cont_list
; /* group IDs for "contains" argument */
319 short *cont_in_list
; /* group IDs for "containedin" argument */
320 short *next_list
; /* group IDs for "nextgroup" argument */
324 * The next possible match in the current line for any pattern is remembered,
325 * to avoid having to try for a match in each column.
326 * If next_match_idx == -1, not tried (in this line) yet.
327 * If next_match_col == MAXCOL, no match found in this line.
328 * (All end positions have the column of the char after the end)
330 static int next_match_col
; /* column for start of next match */
331 static lpos_T next_match_m_endpos
; /* position for end of next match */
332 static lpos_T next_match_h_startpos
; /* pos. for highl. start of next match */
333 static lpos_T next_match_h_endpos
; /* pos. for highl. end of next match */
334 static int next_match_idx
; /* index of matched item */
335 static long next_match_flags
; /* flags for next match */
336 static lpos_T next_match_eos_pos
; /* end of start pattn (start region) */
337 static lpos_T next_match_eoe_pos
; /* pos. for end of end pattern */
338 static int next_match_end_idx
; /* ID of group for end pattn or zero */
339 static reg_extmatch_T
*next_match_extmatch
= NULL
;
342 * A state stack is an array of integers or stateitem_T, stored in a
343 * garray_T. A state stack is invalid if it's itemsize entry is zero.
345 #define INVALID_STATE(ssp) ((ssp)->ga_itemsize == 0)
346 #define VALID_STATE(ssp) ((ssp)->ga_itemsize != 0)
349 * The current state (within the line) of the recognition engine.
350 * When current_state.ga_itemsize is 0 the current state is invalid.
352 static win_T
*syn_win
; /* current window for highlighting */
353 static buf_T
*syn_buf
; /* current buffer for highlighting */
354 static linenr_T current_lnum
= 0; /* lnum of current state */
355 static colnr_T current_col
= 0; /* column of current state */
356 static int current_state_stored
= 0; /* TRUE if stored current state
357 * after setting current_finished */
358 static int current_finished
= 0; /* current line has been finished */
359 static garray_T current_state
/* current stack of state_items */
360 = {0, 0, 0, 0, NULL
};
361 static short *current_next_list
= NULL
; /* when non-zero, nextgroup list */
362 static int current_next_flags
= 0; /* flags for current_next_list */
363 static int current_line_id
= 0; /* unique number for current line */
365 #define CUR_STATE(idx) ((stateitem_T *)(current_state.ga_data))[idx]
367 static void syn_sync
__ARGS((win_T
*wp
, linenr_T lnum
, synstate_T
*last_valid
));
368 static int syn_match_linecont
__ARGS((linenr_T lnum
));
369 static void syn_start_line
__ARGS((void));
370 static void syn_update_ends
__ARGS((int startofline
));
371 static void syn_stack_alloc
__ARGS((void));
372 static int syn_stack_cleanup
__ARGS((void));
373 static void syn_stack_free_entry
__ARGS((buf_T
*buf
, synstate_T
*p
));
374 static synstate_T
*syn_stack_find_entry
__ARGS((linenr_T lnum
));
375 static synstate_T
*store_current_state
__ARGS((void));
376 static void load_current_state
__ARGS((synstate_T
*from
));
377 static void invalidate_current_state
__ARGS((void));
378 static int syn_stack_equal
__ARGS((synstate_T
*sp
));
379 static void validate_current_state
__ARGS((void));
380 static int syn_finish_line
__ARGS((int syncing
));
381 static int syn_current_attr
__ARGS((int syncing
, int displaying
, int *can_spell
, int keep_state
));
382 static int did_match_already
__ARGS((int idx
, garray_T
*gap
));
383 static stateitem_T
*push_next_match
__ARGS((stateitem_T
*cur_si
));
384 static void check_state_ends
__ARGS((void));
385 static void update_si_attr
__ARGS((int idx
));
386 static void check_keepend
__ARGS((void));
387 static void update_si_end
__ARGS((stateitem_T
*sip
, int startcol
, int force
));
388 static short *copy_id_list
__ARGS((short *list
));
389 static int in_id_list
__ARGS((stateitem_T
*item
, short *cont_list
, struct sp_syn
*ssp
, int contained
));
390 static int push_current_state
__ARGS((int idx
));
391 static void pop_current_state
__ARGS((void));
393 static void find_endpos
__ARGS((int idx
, lpos_T
*startpos
, lpos_T
*m_endpos
, lpos_T
*hl_endpos
, long *flagsp
, lpos_T
*end_endpos
, int *end_idx
, reg_extmatch_T
*start_ext
));
394 static void clear_syn_state
__ARGS((synstate_T
*p
));
395 static void clear_current_state
__ARGS((void));
397 static void limit_pos
__ARGS((lpos_T
*pos
, lpos_T
*limit
));
398 static void limit_pos_zero
__ARGS((lpos_T
*pos
, lpos_T
*limit
));
399 static void syn_add_end_off
__ARGS((lpos_T
*result
, regmmatch_T
*regmatch
, synpat_T
*spp
, int idx
, int extra
));
400 static void syn_add_start_off
__ARGS((lpos_T
*result
, regmmatch_T
*regmatch
, synpat_T
*spp
, int idx
, int extra
));
401 static char_u
*syn_getcurline
__ARGS((void));
402 static int syn_regexec
__ARGS((regmmatch_T
*rmp
, linenr_T lnum
, colnr_T col
));
403 static int check_keyword_id
__ARGS((char_u
*line
, int startcol
, int *endcol
, long *flags
, short **next_list
, stateitem_T
*cur_si
));
404 static void syn_cmd_case
__ARGS((exarg_T
*eap
, int syncing
));
405 static void syn_cmd_spell
__ARGS((exarg_T
*eap
, int syncing
));
406 static void syntax_sync_clear
__ARGS((void));
407 static void syn_remove_pattern
__ARGS((buf_T
*buf
, int idx
));
408 static void syn_clear_pattern
__ARGS((buf_T
*buf
, int i
));
409 static void syn_clear_cluster
__ARGS((buf_T
*buf
, int i
));
410 static void syn_cmd_clear
__ARGS((exarg_T
*eap
, int syncing
));
411 static void syn_clear_one
__ARGS((int id
, int syncing
));
412 static void syn_cmd_on
__ARGS((exarg_T
*eap
, int syncing
));
413 static void syn_cmd_enable
__ARGS((exarg_T
*eap
, int syncing
));
414 static void syn_cmd_reset
__ARGS((exarg_T
*eap
, int syncing
));
415 static void syn_cmd_manual
__ARGS((exarg_T
*eap
, int syncing
));
416 static void syn_cmd_off
__ARGS((exarg_T
*eap
, int syncing
));
417 static void syn_cmd_onoff
__ARGS((exarg_T
*eap
, char *name
));
418 static void syn_cmd_list
__ARGS((exarg_T
*eap
, int syncing
));
419 static void syn_lines_msg
__ARGS((void));
420 static void syn_match_msg
__ARGS((void));
421 static void syn_list_one
__ARGS((int id
, int syncing
, int link_only
));
422 static void syn_list_cluster
__ARGS((int id
));
423 static void put_id_list
__ARGS((char_u
*name
, short *list
, int attr
));
424 static void put_pattern
__ARGS((char *s
, int c
, synpat_T
*spp
, int attr
));
425 static int syn_list_keywords
__ARGS((int id
, hashtab_T
*ht
, int did_header
, int attr
));
426 static void syn_clear_keyword
__ARGS((int id
, hashtab_T
*ht
));
427 static void clear_keywtab
__ARGS((hashtab_T
*ht
));
428 static void add_keyword
__ARGS((char_u
*name
, int id
, int flags
, short *cont_in_list
, short *next_list
));
429 static char_u
*get_group_name
__ARGS((char_u
*arg
, char_u
**name_end
));
430 static char_u
*get_syn_options
__ARGS((char_u
*arg
, syn_opt_arg_T
*opt
));
431 static void syn_cmd_include
__ARGS((exarg_T
*eap
, int syncing
));
432 static void syn_cmd_keyword
__ARGS((exarg_T
*eap
, int syncing
));
433 static void syn_cmd_match
__ARGS((exarg_T
*eap
, int syncing
));
434 static void syn_cmd_region
__ARGS((exarg_T
*eap
, int syncing
));
436 static int _RTLENTRYF syn_compare_stub
__ARGS((const void *v1
, const void *v2
));
438 static int syn_compare_stub
__ARGS((const void *v1
, const void *v2
));
440 static void syn_cmd_cluster
__ARGS((exarg_T
*eap
, int syncing
));
441 static int syn_scl_name2id
__ARGS((char_u
*name
));
442 static int syn_scl_namen2id
__ARGS((char_u
*linep
, int len
));
443 static int syn_check_cluster
__ARGS((char_u
*pp
, int len
));
444 static int syn_add_cluster
__ARGS((char_u
*name
));
445 static void init_syn_patterns
__ARGS((void));
446 static char_u
*get_syn_pattern
__ARGS((char_u
*arg
, synpat_T
*ci
));
447 static void syn_cmd_sync
__ARGS((exarg_T
*eap
, int syncing
));
448 static int get_id_list
__ARGS((char_u
**arg
, int keylen
, short **list
));
449 static void syn_combine_list
__ARGS((short **clstr1
, short **clstr2
, int list_op
));
450 static void syn_incl_toplevel
__ARGS((int id
, int *flagsp
));
453 * Start the syntax recognition for a line. This function is normally called
454 * from the screen updating, once for each displayed line.
455 * The buffer is remembered in syn_buf, because get_syntax_attr() doesn't get
456 * it. Careful: curbuf and curwin are likely to point to another buffer and
460 syntax_start(wp
, lnum
)
465 synstate_T
*last_valid
= NULL
;
466 synstate_T
*last_min_valid
= NULL
;
467 synstate_T
*sp
, *prev
= NULL
;
468 linenr_T parsed_lnum
;
469 linenr_T first_stored
;
471 static int changedtick
= 0; /* remember the last change ID */
474 * After switching buffers, invalidate current_state.
475 * Also do this when a change was made, the current state may be invalid
478 if (syn_buf
!= wp
->w_buffer
|| changedtick
!= syn_buf
->b_changedtick
)
480 invalidate_current_state();
481 syn_buf
= wp
->w_buffer
;
483 changedtick
= syn_buf
->b_changedtick
;
487 * Allocate syntax stack when needed.
490 if (syn_buf
->b_sst_array
== NULL
)
491 return; /* out of memory */
492 syn_buf
->b_sst_lasttick
= display_tick
;
495 * If the state of the end of the previous line is useful, store it.
497 if (VALID_STATE(¤t_state
)
498 && current_lnum
< lnum
499 && current_lnum
< syn_buf
->b_ml
.ml_line_count
)
501 (void)syn_finish_line(FALSE
);
502 if (!current_state_stored
)
505 (void)store_current_state();
509 * If the current_lnum is now the same as "lnum", keep the current
510 * state (this happens very often!). Otherwise invalidate
511 * current_state and figure it out below.
513 if (current_lnum
!= lnum
)
514 invalidate_current_state();
517 invalidate_current_state();
520 * Try to synchronize from a saved state in b_sst_array[].
521 * Only do this if lnum is not before and not to far beyond a saved state.
523 if (INVALID_STATE(¤t_state
) && syn_buf
->b_sst_array
!= NULL
)
525 /* Find last valid saved state before start_lnum. */
526 for (p
= syn_buf
->b_sst_first
; p
!= NULL
; p
= p
->sst_next
)
528 if (p
->sst_lnum
> lnum
)
530 if (p
->sst_lnum
<= lnum
&& p
->sst_change_lnum
== 0)
533 if (p
->sst_lnum
>= lnum
- syn_buf
->b_syn_sync_minlines
)
537 if (last_min_valid
!= NULL
)
538 load_current_state(last_min_valid
);
542 * If "lnum" is before or far beyond a line with a saved state, need to
545 if (INVALID_STATE(¤t_state
))
547 syn_sync(wp
, lnum
, last_valid
);
548 first_stored
= current_lnum
+ syn_buf
->b_syn_sync_minlines
;
551 first_stored
= current_lnum
;
554 * Advance from the sync point or saved state until the current line.
555 * Save some entries for syncing with later on.
557 if (syn_buf
->b_sst_len
<= Rows
)
560 dist
= syn_buf
->b_ml
.ml_line_count
/ (syn_buf
->b_sst_len
- Rows
) + 1;
561 while (current_lnum
< lnum
)
564 (void)syn_finish_line(FALSE
);
567 /* If we parsed at least "minlines" lines or started at a valid
568 * state, the current state is considered valid. */
569 if (current_lnum
>= first_stored
)
571 /* Check if the saved state entry is for the current line and is
572 * equal to the current state. If so, then validate all saved
573 * states that depended on a change before the parsed line. */
575 prev
= syn_stack_find_entry(current_lnum
- 1);
577 sp
= syn_buf
->b_sst_first
;
580 while (sp
!= NULL
&& sp
->sst_lnum
< current_lnum
)
583 && sp
->sst_lnum
== current_lnum
584 && syn_stack_equal(sp
))
586 parsed_lnum
= current_lnum
;
588 while (sp
!= NULL
&& sp
->sst_change_lnum
<= parsed_lnum
)
590 if (sp
->sst_lnum
<= lnum
)
591 /* valid state before desired line, use this one */
593 else if (sp
->sst_change_lnum
== 0)
594 /* past saved states depending on change, break here. */
596 sp
->sst_change_lnum
= 0;
599 load_current_state(prev
);
601 /* Store the state at this line when it's the first one, the line
602 * where we start parsing, or some distance from the previously
603 * saved state. But only when parsed at least 'minlines'. */
604 else if (prev
== NULL
605 || current_lnum
== lnum
606 || current_lnum
>= prev
->sst_lnum
+ dist
)
607 prev
= store_current_state();
610 /* This can take a long time: break when CTRL-C pressed. The current
611 * state will be wrong then. */
624 * We cannot simply discard growarrays full of state_items or buf_states; we
625 * have to manually release their extmatch pointers first.
634 if (p
->sst_stacksize
> SST_FIX_STATES
)
636 gap
= &(p
->sst_union
.sst_ga
);
637 for (i
= 0; i
< gap
->ga_len
; i
++)
638 unref_extmatch(SYN_STATE_P(gap
)[i
].bs_extmatch
);
643 for (i
= 0; i
< p
->sst_stacksize
; i
++)
644 unref_extmatch(p
->sst_union
.sst_stack
[i
].bs_extmatch
);
649 * Cleanup the current_state stack.
652 clear_current_state()
657 sip
= (stateitem_T
*)(current_state
.ga_data
);
658 for (i
= 0; i
< current_state
.ga_len
; i
++)
659 unref_extmatch(sip
[i
].si_extmatch
);
660 ga_clear(¤t_state
);
664 * Try to find a synchronisation point for line "lnum".
666 * This sets current_lnum and the current state. One of three methods is
668 * 1. Search backwards for the end of a C-comment.
669 * 2. Search backwards for given sync patterns.
670 * 3. Simply start on a given number of lines above "lnum".
673 syn_sync(wp
, start_lnum
, last_valid
)
676 synstate_T
*last_valid
;
690 int found_match_idx
= 0;
691 linenr_T found_current_lnum
= 0;
692 int found_current_col
= 0;
693 lpos_T found_m_endpos
;
694 colnr_T prev_current_col
;
697 * Clear any current state that might be hanging around.
699 invalidate_current_state();
702 * Start at least "minlines" back. Default starting point for parsing is
704 * Start further back, to avoid that scrolling backwards will result in
705 * resyncing for every line. Now it resyncs only one out of N lines,
706 * where N is minlines * 1.5, or minlines * 2 if minlines is small.
707 * Watch out for overflow when minlines is MAXLNUM.
709 if (syn_buf
->b_syn_sync_minlines
> start_lnum
)
713 if (syn_buf
->b_syn_sync_minlines
== 1)
715 else if (syn_buf
->b_syn_sync_minlines
< 10)
716 lnum
= syn_buf
->b_syn_sync_minlines
* 2;
718 lnum
= syn_buf
->b_syn_sync_minlines
* 3 / 2;
719 if (syn_buf
->b_syn_sync_maxlines
!= 0
720 && lnum
> syn_buf
->b_syn_sync_maxlines
)
721 lnum
= syn_buf
->b_syn_sync_maxlines
;
722 if (lnum
>= start_lnum
)
727 current_lnum
= start_lnum
;
730 * 1. Search backwards for the end of a C-style comment.
732 if (syn_buf
->b_syn_sync_flags
& SF_CCOMMENT
)
734 /* Need to make syn_buf the current buffer for a moment, to be able to
735 * use find_start_comment(). */
736 curwin_save
= curwin
;
738 curbuf_save
= curbuf
;
742 * Skip lines that end in a backslash.
744 for ( ; start_lnum
> 1; --start_lnum
)
746 line
= ml_get(start_lnum
- 1);
747 if (*line
== NUL
|| *(line
+ STRLEN(line
) - 1) != '\\')
750 current_lnum
= start_lnum
;
752 /* set cursor to start of search */
753 cursor_save
= wp
->w_cursor
;
754 wp
->w_cursor
.lnum
= start_lnum
;
755 wp
->w_cursor
.col
= 0;
758 * If the line is inside a comment, need to find the syntax item that
759 * defines the comment.
760 * Restrict the search for the end of a comment to b_syn_sync_maxlines.
762 if (find_start_comment((int)syn_buf
->b_syn_sync_maxlines
) != NULL
)
764 for (idx
= syn_buf
->b_syn_patterns
.ga_len
; --idx
>= 0; )
765 if (SYN_ITEMS(syn_buf
)[idx
].sp_syn
.id
== syn_buf
->b_syn_sync_id
766 && SYN_ITEMS(syn_buf
)[idx
].sp_type
== SPTYPE_START
)
768 validate_current_state();
769 if (push_current_state(idx
) == OK
)
770 update_si_attr(current_state
.ga_len
- 1);
775 /* restore cursor and buffer */
776 wp
->w_cursor
= cursor_save
;
777 curwin
= curwin_save
;
778 curbuf
= curbuf_save
;
782 * 2. Search backwards for given sync patterns.
784 else if (syn_buf
->b_syn_sync_flags
& SF_MATCH
)
786 if (syn_buf
->b_syn_sync_maxlines
!= 0
787 && start_lnum
> syn_buf
->b_syn_sync_maxlines
)
788 break_lnum
= start_lnum
- syn_buf
->b_syn_sync_maxlines
;
792 found_m_endpos
.lnum
= 0;
793 found_m_endpos
.col
= 0;
794 end_lnum
= start_lnum
;
796 while (--lnum
> break_lnum
)
798 /* This can take a long time: break when CTRL-C pressed. */
802 invalidate_current_state();
803 current_lnum
= start_lnum
;
807 /* Check if we have run into a valid saved state stack now. */
808 if (last_valid
!= NULL
&& lnum
== last_valid
->sst_lnum
)
810 load_current_state(last_valid
);
815 * Check if the previous line has the line-continuation pattern.
817 if (lnum
> 1 && syn_match_linecont(lnum
- 1))
821 * Start with nothing on the state stack
823 validate_current_state();
825 for (current_lnum
= lnum
; current_lnum
< end_lnum
; ++current_lnum
)
830 had_sync_point
= syn_finish_line(TRUE
);
832 * When a sync point has been found, remember where, and
833 * continue to look for another one, further on in the line.
835 if (had_sync_point
&& current_state
.ga_len
)
837 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
838 if (cur_si
->si_m_endpos
.lnum
> start_lnum
)
840 /* ignore match that goes to after where started */
841 current_lnum
= end_lnum
;
844 if (cur_si
->si_idx
< 0)
848 found_match_idx
= KEYWORD_IDX
;
852 spp
= &(SYN_ITEMS(syn_buf
)[cur_si
->si_idx
]);
853 found_flags
= spp
->sp_flags
;
854 found_match_idx
= spp
->sp_sync_idx
;
856 found_current_lnum
= current_lnum
;
857 found_current_col
= current_col
;
858 found_m_endpos
= cur_si
->si_m_endpos
;
860 * Continue after the match (be aware of a zero-length
863 if (found_m_endpos
.lnum
> current_lnum
)
865 current_lnum
= found_m_endpos
.lnum
;
866 current_col
= found_m_endpos
.col
;
867 if (current_lnum
>= end_lnum
)
870 else if (found_m_endpos
.col
> current_col
)
871 current_col
= found_m_endpos
.col
;
875 /* syn_current_attr() will have skipped the check for
876 * an item that ends here, need to do that now. Be
877 * careful not to go past the NUL. */
878 prev_current_col
= current_col
;
879 if (syn_getcurline()[current_col
] != NUL
)
882 current_col
= prev_current_col
;
890 * If a sync point was encountered, break here.
895 * Put the item that was specified by the sync point on the
896 * state stack. If there was no item specified, make the
899 clear_current_state();
900 if (found_match_idx
>= 0
901 && push_current_state(found_match_idx
) == OK
)
902 update_si_attr(current_state
.ga_len
- 1);
905 * When using "grouphere", continue from the sync point
906 * match, until the end of the line. Parsing starts at
908 * For "groupthere" the parsing starts at start_lnum.
910 if (found_flags
& HL_SYNC_HERE
)
912 if (current_state
.ga_len
)
914 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
915 cur_si
->si_h_startpos
.lnum
= found_current_lnum
;
916 cur_si
->si_h_startpos
.col
= found_current_col
;
917 update_si_end(cur_si
, (int)current_col
, TRUE
);
920 current_col
= found_m_endpos
.col
;
921 current_lnum
= found_m_endpos
.lnum
;
922 (void)syn_finish_line(FALSE
);
926 current_lnum
= start_lnum
;
932 invalidate_current_state();
935 /* Ran into start of the file or exceeded maximum number of lines */
936 if (lnum
<= break_lnum
)
938 invalidate_current_state();
939 current_lnum
= break_lnum
+ 1;
943 validate_current_state();
947 * Return TRUE if the line-continuation pattern matches in line "lnum".
950 syn_match_linecont(lnum
)
953 regmmatch_T regmatch
;
955 if (syn_buf
->b_syn_linecont_prog
!= NULL
)
957 regmatch
.rmm_ic
= syn_buf
->b_syn_linecont_ic
;
958 regmatch
.regprog
= syn_buf
->b_syn_linecont_prog
;
959 return syn_regexec(®match
, lnum
, (colnr_T
)0);
965 * Prepare the current state for the start of a line.
970 current_finished
= FALSE
;
974 * Need to update the end of a start/skip/end that continues from the
975 * previous line and regions that have "keepend".
977 if (current_state
.ga_len
> 0)
978 syn_update_ends(TRUE
);
985 * Check for items in the stack that need their end updated.
986 * When "startofline" is TRUE the last item is always updated.
987 * When "startofline" is FALSE the item with "keepend" is forcefully updated.
990 syn_update_ends(startofline
)
999 /* Check for a match carried over from a previous line with a
1000 * contained region. The match ends as soon as the region ends. */
1001 for (i
= 0; i
< current_state
.ga_len
; ++i
)
1003 cur_si
= &CUR_STATE(i
);
1004 if (cur_si
->si_idx
>= 0
1005 && (SYN_ITEMS(syn_buf
)[cur_si
->si_idx
]).sp_type
1007 && cur_si
->si_m_endpos
.lnum
< current_lnum
)
1009 cur_si
->si_flags
|= HL_MATCHCONT
;
1010 cur_si
->si_m_endpos
.lnum
= 0;
1011 cur_si
->si_m_endpos
.col
= 0;
1012 cur_si
->si_h_endpos
= cur_si
->si_m_endpos
;
1013 cur_si
->si_ends
= TRUE
;
1019 * Need to update the end of a start/skip/end that continues from the
1020 * previous line. And regions that have "keepend", because they may
1021 * influence contained items. If we've just removed "extend"
1022 * (startofline == 0) then we should update ends of normal regions
1023 * contained inside "keepend" because "extend" could have extended
1024 * these "keepend" regions as well as contained normal regions.
1025 * Then check for items ending in column 0.
1027 i
= current_state
.ga_len
- 1;
1028 if (keepend_level
>= 0)
1029 for ( ; i
> keepend_level
; --i
)
1030 if (CUR_STATE(i
).si_flags
& HL_EXTEND
)
1033 seen_keepend
= FALSE
;
1034 for ( ; i
< current_state
.ga_len
; ++i
)
1036 cur_si
= &CUR_STATE(i
);
1037 if ((cur_si
->si_flags
& HL_KEEPEND
)
1038 || (seen_keepend
&& !startofline
)
1039 || (i
== current_state
.ga_len
- 1 && startofline
))
1041 cur_si
->si_h_startpos
.col
= 0; /* start highl. in col 0 */
1042 cur_si
->si_h_startpos
.lnum
= current_lnum
;
1044 if (!(cur_si
->si_flags
& HL_MATCHCONT
))
1045 update_si_end(cur_si
, (int)current_col
, !startofline
);
1047 if (!startofline
&& (cur_si
->si_flags
& HL_KEEPEND
))
1048 seen_keepend
= TRUE
;
1055 /****************************************
1056 * Handling of the state stack cache.
1060 * EXPLANATION OF THE SYNTAX STATE STACK CACHE
1062 * To speed up syntax highlighting, the state stack for the start of some
1063 * lines is cached. These entries can be used to start parsing at that point.
1065 * The stack is kept in b_sst_array[] for each buffer. There is a list of
1066 * valid entries. b_sst_first points to the first one, then follow sst_next.
1067 * The entries are sorted on line number. The first entry is often for line 2
1068 * (line 1 always starts with an empty stack).
1069 * There is also a list for free entries. This construction is used to avoid
1070 * having to allocate and free memory blocks too often.
1072 * When making changes to the buffer, this is logged in b_mod_*. When calling
1073 * update_screen() to update the display, it will call
1074 * syn_stack_apply_changes() for each displayed buffer to adjust the cached
1075 * entries. The entries which are inside the changed area are removed,
1076 * because they must be recomputed. Entries below the changed have their line
1077 * number adjusted for deleted/inserted lines, and have their sst_change_lnum
1078 * set to indicate that a check must be made if the changed lines would change
1081 * When later displaying lines, an entry is stored for each line. Displayed
1082 * lines are likely to be displayed again, in which case the state at the
1083 * start of the line is needed.
1084 * For not displayed lines, an entry is stored for every so many lines. These
1085 * entries will be used e.g., when scrolling backwards. The distance between
1086 * entries depends on the number of lines in the buffer. For small buffers
1087 * the distance is fixed at SST_DIST, for large buffers there is a fixed
1088 * number of entries SST_MAX_ENTRIES, and the distance is computed.
1092 * Free b_sst_array[] for buffer "buf".
1093 * Used when syntax items changed to force resyncing everywhere.
1096 syn_stack_free_all(buf
)
1102 if (buf
->b_sst_array
!= NULL
)
1104 for (p
= buf
->b_sst_first
; p
!= NULL
; p
= p
->sst_next
)
1106 vim_free(buf
->b_sst_array
);
1107 buf
->b_sst_array
= NULL
;
1111 /* When using "syntax" fold method, must update all folds. */
1114 if (wp
->w_buffer
== buf
&& foldmethodIsSyntax(wp
))
1121 * Allocate the syntax state stack for syn_buf when needed.
1122 * If the number of entries in b_sst_array[] is much too big or a bit too
1123 * small, reallocate it.
1124 * Also used to allocate b_sst_array[] for the first time.
1130 synstate_T
*to
, *from
;
1133 len
= syn_buf
->b_ml
.ml_line_count
/ SST_DIST
+ Rows
* 2;
1134 if (len
< SST_MIN_ENTRIES
)
1135 len
= SST_MIN_ENTRIES
;
1136 else if (len
> SST_MAX_ENTRIES
)
1137 len
= SST_MAX_ENTRIES
;
1138 if (syn_buf
->b_sst_len
> len
* 2 || syn_buf
->b_sst_len
< len
)
1140 /* Allocate 50% too much, to avoid reallocating too often. */
1141 len
= syn_buf
->b_ml
.ml_line_count
;
1142 len
= (len
+ len
/ 2) / SST_DIST
+ Rows
* 2;
1143 if (len
< SST_MIN_ENTRIES
)
1144 len
= SST_MIN_ENTRIES
;
1145 else if (len
> SST_MAX_ENTRIES
)
1146 len
= SST_MAX_ENTRIES
;
1148 if (syn_buf
->b_sst_array
!= NULL
)
1150 /* When shrinking the array, cleanup the existing stack.
1151 * Make sure that all valid entries fit in the new array. */
1152 while (syn_buf
->b_sst_len
- syn_buf
->b_sst_freecount
+ 2 > len
1153 && syn_stack_cleanup())
1155 if (len
< syn_buf
->b_sst_len
- syn_buf
->b_sst_freecount
+ 2)
1156 len
= syn_buf
->b_sst_len
- syn_buf
->b_sst_freecount
+ 2;
1159 sstp
= (synstate_T
*)alloc_clear((unsigned)(len
* sizeof(synstate_T
)));
1160 if (sstp
== NULL
) /* out of memory! */
1164 if (syn_buf
->b_sst_array
!= NULL
)
1166 /* Move the states from the old array to the new one. */
1167 for (from
= syn_buf
->b_sst_first
; from
!= NULL
;
1168 from
= from
->sst_next
)
1172 to
->sst_next
= to
+ 1;
1177 to
->sst_next
= NULL
;
1178 syn_buf
->b_sst_first
= sstp
;
1179 syn_buf
->b_sst_freecount
= len
- (int)(to
- sstp
) - 1;
1183 syn_buf
->b_sst_first
= NULL
;
1184 syn_buf
->b_sst_freecount
= len
;
1187 /* Create the list of free entries. */
1188 syn_buf
->b_sst_firstfree
= to
+ 1;
1189 while (++to
< sstp
+ len
)
1190 to
->sst_next
= to
+ 1;
1191 (sstp
+ len
- 1)->sst_next
= NULL
;
1193 vim_free(syn_buf
->b_sst_array
);
1194 syn_buf
->b_sst_array
= sstp
;
1195 syn_buf
->b_sst_len
= len
;
1200 * Check for changes in a buffer to affect stored syntax states. Uses the
1202 * Called from update_screen(), before screen is being updated, once for each
1206 syn_stack_apply_changes(buf
)
1209 synstate_T
*p
, *prev
, *np
;
1212 if (buf
->b_sst_array
== NULL
) /* nothing to do */
1216 for (p
= buf
->b_sst_first
; p
!= NULL
; )
1218 if (p
->sst_lnum
+ buf
->b_syn_sync_linebreaks
> buf
->b_mod_top
)
1220 n
= p
->sst_lnum
+ buf
->b_mod_xlines
;
1221 if (n
<= buf
->b_mod_bot
)
1223 /* this state is inside the changed area, remove it */
1226 buf
->b_sst_first
= np
;
1228 prev
->sst_next
= np
;
1229 syn_stack_free_entry(buf
, p
);
1233 /* This state is below the changed area. Remember the line
1234 * that needs to be parsed before this entry can be made valid
1236 if (p
->sst_change_lnum
!= 0 && p
->sst_change_lnum
> buf
->b_mod_top
)
1238 if (p
->sst_change_lnum
+ buf
->b_mod_xlines
> buf
->b_mod_top
)
1239 p
->sst_change_lnum
+= buf
->b_mod_xlines
;
1241 p
->sst_change_lnum
= buf
->b_mod_top
;
1243 if (p
->sst_change_lnum
== 0
1244 || p
->sst_change_lnum
< buf
->b_mod_bot
)
1245 p
->sst_change_lnum
= buf
->b_mod_bot
;
1255 * Reduce the number of entries in the state stack for syn_buf.
1256 * Returns TRUE if at least one entry was freed.
1261 synstate_T
*p
, *prev
;
1267 if (syn_buf
->b_sst_array
== NULL
|| syn_buf
->b_sst_first
== NULL
)
1270 /* Compute normal distance between non-displayed entries. */
1271 if (syn_buf
->b_sst_len
<= Rows
)
1274 dist
= syn_buf
->b_ml
.ml_line_count
/ (syn_buf
->b_sst_len
- Rows
) + 1;
1277 * Go through the list to find the "tick" for the oldest entry that can
1278 * be removed. Set "above" when the "tick" for the oldest entry is above
1279 * "b_sst_lasttick" (the display tick wraps around).
1281 tick
= syn_buf
->b_sst_lasttick
;
1283 prev
= syn_buf
->b_sst_first
;
1284 for (p
= prev
->sst_next
; p
!= NULL
; prev
= p
, p
= p
->sst_next
)
1286 if (prev
->sst_lnum
+ dist
> p
->sst_lnum
)
1288 if (p
->sst_tick
> syn_buf
->b_sst_lasttick
)
1290 if (!above
|| p
->sst_tick
< tick
)
1294 else if (!above
&& p
->sst_tick
< tick
)
1300 * Go through the list to make the entries for the oldest tick at an
1301 * interval of several lines.
1303 prev
= syn_buf
->b_sst_first
;
1304 for (p
= prev
->sst_next
; p
!= NULL
; prev
= p
, p
= p
->sst_next
)
1306 if (p
->sst_tick
== tick
&& prev
->sst_lnum
+ dist
> p
->sst_lnum
)
1308 /* Move this entry from used list to free list */
1309 prev
->sst_next
= p
->sst_next
;
1310 syn_stack_free_entry(syn_buf
, p
);
1319 * Free the allocated memory for a syn_state item.
1320 * Move the entry into the free list.
1323 syn_stack_free_entry(buf
, p
)
1328 p
->sst_next
= buf
->b_sst_firstfree
;
1329 buf
->b_sst_firstfree
= p
;
1330 ++buf
->b_sst_freecount
;
1334 * Find an entry in the list of state stacks at or before "lnum".
1335 * Returns NULL when there is no entry or the first entry is after "lnum".
1338 syn_stack_find_entry(lnum
)
1341 synstate_T
*p
, *prev
;
1344 for (p
= syn_buf
->b_sst_first
; p
!= NULL
; prev
= p
, p
= p
->sst_next
)
1346 if (p
->sst_lnum
== lnum
)
1348 if (p
->sst_lnum
> lnum
)
1355 * Try saving the current state in b_sst_array[].
1356 * The current state must be valid for the start of the current_lnum line!
1359 store_current_state()
1364 stateitem_T
*cur_si
;
1365 synstate_T
*sp
= syn_stack_find_entry(current_lnum
);
1368 * If the current state contains a start or end pattern that continues
1369 * from the previous line, we can't use it. Don't store it then.
1371 for (i
= current_state
.ga_len
- 1; i
>= 0; --i
)
1373 cur_si
= &CUR_STATE(i
);
1374 if (cur_si
->si_h_startpos
.lnum
>= current_lnum
1375 || cur_si
->si_m_endpos
.lnum
>= current_lnum
1376 || cur_si
->si_h_endpos
.lnum
>= current_lnum
1377 || (cur_si
->si_end_idx
1378 && cur_si
->si_eoe_pos
.lnum
>= current_lnum
))
1385 /* find "sp" in the list and remove it */
1386 if (syn_buf
->b_sst_first
== sp
)
1387 /* it's the first entry */
1388 syn_buf
->b_sst_first
= sp
->sst_next
;
1391 /* find the entry just before this one to adjust sst_next */
1392 for (p
= syn_buf
->b_sst_first
; p
!= NULL
; p
= p
->sst_next
)
1393 if (p
->sst_next
== sp
)
1395 if (p
!= NULL
) /* just in case */
1396 p
->sst_next
= sp
->sst_next
;
1398 syn_stack_free_entry(syn_buf
, sp
);
1402 else if (sp
== NULL
|| sp
->sst_lnum
!= current_lnum
)
1407 /* If no free items, cleanup the array first. */
1408 if (syn_buf
->b_sst_freecount
== 0)
1410 (void)syn_stack_cleanup();
1411 /* "sp" may have been moved to the freelist now */
1412 sp
= syn_stack_find_entry(current_lnum
);
1414 /* Still no free items? Must be a strange problem... */
1415 if (syn_buf
->b_sst_freecount
== 0)
1419 /* Take the first item from the free list and put it in the used
1420 * list, after *sp */
1421 p
= syn_buf
->b_sst_firstfree
;
1422 syn_buf
->b_sst_firstfree
= p
->sst_next
;
1423 --syn_buf
->b_sst_freecount
;
1426 /* Insert in front of the list */
1427 p
->sst_next
= syn_buf
->b_sst_first
;
1428 syn_buf
->b_sst_first
= p
;
1432 /* insert in list after *sp */
1433 p
->sst_next
= sp
->sst_next
;
1437 sp
->sst_stacksize
= 0;
1438 sp
->sst_lnum
= current_lnum
;
1443 /* When overwriting an existing state stack, clear it first */
1444 clear_syn_state(sp
);
1445 sp
->sst_stacksize
= current_state
.ga_len
;
1446 if (current_state
.ga_len
> SST_FIX_STATES
)
1448 /* Need to clear it, might be something remaining from when the
1449 * length was less than SST_FIX_STATES. */
1450 ga_init2(&sp
->sst_union
.sst_ga
, (int)sizeof(bufstate_T
), 1);
1451 if (ga_grow(&sp
->sst_union
.sst_ga
, current_state
.ga_len
) == FAIL
)
1452 sp
->sst_stacksize
= 0;
1454 sp
->sst_union
.sst_ga
.ga_len
= current_state
.ga_len
;
1455 bp
= SYN_STATE_P(&(sp
->sst_union
.sst_ga
));
1458 bp
= sp
->sst_union
.sst_stack
;
1459 for (i
= 0; i
< sp
->sst_stacksize
; ++i
)
1461 bp
[i
].bs_idx
= CUR_STATE(i
).si_idx
;
1462 bp
[i
].bs_flags
= CUR_STATE(i
).si_flags
;
1463 bp
[i
].bs_extmatch
= ref_extmatch(CUR_STATE(i
).si_extmatch
);
1465 sp
->sst_next_flags
= current_next_flags
;
1466 sp
->sst_next_list
= current_next_list
;
1467 sp
->sst_tick
= display_tick
;
1468 sp
->sst_change_lnum
= 0;
1470 current_state_stored
= TRUE
;
1475 * Copy a state stack from "from" in b_sst_array[] to current_state;
1478 load_current_state(from
)
1484 clear_current_state();
1485 validate_current_state();
1487 if (from
->sst_stacksize
1488 && ga_grow(¤t_state
, from
->sst_stacksize
) != FAIL
)
1490 if (from
->sst_stacksize
> SST_FIX_STATES
)
1491 bp
= SYN_STATE_P(&(from
->sst_union
.sst_ga
));
1493 bp
= from
->sst_union
.sst_stack
;
1494 for (i
= 0; i
< from
->sst_stacksize
; ++i
)
1496 CUR_STATE(i
).si_idx
= bp
[i
].bs_idx
;
1497 CUR_STATE(i
).si_flags
= bp
[i
].bs_flags
;
1498 CUR_STATE(i
).si_extmatch
= ref_extmatch(bp
[i
].bs_extmatch
);
1499 if (keepend_level
< 0 && (CUR_STATE(i
).si_flags
& HL_KEEPEND
))
1501 CUR_STATE(i
).si_ends
= FALSE
;
1502 CUR_STATE(i
).si_m_lnum
= 0;
1503 if (CUR_STATE(i
).si_idx
>= 0)
1504 CUR_STATE(i
).si_next_list
=
1505 (SYN_ITEMS(syn_buf
)[CUR_STATE(i
).si_idx
]).sp_next_list
;
1507 CUR_STATE(i
).si_next_list
= NULL
;
1510 current_state
.ga_len
= from
->sst_stacksize
;
1512 current_next_list
= from
->sst_next_list
;
1513 current_next_flags
= from
->sst_next_flags
;
1514 current_lnum
= from
->sst_lnum
;
1518 * Compare saved state stack "*sp" with the current state.
1519 * Return TRUE when they are equal.
1527 reg_extmatch_T
*six
, *bsx
;
1529 /* First a quick check if the stacks have the same size end nextlist. */
1530 if (sp
->sst_stacksize
== current_state
.ga_len
1531 && sp
->sst_next_list
== current_next_list
)
1533 /* Need to compare all states on both stacks. */
1534 if (sp
->sst_stacksize
> SST_FIX_STATES
)
1535 bp
= SYN_STATE_P(&(sp
->sst_union
.sst_ga
));
1537 bp
= sp
->sst_union
.sst_stack
;
1539 for (i
= current_state
.ga_len
; --i
>= 0; )
1541 /* If the item has another index the state is different. */
1542 if (bp
[i
].bs_idx
!= CUR_STATE(i
).si_idx
)
1544 if (bp
[i
].bs_extmatch
!= CUR_STATE(i
).si_extmatch
)
1546 /* When the extmatch pointers are different, the strings in
1547 * them can still be the same. Check if the extmatch
1548 * references are equal. */
1549 bsx
= bp
[i
].bs_extmatch
;
1550 six
= CUR_STATE(i
).si_extmatch
;
1551 /* If one of the extmatch pointers is NULL the states are
1553 if (bsx
== NULL
|| six
== NULL
)
1555 for (j
= 0; j
< NSUBEXP
; ++j
)
1557 /* Check each referenced match string. They must all be
1559 if (bsx
->matches
[j
] != six
->matches
[j
])
1561 /* If the pointer is different it can still be the
1562 * same text. Compare the strings, ignore case when
1563 * the start item has the sp_ic flag set. */
1564 if (bsx
->matches
[j
] == NULL
1565 || six
->matches
[j
] == NULL
)
1567 if ((SYN_ITEMS(syn_buf
)[CUR_STATE(i
).si_idx
]).sp_ic
1568 ? MB_STRICMP(bsx
->matches
[j
],
1569 six
->matches
[j
]) != 0
1570 : STRCMP(bsx
->matches
[j
], six
->matches
[j
]) != 0)
1585 * We stop parsing syntax above line "lnum". If the stored state at or below
1586 * this line depended on a change before it, it now depends on the line below
1587 * the last parsed line.
1588 * The window looks like this:
1589 * line which changed
1592 * lnum -> line below window
1595 syntax_end_parsing(lnum
)
1600 sp
= syn_stack_find_entry(lnum
);
1601 if (sp
!= NULL
&& sp
->sst_lnum
< lnum
)
1604 if (sp
!= NULL
&& sp
->sst_change_lnum
!= 0)
1605 sp
->sst_change_lnum
= lnum
;
1609 * End of handling of the state stack.
1610 ****************************************/
1613 invalidate_current_state()
1615 clear_current_state();
1616 current_state
.ga_itemsize
= 0; /* mark current_state invalid */
1617 current_next_list
= NULL
;
1622 validate_current_state()
1624 current_state
.ga_itemsize
= sizeof(stateitem_T
);
1625 current_state
.ga_growsize
= 3;
1629 * Return TRUE if the syntax at start of lnum changed since last time.
1630 * This will only be called just after get_syntax_attr() for the previous
1631 * line, to check if the next line needs to be redrawn too.
1634 syntax_check_changed(lnum
)
1641 * Check the state stack when:
1642 * - lnum is just below the previously syntaxed line.
1643 * - lnum is not before the lines with saved states.
1644 * - lnum is not past the lines with saved states.
1645 * - lnum is at or before the last changed line.
1647 if (VALID_STATE(¤t_state
) && lnum
== current_lnum
+ 1)
1649 sp
= syn_stack_find_entry(lnum
);
1650 if (sp
!= NULL
&& sp
->sst_lnum
== lnum
)
1653 * finish the previous line (needed when not all of the line was
1656 (void)syn_finish_line(FALSE
);
1659 * Compare the current state with the previously saved state of
1662 if (syn_stack_equal(sp
))
1666 * Store the current state in b_sst_array[] for later use.
1669 (void)store_current_state();
1677 * Finish the current line.
1678 * This doesn't return any attributes, it only gets the state at the end of
1679 * the line. It can start anywhere in the line, as long as the current state
1683 syn_finish_line(syncing
)
1684 int syncing
; /* called for syncing */
1686 stateitem_T
*cur_si
;
1687 colnr_T prev_current_col
;
1689 if (!current_finished
)
1691 while (!current_finished
)
1693 (void)syn_current_attr(syncing
, FALSE
, NULL
, FALSE
);
1695 * When syncing, and found some item, need to check the item.
1697 if (syncing
&& current_state
.ga_len
)
1700 * Check for match with sync item.
1702 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
1703 if (cur_si
->si_idx
>= 0
1704 && (SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_flags
1705 & (HL_SYNC_HERE
|HL_SYNC_THERE
)))
1708 /* syn_current_attr() will have skipped the check for an item
1709 * that ends here, need to do that now. Be careful not to go
1711 prev_current_col
= current_col
;
1712 if (syn_getcurline()[current_col
] != NUL
)
1715 current_col
= prev_current_col
;
1724 * Return highlight attributes for next character.
1725 * Must first call syntax_start() once for the line.
1726 * "col" is normally 0 for the first use in a line, and increments by one each
1727 * time. It's allowed to skip characters and to stop before the end of the
1728 * line. But only a "col" after a previously used column is allowed.
1729 * When "can_spell" is not NULL set it to TRUE when spell-checking should be
1733 get_syntax_attr(col
, can_spell
, keep_state
)
1736 int keep_state
; /* keep state of char at "col" */
1740 if (can_spell
!= NULL
)
1741 /* Default: Only do spelling when there is no @Spell cluster or when
1742 * ":syn spell toplevel" was used. */
1743 *can_spell
= syn_buf
->b_syn_spell
== SYNSPL_DEFAULT
1744 ? (syn_buf
->b_spell_cluster_id
== 0)
1745 : (syn_buf
->b_syn_spell
== SYNSPL_TOP
);
1747 /* check for out of memory situation */
1748 if (syn_buf
->b_sst_array
== NULL
)
1751 /* After 'synmaxcol' the attribute is always zero. */
1752 if (syn_buf
->b_p_smc
> 0 && col
>= (colnr_T
)syn_buf
->b_p_smc
)
1754 clear_current_state();
1757 current_trans_id
= 0;
1762 /* Make sure current_state is valid */
1763 if (INVALID_STATE(¤t_state
))
1764 validate_current_state();
1767 * Skip from the current column to "col", get the attributes for "col".
1769 while (current_col
<= col
)
1771 attr
= syn_current_attr(FALSE
, TRUE
, can_spell
,
1772 current_col
== col
? keep_state
: FALSE
);
1780 * Get syntax attributes for current_lnum, current_col.
1783 syn_current_attr(syncing
, displaying
, can_spell
, keep_state
)
1784 int syncing
; /* When 1: called for syncing */
1785 int displaying
; /* result will be displayed */
1786 int *can_spell
; /* return: do spell checking */
1787 int keep_state
; /* keep syntax stack afterwards */
1790 lpos_T endpos
; /* was: char_u *endp; */
1791 lpos_T hl_startpos
; /* was: int hl_startcol; */
1793 lpos_T eos_pos
; /* end-of-start match (start region) */
1794 lpos_T eoe_pos
; /* end-of-end pattern */
1795 int end_idx
; /* group ID for end pattern */
1798 stateitem_T
*cur_si
, *sip
= NULL
;
1803 int found_match
; /* found usable match */
1804 static int try_next_column
= FALSE
; /* must try in next col */
1806 regmmatch_T regmatch
;
1809 reg_extmatch_T
*cur_extmatch
= NULL
;
1810 char_u
*line
; /* current line. NOTE: becomes invalid after
1811 looking for a pattern match! */
1813 /* variables for zero-width matches that have a "nextgroup" argument */
1815 int zero_width_next_list
= FALSE
;
1816 garray_T zero_width_next_ga
;
1819 * No character, no attributes! Past end of line?
1820 * Do try matching with an empty line (could be the start of a region).
1822 line
= syn_getcurline();
1823 if (line
[current_col
] == NUL
&& current_col
!= 0)
1826 * If we found a match after the last column, use it.
1828 if (next_match_idx
>= 0 && next_match_col
>= (int)current_col
1829 && next_match_col
!= MAXCOL
)
1830 (void)push_next_match(NULL
);
1832 current_finished
= TRUE
;
1833 current_state_stored
= FALSE
;
1837 /* if the current or next character is NUL, we will finish the line now */
1838 if (line
[current_col
] == NUL
|| line
[current_col
+ 1] == NUL
)
1840 current_finished
= TRUE
;
1841 current_state_stored
= FALSE
;
1845 * When in the previous column there was a match but it could not be used
1846 * (empty match or already matched in this column) need to try again in
1849 if (try_next_column
)
1851 next_match_idx
= -1;
1852 try_next_column
= FALSE
;
1855 /* Only check for keywords when not syncing and there are some. */
1856 do_keywords
= !syncing
1857 && (syn_buf
->b_keywtab
.ht_used
> 0
1858 || syn_buf
->b_keywtab_ic
.ht_used
> 0);
1860 /* Init the list of zero-width matches with a nextlist. This is used to
1861 * avoid matching the same item in the same position twice. */
1862 ga_init2(&zero_width_next_ga
, (int)sizeof(int), 10);
1865 * Repeat matching keywords and patterns, to find contained items at the
1866 * same column. This stops when there are no extra matches at the current
1871 found_match
= FALSE
;
1872 keep_next_list
= FALSE
;
1876 * 1. Check for a current state.
1877 * Only when there is no current state, or if the current state may
1878 * contain other things, we need to check for keywords and patterns.
1879 * Always need to check for contained items if some item has the
1880 * "containedin" argument (takes extra time!).
1882 if (current_state
.ga_len
)
1883 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
1887 if (syn_buf
->b_syn_containedin
|| cur_si
== NULL
1888 || cur_si
->si_cont_list
!= NULL
)
1891 * 2. Check for keywords, if on a keyword char after a non-keyword
1892 * char. Don't do this when syncing.
1896 line
= syn_getcurline();
1897 if (vim_iswordc_buf(line
+ current_col
, syn_buf
)
1898 && (current_col
== 0
1899 || !vim_iswordc_buf(line
+ current_col
- 1
1902 ? (*mb_head_off
)(line
, line
+ current_col
- 1)
1907 syn_id
= check_keyword_id(line
, (int)current_col
,
1908 &endcol
, &flags
, &next_list
, cur_si
);
1911 if (push_current_state(KEYWORD_IDX
) == OK
)
1913 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
1914 cur_si
->si_m_startcol
= current_col
;
1915 cur_si
->si_h_startpos
.lnum
= current_lnum
;
1916 cur_si
->si_h_startpos
.col
= 0; /* starts right away */
1917 cur_si
->si_m_endpos
.lnum
= current_lnum
;
1918 cur_si
->si_m_endpos
.col
= endcol
;
1919 cur_si
->si_h_endpos
.lnum
= current_lnum
;
1920 cur_si
->si_h_endpos
.col
= endcol
;
1921 cur_si
->si_ends
= TRUE
;
1922 cur_si
->si_end_idx
= 0;
1923 cur_si
->si_flags
= flags
;
1924 cur_si
->si_id
= syn_id
;
1925 cur_si
->si_trans_id
= syn_id
;
1926 if (flags
& HL_TRANSP
)
1928 if (current_state
.ga_len
< 2)
1930 cur_si
->si_attr
= 0;
1931 cur_si
->si_trans_id
= 0;
1935 cur_si
->si_attr
= CUR_STATE(
1936 current_state
.ga_len
- 2).si_attr
;
1937 cur_si
->si_trans_id
= CUR_STATE(
1938 current_state
.ga_len
- 2).si_trans_id
;
1942 cur_si
->si_attr
= syn_id2attr(syn_id
);
1943 cur_si
->si_cont_list
= NULL
;
1944 cur_si
->si_next_list
= next_list
;
1948 vim_free(next_list
);
1954 * 3. Check for patterns (only if no keyword found).
1956 if (syn_id
== 0 && syn_buf
->b_syn_patterns
.ga_len
)
1959 * If we didn't check for a match yet, or we are past it, check
1960 * for any match with a pattern.
1962 if (next_match_idx
< 0 || next_match_col
< (int)current_col
)
1965 * Check all relevant patterns for a match at this
1966 * position. This is complicated, because matching with a
1967 * pattern takes quite a bit of time, thus we want to
1968 * avoid doing it when it's not needed.
1970 next_match_idx
= 0; /* no match in this line yet */
1971 next_match_col
= MAXCOL
;
1972 for (idx
= syn_buf
->b_syn_patterns
.ga_len
; --idx
>= 0; )
1974 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
1975 if ( spp
->sp_syncing
== syncing
1976 && (displaying
|| !(spp
->sp_flags
& HL_DISPLAY
))
1977 && (spp
->sp_type
== SPTYPE_MATCH
1978 || spp
->sp_type
== SPTYPE_START
)
1979 && (current_next_list
!= NULL
1980 ? in_id_list(NULL
, current_next_list
,
1983 ? !(spp
->sp_flags
& HL_CONTAINED
)
1984 : in_id_list(cur_si
,
1985 cur_si
->si_cont_list
, &spp
->sp_syn
,
1986 spp
->sp_flags
& HL_CONTAINED
))))
1988 /* If we already tried matching in this line, and
1989 * there isn't a match before next_match_col, skip
1991 if (spp
->sp_line_id
== current_line_id
1992 && spp
->sp_startcol
>= next_match_col
)
1994 spp
->sp_line_id
= current_line_id
;
1996 lc_col
= current_col
- spp
->sp_offsets
[SPO_LC_OFF
];
2000 regmatch
.rmm_ic
= spp
->sp_ic
;
2001 regmatch
.regprog
= spp
->sp_prog
;
2002 if (!syn_regexec(®match
, current_lnum
,
2005 /* no match in this line, try another one */
2006 spp
->sp_startcol
= MAXCOL
;
2011 * Compute the first column of the match.
2013 syn_add_start_off(&pos
, ®match
,
2014 spp
, SPO_MS_OFF
, -1);
2015 if (pos
.lnum
> current_lnum
)
2017 /* must have used end of match in a next line,
2018 * we can't handle that */
2019 spp
->sp_startcol
= MAXCOL
;
2024 /* remember the next column where this pattern
2025 * matches in the current line */
2026 spp
->sp_startcol
= startcol
;
2029 * If a previously found match starts at a lower
2030 * column number, don't use this one.
2032 if (startcol
>= next_match_col
)
2036 * If we matched this pattern at this position
2037 * before, skip it. Must retry in the next
2038 * column, because it may match from there.
2040 if (did_match_already(idx
, &zero_width_next_ga
))
2042 try_next_column
= TRUE
;
2046 endpos
.lnum
= regmatch
.endpos
[0].lnum
;
2047 endpos
.col
= regmatch
.endpos
[0].col
;
2049 /* Compute the highlight start. */
2050 syn_add_start_off(&hl_startpos
, ®match
,
2051 spp
, SPO_HS_OFF
, -1);
2053 /* Compute the region start. */
2054 /* Default is to use the end of the match. */
2055 syn_add_end_off(&eos_pos
, ®match
,
2056 spp
, SPO_RS_OFF
, 0);
2059 * Grab the external submatches before they get
2060 * overwritten. Reference count doesn't change.
2062 unref_extmatch(cur_extmatch
);
2063 cur_extmatch
= re_extmatch_out
;
2064 re_extmatch_out
= NULL
;
2067 eoe_pos
.lnum
= 0; /* avoid warning */
2073 * For a "oneline" the end must be found in the
2074 * same line too. Search for it after the end of
2075 * the match with the start pattern. Set the
2076 * resulting end positions at the same time.
2078 if (spp
->sp_type
== SPTYPE_START
2079 && (spp
->sp_flags
& HL_ONELINE
))
2084 find_endpos(idx
, &startpos
, &endpos
, &hl_endpos
,
2085 &flags
, &eoe_pos
, &end_idx
, cur_extmatch
);
2086 if (endpos
.lnum
== 0)
2087 continue; /* not found */
2091 * For a "match" the size must be > 0 after the
2092 * end offset needs has been added. Except when
2095 else if (spp
->sp_type
== SPTYPE_MATCH
)
2097 syn_add_end_off(&hl_endpos
, ®match
, spp
,
2099 syn_add_end_off(&endpos
, ®match
, spp
,
2101 if (endpos
.lnum
== current_lnum
2102 && (int)endpos
.col
+ syncing
< startcol
)
2105 * If an empty string is matched, may need
2106 * to try matching again at next column.
2108 if (regmatch
.startpos
[0].col
2109 == regmatch
.endpos
[0].col
)
2110 try_next_column
= TRUE
;
2116 * keep the best match so far in next_match_*
2118 /* Highlighting must start after startpos and end
2120 if (hl_startpos
.lnum
== current_lnum
2121 && (int)hl_startpos
.col
< startcol
)
2122 hl_startpos
.col
= startcol
;
2123 limit_pos_zero(&hl_endpos
, &endpos
);
2125 next_match_idx
= idx
;
2126 next_match_col
= startcol
;
2127 next_match_m_endpos
= endpos
;
2128 next_match_h_endpos
= hl_endpos
;
2129 next_match_h_startpos
= hl_startpos
;
2130 next_match_flags
= flags
;
2131 next_match_eos_pos
= eos_pos
;
2132 next_match_eoe_pos
= eoe_pos
;
2133 next_match_end_idx
= end_idx
;
2134 unref_extmatch(next_match_extmatch
);
2135 next_match_extmatch
= cur_extmatch
;
2136 cur_extmatch
= NULL
;
2142 * If we found a match at the current column, use it.
2144 if (next_match_idx
>= 0 && next_match_col
== (int)current_col
)
2148 /* When a zero-width item matched which has a nextgroup,
2149 * don't push the item but set nextgroup. */
2150 lspp
= &(SYN_ITEMS(syn_buf
)[next_match_idx
]);
2151 if (next_match_m_endpos
.lnum
== current_lnum
2152 && next_match_m_endpos
.col
== current_col
2153 && lspp
->sp_next_list
!= NULL
)
2155 current_next_list
= lspp
->sp_next_list
;
2156 current_next_flags
= lspp
->sp_flags
;
2157 keep_next_list
= TRUE
;
2158 zero_width_next_list
= TRUE
;
2160 /* Add the index to a list, so that we can check
2161 * later that we don't match it again (and cause an
2163 if (ga_grow(&zero_width_next_ga
, 1) == OK
)
2165 ((int *)(zero_width_next_ga
.ga_data
))
2166 [zero_width_next_ga
.ga_len
++] = next_match_idx
;
2168 next_match_idx
= -1;
2171 cur_si
= push_next_match(cur_si
);
2178 * Handle searching for nextgroup match.
2180 if (current_next_list
!= NULL
&& !keep_next_list
)
2183 * If a nextgroup was not found, continue looking for one if:
2184 * - this is an empty line and the "skipempty" option was given
2185 * - we are on white space and the "skipwhite" option was given
2189 line
= syn_getcurline();
2190 if (((current_next_flags
& HL_SKIPWHITE
)
2191 && vim_iswhite(line
[current_col
]))
2192 || ((current_next_flags
& HL_SKIPEMPTY
)
2198 * If a nextgroup was found: Use it, and continue looking for
2199 * contained matches.
2200 * If a nextgroup was not found: Continue looking for a normal
2202 * When did set current_next_list for a zero-width item and no
2203 * match was found don't loop (would get stuck).
2205 current_next_list
= NULL
;
2206 next_match_idx
= -1;
2207 if (!zero_width_next_list
)
2211 } while (found_match
);
2214 * Use attributes from the current state, if within its highlighting.
2215 * If not, use attributes from the current-but-one state, etc.
2220 current_trans_id
= 0;
2225 int current_trans_id
= 0;
2227 for (idx
= current_state
.ga_len
- 1; idx
>= 0; --idx
)
2229 sip
= &CUR_STATE(idx
);
2230 if ((current_lnum
> sip
->si_h_startpos
.lnum
2231 || (current_lnum
== sip
->si_h_startpos
.lnum
2232 && current_col
>= sip
->si_h_startpos
.col
))
2233 && (sip
->si_h_endpos
.lnum
== 0
2234 || current_lnum
< sip
->si_h_endpos
.lnum
2235 || (current_lnum
== sip
->si_h_endpos
.lnum
2236 && current_col
< sip
->si_h_endpos
.col
)))
2238 current_attr
= sip
->si_attr
;
2240 current_id
= sip
->si_id
;
2242 current_trans_id
= sip
->si_trans_id
;
2247 if (can_spell
!= NULL
)
2252 * set "can_spell" to TRUE if spell checking is supposed to be
2253 * done in the current item.
2255 if (syn_buf
->b_spell_cluster_id
== 0)
2257 /* There is no @Spell cluster: Do spelling for items without
2258 * @NoSpell cluster. */
2259 if (syn_buf
->b_nospell_cluster_id
== 0 || current_trans_id
== 0)
2260 *can_spell
= (syn_buf
->b_syn_spell
!= SYNSPL_NOTOP
);
2264 sps
.id
= syn_buf
->b_nospell_cluster_id
;
2265 sps
.cont_in_list
= NULL
;
2266 *can_spell
= !in_id_list(sip
, sip
->si_cont_list
, &sps
, 0);
2271 /* The @Spell cluster is defined: Do spelling in items with
2272 * the @Spell cluster. But not when @NoSpell is also there.
2273 * At the toplevel only spell check when ":syn spell toplevel"
2275 if (current_trans_id
== 0)
2276 *can_spell
= (syn_buf
->b_syn_spell
== SYNSPL_TOP
);
2280 sps
.id
= syn_buf
->b_spell_cluster_id
;
2281 sps
.cont_in_list
= NULL
;
2282 *can_spell
= in_id_list(sip
, sip
->si_cont_list
, &sps
, 0);
2284 if (syn_buf
->b_nospell_cluster_id
!= 0)
2286 sps
.id
= syn_buf
->b_nospell_cluster_id
;
2287 if (in_id_list(sip
, sip
->si_cont_list
, &sps
, 0))
2296 * Check for end of current state (and the states before it) at the
2297 * next column. Don't do this for syncing, because we would miss a
2298 * single character match.
2299 * First check if the current state ends at the current column. It
2300 * may be for an empty match and a containing item might end in the
2303 if (!syncing
&& !keep_state
)
2306 if (current_state
.ga_len
> 0
2307 && syn_getcurline()[current_col
] != NUL
)
2315 else if (can_spell
!= NULL
)
2316 /* Default: Only do spelling when there is no @Spell cluster or when
2317 * ":syn spell toplevel" was used. */
2318 *can_spell
= syn_buf
->b_syn_spell
== SYNSPL_DEFAULT
2319 ? (syn_buf
->b_spell_cluster_id
== 0)
2320 : (syn_buf
->b_syn_spell
== SYNSPL_TOP
);
2322 /* nextgroup ends at end of line, unless "skipnl" or "skipempty" present */
2323 if (current_next_list
!= NULL
2324 && syn_getcurline()[current_col
+ 1] == NUL
2325 && !(current_next_flags
& (HL_SKIPNL
| HL_SKIPEMPTY
)))
2326 current_next_list
= NULL
;
2328 if (zero_width_next_ga
.ga_len
> 0)
2329 ga_clear(&zero_width_next_ga
);
2331 /* No longer need external matches. But keep next_match_extmatch. */
2332 unref_extmatch(re_extmatch_out
);
2333 re_extmatch_out
= NULL
;
2334 unref_extmatch(cur_extmatch
);
2336 return current_attr
;
2341 * Check if we already matched pattern "idx" at the current column.
2344 did_match_already(idx
, gap
)
2350 for (i
= current_state
.ga_len
; --i
>= 0; )
2351 if (CUR_STATE(i
).si_m_startcol
== (int)current_col
2352 && CUR_STATE(i
).si_m_lnum
== (int)current_lnum
2353 && CUR_STATE(i
).si_idx
== idx
)
2356 /* Zero-width matches with a nextgroup argument are not put on the syntax
2357 * stack, and can only be matched once anyway. */
2358 for (i
= gap
->ga_len
; --i
>= 0; )
2359 if (((int *)(gap
->ga_data
))[i
] == idx
)
2366 * Push the next match onto the stack.
2368 static stateitem_T
*
2369 push_next_match(cur_si
)
2370 stateitem_T
*cur_si
;
2374 spp
= &(SYN_ITEMS(syn_buf
)[next_match_idx
]);
2377 * Push the item in current_state stack;
2379 if (push_current_state(next_match_idx
) == OK
)
2382 * If it's a start-skip-end type that crosses lines, figure out how
2383 * much it continues in this line. Otherwise just fill in the length.
2385 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2386 cur_si
->si_h_startpos
= next_match_h_startpos
;
2387 cur_si
->si_m_startcol
= current_col
;
2388 cur_si
->si_m_lnum
= current_lnum
;
2389 cur_si
->si_flags
= spp
->sp_flags
;
2390 cur_si
->si_next_list
= spp
->sp_next_list
;
2391 cur_si
->si_extmatch
= ref_extmatch(next_match_extmatch
);
2392 if (spp
->sp_type
== SPTYPE_START
&& !(spp
->sp_flags
& HL_ONELINE
))
2394 /* Try to find the end pattern in the current line */
2395 update_si_end(cur_si
, (int)(next_match_m_endpos
.col
), TRUE
);
2400 cur_si
->si_m_endpos
= next_match_m_endpos
;
2401 cur_si
->si_h_endpos
= next_match_h_endpos
;
2402 cur_si
->si_ends
= TRUE
;
2403 cur_si
->si_flags
|= next_match_flags
;
2404 cur_si
->si_eoe_pos
= next_match_eoe_pos
;
2405 cur_si
->si_end_idx
= next_match_end_idx
;
2407 if (keepend_level
< 0 && (cur_si
->si_flags
& HL_KEEPEND
))
2408 keepend_level
= current_state
.ga_len
- 1;
2410 update_si_attr(current_state
.ga_len
- 1);
2413 * If the start pattern has another highlight group, push another item
2414 * on the stack for the start pattern.
2416 if ( spp
->sp_type
== SPTYPE_START
2417 && spp
->sp_syn_match_id
!= 0
2418 && push_current_state(next_match_idx
) == OK
)
2420 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2421 cur_si
->si_h_startpos
= next_match_h_startpos
;
2422 cur_si
->si_m_startcol
= current_col
;
2423 cur_si
->si_m_lnum
= current_lnum
;
2424 cur_si
->si_m_endpos
= next_match_eos_pos
;
2425 cur_si
->si_h_endpos
= next_match_eos_pos
;
2426 cur_si
->si_ends
= TRUE
;
2427 cur_si
->si_end_idx
= 0;
2428 cur_si
->si_flags
= HL_MATCH
;
2429 cur_si
->si_next_list
= NULL
;
2431 update_si_attr(current_state
.ga_len
- 1);
2435 next_match_idx
= -1; /* try other match next time */
2441 * Check for end of current state (and the states before it).
2446 stateitem_T
*cur_si
;
2447 int had_extend
= FALSE
;
2449 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2453 && (cur_si
->si_m_endpos
.lnum
< current_lnum
2454 || (cur_si
->si_m_endpos
.lnum
== current_lnum
2455 && cur_si
->si_m_endpos
.col
<= current_col
)))
2458 * If there is an end pattern group ID, highlight the end pattern
2459 * now. No need to pop the current item from the stack.
2460 * Only do this if the end pattern continues beyond the current
2463 if (cur_si
->si_end_idx
2464 && (cur_si
->si_eoe_pos
.lnum
> current_lnum
2465 || (cur_si
->si_eoe_pos
.lnum
== current_lnum
2466 && cur_si
->si_eoe_pos
.col
> current_col
)))
2468 cur_si
->si_idx
= cur_si
->si_end_idx
;
2469 cur_si
->si_end_idx
= 0;
2470 cur_si
->si_m_endpos
= cur_si
->si_eoe_pos
;
2471 cur_si
->si_h_endpos
= cur_si
->si_eoe_pos
;
2472 cur_si
->si_flags
|= HL_MATCH
;
2473 update_si_attr(current_state
.ga_len
- 1);
2475 /* what matches next may be different now, clear it */
2477 next_match_col
= MAXCOL
;
2482 /* handle next_list, unless at end of line and no "skipnl" or
2484 current_next_list
= cur_si
->si_next_list
;
2485 current_next_flags
= cur_si
->si_flags
;
2486 if (!(current_next_flags
& (HL_SKIPNL
| HL_SKIPEMPTY
))
2487 && syn_getcurline()[current_col
] == NUL
)
2488 current_next_list
= NULL
;
2490 /* When the ended item has "extend", another item with
2491 * "keepend" now needs to check for its end. */
2492 if (cur_si
->si_flags
& HL_EXTEND
)
2495 pop_current_state();
2497 if (current_state
.ga_len
== 0)
2500 if (had_extend
&& keepend_level
>= 0)
2502 syn_update_ends(FALSE
);
2503 if (current_state
.ga_len
== 0)
2507 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2510 * Only for a region the search for the end continues after
2511 * the end of the contained item. If the contained match
2512 * included the end-of-line, break here, the region continues.
2513 * Don't do this when:
2514 * - "keepend" is used for the contained item
2515 * - not at the end of the line (could be end="x$"me=e-1).
2516 * - "excludenl" is used (HL_HAS_EOL won't be set)
2518 if (cur_si
->si_idx
>= 0
2519 && SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_type
2521 && !(cur_si
->si_flags
& (HL_MATCH
| HL_KEEPEND
)))
2523 update_si_end(cur_si
, (int)current_col
, TRUE
);
2525 if ((current_next_flags
& HL_HAS_EOL
)
2526 && keepend_level
< 0
2527 && syn_getcurline()[current_col
] == NUL
)
2538 * Update an entry in the current_state stack for a match or region. This
2539 * fills in si_attr, si_next_list and si_cont_list.
2545 stateitem_T
*sip
= &CUR_STATE(idx
);
2548 /* This should not happen... */
2549 if (sip
->si_idx
< 0)
2552 spp
= &(SYN_ITEMS(syn_buf
)[sip
->si_idx
]);
2553 if (sip
->si_flags
& HL_MATCH
)
2554 sip
->si_id
= spp
->sp_syn_match_id
;
2556 sip
->si_id
= spp
->sp_syn
.id
;
2557 sip
->si_attr
= syn_id2attr(sip
->si_id
);
2558 sip
->si_trans_id
= sip
->si_id
;
2559 if (sip
->si_flags
& HL_MATCH
)
2560 sip
->si_cont_list
= NULL
;
2562 sip
->si_cont_list
= spp
->sp_cont_list
;
2565 * For transparent items, take attr from outer item.
2566 * Also take cont_list, if there is none.
2567 * Don't do this for the matchgroup of a start or end pattern.
2569 if ((spp
->sp_flags
& HL_TRANSP
) && !(sip
->si_flags
& HL_MATCH
))
2574 sip
->si_trans_id
= 0;
2575 if (sip
->si_cont_list
== NULL
)
2576 sip
->si_cont_list
= ID_LIST_ALL
;
2580 sip
->si_attr
= CUR_STATE(idx
- 1).si_attr
;
2581 sip
->si_trans_id
= CUR_STATE(idx
- 1).si_trans_id
;
2582 sip
->si_h_startpos
= CUR_STATE(idx
- 1).si_h_startpos
;
2583 sip
->si_h_endpos
= CUR_STATE(idx
- 1).si_h_endpos
;
2584 if (sip
->si_cont_list
== NULL
)
2586 sip
->si_flags
|= HL_TRANS_CONT
;
2587 sip
->si_cont_list
= CUR_STATE(idx
- 1).si_cont_list
;
2594 * Check the current stack for patterns with "keepend" flag.
2595 * Propagate the match-end to contained items, until a "skipend" item is found.
2606 * This check can consume a lot of time; only do it from the level where
2607 * there really is a keepend.
2609 if (keepend_level
< 0)
2613 * Find the last index of an "extend" item. "keepend" items before that
2614 * won't do anything. If there is no "extend" item "i" will be
2615 * "keepend_level" and all "keepend" items will work normally.
2617 for (i
= current_state
.ga_len
- 1; i
> keepend_level
; --i
)
2618 if (CUR_STATE(i
).si_flags
& HL_EXTEND
)
2625 for ( ; i
< current_state
.ga_len
; ++i
)
2627 sip
= &CUR_STATE(i
);
2628 if (maxpos
.lnum
!= 0)
2630 limit_pos_zero(&sip
->si_m_endpos
, &maxpos
);
2631 limit_pos_zero(&sip
->si_h_endpos
, &maxpos_h
);
2632 limit_pos_zero(&sip
->si_eoe_pos
, &maxpos
);
2633 sip
->si_ends
= TRUE
;
2635 if (sip
->si_ends
&& (sip
->si_flags
& HL_KEEPEND
))
2637 if (maxpos
.lnum
== 0
2638 || maxpos
.lnum
> sip
->si_m_endpos
.lnum
2639 || (maxpos
.lnum
== sip
->si_m_endpos
.lnum
2640 && maxpos
.col
> sip
->si_m_endpos
.col
))
2641 maxpos
= sip
->si_m_endpos
;
2642 if (maxpos_h
.lnum
== 0
2643 || maxpos_h
.lnum
> sip
->si_h_endpos
.lnum
2644 || (maxpos_h
.lnum
== sip
->si_h_endpos
.lnum
2645 && maxpos_h
.col
> sip
->si_h_endpos
.col
))
2646 maxpos_h
= sip
->si_h_endpos
;
2652 * Update an entry in the current_state stack for a start-skip-end pattern.
2653 * This finds the end of the current item, if it's in the current line.
2655 * Return the flags for the matched END.
2658 update_si_end(sip
, startcol
, force
)
2660 int startcol
; /* where to start searching for the end */
2661 int force
; /* when TRUE overrule a previous end */
2669 /* return quickly for a keyword */
2670 if (sip
->si_idx
< 0)
2673 /* Don't update when it's already done. Can be a match of an end pattern
2674 * that started in a previous line. Watch out: can also be a "keepend"
2675 * from a containing item. */
2676 if (!force
&& sip
->si_m_endpos
.lnum
>= current_lnum
)
2680 * We need to find the end of the region. It may continue in the next
2684 startpos
.lnum
= current_lnum
;
2685 startpos
.col
= startcol
;
2686 find_endpos(sip
->si_idx
, &startpos
, &endpos
, &hl_endpos
,
2687 &(sip
->si_flags
), &end_endpos
, &end_idx
, sip
->si_extmatch
);
2689 if (endpos
.lnum
== 0)
2691 /* No end pattern matched. */
2692 if (SYN_ITEMS(syn_buf
)[sip
->si_idx
].sp_flags
& HL_ONELINE
)
2694 /* a "oneline" never continues in the next line */
2695 sip
->si_ends
= TRUE
;
2696 sip
->si_m_endpos
.lnum
= current_lnum
;
2697 sip
->si_m_endpos
.col
= (colnr_T
)STRLEN(syn_getcurline());
2701 /* continues in the next line */
2702 sip
->si_ends
= FALSE
;
2703 sip
->si_m_endpos
.lnum
= 0;
2705 sip
->si_h_endpos
= sip
->si_m_endpos
;
2709 /* match within this line */
2710 sip
->si_m_endpos
= endpos
;
2711 sip
->si_h_endpos
= hl_endpos
;
2712 sip
->si_eoe_pos
= end_endpos
;
2713 sip
->si_ends
= TRUE
;
2714 sip
->si_end_idx
= end_idx
;
2719 * Add a new state to the current state stack.
2720 * It is cleared and the index set to "idx".
2721 * Return FAIL if it's not possible (out of memory).
2724 push_current_state(idx
)
2727 if (ga_grow(¤t_state
, 1) == FAIL
)
2729 vim_memset(&CUR_STATE(current_state
.ga_len
), 0, sizeof(stateitem_T
));
2730 CUR_STATE(current_state
.ga_len
).si_idx
= idx
;
2731 ++current_state
.ga_len
;
2736 * Remove a state from the current_state stack.
2741 if (current_state
.ga_len
)
2743 unref_extmatch(CUR_STATE(current_state
.ga_len
- 1).si_extmatch
);
2744 --current_state
.ga_len
;
2746 /* after the end of a pattern, try matching a keyword or pattern */
2747 next_match_idx
= -1;
2749 /* if first state with "keepend" is popped, reset keepend_level */
2750 if (keepend_level
>= current_state
.ga_len
)
2755 * Find the end of a start/skip/end syntax region after "startpos".
2756 * Only checks one line.
2757 * Also handles a match item that continued from a previous line.
2758 * If not found, the syntax item continues in the next line. m_endpos->lnum
2760 * If found, the end of the region and the end of the highlighting is
2764 find_endpos(idx
, startpos
, m_endpos
, hl_endpos
, flagsp
, end_endpos
,
2766 int idx
; /* index of the pattern */
2767 lpos_T
*startpos
; /* where to start looking for an END match */
2768 lpos_T
*m_endpos
; /* return: end of match */
2769 lpos_T
*hl_endpos
; /* return: end of highlighting */
2770 long *flagsp
; /* return: flags of matching END */
2771 lpos_T
*end_endpos
; /* return: end of end pattern match */
2772 int *end_idx
; /* return: group ID for end pat. match, or 0 */
2773 reg_extmatch_T
*start_ext
; /* submatches from the start pattern */
2776 synpat_T
*spp
, *spp_skip
;
2779 regmmatch_T regmatch
;
2780 regmmatch_T best_regmatch
; /* startpos/endpos of best match */
2783 int had_match
= FALSE
;
2785 /* just in case we are invoked for a keyword */
2790 * Check for being called with a START pattern.
2791 * Can happen with a match that continues to the next line, because it
2792 * contained a region.
2794 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
2795 if (spp
->sp_type
!= SPTYPE_START
)
2797 *hl_endpos
= *startpos
;
2802 * Find the SKIP or first END pattern after the last START pattern.
2806 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
2807 if (spp
->sp_type
!= SPTYPE_START
)
2813 * Lookup the SKIP pattern (if present)
2815 if (spp
->sp_type
== SPTYPE_SKIP
)
2823 /* Setup external matches for syn_regexec(). */
2824 unref_extmatch(re_extmatch_in
);
2825 re_extmatch_in
= ref_extmatch(start_ext
);
2827 matchcol
= startpos
->col
; /* start looking for a match at sstart */
2828 start_idx
= idx
; /* remember the first END pattern. */
2829 best_regmatch
.startpos
[0].col
= 0; /* avoid compiler warning */
2833 * Find end pattern that matches first after "matchcol".
2836 for (idx
= start_idx
; idx
< syn_buf
->b_syn_patterns
.ga_len
; ++idx
)
2838 int lc_col
= matchcol
;
2840 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
2841 if (spp
->sp_type
!= SPTYPE_END
) /* past last END pattern */
2843 lc_col
-= spp
->sp_offsets
[SPO_LC_OFF
];
2847 regmatch
.rmm_ic
= spp
->sp_ic
;
2848 regmatch
.regprog
= spp
->sp_prog
;
2849 if (syn_regexec(®match
, startpos
->lnum
, lc_col
))
2851 if (best_idx
== -1 || regmatch
.startpos
[0].col
2852 < best_regmatch
.startpos
[0].col
)
2855 best_regmatch
.startpos
[0] = regmatch
.startpos
[0];
2856 best_regmatch
.endpos
[0] = regmatch
.endpos
[0];
2862 * If all end patterns have been tried, and there is no match, the
2863 * item continues until end-of-line.
2869 * If the skip pattern matches before the end pattern,
2870 * continue searching after the skip pattern.
2872 if (spp_skip
!= NULL
)
2874 int lc_col
= matchcol
- spp_skip
->sp_offsets
[SPO_LC_OFF
];
2878 regmatch
.rmm_ic
= spp_skip
->sp_ic
;
2879 regmatch
.regprog
= spp_skip
->sp_prog
;
2880 if (syn_regexec(®match
, startpos
->lnum
, lc_col
)
2881 && regmatch
.startpos
[0].col
2882 <= best_regmatch
.startpos
[0].col
)
2884 /* Add offset to skip pattern match */
2885 syn_add_end_off(&pos
, ®match
, spp_skip
, SPO_ME_OFF
, 1);
2887 /* If the skip pattern goes on to the next line, there is no
2888 * match with an end pattern in this line. */
2889 if (pos
.lnum
> startpos
->lnum
)
2892 line
= ml_get_buf(syn_buf
, startpos
->lnum
, FALSE
);
2894 /* take care of an empty match or negative offset */
2895 if (pos
.col
<= matchcol
)
2897 else if (pos
.col
<= regmatch
.endpos
[0].col
)
2900 /* Be careful not to jump over the NUL at the end-of-line */
2901 for (matchcol
= regmatch
.endpos
[0].col
;
2902 line
[matchcol
] != NUL
&& matchcol
< pos
.col
;
2906 /* if the skip pattern includes end-of-line, break here */
2907 if (line
[matchcol
] == NUL
)
2910 continue; /* start with first end pattern again */
2915 * Match from start pattern to end pattern.
2916 * Correct for match and highlight offset of end pattern.
2918 spp
= &(SYN_ITEMS(syn_buf
)[best_idx
]);
2919 syn_add_end_off(m_endpos
, &best_regmatch
, spp
, SPO_ME_OFF
, 1);
2920 /* can't end before the start */
2921 if (m_endpos
->lnum
== startpos
->lnum
&& m_endpos
->col
< startpos
->col
)
2922 m_endpos
->col
= startpos
->col
;
2924 syn_add_end_off(end_endpos
, &best_regmatch
, spp
, SPO_HE_OFF
, 1);
2925 /* can't end before the start */
2926 if (end_endpos
->lnum
== startpos
->lnum
2927 && end_endpos
->col
< startpos
->col
)
2928 end_endpos
->col
= startpos
->col
;
2929 /* can't end after the match */
2930 limit_pos(end_endpos
, m_endpos
);
2933 * If the end group is highlighted differently, adjust the pointers.
2935 if (spp
->sp_syn_match_id
!= spp
->sp_syn
.id
&& spp
->sp_syn_match_id
!= 0)
2937 *end_idx
= best_idx
;
2938 if (spp
->sp_off_flags
& (1 << (SPO_RE_OFF
+ SPO_COUNT
)))
2940 hl_endpos
->lnum
= best_regmatch
.endpos
[0].lnum
;
2941 hl_endpos
->col
= best_regmatch
.endpos
[0].col
;
2945 hl_endpos
->lnum
= best_regmatch
.startpos
[0].lnum
;
2946 hl_endpos
->col
= best_regmatch
.startpos
[0].col
;
2948 hl_endpos
->col
+= spp
->sp_offsets
[SPO_RE_OFF
];
2950 /* can't end before the start */
2951 if (hl_endpos
->lnum
== startpos
->lnum
2952 && hl_endpos
->col
< startpos
->col
)
2953 hl_endpos
->col
= startpos
->col
;
2954 limit_pos(hl_endpos
, m_endpos
);
2956 /* now the match ends where the highlighting ends, it is turned
2957 * into the matchgroup for the end */
2958 *m_endpos
= *hl_endpos
;
2963 *hl_endpos
= *end_endpos
;
2966 *flagsp
= spp
->sp_flags
;
2972 /* no match for an END pattern in this line */
2976 /* Remove external matches. */
2977 unref_extmatch(re_extmatch_in
);
2978 re_extmatch_in
= NULL
;
2982 * Limit "pos" not to be after "limit".
2985 limit_pos(pos
, limit
)
2989 if (pos
->lnum
> limit
->lnum
)
2991 else if (pos
->lnum
== limit
->lnum
&& pos
->col
> limit
->col
)
2992 pos
->col
= limit
->col
;
2996 * Limit "pos" not to be after "limit", unless pos->lnum is zero.
2999 limit_pos_zero(pos
, limit
)
3006 limit_pos(pos
, limit
);
3010 * Add offset to matched text for end of match or highlight.
3013 syn_add_end_off(result
, regmatch
, spp
, idx
, extra
)
3014 lpos_T
*result
; /* returned position */
3015 regmmatch_T
*regmatch
; /* start/end of match */
3016 synpat_T
*spp
; /* matched pattern */
3017 int idx
; /* index of offset */
3018 int extra
; /* extra chars for offset to start */
3025 if (spp
->sp_off_flags
& (1 << idx
))
3027 result
->lnum
= regmatch
->startpos
[0].lnum
;
3028 col
= regmatch
->startpos
[0].col
;
3029 off
= spp
->sp_offsets
[idx
] + extra
;
3033 result
->lnum
= regmatch
->endpos
[0].lnum
;
3034 col
= regmatch
->endpos
[0].col
;
3035 off
= spp
->sp_offsets
[idx
];
3037 /* Don't go past the end of the line. Matters for "rs=e+2" when there
3038 * is a matchgroup. Watch out for match with last NL in the buffer. */
3039 if (result
->lnum
> syn_buf
->b_ml
.ml_line_count
)
3043 base
= ml_get_buf(syn_buf
, result
->lnum
, FALSE
);
3047 while (off
-- > 0 && *p
!= NUL
)
3052 while (off
++ < 0 && base
< p
)
3053 mb_ptr_back(base
, p
);
3055 col
= (int)(p
- base
);
3061 * Add offset to matched text for start of match or highlight.
3062 * Avoid resulting column to become negative.
3065 syn_add_start_off(result
, regmatch
, spp
, idx
, extra
)
3066 lpos_T
*result
; /* returned position */
3067 regmmatch_T
*regmatch
; /* start/end of match */
3070 int extra
; /* extra chars for offset to end */
3077 if (spp
->sp_off_flags
& (1 << (idx
+ SPO_COUNT
)))
3079 result
->lnum
= regmatch
->endpos
[0].lnum
;
3080 col
= regmatch
->endpos
[0].col
;
3081 off
= spp
->sp_offsets
[idx
] + extra
;
3085 result
->lnum
= regmatch
->startpos
[0].lnum
;
3086 col
= regmatch
->startpos
[0].col
;
3087 off
= spp
->sp_offsets
[idx
];
3091 base
= ml_get_buf(syn_buf
, result
->lnum
, FALSE
);
3095 while (off
-- && *p
!= NUL
)
3100 while (off
++ && base
< p
)
3101 mb_ptr_back(base
, p
);
3103 col
= (int)(p
- base
);
3109 * Get current line in syntax buffer.
3114 return ml_get_buf(syn_buf
, current_lnum
, FALSE
);
3118 * Call vim_regexec() to find a match with "rmp" in "syn_buf".
3119 * Returns TRUE when there is a match.
3122 syn_regexec(rmp
, lnum
, col
)
3127 rmp
->rmm_maxcol
= syn_buf
->b_p_smc
;
3128 if (vim_regexec_multi(rmp
, syn_win
, syn_buf
, lnum
, col
, NULL
) > 0)
3130 rmp
->startpos
[0].lnum
+= lnum
;
3131 rmp
->endpos
[0].lnum
+= lnum
;
3138 * Check one position in a line for a matching keyword.
3139 * The caller must check if a keyword can start at startcol.
3140 * Return it's ID if found, 0 otherwise.
3143 check_keyword_id(line
, startcol
, endcolp
, flagsp
, next_listp
, cur_si
)
3145 int startcol
; /* position in line to check for keyword */
3146 int *endcolp
; /* return: character after found keyword */
3147 long *flagsp
; /* return: flags of matching keyword */
3148 short **next_listp
; /* return: next_list of matching keyword */
3149 stateitem_T
*cur_si
; /* item at the top of the stack */
3155 char_u keyword
[MAXKEYWLEN
+ 1]; /* assume max. keyword len is 80 */
3159 /* Find first character after the keyword. First character was already
3161 kwp
= line
+ startcol
;
3167 kwlen
+= (*mb_ptr2len
)(kwp
+ kwlen
);
3172 while (vim_iswordc_buf(kwp
+ kwlen
, syn_buf
));
3174 if (kwlen
> MAXKEYWLEN
)
3178 * Must make a copy of the keyword, so we can add a NUL and make it
3181 vim_strncpy(keyword
, kwp
, kwlen
);
3188 for (round
= 1; round
<= 2; ++round
)
3190 ht
= round
== 1 ? &syn_buf
->b_keywtab
: &syn_buf
->b_keywtab_ic
;
3191 if (ht
->ht_used
== 0)
3193 if (round
== 2) /* ignore case */
3194 (void)str_foldcase(kwp
, kwlen
, keyword
, MAXKEYWLEN
+ 1);
3197 * Find keywords that match. There can be several with different
3199 * When current_next_list is non-zero accept only that group, otherwise:
3200 * Accept a not-contained keyword at toplevel.
3201 * Accept a keyword at other levels only if it is in the contains list.
3203 hi
= hash_find(ht
, keyword
);
3204 if (!HASHITEM_EMPTY(hi
))
3205 for (kp
= HI2KE(hi
); kp
!= NULL
; kp
= kp
->ke_next
)
3207 if (current_next_list
!= 0
3208 ? in_id_list(NULL
, current_next_list
, &kp
->k_syn
, 0)
3210 ? !(kp
->flags
& HL_CONTAINED
)
3211 : in_id_list(cur_si
, cur_si
->si_cont_list
,
3212 &kp
->k_syn
, kp
->flags
& HL_CONTAINED
)))
3214 *endcolp
= startcol
+ kwlen
;
3215 *flagsp
= kp
->flags
;
3216 *next_listp
= kp
->next_list
;
3217 return kp
->k_syn
.id
;
3225 * Handle ":syntax case" command.
3228 syn_cmd_case(eap
, syncing
)
3232 char_u
*arg
= eap
->arg
;
3235 eap
->nextcmd
= find_nextcmd(arg
);
3239 next
= skiptowhite(arg
);
3240 if (STRNICMP(arg
, "match", 5) == 0 && next
- arg
== 5)
3241 curbuf
->b_syn_ic
= FALSE
;
3242 else if (STRNICMP(arg
, "ignore", 6) == 0 && next
- arg
== 6)
3243 curbuf
->b_syn_ic
= TRUE
;
3245 EMSG2(_("E390: Illegal argument: %s"), arg
);
3249 * Handle ":syntax spell" command.
3252 syn_cmd_spell(eap
, syncing
)
3256 char_u
*arg
= eap
->arg
;
3259 eap
->nextcmd
= find_nextcmd(arg
);
3263 next
= skiptowhite(arg
);
3264 if (STRNICMP(arg
, "toplevel", 8) == 0 && next
- arg
== 8)
3265 curbuf
->b_syn_spell
= SYNSPL_TOP
;
3266 else if (STRNICMP(arg
, "notoplevel", 10) == 0 && next
- arg
== 10)
3267 curbuf
->b_syn_spell
= SYNSPL_NOTOP
;
3268 else if (STRNICMP(arg
, "default", 7) == 0 && next
- arg
== 7)
3269 curbuf
->b_syn_spell
= SYNSPL_DEFAULT
;
3271 EMSG2(_("E390: Illegal argument: %s"), arg
);
3275 * Clear all syntax info for one buffer.
3283 buf
->b_syn_error
= FALSE
; /* clear previous error */
3284 buf
->b_syn_ic
= FALSE
; /* Use case, by default */
3285 buf
->b_syn_spell
= SYNSPL_DEFAULT
; /* default spell checking */
3286 buf
->b_syn_containedin
= FALSE
;
3288 /* free the keywords */
3289 clear_keywtab(&buf
->b_keywtab
);
3290 clear_keywtab(&buf
->b_keywtab_ic
);
3292 /* free the syntax patterns */
3293 for (i
= buf
->b_syn_patterns
.ga_len
; --i
>= 0; )
3294 syn_clear_pattern(buf
, i
);
3295 ga_clear(&buf
->b_syn_patterns
);
3297 /* free the syntax clusters */
3298 for (i
= buf
->b_syn_clusters
.ga_len
; --i
>= 0; )
3299 syn_clear_cluster(buf
, i
);
3300 ga_clear(&buf
->b_syn_clusters
);
3301 buf
->b_spell_cluster_id
= 0;
3302 buf
->b_nospell_cluster_id
= 0;
3304 buf
->b_syn_sync_flags
= 0;
3305 buf
->b_syn_sync_minlines
= 0;
3306 buf
->b_syn_sync_maxlines
= 0;
3307 buf
->b_syn_sync_linebreaks
= 0;
3309 vim_free(buf
->b_syn_linecont_prog
);
3310 buf
->b_syn_linecont_prog
= NULL
;
3311 vim_free(buf
->b_syn_linecont_pat
);
3312 buf
->b_syn_linecont_pat
= NULL
;
3314 buf
->b_syn_folditems
= 0;
3317 /* free the stored states */
3318 syn_stack_free_all(buf
);
3319 invalidate_current_state();
3323 * Clear syncing info for one buffer.
3330 /* free the syntax patterns */
3331 for (i
= curbuf
->b_syn_patterns
.ga_len
; --i
>= 0; )
3332 if (SYN_ITEMS(curbuf
)[i
].sp_syncing
)
3333 syn_remove_pattern(curbuf
, i
);
3335 curbuf
->b_syn_sync_flags
= 0;
3336 curbuf
->b_syn_sync_minlines
= 0;
3337 curbuf
->b_syn_sync_maxlines
= 0;
3338 curbuf
->b_syn_sync_linebreaks
= 0;
3340 vim_free(curbuf
->b_syn_linecont_prog
);
3341 curbuf
->b_syn_linecont_prog
= NULL
;
3342 vim_free(curbuf
->b_syn_linecont_pat
);
3343 curbuf
->b_syn_linecont_pat
= NULL
;
3345 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
3349 * Remove one pattern from the buffer's pattern list.
3352 syn_remove_pattern(buf
, idx
)
3358 spp
= &(SYN_ITEMS(buf
)[idx
]);
3360 if (spp
->sp_flags
& HL_FOLD
)
3361 --buf
->b_syn_folditems
;
3363 syn_clear_pattern(buf
, idx
);
3364 mch_memmove(spp
, spp
+ 1,
3365 sizeof(synpat_T
) * (buf
->b_syn_patterns
.ga_len
- idx
- 1));
3366 --buf
->b_syn_patterns
.ga_len
;
3370 * Clear and free one syntax pattern. When clearing all, must be called from
3374 syn_clear_pattern(buf
, i
)
3378 vim_free(SYN_ITEMS(buf
)[i
].sp_pattern
);
3379 vim_free(SYN_ITEMS(buf
)[i
].sp_prog
);
3380 /* Only free sp_cont_list and sp_next_list of first start pattern */
3381 if (i
== 0 || SYN_ITEMS(buf
)[i
- 1].sp_type
!= SPTYPE_START
)
3383 vim_free(SYN_ITEMS(buf
)[i
].sp_cont_list
);
3384 vim_free(SYN_ITEMS(buf
)[i
].sp_next_list
);
3385 vim_free(SYN_ITEMS(buf
)[i
].sp_syn
.cont_in_list
);
3390 * Clear and free one syntax cluster.
3393 syn_clear_cluster(buf
, i
)
3397 vim_free(SYN_CLSTR(buf
)[i
].scl_name
);
3398 vim_free(SYN_CLSTR(buf
)[i
].scl_name_u
);
3399 vim_free(SYN_CLSTR(buf
)[i
].scl_list
);
3403 * Handle ":syntax clear" command.
3406 syn_cmd_clear(eap
, syncing
)
3410 char_u
*arg
= eap
->arg
;
3414 eap
->nextcmd
= find_nextcmd(arg
);
3419 * We have to disable this within ":syn include @group filename",
3420 * because otherwise @group would get deleted.
3421 * Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
3424 if (curbuf
->b_syn_topgrp
!= 0)
3427 if (ends_excmd(*arg
))
3430 * No argument: Clear all syntax items.
3433 syntax_sync_clear();
3436 syntax_clear(curbuf
);
3437 do_unlet((char_u
*)"b:current_syntax", TRUE
);
3443 * Clear the group IDs that are in the argument.
3445 while (!ends_excmd(*arg
))
3447 arg_end
= skiptowhite(arg
);
3450 id
= syn_scl_namen2id(arg
+ 1, (int)(arg_end
- arg
- 1));
3453 EMSG2(_("E391: No such syntax cluster: %s"), arg
);
3459 * We can't physically delete a cluster without changing
3460 * the IDs of other clusters, so we do the next best thing
3461 * and make it empty.
3463 short scl_id
= id
- SYNID_CLUSTER
;
3465 vim_free(SYN_CLSTR(curbuf
)[scl_id
].scl_list
);
3466 SYN_CLSTR(curbuf
)[scl_id
].scl_list
= NULL
;
3471 id
= syn_namen2id(arg
, (int)(arg_end
- arg
));
3474 EMSG2(_(e_nogroup
), arg
);
3478 syn_clear_one(id
, syncing
);
3480 arg
= skipwhite(arg_end
);
3483 redraw_curbuf_later(SOME_VALID
);
3484 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
3488 * Clear one syntax group for the current buffer.
3491 syn_clear_one(id
, syncing
)
3498 /* Clear keywords only when not ":syn sync clear group-name" */
3501 (void)syn_clear_keyword(id
, &curbuf
->b_keywtab
);
3502 (void)syn_clear_keyword(id
, &curbuf
->b_keywtab_ic
);
3505 /* clear the patterns for "id" */
3506 for (idx
= curbuf
->b_syn_patterns
.ga_len
; --idx
>= 0; )
3508 spp
= &(SYN_ITEMS(curbuf
)[idx
]);
3509 if (spp
->sp_syn
.id
!= id
|| spp
->sp_syncing
!= syncing
)
3511 syn_remove_pattern(curbuf
, idx
);
3516 * Handle ":syntax on" command.
3519 syn_cmd_on(eap
, syncing
)
3523 syn_cmd_onoff(eap
, "syntax");
3527 * Handle ":syntax enable" command.
3530 syn_cmd_enable(eap
, syncing
)
3534 set_internal_string_var((char_u
*)"syntax_cmd", (char_u
*)"enable");
3535 syn_cmd_onoff(eap
, "syntax");
3536 do_unlet((char_u
*)"g:syntax_cmd", TRUE
);
3540 * Handle ":syntax reset" command.
3543 syn_cmd_reset(eap
, syncing
)
3547 eap
->nextcmd
= check_nextcmd(eap
->arg
);
3550 set_internal_string_var((char_u
*)"syntax_cmd", (char_u
*)"reset");
3551 do_cmdline_cmd((char_u
*)"runtime! syntax/syncolor.vim");
3552 do_unlet((char_u
*)"g:syntax_cmd", TRUE
);
3557 * Handle ":syntax manual" command.
3560 syn_cmd_manual(eap
, syncing
)
3564 syn_cmd_onoff(eap
, "manual");
3568 * Handle ":syntax off" command.
3571 syn_cmd_off(eap
, syncing
)
3575 syn_cmd_onoff(eap
, "nosyntax");
3579 syn_cmd_onoff(eap
, name
)
3585 eap
->nextcmd
= check_nextcmd(eap
->arg
);
3589 vim_snprintf((char *)buf
+ 3, sizeof(buf
) - 3, SYNTAX_FNAME
, name
);
3590 do_cmdline_cmd(buf
);
3595 * Handle ":syntax [list]" command: list current syntax words.
3598 syn_cmd_list(eap
, syncing
)
3600 int syncing
; /* when TRUE: list syncing items */
3602 char_u
*arg
= eap
->arg
;
3606 eap
->nextcmd
= find_nextcmd(arg
);
3610 if (!syntax_present(curbuf
))
3612 MSG(_("No Syntax items defined for this buffer"));
3618 if (curbuf
->b_syn_sync_flags
& SF_CCOMMENT
)
3620 MSG_PUTS(_("syncing on C-style comments"));
3625 else if (!(curbuf
->b_syn_sync_flags
& SF_MATCH
))
3627 if (curbuf
->b_syn_sync_minlines
== 0)
3628 MSG_PUTS(_("no syncing"));
3631 MSG_PUTS(_("syncing starts "));
3632 msg_outnum(curbuf
->b_syn_sync_minlines
);
3633 MSG_PUTS(_(" lines before top line"));
3638 MSG_PUTS_TITLE(_("\n--- Syntax sync items ---"));
3639 if (curbuf
->b_syn_sync_minlines
> 0
3640 || curbuf
->b_syn_sync_maxlines
> 0
3641 || curbuf
->b_syn_sync_linebreaks
> 0)
3643 MSG_PUTS(_("\nsyncing on items"));
3649 MSG_PUTS_TITLE(_("\n--- Syntax items ---"));
3650 if (ends_excmd(*arg
))
3653 * No argument: List all group IDs and all syntax clusters.
3655 for (id
= 1; id
<= highlight_ga
.ga_len
&& !got_int
; ++id
)
3656 syn_list_one(id
, syncing
, FALSE
);
3657 for (id
= 0; id
< curbuf
->b_syn_clusters
.ga_len
&& !got_int
; ++id
)
3658 syn_list_cluster(id
);
3663 * List the group IDs and syntax clusters that are in the argument.
3665 while (!ends_excmd(*arg
) && !got_int
)
3667 arg_end
= skiptowhite(arg
);
3670 id
= syn_scl_namen2id(arg
+ 1, (int)(arg_end
- arg
- 1));
3672 EMSG2(_("E392: No such syntax cluster: %s"), arg
);
3674 syn_list_cluster(id
- SYNID_CLUSTER
);
3678 id
= syn_namen2id(arg
, (int)(arg_end
- arg
));
3680 EMSG2(_(e_nogroup
), arg
);
3682 syn_list_one(id
, syncing
, TRUE
);
3684 arg
= skipwhite(arg_end
);
3687 eap
->nextcmd
= check_nextcmd(arg
);
3693 if (curbuf
->b_syn_sync_maxlines
> 0 || curbuf
->b_syn_sync_minlines
> 0)
3696 if (curbuf
->b_syn_sync_minlines
> 0)
3698 MSG_PUTS(_("minimal "));
3699 msg_outnum(curbuf
->b_syn_sync_minlines
);
3700 if (curbuf
->b_syn_sync_maxlines
)
3703 if (curbuf
->b_syn_sync_maxlines
> 0)
3705 MSG_PUTS(_("maximal "));
3706 msg_outnum(curbuf
->b_syn_sync_maxlines
);
3708 MSG_PUTS(_(" lines before top line"));
3715 if (curbuf
->b_syn_sync_linebreaks
> 0)
3717 MSG_PUTS(_("; match "));
3718 msg_outnum(curbuf
->b_syn_sync_linebreaks
);
3719 MSG_PUTS(_(" line breaks"));
3723 static int last_matchgroup
;
3731 static void syn_list_flags
__ARGS((struct name_list
*nl
, int flags
, int attr
));
3734 * List one syntax item, for ":syntax" or "syntax list syntax_name".
3737 syn_list_one(id
, syncing
, link_only
)
3739 int syncing
; /* when TRUE: list syncing items */
3740 int link_only
; /* when TRUE; list link-only too */
3744 int did_header
= FALSE
;
3746 static struct name_list namelist1
[] =
3748 {HL_DISPLAY
, "display"},
3749 {HL_CONTAINED
, "contained"},
3750 {HL_ONELINE
, "oneline"},
3751 {HL_KEEPEND
, "keepend"},
3752 {HL_EXTEND
, "extend"},
3753 {HL_EXCLUDENL
, "excludenl"},
3754 {HL_TRANSP
, "transparent"},
3758 static struct name_list namelist2
[] =
3760 {HL_SKIPWHITE
, "skipwhite"},
3761 {HL_SKIPNL
, "skipnl"},
3762 {HL_SKIPEMPTY
, "skipempty"},
3766 attr
= hl_attr(HLF_D
); /* highlight like directories */
3768 /* list the keywords for "id" */
3771 did_header
= syn_list_keywords(id
, &curbuf
->b_keywtab
, FALSE
, attr
);
3772 did_header
= syn_list_keywords(id
, &curbuf
->b_keywtab_ic
,
3776 /* list the patterns for "id" */
3777 for (idx
= 0; idx
< curbuf
->b_syn_patterns
.ga_len
&& !got_int
; ++idx
)
3779 spp
= &(SYN_ITEMS(curbuf
)[idx
]);
3780 if (spp
->sp_syn
.id
!= id
|| spp
->sp_syncing
!= syncing
)
3783 (void)syn_list_header(did_header
, 999, id
);
3785 last_matchgroup
= 0;
3786 if (spp
->sp_type
== SPTYPE_MATCH
)
3788 put_pattern("match", ' ', spp
, attr
);
3791 else if (spp
->sp_type
== SPTYPE_START
)
3793 while (SYN_ITEMS(curbuf
)[idx
].sp_type
== SPTYPE_START
)
3794 put_pattern("start", '=', &SYN_ITEMS(curbuf
)[idx
++], attr
);
3795 if (SYN_ITEMS(curbuf
)[idx
].sp_type
== SPTYPE_SKIP
)
3796 put_pattern("skip", '=', &SYN_ITEMS(curbuf
)[idx
++], attr
);
3797 while (idx
< curbuf
->b_syn_patterns
.ga_len
3798 && SYN_ITEMS(curbuf
)[idx
].sp_type
== SPTYPE_END
)
3799 put_pattern("end", '=', &SYN_ITEMS(curbuf
)[idx
++], attr
);
3803 syn_list_flags(namelist1
, spp
->sp_flags
, attr
);
3805 if (spp
->sp_cont_list
!= NULL
)
3806 put_id_list((char_u
*)"contains", spp
->sp_cont_list
, attr
);
3808 if (spp
->sp_syn
.cont_in_list
!= NULL
)
3809 put_id_list((char_u
*)"containedin",
3810 spp
->sp_syn
.cont_in_list
, attr
);
3812 if (spp
->sp_next_list
!= NULL
)
3814 put_id_list((char_u
*)"nextgroup", spp
->sp_next_list
, attr
);
3815 syn_list_flags(namelist2
, spp
->sp_flags
, attr
);
3817 if (spp
->sp_flags
& (HL_SYNC_HERE
|HL_SYNC_THERE
))
3819 if (spp
->sp_flags
& HL_SYNC_HERE
)
3820 msg_puts_attr((char_u
*)"grouphere", attr
);
3822 msg_puts_attr((char_u
*)"groupthere", attr
);
3824 if (spp
->sp_sync_idx
>= 0)
3825 msg_outtrans(HL_TABLE()[SYN_ITEMS(curbuf
)
3826 [spp
->sp_sync_idx
].sp_syn
.id
- 1].sg_name
);
3833 /* list the link, if there is one */
3834 if (HL_TABLE()[id
- 1].sg_link
&& (did_header
|| link_only
) && !got_int
)
3836 (void)syn_list_header(did_header
, 999, id
);
3837 msg_puts_attr((char_u
*)"links to", attr
);
3839 msg_outtrans(HL_TABLE()[HL_TABLE()[id
- 1].sg_link
- 1].sg_name
);
3844 syn_list_flags(nl
, flags
, attr
)
3845 struct name_list
*nl
;
3851 for (i
= 0; nl
[i
].flag
!= 0; ++i
)
3852 if (flags
& nl
[i
].flag
)
3854 msg_puts_attr((char_u
*)nl
[i
].name
, attr
);
3860 * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
3863 syn_list_cluster(id
)
3868 /* slight hack: roughly duplicate the guts of syn_list_header() */
3870 msg_outtrans(SYN_CLSTR(curbuf
)[id
].scl_name
);
3872 if (msg_col
>= endcol
) /* output at least one space */
3873 endcol
= msg_col
+ 1;
3874 if (Columns
<= endcol
) /* avoid hang for tiny window */
3875 endcol
= Columns
- 1;
3877 msg_advance(endcol
);
3878 if (SYN_CLSTR(curbuf
)[id
].scl_list
!= NULL
)
3880 put_id_list((char_u
*)"cluster", SYN_CLSTR(curbuf
)[id
].scl_list
,
3885 msg_puts_attr((char_u
*)"cluster", hl_attr(HLF_D
));
3886 msg_puts((char_u
*)"=NONE");
3891 put_id_list(name
, list
, attr
)
3898 msg_puts_attr(name
, attr
);
3900 for (p
= list
; *p
; ++p
)
3902 if (*p
>= SYNID_ALLBUT
&& *p
< SYNID_TOP
)
3909 else if (*p
>= SYNID_TOP
&& *p
< SYNID_CONTAINED
)
3913 else if (*p
>= SYNID_CONTAINED
&& *p
< SYNID_CLUSTER
)
3915 MSG_PUTS("CONTAINED");
3917 else if (*p
>= SYNID_CLUSTER
)
3919 short scl_id
= *p
- SYNID_CLUSTER
;
3922 msg_outtrans(SYN_CLSTR(curbuf
)[scl_id
].scl_name
);
3925 msg_outtrans(HL_TABLE()[*p
- 1].sg_name
);
3933 put_pattern(s
, c
, spp
, attr
)
3942 static char *sepchars
= "/+=-#@\"|'^&";
3945 /* May have to write "matchgroup=group" */
3946 if (last_matchgroup
!= spp
->sp_syn_match_id
)
3948 last_matchgroup
= spp
->sp_syn_match_id
;
3949 msg_puts_attr((char_u
*)"matchgroup", attr
);
3951 if (last_matchgroup
== 0)
3952 msg_outtrans((char_u
*)"NONE");
3954 msg_outtrans(HL_TABLE()[last_matchgroup
- 1].sg_name
);
3958 /* output the name of the pattern and an '=' or ' ' */
3959 msg_puts_attr((char_u
*)s
, attr
);
3962 /* output the pattern, in between a char that is not in the pattern */
3963 for (i
= 0; vim_strchr(spp
->sp_pattern
, sepchars
[i
]) != NULL
; )
3964 if (sepchars
[++i
] == NUL
)
3966 i
= 0; /* no good char found, just use the first one */
3969 msg_putchar(sepchars
[i
]);
3970 msg_outtrans(spp
->sp_pattern
);
3971 msg_putchar(sepchars
[i
]);
3973 /* output any pattern options */
3975 for (i
= 0; i
< SPO_COUNT
; ++i
)
3978 if (spp
->sp_off_flags
& (mask
+ (mask
<< SPO_COUNT
)))
3981 msg_putchar(','); /* separate with commas */
3982 msg_puts((char_u
*)spo_name_tab
[i
]);
3983 n
= spp
->sp_offsets
[i
];
3984 if (i
!= SPO_LC_OFF
)
3986 if (spp
->sp_off_flags
& mask
)
3993 if (n
|| i
== SPO_LC_OFF
)
4002 * List or clear the keywords for one syntax group.
4003 * Return TRUE if the header has been printed.
4006 syn_list_keywords(id
, ht
, did_header
, attr
)
4009 int did_header
; /* header has already been printed */
4016 int prev_contained
= 0;
4017 short *prev_next_list
= NULL
;
4018 short *prev_cont_in_list
= NULL
;
4019 int prev_skipnl
= 0;
4020 int prev_skipwhite
= 0;
4021 int prev_skipempty
= 0;
4024 * Unfortunately, this list of keywords is not sorted on alphabet but on
4027 todo
= (int)ht
->ht_used
;
4028 for (hi
= ht
->ht_array
; todo
> 0 && !got_int
; ++hi
)
4030 if (!HASHITEM_EMPTY(hi
))
4033 for (kp
= HI2KE(hi
); kp
!= NULL
&& !got_int
; kp
= kp
->ke_next
)
4035 if (kp
->k_syn
.id
== id
)
4037 if (prev_contained
!= (kp
->flags
& HL_CONTAINED
)
4038 || prev_skipnl
!= (kp
->flags
& HL_SKIPNL
)
4039 || prev_skipwhite
!= (kp
->flags
& HL_SKIPWHITE
)
4040 || prev_skipempty
!= (kp
->flags
& HL_SKIPEMPTY
)
4041 || prev_cont_in_list
!= kp
->k_syn
.cont_in_list
4042 || prev_next_list
!= kp
->next_list
)
4045 outlen
= (int)STRLEN(kp
->keyword
);
4046 /* output "contained" and "nextgroup" on each line */
4047 if (syn_list_header(did_header
, outlen
, id
))
4050 prev_next_list
= NULL
;
4051 prev_cont_in_list
= NULL
;
4057 if (prev_contained
!= (kp
->flags
& HL_CONTAINED
))
4059 msg_puts_attr((char_u
*)"contained", attr
);
4061 prev_contained
= (kp
->flags
& HL_CONTAINED
);
4063 if (kp
->k_syn
.cont_in_list
!= prev_cont_in_list
)
4065 put_id_list((char_u
*)"containedin",
4066 kp
->k_syn
.cont_in_list
, attr
);
4068 prev_cont_in_list
= kp
->k_syn
.cont_in_list
;
4070 if (kp
->next_list
!= prev_next_list
)
4072 put_id_list((char_u
*)"nextgroup", kp
->next_list
, attr
);
4074 prev_next_list
= kp
->next_list
;
4075 if (kp
->flags
& HL_SKIPNL
)
4077 msg_puts_attr((char_u
*)"skipnl", attr
);
4079 prev_skipnl
= (kp
->flags
& HL_SKIPNL
);
4081 if (kp
->flags
& HL_SKIPWHITE
)
4083 msg_puts_attr((char_u
*)"skipwhite", attr
);
4085 prev_skipwhite
= (kp
->flags
& HL_SKIPWHITE
);
4087 if (kp
->flags
& HL_SKIPEMPTY
)
4089 msg_puts_attr((char_u
*)"skipempty", attr
);
4091 prev_skipempty
= (kp
->flags
& HL_SKIPEMPTY
);
4094 msg_outtrans(kp
->keyword
);
4104 syn_clear_keyword(id
, ht
)
4110 keyentry_T
*kp_prev
;
4111 keyentry_T
*kp_next
;
4115 todo
= (int)ht
->ht_used
;
4116 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
4118 if (!HASHITEM_EMPTY(hi
))
4122 for (kp
= HI2KE(hi
); kp
!= NULL
; )
4124 if (kp
->k_syn
.id
== id
)
4126 kp_next
= kp
->ke_next
;
4127 if (kp_prev
== NULL
)
4129 if (kp_next
== NULL
)
4130 hash_remove(ht
, hi
);
4132 hi
->hi_key
= KE2HIKEY(kp_next
);
4135 kp_prev
->ke_next
= kp_next
;
4136 vim_free(kp
->next_list
);
4137 vim_free(kp
->k_syn
.cont_in_list
);
4153 * Clear a whole keyword table.
4162 keyentry_T
*kp_next
;
4164 todo
= (int)ht
->ht_used
;
4165 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
4167 if (!HASHITEM_EMPTY(hi
))
4171 for (kp
= HI2KE(hi
); kp
!= NULL
; kp
= kp_next
)
4173 kp_next
= kp
->ke_next
;
4174 vim_free(kp
->next_list
);
4175 vim_free(kp
->k_syn
.cont_in_list
);
4185 * Add a keyword to the list of keywords.
4188 add_keyword(name
, id
, flags
, cont_in_list
, next_list
)
4189 char_u
*name
; /* name of keyword */
4190 int id
; /* group ID for this keyword */
4191 int flags
; /* flags for this keyword */
4192 short *cont_in_list
; /* containedin for this keyword */
4193 short *next_list
; /* nextgroup for this keyword */
4200 char_u name_folded
[MAXKEYWLEN
+ 1];
4202 if (curbuf
->b_syn_ic
)
4203 name_ic
= str_foldcase(name
, (int)STRLEN(name
),
4204 name_folded
, MAXKEYWLEN
+ 1);
4207 kp
= (keyentry_T
*)alloc((int)(sizeof(keyentry_T
) + STRLEN(name_ic
)));
4210 STRCPY(kp
->keyword
, name_ic
);
4212 kp
->k_syn
.inc_tag
= current_syn_inc_tag
;
4214 kp
->k_syn
.cont_in_list
= copy_id_list(cont_in_list
);
4215 if (cont_in_list
!= NULL
)
4216 curbuf
->b_syn_containedin
= TRUE
;
4217 kp
->next_list
= copy_id_list(next_list
);
4219 if (curbuf
->b_syn_ic
)
4220 ht
= &curbuf
->b_keywtab_ic
;
4222 ht
= &curbuf
->b_keywtab
;
4224 hash
= hash_hash(kp
->keyword
);
4225 hi
= hash_lookup(ht
, kp
->keyword
, hash
);
4226 if (HASHITEM_EMPTY(hi
))
4228 /* new keyword, add to hashtable */
4230 hash_add_item(ht
, hi
, kp
->keyword
, hash
);
4234 /* keyword already exists, prepend to list */
4235 kp
->ke_next
= HI2KE(hi
);
4236 hi
->hi_key
= KE2HIKEY(kp
);
4241 * Get the start and end of the group name argument.
4242 * Return a pointer to the first argument.
4243 * Return NULL if the end of the command was found instead of further args.
4246 get_group_name(arg
, name_end
)
4247 char_u
*arg
; /* start of the argument */
4248 char_u
**name_end
; /* pointer to end of the name */
4252 *name_end
= skiptowhite(arg
);
4253 rest
= skipwhite(*name_end
);
4256 * Check if there are enough arguments. The first argument may be a
4257 * pattern, where '|' is allowed, so only check for NUL.
4259 if (ends_excmd(*arg
) || *rest
== NUL
)
4265 * Check for syntax command option arguments.
4266 * This can be called at any place in the list of arguments, and just picks
4267 * out the arguments that are known. Can be called several times in a row to
4268 * collect all options in between other arguments.
4269 * Return a pointer to the next argument (which isn't an option).
4270 * Return NULL for any error;
4273 get_syn_options(arg
, opt
)
4274 char_u
*arg
; /* next argument to be checked */
4275 syn_opt_arg_T
*opt
; /* various things */
4277 char_u
*gname_start
, *gname
;
4288 } flagtab
[] = { {"cCoOnNtTaAiInNeEdD", 0, HL_CONTAINED
},
4289 {"oOnNeElLiInNeE", 0, HL_ONELINE
},
4290 {"kKeEeEpPeEnNdD", 0, HL_KEEPEND
},
4291 {"eExXtTeEnNdD", 0, HL_EXTEND
},
4292 {"eExXcClLuUdDeEnNlL", 0, HL_EXCLUDENL
},
4293 {"tTrRaAnNsSpPaArReEnNtT", 0, HL_TRANSP
},
4294 {"sSkKiIpPnNlL", 0, HL_SKIPNL
},
4295 {"sSkKiIpPwWhHiItTeE", 0, HL_SKIPWHITE
},
4296 {"sSkKiIpPeEmMpPtTyY", 0, HL_SKIPEMPTY
},
4297 {"gGrRoOuUpPhHeErReE", 0, HL_SYNC_HERE
},
4298 {"gGrRoOuUpPtThHeErReE", 0, HL_SYNC_THERE
},
4299 {"dDiIsSpPlLaAyY", 0, HL_DISPLAY
},
4300 {"fFoOlLdD", 0, HL_FOLD
},
4301 {"cCoOnNtTaAiInNsS", 1, 0},
4302 {"cCoOnNtTaAiInNeEdDiInN", 2, 0},
4303 {"nNeExXtTgGrRoOuUpP", 3, 0},
4305 static char *first_letters
= "cCoOkKeEtTsSgGdDfFnN";
4307 if (arg
== NULL
) /* already detected error */
4313 * This is used very often when a large number of keywords is defined.
4314 * Need to skip quickly when no option name is found.
4315 * Also avoid tolower(), it's slow.
4317 if (strchr(first_letters
, *arg
) == NULL
)
4320 for (fidx
= sizeof(flagtab
) / sizeof(struct flag
); --fidx
>= 0; )
4322 p
= flagtab
[fidx
].name
;
4323 for (i
= 0, len
= 0; p
[i
] != NUL
; i
+= 2, ++len
)
4324 if (arg
[len
] != p
[i
] && arg
[len
] != p
[i
+ 1])
4326 if (p
[i
] == NUL
&& (vim_iswhite(arg
[len
])
4327 || (flagtab
[fidx
].argtype
> 0
4329 : ends_excmd(arg
[len
]))))
4332 && (flagtab
[fidx
].flags
== HL_DISPLAY
4333 || flagtab
[fidx
].flags
== HL_FOLD
4334 || flagtab
[fidx
].flags
== HL_EXTEND
))
4335 /* treat "display", "fold" and "extend" as a keyword */
4340 if (fidx
< 0) /* no match found */
4343 if (flagtab
[fidx
].argtype
== 1)
4345 if (!opt
->has_cont_list
)
4347 EMSG(_("E395: contains argument not accepted here"));
4350 if (get_id_list(&arg
, 8, &opt
->cont_list
) == FAIL
)
4353 else if (flagtab
[fidx
].argtype
== 2)
4355 #if 0 /* cannot happen */
4356 if (opt
->cont_in_list
== NULL
)
4358 EMSG(_("E396: containedin argument not accepted here"));
4362 if (get_id_list(&arg
, 11, &opt
->cont_in_list
) == FAIL
)
4365 else if (flagtab
[fidx
].argtype
== 3)
4367 if (get_id_list(&arg
, 9, &opt
->next_list
) == FAIL
)
4372 opt
->flags
|= flagtab
[fidx
].flags
;
4373 arg
= skipwhite(arg
+ len
);
4375 if (flagtab
[fidx
].flags
== HL_SYNC_HERE
4376 || flagtab
[fidx
].flags
== HL_SYNC_THERE
)
4378 if (opt
->sync_idx
== NULL
)
4380 EMSG(_("E393: group[t]here not accepted here"));
4384 arg
= skiptowhite(arg
);
4385 if (gname_start
== arg
)
4387 gname
= vim_strnsave(gname_start
, (int)(arg
- gname_start
));
4390 if (STRCMP(gname
, "NONE") == 0)
4391 *opt
->sync_idx
= NONE_IDX
;
4394 syn_id
= syn_name2id(gname
);
4395 for (i
= curbuf
->b_syn_patterns
.ga_len
; --i
>= 0; )
4396 if (SYN_ITEMS(curbuf
)[i
].sp_syn
.id
== syn_id
4397 && SYN_ITEMS(curbuf
)[i
].sp_type
== SPTYPE_START
)
4404 EMSG2(_("E394: Didn't find region item for %s"), gname
);
4411 arg
= skipwhite(arg
);
4414 else if (flagtab
[fidx
].flags
== HL_FOLD
4415 && foldmethodIsSyntax(curwin
))
4416 /* Need to update folds later. */
4417 foldUpdateAll(curwin
);
4426 * Adjustments to syntax item when declared in a ":syn include"'d file.
4427 * Set the contained flag, and if the item is not already contained, add it
4428 * to the specified top-level group, if any.
4431 syn_incl_toplevel(id
, flagsp
)
4435 if ((*flagsp
& HL_CONTAINED
) || curbuf
->b_syn_topgrp
== 0)
4437 *flagsp
|= HL_CONTAINED
;
4438 if (curbuf
->b_syn_topgrp
>= SYNID_CLUSTER
)
4440 /* We have to alloc this, because syn_combine_list() will free it. */
4441 short *grp_list
= (short *)alloc((unsigned)(2 * sizeof(short)));
4442 int tlg_id
= curbuf
->b_syn_topgrp
- SYNID_CLUSTER
;
4444 if (grp_list
!= NULL
)
4448 syn_combine_list(&SYN_CLSTR(curbuf
)[tlg_id
].scl_list
, &grp_list
,
4455 * Handle ":syntax include [@{group-name}] filename" command.
4458 syn_cmd_include(eap
, syncing
)
4462 char_u
*arg
= eap
->arg
;
4464 char_u
*group_name_end
;
4466 char_u
*errormsg
= NULL
;
4467 int prev_toplvl_grp
;
4468 int prev_syn_inc_tag
;
4471 eap
->nextcmd
= find_nextcmd(arg
);
4478 rest
= get_group_name(arg
, &group_name_end
);
4481 EMSG((char_u
*)_("E397: Filename required"));
4484 sgl_id
= syn_check_cluster(arg
, (int)(group_name_end
- arg
));
4485 /* separate_nextcmd() and expand_filename() depend on this */
4490 * Everything that's left, up to the next command, should be the
4491 * filename to include.
4493 eap
->argt
|= (XFILE
| NOSPC
);
4494 separate_nextcmd(eap
);
4495 if (*eap
->arg
== '<' || *eap
->arg
== '$' || mch_isFullName(eap
->arg
))
4497 /* For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the
4498 * file. Need to expand the file name first. In other cases
4499 * ":runtime!" is used. */
4501 if (expand_filename(eap
, syn_cmdlinep
, &errormsg
) == FAIL
)
4503 if (errormsg
!= NULL
)
4510 * Save and restore the existing top-level grouplist id and ":syn
4511 * include" tag around the actual inclusion.
4513 prev_syn_inc_tag
= current_syn_inc_tag
;
4514 current_syn_inc_tag
= ++running_syn_inc_tag
;
4515 prev_toplvl_grp
= curbuf
->b_syn_topgrp
;
4516 curbuf
->b_syn_topgrp
= sgl_id
;
4517 if (source
? do_source(eap
->arg
, FALSE
, DOSO_NONE
) == FAIL
4518 : source_runtime(eap
->arg
, TRUE
) == FAIL
)
4519 EMSG2(_(e_notopen
), eap
->arg
);
4520 curbuf
->b_syn_topgrp
= prev_toplvl_grp
;
4521 current_syn_inc_tag
= prev_syn_inc_tag
;
4525 * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
4528 syn_cmd_keyword(eap
, syncing
)
4532 char_u
*arg
= eap
->arg
;
4533 char_u
*group_name_end
;
4536 char_u
*keyword_copy
;
4539 syn_opt_arg_T syn_opt_arg
;
4542 rest
= get_group_name(arg
, &group_name_end
);
4546 syn_id
= syn_check_group(arg
, (int)(group_name_end
- arg
));
4548 /* allocate a buffer, for removing the backslashes in the keyword */
4549 keyword_copy
= alloc((unsigned)STRLEN(rest
) + 1);
4550 if (keyword_copy
!= NULL
)
4552 syn_opt_arg
.flags
= 0;
4553 syn_opt_arg
.keyword
= TRUE
;
4554 syn_opt_arg
.sync_idx
= NULL
;
4555 syn_opt_arg
.has_cont_list
= FALSE
;
4556 syn_opt_arg
.cont_in_list
= NULL
;
4557 syn_opt_arg
.next_list
= NULL
;
4560 * The options given apply to ALL keywords, so all options must be
4561 * found before keywords can be created.
4562 * 1: collect the options and copy the keywords to keyword_copy.
4566 for ( ; rest
!= NULL
&& !ends_excmd(*rest
); rest
= skipwhite(rest
))
4568 rest
= get_syn_options(rest
, &syn_opt_arg
);
4569 if (rest
== NULL
|| ends_excmd(*rest
))
4571 /* Copy the keyword, removing backslashes, and add a NUL. */
4572 while (*rest
!= NUL
&& !vim_iswhite(*rest
))
4574 if (*rest
== '\\' && rest
[1] != NUL
)
4584 /* Adjust flags for use of ":syn include". */
4585 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4588 * 2: Add an entry for each keyword.
4590 for (kw
= keyword_copy
; --cnt
>= 0; kw
+= STRLEN(kw
) + 1)
4592 for (p
= vim_strchr(kw
, '['); ; )
4596 add_keyword(kw
, syn_id
, syn_opt_arg
.flags
,
4597 syn_opt_arg
.cont_in_list
,
4598 syn_opt_arg
.next_list
);
4603 EMSG2(_("E789: Missing ']': %s"), kw
);
4604 kw
= p
+ 2; /* skip over the NUL */
4609 kw
= p
+ 1; /* skip over the "]" */
4615 int l
= (*mb_ptr2len
)(p
+ 1);
4617 mch_memmove(p
, p
+ 1, l
);
4630 vim_free(keyword_copy
);
4631 vim_free(syn_opt_arg
.cont_in_list
);
4632 vim_free(syn_opt_arg
.next_list
);
4637 eap
->nextcmd
= check_nextcmd(rest
);
4639 EMSG2(_(e_invarg2
), arg
);
4641 redraw_curbuf_later(SOME_VALID
);
4642 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4646 * Handle ":syntax match {name} [{options}] {pattern} [{options}]".
4648 * Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
4651 syn_cmd_match(eap
, syncing
)
4653 int syncing
; /* TRUE for ":syntax sync match .. " */
4655 char_u
*arg
= eap
->arg
;
4656 char_u
*group_name_end
;
4658 synpat_T item
; /* the item found in the line */
4661 syn_opt_arg_T syn_opt_arg
;
4664 /* Isolate the group name, check for validity */
4665 rest
= get_group_name(arg
, &group_name_end
);
4667 /* Get options before the pattern */
4668 syn_opt_arg
.flags
= 0;
4669 syn_opt_arg
.keyword
= FALSE
;
4670 syn_opt_arg
.sync_idx
= syncing
? &sync_idx
: NULL
;
4671 syn_opt_arg
.has_cont_list
= TRUE
;
4672 syn_opt_arg
.cont_list
= NULL
;
4673 syn_opt_arg
.cont_in_list
= NULL
;
4674 syn_opt_arg
.next_list
= NULL
;
4675 rest
= get_syn_options(rest
, &syn_opt_arg
);
4677 /* get the pattern. */
4678 init_syn_patterns();
4679 vim_memset(&item
, 0, sizeof(item
));
4680 rest
= get_syn_pattern(rest
, &item
);
4681 if (vim_regcomp_had_eol() && !(syn_opt_arg
.flags
& HL_EXCLUDENL
))
4682 syn_opt_arg
.flags
|= HL_HAS_EOL
;
4684 /* Get options after the pattern */
4685 rest
= get_syn_options(rest
, &syn_opt_arg
);
4687 if (rest
!= NULL
) /* all arguments are valid */
4690 * Check for trailing command and illegal trailing arguments.
4692 eap
->nextcmd
= check_nextcmd(rest
);
4693 if (!ends_excmd(*rest
) || eap
->skip
)
4695 else if (ga_grow(&curbuf
->b_syn_patterns
, 1) != FAIL
4696 && (syn_id
= syn_check_group(arg
,
4697 (int)(group_name_end
- arg
))) != 0)
4699 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4701 * Store the pattern in the syn_items list
4703 idx
= curbuf
->b_syn_patterns
.ga_len
;
4704 SYN_ITEMS(curbuf
)[idx
] = item
;
4705 SYN_ITEMS(curbuf
)[idx
].sp_syncing
= syncing
;
4706 SYN_ITEMS(curbuf
)[idx
].sp_type
= SPTYPE_MATCH
;
4707 SYN_ITEMS(curbuf
)[idx
].sp_syn
.id
= syn_id
;
4708 SYN_ITEMS(curbuf
)[idx
].sp_syn
.inc_tag
= current_syn_inc_tag
;
4709 SYN_ITEMS(curbuf
)[idx
].sp_flags
= syn_opt_arg
.flags
;
4710 SYN_ITEMS(curbuf
)[idx
].sp_sync_idx
= sync_idx
;
4711 SYN_ITEMS(curbuf
)[idx
].sp_cont_list
= syn_opt_arg
.cont_list
;
4712 SYN_ITEMS(curbuf
)[idx
].sp_syn
.cont_in_list
=
4713 syn_opt_arg
.cont_in_list
;
4714 if (syn_opt_arg
.cont_in_list
!= NULL
)
4715 curbuf
->b_syn_containedin
= TRUE
;
4716 SYN_ITEMS(curbuf
)[idx
].sp_next_list
= syn_opt_arg
.next_list
;
4717 ++curbuf
->b_syn_patterns
.ga_len
;
4719 /* remember that we found a match for syncing on */
4720 if (syn_opt_arg
.flags
& (HL_SYNC_HERE
|HL_SYNC_THERE
))
4721 curbuf
->b_syn_sync_flags
|= SF_MATCH
;
4723 if (syn_opt_arg
.flags
& HL_FOLD
)
4724 ++curbuf
->b_syn_folditems
;
4727 redraw_curbuf_later(SOME_VALID
);
4728 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4729 return; /* don't free the progs and patterns now */
4734 * Something failed, free the allocated memory.
4736 vim_free(item
.sp_prog
);
4737 vim_free(item
.sp_pattern
);
4738 vim_free(syn_opt_arg
.cont_list
);
4739 vim_free(syn_opt_arg
.cont_in_list
);
4740 vim_free(syn_opt_arg
.next_list
);
4743 EMSG2(_(e_invarg2
), arg
);
4747 * Handle ":syntax region {group-name} [matchgroup={group-name}]
4748 * start {start} .. [skip {skip}] end {end} .. [{options}]".
4751 syn_cmd_region(eap
, syncing
)
4753 int syncing
; /* TRUE for ":syntax sync region .." */
4755 char_u
*arg
= eap
->arg
;
4756 char_u
*group_name_end
;
4757 char_u
*rest
; /* next arg, NULL on error */
4762 #define ITEM_START 0
4765 #define ITEM_MATCHGROUP 3
4768 synpat_T
*pp_synp
; /* pointer to syn_pattern */
4769 int pp_matchgroup_id
; /* matchgroup ID */
4770 struct pat_ptr
*pp_next
; /* pointer to next pat_ptr */
4772 /* patterns found in the line */
4773 struct pat_ptr
*ppp
;
4774 struct pat_ptr
*ppp_next
;
4775 int pat_count
= 0; /* nr of syn_patterns found */
4777 int matchgroup_id
= 0;
4778 int not_enough
= FALSE
; /* not enough arguments */
4779 int illegal
= FALSE
; /* illegal arguments */
4780 int success
= FALSE
;
4782 syn_opt_arg_T syn_opt_arg
;
4784 /* Isolate the group name, check for validity */
4785 rest
= get_group_name(arg
, &group_name_end
);
4791 init_syn_patterns();
4793 syn_opt_arg
.flags
= 0;
4794 syn_opt_arg
.keyword
= FALSE
;
4795 syn_opt_arg
.sync_idx
= NULL
;
4796 syn_opt_arg
.has_cont_list
= TRUE
;
4797 syn_opt_arg
.cont_list
= NULL
;
4798 syn_opt_arg
.cont_in_list
= NULL
;
4799 syn_opt_arg
.next_list
= NULL
;
4802 * get the options, patterns and matchgroup.
4804 while (rest
!= NULL
&& !ends_excmd(*rest
))
4806 /* Check for option arguments */
4807 rest
= get_syn_options(rest
, &syn_opt_arg
);
4808 if (rest
== NULL
|| ends_excmd(*rest
))
4811 /* must be a pattern or matchgroup then */
4813 while (*key_end
&& !vim_iswhite(*key_end
) && *key_end
!= '=')
4816 key
= vim_strnsave_up(rest
, (int)(key_end
- rest
));
4817 if (key
== NULL
) /* out of memory */
4822 if (STRCMP(key
, "MATCHGROUP") == 0)
4823 item
= ITEM_MATCHGROUP
;
4824 else if (STRCMP(key
, "START") == 0)
4826 else if (STRCMP(key
, "END") == 0)
4828 else if (STRCMP(key
, "SKIP") == 0)
4830 if (pat_ptrs
[ITEM_SKIP
] != NULL
) /* one skip pattern allowed */
4839 rest
= skipwhite(key_end
);
4843 EMSG2(_("E398: Missing '=': %s"), arg
);
4846 rest
= skipwhite(rest
+ 1);
4853 if (item
== ITEM_MATCHGROUP
)
4855 p
= skiptowhite(rest
);
4856 if ((p
- rest
== 4 && STRNCMP(rest
, "NONE", 4) == 0) || eap
->skip
)
4860 matchgroup_id
= syn_check_group(rest
, (int)(p
- rest
));
4861 if (matchgroup_id
== 0)
4867 rest
= skipwhite(p
);
4872 * Allocate room for a syn_pattern, and link it in the list of
4873 * syn_patterns for this item, at the start (because the list is
4874 * used from end to start).
4876 ppp
= (struct pat_ptr
*)alloc((unsigned)sizeof(struct pat_ptr
));
4882 ppp
->pp_next
= pat_ptrs
[item
];
4883 pat_ptrs
[item
] = ppp
;
4884 ppp
->pp_synp
= (synpat_T
*)alloc_clear((unsigned)sizeof(synpat_T
));
4885 if (ppp
->pp_synp
== NULL
)
4892 * Get the syntax pattern and the following offset(s).
4894 /* Enable the appropriate \z specials. */
4895 if (item
== ITEM_START
)
4896 reg_do_extmatch
= REX_SET
;
4897 else if (item
== ITEM_SKIP
|| item
== ITEM_END
)
4898 reg_do_extmatch
= REX_USE
;
4899 rest
= get_syn_pattern(rest
, ppp
->pp_synp
);
4900 reg_do_extmatch
= 0;
4901 if (item
== ITEM_END
&& vim_regcomp_had_eol()
4902 && !(syn_opt_arg
.flags
& HL_EXCLUDENL
))
4903 ppp
->pp_synp
->sp_flags
|= HL_HAS_EOL
;
4904 ppp
->pp_matchgroup_id
= matchgroup_id
;
4909 if (illegal
|| not_enough
)
4913 * Must have a "start" and "end" pattern.
4915 if (rest
!= NULL
&& (pat_ptrs
[ITEM_START
] == NULL
||
4916 pat_ptrs
[ITEM_END
] == NULL
))
4925 * Check for trailing garbage or command.
4926 * If OK, add the item.
4928 eap
->nextcmd
= check_nextcmd(rest
);
4929 if (!ends_excmd(*rest
) || eap
->skip
)
4931 else if (ga_grow(&(curbuf
->b_syn_patterns
), pat_count
) != FAIL
4932 && (syn_id
= syn_check_group(arg
,
4933 (int)(group_name_end
- arg
))) != 0)
4935 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4937 * Store the start/skip/end in the syn_items list
4939 idx
= curbuf
->b_syn_patterns
.ga_len
;
4940 for (item
= ITEM_START
; item
<= ITEM_END
; ++item
)
4942 for (ppp
= pat_ptrs
[item
]; ppp
!= NULL
; ppp
= ppp
->pp_next
)
4944 SYN_ITEMS(curbuf
)[idx
] = *(ppp
->pp_synp
);
4945 SYN_ITEMS(curbuf
)[idx
].sp_syncing
= syncing
;
4946 SYN_ITEMS(curbuf
)[idx
].sp_type
=
4947 (item
== ITEM_START
) ? SPTYPE_START
:
4948 (item
== ITEM_SKIP
) ? SPTYPE_SKIP
: SPTYPE_END
;
4949 SYN_ITEMS(curbuf
)[idx
].sp_flags
|= syn_opt_arg
.flags
;
4950 SYN_ITEMS(curbuf
)[idx
].sp_syn
.id
= syn_id
;
4951 SYN_ITEMS(curbuf
)[idx
].sp_syn
.inc_tag
= current_syn_inc_tag
;
4952 SYN_ITEMS(curbuf
)[idx
].sp_syn_match_id
=
4953 ppp
->pp_matchgroup_id
;
4954 if (item
== ITEM_START
)
4956 SYN_ITEMS(curbuf
)[idx
].sp_cont_list
=
4957 syn_opt_arg
.cont_list
;
4958 SYN_ITEMS(curbuf
)[idx
].sp_syn
.cont_in_list
=
4959 syn_opt_arg
.cont_in_list
;
4960 if (syn_opt_arg
.cont_in_list
!= NULL
)
4961 curbuf
->b_syn_containedin
= TRUE
;
4962 SYN_ITEMS(curbuf
)[idx
].sp_next_list
=
4963 syn_opt_arg
.next_list
;
4965 ++curbuf
->b_syn_patterns
.ga_len
;
4968 if (syn_opt_arg
.flags
& HL_FOLD
)
4969 ++curbuf
->b_syn_folditems
;
4974 redraw_curbuf_later(SOME_VALID
);
4975 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4976 success
= TRUE
; /* don't free the progs and patterns now */
4981 * Free the allocated memory.
4983 for (item
= ITEM_START
; item
<= ITEM_END
; ++item
)
4984 for (ppp
= pat_ptrs
[item
]; ppp
!= NULL
; ppp
= ppp_next
)
4988 vim_free(ppp
->pp_synp
->sp_prog
);
4989 vim_free(ppp
->pp_synp
->sp_pattern
);
4991 vim_free(ppp
->pp_synp
);
4992 ppp_next
= ppp
->pp_next
;
4998 vim_free(syn_opt_arg
.cont_list
);
4999 vim_free(syn_opt_arg
.cont_in_list
);
5000 vim_free(syn_opt_arg
.next_list
);
5002 EMSG2(_("E399: Not enough arguments: syntax region %s"), arg
);
5003 else if (illegal
|| rest
== NULL
)
5004 EMSG2(_(e_invarg2
), arg
);
5009 * A simple syntax group ID comparison function suitable for use in qsort()
5015 syn_compare_stub(v1
, v2
)
5019 const short *s1
= v1
;
5020 const short *s2
= v2
;
5022 return (*s1
> *s2
? 1 : *s1
< *s2
? -1 : 0);
5026 * Combines lists of syntax clusters.
5027 * *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
5030 syn_combine_list(clstr1
, clstr2
, list_op
)
5039 short *clstr
= NULL
;
5044 * Handle degenerate cases.
5046 if (*clstr2
== NULL
)
5048 if (*clstr1
== NULL
|| list_op
== CLUSTER_REPLACE
)
5050 if (list_op
== CLUSTER_REPLACE
)
5052 if (list_op
== CLUSTER_REPLACE
|| list_op
== CLUSTER_ADD
)
5059 for (g1
= *clstr1
; *g1
; g1
++)
5061 for (g2
= *clstr2
; *g2
; g2
++)
5065 * For speed purposes, sort both lists.
5067 qsort(*clstr1
, (size_t)count1
, sizeof(short), syn_compare_stub
);
5068 qsort(*clstr2
, (size_t)count2
, sizeof(short), syn_compare_stub
);
5071 * We proceed in two passes; in round 1, we count the elements to place
5072 * in the new list, and in round 2, we allocate and populate the new
5073 * list. For speed, we use a mergesort-like method, adding the smaller
5074 * of the current elements in each list to the new list.
5076 for (round
= 1; round
<= 2; round
++)
5083 * First, loop through the lists until one of them is empty.
5088 * We always want to add from the first list.
5099 * We only want to add from the second list if we're adding the
5102 if (list_op
== CLUSTER_ADD
)
5114 * Now add the leftovers from whichever list didn't get finished
5115 * first. As before, we only want to add from the second list if
5116 * we're adding the lists.
5118 for (; *g1
; g1
++, count
++)
5121 if (list_op
== CLUSTER_ADD
)
5122 for (; *g2
; g2
++, count
++)
5129 * If the group ended up empty, we don't need to allocate any
5137 clstr
= (short *)alloc((unsigned)((count
+ 1) * sizeof(short)));
5145 * Finally, put the new list in place.
5153 * Lookup a syntax cluster name and return it's ID.
5154 * If it is not found, 0 is returned.
5157 syn_scl_name2id(name
)
5163 /* Avoid using stricmp() too much, it's slow on some systems */
5164 name_u
= vim_strsave_up(name
);
5167 for (i
= curbuf
->b_syn_clusters
.ga_len
; --i
>= 0; )
5168 if (SYN_CLSTR(curbuf
)[i
].scl_name_u
!= NULL
5169 && STRCMP(name_u
, SYN_CLSTR(curbuf
)[i
].scl_name_u
) == 0)
5172 return (i
< 0 ? 0 : i
+ SYNID_CLUSTER
);
5176 * Like syn_scl_name2id(), but take a pointer + length argument.
5179 syn_scl_namen2id(linep
, len
)
5186 name
= vim_strnsave(linep
, len
);
5189 id
= syn_scl_name2id(name
);
5196 * Find syntax cluster name in the table and return it's ID.
5197 * The argument is a pointer to the name and the length of the name.
5198 * If it doesn't exist yet, a new entry is created.
5199 * Return 0 for failure.
5202 syn_check_cluster(pp
, len
)
5209 name
= vim_strnsave(pp
, len
);
5213 id
= syn_scl_name2id(name
);
5214 if (id
== 0) /* doesn't exist yet */
5215 id
= syn_add_cluster(name
);
5222 * Add new syntax cluster and return it's ID.
5223 * "name" must be an allocated string, it will be consumed.
5224 * Return 0 for failure.
5227 syn_add_cluster(name
)
5233 * First call for this growarray: init growing array.
5235 if (curbuf
->b_syn_clusters
.ga_data
== NULL
)
5237 curbuf
->b_syn_clusters
.ga_itemsize
= sizeof(syn_cluster_T
);
5238 curbuf
->b_syn_clusters
.ga_growsize
= 10;
5242 * Make room for at least one other cluster entry.
5244 if (ga_grow(&curbuf
->b_syn_clusters
, 1) == FAIL
)
5249 len
= curbuf
->b_syn_clusters
.ga_len
;
5251 vim_memset(&(SYN_CLSTR(curbuf
)[len
]), 0, sizeof(syn_cluster_T
));
5252 SYN_CLSTR(curbuf
)[len
].scl_name
= name
;
5253 SYN_CLSTR(curbuf
)[len
].scl_name_u
= vim_strsave_up(name
);
5254 SYN_CLSTR(curbuf
)[len
].scl_list
= NULL
;
5255 ++curbuf
->b_syn_clusters
.ga_len
;
5257 if (STRICMP(name
, "Spell") == 0)
5258 curbuf
->b_spell_cluster_id
= len
+ SYNID_CLUSTER
;
5259 if (STRICMP(name
, "NoSpell") == 0)
5260 curbuf
->b_nospell_cluster_id
= len
+ SYNID_CLUSTER
;
5262 return len
+ SYNID_CLUSTER
;
5266 * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
5267 * [add={groupname},..] [remove={groupname},..]".
5270 syn_cmd_cluster(eap
, syncing
)
5274 char_u
*arg
= eap
->arg
;
5275 char_u
*group_name_end
;
5279 int got_clstr
= FALSE
;
5283 eap
->nextcmd
= find_nextcmd(arg
);
5287 rest
= get_group_name(arg
, &group_name_end
);
5291 scl_id
= syn_check_cluster(arg
, (int)(group_name_end
- arg
))
5296 if (STRNICMP(rest
, "add", 3) == 0
5297 && (vim_iswhite(rest
[3]) || rest
[3] == '='))
5300 list_op
= CLUSTER_ADD
;
5302 else if (STRNICMP(rest
, "remove", 6) == 0
5303 && (vim_iswhite(rest
[6]) || rest
[6] == '='))
5306 list_op
= CLUSTER_SUBTRACT
;
5308 else if (STRNICMP(rest
, "contains", 8) == 0
5309 && (vim_iswhite(rest
[8]) || rest
[8] == '='))
5312 list_op
= CLUSTER_REPLACE
;
5318 if (get_id_list(&rest
, opt_len
, &clstr_list
) == FAIL
)
5320 EMSG2(_(e_invarg2
), rest
);
5323 syn_combine_list(&SYN_CLSTR(curbuf
)[scl_id
].scl_list
,
5324 &clstr_list
, list_op
);
5330 redraw_curbuf_later(SOME_VALID
);
5331 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
5336 EMSG(_("E400: No cluster specified"));
5337 if (rest
== NULL
|| !ends_excmd(*rest
))
5338 EMSG2(_(e_invarg2
), arg
);
5342 * On first call for current buffer: Init growing array.
5347 curbuf
->b_syn_patterns
.ga_itemsize
= sizeof(synpat_T
);
5348 curbuf
->b_syn_patterns
.ga_growsize
= 10;
5352 * Get one pattern for a ":syntax match" or ":syntax region" command.
5353 * Stores the pattern and program in a synpat_T.
5354 * Returns a pointer to the next argument, or NULL in case of an error.
5357 get_syn_pattern(arg
, ci
)
5366 /* need at least three chars */
5367 if (arg
== NULL
|| arg
[1] == NUL
|| arg
[2] == NUL
)
5370 end
= skip_regexp(arg
+ 1, *arg
, TRUE
, NULL
);
5371 if (*end
!= *arg
) /* end delimiter not found */
5373 EMSG2(_("E401: Pattern delimiter not found: %s"), arg
);
5376 /* store the pattern and compiled regexp program */
5377 if ((ci
->sp_pattern
= vim_strnsave(arg
+ 1, (int)(end
- arg
- 1))) == NULL
)
5380 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5382 p_cpo
= (char_u
*)"";
5383 ci
->sp_prog
= vim_regcomp(ci
->sp_pattern
, RE_MAGIC
);
5386 if (ci
->sp_prog
== NULL
)
5388 ci
->sp_ic
= curbuf
->b_syn_ic
;
5391 * Check for a match, highlight or region offset.
5396 for (idx
= SPO_COUNT
; --idx
>= 0; )
5397 if (STRNCMP(end
, spo_name_tab
[idx
], 3) == 0)
5401 p
= &(ci
->sp_offsets
[idx
]);
5402 if (idx
!= SPO_LC_OFF
)
5407 case 'e': idx
+= SPO_COUNT
; break;
5408 default: idx
= -1; break;
5412 ci
->sp_off_flags
|= (1 << idx
);
5413 if (idx
== SPO_LC_OFF
) /* lc=99 */
5416 *p
= getdigits(&end
);
5418 /* "lc=" offset automatically sets "ms=" offset */
5419 if (!(ci
->sp_off_flags
& (1 << SPO_MS_OFF
)))
5421 ci
->sp_off_flags
|= (1 << SPO_MS_OFF
);
5422 ci
->sp_offsets
[SPO_MS_OFF
] = *p
;
5431 *p
= getdigits(&end
); /* positive offset */
5433 else if (*end
== '-')
5436 *p
= -getdigits(&end
); /* negative offset */
5446 if (!ends_excmd(*end
) && !vim_iswhite(*end
))
5448 EMSG2(_("E402: Garbage after pattern: %s"), arg
);
5451 return skipwhite(end
);
5455 * Handle ":syntax sync .." command.
5458 syn_cmd_sync(eap
, syncing
)
5462 char_u
*arg_start
= eap
->arg
;
5466 int illegal
= FALSE
;
5467 int finished
= FALSE
;
5471 if (ends_excmd(*arg_start
))
5473 syn_cmd_list(eap
, TRUE
);
5477 while (!ends_excmd(*arg_start
))
5479 arg_end
= skiptowhite(arg_start
);
5480 next_arg
= skipwhite(arg_end
);
5482 key
= vim_strnsave_up(arg_start
, (int)(arg_end
- arg_start
));
5483 if (STRCMP(key
, "CCOMMENT") == 0)
5486 curbuf
->b_syn_sync_flags
|= SF_CCOMMENT
;
5487 if (!ends_excmd(*next_arg
))
5489 arg_end
= skiptowhite(next_arg
);
5491 curbuf
->b_syn_sync_id
= syn_check_group(next_arg
,
5492 (int)(arg_end
- next_arg
));
5493 next_arg
= skipwhite(arg_end
);
5495 else if (!eap
->skip
)
5496 curbuf
->b_syn_sync_id
= syn_name2id((char_u
*)"Comment");
5498 else if ( STRNCMP(key
, "LINES", 5) == 0
5499 || STRNCMP(key
, "MINLINES", 8) == 0
5500 || STRNCMP(key
, "MAXLINES", 8) == 0
5501 || STRNCMP(key
, "LINEBREAKS", 10) == 0)
5505 else if (key
[0] == 'L')
5509 if (arg_end
[-1] != '=' || !VIM_ISDIGIT(*arg_end
))
5514 n
= getdigits(&arg_end
);
5518 curbuf
->b_syn_sync_linebreaks
= n
;
5519 else if (key
[1] == 'A')
5520 curbuf
->b_syn_sync_maxlines
= n
;
5522 curbuf
->b_syn_sync_minlines
= n
;
5525 else if (STRCMP(key
, "FROMSTART") == 0)
5529 curbuf
->b_syn_sync_minlines
= MAXLNUM
;
5530 curbuf
->b_syn_sync_maxlines
= 0;
5533 else if (STRCMP(key
, "LINECONT") == 0)
5535 if (curbuf
->b_syn_linecont_pat
!= NULL
)
5537 EMSG(_("E403: syntax sync: line continuations pattern specified twice"));
5541 arg_end
= skip_regexp(next_arg
+ 1, *next_arg
, TRUE
, NULL
);
5542 if (*arg_end
!= *next_arg
) /* end delimiter not found */
5550 /* store the pattern and compiled regexp program */
5551 if ((curbuf
->b_syn_linecont_pat
= vim_strnsave(next_arg
+ 1,
5552 (int)(arg_end
- next_arg
- 1))) == NULL
)
5557 curbuf
->b_syn_linecont_ic
= curbuf
->b_syn_ic
;
5559 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5561 p_cpo
= (char_u
*)"";
5562 curbuf
->b_syn_linecont_prog
=
5563 vim_regcomp(curbuf
->b_syn_linecont_pat
, RE_MAGIC
);
5566 if (curbuf
->b_syn_linecont_prog
== NULL
)
5568 vim_free(curbuf
->b_syn_linecont_pat
);
5569 curbuf
->b_syn_linecont_pat
= NULL
;
5574 next_arg
= skipwhite(arg_end
+ 1);
5578 eap
->arg
= next_arg
;
5579 if (STRCMP(key
, "MATCH") == 0)
5580 syn_cmd_match(eap
, TRUE
);
5581 else if (STRCMP(key
, "REGION") == 0)
5582 syn_cmd_region(eap
, TRUE
);
5583 else if (STRCMP(key
, "CLEAR") == 0)
5584 syn_cmd_clear(eap
, TRUE
);
5590 arg_start
= next_arg
;
5594 EMSG2(_("E404: Illegal arguments: %s"), arg_start
);
5597 eap
->nextcmd
= check_nextcmd(arg_start
);
5598 redraw_curbuf_later(SOME_VALID
);
5599 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
5604 * Convert a line of highlight group names into a list of group ID numbers.
5605 * "arg" should point to the "contains" or "nextgroup" keyword.
5606 * "arg" is advanced to after the last group name.
5607 * Careful: the argument is modified (NULs added).
5608 * returns FAIL for some error, OK for success.
5611 get_id_list(arg
, keylen
, list
)
5613 int keylen
; /* length of keyword */
5614 short **list
; /* where to store the resulting list, if not
5615 NULL, the list is silently skipped! */
5621 int total_count
= 0;
5622 short *retval
= NULL
;
5624 regmatch_T regmatch
;
5630 * We parse the list twice:
5631 * round == 1: count the number of items, allocate the array.
5632 * round == 2: fill the array with the items.
5633 * In round 1 new groups may be added, causing the number of items to
5634 * grow when a regexp is used. In that case round 1 is done once again.
5636 for (round
= 1; round
<= 2; ++round
)
5641 p
= skipwhite(*arg
+ keylen
);
5644 EMSG2(_("E405: Missing equal sign: %s"), *arg
);
5647 p
= skipwhite(p
+ 1);
5650 EMSG2(_("E406: Empty argument: %s"), *arg
);
5655 * parse the arguments after "contains"
5658 while (!ends_excmd(*p
))
5660 for (end
= p
; *end
&& !vim_iswhite(*end
) && *end
!= ','; ++end
)
5662 name
= alloc((int)(end
- p
+ 3)); /* leave room for "^$" */
5668 vim_strncpy(name
+ 1, p
, end
- p
);
5669 if ( STRCMP(name
+ 1, "ALLBUT") == 0
5670 || STRCMP(name
+ 1, "ALL") == 0
5671 || STRCMP(name
+ 1, "TOP") == 0
5672 || STRCMP(name
+ 1, "CONTAINED") == 0)
5674 if (TOUPPER_ASC(**arg
) != 'C')
5676 EMSG2(_("E407: %s not allowed here"), name
+ 1);
5683 EMSG2(_("E408: %s must be first in contains list"), name
+ 1);
5690 else if (name
[1] == 'T')
5693 id
= SYNID_CONTAINED
;
5694 id
+= current_syn_inc_tag
;
5696 else if (name
[1] == '@')
5698 id
= syn_check_cluster(name
+ 2, (int)(end
- p
- 1));
5703 * Handle full group name.
5705 if (vim_strpbrk(name
+ 1, (char_u
*)"\\.*^$~[") == NULL
)
5706 id
= syn_check_group(name
+ 1, (int)(end
- p
));
5710 * Handle match of regexp with group names.
5714 regmatch
.regprog
= vim_regcomp(name
, RE_MAGIC
);
5715 if (regmatch
.regprog
== NULL
)
5722 regmatch
.rm_ic
= TRUE
;
5724 for (i
= highlight_ga
.ga_len
; --i
>= 0; )
5726 if (vim_regexec(®match
, HL_TABLE()[i
].sg_name
,
5731 /* Got more items than expected; can happen
5732 * when adding items that match:
5733 * "contains=a.*b,axb".
5734 * Go back to first round */
5735 if (count
>= total_count
)
5741 retval
[count
] = i
+ 1;
5744 id
= -1; /* remember that we found one */
5747 vim_free(regmatch
.regprog
);
5753 EMSG2(_("E409: Unknown group name: %s"), p
);
5761 /* Got more items than expected, go back to first round */
5762 if (count
>= total_count
)
5775 p
= skipwhite(p
+ 1); /* skip comma in between arguments */
5781 retval
= (short *)alloc((unsigned)((count
+ 1) * sizeof(short)));
5784 retval
[count
] = 0; /* zero means end of the list */
5785 total_count
= count
;
5790 if (failed
|| retval
== NULL
)
5799 vim_free(retval
); /* list already found, don't overwrite it */
5805 * Make a copy of an ID list.
5818 for (count
= 0; list
[count
]; ++count
)
5820 len
= (count
+ 1) * sizeof(short);
5821 retval
= (short *)alloc((unsigned)len
);
5823 mch_memmove(retval
, list
, (size_t)len
);
5829 * Check if syntax group "ssp" is in the ID list "list" of "cur_si".
5830 * "cur_si" can be NULL if not checking the "containedin" list.
5831 * Used to check if a syntax item is in the "contains" or "nextgroup" list of
5833 * This function is called very often, keep it fast!!
5836 in_id_list(cur_si
, list
, ssp
, contained
)
5837 stateitem_T
*cur_si
; /* current item or NULL */
5838 short *list
; /* id list */
5839 struct sp_syn
*ssp
; /* group id and ":syn include" tag of group */
5840 int contained
; /* group id is contained */
5846 static int depth
= 0;
5849 /* If spp has a "containedin" list and "cur_si" is in it, return TRUE. */
5850 if (cur_si
!= NULL
&& ssp
->cont_in_list
!= NULL
5851 && !(cur_si
->si_flags
& HL_MATCH
))
5853 /* Ignore transparent items without a contains argument. Double check
5854 * that we don't go back past the first one. */
5855 while ((cur_si
->si_flags
& HL_TRANS_CONT
)
5856 && cur_si
> (stateitem_T
*)(current_state
.ga_data
))
5858 /* cur_si->si_idx is -1 for keywords, these never contain anything. */
5859 if (cur_si
->si_idx
>= 0 && in_id_list(NULL
, ssp
->cont_in_list
,
5860 &(SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_syn
),
5861 SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_flags
& HL_CONTAINED
))
5869 * If list is ID_LIST_ALL, we are in a transparent item that isn't
5870 * inside anything. Only allow not-contained groups.
5872 if (list
== ID_LIST_ALL
)
5876 * If the first item is "ALLBUT", return TRUE if "id" is NOT in the
5877 * contains list. We also require that "id" is at the same ":syn include"
5878 * level as the list.
5881 if (item
>= SYNID_ALLBUT
&& item
< SYNID_CLUSTER
)
5883 if (item
< SYNID_TOP
)
5885 /* ALL or ALLBUT: accept all groups in the same file */
5886 if (item
- SYNID_ALLBUT
!= ssp
->inc_tag
)
5889 else if (item
< SYNID_CONTAINED
)
5891 /* TOP: accept all not-contained groups in the same file */
5892 if (item
- SYNID_TOP
!= ssp
->inc_tag
|| contained
)
5897 /* CONTAINED: accept all contained groups in the same file */
5898 if (item
- SYNID_CONTAINED
!= ssp
->inc_tag
|| !contained
)
5908 * Return "retval" if id is in the contains list.
5914 if (item
>= SYNID_CLUSTER
)
5916 scl_list
= SYN_CLSTR(syn_buf
)[item
- SYNID_CLUSTER
].scl_list
;
5917 /* restrict recursiveness to 30 to avoid an endless loop for a
5918 * cluster that includes itself (indirectly) */
5919 if (scl_list
!= NULL
&& depth
< 30)
5922 r
= in_id_list(NULL
, scl_list
, ssp
, contained
);
5935 char *name
; /* subcommand name */
5936 void (*func
)__ARGS((exarg_T
*, int)); /* function to call */
5939 static struct subcommand subcommands
[] =
5941 {"case", syn_cmd_case
},
5942 {"clear", syn_cmd_clear
},
5943 {"cluster", syn_cmd_cluster
},
5944 {"enable", syn_cmd_enable
},
5945 {"include", syn_cmd_include
},
5946 {"keyword", syn_cmd_keyword
},
5947 {"list", syn_cmd_list
},
5948 {"manual", syn_cmd_manual
},
5949 {"match", syn_cmd_match
},
5951 {"off", syn_cmd_off
},
5952 {"region", syn_cmd_region
},
5953 {"reset", syn_cmd_reset
},
5954 {"spell", syn_cmd_spell
},
5955 {"sync", syn_cmd_sync
},
5962 * This searches the subcommands[] table for the subcommand name, and calls a
5963 * syntax_subcommand() function to do the rest.
5969 char_u
*arg
= eap
->arg
;
5971 char_u
*subcmd_name
;
5974 syn_cmdlinep
= eap
->cmdlinep
;
5976 /* isolate subcommand name */
5977 for (subcmd_end
= arg
; ASCII_ISALPHA(*subcmd_end
); ++subcmd_end
)
5979 subcmd_name
= vim_strnsave(arg
, (int)(subcmd_end
- arg
));
5980 if (subcmd_name
!= NULL
)
5982 if (eap
->skip
) /* skip error messages for all subcommands */
5986 if (subcommands
[i
].name
== NULL
)
5988 EMSG2(_("E410: Invalid :syntax subcommand: %s"), subcmd_name
);
5991 if (STRCMP(subcmd_name
, (char_u
*)subcommands
[i
].name
) == 0)
5993 eap
->arg
= skipwhite(subcmd_end
);
5994 (subcommands
[i
].func
)(eap
, FALSE
);
5998 vim_free(subcmd_name
);
6008 return (buf
->b_syn_patterns
.ga_len
!= 0
6009 || buf
->b_syn_clusters
.ga_len
!= 0
6010 || buf
->b_keywtab
.ht_used
> 0
6011 || buf
->b_keywtab_ic
.ht_used
> 0);
6014 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
6018 EXP_SUBCMD
, /* expand ":syn" sub-commands */
6019 EXP_CASE
/* expand ":syn case" arguments */
6023 * Reset include_link, include_default, include_none to 0.
6024 * Called when we are done expanding.
6027 reset_expand_highlight()
6029 include_link
= include_default
= include_none
= 0;
6033 * Handle command line completion for :match and :echohl command: Add "None"
6034 * as highlight group.
6037 set_context_in_echohl_cmd(xp
, arg
)
6041 xp
->xp_context
= EXPAND_HIGHLIGHT
;
6042 xp
->xp_pattern
= arg
;
6047 * Handle command line completion for :syntax command.
6050 set_context_in_syntax_cmd(xp
, arg
)
6056 /* Default: expand subcommands */
6057 xp
->xp_context
= EXPAND_SYNTAX
;
6058 expand_what
= EXP_SUBCMD
;
6059 xp
->xp_pattern
= arg
;
6061 include_default
= 0;
6063 /* (part of) subcommand already typed */
6066 p
= skiptowhite(arg
);
6067 if (*p
!= NUL
) /* past first word */
6069 xp
->xp_pattern
= skipwhite(p
);
6070 if (*skiptowhite(xp
->xp_pattern
) != NUL
)
6071 xp
->xp_context
= EXPAND_NOTHING
;
6072 else if (STRNICMP(arg
, "case", p
- arg
) == 0)
6073 expand_what
= EXP_CASE
;
6074 else if ( STRNICMP(arg
, "keyword", p
- arg
) == 0
6075 || STRNICMP(arg
, "region", p
- arg
) == 0
6076 || STRNICMP(arg
, "match", p
- arg
) == 0
6077 || STRNICMP(arg
, "list", p
- arg
) == 0)
6078 xp
->xp_context
= EXPAND_HIGHLIGHT
;
6080 xp
->xp_context
= EXPAND_NOTHING
;
6085 static char *(case_args
[]) = {"match", "ignore", NULL
};
6088 * Function given to ExpandGeneric() to obtain the list syntax names for
6092 get_syntax_name(xp
, idx
)
6093 expand_T
*xp UNUSED
;
6096 if (expand_what
== EXP_SUBCMD
)
6097 return (char_u
*)subcommands
[idx
].name
;
6098 return (char_u
*)case_args
[idx
];
6101 #endif /* FEAT_CMDL_COMPL */
6104 * Function called for expression evaluation: get syntax ID at file position.
6107 syn_get_id(wp
, lnum
, col
, trans
, spellp
, keep_state
)
6111 int trans
; /* remove transparency */
6112 int *spellp
; /* return: can do spell checking */
6113 int keep_state
; /* keep state of char at "col" */
6115 /* When the position is not after the current position and in the same
6116 * line of the same buffer, need to restart parsing. */
6117 if (wp
->w_buffer
!= syn_buf
6118 || lnum
!= current_lnum
6119 || col
< current_col
)
6120 syntax_start(wp
, lnum
);
6122 (void)get_syntax_attr(col
, spellp
, keep_state
);
6124 return (trans
? current_trans_id
: current_id
);
6127 #if defined(FEAT_EVAL) || defined(PROTO)
6129 * Return the syntax ID at position "i" in the current stack.
6130 * The caller must have called syn_get_id() before to fill the stack.
6131 * Returns -1 when "i" is out of range.
6134 syn_get_stack_item(i
)
6137 if (i
>= current_state
.ga_len
)
6139 /* Need to invalidate the state, because we didn't properly finish it
6140 * for the last character, "keep_state" was TRUE. */
6141 invalidate_current_state();
6142 current_col
= MAXCOL
;
6145 return CUR_STATE(i
).si_id
;
6149 #if defined(FEAT_FOLDING) || defined(PROTO)
6151 * Function called to get folding level for line "lnum" in window "wp".
6154 syn_get_foldlevel(wp
, lnum
)
6161 /* Return quickly when there are no fold items at all. */
6162 if (wp
->w_buffer
->b_syn_folditems
!= 0)
6164 syntax_start(wp
, lnum
);
6166 for (i
= 0; i
< current_state
.ga_len
; ++i
)
6167 if (CUR_STATE(i
).si_flags
& HL_FOLD
)
6170 if (level
> wp
->w_p_fdn
)
6172 level
= wp
->w_p_fdn
;
6180 #endif /* FEAT_SYN_HL */
6183 /**************************************
6184 * Highlighting stuff *
6185 **************************************/
6188 * The default highlight groups. These are compiled-in for fast startup and
6189 * they still work when the runtime files can't be found.
6190 * When making changes here, also change runtime/colors/default.vim!
6191 * The #ifdefs are needed to reduce the amount of static data. Helps to make
6192 * the 16 bit DOS (museum) version compile.
6195 # define CENT(a, b) b
6197 # define CENT(a, b) a
6199 static char *(highlight_init_both
[]) =
6201 CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White",
6202 "ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"),
6203 #ifdef FEAT_SEARCH_EXTRA
6204 CENT("IncSearch term=reverse cterm=reverse",
6205 "IncSearch term=reverse cterm=reverse gui=reverse"),
6207 CENT("ModeMsg term=bold cterm=bold",
6208 "ModeMsg term=bold cterm=bold gui=bold"),
6209 CENT("NonText term=bold ctermfg=Blue",
6210 "NonText term=bold ctermfg=Blue gui=bold guifg=Blue"),
6211 CENT("StatusLine term=reverse,bold cterm=reverse,bold",
6212 "StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"),
6213 CENT("StatusLineNC term=reverse cterm=reverse",
6214 "StatusLineNC term=reverse cterm=reverse gui=reverse"),
6215 #ifdef FEAT_VERTSPLIT
6216 CENT("VertSplit term=reverse cterm=reverse",
6217 "VertSplit term=reverse cterm=reverse gui=reverse"),
6219 #ifdef FEAT_CLIPBOARD
6220 CENT("VisualNOS term=underline,bold cterm=underline,bold",
6221 "VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"),
6224 CENT("DiffText term=reverse cterm=bold ctermbg=Red",
6225 "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"),
6227 #ifdef FEAT_INS_EXPAND
6228 CENT("PmenuThumb cterm=reverse",
6229 "PmenuThumb cterm=reverse gui=reverse"),
6230 CENT("PmenuSbar ctermbg=Grey",
6231 "PmenuSbar ctermbg=Grey guibg=Grey"),
6234 CENT("TabLineSel term=bold cterm=bold",
6235 "TabLineSel term=bold cterm=bold gui=bold"),
6236 CENT("TabLineFill term=reverse cterm=reverse",
6237 "TabLineFill term=reverse cterm=reverse gui=reverse"),
6240 "Cursor guibg=fg guifg=bg",
6241 "lCursor guibg=fg guifg=bg", /* should be different, but what? */
6246 static char *(highlight_init_light
[]) =
6248 CENT("Directory term=bold ctermfg=DarkBlue",
6249 "Directory term=bold ctermfg=DarkBlue guifg=Blue"),
6250 CENT("LineNr term=underline ctermfg=Brown",
6251 "LineNr term=underline ctermfg=Brown guifg=Brown"),
6252 CENT("MoreMsg term=bold ctermfg=DarkGreen",
6253 "MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6254 CENT("Question term=standout ctermfg=DarkGreen",
6255 "Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6256 CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE",
6257 "Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"),
6259 CENT("SpellBad term=reverse ctermbg=LightRed",
6260 "SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"),
6261 CENT("SpellCap term=reverse ctermbg=LightBlue",
6262 "SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"),
6263 CENT("SpellRare term=reverse ctermbg=LightMagenta",
6264 "SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"),
6265 CENT("SpellLocal term=underline ctermbg=Cyan",
6266 "SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"),
6268 #ifdef FEAT_INS_EXPAND
6269 CENT("Pmenu ctermbg=LightMagenta",
6270 "Pmenu ctermbg=LightMagenta guibg=LightMagenta"),
6271 CENT("PmenuSel ctermbg=LightGrey",
6272 "PmenuSel ctermbg=LightGrey guibg=Grey"),
6274 CENT("SpecialKey term=bold ctermfg=DarkBlue",
6275 "SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"),
6276 CENT("Title term=bold ctermfg=DarkMagenta",
6277 "Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"),
6278 CENT("WarningMsg term=standout ctermfg=DarkRed",
6279 "WarningMsg term=standout ctermfg=DarkRed guifg=Red"),
6280 #ifdef FEAT_WILDMENU
6281 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6282 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6285 CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue",
6286 "Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"),
6287 CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6288 "FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6291 CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6292 "SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6295 CENT("Visual term=reverse",
6296 "Visual term=reverse guibg=LightGrey"),
6299 CENT("DiffAdd term=bold ctermbg=LightBlue",
6300 "DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"),
6301 CENT("DiffChange term=bold ctermbg=LightMagenta",
6302 "DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"),
6303 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan",
6304 "DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"),
6307 CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey",
6308 "TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"),
6311 CENT("CursorColumn term=reverse ctermbg=LightGrey",
6312 "CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"),
6313 CENT("CursorLine term=underline cterm=underline",
6314 "CursorLine term=underline cterm=underline guibg=Grey90"),
6317 CENT("MatchParen term=reverse ctermbg=Cyan",
6318 "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"),
6326 static char *(highlight_init_dark
[]) =
6328 CENT("Directory term=bold ctermfg=LightCyan",
6329 "Directory term=bold ctermfg=LightCyan guifg=Cyan"),
6330 CENT("LineNr term=underline ctermfg=Yellow",
6331 "LineNr term=underline ctermfg=Yellow guifg=Yellow"),
6332 CENT("MoreMsg term=bold ctermfg=LightGreen",
6333 "MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"),
6334 CENT("Question term=standout ctermfg=LightGreen",
6335 "Question term=standout ctermfg=LightGreen gui=bold guifg=Green"),
6336 CENT("Search term=reverse ctermbg=Yellow ctermfg=Black",
6337 "Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6338 CENT("SpecialKey term=bold ctermfg=LightBlue",
6339 "SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"),
6341 CENT("SpellBad term=reverse ctermbg=Red",
6342 "SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"),
6343 CENT("SpellCap term=reverse ctermbg=Blue",
6344 "SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"),
6345 CENT("SpellRare term=reverse ctermbg=Magenta",
6346 "SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"),
6347 CENT("SpellLocal term=underline ctermbg=Cyan",
6348 "SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"),
6350 #ifdef FEAT_INS_EXPAND
6351 CENT("Pmenu ctermbg=Magenta",
6352 "Pmenu ctermbg=Magenta guibg=Magenta"),
6353 CENT("PmenuSel ctermbg=DarkGrey",
6354 "PmenuSel ctermbg=DarkGrey guibg=DarkGrey"),
6356 CENT("Title term=bold ctermfg=LightMagenta",
6357 "Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"),
6358 CENT("WarningMsg term=standout ctermfg=LightRed",
6359 "WarningMsg term=standout ctermfg=LightRed guifg=Red"),
6360 #ifdef FEAT_WILDMENU
6361 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6362 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6365 CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan",
6366 "Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"),
6367 CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6368 "FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6371 CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6372 "SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6375 CENT("Visual term=reverse",
6376 "Visual term=reverse guibg=DarkGrey"),
6379 CENT("DiffAdd term=bold ctermbg=DarkBlue",
6380 "DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"),
6381 CENT("DiffChange term=bold ctermbg=DarkMagenta",
6382 "DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"),
6383 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan",
6384 "DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"),
6387 CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey",
6388 "TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"),
6391 CENT("CursorColumn term=reverse ctermbg=DarkGrey",
6392 "CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"),
6393 CENT("CursorLine term=underline cterm=underline",
6394 "CursorLine term=underline cterm=underline guibg=Grey40"),
6397 CENT("MatchParen term=reverse ctermbg=DarkCyan",
6398 "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"),
6407 init_highlight(both
, reset
)
6408 int both
; /* include groups where 'bg' doesn't matter */
6409 int reset
; /* clear group first */
6413 static int had_both
= FALSE
;
6418 * Try finding the color scheme file. Used when a color file was loaded
6419 * and 'background' or 't_Co' is changed.
6421 p
= get_var_value((char_u
*)"g:colors_name");
6422 if (p
!= NULL
&& load_colors(p
) == OK
)
6427 * Didn't use a color file, use the compiled-in colors.
6432 pp
= highlight_init_both
;
6433 for (i
= 0; pp
[i
] != NULL
; ++i
)
6434 do_highlight((char_u
*)pp
[i
], reset
, TRUE
);
6437 /* Don't do anything before the call with both == TRUE from main().
6438 * Not everything has been setup then, and that call will overrule
6439 * everything anyway. */
6443 pp
= highlight_init_light
;
6445 pp
= highlight_init_dark
;
6446 for (i
= 0; pp
[i
] != NULL
; ++i
)
6447 do_highlight((char_u
*)pp
[i
], reset
, TRUE
);
6449 /* Reverse looks ugly, but grey may not work for 8 colors. Thus let it
6450 * depend on the number of colors available.
6451 * With 8 colors brown is equal to yellow, need to use black for Search fg
6452 * to avoid Statement highlighted text disappears.
6453 * Clear the attributes, needed when changing the t_Co value. */
6455 do_highlight((char_u
*)(*p_bg
== 'l'
6456 ? "Visual cterm=NONE ctermbg=LightGrey"
6457 : "Visual cterm=NONE ctermbg=DarkGrey"), FALSE
, TRUE
);
6460 do_highlight((char_u
*)"Visual cterm=reverse ctermbg=NONE",
6463 do_highlight((char_u
*)"Search ctermfg=black", FALSE
, TRUE
);
6468 * If syntax highlighting is enabled load the highlighting for it.
6470 if (get_var_value((char_u
*)"g:syntax_on") != NULL
)
6472 static int recursive
= 0;
6475 EMSG(_("E679: recursive loop loading syncolor.vim"));
6479 (void)source_runtime((char_u
*)"syntax/syncolor.vim", TRUE
);
6487 * Load color file "name".
6488 * Return OK for success, FAIL for failure.
6496 static int recursive
= FALSE
;
6498 /* When being called recursively, this is probably because setting
6499 * 'background' caused the highlighting to be reloaded. This means it is
6500 * working, thus we should return OK. */
6505 buf
= alloc((unsigned)(STRLEN(name
) + 12));
6508 sprintf((char *)buf
, "colors/%s.vim", name
);
6509 retval
= source_runtime(buf
, FALSE
);
6512 apply_autocmds(EVENT_COLORSCHEME
, NULL
, NULL
, FALSE
, curbuf
);
6521 * Handle the ":highlight .." command.
6522 * When using ":hi clear" this is called recursively for each group with
6523 * "forceit" and "init" both TRUE.
6526 do_highlight(line
, forceit
, init
)
6529 int init
; /* TRUE when called for initializing */
6536 char_u
*key
= NULL
, *arg
= NULL
;
6543 int dodefault
= FALSE
;
6544 int doclear
= FALSE
;
6548 int is_normal_group
= FALSE
; /* "Normal" group */
6550 int is_menu_group
= FALSE
; /* "Menu" group */
6551 int is_scrollbar_group
= FALSE
; /* "Scrollbar" group */
6552 int is_tooltip_group
= FALSE
; /* "Tooltip" group */
6553 int do_colors
= FALSE
; /* need to update colors? */
6555 # define is_menu_group 0
6556 # define is_tooltip_group 0
6560 * If no argument, list current highlighting.
6562 if (ends_excmd(*line
))
6564 for (i
= 1; i
<= highlight_ga
.ga_len
&& !got_int
; ++i
)
6565 /* TODO: only call when the group has attributes set */
6566 highlight_list_one((int)i
);
6573 name_end
= skiptowhite(line
);
6574 linep
= skipwhite(name_end
);
6577 * Check for "default" argument.
6579 if (STRNCMP(line
, "default", name_end
- line
) == 0)
6583 name_end
= skiptowhite(line
);
6584 linep
= skipwhite(name_end
);
6588 * Check for "clear" or "link" argument.
6590 if (STRNCMP(line
, "clear", name_end
- line
) == 0)
6592 if (STRNCMP(line
, "link", name_end
- line
) == 0)
6596 * ":highlight {group-name}": list highlighting for one group.
6598 if (!doclear
&& !dolink
&& ends_excmd(*linep
))
6600 id
= syn_namen2id(line
, (int)(name_end
- line
));
6602 EMSG2(_("E411: highlight group not found: %s"), line
);
6604 highlight_list_one(id
);
6609 * Handle ":highlight link {from} {to}" command.
6613 char_u
*from_start
= linep
;
6620 from_end
= skiptowhite(from_start
);
6621 to_start
= skipwhite(from_end
);
6622 to_end
= skiptowhite(to_start
);
6624 if (ends_excmd(*from_start
) || ends_excmd(*to_start
))
6626 EMSG2(_("E412: Not enough arguments: \":highlight link %s\""),
6631 if (!ends_excmd(*skipwhite(to_end
)))
6633 EMSG2(_("E413: Too many arguments: \":highlight link %s\""), from_start
);
6637 from_id
= syn_check_group(from_start
, (int)(from_end
- from_start
));
6638 if (STRNCMP(to_start
, "NONE", 4) == 0)
6641 to_id
= syn_check_group(to_start
, (int)(to_end
- to_start
));
6643 if (from_id
> 0 && (!init
|| HL_TABLE()[from_id
- 1].sg_set
== 0))
6646 * Don't allow a link when there already is some highlighting
6647 * for the group, unless '!' is used
6649 if (to_id
> 0 && !forceit
&& !init
6650 && hl_has_settings(from_id
- 1, dodefault
))
6652 if (sourcing_name
== NULL
&& !dodefault
)
6653 EMSG(_("E414: group has settings, highlight link ignored"));
6658 HL_TABLE()[from_id
- 1].sg_set
|= SG_LINK
;
6659 HL_TABLE()[from_id
- 1].sg_link
= to_id
;
6661 HL_TABLE()[from_id
- 1].sg_scriptID
= current_SID
;
6663 redraw_all_later(SOME_VALID
);
6667 /* Only call highlight_changed() once, after sourcing a syntax file */
6668 need_highlight_changed
= TRUE
;
6676 * ":highlight clear [group]" command.
6679 if (ends_excmd(*line
))
6682 /* First, we do not destroy the old values, but allocate the new
6683 * ones and update the display. THEN we destroy the old values.
6684 * If we destroy the old values first, then the old values
6685 * (such as GuiFont's or GuiFontset's) will still be displayed but
6686 * invalid because they were free'd.
6690 # ifdef FEAT_BEVAL_TIP
6691 gui_init_tooltip_font();
6693 # if defined(FEAT_MENU) && (defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MOTIF))
6694 gui_init_menu_font();
6697 # if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11)
6698 gui_mch_def_colors();
6700 # ifdef FEAT_GUI_X11
6703 /* This only needs to be done when there is no Menu highlight
6704 * group defined by default, which IS currently the case.
6706 gui_mch_new_menu_colors();
6710 gui_new_scrollbar_colors();
6712 gui_mch_new_tooltip_colors();
6715 gui_mch_new_menu_font();
6720 /* Ok, we're done allocating the new default graphics items.
6721 * The screen should already be refreshed at this point.
6722 * It is now Ok to clear out the old data.
6726 do_unlet((char_u
*)"colors_name", TRUE
);
6728 restore_cterm_colors();
6731 * Clear all default highlight groups and load the defaults.
6733 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
6734 highlight_clear(idx
);
6735 init_highlight(TRUE
, TRUE
);
6738 highlight_gui_started();
6740 highlight_changed();
6741 redraw_later_clear();
6744 name_end
= skiptowhite(line
);
6745 linep
= skipwhite(name_end
);
6749 * Find the group name in the table. If it does not exist yet, add it.
6751 id
= syn_check_group(line
, (int)(name_end
- line
));
6752 if (id
== 0) /* failed (out of memory) */
6754 idx
= id
- 1; /* index is ID minus one */
6756 /* Return if "default" was used and the group already has settings. */
6757 if (dodefault
&& hl_has_settings(idx
, TRUE
))
6760 if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "NORMAL") == 0)
6761 is_normal_group
= TRUE
;
6763 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "MENU") == 0)
6764 is_menu_group
= TRUE
;
6765 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "SCROLLBAR") == 0)
6766 is_scrollbar_group
= TRUE
;
6767 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "TOOLTIP") == 0)
6768 is_tooltip_group
= TRUE
;
6771 /* Clear the highlighting for ":hi clear {group}" and ":hi clear". */
6772 if (doclear
|| (forceit
&& init
))
6774 highlight_clear(idx
);
6776 HL_TABLE()[idx
].sg_set
= 0;
6780 while (!ends_excmd(*linep
))
6785 EMSG2(_("E415: unexpected equal sign: %s"), key_start
);
6791 * Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" or
6794 while (*linep
&& !vim_iswhite(*linep
) && *linep
!= '=')
6797 key
= vim_strnsave_up(key_start
, (int)(linep
- key_start
));
6803 linep
= skipwhite(linep
);
6805 if (STRCMP(key
, "NONE") == 0)
6807 if (!init
|| HL_TABLE()[idx
].sg_set
== 0)
6810 HL_TABLE()[idx
].sg_set
|= SG_TERM
+SG_CTERM
+SG_GUI
;
6811 highlight_clear(idx
);
6817 * Check for the equal sign.
6821 EMSG2(_("E416: missing equal sign: %s"), key_start
);
6828 * Isolate the argument.
6830 linep
= skipwhite(linep
);
6831 if (*linep
== '\'') /* guifg='color name' */
6833 arg_start
= ++linep
;
6834 linep
= vim_strchr(linep
, '\'');
6837 EMSG2(_(e_invarg2
), key_start
);
6845 linep
= skiptowhite(linep
);
6847 if (linep
== arg_start
)
6849 EMSG2(_("E417: missing argument: %s"), key_start
);
6854 arg
= vim_strnsave(arg_start
, (int)(linep
- arg_start
));
6864 * Store the argument.
6866 if ( STRCMP(key
, "TERM") == 0
6867 || STRCMP(key
, "CTERM") == 0
6868 || STRCMP(key
, "GUI") == 0)
6872 while (arg
[off
] != NUL
)
6874 for (i
= sizeof(hl_attr_table
) / sizeof(int); --i
>= 0; )
6876 len
= (int)STRLEN(hl_name_table
[i
]);
6877 if (STRNICMP(arg
+ off
, hl_name_table
[i
], len
) == 0)
6879 attr
|= hl_attr_table
[i
];
6886 EMSG2(_("E418: Illegal value: %s"), arg
);
6890 if (arg
[off
] == ',') /* another one follows */
6897 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_TERM
))
6900 HL_TABLE()[idx
].sg_set
|= SG_TERM
;
6901 HL_TABLE()[idx
].sg_term
= attr
;
6904 else if (*key
== 'C')
6906 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_CTERM
))
6909 HL_TABLE()[idx
].sg_set
|= SG_CTERM
;
6910 HL_TABLE()[idx
].sg_cterm
= attr
;
6911 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
6917 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
6920 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
6921 HL_TABLE()[idx
].sg_gui
= attr
;
6926 else if (STRCMP(key
, "FONT") == 0)
6928 /* in non-GUI fonts are simply ignored */
6930 if (!gui
.shell_created
)
6932 /* GUI not started yet, always accept the name. */
6933 vim_free(HL_TABLE()[idx
].sg_font_name
);
6934 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6938 GuiFont temp_sg_font
= HL_TABLE()[idx
].sg_font
;
6939 # ifdef FEAT_XFONTSET
6940 GuiFontset temp_sg_fontset
= HL_TABLE()[idx
].sg_fontset
;
6942 /* First, save the current font/fontset.
6943 * Then try to allocate the font/fontset.
6944 * If the allocation fails, HL_TABLE()[idx].sg_font OR
6945 * sg_fontset will be set to NOFONT or NOFONTSET respectively.
6948 HL_TABLE()[idx
].sg_font
= NOFONT
;
6949 # ifdef FEAT_XFONTSET
6950 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
6952 hl_do_font(idx
, arg
, is_normal_group
, is_menu_group
,
6955 # ifdef FEAT_XFONTSET
6956 if (HL_TABLE()[idx
].sg_fontset
!= NOFONTSET
)
6958 /* New fontset was accepted. Free the old one, if there was
6961 gui_mch_free_fontset(temp_sg_fontset
);
6962 vim_free(HL_TABLE()[idx
].sg_font_name
);
6963 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6966 HL_TABLE()[idx
].sg_fontset
= temp_sg_fontset
;
6968 if (HL_TABLE()[idx
].sg_font
!= NOFONT
)
6970 /* New font was accepted. Free the old one, if there was
6973 gui_mch_free_font(temp_sg_font
);
6974 vim_free(HL_TABLE()[idx
].sg_font_name
);
6975 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6978 HL_TABLE()[idx
].sg_font
= temp_sg_font
;
6982 else if (STRCMP(key
, "CTERMFG") == 0 || STRCMP(key
, "CTERMBG") == 0)
6984 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_CTERM
))
6987 HL_TABLE()[idx
].sg_set
|= SG_CTERM
;
6989 /* When setting the foreground color, and previously the "bold"
6990 * flag was set for a light color, reset it now */
6991 if (key
[5] == 'F' && HL_TABLE()[idx
].sg_cterm_bold
)
6993 HL_TABLE()[idx
].sg_cterm
&= ~HL_BOLD
;
6994 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
6997 if (VIM_ISDIGIT(*arg
))
6998 color
= atoi((char *)arg
);
6999 else if (STRICMP(arg
, "fg") == 0)
7001 if (cterm_normal_fg_color
)
7002 color
= cterm_normal_fg_color
- 1;
7005 EMSG(_("E419: FG color unknown"));
7010 else if (STRICMP(arg
, "bg") == 0)
7012 if (cterm_normal_bg_color
> 0)
7013 color
= cterm_normal_bg_color
- 1;
7016 EMSG(_("E420: BG color unknown"));
7023 static char *(color_names
[28]) = {
7024 "Black", "DarkBlue", "DarkGreen", "DarkCyan",
7025 "DarkRed", "DarkMagenta", "Brown", "DarkYellow",
7027 "LightGray", "LightGrey", "DarkGray", "DarkGrey",
7028 "Blue", "LightBlue", "Green", "LightGreen",
7029 "Cyan", "LightCyan", "Red", "LightRed", "Magenta",
7030 "LightMagenta", "Yellow", "LightYellow", "White", "NONE"};
7031 static int color_numbers_16
[28] = {0, 1, 2, 3,
7037 13, 14, 14, 15, -1};
7038 /* for xterm with 88 colors... */
7039 static int color_numbers_88
[28] = {0, 4, 2, 6,
7045 75, 11, 78, 15, -1};
7046 /* for xterm with 256 colors... */
7047 static int color_numbers_256
[28] = {0, 4, 2, 6,
7052 14, 159, 9, 224, 13,
7053 225, 11, 229, 15, -1};
7054 /* for terminals with less than 16 colors... */
7055 static int color_numbers_8
[28] = {0, 4, 2, 6,
7060 6+8, 6+8, 1+8, 1+8, 5+8,
7061 5+8, 3+8, 3+8, 7+8, -1};
7062 #if defined(__QNXNTO__)
7063 static int *color_numbers_8_qansi
= color_numbers_8
;
7064 /* On qnx, the 8 & 16 color arrays are the same */
7065 if (STRNCMP(T_NAME
, "qansi", 5) == 0)
7066 color_numbers_8_qansi
= color_numbers_16
;
7069 /* reduce calls to STRICMP a bit, it can be slow */
7070 off
= TOUPPER_ASC(*arg
);
7071 for (i
= (sizeof(color_names
) / sizeof(char *)); --i
>= 0; )
7072 if (off
== color_names
[i
][0]
7073 && STRICMP(arg
+ 1, color_names
[i
] + 1) == 0)
7077 EMSG2(_("E421: Color name or number not recognized: %s"), key_start
);
7082 /* Use the _16 table to check if its a valid color name. */
7083 color
= color_numbers_16
[i
];
7088 /* t_Co is 8: use the 8 colors table */
7089 #if defined(__QNXNTO__)
7090 color
= color_numbers_8_qansi
[i
];
7092 color
= color_numbers_8
[i
];
7096 /* set/reset bold attribute to get light foreground
7097 * colors (on some terminals, e.g. "linux") */
7100 HL_TABLE()[idx
].sg_cterm
|= HL_BOLD
;
7101 HL_TABLE()[idx
].sg_cterm_bold
= TRUE
;
7104 HL_TABLE()[idx
].sg_cterm
&= ~HL_BOLD
;
7106 color
&= 7; /* truncate to 8 colors */
7108 else if (t_colors
== 16 || t_colors
== 88
7112 * Guess: if the termcap entry ends in 'm', it is
7113 * probably an xterm-like terminal. Use the changed
7120 if (*p
!= NUL
&& *(p
+ STRLEN(p
) - 1) == 'm')
7124 color
= color_numbers_8
[i
];
7127 color
= color_numbers_88
[i
];
7130 color
= color_numbers_256
[i
];
7136 /* Add one to the argument, to avoid zero */
7139 HL_TABLE()[idx
].sg_cterm_fg
= color
+ 1;
7140 if (is_normal_group
)
7142 cterm_normal_fg_color
= color
+ 1;
7143 cterm_normal_fg_bold
= (HL_TABLE()[idx
].sg_cterm
& HL_BOLD
);
7145 /* Don't do this if the GUI is used. */
7146 if (!gui
.in_use
&& !gui
.starting
)
7149 must_redraw
= CLEAR
;
7151 term_fg_color(color
);
7157 HL_TABLE()[idx
].sg_cterm_bg
= color
+ 1;
7158 if (is_normal_group
)
7160 cterm_normal_bg_color
= color
+ 1;
7162 /* Don't mess with 'background' if the GUI is used. */
7163 if (!gui
.in_use
&& !gui
.starting
)
7166 must_redraw
= CLEAR
;
7168 term_bg_color(color
);
7170 i
= (color
== 0 || color
== 4);
7172 i
= (color
< 7 || color
== 8);
7173 /* Set the 'background' option if the value is wrong. */
7174 if (i
!= (*p_bg
== 'd'))
7175 set_option_value((char_u
*)"bg", 0L,
7176 i
? (char_u
*)"dark" : (char_u
*)"light", 0);
7182 else if (STRCMP(key
, "GUIFG") == 0)
7184 #ifdef FEAT_GUI /* in non-GUI guifg colors are simply ignored */
7185 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7188 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7190 i
= color_name2handle(arg
);
7191 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7193 HL_TABLE()[idx
].sg_gui_fg
= i
;
7194 vim_free(HL_TABLE()[idx
].sg_gui_fg_name
);
7195 if (STRCMP(arg
, "NONE"))
7196 HL_TABLE()[idx
].sg_gui_fg_name
= vim_strsave(arg
);
7198 HL_TABLE()[idx
].sg_gui_fg_name
= NULL
;
7199 # ifdef FEAT_GUI_X11
7201 gui
.menu_fg_pixel
= i
;
7202 if (is_scrollbar_group
)
7203 gui
.scroll_fg_pixel
= i
;
7205 if (is_tooltip_group
)
7206 gui
.tooltip_fg_pixel
= i
;
7214 else if (STRCMP(key
, "GUIBG") == 0)
7216 #ifdef FEAT_GUI /* in non-GUI guibg colors are simply ignored */
7217 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7220 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7222 i
= color_name2handle(arg
);
7223 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7225 HL_TABLE()[idx
].sg_gui_bg
= i
;
7226 vim_free(HL_TABLE()[idx
].sg_gui_bg_name
);
7227 if (STRCMP(arg
, "NONE") != 0)
7228 HL_TABLE()[idx
].sg_gui_bg_name
= vim_strsave(arg
);
7230 HL_TABLE()[idx
].sg_gui_bg_name
= NULL
;
7231 # ifdef FEAT_GUI_X11
7233 gui
.menu_bg_pixel
= i
;
7234 if (is_scrollbar_group
)
7235 gui
.scroll_bg_pixel
= i
;
7237 if (is_tooltip_group
)
7238 gui
.tooltip_bg_pixel
= i
;
7246 else if (STRCMP(key
, "GUISP") == 0)
7248 #ifdef FEAT_GUI /* in non-GUI guisp colors are simply ignored */
7249 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7252 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7254 i
= color_name2handle(arg
);
7255 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7257 HL_TABLE()[idx
].sg_gui_sp
= i
;
7258 vim_free(HL_TABLE()[idx
].sg_gui_sp_name
);
7259 if (STRCMP(arg
, "NONE") != 0)
7260 HL_TABLE()[idx
].sg_gui_sp_name
= vim_strsave(arg
);
7262 HL_TABLE()[idx
].sg_gui_sp_name
= NULL
;
7267 else if (STRCMP(key
, "START") == 0 || STRCMP(key
, "STOP") == 0)
7273 HL_TABLE()[idx
].sg_set
|= SG_TERM
;
7276 * The "start" and "stop" arguments can be a literal escape
7277 * sequence, or a comma separated list of terminal codes.
7279 if (STRNCMP(arg
, "t_", 2) == 0)
7283 while (arg
[off
] != NUL
)
7285 /* Isolate one termcap name */
7286 for (len
= 0; arg
[off
+ len
] &&
7287 arg
[off
+ len
] != ','; ++len
)
7289 tname
= vim_strnsave(arg
+ off
, len
);
7290 if (tname
== NULL
) /* out of memory */
7295 /* lookup the escape sequence for the item */
7296 p
= get_term_code(tname
);
7298 if (p
== NULL
) /* ignore non-existing things */
7301 /* Append it to the already found stuff */
7302 if ((int)(STRLEN(buf
) + STRLEN(p
)) >= 99)
7304 EMSG2(_("E422: terminal code too long: %s"), arg
);
7310 /* Advance to the next item */
7312 if (arg
[off
] == ',') /* another one follows */
7319 * Copy characters from arg[] to buf[], translating <> codes.
7321 for (p
= arg
, off
= 0; off
< 100 && *p
; )
7323 len
= trans_special(&p
, buf
+ off
, FALSE
);
7324 if (len
) /* recognized special char */
7326 else /* copy as normal char */
7334 if (STRCMP(buf
, "NONE") == 0) /* resetting the value */
7337 p
= vim_strsave(buf
);
7340 vim_free(HL_TABLE()[idx
].sg_start
);
7341 HL_TABLE()[idx
].sg_start
= p
;
7345 vim_free(HL_TABLE()[idx
].sg_stop
);
7346 HL_TABLE()[idx
].sg_stop
= p
;
7351 EMSG2(_("E423: Illegal argument: %s"), key_start
);
7357 * When highlighting has been given for a group, don't link it.
7359 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_LINK
))
7360 HL_TABLE()[idx
].sg_link
= 0;
7363 * Continue with next argument.
7365 linep
= skipwhite(linep
);
7369 * If there is an error, and it's a new entry, remove it from the table.
7371 if (error
&& idx
== highlight_ga
.ga_len
)
7375 if (is_normal_group
)
7377 HL_TABLE()[idx
].sg_term_attr
= 0;
7378 HL_TABLE()[idx
].sg_cterm_attr
= 0;
7380 HL_TABLE()[idx
].sg_gui_attr
= 0;
7382 * Need to update all groups, because they might be using "bg"
7383 * and/or "fg", which have been changed now.
7386 highlight_gui_started();
7391 else if (is_menu_group
)
7393 if (gui
.in_use
&& do_colors
)
7394 gui_mch_new_menu_colors();
7397 else if (is_scrollbar_group
)
7399 if (gui
.in_use
&& do_colors
)
7400 gui_new_scrollbar_colors();
7403 else if (is_tooltip_group
)
7405 if (gui
.in_use
&& do_colors
)
7406 gui_mch_new_tooltip_colors();
7413 HL_TABLE()[idx
].sg_scriptID
= current_SID
;
7415 redraw_all_later(NOT_VALID
);
7420 /* Only call highlight_changed() once, after sourcing a syntax file */
7421 need_highlight_changed
= TRUE
;
7424 #if defined(EXITFREE) || defined(PROTO)
7430 for (i
= 0; i
< highlight_ga
.ga_len
; ++i
)
7433 vim_free(HL_TABLE()[i
].sg_name
);
7434 vim_free(HL_TABLE()[i
].sg_name_u
);
7436 ga_clear(&highlight_ga
);
7441 * Reset the cterm colors to what they were before Vim was started, if
7442 * possible. Otherwise reset them to zero.
7445 restore_cterm_colors()
7447 #if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32))
7448 /* Since t_me has been set, this probably means that the user
7449 * wants to use this as default colors. Need to reset default
7450 * background/foreground colors. */
7451 mch_set_normal_colors();
7453 cterm_normal_fg_color
= 0;
7454 cterm_normal_fg_bold
= 0;
7455 cterm_normal_bg_color
= 0;
7460 * Return TRUE if highlight group "idx" has any settings.
7461 * When "check_link" is TRUE also check for an existing link.
7464 hl_has_settings(idx
, check_link
)
7468 return ( HL_TABLE()[idx
].sg_term_attr
!= 0
7469 || HL_TABLE()[idx
].sg_cterm_attr
!= 0
7471 || HL_TABLE()[idx
].sg_gui_attr
!= 0
7473 || (check_link
&& (HL_TABLE()[idx
].sg_set
& SG_LINK
)));
7477 * Clear highlighting for one group.
7480 highlight_clear(idx
)
7483 HL_TABLE()[idx
].sg_term
= 0;
7484 vim_free(HL_TABLE()[idx
].sg_start
);
7485 HL_TABLE()[idx
].sg_start
= NULL
;
7486 vim_free(HL_TABLE()[idx
].sg_stop
);
7487 HL_TABLE()[idx
].sg_stop
= NULL
;
7488 HL_TABLE()[idx
].sg_term_attr
= 0;
7489 HL_TABLE()[idx
].sg_cterm
= 0;
7490 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
7491 HL_TABLE()[idx
].sg_cterm_fg
= 0;
7492 HL_TABLE()[idx
].sg_cterm_bg
= 0;
7493 HL_TABLE()[idx
].sg_cterm_attr
= 0;
7494 #ifdef FEAT_GUI /* in non-GUI fonts are simply ignored */
7495 HL_TABLE()[idx
].sg_gui
= 0;
7496 HL_TABLE()[idx
].sg_gui_fg
= INVALCOLOR
;
7497 vim_free(HL_TABLE()[idx
].sg_gui_fg_name
);
7498 HL_TABLE()[idx
].sg_gui_fg_name
= NULL
;
7499 HL_TABLE()[idx
].sg_gui_bg
= INVALCOLOR
;
7500 vim_free(HL_TABLE()[idx
].sg_gui_bg_name
);
7501 HL_TABLE()[idx
].sg_gui_bg_name
= NULL
;
7502 HL_TABLE()[idx
].sg_gui_sp
= INVALCOLOR
;
7503 vim_free(HL_TABLE()[idx
].sg_gui_sp_name
);
7504 HL_TABLE()[idx
].sg_gui_sp_name
= NULL
;
7505 gui_mch_free_font(HL_TABLE()[idx
].sg_font
);
7506 HL_TABLE()[idx
].sg_font
= NOFONT
;
7507 # ifdef FEAT_XFONTSET
7508 gui_mch_free_fontset(HL_TABLE()[idx
].sg_fontset
);
7509 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
7511 vim_free(HL_TABLE()[idx
].sg_font_name
);
7512 HL_TABLE()[idx
].sg_font_name
= NULL
;
7513 HL_TABLE()[idx
].sg_gui_attr
= 0;
7516 /* Clear the script ID only when there is no link, since that is not
7518 if (HL_TABLE()[idx
].sg_link
== 0)
7519 HL_TABLE()[idx
].sg_scriptID
= 0;
7523 #if defined(FEAT_GUI) || defined(PROTO)
7525 * Set the normal foreground and background colors according to the "Normal"
7526 * highlighting group. For X11 also set "Menu", "Scrollbar", and
7532 if (set_group_colors((char_u
*)"Normal",
7533 &gui
.norm_pixel
, &gui
.back_pixel
,
7534 FALSE
, TRUE
, FALSE
))
7536 gui_mch_new_colors();
7537 must_redraw
= CLEAR
;
7540 if (set_group_colors((char_u
*)"Menu",
7541 &gui
.menu_fg_pixel
, &gui
.menu_bg_pixel
,
7542 TRUE
, FALSE
, FALSE
))
7545 gui_mch_new_menu_colors();
7547 must_redraw
= CLEAR
;
7550 if (set_group_colors((char_u
*)"Tooltip",
7551 &gui
.tooltip_fg_pixel
, &gui
.tooltip_bg_pixel
,
7552 FALSE
, FALSE
, TRUE
))
7554 # ifdef FEAT_TOOLBAR
7555 gui_mch_new_tooltip_colors();
7557 must_redraw
= CLEAR
;
7560 if (set_group_colors((char_u
*)"Scrollbar",
7561 &gui
.scroll_fg_pixel
, &gui
.scroll_bg_pixel
,
7562 FALSE
, FALSE
, FALSE
))
7564 gui_new_scrollbar_colors();
7565 must_redraw
= CLEAR
;
7571 * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
7574 set_group_colors(name
, fgp
, bgp
, do_menu
, use_norm
, do_tooltip
)
7584 idx
= syn_name2id(name
) - 1;
7587 gui_do_one_color(idx
, do_menu
, do_tooltip
);
7589 if (HL_TABLE()[idx
].sg_gui_fg
!= INVALCOLOR
)
7590 *fgp
= HL_TABLE()[idx
].sg_gui_fg
;
7592 *fgp
= gui
.def_norm_pixel
;
7593 if (HL_TABLE()[idx
].sg_gui_bg
!= INVALCOLOR
)
7594 *bgp
= HL_TABLE()[idx
].sg_gui_bg
;
7596 *bgp
= gui
.def_back_pixel
;
7603 * Get the font of the "Normal" group.
7604 * Returns "" when it's not found or not set.
7612 id
= syn_name2id((char_u
*)"Normal");
7615 s
= HL_TABLE()[id
- 1].sg_font_name
;
7619 return (char_u
*)"";
7623 * Set font for "Normal" group. Called by gui_mch_init_font() when a font has
7624 * actually chosen to be used.
7627 hl_set_font_name(font_name
)
7632 id
= syn_name2id((char_u
*)"Normal");
7635 vim_free(HL_TABLE()[id
- 1].sg_font_name
);
7636 HL_TABLE()[id
- 1].sg_font_name
= vim_strsave(font_name
);
7641 * Set background color for "Normal" group. Called by gui_set_bg_color()
7642 * when the color is known.
7645 hl_set_bg_color_name(name
)
7646 char_u
*name
; /* must have been allocated */
7652 id
= syn_name2id((char_u
*)"Normal");
7655 vim_free(HL_TABLE()[id
- 1].sg_gui_bg_name
);
7656 HL_TABLE()[id
- 1].sg_gui_bg_name
= name
;
7662 * Set foreground color for "Normal" group. Called by gui_set_fg_color()
7663 * when the color is known.
7666 hl_set_fg_color_name(name
)
7667 char_u
*name
; /* must have been allocated */
7673 id
= syn_name2id((char_u
*)"Normal");
7676 vim_free(HL_TABLE()[id
- 1].sg_gui_fg_name
);
7677 HL_TABLE()[id
- 1].sg_gui_fg_name
= name
;
7683 * Return the handle for a color name.
7684 * Returns INVALCOLOR when failed.
7687 color_name2handle(name
)
7690 if (STRCMP(name
, "NONE") == 0)
7693 if (STRICMP(name
, "fg") == 0 || STRICMP(name
, "foreground") == 0)
7694 return gui
.norm_pixel
;
7695 if (STRICMP(name
, "bg") == 0 || STRICMP(name
, "background") == 0)
7696 return gui
.back_pixel
;
7698 return gui_get_color(name
);
7702 * Return the handle for a font name.
7703 * Returns NOFONT when failed.
7706 font_name2handle(name
)
7709 if (STRCMP(name
, "NONE") == 0)
7712 return gui_mch_get_font(name
, TRUE
);
7715 # ifdef FEAT_XFONTSET
7717 * Return the handle for a fontset name.
7718 * Returns NOFONTSET when failed.
7721 fontset_name2handle(name
, fixed_width
)
7725 if (STRCMP(name
, "NONE") == 0)
7728 return gui_mch_get_fontset(name
, TRUE
, fixed_width
);
7733 * Get the font or fontset for one highlight group.
7736 hl_do_font(idx
, arg
, do_normal
, do_menu
, do_tooltip
)
7739 int do_normal
; /* set normal font */
7740 int do_menu UNUSED
; /* set menu font */
7741 int do_tooltip UNUSED
; /* set tooltip font */
7743 # ifdef FEAT_XFONTSET
7744 /* If 'guifontset' is not empty, first try using the name as a
7745 * fontset. If that doesn't work, use it as a font name. */
7746 if (*p_guifontset
!= NUL
7747 # ifdef FONTSET_ALWAYS
7750 # ifdef FEAT_BEVAL_TIP
7751 /* In Athena & Motif, the Tooltip highlight group is always a fontset */
7755 HL_TABLE()[idx
].sg_fontset
= fontset_name2handle(arg
, 0
7756 # ifdef FONTSET_ALWAYS
7759 # ifdef FEAT_BEVAL_TIP
7763 if (HL_TABLE()[idx
].sg_fontset
!= NOFONTSET
)
7765 /* If it worked and it's the Normal group, use it as the
7766 * normal fontset. Same for the Menu group. */
7768 gui_init_font(arg
, TRUE
);
7769 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7772 # ifdef FONTSET_ALWAYS
7773 gui
.menu_fontset
= HL_TABLE()[idx
].sg_fontset
;
7775 /* YIKES! This is a bug waiting to crash the program */
7776 gui
.menu_font
= HL_TABLE()[idx
].sg_fontset
;
7778 gui_mch_new_menu_font();
7783 /* The Athena widget set cannot currently handle switching between
7784 * displaying a single font and a fontset.
7785 * If the XtNinternational resource is set to True at widget
7786 * creation, then a fontset is always used, otherwise an
7787 * XFontStruct is used.
7789 gui
.tooltip_fontset
= (XFontSet
)HL_TABLE()[idx
].sg_fontset
;
7790 gui_mch_new_tooltip_font();
7798 HL_TABLE()[idx
].sg_font
= font_name2handle(arg
);
7799 /* If it worked and it's the Normal group, use it as the
7800 * normal font. Same for the Menu group. */
7801 if (HL_TABLE()[idx
].sg_font
!= NOFONT
)
7804 gui_init_font(arg
, FALSE
);
7805 #ifndef FONTSET_ALWAYS
7806 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7809 gui
.menu_font
= HL_TABLE()[idx
].sg_font
;
7810 gui_mch_new_menu_font();
7818 #endif /* FEAT_GUI */
7821 * Table with the specifications for an attribute number.
7822 * Note that this table is used by ALL buffers. This is required because the
7823 * GUI can redraw at any time for any buffer.
7825 static garray_T term_attr_table
= {0, 0, 0, 0, NULL
};
7827 #define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx]
7829 static garray_T cterm_attr_table
= {0, 0, 0, 0, NULL
};
7831 #define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx]
7834 static garray_T gui_attr_table
= {0, 0, 0, 0, NULL
};
7836 #define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx]
7840 * Return the attr number for a set of colors and font.
7841 * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
7842 * if the combination is new.
7843 * Return 0 for error (no more room).
7846 get_attr_entry(table
, aep
)
7852 static int recursive
= FALSE
;
7855 * Init the table, in case it wasn't done yet.
7857 table
->ga_itemsize
= sizeof(attrentry_T
);
7858 table
->ga_growsize
= 7;
7861 * Try to find an entry with the same specifications.
7863 for (i
= 0; i
< table
->ga_len
; ++i
)
7865 taep
= &(((attrentry_T
*)table
->ga_data
)[i
]);
7866 if ( aep
->ae_attr
== taep
->ae_attr
7869 (table
== &gui_attr_table
7870 && (aep
->ae_u
.gui
.fg_color
== taep
->ae_u
.gui
.fg_color
7871 && aep
->ae_u
.gui
.bg_color
7872 == taep
->ae_u
.gui
.bg_color
7873 && aep
->ae_u
.gui
.sp_color
7874 == taep
->ae_u
.gui
.sp_color
7875 && aep
->ae_u
.gui
.font
== taep
->ae_u
.gui
.font
7876 # ifdef FEAT_XFONTSET
7877 && aep
->ae_u
.gui
.fontset
== taep
->ae_u
.gui
.fontset
7882 (table
== &term_attr_table
7883 && (aep
->ae_u
.term
.start
== NULL
)
7884 == (taep
->ae_u
.term
.start
== NULL
)
7885 && (aep
->ae_u
.term
.start
== NULL
7886 || STRCMP(aep
->ae_u
.term
.start
,
7887 taep
->ae_u
.term
.start
) == 0)
7888 && (aep
->ae_u
.term
.stop
== NULL
)
7889 == (taep
->ae_u
.term
.stop
== NULL
)
7890 && (aep
->ae_u
.term
.stop
== NULL
7891 || STRCMP(aep
->ae_u
.term
.stop
,
7892 taep
->ae_u
.term
.stop
) == 0))
7893 || (table
== &cterm_attr_table
7894 && aep
->ae_u
.cterm
.fg_color
7895 == taep
->ae_u
.cterm
.fg_color
7896 && aep
->ae_u
.cterm
.bg_color
7897 == taep
->ae_u
.cterm
.bg_color
)
7900 return i
+ ATTR_OFF
;
7903 if (table
->ga_len
+ ATTR_OFF
> MAX_TYPENR
)
7906 * Running out of attribute entries! remove all attributes, and
7907 * compute new ones for all groups.
7908 * When called recursively, we are really out of numbers.
7912 EMSG(_("E424: Too many different highlighting attributes in use"));
7919 must_redraw
= CLEAR
;
7921 for (i
= 0; i
< highlight_ga
.ga_len
; ++i
)
7928 * This is a new combination of colors and font, add an entry.
7930 if (ga_grow(table
, 1) == FAIL
)
7933 taep
= &(((attrentry_T
*)table
->ga_data
)[table
->ga_len
]);
7934 vim_memset(taep
, 0, sizeof(attrentry_T
));
7935 taep
->ae_attr
= aep
->ae_attr
;
7937 if (table
== &gui_attr_table
)
7939 taep
->ae_u
.gui
.fg_color
= aep
->ae_u
.gui
.fg_color
;
7940 taep
->ae_u
.gui
.bg_color
= aep
->ae_u
.gui
.bg_color
;
7941 taep
->ae_u
.gui
.sp_color
= aep
->ae_u
.gui
.sp_color
;
7942 taep
->ae_u
.gui
.font
= aep
->ae_u
.gui
.font
;
7943 # ifdef FEAT_XFONTSET
7944 taep
->ae_u
.gui
.fontset
= aep
->ae_u
.gui
.fontset
;
7948 if (table
== &term_attr_table
)
7950 if (aep
->ae_u
.term
.start
== NULL
)
7951 taep
->ae_u
.term
.start
= NULL
;
7953 taep
->ae_u
.term
.start
= vim_strsave(aep
->ae_u
.term
.start
);
7954 if (aep
->ae_u
.term
.stop
== NULL
)
7955 taep
->ae_u
.term
.stop
= NULL
;
7957 taep
->ae_u
.term
.stop
= vim_strsave(aep
->ae_u
.term
.stop
);
7959 else if (table
== &cterm_attr_table
)
7961 taep
->ae_u
.cterm
.fg_color
= aep
->ae_u
.cterm
.fg_color
;
7962 taep
->ae_u
.cterm
.bg_color
= aep
->ae_u
.cterm
.bg_color
;
7965 return (table
->ga_len
- 1 + ATTR_OFF
);
7969 * Clear all highlight tables.
7978 ga_clear(&gui_attr_table
);
7980 for (i
= 0; i
< term_attr_table
.ga_len
; ++i
)
7982 taep
= &(((attrentry_T
*)term_attr_table
.ga_data
)[i
]);
7983 vim_free(taep
->ae_u
.term
.start
);
7984 vim_free(taep
->ae_u
.term
.stop
);
7986 ga_clear(&term_attr_table
);
7987 ga_clear(&cterm_attr_table
);
7990 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO)
7992 * Combine special attributes (e.g., for spelling) with other attributes
7993 * (e.g., for syntax highlighting).
7994 * "prim_attr" overrules "char_attr".
7995 * This creates a new group when required.
7996 * Since we expect there to be few spelling mistakes we don't cache the
7998 * Return the resulting attributes.
8001 hl_combine_attr(char_attr
, prim_attr
)
8005 attrentry_T
*char_aep
= NULL
;
8006 attrentry_T
*spell_aep
;
8011 if (char_attr
<= HL_ALL
&& prim_attr
<= HL_ALL
)
8012 return char_attr
| prim_attr
;
8016 if (char_attr
> HL_ALL
)
8017 char_aep
= syn_gui_attr2entry(char_attr
);
8018 if (char_aep
!= NULL
)
8022 vim_memset(&new_en
, 0, sizeof(new_en
));
8023 new_en
.ae_u
.gui
.fg_color
= INVALCOLOR
;
8024 new_en
.ae_u
.gui
.bg_color
= INVALCOLOR
;
8025 new_en
.ae_u
.gui
.sp_color
= INVALCOLOR
;
8026 if (char_attr
<= HL_ALL
)
8027 new_en
.ae_attr
= char_attr
;
8030 if (prim_attr
<= HL_ALL
)
8031 new_en
.ae_attr
|= prim_attr
;
8034 spell_aep
= syn_gui_attr2entry(prim_attr
);
8035 if (spell_aep
!= NULL
)
8037 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8038 if (spell_aep
->ae_u
.gui
.fg_color
!= INVALCOLOR
)
8039 new_en
.ae_u
.gui
.fg_color
= spell_aep
->ae_u
.gui
.fg_color
;
8040 if (spell_aep
->ae_u
.gui
.bg_color
!= INVALCOLOR
)
8041 new_en
.ae_u
.gui
.bg_color
= spell_aep
->ae_u
.gui
.bg_color
;
8042 if (spell_aep
->ae_u
.gui
.sp_color
!= INVALCOLOR
)
8043 new_en
.ae_u
.gui
.sp_color
= spell_aep
->ae_u
.gui
.sp_color
;
8044 if (spell_aep
->ae_u
.gui
.font
!= NOFONT
)
8045 new_en
.ae_u
.gui
.font
= spell_aep
->ae_u
.gui
.font
;
8046 # ifdef FEAT_XFONTSET
8047 if (spell_aep
->ae_u
.gui
.fontset
!= NOFONTSET
)
8048 new_en
.ae_u
.gui
.fontset
= spell_aep
->ae_u
.gui
.fontset
;
8052 return get_attr_entry(&gui_attr_table
, &new_en
);
8058 if (char_attr
> HL_ALL
)
8059 char_aep
= syn_cterm_attr2entry(char_attr
);
8060 if (char_aep
!= NULL
)
8064 vim_memset(&new_en
, 0, sizeof(new_en
));
8065 if (char_attr
<= HL_ALL
)
8066 new_en
.ae_attr
= char_attr
;
8069 if (prim_attr
<= HL_ALL
)
8070 new_en
.ae_attr
|= prim_attr
;
8073 spell_aep
= syn_cterm_attr2entry(prim_attr
);
8074 if (spell_aep
!= NULL
)
8076 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8077 if (spell_aep
->ae_u
.cterm
.fg_color
> 0)
8078 new_en
.ae_u
.cterm
.fg_color
= spell_aep
->ae_u
.cterm
.fg_color
;
8079 if (spell_aep
->ae_u
.cterm
.bg_color
> 0)
8080 new_en
.ae_u
.cterm
.bg_color
= spell_aep
->ae_u
.cterm
.bg_color
;
8083 return get_attr_entry(&cterm_attr_table
, &new_en
);
8086 if (char_attr
> HL_ALL
)
8087 char_aep
= syn_term_attr2entry(char_attr
);
8088 if (char_aep
!= NULL
)
8092 vim_memset(&new_en
, 0, sizeof(new_en
));
8093 if (char_attr
<= HL_ALL
)
8094 new_en
.ae_attr
= char_attr
;
8097 if (prim_attr
<= HL_ALL
)
8098 new_en
.ae_attr
|= prim_attr
;
8101 spell_aep
= syn_term_attr2entry(prim_attr
);
8102 if (spell_aep
!= NULL
)
8104 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8105 if (spell_aep
->ae_u
.term
.start
!= NULL
)
8107 new_en
.ae_u
.term
.start
= spell_aep
->ae_u
.term
.start
;
8108 new_en
.ae_u
.term
.stop
= spell_aep
->ae_u
.term
.stop
;
8112 return get_attr_entry(&term_attr_table
, &new_en
);
8119 syn_gui_attr2entry(attr
)
8123 if (attr
>= gui_attr_table
.ga_len
) /* did ":syntax clear" */
8125 return &(GUI_ATTR_ENTRY(attr
));
8127 #endif /* FEAT_GUI */
8130 * Get the highlight attributes (HL_BOLD etc.) from an attribute nr.
8131 * Only to be used when "attr" > HL_ALL.
8141 aep
= syn_gui_attr2entry(attr
);
8145 aep
= syn_cterm_attr2entry(attr
);
8147 aep
= syn_term_attr2entry(attr
);
8149 if (aep
== NULL
) /* highlighting not set */
8151 return aep
->ae_attr
;
8156 syn_term_attr2entry(attr
)
8160 if (attr
>= term_attr_table
.ga_len
) /* did ":syntax clear" */
8162 return &(TERM_ATTR_ENTRY(attr
));
8166 syn_cterm_attr2entry(attr
)
8170 if (attr
>= cterm_attr_table
.ga_len
) /* did ":syntax clear" */
8172 return &(CTERM_ATTR_ENTRY(attr
));
8176 #define LIST_STRING 2
8180 highlight_list_one(id
)
8183 struct hl_group
*sgp
;
8186 sgp
= &HL_TABLE()[id
- 1]; /* index is ID minus one */
8188 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8189 sgp
->sg_term
, NULL
, "term");
8190 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8191 0, sgp
->sg_start
, "start");
8192 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8193 0, sgp
->sg_stop
, "stop");
8195 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8196 sgp
->sg_cterm
, NULL
, "cterm");
8197 didh
= highlight_list_arg(id
, didh
, LIST_INT
,
8198 sgp
->sg_cterm_fg
, NULL
, "ctermfg");
8199 didh
= highlight_list_arg(id
, didh
, LIST_INT
,
8200 sgp
->sg_cterm_bg
, NULL
, "ctermbg");
8203 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8204 sgp
->sg_gui
, NULL
, "gui");
8205 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8206 0, sgp
->sg_gui_fg_name
, "guifg");
8207 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8208 0, sgp
->sg_gui_bg_name
, "guibg");
8209 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8210 0, sgp
->sg_gui_sp_name
, "guisp");
8211 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8212 0, sgp
->sg_font_name
, "font");
8215 if (sgp
->sg_link
&& !got_int
)
8217 (void)syn_list_header(didh
, 9999, id
);
8219 msg_puts_attr((char_u
*)"links to", hl_attr(HLF_D
));
8221 msg_outtrans(HL_TABLE()[HL_TABLE()[id
- 1].sg_link
- 1].sg_name
);
8225 highlight_list_arg(id
, didh
, LIST_STRING
, 0, (char_u
*)"cleared", "");
8228 last_set_msg(sgp
->sg_scriptID
);
8233 highlight_list_arg(id
, didh
, type
, iarg
, sarg
, name
)
8247 if (type
== LIST_STRING
? (sarg
!= NULL
) : (iarg
!= 0))
8250 if (type
== LIST_INT
)
8251 sprintf((char *)buf
, "%d", iarg
- 1);
8252 else if (type
== LIST_STRING
)
8254 else /* type == LIST_ATTR */
8257 for (i
= 0; hl_attr_table
[i
] != 0; ++i
)
8259 if (iarg
& hl_attr_table
[i
])
8263 STRCAT(buf
, hl_name_table
[i
]);
8264 iarg
&= ~hl_attr_table
[i
]; /* don't want "inverse" */
8269 (void)syn_list_header(didh
,
8270 (int)(vim_strsize(ts
) + STRLEN(name
) + 1), id
);
8276 MSG_PUTS_ATTR(name
, hl_attr(HLF_D
));
8277 MSG_PUTS_ATTR("=", hl_attr(HLF_D
));
8285 #if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO)
8287 * Return "1" if highlight group "id" has attribute "flag".
8288 * Return NULL otherwise.
8291 highlight_has_attr(id
, flag
, modec
)
8294 int modec
; /* 'g' for GUI, 'c' for cterm, 't' for term */
8298 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8303 attr
= HL_TABLE()[id
- 1].sg_gui
;
8307 attr
= HL_TABLE()[id
- 1].sg_cterm
;
8309 attr
= HL_TABLE()[id
- 1].sg_term
;
8312 return (char_u
*)"1";
8317 #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
8319 * Return color name of highlight group "id".
8322 highlight_color(id
, what
, modec
)
8324 char_u
*what
; /* "fg", "bg", "sp", "fg#", "bg#" or "sp#" */
8325 int modec
; /* 'g' for GUI, 'c' for cterm, 't' for term */
8327 static char_u name
[20];
8334 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8337 if (TOLOWER_ASC(what
[0]) == 'f')
8340 else if (TOLOWER_ASC(what
[0]) == 's')
8344 /* return #RRGGBB form (only possible when GUI is running) */
8345 if (gui
.in_use
&& what
[1] && what
[2] == '#')
8349 static char_u buf
[10];
8352 color
= HL_TABLE()[id
- 1].sg_gui_fg
;
8354 color
= HL_TABLE()[id
- 1].sg_gui_sp
;
8356 color
= HL_TABLE()[id
- 1].sg_gui_bg
;
8357 if (color
== INVALCOLOR
)
8359 rgb
= gui_mch_get_rgb(color
);
8360 sprintf((char *)buf
, "#%02x%02x%02x",
8361 (unsigned)(rgb
>> 16),
8362 (unsigned)(rgb
>> 8) & 255,
8363 (unsigned)rgb
& 255);
8367 return (HL_TABLE()[id
- 1].sg_gui_fg_name
);
8369 return (HL_TABLE()[id
- 1].sg_gui_sp_name
);
8370 return (HL_TABLE()[id
- 1].sg_gui_bg_name
);
8376 n
= HL_TABLE()[id
- 1].sg_cterm_fg
- 1;
8378 n
= HL_TABLE()[id
- 1].sg_cterm_bg
- 1;
8379 sprintf((char *)name
, "%d", n
);
8382 /* term doesn't have color */
8387 #if (defined(FEAT_SYN_HL) && defined(FEAT_GUI) && defined(FEAT_PRINTER)) \
8390 * Return color name of highlight group "id" as RGB value.
8393 highlight_gui_color_rgb(id
, fg
)
8395 int fg
; /* TRUE = fg, FALSE = bg */
8399 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8403 color
= HL_TABLE()[id
- 1].sg_gui_fg
;
8405 color
= HL_TABLE()[id
- 1].sg_gui_bg
;
8407 if (color
== INVALCOLOR
)
8410 return gui_mch_get_rgb(color
);
8415 * Output the syntax list header.
8416 * Return TRUE when started a new line.
8419 syn_list_header(did_header
, outlen
, id
)
8420 int did_header
; /* did header already */
8421 int outlen
; /* length of string that comes */
8422 int id
; /* highlight group id */
8432 msg_outtrans(HL_TABLE()[id
- 1].sg_name
);
8435 else if (msg_col
+ outlen
+ 1 >= Columns
)
8443 if (msg_col
>= endcol
) /* wrap around is like starting a new line */
8447 if (msg_col
>= endcol
) /* output at least one space */
8448 endcol
= msg_col
+ 1;
8449 if (Columns
<= endcol
) /* avoid hang for tiny window */
8450 endcol
= Columns
- 1;
8452 msg_advance(endcol
);
8454 /* Show "xxx" with the attributes. */
8457 msg_puts_attr((char_u
*)"xxx", syn_id2attr(id
));
8465 * Set the attribute numbers for a highlight group.
8466 * Called after one of the attributes has changed.
8470 int idx
; /* index in array */
8473 struct hl_group
*sgp
= HL_TABLE() + idx
;
8475 /* The "Normal" group doesn't need an attribute number */
8476 if (sgp
->sg_name_u
!= NULL
&& STRCMP(sgp
->sg_name_u
, "NORMAL") == 0)
8481 * For the GUI mode: If there are other than "normal" highlighting
8482 * attributes, need to allocate an attr number.
8484 if (sgp
->sg_gui_fg
== INVALCOLOR
8485 && sgp
->sg_gui_bg
== INVALCOLOR
8486 && sgp
->sg_gui_sp
== INVALCOLOR
8487 && sgp
->sg_font
== NOFONT
8488 # ifdef FEAT_XFONTSET
8489 && sgp
->sg_fontset
== NOFONTSET
8493 sgp
->sg_gui_attr
= sgp
->sg_gui
;
8497 at_en
.ae_attr
= sgp
->sg_gui
;
8498 at_en
.ae_u
.gui
.fg_color
= sgp
->sg_gui_fg
;
8499 at_en
.ae_u
.gui
.bg_color
= sgp
->sg_gui_bg
;
8500 at_en
.ae_u
.gui
.sp_color
= sgp
->sg_gui_sp
;
8501 at_en
.ae_u
.gui
.font
= sgp
->sg_font
;
8502 # ifdef FEAT_XFONTSET
8503 at_en
.ae_u
.gui
.fontset
= sgp
->sg_fontset
;
8505 sgp
->sg_gui_attr
= get_attr_entry(&gui_attr_table
, &at_en
);
8509 * For the term mode: If there are other than "normal" highlighting
8510 * attributes, need to allocate an attr number.
8512 if (sgp
->sg_start
== NULL
&& sgp
->sg_stop
== NULL
)
8513 sgp
->sg_term_attr
= sgp
->sg_term
;
8516 at_en
.ae_attr
= sgp
->sg_term
;
8517 at_en
.ae_u
.term
.start
= sgp
->sg_start
;
8518 at_en
.ae_u
.term
.stop
= sgp
->sg_stop
;
8519 sgp
->sg_term_attr
= get_attr_entry(&term_attr_table
, &at_en
);
8523 * For the color term mode: If there are other than "normal"
8524 * highlighting attributes, need to allocate an attr number.
8526 if (sgp
->sg_cterm_fg
== 0 && sgp
->sg_cterm_bg
== 0)
8527 sgp
->sg_cterm_attr
= sgp
->sg_cterm
;
8530 at_en
.ae_attr
= sgp
->sg_cterm
;
8531 at_en
.ae_u
.cterm
.fg_color
= sgp
->sg_cterm_fg
;
8532 at_en
.ae_u
.cterm
.bg_color
= sgp
->sg_cterm_bg
;
8533 sgp
->sg_cterm_attr
= get_attr_entry(&cterm_attr_table
, &at_en
);
8538 * Lookup a highlight group name and return it's ID.
8539 * If it is not found, 0 is returned.
8548 /* Avoid using stricmp() too much, it's slow on some systems */
8549 /* Avoid alloc()/free(), these are slow too. ID names over 200 chars
8550 * don't deserve to be found! */
8551 vim_strncpy(name_u
, name
, 199);
8553 for (i
= highlight_ga
.ga_len
; --i
>= 0; )
8554 if (HL_TABLE()[i
].sg_name_u
!= NULL
8555 && STRCMP(name_u
, HL_TABLE()[i
].sg_name_u
) == 0)
8560 #if defined(FEAT_EVAL) || defined(PROTO)
8562 * Return TRUE if highlight group "name" exists.
8565 highlight_exists(name
)
8568 return (syn_name2id(name
) > 0);
8571 # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
8573 * Return the name of highlight group "id".
8574 * When not a valid ID return an empty string.
8580 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8581 return (char_u
*)"";
8582 return HL_TABLE()[id
- 1].sg_name
;
8588 * Like syn_name2id(), but take a pointer + length argument.
8591 syn_namen2id(linep
, len
)
8598 name
= vim_strnsave(linep
, len
);
8601 id
= syn_name2id(name
);
8608 * Find highlight group name in the table and return it's ID.
8609 * The argument is a pointer to the name and the length of the name.
8610 * If it doesn't exist yet, a new entry is created.
8611 * Return 0 for failure.
8614 syn_check_group(pp
, len
)
8621 name
= vim_strnsave(pp
, len
);
8625 id
= syn_name2id(name
);
8626 if (id
== 0) /* doesn't exist yet */
8627 id
= syn_add_group(name
);
8634 * Add new highlight group and return it's ID.
8635 * "name" must be an allocated string, it will be consumed.
8636 * Return 0 for failure.
8644 /* Check that the name is ASCII letters, digits and underscore. */
8645 for (p
= name
; *p
!= NUL
; ++p
)
8647 if (!vim_isprintc(*p
))
8649 EMSG(_("E669: Unprintable character in group name"));
8653 else if (!ASCII_ISALNUM(*p
) && *p
!= '_')
8655 /* This is an error, but since there previously was no check only
8656 * give a warning. */
8657 msg_source(hl_attr(HLF_W
));
8658 MSG(_("W18: Invalid character in group name"));
8664 * First call for this growarray: init growing array.
8666 if (highlight_ga
.ga_data
== NULL
)
8668 highlight_ga
.ga_itemsize
= sizeof(struct hl_group
);
8669 highlight_ga
.ga_growsize
= 10;
8673 * Make room for at least one other syntax_highlight entry.
8675 if (ga_grow(&highlight_ga
, 1) == FAIL
)
8681 vim_memset(&(HL_TABLE()[highlight_ga
.ga_len
]), 0, sizeof(struct hl_group
));
8682 HL_TABLE()[highlight_ga
.ga_len
].sg_name
= name
;
8683 HL_TABLE()[highlight_ga
.ga_len
].sg_name_u
= vim_strsave_up(name
);
8685 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_bg
= INVALCOLOR
;
8686 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_fg
= INVALCOLOR
;
8687 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_sp
= INVALCOLOR
;
8689 ++highlight_ga
.ga_len
;
8691 return highlight_ga
.ga_len
; /* ID is index plus one */
8695 * When, just after calling syn_add_group(), an error is discovered, this
8696 * function deletes the new name.
8701 --highlight_ga
.ga_len
;
8702 vim_free(HL_TABLE()[highlight_ga
.ga_len
].sg_name
);
8703 vim_free(HL_TABLE()[highlight_ga
.ga_len
].sg_name_u
);
8707 * Translate a group ID to highlight attributes.
8714 struct hl_group
*sgp
;
8716 hl_id
= syn_get_final_id(hl_id
);
8717 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8721 * Only use GUI attr when the GUI is being used.
8724 attr
= sgp
->sg_gui_attr
;
8728 attr
= sgp
->sg_cterm_attr
;
8730 attr
= sgp
->sg_term_attr
;
8737 * Get the GUI colors and attributes for a group ID.
8738 * NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
8741 syn_id2colors(hl_id
, fgp
, bgp
)
8746 struct hl_group
*sgp
;
8748 hl_id
= syn_get_final_id(hl_id
);
8749 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8751 *fgp
= sgp
->sg_gui_fg
;
8752 *bgp
= sgp
->sg_gui_bg
;
8758 * Translate a group ID to the final group ID (following links).
8761 syn_get_final_id(hl_id
)
8765 struct hl_group
*sgp
;
8767 if (hl_id
> highlight_ga
.ga_len
|| hl_id
< 1)
8768 return 0; /* Can be called from eval!! */
8771 * Follow links until there is no more.
8772 * Look out for loops! Break after 100 links.
8774 for (count
= 100; --count
>= 0; )
8776 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8777 if (sgp
->sg_link
== 0 || sgp
->sg_link
> highlight_ga
.ga_len
)
8779 hl_id
= sgp
->sg_link
;
8787 * Call this function just after the GUI has started.
8788 * It finds the font and color handles for the highlighting groups.
8791 highlight_gui_started()
8795 /* First get the colors from the "Normal" and "Menu" group, if set */
8796 set_normal_colors();
8798 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
8799 gui_do_one_color(idx
, FALSE
, FALSE
);
8801 highlight_changed();
8805 gui_do_one_color(idx
, do_menu
, do_tooltip
)
8807 int do_menu
; /* TRUE: might set the menu font */
8808 int do_tooltip
; /* TRUE: might set the tooltip font */
8812 if (HL_TABLE()[idx
].sg_font_name
!= NULL
)
8814 hl_do_font(idx
, HL_TABLE()[idx
].sg_font_name
, FALSE
, do_menu
,
8818 if (HL_TABLE()[idx
].sg_gui_fg_name
!= NULL
)
8820 HL_TABLE()[idx
].sg_gui_fg
=
8821 color_name2handle(HL_TABLE()[idx
].sg_gui_fg_name
);
8824 if (HL_TABLE()[idx
].sg_gui_bg_name
!= NULL
)
8826 HL_TABLE()[idx
].sg_gui_bg
=
8827 color_name2handle(HL_TABLE()[idx
].sg_gui_bg_name
);
8830 if (HL_TABLE()[idx
].sg_gui_sp_name
!= NULL
)
8832 HL_TABLE()[idx
].sg_gui_sp
=
8833 color_name2handle(HL_TABLE()[idx
].sg_gui_sp_name
);
8836 if (didit
) /* need to get a new attr number */
8843 * Translate the 'highlight' option into attributes in highlight_attr[] and
8844 * set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of
8845 * corresponding highlights to use on top of HLF_SNC is computed.
8846 * Called only when the 'highlight' option has been changed and upon first
8847 * screen redraw after any :highlight command.
8848 * Return FAIL when an invalid flag is found in 'highlight'. OK otherwise.
8859 #ifdef USER_HIGHLIGHT
8861 # ifdef FEAT_STL_OPT
8867 static int hl_flags
[HLF_COUNT
] = HL_FLAGS
;
8869 need_highlight_changed
= FALSE
;
8872 * Clear all attributes.
8874 for (hlf
= 0; hlf
< (int)HLF_COUNT
; ++hlf
)
8875 highlight_attr
[hlf
] = 0;
8878 * First set all attributes to their default value.
8879 * Then use the attributes from the 'highlight' option.
8881 for (i
= 0; i
< 2; ++i
)
8886 p
= get_highlight_default();
8887 if (p
== NULL
) /* just in case */
8892 for (hlf
= 0; hlf
< (int)HLF_COUNT
; ++hlf
)
8893 if (hl_flags
[hlf
] == *p
)
8896 if (hlf
== (int)HLF_COUNT
|| *p
== NUL
)
8900 * Allow several hl_flags to be combined, like "bu" for
8904 for ( ; *p
&& *p
!= ','; ++p
) /* parse upto comma */
8906 if (vim_iswhite(*p
)) /* ignore white space */
8909 if (attr
> HL_ALL
) /* Combination with ':' is not allowed. */
8914 case 'b': attr
|= HL_BOLD
;
8916 case 'i': attr
|= HL_ITALIC
;
8919 case 'n': /* no highlighting */
8921 case 'r': attr
|= HL_INVERSE
;
8923 case 's': attr
|= HL_STANDOUT
;
8925 case 'u': attr
|= HL_UNDERLINE
;
8927 case 'c': attr
|= HL_UNDERCURL
;
8929 case ':': ++p
; /* highlight group name */
8930 if (attr
|| *p
== NUL
) /* no combinations */
8932 end
= vim_strchr(p
, ',');
8934 end
= p
+ STRLEN(p
);
8935 id
= syn_check_group(p
, (int)(end
- p
));
8938 attr
= syn_id2attr(id
);
8940 #if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT)
8941 if (hlf
== (int)HLF_SNC
)
8942 id_SNC
= syn_get_final_id(id
);
8943 else if (hlf
== (int)HLF_S
)
8944 id_S
= syn_get_final_id(id
);
8947 default: return FAIL
;
8950 highlight_attr
[hlf
] = attr
;
8952 p
= skip_to_option_part(p
); /* skip comma and spaces */
8956 #ifdef USER_HIGHLIGHT
8957 /* Setup the user highlights
8959 * Temporarily utilize 10 more hl entries. Have to be in there
8960 * simultaneously in case of table overflows in get_attr_entry()
8962 # ifdef FEAT_STL_OPT
8963 if (ga_grow(&highlight_ga
, 10) == FAIL
)
8965 hlcnt
= highlight_ga
.ga_len
;
8967 { /* Make sure id_S is always valid to simplify code below */
8968 memset(&HL_TABLE()[hlcnt
+ 9], 0, sizeof(struct hl_group
));
8969 HL_TABLE()[hlcnt
+ 9].sg_term
= highlight_attr
[HLF_S
];
8973 for (i
= 0; i
< 9; i
++)
8975 sprintf((char *)userhl
, "User%d", i
+ 1);
8976 id
= syn_name2id(userhl
);
8979 highlight_user
[i
] = 0;
8980 # ifdef FEAT_STL_OPT
8981 highlight_stlnc
[i
] = 0;
8986 # ifdef FEAT_STL_OPT
8987 struct hl_group
*hlt
= HL_TABLE();
8990 highlight_user
[i
] = syn_id2attr(id
);
8991 # ifdef FEAT_STL_OPT
8994 memset(&hlt
[hlcnt
+ i
], 0, sizeof(struct hl_group
));
8995 hlt
[hlcnt
+ i
].sg_term
= highlight_attr
[HLF_SNC
];
8996 hlt
[hlcnt
+ i
].sg_cterm
= highlight_attr
[HLF_SNC
];
8998 hlt
[hlcnt
+ i
].sg_gui
= highlight_attr
[HLF_SNC
];
9002 mch_memmove(&hlt
[hlcnt
+ i
],
9004 sizeof(struct hl_group
));
9005 hlt
[hlcnt
+ i
].sg_link
= 0;
9007 /* Apply difference between UserX and HLF_S to HLF_SNC */
9008 hlt
[hlcnt
+ i
].sg_term
^=
9009 hlt
[id
- 1].sg_term
^ hlt
[id_S
- 1].sg_term
;
9010 if (hlt
[id
- 1].sg_start
!= hlt
[id_S
- 1].sg_start
)
9011 hlt
[hlcnt
+ i
].sg_start
= hlt
[id
- 1].sg_start
;
9012 if (hlt
[id
- 1].sg_stop
!= hlt
[id_S
- 1].sg_stop
)
9013 hlt
[hlcnt
+ i
].sg_stop
= hlt
[id
- 1].sg_stop
;
9014 hlt
[hlcnt
+ i
].sg_cterm
^=
9015 hlt
[id
- 1].sg_cterm
^ hlt
[id_S
- 1].sg_cterm
;
9016 if (hlt
[id
- 1].sg_cterm_fg
!= hlt
[id_S
- 1].sg_cterm_fg
)
9017 hlt
[hlcnt
+ i
].sg_cterm_fg
= hlt
[id
- 1].sg_cterm_fg
;
9018 if (hlt
[id
- 1].sg_cterm_bg
!= hlt
[id_S
- 1].sg_cterm_bg
)
9019 hlt
[hlcnt
+ i
].sg_cterm_bg
= hlt
[id
- 1].sg_cterm_bg
;
9021 hlt
[hlcnt
+ i
].sg_gui
^=
9022 hlt
[id
- 1].sg_gui
^ hlt
[id_S
- 1].sg_gui
;
9023 if (hlt
[id
- 1].sg_gui_fg
!= hlt
[id_S
- 1].sg_gui_fg
)
9024 hlt
[hlcnt
+ i
].sg_gui_fg
= hlt
[id
- 1].sg_gui_fg
;
9025 if (hlt
[id
- 1].sg_gui_bg
!= hlt
[id_S
- 1].sg_gui_bg
)
9026 hlt
[hlcnt
+ i
].sg_gui_bg
= hlt
[id
- 1].sg_gui_bg
;
9027 if (hlt
[id
- 1].sg_gui_sp
!= hlt
[id_S
- 1].sg_gui_sp
)
9028 hlt
[hlcnt
+ i
].sg_gui_sp
= hlt
[id
- 1].sg_gui_sp
;
9029 if (hlt
[id
- 1].sg_font
!= hlt
[id_S
- 1].sg_font
)
9030 hlt
[hlcnt
+ i
].sg_font
= hlt
[id
- 1].sg_font
;
9031 # ifdef FEAT_XFONTSET
9032 if (hlt
[id
- 1].sg_fontset
!= hlt
[id_S
- 1].sg_fontset
)
9033 hlt
[hlcnt
+ i
].sg_fontset
= hlt
[id
- 1].sg_fontset
;
9036 highlight_ga
.ga_len
= hlcnt
+ i
+ 1;
9037 set_hl_attr(hlcnt
+ i
); /* At long last we can apply */
9038 highlight_stlnc
[i
] = syn_id2attr(hlcnt
+ i
+ 1);
9042 # ifdef FEAT_STL_OPT
9043 highlight_ga
.ga_len
= hlcnt
;
9046 #endif /* USER_HIGHLIGHT */
9051 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9053 static void highlight_list
__ARGS((void));
9054 static void highlight_list_two
__ARGS((int cnt
, int attr
));
9057 * Handle command line completion for :highlight command.
9060 set_context_in_highlight_cmd(xp
, arg
)
9066 /* Default: expand group names */
9067 xp
->xp_context
= EXPAND_HIGHLIGHT
;
9068 xp
->xp_pattern
= arg
;
9070 include_default
= 1;
9072 /* (part of) subcommand already typed */
9075 p
= skiptowhite(arg
);
9076 if (*p
!= NUL
) /* past "default" or group name */
9078 include_default
= 0;
9079 if (STRNCMP("default", arg
, p
- arg
) == 0)
9082 xp
->xp_pattern
= arg
;
9083 p
= skiptowhite(arg
);
9085 if (*p
!= NUL
) /* past group name */
9088 if (arg
[1] == 'i' && arg
[0] == 'N')
9090 if (STRNCMP("link", arg
, p
- arg
) == 0
9091 || STRNCMP("clear", arg
, p
- arg
) == 0)
9093 xp
->xp_pattern
= skipwhite(p
);
9094 p
= skiptowhite(xp
->xp_pattern
);
9095 if (*p
!= NUL
) /* past first group name */
9097 xp
->xp_pattern
= skipwhite(p
);
9098 p
= skiptowhite(xp
->xp_pattern
);
9101 if (*p
!= NUL
) /* past group name(s) */
9102 xp
->xp_context
= EXPAND_NOTHING
;
9109 * List highlighting matches in a nice way.
9116 for (i
= 10; --i
>= 0; )
9117 highlight_list_two(i
, hl_attr(HLF_D
));
9118 for (i
= 40; --i
>= 0; )
9119 highlight_list_two(99, 0);
9123 highlight_list_two(cnt
, attr
)
9127 msg_puts_attr((char_u
*)("N \bI \b! \b" + cnt
/ 11), attr
);
9130 ui_delay(cnt
== 99 ? 40L : (long)cnt
* 50L, FALSE
);
9133 #endif /* FEAT_CMDL_COMPL */
9135 #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) \
9136 || defined(FEAT_SIGNS) || defined(PROTO)
9138 * Function given to ExpandGeneric() to obtain the list of group names.
9139 * Also used for synIDattr() function.
9142 get_highlight_name(xp
, idx
)
9143 expand_T
*xp UNUSED
;
9146 #ifdef FEAT_CMDL_COMPL
9147 if (idx
== highlight_ga
.ga_len
&& include_none
!= 0)
9148 return (char_u
*)"none";
9149 if (idx
== highlight_ga
.ga_len
+ include_none
&& include_default
!= 0)
9150 return (char_u
*)"default";
9151 if (idx
== highlight_ga
.ga_len
+ include_none
+ include_default
9152 && include_link
!= 0)
9153 return (char_u
*)"link";
9154 if (idx
== highlight_ga
.ga_len
+ include_none
+ include_default
+ 1
9155 && include_link
!= 0)
9156 return (char_u
*)"clear";
9158 if (idx
< 0 || idx
>= highlight_ga
.ga_len
)
9160 return HL_TABLE()[idx
].sg_name
;
9164 #if defined(FEAT_GUI) || defined(PROTO)
9166 * Free all the highlight group fonts.
9167 * Used when quitting for systems which need it.
9170 free_highlight_fonts()
9174 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
9176 gui_mch_free_font(HL_TABLE()[idx
].sg_font
);
9177 HL_TABLE()[idx
].sg_font
= NOFONT
;
9178 # ifdef FEAT_XFONTSET
9179 gui_mch_free_fontset(HL_TABLE()[idx
].sg_fontset
);
9180 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
9184 gui_mch_free_font(gui
.norm_font
);
9185 # ifdef FEAT_XFONTSET
9186 gui_mch_free_fontset(gui
.fontset
);
9189 gui_mch_free_font(gui
.bold_font
);
9190 gui_mch_free_font(gui
.ital_font
);
9191 gui_mch_free_font(gui
.boldital_font
);
9196 /**************************************
9197 * End of Highlighting stuff *
9198 **************************************/