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
))
4170 for (kp
= HI2KE(hi
); kp
!= NULL
; kp
= kp_next
)
4172 kp_next
= kp
->ke_next
;
4173 vim_free(kp
->next_list
);
4174 vim_free(kp
->k_syn
.cont_in_list
);
4184 * Add a keyword to the list of keywords.
4187 add_keyword(name
, id
, flags
, cont_in_list
, next_list
)
4188 char_u
*name
; /* name of keyword */
4189 int id
; /* group ID for this keyword */
4190 int flags
; /* flags for this keyword */
4191 short *cont_in_list
; /* containedin for this keyword */
4192 short *next_list
; /* nextgroup for this keyword */
4199 char_u name_folded
[MAXKEYWLEN
+ 1];
4201 if (curbuf
->b_syn_ic
)
4202 name_ic
= str_foldcase(name
, (int)STRLEN(name
),
4203 name_folded
, MAXKEYWLEN
+ 1);
4206 kp
= (keyentry_T
*)alloc((int)(sizeof(keyentry_T
) + STRLEN(name_ic
)));
4209 STRCPY(kp
->keyword
, name_ic
);
4211 kp
->k_syn
.inc_tag
= current_syn_inc_tag
;
4213 kp
->k_syn
.cont_in_list
= copy_id_list(cont_in_list
);
4214 if (cont_in_list
!= NULL
)
4215 curbuf
->b_syn_containedin
= TRUE
;
4216 kp
->next_list
= copy_id_list(next_list
);
4218 if (curbuf
->b_syn_ic
)
4219 ht
= &curbuf
->b_keywtab_ic
;
4221 ht
= &curbuf
->b_keywtab
;
4223 hash
= hash_hash(kp
->keyword
);
4224 hi
= hash_lookup(ht
, kp
->keyword
, hash
);
4225 if (HASHITEM_EMPTY(hi
))
4227 /* new keyword, add to hashtable */
4229 hash_add_item(ht
, hi
, kp
->keyword
, hash
);
4233 /* keyword already exists, prepend to list */
4234 kp
->ke_next
= HI2KE(hi
);
4235 hi
->hi_key
= KE2HIKEY(kp
);
4240 * Get the start and end of the group name argument.
4241 * Return a pointer to the first argument.
4242 * Return NULL if the end of the command was found instead of further args.
4245 get_group_name(arg
, name_end
)
4246 char_u
*arg
; /* start of the argument */
4247 char_u
**name_end
; /* pointer to end of the name */
4251 *name_end
= skiptowhite(arg
);
4252 rest
= skipwhite(*name_end
);
4255 * Check if there are enough arguments. The first argument may be a
4256 * pattern, where '|' is allowed, so only check for NUL.
4258 if (ends_excmd(*arg
) || *rest
== NUL
)
4264 * Check for syntax command option arguments.
4265 * This can be called at any place in the list of arguments, and just picks
4266 * out the arguments that are known. Can be called several times in a row to
4267 * collect all options in between other arguments.
4268 * Return a pointer to the next argument (which isn't an option).
4269 * Return NULL for any error;
4272 get_syn_options(arg
, opt
)
4273 char_u
*arg
; /* next argument to be checked */
4274 syn_opt_arg_T
*opt
; /* various things */
4276 char_u
*gname_start
, *gname
;
4287 } flagtab
[] = { {"cCoOnNtTaAiInNeEdD", 0, HL_CONTAINED
},
4288 {"oOnNeElLiInNeE", 0, HL_ONELINE
},
4289 {"kKeEeEpPeEnNdD", 0, HL_KEEPEND
},
4290 {"eExXtTeEnNdD", 0, HL_EXTEND
},
4291 {"eExXcClLuUdDeEnNlL", 0, HL_EXCLUDENL
},
4292 {"tTrRaAnNsSpPaArReEnNtT", 0, HL_TRANSP
},
4293 {"sSkKiIpPnNlL", 0, HL_SKIPNL
},
4294 {"sSkKiIpPwWhHiItTeE", 0, HL_SKIPWHITE
},
4295 {"sSkKiIpPeEmMpPtTyY", 0, HL_SKIPEMPTY
},
4296 {"gGrRoOuUpPhHeErReE", 0, HL_SYNC_HERE
},
4297 {"gGrRoOuUpPtThHeErReE", 0, HL_SYNC_THERE
},
4298 {"dDiIsSpPlLaAyY", 0, HL_DISPLAY
},
4299 {"fFoOlLdD", 0, HL_FOLD
},
4300 {"cCoOnNtTaAiInNsS", 1, 0},
4301 {"cCoOnNtTaAiInNeEdDiInN", 2, 0},
4302 {"nNeExXtTgGrRoOuUpP", 3, 0},
4304 static char *first_letters
= "cCoOkKeEtTsSgGdDfFnN";
4306 if (arg
== NULL
) /* already detected error */
4312 * This is used very often when a large number of keywords is defined.
4313 * Need to skip quickly when no option name is found.
4314 * Also avoid tolower(), it's slow.
4316 if (strchr(first_letters
, *arg
) == NULL
)
4319 for (fidx
= sizeof(flagtab
) / sizeof(struct flag
); --fidx
>= 0; )
4321 p
= flagtab
[fidx
].name
;
4322 for (i
= 0, len
= 0; p
[i
] != NUL
; i
+= 2, ++len
)
4323 if (arg
[len
] != p
[i
] && arg
[len
] != p
[i
+ 1])
4325 if (p
[i
] == NUL
&& (vim_iswhite(arg
[len
])
4326 || (flagtab
[fidx
].argtype
> 0
4328 : ends_excmd(arg
[len
]))))
4331 && (flagtab
[fidx
].flags
== HL_DISPLAY
4332 || flagtab
[fidx
].flags
== HL_FOLD
4333 || flagtab
[fidx
].flags
== HL_EXTEND
))
4334 /* treat "display", "fold" and "extend" as a keyword */
4339 if (fidx
< 0) /* no match found */
4342 if (flagtab
[fidx
].argtype
== 1)
4344 if (!opt
->has_cont_list
)
4346 EMSG(_("E395: contains argument not accepted here"));
4349 if (get_id_list(&arg
, 8, &opt
->cont_list
) == FAIL
)
4352 else if (flagtab
[fidx
].argtype
== 2)
4354 #if 0 /* cannot happen */
4355 if (opt
->cont_in_list
== NULL
)
4357 EMSG(_("E396: containedin argument not accepted here"));
4361 if (get_id_list(&arg
, 11, &opt
->cont_in_list
) == FAIL
)
4364 else if (flagtab
[fidx
].argtype
== 3)
4366 if (get_id_list(&arg
, 9, &opt
->next_list
) == FAIL
)
4371 opt
->flags
|= flagtab
[fidx
].flags
;
4372 arg
= skipwhite(arg
+ len
);
4374 if (flagtab
[fidx
].flags
== HL_SYNC_HERE
4375 || flagtab
[fidx
].flags
== HL_SYNC_THERE
)
4377 if (opt
->sync_idx
== NULL
)
4379 EMSG(_("E393: group[t]here not accepted here"));
4383 arg
= skiptowhite(arg
);
4384 if (gname_start
== arg
)
4386 gname
= vim_strnsave(gname_start
, (int)(arg
- gname_start
));
4389 if (STRCMP(gname
, "NONE") == 0)
4390 *opt
->sync_idx
= NONE_IDX
;
4393 syn_id
= syn_name2id(gname
);
4394 for (i
= curbuf
->b_syn_patterns
.ga_len
; --i
>= 0; )
4395 if (SYN_ITEMS(curbuf
)[i
].sp_syn
.id
== syn_id
4396 && SYN_ITEMS(curbuf
)[i
].sp_type
== SPTYPE_START
)
4403 EMSG2(_("E394: Didn't find region item for %s"), gname
);
4410 arg
= skipwhite(arg
);
4413 else if (flagtab
[fidx
].flags
== HL_FOLD
4414 && foldmethodIsSyntax(curwin
))
4415 /* Need to update folds later. */
4416 foldUpdateAll(curwin
);
4425 * Adjustments to syntax item when declared in a ":syn include"'d file.
4426 * Set the contained flag, and if the item is not already contained, add it
4427 * to the specified top-level group, if any.
4430 syn_incl_toplevel(id
, flagsp
)
4434 if ((*flagsp
& HL_CONTAINED
) || curbuf
->b_syn_topgrp
== 0)
4436 *flagsp
|= HL_CONTAINED
;
4437 if (curbuf
->b_syn_topgrp
>= SYNID_CLUSTER
)
4439 /* We have to alloc this, because syn_combine_list() will free it. */
4440 short *grp_list
= (short *)alloc((unsigned)(2 * sizeof(short)));
4441 int tlg_id
= curbuf
->b_syn_topgrp
- SYNID_CLUSTER
;
4443 if (grp_list
!= NULL
)
4447 syn_combine_list(&SYN_CLSTR(curbuf
)[tlg_id
].scl_list
, &grp_list
,
4454 * Handle ":syntax include [@{group-name}] filename" command.
4457 syn_cmd_include(eap
, syncing
)
4461 char_u
*arg
= eap
->arg
;
4463 char_u
*group_name_end
;
4465 char_u
*errormsg
= NULL
;
4466 int prev_toplvl_grp
;
4467 int prev_syn_inc_tag
;
4470 eap
->nextcmd
= find_nextcmd(arg
);
4477 rest
= get_group_name(arg
, &group_name_end
);
4480 EMSG((char_u
*)_("E397: Filename required"));
4483 sgl_id
= syn_check_cluster(arg
, (int)(group_name_end
- arg
));
4484 /* separate_nextcmd() and expand_filename() depend on this */
4489 * Everything that's left, up to the next command, should be the
4490 * filename to include.
4492 eap
->argt
|= (XFILE
| NOSPC
);
4493 separate_nextcmd(eap
);
4494 if (*eap
->arg
== '<' || *eap
->arg
== '$' || mch_isFullName(eap
->arg
))
4496 /* For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the
4497 * file. Need to expand the file name first. In other cases
4498 * ":runtime!" is used. */
4500 if (expand_filename(eap
, syn_cmdlinep
, &errormsg
) == FAIL
)
4502 if (errormsg
!= NULL
)
4509 * Save and restore the existing top-level grouplist id and ":syn
4510 * include" tag around the actual inclusion.
4512 prev_syn_inc_tag
= current_syn_inc_tag
;
4513 current_syn_inc_tag
= ++running_syn_inc_tag
;
4514 prev_toplvl_grp
= curbuf
->b_syn_topgrp
;
4515 curbuf
->b_syn_topgrp
= sgl_id
;
4516 if (source
? do_source(eap
->arg
, FALSE
, DOSO_NONE
) == FAIL
4517 : source_runtime(eap
->arg
, TRUE
) == FAIL
)
4518 EMSG2(_(e_notopen
), eap
->arg
);
4519 curbuf
->b_syn_topgrp
= prev_toplvl_grp
;
4520 current_syn_inc_tag
= prev_syn_inc_tag
;
4524 * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
4527 syn_cmd_keyword(eap
, syncing
)
4531 char_u
*arg
= eap
->arg
;
4532 char_u
*group_name_end
;
4535 char_u
*keyword_copy
;
4538 syn_opt_arg_T syn_opt_arg
;
4541 rest
= get_group_name(arg
, &group_name_end
);
4545 syn_id
= syn_check_group(arg
, (int)(group_name_end
- arg
));
4547 /* allocate a buffer, for removing the backslashes in the keyword */
4548 keyword_copy
= alloc((unsigned)STRLEN(rest
) + 1);
4549 if (keyword_copy
!= NULL
)
4551 syn_opt_arg
.flags
= 0;
4552 syn_opt_arg
.keyword
= TRUE
;
4553 syn_opt_arg
.sync_idx
= NULL
;
4554 syn_opt_arg
.has_cont_list
= FALSE
;
4555 syn_opt_arg
.cont_in_list
= NULL
;
4556 syn_opt_arg
.next_list
= NULL
;
4559 * The options given apply to ALL keywords, so all options must be
4560 * found before keywords can be created.
4561 * 1: collect the options and copy the keywords to keyword_copy.
4565 for ( ; rest
!= NULL
&& !ends_excmd(*rest
); rest
= skipwhite(rest
))
4567 rest
= get_syn_options(rest
, &syn_opt_arg
);
4568 if (rest
== NULL
|| ends_excmd(*rest
))
4570 /* Copy the keyword, removing backslashes, and add a NUL. */
4571 while (*rest
!= NUL
&& !vim_iswhite(*rest
))
4573 if (*rest
== '\\' && rest
[1] != NUL
)
4583 /* Adjust flags for use of ":syn include". */
4584 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4587 * 2: Add an entry for each keyword.
4589 for (kw
= keyword_copy
; --cnt
>= 0; kw
+= STRLEN(kw
) + 1)
4591 for (p
= vim_strchr(kw
, '['); ; )
4595 add_keyword(kw
, syn_id
, syn_opt_arg
.flags
,
4596 syn_opt_arg
.cont_in_list
,
4597 syn_opt_arg
.next_list
);
4602 EMSG2(_("E789: Missing ']': %s"), kw
);
4603 kw
= p
+ 2; /* skip over the NUL */
4608 kw
= p
+ 1; /* skip over the "]" */
4614 int l
= (*mb_ptr2len
)(p
+ 1);
4616 mch_memmove(p
, p
+ 1, l
);
4629 vim_free(keyword_copy
);
4630 vim_free(syn_opt_arg
.cont_in_list
);
4631 vim_free(syn_opt_arg
.next_list
);
4636 eap
->nextcmd
= check_nextcmd(rest
);
4638 EMSG2(_(e_invarg2
), arg
);
4640 redraw_curbuf_later(SOME_VALID
);
4641 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4645 * Handle ":syntax match {name} [{options}] {pattern} [{options}]".
4647 * Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
4650 syn_cmd_match(eap
, syncing
)
4652 int syncing
; /* TRUE for ":syntax sync match .. " */
4654 char_u
*arg
= eap
->arg
;
4655 char_u
*group_name_end
;
4657 synpat_T item
; /* the item found in the line */
4660 syn_opt_arg_T syn_opt_arg
;
4663 /* Isolate the group name, check for validity */
4664 rest
= get_group_name(arg
, &group_name_end
);
4666 /* Get options before the pattern */
4667 syn_opt_arg
.flags
= 0;
4668 syn_opt_arg
.keyword
= FALSE
;
4669 syn_opt_arg
.sync_idx
= syncing
? &sync_idx
: NULL
;
4670 syn_opt_arg
.has_cont_list
= TRUE
;
4671 syn_opt_arg
.cont_list
= NULL
;
4672 syn_opt_arg
.cont_in_list
= NULL
;
4673 syn_opt_arg
.next_list
= NULL
;
4674 rest
= get_syn_options(rest
, &syn_opt_arg
);
4676 /* get the pattern. */
4677 init_syn_patterns();
4678 vim_memset(&item
, 0, sizeof(item
));
4679 rest
= get_syn_pattern(rest
, &item
);
4680 if (vim_regcomp_had_eol() && !(syn_opt_arg
.flags
& HL_EXCLUDENL
))
4681 syn_opt_arg
.flags
|= HL_HAS_EOL
;
4683 /* Get options after the pattern */
4684 rest
= get_syn_options(rest
, &syn_opt_arg
);
4686 if (rest
!= NULL
) /* all arguments are valid */
4689 * Check for trailing command and illegal trailing arguments.
4691 eap
->nextcmd
= check_nextcmd(rest
);
4692 if (!ends_excmd(*rest
) || eap
->skip
)
4694 else if (ga_grow(&curbuf
->b_syn_patterns
, 1) != FAIL
4695 && (syn_id
= syn_check_group(arg
,
4696 (int)(group_name_end
- arg
))) != 0)
4698 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4700 * Store the pattern in the syn_items list
4702 idx
= curbuf
->b_syn_patterns
.ga_len
;
4703 SYN_ITEMS(curbuf
)[idx
] = item
;
4704 SYN_ITEMS(curbuf
)[idx
].sp_syncing
= syncing
;
4705 SYN_ITEMS(curbuf
)[idx
].sp_type
= SPTYPE_MATCH
;
4706 SYN_ITEMS(curbuf
)[idx
].sp_syn
.id
= syn_id
;
4707 SYN_ITEMS(curbuf
)[idx
].sp_syn
.inc_tag
= current_syn_inc_tag
;
4708 SYN_ITEMS(curbuf
)[idx
].sp_flags
= syn_opt_arg
.flags
;
4709 SYN_ITEMS(curbuf
)[idx
].sp_sync_idx
= sync_idx
;
4710 SYN_ITEMS(curbuf
)[idx
].sp_cont_list
= syn_opt_arg
.cont_list
;
4711 SYN_ITEMS(curbuf
)[idx
].sp_syn
.cont_in_list
=
4712 syn_opt_arg
.cont_in_list
;
4713 if (syn_opt_arg
.cont_in_list
!= NULL
)
4714 curbuf
->b_syn_containedin
= TRUE
;
4715 SYN_ITEMS(curbuf
)[idx
].sp_next_list
= syn_opt_arg
.next_list
;
4716 ++curbuf
->b_syn_patterns
.ga_len
;
4718 /* remember that we found a match for syncing on */
4719 if (syn_opt_arg
.flags
& (HL_SYNC_HERE
|HL_SYNC_THERE
))
4720 curbuf
->b_syn_sync_flags
|= SF_MATCH
;
4722 if (syn_opt_arg
.flags
& HL_FOLD
)
4723 ++curbuf
->b_syn_folditems
;
4726 redraw_curbuf_later(SOME_VALID
);
4727 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4728 return; /* don't free the progs and patterns now */
4733 * Something failed, free the allocated memory.
4735 vim_free(item
.sp_prog
);
4736 vim_free(item
.sp_pattern
);
4737 vim_free(syn_opt_arg
.cont_list
);
4738 vim_free(syn_opt_arg
.cont_in_list
);
4739 vim_free(syn_opt_arg
.next_list
);
4742 EMSG2(_(e_invarg2
), arg
);
4746 * Handle ":syntax region {group-name} [matchgroup={group-name}]
4747 * start {start} .. [skip {skip}] end {end} .. [{options}]".
4750 syn_cmd_region(eap
, syncing
)
4752 int syncing
; /* TRUE for ":syntax sync region .." */
4754 char_u
*arg
= eap
->arg
;
4755 char_u
*group_name_end
;
4756 char_u
*rest
; /* next arg, NULL on error */
4761 #define ITEM_START 0
4764 #define ITEM_MATCHGROUP 3
4767 synpat_T
*pp_synp
; /* pointer to syn_pattern */
4768 int pp_matchgroup_id
; /* matchgroup ID */
4769 struct pat_ptr
*pp_next
; /* pointer to next pat_ptr */
4771 /* patterns found in the line */
4772 struct pat_ptr
*ppp
;
4773 struct pat_ptr
*ppp_next
;
4774 int pat_count
= 0; /* nr of syn_patterns found */
4776 int matchgroup_id
= 0;
4777 int not_enough
= FALSE
; /* not enough arguments */
4778 int illegal
= FALSE
; /* illegal arguments */
4779 int success
= FALSE
;
4781 syn_opt_arg_T syn_opt_arg
;
4783 /* Isolate the group name, check for validity */
4784 rest
= get_group_name(arg
, &group_name_end
);
4790 init_syn_patterns();
4792 syn_opt_arg
.flags
= 0;
4793 syn_opt_arg
.keyword
= FALSE
;
4794 syn_opt_arg
.sync_idx
= NULL
;
4795 syn_opt_arg
.has_cont_list
= TRUE
;
4796 syn_opt_arg
.cont_list
= NULL
;
4797 syn_opt_arg
.cont_in_list
= NULL
;
4798 syn_opt_arg
.next_list
= NULL
;
4801 * get the options, patterns and matchgroup.
4803 while (rest
!= NULL
&& !ends_excmd(*rest
))
4805 /* Check for option arguments */
4806 rest
= get_syn_options(rest
, &syn_opt_arg
);
4807 if (rest
== NULL
|| ends_excmd(*rest
))
4810 /* must be a pattern or matchgroup then */
4812 while (*key_end
&& !vim_iswhite(*key_end
) && *key_end
!= '=')
4815 key
= vim_strnsave_up(rest
, (int)(key_end
- rest
));
4816 if (key
== NULL
) /* out of memory */
4821 if (STRCMP(key
, "MATCHGROUP") == 0)
4822 item
= ITEM_MATCHGROUP
;
4823 else if (STRCMP(key
, "START") == 0)
4825 else if (STRCMP(key
, "END") == 0)
4827 else if (STRCMP(key
, "SKIP") == 0)
4829 if (pat_ptrs
[ITEM_SKIP
] != NULL
) /* one skip pattern allowed */
4838 rest
= skipwhite(key_end
);
4842 EMSG2(_("E398: Missing '=': %s"), arg
);
4845 rest
= skipwhite(rest
+ 1);
4852 if (item
== ITEM_MATCHGROUP
)
4854 p
= skiptowhite(rest
);
4855 if ((p
- rest
== 4 && STRNCMP(rest
, "NONE", 4) == 0) || eap
->skip
)
4859 matchgroup_id
= syn_check_group(rest
, (int)(p
- rest
));
4860 if (matchgroup_id
== 0)
4866 rest
= skipwhite(p
);
4871 * Allocate room for a syn_pattern, and link it in the list of
4872 * syn_patterns for this item, at the start (because the list is
4873 * used from end to start).
4875 ppp
= (struct pat_ptr
*)alloc((unsigned)sizeof(struct pat_ptr
));
4881 ppp
->pp_next
= pat_ptrs
[item
];
4882 pat_ptrs
[item
] = ppp
;
4883 ppp
->pp_synp
= (synpat_T
*)alloc_clear((unsigned)sizeof(synpat_T
));
4884 if (ppp
->pp_synp
== NULL
)
4891 * Get the syntax pattern and the following offset(s).
4893 /* Enable the appropriate \z specials. */
4894 if (item
== ITEM_START
)
4895 reg_do_extmatch
= REX_SET
;
4896 else if (item
== ITEM_SKIP
|| item
== ITEM_END
)
4897 reg_do_extmatch
= REX_USE
;
4898 rest
= get_syn_pattern(rest
, ppp
->pp_synp
);
4899 reg_do_extmatch
= 0;
4900 if (item
== ITEM_END
&& vim_regcomp_had_eol()
4901 && !(syn_opt_arg
.flags
& HL_EXCLUDENL
))
4902 ppp
->pp_synp
->sp_flags
|= HL_HAS_EOL
;
4903 ppp
->pp_matchgroup_id
= matchgroup_id
;
4908 if (illegal
|| not_enough
)
4912 * Must have a "start" and "end" pattern.
4914 if (rest
!= NULL
&& (pat_ptrs
[ITEM_START
] == NULL
||
4915 pat_ptrs
[ITEM_END
] == NULL
))
4924 * Check for trailing garbage or command.
4925 * If OK, add the item.
4927 eap
->nextcmd
= check_nextcmd(rest
);
4928 if (!ends_excmd(*rest
) || eap
->skip
)
4930 else if (ga_grow(&(curbuf
->b_syn_patterns
), pat_count
) != FAIL
4931 && (syn_id
= syn_check_group(arg
,
4932 (int)(group_name_end
- arg
))) != 0)
4934 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4936 * Store the start/skip/end in the syn_items list
4938 idx
= curbuf
->b_syn_patterns
.ga_len
;
4939 for (item
= ITEM_START
; item
<= ITEM_END
; ++item
)
4941 for (ppp
= pat_ptrs
[item
]; ppp
!= NULL
; ppp
= ppp
->pp_next
)
4943 SYN_ITEMS(curbuf
)[idx
] = *(ppp
->pp_synp
);
4944 SYN_ITEMS(curbuf
)[idx
].sp_syncing
= syncing
;
4945 SYN_ITEMS(curbuf
)[idx
].sp_type
=
4946 (item
== ITEM_START
) ? SPTYPE_START
:
4947 (item
== ITEM_SKIP
) ? SPTYPE_SKIP
: SPTYPE_END
;
4948 SYN_ITEMS(curbuf
)[idx
].sp_flags
|= syn_opt_arg
.flags
;
4949 SYN_ITEMS(curbuf
)[idx
].sp_syn
.id
= syn_id
;
4950 SYN_ITEMS(curbuf
)[idx
].sp_syn
.inc_tag
= current_syn_inc_tag
;
4951 SYN_ITEMS(curbuf
)[idx
].sp_syn_match_id
=
4952 ppp
->pp_matchgroup_id
;
4953 if (item
== ITEM_START
)
4955 SYN_ITEMS(curbuf
)[idx
].sp_cont_list
=
4956 syn_opt_arg
.cont_list
;
4957 SYN_ITEMS(curbuf
)[idx
].sp_syn
.cont_in_list
=
4958 syn_opt_arg
.cont_in_list
;
4959 if (syn_opt_arg
.cont_in_list
!= NULL
)
4960 curbuf
->b_syn_containedin
= TRUE
;
4961 SYN_ITEMS(curbuf
)[idx
].sp_next_list
=
4962 syn_opt_arg
.next_list
;
4964 ++curbuf
->b_syn_patterns
.ga_len
;
4967 if (syn_opt_arg
.flags
& HL_FOLD
)
4968 ++curbuf
->b_syn_folditems
;
4973 redraw_curbuf_later(SOME_VALID
);
4974 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4975 success
= TRUE
; /* don't free the progs and patterns now */
4980 * Free the allocated memory.
4982 for (item
= ITEM_START
; item
<= ITEM_END
; ++item
)
4983 for (ppp
= pat_ptrs
[item
]; ppp
!= NULL
; ppp
= ppp_next
)
4987 vim_free(ppp
->pp_synp
->sp_prog
);
4988 vim_free(ppp
->pp_synp
->sp_pattern
);
4990 vim_free(ppp
->pp_synp
);
4991 ppp_next
= ppp
->pp_next
;
4997 vim_free(syn_opt_arg
.cont_list
);
4998 vim_free(syn_opt_arg
.cont_in_list
);
4999 vim_free(syn_opt_arg
.next_list
);
5001 EMSG2(_("E399: Not enough arguments: syntax region %s"), arg
);
5002 else if (illegal
|| rest
== NULL
)
5003 EMSG2(_(e_invarg2
), arg
);
5008 * A simple syntax group ID comparison function suitable for use in qsort()
5014 syn_compare_stub(v1
, v2
)
5018 const short *s1
= v1
;
5019 const short *s2
= v2
;
5021 return (*s1
> *s2
? 1 : *s1
< *s2
? -1 : 0);
5025 * Combines lists of syntax clusters.
5026 * *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
5029 syn_combine_list(clstr1
, clstr2
, list_op
)
5038 short *clstr
= NULL
;
5043 * Handle degenerate cases.
5045 if (*clstr2
== NULL
)
5047 if (*clstr1
== NULL
|| list_op
== CLUSTER_REPLACE
)
5049 if (list_op
== CLUSTER_REPLACE
)
5051 if (list_op
== CLUSTER_REPLACE
|| list_op
== CLUSTER_ADD
)
5058 for (g1
= *clstr1
; *g1
; g1
++)
5060 for (g2
= *clstr2
; *g2
; g2
++)
5064 * For speed purposes, sort both lists.
5066 qsort(*clstr1
, (size_t)count1
, sizeof(short), syn_compare_stub
);
5067 qsort(*clstr2
, (size_t)count2
, sizeof(short), syn_compare_stub
);
5070 * We proceed in two passes; in round 1, we count the elements to place
5071 * in the new list, and in round 2, we allocate and populate the new
5072 * list. For speed, we use a mergesort-like method, adding the smaller
5073 * of the current elements in each list to the new list.
5075 for (round
= 1; round
<= 2; round
++)
5082 * First, loop through the lists until one of them is empty.
5087 * We always want to add from the first list.
5098 * We only want to add from the second list if we're adding the
5101 if (list_op
== CLUSTER_ADD
)
5113 * Now add the leftovers from whichever list didn't get finished
5114 * first. As before, we only want to add from the second list if
5115 * we're adding the lists.
5117 for (; *g1
; g1
++, count
++)
5120 if (list_op
== CLUSTER_ADD
)
5121 for (; *g2
; g2
++, count
++)
5128 * If the group ended up empty, we don't need to allocate any
5136 clstr
= (short *)alloc((unsigned)((count
+ 1) * sizeof(short)));
5144 * Finally, put the new list in place.
5152 * Lookup a syntax cluster name and return it's ID.
5153 * If it is not found, 0 is returned.
5156 syn_scl_name2id(name
)
5162 /* Avoid using stricmp() too much, it's slow on some systems */
5163 name_u
= vim_strsave_up(name
);
5166 for (i
= curbuf
->b_syn_clusters
.ga_len
; --i
>= 0; )
5167 if (SYN_CLSTR(curbuf
)[i
].scl_name_u
!= NULL
5168 && STRCMP(name_u
, SYN_CLSTR(curbuf
)[i
].scl_name_u
) == 0)
5171 return (i
< 0 ? 0 : i
+ SYNID_CLUSTER
);
5175 * Like syn_scl_name2id(), but take a pointer + length argument.
5178 syn_scl_namen2id(linep
, len
)
5185 name
= vim_strnsave(linep
, len
);
5188 id
= syn_scl_name2id(name
);
5195 * Find syntax cluster name in the table and return it's ID.
5196 * The argument is a pointer to the name and the length of the name.
5197 * If it doesn't exist yet, a new entry is created.
5198 * Return 0 for failure.
5201 syn_check_cluster(pp
, len
)
5208 name
= vim_strnsave(pp
, len
);
5212 id
= syn_scl_name2id(name
);
5213 if (id
== 0) /* doesn't exist yet */
5214 id
= syn_add_cluster(name
);
5221 * Add new syntax cluster and return it's ID.
5222 * "name" must be an allocated string, it will be consumed.
5223 * Return 0 for failure.
5226 syn_add_cluster(name
)
5232 * First call for this growarray: init growing array.
5234 if (curbuf
->b_syn_clusters
.ga_data
== NULL
)
5236 curbuf
->b_syn_clusters
.ga_itemsize
= sizeof(syn_cluster_T
);
5237 curbuf
->b_syn_clusters
.ga_growsize
= 10;
5241 * Make room for at least one other cluster entry.
5243 if (ga_grow(&curbuf
->b_syn_clusters
, 1) == FAIL
)
5248 len
= curbuf
->b_syn_clusters
.ga_len
;
5250 vim_memset(&(SYN_CLSTR(curbuf
)[len
]), 0, sizeof(syn_cluster_T
));
5251 SYN_CLSTR(curbuf
)[len
].scl_name
= name
;
5252 SYN_CLSTR(curbuf
)[len
].scl_name_u
= vim_strsave_up(name
);
5253 SYN_CLSTR(curbuf
)[len
].scl_list
= NULL
;
5254 ++curbuf
->b_syn_clusters
.ga_len
;
5256 if (STRICMP(name
, "Spell") == 0)
5257 curbuf
->b_spell_cluster_id
= len
+ SYNID_CLUSTER
;
5258 if (STRICMP(name
, "NoSpell") == 0)
5259 curbuf
->b_nospell_cluster_id
= len
+ SYNID_CLUSTER
;
5261 return len
+ SYNID_CLUSTER
;
5265 * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
5266 * [add={groupname},..] [remove={groupname},..]".
5269 syn_cmd_cluster(eap
, syncing
)
5273 char_u
*arg
= eap
->arg
;
5274 char_u
*group_name_end
;
5278 int got_clstr
= FALSE
;
5282 eap
->nextcmd
= find_nextcmd(arg
);
5286 rest
= get_group_name(arg
, &group_name_end
);
5290 scl_id
= syn_check_cluster(arg
, (int)(group_name_end
- arg
))
5295 if (STRNICMP(rest
, "add", 3) == 0
5296 && (vim_iswhite(rest
[3]) || rest
[3] == '='))
5299 list_op
= CLUSTER_ADD
;
5301 else if (STRNICMP(rest
, "remove", 6) == 0
5302 && (vim_iswhite(rest
[6]) || rest
[6] == '='))
5305 list_op
= CLUSTER_SUBTRACT
;
5307 else if (STRNICMP(rest
, "contains", 8) == 0
5308 && (vim_iswhite(rest
[8]) || rest
[8] == '='))
5311 list_op
= CLUSTER_REPLACE
;
5317 if (get_id_list(&rest
, opt_len
, &clstr_list
) == FAIL
)
5319 EMSG2(_(e_invarg2
), rest
);
5322 syn_combine_list(&SYN_CLSTR(curbuf
)[scl_id
].scl_list
,
5323 &clstr_list
, list_op
);
5329 redraw_curbuf_later(SOME_VALID
);
5330 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
5335 EMSG(_("E400: No cluster specified"));
5336 if (rest
== NULL
|| !ends_excmd(*rest
))
5337 EMSG2(_(e_invarg2
), arg
);
5341 * On first call for current buffer: Init growing array.
5346 curbuf
->b_syn_patterns
.ga_itemsize
= sizeof(synpat_T
);
5347 curbuf
->b_syn_patterns
.ga_growsize
= 10;
5351 * Get one pattern for a ":syntax match" or ":syntax region" command.
5352 * Stores the pattern and program in a synpat_T.
5353 * Returns a pointer to the next argument, or NULL in case of an error.
5356 get_syn_pattern(arg
, ci
)
5365 /* need at least three chars */
5366 if (arg
== NULL
|| arg
[1] == NUL
|| arg
[2] == NUL
)
5369 end
= skip_regexp(arg
+ 1, *arg
, TRUE
, NULL
);
5370 if (*end
!= *arg
) /* end delimiter not found */
5372 EMSG2(_("E401: Pattern delimiter not found: %s"), arg
);
5375 /* store the pattern and compiled regexp program */
5376 if ((ci
->sp_pattern
= vim_strnsave(arg
+ 1, (int)(end
- arg
- 1))) == NULL
)
5379 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5381 p_cpo
= (char_u
*)"";
5382 ci
->sp_prog
= vim_regcomp(ci
->sp_pattern
, RE_MAGIC
);
5385 if (ci
->sp_prog
== NULL
)
5387 ci
->sp_ic
= curbuf
->b_syn_ic
;
5390 * Check for a match, highlight or region offset.
5395 for (idx
= SPO_COUNT
; --idx
>= 0; )
5396 if (STRNCMP(end
, spo_name_tab
[idx
], 3) == 0)
5400 p
= &(ci
->sp_offsets
[idx
]);
5401 if (idx
!= SPO_LC_OFF
)
5406 case 'e': idx
+= SPO_COUNT
; break;
5407 default: idx
= -1; break;
5411 ci
->sp_off_flags
|= (1 << idx
);
5412 if (idx
== SPO_LC_OFF
) /* lc=99 */
5415 *p
= getdigits(&end
);
5417 /* "lc=" offset automatically sets "ms=" offset */
5418 if (!(ci
->sp_off_flags
& (1 << SPO_MS_OFF
)))
5420 ci
->sp_off_flags
|= (1 << SPO_MS_OFF
);
5421 ci
->sp_offsets
[SPO_MS_OFF
] = *p
;
5430 *p
= getdigits(&end
); /* positive offset */
5432 else if (*end
== '-')
5435 *p
= -getdigits(&end
); /* negative offset */
5445 if (!ends_excmd(*end
) && !vim_iswhite(*end
))
5447 EMSG2(_("E402: Garbage after pattern: %s"), arg
);
5450 return skipwhite(end
);
5454 * Handle ":syntax sync .." command.
5457 syn_cmd_sync(eap
, syncing
)
5461 char_u
*arg_start
= eap
->arg
;
5465 int illegal
= FALSE
;
5466 int finished
= FALSE
;
5470 if (ends_excmd(*arg_start
))
5472 syn_cmd_list(eap
, TRUE
);
5476 while (!ends_excmd(*arg_start
))
5478 arg_end
= skiptowhite(arg_start
);
5479 next_arg
= skipwhite(arg_end
);
5481 key
= vim_strnsave_up(arg_start
, (int)(arg_end
- arg_start
));
5482 if (STRCMP(key
, "CCOMMENT") == 0)
5485 curbuf
->b_syn_sync_flags
|= SF_CCOMMENT
;
5486 if (!ends_excmd(*next_arg
))
5488 arg_end
= skiptowhite(next_arg
);
5490 curbuf
->b_syn_sync_id
= syn_check_group(next_arg
,
5491 (int)(arg_end
- next_arg
));
5492 next_arg
= skipwhite(arg_end
);
5494 else if (!eap
->skip
)
5495 curbuf
->b_syn_sync_id
= syn_name2id((char_u
*)"Comment");
5497 else if ( STRNCMP(key
, "LINES", 5) == 0
5498 || STRNCMP(key
, "MINLINES", 8) == 0
5499 || STRNCMP(key
, "MAXLINES", 8) == 0
5500 || STRNCMP(key
, "LINEBREAKS", 10) == 0)
5504 else if (key
[0] == 'L')
5508 if (arg_end
[-1] != '=' || !VIM_ISDIGIT(*arg_end
))
5513 n
= getdigits(&arg_end
);
5517 curbuf
->b_syn_sync_linebreaks
= n
;
5518 else if (key
[1] == 'A')
5519 curbuf
->b_syn_sync_maxlines
= n
;
5521 curbuf
->b_syn_sync_minlines
= n
;
5524 else if (STRCMP(key
, "FROMSTART") == 0)
5528 curbuf
->b_syn_sync_minlines
= MAXLNUM
;
5529 curbuf
->b_syn_sync_maxlines
= 0;
5532 else if (STRCMP(key
, "LINECONT") == 0)
5534 if (curbuf
->b_syn_linecont_pat
!= NULL
)
5536 EMSG(_("E403: syntax sync: line continuations pattern specified twice"));
5540 arg_end
= skip_regexp(next_arg
+ 1, *next_arg
, TRUE
, NULL
);
5541 if (*arg_end
!= *next_arg
) /* end delimiter not found */
5549 /* store the pattern and compiled regexp program */
5550 if ((curbuf
->b_syn_linecont_pat
= vim_strnsave(next_arg
+ 1,
5551 (int)(arg_end
- next_arg
- 1))) == NULL
)
5556 curbuf
->b_syn_linecont_ic
= curbuf
->b_syn_ic
;
5558 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5560 p_cpo
= (char_u
*)"";
5561 curbuf
->b_syn_linecont_prog
=
5562 vim_regcomp(curbuf
->b_syn_linecont_pat
, RE_MAGIC
);
5565 if (curbuf
->b_syn_linecont_prog
== NULL
)
5567 vim_free(curbuf
->b_syn_linecont_pat
);
5568 curbuf
->b_syn_linecont_pat
= NULL
;
5573 next_arg
= skipwhite(arg_end
+ 1);
5577 eap
->arg
= next_arg
;
5578 if (STRCMP(key
, "MATCH") == 0)
5579 syn_cmd_match(eap
, TRUE
);
5580 else if (STRCMP(key
, "REGION") == 0)
5581 syn_cmd_region(eap
, TRUE
);
5582 else if (STRCMP(key
, "CLEAR") == 0)
5583 syn_cmd_clear(eap
, TRUE
);
5589 arg_start
= next_arg
;
5593 EMSG2(_("E404: Illegal arguments: %s"), arg_start
);
5596 eap
->nextcmd
= check_nextcmd(arg_start
);
5597 redraw_curbuf_later(SOME_VALID
);
5598 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
5603 * Convert a line of highlight group names into a list of group ID numbers.
5604 * "arg" should point to the "contains" or "nextgroup" keyword.
5605 * "arg" is advanced to after the last group name.
5606 * Careful: the argument is modified (NULs added).
5607 * returns FAIL for some error, OK for success.
5610 get_id_list(arg
, keylen
, list
)
5612 int keylen
; /* length of keyword */
5613 short **list
; /* where to store the resulting list, if not
5614 NULL, the list is silently skipped! */
5620 int total_count
= 0;
5621 short *retval
= NULL
;
5623 regmatch_T regmatch
;
5629 * We parse the list twice:
5630 * round == 1: count the number of items, allocate the array.
5631 * round == 2: fill the array with the items.
5632 * In round 1 new groups may be added, causing the number of items to
5633 * grow when a regexp is used. In that case round 1 is done once again.
5635 for (round
= 1; round
<= 2; ++round
)
5640 p
= skipwhite(*arg
+ keylen
);
5643 EMSG2(_("E405: Missing equal sign: %s"), *arg
);
5646 p
= skipwhite(p
+ 1);
5649 EMSG2(_("E406: Empty argument: %s"), *arg
);
5654 * parse the arguments after "contains"
5657 while (!ends_excmd(*p
))
5659 for (end
= p
; *end
&& !vim_iswhite(*end
) && *end
!= ','; ++end
)
5661 name
= alloc((int)(end
- p
+ 3)); /* leave room for "^$" */
5667 vim_strncpy(name
+ 1, p
, end
- p
);
5668 if ( STRCMP(name
+ 1, "ALLBUT") == 0
5669 || STRCMP(name
+ 1, "ALL") == 0
5670 || STRCMP(name
+ 1, "TOP") == 0
5671 || STRCMP(name
+ 1, "CONTAINED") == 0)
5673 if (TOUPPER_ASC(**arg
) != 'C')
5675 EMSG2(_("E407: %s not allowed here"), name
+ 1);
5682 EMSG2(_("E408: %s must be first in contains list"), name
+ 1);
5689 else if (name
[1] == 'T')
5692 id
= SYNID_CONTAINED
;
5693 id
+= current_syn_inc_tag
;
5695 else if (name
[1] == '@')
5697 id
= syn_check_cluster(name
+ 2, (int)(end
- p
- 1));
5702 * Handle full group name.
5704 if (vim_strpbrk(name
+ 1, (char_u
*)"\\.*^$~[") == NULL
)
5705 id
= syn_check_group(name
+ 1, (int)(end
- p
));
5709 * Handle match of regexp with group names.
5713 regmatch
.regprog
= vim_regcomp(name
, RE_MAGIC
);
5714 if (regmatch
.regprog
== NULL
)
5721 regmatch
.rm_ic
= TRUE
;
5723 for (i
= highlight_ga
.ga_len
; --i
>= 0; )
5725 if (vim_regexec(®match
, HL_TABLE()[i
].sg_name
,
5730 /* Got more items than expected; can happen
5731 * when adding items that match:
5732 * "contains=a.*b,axb".
5733 * Go back to first round */
5734 if (count
>= total_count
)
5740 retval
[count
] = i
+ 1;
5743 id
= -1; /* remember that we found one */
5746 vim_free(regmatch
.regprog
);
5752 EMSG2(_("E409: Unknown group name: %s"), p
);
5760 /* Got more items than expected, go back to first round */
5761 if (count
>= total_count
)
5774 p
= skipwhite(p
+ 1); /* skip comma in between arguments */
5780 retval
= (short *)alloc((unsigned)((count
+ 1) * sizeof(short)));
5783 retval
[count
] = 0; /* zero means end of the list */
5784 total_count
= count
;
5789 if (failed
|| retval
== NULL
)
5798 vim_free(retval
); /* list already found, don't overwrite it */
5804 * Make a copy of an ID list.
5817 for (count
= 0; list
[count
]; ++count
)
5819 len
= (count
+ 1) * sizeof(short);
5820 retval
= (short *)alloc((unsigned)len
);
5822 mch_memmove(retval
, list
, (size_t)len
);
5828 * Check if syntax group "ssp" is in the ID list "list" of "cur_si".
5829 * "cur_si" can be NULL if not checking the "containedin" list.
5830 * Used to check if a syntax item is in the "contains" or "nextgroup" list of
5832 * This function is called very often, keep it fast!!
5835 in_id_list(cur_si
, list
, ssp
, contained
)
5836 stateitem_T
*cur_si
; /* current item or NULL */
5837 short *list
; /* id list */
5838 struct sp_syn
*ssp
; /* group id and ":syn include" tag of group */
5839 int contained
; /* group id is contained */
5845 static int depth
= 0;
5848 /* If spp has a "containedin" list and "cur_si" is in it, return TRUE. */
5849 if (cur_si
!= NULL
&& ssp
->cont_in_list
!= NULL
5850 && !(cur_si
->si_flags
& HL_MATCH
))
5852 /* Ignore transparent items without a contains argument. Double check
5853 * that we don't go back past the first one. */
5854 while ((cur_si
->si_flags
& HL_TRANS_CONT
)
5855 && cur_si
> (stateitem_T
*)(current_state
.ga_data
))
5857 /* cur_si->si_idx is -1 for keywords, these never contain anything. */
5858 if (cur_si
->si_idx
>= 0 && in_id_list(NULL
, ssp
->cont_in_list
,
5859 &(SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_syn
),
5860 SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_flags
& HL_CONTAINED
))
5868 * If list is ID_LIST_ALL, we are in a transparent item that isn't
5869 * inside anything. Only allow not-contained groups.
5871 if (list
== ID_LIST_ALL
)
5875 * If the first item is "ALLBUT", return TRUE if "id" is NOT in the
5876 * contains list. We also require that "id" is at the same ":syn include"
5877 * level as the list.
5880 if (item
>= SYNID_ALLBUT
&& item
< SYNID_CLUSTER
)
5882 if (item
< SYNID_TOP
)
5884 /* ALL or ALLBUT: accept all groups in the same file */
5885 if (item
- SYNID_ALLBUT
!= ssp
->inc_tag
)
5888 else if (item
< SYNID_CONTAINED
)
5890 /* TOP: accept all not-contained groups in the same file */
5891 if (item
- SYNID_TOP
!= ssp
->inc_tag
|| contained
)
5896 /* CONTAINED: accept all contained groups in the same file */
5897 if (item
- SYNID_CONTAINED
!= ssp
->inc_tag
|| !contained
)
5907 * Return "retval" if id is in the contains list.
5913 if (item
>= SYNID_CLUSTER
)
5915 scl_list
= SYN_CLSTR(syn_buf
)[item
- SYNID_CLUSTER
].scl_list
;
5916 /* restrict recursiveness to 30 to avoid an endless loop for a
5917 * cluster that includes itself (indirectly) */
5918 if (scl_list
!= NULL
&& depth
< 30)
5921 r
= in_id_list(NULL
, scl_list
, ssp
, contained
);
5934 char *name
; /* subcommand name */
5935 void (*func
)__ARGS((exarg_T
*, int)); /* function to call */
5938 static struct subcommand subcommands
[] =
5940 {"case", syn_cmd_case
},
5941 {"clear", syn_cmd_clear
},
5942 {"cluster", syn_cmd_cluster
},
5943 {"enable", syn_cmd_enable
},
5944 {"include", syn_cmd_include
},
5945 {"keyword", syn_cmd_keyword
},
5946 {"list", syn_cmd_list
},
5947 {"manual", syn_cmd_manual
},
5948 {"match", syn_cmd_match
},
5950 {"off", syn_cmd_off
},
5951 {"region", syn_cmd_region
},
5952 {"reset", syn_cmd_reset
},
5953 {"spell", syn_cmd_spell
},
5954 {"sync", syn_cmd_sync
},
5961 * This searches the subcommands[] table for the subcommand name, and calls a
5962 * syntax_subcommand() function to do the rest.
5968 char_u
*arg
= eap
->arg
;
5970 char_u
*subcmd_name
;
5973 syn_cmdlinep
= eap
->cmdlinep
;
5975 /* isolate subcommand name */
5976 for (subcmd_end
= arg
; ASCII_ISALPHA(*subcmd_end
); ++subcmd_end
)
5978 subcmd_name
= vim_strnsave(arg
, (int)(subcmd_end
- arg
));
5979 if (subcmd_name
!= NULL
)
5981 if (eap
->skip
) /* skip error messages for all subcommands */
5985 if (subcommands
[i
].name
== NULL
)
5987 EMSG2(_("E410: Invalid :syntax subcommand: %s"), subcmd_name
);
5990 if (STRCMP(subcmd_name
, (char_u
*)subcommands
[i
].name
) == 0)
5992 eap
->arg
= skipwhite(subcmd_end
);
5993 (subcommands
[i
].func
)(eap
, FALSE
);
5997 vim_free(subcmd_name
);
6007 return (buf
->b_syn_patterns
.ga_len
!= 0
6008 || buf
->b_syn_clusters
.ga_len
!= 0
6009 || buf
->b_keywtab
.ht_used
> 0
6010 || buf
->b_keywtab_ic
.ht_used
> 0);
6013 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
6017 EXP_SUBCMD
, /* expand ":syn" sub-commands */
6018 EXP_CASE
/* expand ":syn case" arguments */
6022 * Reset include_link, include_default, include_none to 0.
6023 * Called when we are done expanding.
6026 reset_expand_highlight()
6028 include_link
= include_default
= include_none
= 0;
6032 * Handle command line completion for :match and :echohl command: Add "None"
6033 * as highlight group.
6036 set_context_in_echohl_cmd(xp
, arg
)
6040 xp
->xp_context
= EXPAND_HIGHLIGHT
;
6041 xp
->xp_pattern
= arg
;
6046 * Handle command line completion for :syntax command.
6049 set_context_in_syntax_cmd(xp
, arg
)
6055 /* Default: expand subcommands */
6056 xp
->xp_context
= EXPAND_SYNTAX
;
6057 expand_what
= EXP_SUBCMD
;
6058 xp
->xp_pattern
= arg
;
6060 include_default
= 0;
6062 /* (part of) subcommand already typed */
6065 p
= skiptowhite(arg
);
6066 if (*p
!= NUL
) /* past first word */
6068 xp
->xp_pattern
= skipwhite(p
);
6069 if (*skiptowhite(xp
->xp_pattern
) != NUL
)
6070 xp
->xp_context
= EXPAND_NOTHING
;
6071 else if (STRNICMP(arg
, "case", p
- arg
) == 0)
6072 expand_what
= EXP_CASE
;
6073 else if ( STRNICMP(arg
, "keyword", p
- arg
) == 0
6074 || STRNICMP(arg
, "region", p
- arg
) == 0
6075 || STRNICMP(arg
, "match", p
- arg
) == 0
6076 || STRNICMP(arg
, "list", p
- arg
) == 0)
6077 xp
->xp_context
= EXPAND_HIGHLIGHT
;
6079 xp
->xp_context
= EXPAND_NOTHING
;
6084 static char *(case_args
[]) = {"match", "ignore", NULL
};
6087 * Function given to ExpandGeneric() to obtain the list syntax names for
6091 get_syntax_name(xp
, idx
)
6092 expand_T
*xp UNUSED
;
6095 if (expand_what
== EXP_SUBCMD
)
6096 return (char_u
*)subcommands
[idx
].name
;
6097 return (char_u
*)case_args
[idx
];
6100 #endif /* FEAT_CMDL_COMPL */
6103 * Function called for expression evaluation: get syntax ID at file position.
6106 syn_get_id(wp
, lnum
, col
, trans
, spellp
, keep_state
)
6110 int trans
; /* remove transparency */
6111 int *spellp
; /* return: can do spell checking */
6112 int keep_state
; /* keep state of char at "col" */
6114 /* When the position is not after the current position and in the same
6115 * line of the same buffer, need to restart parsing. */
6116 if (wp
->w_buffer
!= syn_buf
6117 || lnum
!= current_lnum
6118 || col
< current_col
)
6119 syntax_start(wp
, lnum
);
6121 (void)get_syntax_attr(col
, spellp
, keep_state
);
6123 return (trans
? current_trans_id
: current_id
);
6126 #if defined(FEAT_EVAL) || defined(PROTO)
6128 * Return the syntax ID at position "i" in the current stack.
6129 * The caller must have called syn_get_id() before to fill the stack.
6130 * Returns -1 when "i" is out of range.
6133 syn_get_stack_item(i
)
6136 if (i
>= current_state
.ga_len
)
6138 /* Need to invalidate the state, because we didn't properly finish it
6139 * for the last character, "keep_state" was TRUE. */
6140 invalidate_current_state();
6141 current_col
= MAXCOL
;
6144 return CUR_STATE(i
).si_id
;
6148 #if defined(FEAT_FOLDING) || defined(PROTO)
6150 * Function called to get folding level for line "lnum" in window "wp".
6153 syn_get_foldlevel(wp
, lnum
)
6160 /* Return quickly when there are no fold items at all. */
6161 if (wp
->w_buffer
->b_syn_folditems
!= 0)
6163 syntax_start(wp
, lnum
);
6165 for (i
= 0; i
< current_state
.ga_len
; ++i
)
6166 if (CUR_STATE(i
).si_flags
& HL_FOLD
)
6169 if (level
> wp
->w_p_fdn
)
6171 level
= wp
->w_p_fdn
;
6179 #endif /* FEAT_SYN_HL */
6182 /**************************************
6183 * Highlighting stuff *
6184 **************************************/
6187 * The default highlight groups. These are compiled-in for fast startup and
6188 * they still work when the runtime files can't be found.
6189 * When making changes here, also change runtime/colors/default.vim!
6190 * The #ifdefs are needed to reduce the amount of static data. Helps to make
6191 * the 16 bit DOS (museum) version compile.
6194 # define CENT(a, b) b
6196 # define CENT(a, b) a
6198 static char *(highlight_init_both
[]) =
6200 CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White",
6201 "ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"),
6202 #ifdef FEAT_SEARCH_EXTRA
6203 CENT("IncSearch term=reverse cterm=reverse",
6204 "IncSearch term=reverse cterm=reverse gui=reverse"),
6206 CENT("ModeMsg term=bold cterm=bold",
6207 "ModeMsg term=bold cterm=bold gui=bold"),
6208 CENT("NonText term=bold ctermfg=Blue",
6209 "NonText term=bold ctermfg=Blue gui=bold guifg=Blue"),
6210 CENT("StatusLine term=reverse,bold cterm=reverse,bold",
6211 "StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"),
6212 CENT("StatusLineNC term=reverse cterm=reverse",
6213 "StatusLineNC term=reverse cterm=reverse gui=reverse"),
6214 #ifdef FEAT_VERTSPLIT
6215 CENT("VertSplit term=reverse cterm=reverse",
6216 "VertSplit term=reverse cterm=reverse gui=reverse"),
6218 #ifdef FEAT_CLIPBOARD
6219 CENT("VisualNOS term=underline,bold cterm=underline,bold",
6220 "VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"),
6223 CENT("DiffText term=reverse cterm=bold ctermbg=Red",
6224 "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"),
6226 #ifdef FEAT_INS_EXPAND
6227 CENT("PmenuThumb cterm=reverse",
6228 "PmenuThumb cterm=reverse gui=reverse"),
6229 CENT("PmenuSbar ctermbg=Grey",
6230 "PmenuSbar ctermbg=Grey guibg=Grey"),
6233 CENT("TabLineSel term=bold cterm=bold",
6234 "TabLineSel term=bold cterm=bold gui=bold"),
6235 CENT("TabLineFill term=reverse cterm=reverse",
6236 "TabLineFill term=reverse cterm=reverse gui=reverse"),
6239 "Cursor guibg=fg guifg=bg",
6240 "lCursor guibg=fg guifg=bg", /* should be different, but what? */
6245 static char *(highlight_init_light
[]) =
6247 CENT("Directory term=bold ctermfg=DarkBlue",
6248 "Directory term=bold ctermfg=DarkBlue guifg=Blue"),
6249 CENT("LineNr term=underline ctermfg=Brown",
6250 "LineNr term=underline ctermfg=Brown guifg=Brown"),
6251 CENT("MoreMsg term=bold ctermfg=DarkGreen",
6252 "MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6253 CENT("Question term=standout ctermfg=DarkGreen",
6254 "Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6255 CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE",
6256 "Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"),
6258 CENT("SpellBad term=reverse ctermbg=LightRed",
6259 "SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"),
6260 CENT("SpellCap term=reverse ctermbg=LightBlue",
6261 "SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"),
6262 CENT("SpellRare term=reverse ctermbg=LightMagenta",
6263 "SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"),
6264 CENT("SpellLocal term=underline ctermbg=Cyan",
6265 "SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"),
6267 #ifdef FEAT_INS_EXPAND
6268 CENT("Pmenu ctermbg=LightMagenta",
6269 "Pmenu ctermbg=LightMagenta guibg=LightMagenta"),
6270 CENT("PmenuSel ctermbg=LightGrey",
6271 "PmenuSel ctermbg=LightGrey guibg=Grey"),
6273 CENT("SpecialKey term=bold ctermfg=DarkBlue",
6274 "SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"),
6275 CENT("Title term=bold ctermfg=DarkMagenta",
6276 "Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"),
6277 CENT("WarningMsg term=standout ctermfg=DarkRed",
6278 "WarningMsg term=standout ctermfg=DarkRed guifg=Red"),
6279 #ifdef FEAT_WILDMENU
6280 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6281 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6284 CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue",
6285 "Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"),
6286 CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6287 "FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6290 CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6291 "SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6294 CENT("Visual term=reverse",
6295 "Visual term=reverse guibg=LightGrey"),
6298 CENT("DiffAdd term=bold ctermbg=LightBlue",
6299 "DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"),
6300 CENT("DiffChange term=bold ctermbg=LightMagenta",
6301 "DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"),
6302 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan",
6303 "DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"),
6306 CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey",
6307 "TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"),
6310 CENT("CursorColumn term=reverse ctermbg=LightGrey",
6311 "CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"),
6312 CENT("CursorLine term=underline cterm=underline",
6313 "CursorLine term=underline cterm=underline guibg=Grey90"),
6316 CENT("MatchParen term=reverse ctermbg=Cyan",
6317 "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"),
6325 static char *(highlight_init_dark
[]) =
6327 CENT("Directory term=bold ctermfg=LightCyan",
6328 "Directory term=bold ctermfg=LightCyan guifg=Cyan"),
6329 CENT("LineNr term=underline ctermfg=Yellow",
6330 "LineNr term=underline ctermfg=Yellow guifg=Yellow"),
6331 CENT("MoreMsg term=bold ctermfg=LightGreen",
6332 "MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"),
6333 CENT("Question term=standout ctermfg=LightGreen",
6334 "Question term=standout ctermfg=LightGreen gui=bold guifg=Green"),
6335 CENT("Search term=reverse ctermbg=Yellow ctermfg=Black",
6336 "Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6337 CENT("SpecialKey term=bold ctermfg=LightBlue",
6338 "SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"),
6340 CENT("SpellBad term=reverse ctermbg=Red",
6341 "SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"),
6342 CENT("SpellCap term=reverse ctermbg=Blue",
6343 "SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"),
6344 CENT("SpellRare term=reverse ctermbg=Magenta",
6345 "SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"),
6346 CENT("SpellLocal term=underline ctermbg=Cyan",
6347 "SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"),
6349 #ifdef FEAT_INS_EXPAND
6350 CENT("Pmenu ctermbg=Magenta",
6351 "Pmenu ctermbg=Magenta guibg=Magenta"),
6352 CENT("PmenuSel ctermbg=DarkGrey",
6353 "PmenuSel ctermbg=DarkGrey guibg=DarkGrey"),
6355 CENT("Title term=bold ctermfg=LightMagenta",
6356 "Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"),
6357 CENT("WarningMsg term=standout ctermfg=LightRed",
6358 "WarningMsg term=standout ctermfg=LightRed guifg=Red"),
6359 #ifdef FEAT_WILDMENU
6360 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6361 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6364 CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan",
6365 "Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"),
6366 CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6367 "FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6370 CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6371 "SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6374 CENT("Visual term=reverse",
6375 "Visual term=reverse guibg=DarkGrey"),
6378 CENT("DiffAdd term=bold ctermbg=DarkBlue",
6379 "DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"),
6380 CENT("DiffChange term=bold ctermbg=DarkMagenta",
6381 "DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"),
6382 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan",
6383 "DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"),
6386 CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey",
6387 "TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"),
6390 CENT("CursorColumn term=reverse ctermbg=DarkGrey",
6391 "CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"),
6392 CENT("CursorLine term=underline cterm=underline",
6393 "CursorLine term=underline cterm=underline guibg=Grey40"),
6396 CENT("MatchParen term=reverse ctermbg=DarkCyan",
6397 "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"),
6406 init_highlight(both
, reset
)
6407 int both
; /* include groups where 'bg' doesn't matter */
6408 int reset
; /* clear group first */
6412 static int had_both
= FALSE
;
6417 * Try finding the color scheme file. Used when a color file was loaded
6418 * and 'background' or 't_Co' is changed.
6420 p
= get_var_value((char_u
*)"g:colors_name");
6421 if (p
!= NULL
&& load_colors(p
) == OK
)
6426 * Didn't use a color file, use the compiled-in colors.
6431 pp
= highlight_init_both
;
6432 for (i
= 0; pp
[i
] != NULL
; ++i
)
6433 do_highlight((char_u
*)pp
[i
], reset
, TRUE
);
6436 /* Don't do anything before the call with both == TRUE from main().
6437 * Not everything has been setup then, and that call will overrule
6438 * everything anyway. */
6442 pp
= highlight_init_light
;
6444 pp
= highlight_init_dark
;
6445 for (i
= 0; pp
[i
] != NULL
; ++i
)
6446 do_highlight((char_u
*)pp
[i
], reset
, TRUE
);
6448 /* Reverse looks ugly, but grey may not work for 8 colors. Thus let it
6449 * depend on the number of colors available.
6450 * With 8 colors brown is equal to yellow, need to use black for Search fg
6451 * to avoid Statement highlighted text disappears.
6452 * Clear the attributes, needed when changing the t_Co value. */
6454 do_highlight((char_u
*)(*p_bg
== 'l'
6455 ? "Visual cterm=NONE ctermbg=LightGrey"
6456 : "Visual cterm=NONE ctermbg=DarkGrey"), FALSE
, TRUE
);
6459 do_highlight((char_u
*)"Visual cterm=reverse ctermbg=NONE",
6462 do_highlight((char_u
*)"Search ctermfg=black", FALSE
, TRUE
);
6467 * If syntax highlighting is enabled load the highlighting for it.
6469 if (get_var_value((char_u
*)"g:syntax_on") != NULL
)
6471 static int recursive
= 0;
6474 EMSG(_("E679: recursive loop loading syncolor.vim"));
6478 (void)source_runtime((char_u
*)"syntax/syncolor.vim", TRUE
);
6486 * Load color file "name".
6487 * Return OK for success, FAIL for failure.
6495 static int recursive
= FALSE
;
6497 /* When being called recursively, this is probably because setting
6498 * 'background' caused the highlighting to be reloaded. This means it is
6499 * working, thus we should return OK. */
6504 buf
= alloc((unsigned)(STRLEN(name
) + 12));
6507 sprintf((char *)buf
, "colors/%s.vim", name
);
6508 retval
= source_runtime(buf
, FALSE
);
6511 apply_autocmds(EVENT_COLORSCHEME
, NULL
, NULL
, FALSE
, curbuf
);
6520 * Handle the ":highlight .." command.
6521 * When using ":hi clear" this is called recursively for each group with
6522 * "forceit" and "init" both TRUE.
6525 do_highlight(line
, forceit
, init
)
6528 int init
; /* TRUE when called for initializing */
6535 char_u
*key
= NULL
, *arg
= NULL
;
6542 int dodefault
= FALSE
;
6543 int doclear
= FALSE
;
6547 int is_normal_group
= FALSE
; /* "Normal" group */
6549 int is_menu_group
= FALSE
; /* "Menu" group */
6550 int is_scrollbar_group
= FALSE
; /* "Scrollbar" group */
6551 int is_tooltip_group
= FALSE
; /* "Tooltip" group */
6552 int do_colors
= FALSE
; /* need to update colors? */
6554 # define is_menu_group 0
6555 # define is_tooltip_group 0
6559 * If no argument, list current highlighting.
6561 if (ends_excmd(*line
))
6563 for (i
= 1; i
<= highlight_ga
.ga_len
&& !got_int
; ++i
)
6564 /* TODO: only call when the group has attributes set */
6565 highlight_list_one((int)i
);
6572 name_end
= skiptowhite(line
);
6573 linep
= skipwhite(name_end
);
6576 * Check for "default" argument.
6578 if (STRNCMP(line
, "default", name_end
- line
) == 0)
6582 name_end
= skiptowhite(line
);
6583 linep
= skipwhite(name_end
);
6587 * Check for "clear" or "link" argument.
6589 if (STRNCMP(line
, "clear", name_end
- line
) == 0)
6591 if (STRNCMP(line
, "link", name_end
- line
) == 0)
6595 * ":highlight {group-name}": list highlighting for one group.
6597 if (!doclear
&& !dolink
&& ends_excmd(*linep
))
6599 id
= syn_namen2id(line
, (int)(name_end
- line
));
6601 EMSG2(_("E411: highlight group not found: %s"), line
);
6603 highlight_list_one(id
);
6608 * Handle ":highlight link {from} {to}" command.
6612 char_u
*from_start
= linep
;
6619 from_end
= skiptowhite(from_start
);
6620 to_start
= skipwhite(from_end
);
6621 to_end
= skiptowhite(to_start
);
6623 if (ends_excmd(*from_start
) || ends_excmd(*to_start
))
6625 EMSG2(_("E412: Not enough arguments: \":highlight link %s\""),
6630 if (!ends_excmd(*skipwhite(to_end
)))
6632 EMSG2(_("E413: Too many arguments: \":highlight link %s\""), from_start
);
6636 from_id
= syn_check_group(from_start
, (int)(from_end
- from_start
));
6637 if (STRNCMP(to_start
, "NONE", 4) == 0)
6640 to_id
= syn_check_group(to_start
, (int)(to_end
- to_start
));
6642 if (from_id
> 0 && (!init
|| HL_TABLE()[from_id
- 1].sg_set
== 0))
6645 * Don't allow a link when there already is some highlighting
6646 * for the group, unless '!' is used
6648 if (to_id
> 0 && !forceit
&& !init
6649 && hl_has_settings(from_id
- 1, dodefault
))
6651 if (sourcing_name
== NULL
&& !dodefault
)
6652 EMSG(_("E414: group has settings, highlight link ignored"));
6657 HL_TABLE()[from_id
- 1].sg_set
|= SG_LINK
;
6658 HL_TABLE()[from_id
- 1].sg_link
= to_id
;
6660 HL_TABLE()[from_id
- 1].sg_scriptID
= current_SID
;
6662 redraw_all_later(SOME_VALID
);
6666 /* Only call highlight_changed() once, after sourcing a syntax file */
6667 need_highlight_changed
= TRUE
;
6675 * ":highlight clear [group]" command.
6678 if (ends_excmd(*line
))
6681 /* First, we do not destroy the old values, but allocate the new
6682 * ones and update the display. THEN we destroy the old values.
6683 * If we destroy the old values first, then the old values
6684 * (such as GuiFont's or GuiFontset's) will still be displayed but
6685 * invalid because they were free'd.
6689 # ifdef FEAT_BEVAL_TIP
6690 gui_init_tooltip_font();
6692 # if defined(FEAT_MENU) && (defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MOTIF))
6693 gui_init_menu_font();
6696 # if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11)
6697 gui_mch_def_colors();
6699 # ifdef FEAT_GUI_X11
6702 /* This only needs to be done when there is no Menu highlight
6703 * group defined by default, which IS currently the case.
6705 gui_mch_new_menu_colors();
6709 gui_new_scrollbar_colors();
6711 gui_mch_new_tooltip_colors();
6714 gui_mch_new_menu_font();
6719 /* Ok, we're done allocating the new default graphics items.
6720 * The screen should already be refreshed at this point.
6721 * It is now Ok to clear out the old data.
6725 do_unlet((char_u
*)"colors_name", TRUE
);
6727 restore_cterm_colors();
6730 * Clear all default highlight groups and load the defaults.
6732 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
6733 highlight_clear(idx
);
6734 init_highlight(TRUE
, TRUE
);
6737 highlight_gui_started();
6739 highlight_changed();
6740 redraw_later_clear();
6743 name_end
= skiptowhite(line
);
6744 linep
= skipwhite(name_end
);
6748 * Find the group name in the table. If it does not exist yet, add it.
6750 id
= syn_check_group(line
, (int)(name_end
- line
));
6751 if (id
== 0) /* failed (out of memory) */
6753 idx
= id
- 1; /* index is ID minus one */
6755 /* Return if "default" was used and the group already has settings. */
6756 if (dodefault
&& hl_has_settings(idx
, TRUE
))
6759 if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "NORMAL") == 0)
6760 is_normal_group
= TRUE
;
6762 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "MENU") == 0)
6763 is_menu_group
= TRUE
;
6764 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "SCROLLBAR") == 0)
6765 is_scrollbar_group
= TRUE
;
6766 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "TOOLTIP") == 0)
6767 is_tooltip_group
= TRUE
;
6770 /* Clear the highlighting for ":hi clear {group}" and ":hi clear". */
6771 if (doclear
|| (forceit
&& init
))
6773 highlight_clear(idx
);
6775 HL_TABLE()[idx
].sg_set
= 0;
6779 while (!ends_excmd(*linep
))
6784 EMSG2(_("E415: unexpected equal sign: %s"), key_start
);
6790 * Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" or
6793 while (*linep
&& !vim_iswhite(*linep
) && *linep
!= '=')
6796 key
= vim_strnsave_up(key_start
, (int)(linep
- key_start
));
6802 linep
= skipwhite(linep
);
6804 if (STRCMP(key
, "NONE") == 0)
6806 if (!init
|| HL_TABLE()[idx
].sg_set
== 0)
6809 HL_TABLE()[idx
].sg_set
|= SG_TERM
+SG_CTERM
+SG_GUI
;
6810 highlight_clear(idx
);
6816 * Check for the equal sign.
6820 EMSG2(_("E416: missing equal sign: %s"), key_start
);
6827 * Isolate the argument.
6829 linep
= skipwhite(linep
);
6830 if (*linep
== '\'') /* guifg='color name' */
6832 arg_start
= ++linep
;
6833 linep
= vim_strchr(linep
, '\'');
6836 EMSG2(_(e_invarg2
), key_start
);
6844 linep
= skiptowhite(linep
);
6846 if (linep
== arg_start
)
6848 EMSG2(_("E417: missing argument: %s"), key_start
);
6853 arg
= vim_strnsave(arg_start
, (int)(linep
- arg_start
));
6863 * Store the argument.
6865 if ( STRCMP(key
, "TERM") == 0
6866 || STRCMP(key
, "CTERM") == 0
6867 || STRCMP(key
, "GUI") == 0)
6871 while (arg
[off
] != NUL
)
6873 for (i
= sizeof(hl_attr_table
) / sizeof(int); --i
>= 0; )
6875 len
= (int)STRLEN(hl_name_table
[i
]);
6876 if (STRNICMP(arg
+ off
, hl_name_table
[i
], len
) == 0)
6878 attr
|= hl_attr_table
[i
];
6885 EMSG2(_("E418: Illegal value: %s"), arg
);
6889 if (arg
[off
] == ',') /* another one follows */
6896 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_TERM
))
6899 HL_TABLE()[idx
].sg_set
|= SG_TERM
;
6900 HL_TABLE()[idx
].sg_term
= attr
;
6903 else if (*key
== 'C')
6905 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_CTERM
))
6908 HL_TABLE()[idx
].sg_set
|= SG_CTERM
;
6909 HL_TABLE()[idx
].sg_cterm
= attr
;
6910 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
6916 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
6919 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
6920 HL_TABLE()[idx
].sg_gui
= attr
;
6925 else if (STRCMP(key
, "FONT") == 0)
6927 /* in non-GUI fonts are simply ignored */
6929 if (!gui
.shell_created
)
6931 /* GUI not started yet, always accept the name. */
6932 vim_free(HL_TABLE()[idx
].sg_font_name
);
6933 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6937 GuiFont temp_sg_font
= HL_TABLE()[idx
].sg_font
;
6938 # ifdef FEAT_XFONTSET
6939 GuiFontset temp_sg_fontset
= HL_TABLE()[idx
].sg_fontset
;
6941 /* First, save the current font/fontset.
6942 * Then try to allocate the font/fontset.
6943 * If the allocation fails, HL_TABLE()[idx].sg_font OR
6944 * sg_fontset will be set to NOFONT or NOFONTSET respectively.
6947 HL_TABLE()[idx
].sg_font
= NOFONT
;
6948 # ifdef FEAT_XFONTSET
6949 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
6951 hl_do_font(idx
, arg
, is_normal_group
, is_menu_group
,
6954 # ifdef FEAT_XFONTSET
6955 if (HL_TABLE()[idx
].sg_fontset
!= NOFONTSET
)
6957 /* New fontset was accepted. Free the old one, if there was
6960 gui_mch_free_fontset(temp_sg_fontset
);
6961 vim_free(HL_TABLE()[idx
].sg_font_name
);
6962 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6965 HL_TABLE()[idx
].sg_fontset
= temp_sg_fontset
;
6967 if (HL_TABLE()[idx
].sg_font
!= NOFONT
)
6969 /* New font was accepted. Free the old one, if there was
6972 gui_mch_free_font(temp_sg_font
);
6973 vim_free(HL_TABLE()[idx
].sg_font_name
);
6974 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6977 HL_TABLE()[idx
].sg_font
= temp_sg_font
;
6981 else if (STRCMP(key
, "CTERMFG") == 0 || STRCMP(key
, "CTERMBG") == 0)
6983 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_CTERM
))
6986 HL_TABLE()[idx
].sg_set
|= SG_CTERM
;
6988 /* When setting the foreground color, and previously the "bold"
6989 * flag was set for a light color, reset it now */
6990 if (key
[5] == 'F' && HL_TABLE()[idx
].sg_cterm_bold
)
6992 HL_TABLE()[idx
].sg_cterm
&= ~HL_BOLD
;
6993 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
6996 if (VIM_ISDIGIT(*arg
))
6997 color
= atoi((char *)arg
);
6998 else if (STRICMP(arg
, "fg") == 0)
7000 if (cterm_normal_fg_color
)
7001 color
= cterm_normal_fg_color
- 1;
7004 EMSG(_("E419: FG color unknown"));
7009 else if (STRICMP(arg
, "bg") == 0)
7011 if (cterm_normal_bg_color
> 0)
7012 color
= cterm_normal_bg_color
- 1;
7015 EMSG(_("E420: BG color unknown"));
7022 static char *(color_names
[28]) = {
7023 "Black", "DarkBlue", "DarkGreen", "DarkCyan",
7024 "DarkRed", "DarkMagenta", "Brown", "DarkYellow",
7026 "LightGray", "LightGrey", "DarkGray", "DarkGrey",
7027 "Blue", "LightBlue", "Green", "LightGreen",
7028 "Cyan", "LightCyan", "Red", "LightRed", "Magenta",
7029 "LightMagenta", "Yellow", "LightYellow", "White", "NONE"};
7030 static int color_numbers_16
[28] = {0, 1, 2, 3,
7036 13, 14, 14, 15, -1};
7037 /* for xterm with 88 colors... */
7038 static int color_numbers_88
[28] = {0, 4, 2, 6,
7044 75, 11, 78, 15, -1};
7045 /* for xterm with 256 colors... */
7046 static int color_numbers_256
[28] = {0, 4, 2, 6,
7051 14, 159, 9, 224, 13,
7052 225, 11, 229, 15, -1};
7053 /* for terminals with less than 16 colors... */
7054 static int color_numbers_8
[28] = {0, 4, 2, 6,
7059 6+8, 6+8, 1+8, 1+8, 5+8,
7060 5+8, 3+8, 3+8, 7+8, -1};
7061 #if defined(__QNXNTO__)
7062 static int *color_numbers_8_qansi
= color_numbers_8
;
7063 /* On qnx, the 8 & 16 color arrays are the same */
7064 if (STRNCMP(T_NAME
, "qansi", 5) == 0)
7065 color_numbers_8_qansi
= color_numbers_16
;
7068 /* reduce calls to STRICMP a bit, it can be slow */
7069 off
= TOUPPER_ASC(*arg
);
7070 for (i
= (sizeof(color_names
) / sizeof(char *)); --i
>= 0; )
7071 if (off
== color_names
[i
][0]
7072 && STRICMP(arg
+ 1, color_names
[i
] + 1) == 0)
7076 EMSG2(_("E421: Color name or number not recognized: %s"), key_start
);
7081 /* Use the _16 table to check if its a valid color name. */
7082 color
= color_numbers_16
[i
];
7087 /* t_Co is 8: use the 8 colors table */
7088 #if defined(__QNXNTO__)
7089 color
= color_numbers_8_qansi
[i
];
7091 color
= color_numbers_8
[i
];
7095 /* set/reset bold attribute to get light foreground
7096 * colors (on some terminals, e.g. "linux") */
7099 HL_TABLE()[idx
].sg_cterm
|= HL_BOLD
;
7100 HL_TABLE()[idx
].sg_cterm_bold
= TRUE
;
7103 HL_TABLE()[idx
].sg_cterm
&= ~HL_BOLD
;
7105 color
&= 7; /* truncate to 8 colors */
7107 else if (t_colors
== 16 || t_colors
== 88
7111 * Guess: if the termcap entry ends in 'm', it is
7112 * probably an xterm-like terminal. Use the changed
7119 if (*p
!= NUL
&& *(p
+ STRLEN(p
) - 1) == 'm')
7123 color
= color_numbers_8
[i
];
7126 color
= color_numbers_88
[i
];
7129 color
= color_numbers_256
[i
];
7135 /* Add one to the argument, to avoid zero */
7138 HL_TABLE()[idx
].sg_cterm_fg
= color
+ 1;
7139 if (is_normal_group
)
7141 cterm_normal_fg_color
= color
+ 1;
7142 cterm_normal_fg_bold
= (HL_TABLE()[idx
].sg_cterm
& HL_BOLD
);
7144 /* Don't do this if the GUI is used. */
7145 if (!gui
.in_use
&& !gui
.starting
)
7148 must_redraw
= CLEAR
;
7150 term_fg_color(color
);
7156 HL_TABLE()[idx
].sg_cterm_bg
= color
+ 1;
7157 if (is_normal_group
)
7159 cterm_normal_bg_color
= color
+ 1;
7161 /* Don't mess with 'background' if the GUI is used. */
7162 if (!gui
.in_use
&& !gui
.starting
)
7165 must_redraw
= CLEAR
;
7167 term_bg_color(color
);
7169 i
= (color
== 0 || color
== 4);
7171 i
= (color
< 7 || color
== 8);
7172 /* Set the 'background' option if the value is wrong. */
7173 if (i
!= (*p_bg
== 'd'))
7174 set_option_value((char_u
*)"bg", 0L,
7175 i
? (char_u
*)"dark" : (char_u
*)"light", 0);
7181 else if (STRCMP(key
, "GUIFG") == 0)
7183 #ifdef FEAT_GUI /* in non-GUI guifg colors are simply ignored */
7184 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7187 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7189 i
= color_name2handle(arg
);
7190 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7192 HL_TABLE()[idx
].sg_gui_fg
= i
;
7193 vim_free(HL_TABLE()[idx
].sg_gui_fg_name
);
7194 if (STRCMP(arg
, "NONE"))
7195 HL_TABLE()[idx
].sg_gui_fg_name
= vim_strsave(arg
);
7197 HL_TABLE()[idx
].sg_gui_fg_name
= NULL
;
7198 # ifdef FEAT_GUI_X11
7200 gui
.menu_fg_pixel
= i
;
7201 if (is_scrollbar_group
)
7202 gui
.scroll_fg_pixel
= i
;
7204 if (is_tooltip_group
)
7205 gui
.tooltip_fg_pixel
= i
;
7213 else if (STRCMP(key
, "GUIBG") == 0)
7215 #ifdef FEAT_GUI /* in non-GUI guibg colors are simply ignored */
7216 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7219 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7221 i
= color_name2handle(arg
);
7222 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7224 HL_TABLE()[idx
].sg_gui_bg
= i
;
7225 vim_free(HL_TABLE()[idx
].sg_gui_bg_name
);
7226 if (STRCMP(arg
, "NONE") != 0)
7227 HL_TABLE()[idx
].sg_gui_bg_name
= vim_strsave(arg
);
7229 HL_TABLE()[idx
].sg_gui_bg_name
= NULL
;
7230 # ifdef FEAT_GUI_X11
7232 gui
.menu_bg_pixel
= i
;
7233 if (is_scrollbar_group
)
7234 gui
.scroll_bg_pixel
= i
;
7236 if (is_tooltip_group
)
7237 gui
.tooltip_bg_pixel
= i
;
7245 else if (STRCMP(key
, "GUISP") == 0)
7247 #ifdef FEAT_GUI /* in non-GUI guisp colors are simply ignored */
7248 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7251 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7253 i
= color_name2handle(arg
);
7254 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7256 HL_TABLE()[idx
].sg_gui_sp
= i
;
7257 vim_free(HL_TABLE()[idx
].sg_gui_sp_name
);
7258 if (STRCMP(arg
, "NONE") != 0)
7259 HL_TABLE()[idx
].sg_gui_sp_name
= vim_strsave(arg
);
7261 HL_TABLE()[idx
].sg_gui_sp_name
= NULL
;
7266 else if (STRCMP(key
, "START") == 0 || STRCMP(key
, "STOP") == 0)
7272 HL_TABLE()[idx
].sg_set
|= SG_TERM
;
7275 * The "start" and "stop" arguments can be a literal escape
7276 * sequence, or a comma separated list of terminal codes.
7278 if (STRNCMP(arg
, "t_", 2) == 0)
7282 while (arg
[off
] != NUL
)
7284 /* Isolate one termcap name */
7285 for (len
= 0; arg
[off
+ len
] &&
7286 arg
[off
+ len
] != ','; ++len
)
7288 tname
= vim_strnsave(arg
+ off
, len
);
7289 if (tname
== NULL
) /* out of memory */
7294 /* lookup the escape sequence for the item */
7295 p
= get_term_code(tname
);
7297 if (p
== NULL
) /* ignore non-existing things */
7300 /* Append it to the already found stuff */
7301 if ((int)(STRLEN(buf
) + STRLEN(p
)) >= 99)
7303 EMSG2(_("E422: terminal code too long: %s"), arg
);
7309 /* Advance to the next item */
7311 if (arg
[off
] == ',') /* another one follows */
7318 * Copy characters from arg[] to buf[], translating <> codes.
7320 for (p
= arg
, off
= 0; off
< 100 && *p
; )
7322 len
= trans_special(&p
, buf
+ off
, FALSE
);
7323 if (len
) /* recognized special char */
7325 else /* copy as normal char */
7333 if (STRCMP(buf
, "NONE") == 0) /* resetting the value */
7336 p
= vim_strsave(buf
);
7339 vim_free(HL_TABLE()[idx
].sg_start
);
7340 HL_TABLE()[idx
].sg_start
= p
;
7344 vim_free(HL_TABLE()[idx
].sg_stop
);
7345 HL_TABLE()[idx
].sg_stop
= p
;
7350 EMSG2(_("E423: Illegal argument: %s"), key_start
);
7356 * When highlighting has been given for a group, don't link it.
7358 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_LINK
))
7359 HL_TABLE()[idx
].sg_link
= 0;
7362 * Continue with next argument.
7364 linep
= skipwhite(linep
);
7368 * If there is an error, and it's a new entry, remove it from the table.
7370 if (error
&& idx
== highlight_ga
.ga_len
)
7374 if (is_normal_group
)
7376 HL_TABLE()[idx
].sg_term_attr
= 0;
7377 HL_TABLE()[idx
].sg_cterm_attr
= 0;
7379 HL_TABLE()[idx
].sg_gui_attr
= 0;
7381 * Need to update all groups, because they might be using "bg"
7382 * and/or "fg", which have been changed now.
7385 highlight_gui_started();
7390 else if (is_menu_group
)
7392 if (gui
.in_use
&& do_colors
)
7393 gui_mch_new_menu_colors();
7396 else if (is_scrollbar_group
)
7398 if (gui
.in_use
&& do_colors
)
7399 gui_new_scrollbar_colors();
7402 else if (is_tooltip_group
)
7404 if (gui
.in_use
&& do_colors
)
7405 gui_mch_new_tooltip_colors();
7412 HL_TABLE()[idx
].sg_scriptID
= current_SID
;
7414 redraw_all_later(NOT_VALID
);
7419 /* Only call highlight_changed() once, after sourcing a syntax file */
7420 need_highlight_changed
= TRUE
;
7423 #if defined(EXITFREE) || defined(PROTO)
7429 for (i
= 0; i
< highlight_ga
.ga_len
; ++i
)
7432 vim_free(HL_TABLE()[i
].sg_name
);
7433 vim_free(HL_TABLE()[i
].sg_name_u
);
7435 ga_clear(&highlight_ga
);
7440 * Reset the cterm colors to what they were before Vim was started, if
7441 * possible. Otherwise reset them to zero.
7444 restore_cterm_colors()
7446 #if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32))
7447 /* Since t_me has been set, this probably means that the user
7448 * wants to use this as default colors. Need to reset default
7449 * background/foreground colors. */
7450 mch_set_normal_colors();
7452 cterm_normal_fg_color
= 0;
7453 cterm_normal_fg_bold
= 0;
7454 cterm_normal_bg_color
= 0;
7459 * Return TRUE if highlight group "idx" has any settings.
7460 * When "check_link" is TRUE also check for an existing link.
7463 hl_has_settings(idx
, check_link
)
7467 return ( HL_TABLE()[idx
].sg_term_attr
!= 0
7468 || HL_TABLE()[idx
].sg_cterm_attr
!= 0
7470 || HL_TABLE()[idx
].sg_gui_attr
!= 0
7472 || (check_link
&& (HL_TABLE()[idx
].sg_set
& SG_LINK
)));
7476 * Clear highlighting for one group.
7479 highlight_clear(idx
)
7482 HL_TABLE()[idx
].sg_term
= 0;
7483 vim_free(HL_TABLE()[idx
].sg_start
);
7484 HL_TABLE()[idx
].sg_start
= NULL
;
7485 vim_free(HL_TABLE()[idx
].sg_stop
);
7486 HL_TABLE()[idx
].sg_stop
= NULL
;
7487 HL_TABLE()[idx
].sg_term_attr
= 0;
7488 HL_TABLE()[idx
].sg_cterm
= 0;
7489 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
7490 HL_TABLE()[idx
].sg_cterm_fg
= 0;
7491 HL_TABLE()[idx
].sg_cterm_bg
= 0;
7492 HL_TABLE()[idx
].sg_cterm_attr
= 0;
7493 #ifdef FEAT_GUI /* in non-GUI fonts are simply ignored */
7494 HL_TABLE()[idx
].sg_gui
= 0;
7495 HL_TABLE()[idx
].sg_gui_fg
= INVALCOLOR
;
7496 vim_free(HL_TABLE()[idx
].sg_gui_fg_name
);
7497 HL_TABLE()[idx
].sg_gui_fg_name
= NULL
;
7498 HL_TABLE()[idx
].sg_gui_bg
= INVALCOLOR
;
7499 vim_free(HL_TABLE()[idx
].sg_gui_bg_name
);
7500 HL_TABLE()[idx
].sg_gui_bg_name
= NULL
;
7501 HL_TABLE()[idx
].sg_gui_sp
= INVALCOLOR
;
7502 vim_free(HL_TABLE()[idx
].sg_gui_sp_name
);
7503 HL_TABLE()[idx
].sg_gui_sp_name
= NULL
;
7504 gui_mch_free_font(HL_TABLE()[idx
].sg_font
);
7505 HL_TABLE()[idx
].sg_font
= NOFONT
;
7506 # ifdef FEAT_XFONTSET
7507 gui_mch_free_fontset(HL_TABLE()[idx
].sg_fontset
);
7508 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
7510 vim_free(HL_TABLE()[idx
].sg_font_name
);
7511 HL_TABLE()[idx
].sg_font_name
= NULL
;
7512 HL_TABLE()[idx
].sg_gui_attr
= 0;
7515 /* Clear the script ID only when there is no link, since that is not
7517 if (HL_TABLE()[idx
].sg_link
== 0)
7518 HL_TABLE()[idx
].sg_scriptID
= 0;
7522 #if defined(FEAT_GUI) || defined(PROTO)
7524 * Set the normal foreground and background colors according to the "Normal"
7525 * highlighting group. For X11 also set "Menu", "Scrollbar", and
7531 if (set_group_colors((char_u
*)"Normal",
7532 &gui
.norm_pixel
, &gui
.back_pixel
,
7533 FALSE
, TRUE
, FALSE
))
7535 gui_mch_new_colors();
7536 must_redraw
= CLEAR
;
7539 if (set_group_colors((char_u
*)"Menu",
7540 &gui
.menu_fg_pixel
, &gui
.menu_bg_pixel
,
7541 TRUE
, FALSE
, FALSE
))
7544 gui_mch_new_menu_colors();
7546 must_redraw
= CLEAR
;
7549 if (set_group_colors((char_u
*)"Tooltip",
7550 &gui
.tooltip_fg_pixel
, &gui
.tooltip_bg_pixel
,
7551 FALSE
, FALSE
, TRUE
))
7553 # ifdef FEAT_TOOLBAR
7554 gui_mch_new_tooltip_colors();
7556 must_redraw
= CLEAR
;
7559 if (set_group_colors((char_u
*)"Scrollbar",
7560 &gui
.scroll_fg_pixel
, &gui
.scroll_bg_pixel
,
7561 FALSE
, FALSE
, FALSE
))
7563 gui_new_scrollbar_colors();
7564 must_redraw
= CLEAR
;
7570 * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
7573 set_group_colors(name
, fgp
, bgp
, do_menu
, use_norm
, do_tooltip
)
7583 idx
= syn_name2id(name
) - 1;
7586 gui_do_one_color(idx
, do_menu
, do_tooltip
);
7588 if (HL_TABLE()[idx
].sg_gui_fg
!= INVALCOLOR
)
7589 *fgp
= HL_TABLE()[idx
].sg_gui_fg
;
7591 *fgp
= gui
.def_norm_pixel
;
7592 if (HL_TABLE()[idx
].sg_gui_bg
!= INVALCOLOR
)
7593 *bgp
= HL_TABLE()[idx
].sg_gui_bg
;
7595 *bgp
= gui
.def_back_pixel
;
7602 * Get the font of the "Normal" group.
7603 * Returns "" when it's not found or not set.
7611 id
= syn_name2id((char_u
*)"Normal");
7614 s
= HL_TABLE()[id
- 1].sg_font_name
;
7618 return (char_u
*)"";
7622 * Set font for "Normal" group. Called by gui_mch_init_font() when a font has
7623 * actually chosen to be used.
7626 hl_set_font_name(font_name
)
7631 id
= syn_name2id((char_u
*)"Normal");
7634 vim_free(HL_TABLE()[id
- 1].sg_font_name
);
7635 HL_TABLE()[id
- 1].sg_font_name
= vim_strsave(font_name
);
7640 * Set background color for "Normal" group. Called by gui_set_bg_color()
7641 * when the color is known.
7644 hl_set_bg_color_name(name
)
7645 char_u
*name
; /* must have been allocated */
7651 id
= syn_name2id((char_u
*)"Normal");
7654 vim_free(HL_TABLE()[id
- 1].sg_gui_bg_name
);
7655 HL_TABLE()[id
- 1].sg_gui_bg_name
= name
;
7661 * Set foreground color for "Normal" group. Called by gui_set_fg_color()
7662 * when the color is known.
7665 hl_set_fg_color_name(name
)
7666 char_u
*name
; /* must have been allocated */
7672 id
= syn_name2id((char_u
*)"Normal");
7675 vim_free(HL_TABLE()[id
- 1].sg_gui_fg_name
);
7676 HL_TABLE()[id
- 1].sg_gui_fg_name
= name
;
7682 * Return the handle for a color name.
7683 * Returns INVALCOLOR when failed.
7686 color_name2handle(name
)
7689 if (STRCMP(name
, "NONE") == 0)
7692 if (STRICMP(name
, "fg") == 0 || STRICMP(name
, "foreground") == 0)
7693 return gui
.norm_pixel
;
7694 if (STRICMP(name
, "bg") == 0 || STRICMP(name
, "background") == 0)
7695 return gui
.back_pixel
;
7697 return gui_get_color(name
);
7701 * Return the handle for a font name.
7702 * Returns NOFONT when failed.
7705 font_name2handle(name
)
7708 if (STRCMP(name
, "NONE") == 0)
7711 return gui_mch_get_font(name
, TRUE
);
7714 # ifdef FEAT_XFONTSET
7716 * Return the handle for a fontset name.
7717 * Returns NOFONTSET when failed.
7720 fontset_name2handle(name
, fixed_width
)
7724 if (STRCMP(name
, "NONE") == 0)
7727 return gui_mch_get_fontset(name
, TRUE
, fixed_width
);
7732 * Get the font or fontset for one highlight group.
7735 hl_do_font(idx
, arg
, do_normal
, do_menu
, do_tooltip
)
7738 int do_normal
; /* set normal font */
7739 int do_menu UNUSED
; /* set menu font */
7740 int do_tooltip UNUSED
; /* set tooltip font */
7742 # ifdef FEAT_XFONTSET
7743 /* If 'guifontset' is not empty, first try using the name as a
7744 * fontset. If that doesn't work, use it as a font name. */
7745 if (*p_guifontset
!= NUL
7746 # ifdef FONTSET_ALWAYS
7749 # ifdef FEAT_BEVAL_TIP
7750 /* In Athena & Motif, the Tooltip highlight group is always a fontset */
7754 HL_TABLE()[idx
].sg_fontset
= fontset_name2handle(arg
, 0
7755 # ifdef FONTSET_ALWAYS
7758 # ifdef FEAT_BEVAL_TIP
7762 if (HL_TABLE()[idx
].sg_fontset
!= NOFONTSET
)
7764 /* If it worked and it's the Normal group, use it as the
7765 * normal fontset. Same for the Menu group. */
7767 gui_init_font(arg
, TRUE
);
7768 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7771 # ifdef FONTSET_ALWAYS
7772 gui
.menu_fontset
= HL_TABLE()[idx
].sg_fontset
;
7774 /* YIKES! This is a bug waiting to crash the program */
7775 gui
.menu_font
= HL_TABLE()[idx
].sg_fontset
;
7777 gui_mch_new_menu_font();
7782 /* The Athena widget set cannot currently handle switching between
7783 * displaying a single font and a fontset.
7784 * If the XtNinternational resource is set to True at widget
7785 * creation, then a fontset is always used, otherwise an
7786 * XFontStruct is used.
7788 gui
.tooltip_fontset
= (XFontSet
)HL_TABLE()[idx
].sg_fontset
;
7789 gui_mch_new_tooltip_font();
7797 HL_TABLE()[idx
].sg_font
= font_name2handle(arg
);
7798 /* If it worked and it's the Normal group, use it as the
7799 * normal font. Same for the Menu group. */
7800 if (HL_TABLE()[idx
].sg_font
!= NOFONT
)
7803 gui_init_font(arg
, FALSE
);
7804 #ifndef FONTSET_ALWAYS
7805 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7808 gui
.menu_font
= HL_TABLE()[idx
].sg_font
;
7809 gui_mch_new_menu_font();
7817 #endif /* FEAT_GUI */
7820 * Table with the specifications for an attribute number.
7821 * Note that this table is used by ALL buffers. This is required because the
7822 * GUI can redraw at any time for any buffer.
7824 static garray_T term_attr_table
= {0, 0, 0, 0, NULL
};
7826 #define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx]
7828 static garray_T cterm_attr_table
= {0, 0, 0, 0, NULL
};
7830 #define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx]
7833 static garray_T gui_attr_table
= {0, 0, 0, 0, NULL
};
7835 #define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx]
7839 * Return the attr number for a set of colors and font.
7840 * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
7841 * if the combination is new.
7842 * Return 0 for error (no more room).
7845 get_attr_entry(table
, aep
)
7851 static int recursive
= FALSE
;
7854 * Init the table, in case it wasn't done yet.
7856 table
->ga_itemsize
= sizeof(attrentry_T
);
7857 table
->ga_growsize
= 7;
7860 * Try to find an entry with the same specifications.
7862 for (i
= 0; i
< table
->ga_len
; ++i
)
7864 taep
= &(((attrentry_T
*)table
->ga_data
)[i
]);
7865 if ( aep
->ae_attr
== taep
->ae_attr
7868 (table
== &gui_attr_table
7869 && (aep
->ae_u
.gui
.fg_color
== taep
->ae_u
.gui
.fg_color
7870 && aep
->ae_u
.gui
.bg_color
7871 == taep
->ae_u
.gui
.bg_color
7872 && aep
->ae_u
.gui
.sp_color
7873 == taep
->ae_u
.gui
.sp_color
7874 && aep
->ae_u
.gui
.font
== taep
->ae_u
.gui
.font
7875 # ifdef FEAT_XFONTSET
7876 && aep
->ae_u
.gui
.fontset
== taep
->ae_u
.gui
.fontset
7881 (table
== &term_attr_table
7882 && (aep
->ae_u
.term
.start
== NULL
)
7883 == (taep
->ae_u
.term
.start
== NULL
)
7884 && (aep
->ae_u
.term
.start
== NULL
7885 || STRCMP(aep
->ae_u
.term
.start
,
7886 taep
->ae_u
.term
.start
) == 0)
7887 && (aep
->ae_u
.term
.stop
== NULL
)
7888 == (taep
->ae_u
.term
.stop
== NULL
)
7889 && (aep
->ae_u
.term
.stop
== NULL
7890 || STRCMP(aep
->ae_u
.term
.stop
,
7891 taep
->ae_u
.term
.stop
) == 0))
7892 || (table
== &cterm_attr_table
7893 && aep
->ae_u
.cterm
.fg_color
7894 == taep
->ae_u
.cterm
.fg_color
7895 && aep
->ae_u
.cterm
.bg_color
7896 == taep
->ae_u
.cterm
.bg_color
)
7899 return i
+ ATTR_OFF
;
7902 if (table
->ga_len
+ ATTR_OFF
> MAX_TYPENR
)
7905 * Running out of attribute entries! remove all attributes, and
7906 * compute new ones for all groups.
7907 * When called recursively, we are really out of numbers.
7911 EMSG(_("E424: Too many different highlighting attributes in use"));
7918 must_redraw
= CLEAR
;
7920 for (i
= 0; i
< highlight_ga
.ga_len
; ++i
)
7927 * This is a new combination of colors and font, add an entry.
7929 if (ga_grow(table
, 1) == FAIL
)
7932 taep
= &(((attrentry_T
*)table
->ga_data
)[table
->ga_len
]);
7933 vim_memset(taep
, 0, sizeof(attrentry_T
));
7934 taep
->ae_attr
= aep
->ae_attr
;
7936 if (table
== &gui_attr_table
)
7938 taep
->ae_u
.gui
.fg_color
= aep
->ae_u
.gui
.fg_color
;
7939 taep
->ae_u
.gui
.bg_color
= aep
->ae_u
.gui
.bg_color
;
7940 taep
->ae_u
.gui
.sp_color
= aep
->ae_u
.gui
.sp_color
;
7941 taep
->ae_u
.gui
.font
= aep
->ae_u
.gui
.font
;
7942 # ifdef FEAT_XFONTSET
7943 taep
->ae_u
.gui
.fontset
= aep
->ae_u
.gui
.fontset
;
7947 if (table
== &term_attr_table
)
7949 if (aep
->ae_u
.term
.start
== NULL
)
7950 taep
->ae_u
.term
.start
= NULL
;
7952 taep
->ae_u
.term
.start
= vim_strsave(aep
->ae_u
.term
.start
);
7953 if (aep
->ae_u
.term
.stop
== NULL
)
7954 taep
->ae_u
.term
.stop
= NULL
;
7956 taep
->ae_u
.term
.stop
= vim_strsave(aep
->ae_u
.term
.stop
);
7958 else if (table
== &cterm_attr_table
)
7960 taep
->ae_u
.cterm
.fg_color
= aep
->ae_u
.cterm
.fg_color
;
7961 taep
->ae_u
.cterm
.bg_color
= aep
->ae_u
.cterm
.bg_color
;
7964 return (table
->ga_len
- 1 + ATTR_OFF
);
7968 * Clear all highlight tables.
7977 ga_clear(&gui_attr_table
);
7979 for (i
= 0; i
< term_attr_table
.ga_len
; ++i
)
7981 taep
= &(((attrentry_T
*)term_attr_table
.ga_data
)[i
]);
7982 vim_free(taep
->ae_u
.term
.start
);
7983 vim_free(taep
->ae_u
.term
.stop
);
7985 ga_clear(&term_attr_table
);
7986 ga_clear(&cterm_attr_table
);
7989 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO)
7991 * Combine special attributes (e.g., for spelling) with other attributes
7992 * (e.g., for syntax highlighting).
7993 * "prim_attr" overrules "char_attr".
7994 * This creates a new group when required.
7995 * Since we expect there to be few spelling mistakes we don't cache the
7997 * Return the resulting attributes.
8000 hl_combine_attr(char_attr
, prim_attr
)
8004 attrentry_T
*char_aep
= NULL
;
8005 attrentry_T
*spell_aep
;
8010 if (char_attr
<= HL_ALL
&& prim_attr
<= HL_ALL
)
8011 return char_attr
| prim_attr
;
8015 if (char_attr
> HL_ALL
)
8016 char_aep
= syn_gui_attr2entry(char_attr
);
8017 if (char_aep
!= NULL
)
8021 vim_memset(&new_en
, 0, sizeof(new_en
));
8022 new_en
.ae_u
.gui
.fg_color
= INVALCOLOR
;
8023 new_en
.ae_u
.gui
.bg_color
= INVALCOLOR
;
8024 new_en
.ae_u
.gui
.sp_color
= INVALCOLOR
;
8025 if (char_attr
<= HL_ALL
)
8026 new_en
.ae_attr
= char_attr
;
8029 if (prim_attr
<= HL_ALL
)
8030 new_en
.ae_attr
|= prim_attr
;
8033 spell_aep
= syn_gui_attr2entry(prim_attr
);
8034 if (spell_aep
!= NULL
)
8036 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8037 if (spell_aep
->ae_u
.gui
.fg_color
!= INVALCOLOR
)
8038 new_en
.ae_u
.gui
.fg_color
= spell_aep
->ae_u
.gui
.fg_color
;
8039 if (spell_aep
->ae_u
.gui
.bg_color
!= INVALCOLOR
)
8040 new_en
.ae_u
.gui
.bg_color
= spell_aep
->ae_u
.gui
.bg_color
;
8041 if (spell_aep
->ae_u
.gui
.sp_color
!= INVALCOLOR
)
8042 new_en
.ae_u
.gui
.sp_color
= spell_aep
->ae_u
.gui
.sp_color
;
8043 if (spell_aep
->ae_u
.gui
.font
!= NOFONT
)
8044 new_en
.ae_u
.gui
.font
= spell_aep
->ae_u
.gui
.font
;
8045 # ifdef FEAT_XFONTSET
8046 if (spell_aep
->ae_u
.gui
.fontset
!= NOFONTSET
)
8047 new_en
.ae_u
.gui
.fontset
= spell_aep
->ae_u
.gui
.fontset
;
8051 return get_attr_entry(&gui_attr_table
, &new_en
);
8057 if (char_attr
> HL_ALL
)
8058 char_aep
= syn_cterm_attr2entry(char_attr
);
8059 if (char_aep
!= NULL
)
8063 vim_memset(&new_en
, 0, sizeof(new_en
));
8064 if (char_attr
<= HL_ALL
)
8065 new_en
.ae_attr
= char_attr
;
8068 if (prim_attr
<= HL_ALL
)
8069 new_en
.ae_attr
|= prim_attr
;
8072 spell_aep
= syn_cterm_attr2entry(prim_attr
);
8073 if (spell_aep
!= NULL
)
8075 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8076 if (spell_aep
->ae_u
.cterm
.fg_color
> 0)
8077 new_en
.ae_u
.cterm
.fg_color
= spell_aep
->ae_u
.cterm
.fg_color
;
8078 if (spell_aep
->ae_u
.cterm
.bg_color
> 0)
8079 new_en
.ae_u
.cterm
.bg_color
= spell_aep
->ae_u
.cterm
.bg_color
;
8082 return get_attr_entry(&cterm_attr_table
, &new_en
);
8085 if (char_attr
> HL_ALL
)
8086 char_aep
= syn_term_attr2entry(char_attr
);
8087 if (char_aep
!= NULL
)
8091 vim_memset(&new_en
, 0, sizeof(new_en
));
8092 if (char_attr
<= HL_ALL
)
8093 new_en
.ae_attr
= char_attr
;
8096 if (prim_attr
<= HL_ALL
)
8097 new_en
.ae_attr
|= prim_attr
;
8100 spell_aep
= syn_term_attr2entry(prim_attr
);
8101 if (spell_aep
!= NULL
)
8103 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8104 if (spell_aep
->ae_u
.term
.start
!= NULL
)
8106 new_en
.ae_u
.term
.start
= spell_aep
->ae_u
.term
.start
;
8107 new_en
.ae_u
.term
.stop
= spell_aep
->ae_u
.term
.stop
;
8111 return get_attr_entry(&term_attr_table
, &new_en
);
8118 syn_gui_attr2entry(attr
)
8122 if (attr
>= gui_attr_table
.ga_len
) /* did ":syntax clear" */
8124 return &(GUI_ATTR_ENTRY(attr
));
8126 #endif /* FEAT_GUI */
8129 * Get the highlight attributes (HL_BOLD etc.) from an attribute nr.
8130 * Only to be used when "attr" > HL_ALL.
8140 aep
= syn_gui_attr2entry(attr
);
8144 aep
= syn_cterm_attr2entry(attr
);
8146 aep
= syn_term_attr2entry(attr
);
8148 if (aep
== NULL
) /* highlighting not set */
8150 return aep
->ae_attr
;
8155 syn_term_attr2entry(attr
)
8159 if (attr
>= term_attr_table
.ga_len
) /* did ":syntax clear" */
8161 return &(TERM_ATTR_ENTRY(attr
));
8165 syn_cterm_attr2entry(attr
)
8169 if (attr
>= cterm_attr_table
.ga_len
) /* did ":syntax clear" */
8171 return &(CTERM_ATTR_ENTRY(attr
));
8175 #define LIST_STRING 2
8179 highlight_list_one(id
)
8182 struct hl_group
*sgp
;
8185 sgp
= &HL_TABLE()[id
- 1]; /* index is ID minus one */
8187 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8188 sgp
->sg_term
, NULL
, "term");
8189 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8190 0, sgp
->sg_start
, "start");
8191 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8192 0, sgp
->sg_stop
, "stop");
8194 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8195 sgp
->sg_cterm
, NULL
, "cterm");
8196 didh
= highlight_list_arg(id
, didh
, LIST_INT
,
8197 sgp
->sg_cterm_fg
, NULL
, "ctermfg");
8198 didh
= highlight_list_arg(id
, didh
, LIST_INT
,
8199 sgp
->sg_cterm_bg
, NULL
, "ctermbg");
8202 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8203 sgp
->sg_gui
, NULL
, "gui");
8204 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8205 0, sgp
->sg_gui_fg_name
, "guifg");
8206 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8207 0, sgp
->sg_gui_bg_name
, "guibg");
8208 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8209 0, sgp
->sg_gui_sp_name
, "guisp");
8210 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8211 0, sgp
->sg_font_name
, "font");
8214 if (sgp
->sg_link
&& !got_int
)
8216 (void)syn_list_header(didh
, 9999, id
);
8218 msg_puts_attr((char_u
*)"links to", hl_attr(HLF_D
));
8220 msg_outtrans(HL_TABLE()[HL_TABLE()[id
- 1].sg_link
- 1].sg_name
);
8224 highlight_list_arg(id
, didh
, LIST_STRING
, 0, (char_u
*)"cleared", "");
8227 last_set_msg(sgp
->sg_scriptID
);
8232 highlight_list_arg(id
, didh
, type
, iarg
, sarg
, name
)
8246 if (type
== LIST_STRING
? (sarg
!= NULL
) : (iarg
!= 0))
8249 if (type
== LIST_INT
)
8250 sprintf((char *)buf
, "%d", iarg
- 1);
8251 else if (type
== LIST_STRING
)
8253 else /* type == LIST_ATTR */
8256 for (i
= 0; hl_attr_table
[i
] != 0; ++i
)
8258 if (iarg
& hl_attr_table
[i
])
8262 STRCAT(buf
, hl_name_table
[i
]);
8263 iarg
&= ~hl_attr_table
[i
]; /* don't want "inverse" */
8268 (void)syn_list_header(didh
,
8269 (int)(vim_strsize(ts
) + STRLEN(name
) + 1), id
);
8275 MSG_PUTS_ATTR(name
, hl_attr(HLF_D
));
8276 MSG_PUTS_ATTR("=", hl_attr(HLF_D
));
8284 #if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO)
8286 * Return "1" if highlight group "id" has attribute "flag".
8287 * Return NULL otherwise.
8290 highlight_has_attr(id
, flag
, modec
)
8293 int modec
; /* 'g' for GUI, 'c' for cterm, 't' for term */
8297 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8302 attr
= HL_TABLE()[id
- 1].sg_gui
;
8306 attr
= HL_TABLE()[id
- 1].sg_cterm
;
8308 attr
= HL_TABLE()[id
- 1].sg_term
;
8311 return (char_u
*)"1";
8316 #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
8318 * Return color name of highlight group "id".
8321 highlight_color(id
, what
, modec
)
8323 char_u
*what
; /* "fg", "bg", "sp", "fg#", "bg#" or "sp#" */
8324 int modec
; /* 'g' for GUI, 'c' for cterm, 't' for term */
8326 static char_u name
[20];
8333 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8336 if (TOLOWER_ASC(what
[0]) == 'f')
8339 else if (TOLOWER_ASC(what
[0]) == 's')
8343 /* return #RRGGBB form (only possible when GUI is running) */
8344 if (gui
.in_use
&& what
[1] && what
[2] == '#')
8348 static char_u buf
[10];
8351 color
= HL_TABLE()[id
- 1].sg_gui_fg
;
8353 color
= HL_TABLE()[id
- 1].sg_gui_sp
;
8355 color
= HL_TABLE()[id
- 1].sg_gui_bg
;
8356 if (color
== INVALCOLOR
)
8358 rgb
= gui_mch_get_rgb(color
);
8359 sprintf((char *)buf
, "#%02x%02x%02x",
8360 (unsigned)(rgb
>> 16),
8361 (unsigned)(rgb
>> 8) & 255,
8362 (unsigned)rgb
& 255);
8366 return (HL_TABLE()[id
- 1].sg_gui_fg_name
);
8368 return (HL_TABLE()[id
- 1].sg_gui_sp_name
);
8369 return (HL_TABLE()[id
- 1].sg_gui_bg_name
);
8375 n
= HL_TABLE()[id
- 1].sg_cterm_fg
- 1;
8377 n
= HL_TABLE()[id
- 1].sg_cterm_bg
- 1;
8378 sprintf((char *)name
, "%d", n
);
8381 /* term doesn't have color */
8386 #if (defined(FEAT_SYN_HL) && defined(FEAT_GUI) && defined(FEAT_PRINTER)) \
8389 * Return color name of highlight group "id" as RGB value.
8392 highlight_gui_color_rgb(id
, fg
)
8394 int fg
; /* TRUE = fg, FALSE = bg */
8398 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8402 color
= HL_TABLE()[id
- 1].sg_gui_fg
;
8404 color
= HL_TABLE()[id
- 1].sg_gui_bg
;
8406 if (color
== INVALCOLOR
)
8409 return gui_mch_get_rgb(color
);
8414 * Output the syntax list header.
8415 * Return TRUE when started a new line.
8418 syn_list_header(did_header
, outlen
, id
)
8419 int did_header
; /* did header already */
8420 int outlen
; /* length of string that comes */
8421 int id
; /* highlight group id */
8431 msg_outtrans(HL_TABLE()[id
- 1].sg_name
);
8434 else if (msg_col
+ outlen
+ 1 >= Columns
)
8442 if (msg_col
>= endcol
) /* wrap around is like starting a new line */
8446 if (msg_col
>= endcol
) /* output at least one space */
8447 endcol
= msg_col
+ 1;
8448 if (Columns
<= endcol
) /* avoid hang for tiny window */
8449 endcol
= Columns
- 1;
8451 msg_advance(endcol
);
8453 /* Show "xxx" with the attributes. */
8456 msg_puts_attr((char_u
*)"xxx", syn_id2attr(id
));
8464 * Set the attribute numbers for a highlight group.
8465 * Called after one of the attributes has changed.
8469 int idx
; /* index in array */
8472 struct hl_group
*sgp
= HL_TABLE() + idx
;
8474 /* The "Normal" group doesn't need an attribute number */
8475 if (sgp
->sg_name_u
!= NULL
&& STRCMP(sgp
->sg_name_u
, "NORMAL") == 0)
8480 * For the GUI mode: If there are other than "normal" highlighting
8481 * attributes, need to allocate an attr number.
8483 if (sgp
->sg_gui_fg
== INVALCOLOR
8484 && sgp
->sg_gui_bg
== INVALCOLOR
8485 && sgp
->sg_gui_sp
== INVALCOLOR
8486 && sgp
->sg_font
== NOFONT
8487 # ifdef FEAT_XFONTSET
8488 && sgp
->sg_fontset
== NOFONTSET
8492 sgp
->sg_gui_attr
= sgp
->sg_gui
;
8496 at_en
.ae_attr
= sgp
->sg_gui
;
8497 at_en
.ae_u
.gui
.fg_color
= sgp
->sg_gui_fg
;
8498 at_en
.ae_u
.gui
.bg_color
= sgp
->sg_gui_bg
;
8499 at_en
.ae_u
.gui
.sp_color
= sgp
->sg_gui_sp
;
8500 at_en
.ae_u
.gui
.font
= sgp
->sg_font
;
8501 # ifdef FEAT_XFONTSET
8502 at_en
.ae_u
.gui
.fontset
= sgp
->sg_fontset
;
8504 sgp
->sg_gui_attr
= get_attr_entry(&gui_attr_table
, &at_en
);
8508 * For the term mode: If there are other than "normal" highlighting
8509 * attributes, need to allocate an attr number.
8511 if (sgp
->sg_start
== NULL
&& sgp
->sg_stop
== NULL
)
8512 sgp
->sg_term_attr
= sgp
->sg_term
;
8515 at_en
.ae_attr
= sgp
->sg_term
;
8516 at_en
.ae_u
.term
.start
= sgp
->sg_start
;
8517 at_en
.ae_u
.term
.stop
= sgp
->sg_stop
;
8518 sgp
->sg_term_attr
= get_attr_entry(&term_attr_table
, &at_en
);
8522 * For the color term mode: If there are other than "normal"
8523 * highlighting attributes, need to allocate an attr number.
8525 if (sgp
->sg_cterm_fg
== 0 && sgp
->sg_cterm_bg
== 0)
8526 sgp
->sg_cterm_attr
= sgp
->sg_cterm
;
8529 at_en
.ae_attr
= sgp
->sg_cterm
;
8530 at_en
.ae_u
.cterm
.fg_color
= sgp
->sg_cterm_fg
;
8531 at_en
.ae_u
.cterm
.bg_color
= sgp
->sg_cterm_bg
;
8532 sgp
->sg_cterm_attr
= get_attr_entry(&cterm_attr_table
, &at_en
);
8537 * Lookup a highlight group name and return it's ID.
8538 * If it is not found, 0 is returned.
8547 /* Avoid using stricmp() too much, it's slow on some systems */
8548 /* Avoid alloc()/free(), these are slow too. ID names over 200 chars
8549 * don't deserve to be found! */
8550 vim_strncpy(name_u
, name
, 199);
8552 for (i
= highlight_ga
.ga_len
; --i
>= 0; )
8553 if (HL_TABLE()[i
].sg_name_u
!= NULL
8554 && STRCMP(name_u
, HL_TABLE()[i
].sg_name_u
) == 0)
8559 #if defined(FEAT_EVAL) || defined(PROTO)
8561 * Return TRUE if highlight group "name" exists.
8564 highlight_exists(name
)
8567 return (syn_name2id(name
) > 0);
8570 # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
8572 * Return the name of highlight group "id".
8573 * When not a valid ID return an empty string.
8579 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8580 return (char_u
*)"";
8581 return HL_TABLE()[id
- 1].sg_name
;
8587 * Like syn_name2id(), but take a pointer + length argument.
8590 syn_namen2id(linep
, len
)
8597 name
= vim_strnsave(linep
, len
);
8600 id
= syn_name2id(name
);
8607 * Find highlight group name in the table and return it's ID.
8608 * The argument is a pointer to the name and the length of the name.
8609 * If it doesn't exist yet, a new entry is created.
8610 * Return 0 for failure.
8613 syn_check_group(pp
, len
)
8620 name
= vim_strnsave(pp
, len
);
8624 id
= syn_name2id(name
);
8625 if (id
== 0) /* doesn't exist yet */
8626 id
= syn_add_group(name
);
8633 * Add new highlight group and return it's ID.
8634 * "name" must be an allocated string, it will be consumed.
8635 * Return 0 for failure.
8643 /* Check that the name is ASCII letters, digits and underscore. */
8644 for (p
= name
; *p
!= NUL
; ++p
)
8646 if (!vim_isprintc(*p
))
8648 EMSG(_("E669: Unprintable character in group name"));
8652 else if (!ASCII_ISALNUM(*p
) && *p
!= '_')
8654 /* This is an error, but since there previously was no check only
8655 * give a warning. */
8656 msg_source(hl_attr(HLF_W
));
8657 MSG(_("W18: Invalid character in group name"));
8663 * First call for this growarray: init growing array.
8665 if (highlight_ga
.ga_data
== NULL
)
8667 highlight_ga
.ga_itemsize
= sizeof(struct hl_group
);
8668 highlight_ga
.ga_growsize
= 10;
8672 * Make room for at least one other syntax_highlight entry.
8674 if (ga_grow(&highlight_ga
, 1) == FAIL
)
8680 vim_memset(&(HL_TABLE()[highlight_ga
.ga_len
]), 0, sizeof(struct hl_group
));
8681 HL_TABLE()[highlight_ga
.ga_len
].sg_name
= name
;
8682 HL_TABLE()[highlight_ga
.ga_len
].sg_name_u
= vim_strsave_up(name
);
8684 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_bg
= INVALCOLOR
;
8685 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_fg
= INVALCOLOR
;
8686 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_sp
= INVALCOLOR
;
8688 ++highlight_ga
.ga_len
;
8690 return highlight_ga
.ga_len
; /* ID is index plus one */
8694 * When, just after calling syn_add_group(), an error is discovered, this
8695 * function deletes the new name.
8700 --highlight_ga
.ga_len
;
8701 vim_free(HL_TABLE()[highlight_ga
.ga_len
].sg_name
);
8702 vim_free(HL_TABLE()[highlight_ga
.ga_len
].sg_name_u
);
8706 * Translate a group ID to highlight attributes.
8713 struct hl_group
*sgp
;
8715 hl_id
= syn_get_final_id(hl_id
);
8716 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8720 * Only use GUI attr when the GUI is being used.
8723 attr
= sgp
->sg_gui_attr
;
8727 attr
= sgp
->sg_cterm_attr
;
8729 attr
= sgp
->sg_term_attr
;
8736 * Get the GUI colors and attributes for a group ID.
8737 * NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
8740 syn_id2colors(hl_id
, fgp
, bgp
)
8745 struct hl_group
*sgp
;
8747 hl_id
= syn_get_final_id(hl_id
);
8748 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8750 *fgp
= sgp
->sg_gui_fg
;
8751 *bgp
= sgp
->sg_gui_bg
;
8757 * Translate a group ID to the final group ID (following links).
8760 syn_get_final_id(hl_id
)
8764 struct hl_group
*sgp
;
8766 if (hl_id
> highlight_ga
.ga_len
|| hl_id
< 1)
8767 return 0; /* Can be called from eval!! */
8770 * Follow links until there is no more.
8771 * Look out for loops! Break after 100 links.
8773 for (count
= 100; --count
>= 0; )
8775 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8776 if (sgp
->sg_link
== 0 || sgp
->sg_link
> highlight_ga
.ga_len
)
8778 hl_id
= sgp
->sg_link
;
8786 * Call this function just after the GUI has started.
8787 * It finds the font and color handles for the highlighting groups.
8790 highlight_gui_started()
8794 /* First get the colors from the "Normal" and "Menu" group, if set */
8795 set_normal_colors();
8797 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
8798 gui_do_one_color(idx
, FALSE
, FALSE
);
8800 highlight_changed();
8804 gui_do_one_color(idx
, do_menu
, do_tooltip
)
8806 int do_menu
; /* TRUE: might set the menu font */
8807 int do_tooltip
; /* TRUE: might set the tooltip font */
8811 if (HL_TABLE()[idx
].sg_font_name
!= NULL
)
8813 hl_do_font(idx
, HL_TABLE()[idx
].sg_font_name
, FALSE
, do_menu
,
8817 if (HL_TABLE()[idx
].sg_gui_fg_name
!= NULL
)
8819 HL_TABLE()[idx
].sg_gui_fg
=
8820 color_name2handle(HL_TABLE()[idx
].sg_gui_fg_name
);
8823 if (HL_TABLE()[idx
].sg_gui_bg_name
!= NULL
)
8825 HL_TABLE()[idx
].sg_gui_bg
=
8826 color_name2handle(HL_TABLE()[idx
].sg_gui_bg_name
);
8829 if (HL_TABLE()[idx
].sg_gui_sp_name
!= NULL
)
8831 HL_TABLE()[idx
].sg_gui_sp
=
8832 color_name2handle(HL_TABLE()[idx
].sg_gui_sp_name
);
8835 if (didit
) /* need to get a new attr number */
8842 * Translate the 'highlight' option into attributes in highlight_attr[] and
8843 * set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of
8844 * corresponding highlights to use on top of HLF_SNC is computed.
8845 * Called only when the 'highlight' option has been changed and upon first
8846 * screen redraw after any :highlight command.
8847 * Return FAIL when an invalid flag is found in 'highlight'. OK otherwise.
8858 #ifdef USER_HIGHLIGHT
8860 # ifdef FEAT_STL_OPT
8866 static int hl_flags
[HLF_COUNT
] = HL_FLAGS
;
8868 need_highlight_changed
= FALSE
;
8871 * Clear all attributes.
8873 for (hlf
= 0; hlf
< (int)HLF_COUNT
; ++hlf
)
8874 highlight_attr
[hlf
] = 0;
8877 * First set all attributes to their default value.
8878 * Then use the attributes from the 'highlight' option.
8880 for (i
= 0; i
< 2; ++i
)
8885 p
= get_highlight_default();
8886 if (p
== NULL
) /* just in case */
8891 for (hlf
= 0; hlf
< (int)HLF_COUNT
; ++hlf
)
8892 if (hl_flags
[hlf
] == *p
)
8895 if (hlf
== (int)HLF_COUNT
|| *p
== NUL
)
8899 * Allow several hl_flags to be combined, like "bu" for
8903 for ( ; *p
&& *p
!= ','; ++p
) /* parse upto comma */
8905 if (vim_iswhite(*p
)) /* ignore white space */
8908 if (attr
> HL_ALL
) /* Combination with ':' is not allowed. */
8913 case 'b': attr
|= HL_BOLD
;
8915 case 'i': attr
|= HL_ITALIC
;
8918 case 'n': /* no highlighting */
8920 case 'r': attr
|= HL_INVERSE
;
8922 case 's': attr
|= HL_STANDOUT
;
8924 case 'u': attr
|= HL_UNDERLINE
;
8926 case 'c': attr
|= HL_UNDERCURL
;
8928 case ':': ++p
; /* highlight group name */
8929 if (attr
|| *p
== NUL
) /* no combinations */
8931 end
= vim_strchr(p
, ',');
8933 end
= p
+ STRLEN(p
);
8934 id
= syn_check_group(p
, (int)(end
- p
));
8937 attr
= syn_id2attr(id
);
8939 #if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT)
8940 if (hlf
== (int)HLF_SNC
)
8941 id_SNC
= syn_get_final_id(id
);
8942 else if (hlf
== (int)HLF_S
)
8943 id_S
= syn_get_final_id(id
);
8946 default: return FAIL
;
8949 highlight_attr
[hlf
] = attr
;
8951 p
= skip_to_option_part(p
); /* skip comma and spaces */
8955 #ifdef USER_HIGHLIGHT
8956 /* Setup the user highlights
8958 * Temporarily utilize 10 more hl entries. Have to be in there
8959 * simultaneously in case of table overflows in get_attr_entry()
8961 # ifdef FEAT_STL_OPT
8962 if (ga_grow(&highlight_ga
, 10) == FAIL
)
8964 hlcnt
= highlight_ga
.ga_len
;
8966 { /* Make sure id_S is always valid to simplify code below */
8967 memset(&HL_TABLE()[hlcnt
+ 9], 0, sizeof(struct hl_group
));
8968 HL_TABLE()[hlcnt
+ 9].sg_term
= highlight_attr
[HLF_S
];
8972 for (i
= 0; i
< 9; i
++)
8974 sprintf((char *)userhl
, "User%d", i
+ 1);
8975 id
= syn_name2id(userhl
);
8978 highlight_user
[i
] = 0;
8979 # ifdef FEAT_STL_OPT
8980 highlight_stlnc
[i
] = 0;
8985 # ifdef FEAT_STL_OPT
8986 struct hl_group
*hlt
= HL_TABLE();
8989 highlight_user
[i
] = syn_id2attr(id
);
8990 # ifdef FEAT_STL_OPT
8993 memset(&hlt
[hlcnt
+ i
], 0, sizeof(struct hl_group
));
8994 hlt
[hlcnt
+ i
].sg_term
= highlight_attr
[HLF_SNC
];
8995 hlt
[hlcnt
+ i
].sg_cterm
= highlight_attr
[HLF_SNC
];
8997 hlt
[hlcnt
+ i
].sg_gui
= highlight_attr
[HLF_SNC
];
9001 mch_memmove(&hlt
[hlcnt
+ i
],
9003 sizeof(struct hl_group
));
9004 hlt
[hlcnt
+ i
].sg_link
= 0;
9006 /* Apply difference between UserX and HLF_S to HLF_SNC */
9007 hlt
[hlcnt
+ i
].sg_term
^=
9008 hlt
[id
- 1].sg_term
^ hlt
[id_S
- 1].sg_term
;
9009 if (hlt
[id
- 1].sg_start
!= hlt
[id_S
- 1].sg_start
)
9010 hlt
[hlcnt
+ i
].sg_start
= hlt
[id
- 1].sg_start
;
9011 if (hlt
[id
- 1].sg_stop
!= hlt
[id_S
- 1].sg_stop
)
9012 hlt
[hlcnt
+ i
].sg_stop
= hlt
[id
- 1].sg_stop
;
9013 hlt
[hlcnt
+ i
].sg_cterm
^=
9014 hlt
[id
- 1].sg_cterm
^ hlt
[id_S
- 1].sg_cterm
;
9015 if (hlt
[id
- 1].sg_cterm_fg
!= hlt
[id_S
- 1].sg_cterm_fg
)
9016 hlt
[hlcnt
+ i
].sg_cterm_fg
= hlt
[id
- 1].sg_cterm_fg
;
9017 if (hlt
[id
- 1].sg_cterm_bg
!= hlt
[id_S
- 1].sg_cterm_bg
)
9018 hlt
[hlcnt
+ i
].sg_cterm_bg
= hlt
[id
- 1].sg_cterm_bg
;
9020 hlt
[hlcnt
+ i
].sg_gui
^=
9021 hlt
[id
- 1].sg_gui
^ hlt
[id_S
- 1].sg_gui
;
9022 if (hlt
[id
- 1].sg_gui_fg
!= hlt
[id_S
- 1].sg_gui_fg
)
9023 hlt
[hlcnt
+ i
].sg_gui_fg
= hlt
[id
- 1].sg_gui_fg
;
9024 if (hlt
[id
- 1].sg_gui_bg
!= hlt
[id_S
- 1].sg_gui_bg
)
9025 hlt
[hlcnt
+ i
].sg_gui_bg
= hlt
[id
- 1].sg_gui_bg
;
9026 if (hlt
[id
- 1].sg_gui_sp
!= hlt
[id_S
- 1].sg_gui_sp
)
9027 hlt
[hlcnt
+ i
].sg_gui_sp
= hlt
[id
- 1].sg_gui_sp
;
9028 if (hlt
[id
- 1].sg_font
!= hlt
[id_S
- 1].sg_font
)
9029 hlt
[hlcnt
+ i
].sg_font
= hlt
[id
- 1].sg_font
;
9030 # ifdef FEAT_XFONTSET
9031 if (hlt
[id
- 1].sg_fontset
!= hlt
[id_S
- 1].sg_fontset
)
9032 hlt
[hlcnt
+ i
].sg_fontset
= hlt
[id
- 1].sg_fontset
;
9035 highlight_ga
.ga_len
= hlcnt
+ i
+ 1;
9036 set_hl_attr(hlcnt
+ i
); /* At long last we can apply */
9037 highlight_stlnc
[i
] = syn_id2attr(hlcnt
+ i
+ 1);
9041 # ifdef FEAT_STL_OPT
9042 highlight_ga
.ga_len
= hlcnt
;
9045 #endif /* USER_HIGHLIGHT */
9050 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9052 static void highlight_list
__ARGS((void));
9053 static void highlight_list_two
__ARGS((int cnt
, int attr
));
9056 * Handle command line completion for :highlight command.
9059 set_context_in_highlight_cmd(xp
, arg
)
9065 /* Default: expand group names */
9066 xp
->xp_context
= EXPAND_HIGHLIGHT
;
9067 xp
->xp_pattern
= arg
;
9069 include_default
= 1;
9071 /* (part of) subcommand already typed */
9074 p
= skiptowhite(arg
);
9075 if (*p
!= NUL
) /* past "default" or group name */
9077 include_default
= 0;
9078 if (STRNCMP("default", arg
, p
- arg
) == 0)
9081 xp
->xp_pattern
= arg
;
9082 p
= skiptowhite(arg
);
9084 if (*p
!= NUL
) /* past group name */
9087 if (arg
[1] == 'i' && arg
[0] == 'N')
9089 if (STRNCMP("link", arg
, p
- arg
) == 0
9090 || STRNCMP("clear", arg
, p
- arg
) == 0)
9092 xp
->xp_pattern
= skipwhite(p
);
9093 p
= skiptowhite(xp
->xp_pattern
);
9094 if (*p
!= NUL
) /* past first group name */
9096 xp
->xp_pattern
= skipwhite(p
);
9097 p
= skiptowhite(xp
->xp_pattern
);
9100 if (*p
!= NUL
) /* past group name(s) */
9101 xp
->xp_context
= EXPAND_NOTHING
;
9108 * List highlighting matches in a nice way.
9115 for (i
= 10; --i
>= 0; )
9116 highlight_list_two(i
, hl_attr(HLF_D
));
9117 for (i
= 40; --i
>= 0; )
9118 highlight_list_two(99, 0);
9122 highlight_list_two(cnt
, attr
)
9126 msg_puts_attr((char_u
*)("N \bI \b! \b" + cnt
/ 11), attr
);
9129 ui_delay(cnt
== 99 ? 40L : (long)cnt
* 50L, FALSE
);
9132 #endif /* FEAT_CMDL_COMPL */
9134 #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) \
9135 || defined(FEAT_SIGNS) || defined(PROTO)
9137 * Function given to ExpandGeneric() to obtain the list of group names.
9138 * Also used for synIDattr() function.
9141 get_highlight_name(xp
, idx
)
9142 expand_T
*xp UNUSED
;
9145 #ifdef FEAT_CMDL_COMPL
9146 if (idx
== highlight_ga
.ga_len
&& include_none
!= 0)
9147 return (char_u
*)"none";
9148 if (idx
== highlight_ga
.ga_len
+ include_none
&& include_default
!= 0)
9149 return (char_u
*)"default";
9150 if (idx
== highlight_ga
.ga_len
+ include_none
+ include_default
9151 && include_link
!= 0)
9152 return (char_u
*)"link";
9153 if (idx
== highlight_ga
.ga_len
+ include_none
+ include_default
+ 1
9154 && include_link
!= 0)
9155 return (char_u
*)"clear";
9157 if (idx
< 0 || idx
>= highlight_ga
.ga_len
)
9159 return HL_TABLE()[idx
].sg_name
;
9163 #if defined(FEAT_GUI) || defined(PROTO)
9165 * Free all the highlight group fonts.
9166 * Used when quitting for systems which need it.
9169 free_highlight_fonts()
9173 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
9175 gui_mch_free_font(HL_TABLE()[idx
].sg_font
);
9176 HL_TABLE()[idx
].sg_font
= NOFONT
;
9177 # ifdef FEAT_XFONTSET
9178 gui_mch_free_fontset(HL_TABLE()[idx
].sg_fontset
);
9179 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
9183 gui_mch_free_font(gui
.norm_font
);
9184 # ifdef FEAT_XFONTSET
9185 gui_mch_free_fontset(gui
.fontset
);
9188 gui_mch_free_font(gui
.bold_font
);
9189 gui_mch_free_font(gui
.ital_font
);
9190 gui_mch_free_font(gui
.boldital_font
);
9195 /**************************************
9196 * End of Highlighting stuff *
9197 **************************************/