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, transparancy 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, transparancy 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((synstate_T
*sp
));
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
));
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
;
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(NULL
);
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 prev
= syn_stack_find_entry(current_lnum
);
562 while (current_lnum
< lnum
)
565 (void)syn_finish_line(FALSE
);
568 /* If we parsed at least "minlines" lines or started at a valid
569 * state, the current state is considered valid. */
570 if (current_lnum
>= first_stored
)
572 /* Check if the saved state entry is for the current line and is
573 * equal to the current state. If so, then validate all saved
574 * states that depended on a change before the parsed line. */
576 sp
= syn_buf
->b_sst_first
;
580 && sp
->sst_lnum
== current_lnum
581 && syn_stack_equal(sp
))
583 parsed_lnum
= current_lnum
;
585 while (sp
!= NULL
&& sp
->sst_change_lnum
<= parsed_lnum
)
587 if (sp
->sst_lnum
<= lnum
)
588 /* valid state before desired line, use this one */
590 else if (sp
->sst_change_lnum
== 0)
591 /* past saved states depending on change, break here. */
593 sp
->sst_change_lnum
= 0;
596 load_current_state(prev
);
598 /* Store the state at this line when it's the first one, the line
599 * where we start parsing, or some distance from the previously
600 * saved state. But only when parsed at least 'minlines'. */
601 else if (prev
== NULL
602 || current_lnum
== lnum
603 || current_lnum
>= prev
->sst_lnum
+ dist
)
604 prev
= store_current_state(prev
);
607 /* This can take a long time: break when CTRL-C pressed. The current
608 * state will be wrong then. */
621 * We cannot simply discard growarrays full of state_items or buf_states; we
622 * have to manually release their extmatch pointers first.
631 if (p
->sst_stacksize
> SST_FIX_STATES
)
633 gap
= &(p
->sst_union
.sst_ga
);
634 for (i
= 0; i
< gap
->ga_len
; i
++)
635 unref_extmatch(SYN_STATE_P(gap
)[i
].bs_extmatch
);
640 for (i
= 0; i
< p
->sst_stacksize
; i
++)
641 unref_extmatch(p
->sst_union
.sst_stack
[i
].bs_extmatch
);
646 * Cleanup the current_state stack.
649 clear_current_state()
654 sip
= (stateitem_T
*)(current_state
.ga_data
);
655 for (i
= 0; i
< current_state
.ga_len
; i
++)
656 unref_extmatch(sip
[i
].si_extmatch
);
657 ga_clear(¤t_state
);
661 * Try to find a synchronisation point for line "lnum".
663 * This sets current_lnum and the current state. One of three methods is
665 * 1. Search backwards for the end of a C-comment.
666 * 2. Search backwards for given sync patterns.
667 * 3. Simply start on a given number of lines above "lnum".
670 syn_sync(wp
, start_lnum
, last_valid
)
673 synstate_T
*last_valid
;
687 int found_match_idx
= 0;
688 linenr_T found_current_lnum
= 0;
689 int found_current_col
= 0;
690 lpos_T found_m_endpos
;
691 colnr_T prev_current_col
;
694 * Clear any current state that might be hanging around.
696 invalidate_current_state();
699 * Start at least "minlines" back. Default starting point for parsing is
701 * Start further back, to avoid that scrolling backwards will result in
702 * resyncing for every line. Now it resyncs only one out of N lines,
703 * where N is minlines * 1.5, or minlines * 2 if minlines is small.
704 * Watch out for overflow when minlines is MAXLNUM.
706 if (syn_buf
->b_syn_sync_minlines
> start_lnum
)
710 if (syn_buf
->b_syn_sync_minlines
== 1)
712 else if (syn_buf
->b_syn_sync_minlines
< 10)
713 lnum
= syn_buf
->b_syn_sync_minlines
* 2;
715 lnum
= syn_buf
->b_syn_sync_minlines
* 3 / 2;
716 if (syn_buf
->b_syn_sync_maxlines
!= 0
717 && lnum
> syn_buf
->b_syn_sync_maxlines
)
718 lnum
= syn_buf
->b_syn_sync_maxlines
;
719 if (lnum
>= start_lnum
)
724 current_lnum
= start_lnum
;
727 * 1. Search backwards for the end of a C-style comment.
729 if (syn_buf
->b_syn_sync_flags
& SF_CCOMMENT
)
731 /* Need to make syn_buf the current buffer for a moment, to be able to
732 * use find_start_comment(). */
733 curwin_save
= curwin
;
735 curbuf_save
= curbuf
;
739 * Skip lines that end in a backslash.
741 for ( ; start_lnum
> 1; --start_lnum
)
743 line
= ml_get(start_lnum
- 1);
744 if (*line
== NUL
|| *(line
+ STRLEN(line
) - 1) != '\\')
747 current_lnum
= start_lnum
;
749 /* set cursor to start of search */
750 cursor_save
= wp
->w_cursor
;
751 wp
->w_cursor
.lnum
= start_lnum
;
752 wp
->w_cursor
.col
= 0;
755 * If the line is inside a comment, need to find the syntax item that
756 * defines the comment.
757 * Restrict the search for the end of a comment to b_syn_sync_maxlines.
759 if (find_start_comment((int)syn_buf
->b_syn_sync_maxlines
) != NULL
)
761 for (idx
= syn_buf
->b_syn_patterns
.ga_len
; --idx
>= 0; )
762 if (SYN_ITEMS(syn_buf
)[idx
].sp_syn
.id
== syn_buf
->b_syn_sync_id
763 && SYN_ITEMS(syn_buf
)[idx
].sp_type
== SPTYPE_START
)
765 validate_current_state();
766 if (push_current_state(idx
) == OK
)
767 update_si_attr(current_state
.ga_len
- 1);
772 /* restore cursor and buffer */
773 wp
->w_cursor
= cursor_save
;
774 curwin
= curwin_save
;
775 curbuf
= curbuf_save
;
779 * 2. Search backwards for given sync patterns.
781 else if (syn_buf
->b_syn_sync_flags
& SF_MATCH
)
783 if (syn_buf
->b_syn_sync_maxlines
!= 0
784 && start_lnum
> syn_buf
->b_syn_sync_maxlines
)
785 break_lnum
= start_lnum
- syn_buf
->b_syn_sync_maxlines
;
789 found_m_endpos
.lnum
= 0;
790 found_m_endpos
.col
= 0;
791 end_lnum
= start_lnum
;
793 while (--lnum
> break_lnum
)
795 /* This can take a long time: break when CTRL-C pressed. */
799 invalidate_current_state();
800 current_lnum
= start_lnum
;
804 /* Check if we have run into a valid saved state stack now. */
805 if (last_valid
!= NULL
&& lnum
== last_valid
->sst_lnum
)
807 load_current_state(last_valid
);
812 * Check if the previous line has the line-continuation pattern.
814 if (lnum
> 1 && syn_match_linecont(lnum
- 1))
818 * Start with nothing on the state stack
820 validate_current_state();
822 for (current_lnum
= lnum
; current_lnum
< end_lnum
; ++current_lnum
)
827 had_sync_point
= syn_finish_line(TRUE
);
829 * When a sync point has been found, remember where, and
830 * continue to look for another one, further on in the line.
832 if (had_sync_point
&& current_state
.ga_len
)
834 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
835 if (cur_si
->si_m_endpos
.lnum
> start_lnum
)
837 /* ignore match that goes to after where started */
838 current_lnum
= end_lnum
;
841 if (cur_si
->si_idx
< 0)
845 found_match_idx
= KEYWORD_IDX
;
849 spp
= &(SYN_ITEMS(syn_buf
)[cur_si
->si_idx
]);
850 found_flags
= spp
->sp_flags
;
851 found_match_idx
= spp
->sp_sync_idx
;
853 found_current_lnum
= current_lnum
;
854 found_current_col
= current_col
;
855 found_m_endpos
= cur_si
->si_m_endpos
;
857 * Continue after the match (be aware of a zero-length
860 if (found_m_endpos
.lnum
> current_lnum
)
862 current_lnum
= found_m_endpos
.lnum
;
863 current_col
= found_m_endpos
.col
;
864 if (current_lnum
>= end_lnum
)
867 else if (found_m_endpos
.col
> current_col
)
868 current_col
= found_m_endpos
.col
;
872 /* syn_current_attr() will have skipped the check for
873 * an item that ends here, need to do that now. Be
874 * careful not to go past the NUL. */
875 prev_current_col
= current_col
;
876 if (syn_getcurline()[current_col
] != NUL
)
879 current_col
= prev_current_col
;
887 * If a sync point was encountered, break here.
892 * Put the item that was specified by the sync point on the
893 * state stack. If there was no item specified, make the
896 clear_current_state();
897 if (found_match_idx
>= 0
898 && push_current_state(found_match_idx
) == OK
)
899 update_si_attr(current_state
.ga_len
- 1);
902 * When using "grouphere", continue from the sync point
903 * match, until the end of the line. Parsing starts at
905 * For "groupthere" the parsing starts at start_lnum.
907 if (found_flags
& HL_SYNC_HERE
)
909 if (current_state
.ga_len
)
911 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
912 cur_si
->si_h_startpos
.lnum
= found_current_lnum
;
913 cur_si
->si_h_startpos
.col
= found_current_col
;
914 update_si_end(cur_si
, (int)current_col
, TRUE
);
917 current_col
= found_m_endpos
.col
;
918 current_lnum
= found_m_endpos
.lnum
;
919 (void)syn_finish_line(FALSE
);
923 current_lnum
= start_lnum
;
929 invalidate_current_state();
932 /* Ran into start of the file or exceeded maximum number of lines */
933 if (lnum
<= break_lnum
)
935 invalidate_current_state();
936 current_lnum
= break_lnum
+ 1;
940 validate_current_state();
944 * Return TRUE if the line-continuation pattern matches in line "lnum".
947 syn_match_linecont(lnum
)
950 regmmatch_T regmatch
;
952 if (syn_buf
->b_syn_linecont_prog
!= NULL
)
954 regmatch
.rmm_ic
= syn_buf
->b_syn_linecont_ic
;
955 regmatch
.regprog
= syn_buf
->b_syn_linecont_prog
;
956 return syn_regexec(®match
, lnum
, (colnr_T
)0);
962 * Prepare the current state for the start of a line.
967 current_finished
= FALSE
;
971 * Need to update the end of a start/skip/end that continues from the
972 * previous line and regions that have "keepend".
974 if (current_state
.ga_len
> 0)
975 syn_update_ends(TRUE
);
982 * Check for items in the stack that need their end updated.
983 * When "startofline" is TRUE the last item is always updated.
984 * When "startofline" is FALSE the item with "keepend" is forcefully updated.
987 syn_update_ends(startofline
)
996 /* Check for a match carried over from a previous line with a
997 * contained region. The match ends as soon as the region ends. */
998 for (i
= 0; i
< current_state
.ga_len
; ++i
)
1000 cur_si
= &CUR_STATE(i
);
1001 if (cur_si
->si_idx
>= 0
1002 && (SYN_ITEMS(syn_buf
)[cur_si
->si_idx
]).sp_type
1004 && cur_si
->si_m_endpos
.lnum
< current_lnum
)
1006 cur_si
->si_flags
|= HL_MATCHCONT
;
1007 cur_si
->si_m_endpos
.lnum
= 0;
1008 cur_si
->si_m_endpos
.col
= 0;
1009 cur_si
->si_h_endpos
= cur_si
->si_m_endpos
;
1010 cur_si
->si_ends
= TRUE
;
1016 * Need to update the end of a start/skip/end that continues from the
1017 * previous line. And regions that have "keepend", because they may
1018 * influence contained items. If we've just removed "extend"
1019 * (startofline == 0) then we should update ends of normal regions
1020 * contained inside "keepend" because "extend" could have extended
1021 * these "keepend" regions as well as contained normal regions.
1022 * Then check for items ending in column 0.
1024 i
= current_state
.ga_len
- 1;
1025 if (keepend_level
>= 0)
1026 for ( ; i
> keepend_level
; --i
)
1027 if (CUR_STATE(i
).si_flags
& HL_EXTEND
)
1030 seen_keepend
= FALSE
;
1031 for ( ; i
< current_state
.ga_len
; ++i
)
1033 cur_si
= &CUR_STATE(i
);
1034 if ((cur_si
->si_flags
& HL_KEEPEND
)
1035 || (seen_keepend
&& !startofline
)
1036 || (i
== current_state
.ga_len
- 1 && startofline
))
1038 cur_si
->si_h_startpos
.col
= 0; /* start highl. in col 0 */
1039 cur_si
->si_h_startpos
.lnum
= current_lnum
;
1041 if (!(cur_si
->si_flags
& HL_MATCHCONT
))
1042 update_si_end(cur_si
, (int)current_col
, !startofline
);
1044 if (!startofline
&& (cur_si
->si_flags
& HL_KEEPEND
))
1045 seen_keepend
= TRUE
;
1052 /****************************************
1053 * Handling of the state stack cache.
1057 * EXPLANATION OF THE SYNTAX STATE STACK CACHE
1059 * To speed up syntax highlighting, the state stack for the start of some
1060 * lines is cached. These entries can be used to start parsing at that point.
1062 * The stack is kept in b_sst_array[] for each buffer. There is a list of
1063 * valid entries. b_sst_first points to the first one, then follow sst_next.
1064 * The entries are sorted on line number. The first entry is often for line 2
1065 * (line 1 always starts with an empty stack).
1066 * There is also a list for free entries. This construction is used to avoid
1067 * having to allocate and free memory blocks too often.
1069 * When making changes to the buffer, this is logged in b_mod_*. When calling
1070 * update_screen() to update the display, it will call
1071 * syn_stack_apply_changes() for each displayed buffer to adjust the cached
1072 * entries. The entries which are inside the changed area are removed,
1073 * because they must be recomputed. Entries below the changed have their line
1074 * number adjusted for deleted/inserted lines, and have their sst_change_lnum
1075 * set to indicate that a check must be made if the changed lines would change
1078 * When later displaying lines, an entry is stored for each line. Displayed
1079 * lines are likely to be displayed again, in which case the state at the
1080 * start of the line is needed.
1081 * For not displayed lines, an entry is stored for every so many lines. These
1082 * entries will be used e.g., when scrolling backwards. The distance between
1083 * entries depends on the number of lines in the buffer. For small buffers
1084 * the distance is fixed at SST_DIST, for large buffers there is a fixed
1085 * number of entries SST_MAX_ENTRIES, and the distance is computed.
1089 * Free b_sst_array[] for buffer "buf".
1090 * Used when syntax items changed to force resyncing everywhere.
1093 syn_stack_free_all(buf
)
1099 if (buf
->b_sst_array
!= NULL
)
1101 for (p
= buf
->b_sst_first
; p
!= NULL
; p
= p
->sst_next
)
1103 vim_free(buf
->b_sst_array
);
1104 buf
->b_sst_array
= NULL
;
1108 /* When using "syntax" fold method, must update all folds. */
1111 if (wp
->w_buffer
== buf
&& foldmethodIsSyntax(wp
))
1118 * Allocate the syntax state stack for syn_buf when needed.
1119 * If the number of entries in b_sst_array[] is much too big or a bit too
1120 * small, reallocate it.
1121 * Also used to allocate b_sst_array[] for the first time.
1127 synstate_T
*to
, *from
;
1130 len
= syn_buf
->b_ml
.ml_line_count
/ SST_DIST
+ Rows
* 2;
1131 if (len
< SST_MIN_ENTRIES
)
1132 len
= SST_MIN_ENTRIES
;
1133 else if (len
> SST_MAX_ENTRIES
)
1134 len
= SST_MAX_ENTRIES
;
1135 if (syn_buf
->b_sst_len
> len
* 2 || syn_buf
->b_sst_len
< len
)
1137 /* Allocate 50% too much, to avoid reallocating too often. */
1138 len
= syn_buf
->b_ml
.ml_line_count
;
1139 len
= (len
+ len
/ 2) / SST_DIST
+ Rows
* 2;
1140 if (len
< SST_MIN_ENTRIES
)
1141 len
= SST_MIN_ENTRIES
;
1142 else if (len
> SST_MAX_ENTRIES
)
1143 len
= SST_MAX_ENTRIES
;
1145 if (syn_buf
->b_sst_array
!= NULL
)
1147 /* When shrinking the array, cleanup the existing stack.
1148 * Make sure that all valid entries fit in the new array. */
1149 while (syn_buf
->b_sst_len
- syn_buf
->b_sst_freecount
+ 2 > len
1150 && syn_stack_cleanup())
1152 if (len
< syn_buf
->b_sst_len
- syn_buf
->b_sst_freecount
+ 2)
1153 len
= syn_buf
->b_sst_len
- syn_buf
->b_sst_freecount
+ 2;
1156 sstp
= (synstate_T
*)alloc_clear((unsigned)(len
* sizeof(synstate_T
)));
1157 if (sstp
== NULL
) /* out of memory! */
1161 if (syn_buf
->b_sst_array
!= NULL
)
1163 /* Move the states from the old array to the new one. */
1164 for (from
= syn_buf
->b_sst_first
; from
!= NULL
;
1165 from
= from
->sst_next
)
1169 to
->sst_next
= to
+ 1;
1174 to
->sst_next
= NULL
;
1175 syn_buf
->b_sst_first
= sstp
;
1176 syn_buf
->b_sst_freecount
= len
- (int)(to
- sstp
) - 1;
1180 syn_buf
->b_sst_first
= NULL
;
1181 syn_buf
->b_sst_freecount
= len
;
1184 /* Create the list of free entries. */
1185 syn_buf
->b_sst_firstfree
= to
+ 1;
1186 while (++to
< sstp
+ len
)
1187 to
->sst_next
= to
+ 1;
1188 (sstp
+ len
- 1)->sst_next
= NULL
;
1190 vim_free(syn_buf
->b_sst_array
);
1191 syn_buf
->b_sst_array
= sstp
;
1192 syn_buf
->b_sst_len
= len
;
1197 * Check for changes in a buffer to affect stored syntax states. Uses the
1199 * Called from update_screen(), before screen is being updated, once for each
1203 syn_stack_apply_changes(buf
)
1206 synstate_T
*p
, *prev
, *np
;
1209 if (buf
->b_sst_array
== NULL
) /* nothing to do */
1213 for (p
= buf
->b_sst_first
; p
!= NULL
; )
1215 if (p
->sst_lnum
+ buf
->b_syn_sync_linebreaks
> buf
->b_mod_top
)
1217 n
= p
->sst_lnum
+ buf
->b_mod_xlines
;
1218 if (n
<= buf
->b_mod_bot
)
1220 /* this state is inside the changed area, remove it */
1223 buf
->b_sst_first
= np
;
1225 prev
->sst_next
= np
;
1226 syn_stack_free_entry(buf
, p
);
1230 /* This state is below the changed area. Remember the line
1231 * that needs to be parsed before this entry can be made valid
1233 if (p
->sst_change_lnum
!= 0 && p
->sst_change_lnum
> buf
->b_mod_top
)
1235 if (p
->sst_change_lnum
+ buf
->b_mod_xlines
> buf
->b_mod_top
)
1236 p
->sst_change_lnum
+= buf
->b_mod_xlines
;
1238 p
->sst_change_lnum
= buf
->b_mod_top
;
1240 if (p
->sst_change_lnum
== 0
1241 || p
->sst_change_lnum
< buf
->b_mod_bot
)
1242 p
->sst_change_lnum
= buf
->b_mod_bot
;
1252 * Reduce the number of entries in the state stack for syn_buf.
1253 * Returns TRUE if at least one entry was freed.
1258 synstate_T
*p
, *prev
;
1264 if (syn_buf
->b_sst_array
== NULL
|| syn_buf
->b_sst_first
== NULL
)
1267 /* Compute normal distance between non-displayed entries. */
1268 if (syn_buf
->b_sst_len
<= Rows
)
1271 dist
= syn_buf
->b_ml
.ml_line_count
/ (syn_buf
->b_sst_len
- Rows
) + 1;
1274 * Go throught the list to find the "tick" for the oldest entry that can
1275 * be removed. Set "above" when the "tick" for the oldest entry is above
1276 * "b_sst_lasttick" (the display tick wraps around).
1278 tick
= syn_buf
->b_sst_lasttick
;
1280 prev
= syn_buf
->b_sst_first
;
1281 for (p
= prev
->sst_next
; p
!= NULL
; prev
= p
, p
= p
->sst_next
)
1283 if (prev
->sst_lnum
+ dist
> p
->sst_lnum
)
1285 if (p
->sst_tick
> syn_buf
->b_sst_lasttick
)
1287 if (!above
|| p
->sst_tick
< tick
)
1291 else if (!above
&& p
->sst_tick
< tick
)
1297 * Go through the list to make the entries for the oldest tick at an
1298 * interval of several lines.
1300 prev
= syn_buf
->b_sst_first
;
1301 for (p
= prev
->sst_next
; p
!= NULL
; prev
= p
, p
= p
->sst_next
)
1303 if (p
->sst_tick
== tick
&& prev
->sst_lnum
+ dist
> p
->sst_lnum
)
1305 /* Move this entry from used list to free list */
1306 prev
->sst_next
= p
->sst_next
;
1307 syn_stack_free_entry(syn_buf
, p
);
1316 * Free the allocated memory for a syn_state item.
1317 * Move the entry into the free list.
1320 syn_stack_free_entry(buf
, p
)
1325 p
->sst_next
= buf
->b_sst_firstfree
;
1326 buf
->b_sst_firstfree
= p
;
1327 ++buf
->b_sst_freecount
;
1331 * Find an entry in the list of state stacks at or before "lnum".
1332 * Returns NULL when there is no entry or the first entry is after "lnum".
1335 syn_stack_find_entry(lnum
)
1338 synstate_T
*p
, *prev
;
1341 for (p
= syn_buf
->b_sst_first
; p
!= NULL
; prev
= p
, p
= p
->sst_next
)
1343 if (p
->sst_lnum
== lnum
)
1345 if (p
->sst_lnum
> lnum
)
1352 * Try saving the current state in b_sst_array[].
1353 * The current state must be valid for the start of the current_lnum line!
1356 store_current_state(sp
)
1357 synstate_T
*sp
; /* at or before where state is to be saved or
1363 stateitem_T
*cur_si
;
1366 sp
= syn_stack_find_entry(current_lnum
);
1369 * If the current state contains a start or end pattern that continues
1370 * from the previous line, we can't use it. Don't store it then.
1372 for (i
= current_state
.ga_len
- 1; i
>= 0; --i
)
1374 cur_si
= &CUR_STATE(i
);
1375 if (cur_si
->si_h_startpos
.lnum
>= current_lnum
1376 || cur_si
->si_m_endpos
.lnum
>= current_lnum
1377 || cur_si
->si_h_endpos
.lnum
>= current_lnum
1378 || (cur_si
->si_end_idx
1379 && cur_si
->si_eoe_pos
.lnum
>= current_lnum
))
1386 /* find "sp" in the list and remove it */
1387 if (syn_buf
->b_sst_first
== sp
)
1388 /* it's the first entry */
1389 syn_buf
->b_sst_first
= sp
->sst_next
;
1392 /* find the entry just before this one to adjust sst_next */
1393 for (p
= syn_buf
->b_sst_first
; p
!= NULL
; p
= p
->sst_next
)
1394 if (p
->sst_next
== sp
)
1396 if (p
!= NULL
) /* just in case */
1397 p
->sst_next
= sp
->sst_next
;
1399 syn_stack_free_entry(syn_buf
, sp
);
1403 else if (sp
== NULL
|| sp
->sst_lnum
!= current_lnum
)
1408 /* If no free items, cleanup the array first. */
1409 if (syn_buf
->b_sst_freecount
== 0)
1411 (void)syn_stack_cleanup();
1412 /* "sp" may have been moved to the freelist now */
1413 sp
= syn_stack_find_entry(current_lnum
);
1415 /* Still no free items? Must be a strange problem... */
1416 if (syn_buf
->b_sst_freecount
== 0)
1420 /* Take the first item from the free list and put it in the used
1421 * list, after *sp */
1422 p
= syn_buf
->b_sst_firstfree
;
1423 syn_buf
->b_sst_firstfree
= p
->sst_next
;
1424 --syn_buf
->b_sst_freecount
;
1427 /* Insert in front of the list */
1428 p
->sst_next
= syn_buf
->b_sst_first
;
1429 syn_buf
->b_sst_first
= p
;
1433 /* insert in list after *sp */
1434 p
->sst_next
= sp
->sst_next
;
1438 sp
->sst_stacksize
= 0;
1439 sp
->sst_lnum
= current_lnum
;
1444 /* When overwriting an existing state stack, clear it first */
1445 clear_syn_state(sp
);
1446 sp
->sst_stacksize
= current_state
.ga_len
;
1447 if (current_state
.ga_len
> SST_FIX_STATES
)
1449 /* Need to clear it, might be something remaining from when the
1450 * length was less than SST_FIX_STATES. */
1451 ga_init2(&sp
->sst_union
.sst_ga
, (int)sizeof(bufstate_T
), 1);
1452 if (ga_grow(&sp
->sst_union
.sst_ga
, current_state
.ga_len
) == FAIL
)
1453 sp
->sst_stacksize
= 0;
1455 sp
->sst_union
.sst_ga
.ga_len
= current_state
.ga_len
;
1456 bp
= SYN_STATE_P(&(sp
->sst_union
.sst_ga
));
1459 bp
= sp
->sst_union
.sst_stack
;
1460 for (i
= 0; i
< sp
->sst_stacksize
; ++i
)
1462 bp
[i
].bs_idx
= CUR_STATE(i
).si_idx
;
1463 bp
[i
].bs_flags
= CUR_STATE(i
).si_flags
;
1464 bp
[i
].bs_extmatch
= ref_extmatch(CUR_STATE(i
).si_extmatch
);
1466 sp
->sst_next_flags
= current_next_flags
;
1467 sp
->sst_next_list
= current_next_list
;
1468 sp
->sst_tick
= display_tick
;
1469 sp
->sst_change_lnum
= 0;
1471 current_state_stored
= TRUE
;
1476 * Copy a state stack from "from" in b_sst_array[] to current_state;
1479 load_current_state(from
)
1485 clear_current_state();
1486 validate_current_state();
1488 if (from
->sst_stacksize
1489 && ga_grow(¤t_state
, from
->sst_stacksize
) != FAIL
)
1491 if (from
->sst_stacksize
> SST_FIX_STATES
)
1492 bp
= SYN_STATE_P(&(from
->sst_union
.sst_ga
));
1494 bp
= from
->sst_union
.sst_stack
;
1495 for (i
= 0; i
< from
->sst_stacksize
; ++i
)
1497 CUR_STATE(i
).si_idx
= bp
[i
].bs_idx
;
1498 CUR_STATE(i
).si_flags
= bp
[i
].bs_flags
;
1499 CUR_STATE(i
).si_extmatch
= ref_extmatch(bp
[i
].bs_extmatch
);
1500 if (keepend_level
< 0 && (CUR_STATE(i
).si_flags
& HL_KEEPEND
))
1502 CUR_STATE(i
).si_ends
= FALSE
;
1503 CUR_STATE(i
).si_m_lnum
= 0;
1504 if (CUR_STATE(i
).si_idx
>= 0)
1505 CUR_STATE(i
).si_next_list
=
1506 (SYN_ITEMS(syn_buf
)[CUR_STATE(i
).si_idx
]).sp_next_list
;
1508 CUR_STATE(i
).si_next_list
= NULL
;
1511 current_state
.ga_len
= from
->sst_stacksize
;
1513 current_next_list
= from
->sst_next_list
;
1514 current_next_flags
= from
->sst_next_flags
;
1515 current_lnum
= from
->sst_lnum
;
1519 * Compare saved state stack "*sp" with the current state.
1520 * Return TRUE when they are equal.
1528 reg_extmatch_T
*six
, *bsx
;
1530 /* First a quick check if the stacks have the same size end nextlist. */
1531 if (sp
->sst_stacksize
== current_state
.ga_len
1532 && sp
->sst_next_list
== current_next_list
)
1534 /* Need to compare all states on both stacks. */
1535 if (sp
->sst_stacksize
> SST_FIX_STATES
)
1536 bp
= SYN_STATE_P(&(sp
->sst_union
.sst_ga
));
1538 bp
= sp
->sst_union
.sst_stack
;
1540 for (i
= current_state
.ga_len
; --i
>= 0; )
1542 /* If the item has another index the state is different. */
1543 if (bp
[i
].bs_idx
!= CUR_STATE(i
).si_idx
)
1545 if (bp
[i
].bs_extmatch
!= CUR_STATE(i
).si_extmatch
)
1547 /* When the extmatch pointers are different, the strings in
1548 * them can still be the same. Check if the extmatch
1549 * references are equal. */
1550 bsx
= bp
[i
].bs_extmatch
;
1551 six
= CUR_STATE(i
).si_extmatch
;
1552 /* If one of the extmatch pointers is NULL the states are
1554 if (bsx
== NULL
|| six
== NULL
)
1556 for (j
= 0; j
< NSUBEXP
; ++j
)
1558 /* Check each referenced match string. They must all be
1560 if (bsx
->matches
[j
] != six
->matches
[j
])
1562 /* If the pointer is different it can still be the
1563 * same text. Compare the strings, ignore case when
1564 * the start item has the sp_ic flag set. */
1565 if (bsx
->matches
[j
] == NULL
1566 || six
->matches
[j
] == NULL
)
1568 if ((SYN_ITEMS(syn_buf
)[CUR_STATE(i
).si_idx
]).sp_ic
1569 ? MB_STRICMP(bsx
->matches
[j
],
1570 six
->matches
[j
]) != 0
1571 : STRCMP(bsx
->matches
[j
], six
->matches
[j
]) != 0)
1586 * We stop parsing syntax above line "lnum". If the stored state at or below
1587 * this line depended on a change before it, it now depends on the line below
1588 * the last parsed line.
1589 * The window looks like this:
1590 * line which changed
1593 * lnum -> line below window
1596 syntax_end_parsing(lnum
)
1601 sp
= syn_stack_find_entry(lnum
);
1602 if (sp
!= NULL
&& sp
->sst_lnum
< lnum
)
1605 if (sp
!= NULL
&& sp
->sst_change_lnum
!= 0)
1606 sp
->sst_change_lnum
= lnum
;
1610 * End of handling of the state stack.
1611 ****************************************/
1614 invalidate_current_state()
1616 clear_current_state();
1617 current_state
.ga_itemsize
= 0; /* mark current_state invalid */
1618 current_next_list
= NULL
;
1623 validate_current_state()
1625 current_state
.ga_itemsize
= sizeof(stateitem_T
);
1626 current_state
.ga_growsize
= 3;
1630 * Return TRUE if the syntax at start of lnum changed since last time.
1631 * This will only be called just after get_syntax_attr() for the previous
1632 * line, to check if the next line needs to be redrawn too.
1635 syntax_check_changed(lnum
)
1642 * Check the state stack when:
1643 * - lnum is just below the previously syntaxed line.
1644 * - lnum is not before the lines with saved states.
1645 * - lnum is not past the lines with saved states.
1646 * - lnum is at or before the last changed line.
1648 if (VALID_STATE(¤t_state
) && lnum
== current_lnum
+ 1)
1650 sp
= syn_stack_find_entry(lnum
);
1651 if (sp
!= NULL
&& sp
->sst_lnum
== lnum
)
1654 * finish the previous line (needed when not all of the line was
1657 (void)syn_finish_line(FALSE
);
1660 * Compare the current state with the previously saved state of
1663 if (syn_stack_equal(sp
))
1667 * Store the current state in b_sst_array[] for later use.
1670 (void)store_current_state(NULL
);
1678 * Finish the current line.
1679 * This doesn't return any attributes, it only gets the state at the end of
1680 * the line. It can start anywhere in the line, as long as the current state
1684 syn_finish_line(syncing
)
1685 int syncing
; /* called for syncing */
1687 stateitem_T
*cur_si
;
1688 colnr_T prev_current_col
;
1690 if (!current_finished
)
1692 while (!current_finished
)
1694 (void)syn_current_attr(syncing
, FALSE
, NULL
);
1696 * When syncing, and found some item, need to check the item.
1698 if (syncing
&& current_state
.ga_len
)
1701 * Check for match with sync item.
1703 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
1704 if (cur_si
->si_idx
>= 0
1705 && (SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_flags
1706 & (HL_SYNC_HERE
|HL_SYNC_THERE
)))
1709 /* syn_current_attr() will have skipped the check for an item
1710 * that ends here, need to do that now. Be careful not to go
1712 prev_current_col
= current_col
;
1713 if (syn_getcurline()[current_col
] != NUL
)
1716 current_col
= prev_current_col
;
1725 * Return highlight attributes for next character.
1726 * Must first call syntax_start() once for the line.
1727 * "col" is normally 0 for the first use in a line, and increments by one each
1728 * time. It's allowed to skip characters and to stop before the end of the
1729 * line. But only a "col" after a previously used column is allowed.
1730 * When "can_spell" is not NULL set it to TRUE when spell-checking should be
1734 get_syntax_attr(col
, can_spell
)
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
);
1779 * Get syntax attributes for current_lnum, current_col.
1782 syn_current_attr(syncing
, displaying
, can_spell
)
1783 int syncing
; /* When 1: called for syncing */
1784 int displaying
; /* result will be displayed */
1785 int *can_spell
; /* return: do spell checking */
1788 lpos_T endpos
; /* was: char_u *endp; */
1789 lpos_T hl_startpos
; /* was: int hl_startcol; */
1791 lpos_T eos_pos
; /* end-of-start match (start region) */
1792 lpos_T eoe_pos
; /* end-of-end pattern */
1793 int end_idx
; /* group ID for end pattern */
1796 stateitem_T
*cur_si
, *sip
= NULL
;
1801 int found_match
; /* found usable match */
1802 static int try_next_column
= FALSE
; /* must try in next col */
1804 regmmatch_T regmatch
;
1807 reg_extmatch_T
*cur_extmatch
= NULL
;
1808 char_u
*line
; /* current line. NOTE: becomes invalid after
1809 looking for a pattern match! */
1811 /* variables for zero-width matches that have a "nextgroup" argument */
1813 int zero_width_next_list
= FALSE
;
1814 garray_T zero_width_next_ga
;
1817 * No character, no attributes! Past end of line?
1818 * Do try matching with an empty line (could be the start of a region).
1820 line
= syn_getcurline();
1821 if (line
[current_col
] == NUL
&& current_col
!= 0)
1824 * If we found a match after the last column, use it.
1826 if (next_match_idx
>= 0 && next_match_col
>= (int)current_col
1827 && next_match_col
!= MAXCOL
)
1828 (void)push_next_match(NULL
);
1830 current_finished
= TRUE
;
1831 current_state_stored
= FALSE
;
1835 /* if the current or next character is NUL, we will finish the line now */
1836 if (line
[current_col
] == NUL
|| line
[current_col
+ 1] == NUL
)
1838 current_finished
= TRUE
;
1839 current_state_stored
= FALSE
;
1843 * When in the previous column there was a match but it could not be used
1844 * (empty match or already matched in this column) need to try again in
1847 if (try_next_column
)
1849 next_match_idx
= -1;
1850 try_next_column
= FALSE
;
1853 /* Only check for keywords when not syncing and there are some. */
1854 do_keywords
= !syncing
1855 && (syn_buf
->b_keywtab
.ht_used
> 0
1856 || syn_buf
->b_keywtab_ic
.ht_used
> 0);
1858 /* Init the list of zero-width matches with a nextlist. This is used to
1859 * avoid matching the same item in the same position twice. */
1860 ga_init2(&zero_width_next_ga
, (int)sizeof(int), 10);
1863 * Repeat matching keywords and patterns, to find contained items at the
1864 * same column. This stops when there are no extra matches at the current
1869 found_match
= FALSE
;
1870 keep_next_list
= FALSE
;
1874 * 1. Check for a current state.
1875 * Only when there is no current state, or if the current state may
1876 * contain other things, we need to check for keywords and patterns.
1877 * Always need to check for contained items if some item has the
1878 * "containedin" argument (takes extra time!).
1880 if (current_state
.ga_len
)
1881 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
1885 if (syn_buf
->b_syn_containedin
|| cur_si
== NULL
1886 || cur_si
->si_cont_list
!= NULL
)
1889 * 2. Check for keywords, if on a keyword char after a non-keyword
1890 * char. Don't do this when syncing.
1894 line
= syn_getcurline();
1895 if (vim_iswordc_buf(line
+ current_col
, syn_buf
)
1896 && (current_col
== 0
1897 || !vim_iswordc_buf(line
+ current_col
- 1
1900 ? (*mb_head_off
)(line
, line
+ current_col
- 1)
1905 syn_id
= check_keyword_id(line
, (int)current_col
,
1906 &endcol
, &flags
, &next_list
, cur_si
);
1909 if (push_current_state(KEYWORD_IDX
) == OK
)
1911 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
1912 cur_si
->si_m_startcol
= current_col
;
1913 cur_si
->si_h_startpos
.lnum
= current_lnum
;
1914 cur_si
->si_h_startpos
.col
= 0; /* starts right away */
1915 cur_si
->si_m_endpos
.lnum
= current_lnum
;
1916 cur_si
->si_m_endpos
.col
= endcol
;
1917 cur_si
->si_h_endpos
.lnum
= current_lnum
;
1918 cur_si
->si_h_endpos
.col
= endcol
;
1919 cur_si
->si_ends
= TRUE
;
1920 cur_si
->si_end_idx
= 0;
1921 cur_si
->si_flags
= flags
;
1922 cur_si
->si_id
= syn_id
;
1923 cur_si
->si_trans_id
= syn_id
;
1924 if (flags
& HL_TRANSP
)
1926 if (current_state
.ga_len
< 2)
1928 cur_si
->si_attr
= 0;
1929 cur_si
->si_trans_id
= 0;
1933 cur_si
->si_attr
= CUR_STATE(
1934 current_state
.ga_len
- 2).si_attr
;
1935 cur_si
->si_trans_id
= CUR_STATE(
1936 current_state
.ga_len
- 2).si_trans_id
;
1940 cur_si
->si_attr
= syn_id2attr(syn_id
);
1941 cur_si
->si_cont_list
= NULL
;
1942 cur_si
->si_next_list
= next_list
;
1946 vim_free(next_list
);
1952 * 3. Check for patterns (only if no keyword found).
1954 if (syn_id
== 0 && syn_buf
->b_syn_patterns
.ga_len
)
1957 * If we didn't check for a match yet, or we are past it, check
1958 * for any match with a pattern.
1960 if (next_match_idx
< 0 || next_match_col
< (int)current_col
)
1963 * Check all relevant patterns for a match at this
1964 * position. This is complicated, because matching with a
1965 * pattern takes quite a bit of time, thus we want to
1966 * avoid doing it when it's not needed.
1968 next_match_idx
= 0; /* no match in this line yet */
1969 next_match_col
= MAXCOL
;
1970 for (idx
= syn_buf
->b_syn_patterns
.ga_len
; --idx
>= 0; )
1972 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
1973 if ( spp
->sp_syncing
== syncing
1974 && (displaying
|| !(spp
->sp_flags
& HL_DISPLAY
))
1975 && (spp
->sp_type
== SPTYPE_MATCH
1976 || spp
->sp_type
== SPTYPE_START
)
1977 && (current_next_list
!= NULL
1978 ? in_id_list(NULL
, current_next_list
,
1981 ? !(spp
->sp_flags
& HL_CONTAINED
)
1982 : in_id_list(cur_si
,
1983 cur_si
->si_cont_list
, &spp
->sp_syn
,
1984 spp
->sp_flags
& HL_CONTAINED
))))
1986 /* If we already tried matching in this line, and
1987 * there isn't a match before next_match_col, skip
1989 if (spp
->sp_line_id
== current_line_id
1990 && spp
->sp_startcol
>= next_match_col
)
1992 spp
->sp_line_id
= current_line_id
;
1994 lc_col
= current_col
- spp
->sp_offsets
[SPO_LC_OFF
];
1998 regmatch
.rmm_ic
= spp
->sp_ic
;
1999 regmatch
.regprog
= spp
->sp_prog
;
2000 if (!syn_regexec(®match
, current_lnum
,
2003 /* no match in this line, try another one */
2004 spp
->sp_startcol
= MAXCOL
;
2009 * Compute the first column of the match.
2011 syn_add_start_off(&pos
, ®match
,
2012 spp
, SPO_MS_OFF
, -1);
2013 if (pos
.lnum
> current_lnum
)
2015 /* must have used end of match in a next line,
2016 * we can't handle that */
2017 spp
->sp_startcol
= MAXCOL
;
2022 /* remember the next column where this pattern
2023 * matches in the current line */
2024 spp
->sp_startcol
= startcol
;
2027 * If a previously found match starts at a lower
2028 * column number, don't use this one.
2030 if (startcol
>= next_match_col
)
2034 * If we matched this pattern at this position
2035 * before, skip it. Must retry in the next
2036 * column, because it may match from there.
2038 if (did_match_already(idx
, &zero_width_next_ga
))
2040 try_next_column
= TRUE
;
2044 endpos
.lnum
= regmatch
.endpos
[0].lnum
;
2045 endpos
.col
= regmatch
.endpos
[0].col
;
2047 /* Compute the highlight start. */
2048 syn_add_start_off(&hl_startpos
, ®match
,
2049 spp
, SPO_HS_OFF
, -1);
2051 /* Compute the region start. */
2052 /* Default is to use the end of the match. */
2053 syn_add_end_off(&eos_pos
, ®match
,
2054 spp
, SPO_RS_OFF
, 0);
2057 * Grab the external submatches before they get
2058 * overwritten. Reference count doesn't change.
2060 unref_extmatch(cur_extmatch
);
2061 cur_extmatch
= re_extmatch_out
;
2062 re_extmatch_out
= NULL
;
2065 eoe_pos
.lnum
= 0; /* avoid warning */
2071 * For a "oneline" the end must be found in the
2072 * same line too. Search for it after the end of
2073 * the match with the start pattern. Set the
2074 * resulting end positions at the same time.
2076 if (spp
->sp_type
== SPTYPE_START
2077 && (spp
->sp_flags
& HL_ONELINE
))
2082 find_endpos(idx
, &startpos
, &endpos
, &hl_endpos
,
2083 &flags
, &eoe_pos
, &end_idx
, cur_extmatch
);
2084 if (endpos
.lnum
== 0)
2085 continue; /* not found */
2089 * For a "match" the size must be > 0 after the
2090 * end offset needs has been added. Except when
2093 else if (spp
->sp_type
== SPTYPE_MATCH
)
2095 syn_add_end_off(&hl_endpos
, ®match
, spp
,
2097 syn_add_end_off(&endpos
, ®match
, spp
,
2099 if (endpos
.lnum
== current_lnum
2100 && (int)endpos
.col
+ syncing
< startcol
)
2103 * If an empty string is matched, may need
2104 * to try matching again at next column.
2106 if (regmatch
.startpos
[0].col
2107 == regmatch
.endpos
[0].col
)
2108 try_next_column
= TRUE
;
2114 * keep the best match so far in next_match_*
2116 /* Highlighting must start after startpos and end
2118 if (hl_startpos
.lnum
== current_lnum
2119 && (int)hl_startpos
.col
< startcol
)
2120 hl_startpos
.col
= startcol
;
2121 limit_pos_zero(&hl_endpos
, &endpos
);
2123 next_match_idx
= idx
;
2124 next_match_col
= startcol
;
2125 next_match_m_endpos
= endpos
;
2126 next_match_h_endpos
= hl_endpos
;
2127 next_match_h_startpos
= hl_startpos
;
2128 next_match_flags
= flags
;
2129 next_match_eos_pos
= eos_pos
;
2130 next_match_eoe_pos
= eoe_pos
;
2131 next_match_end_idx
= end_idx
;
2132 unref_extmatch(next_match_extmatch
);
2133 next_match_extmatch
= cur_extmatch
;
2134 cur_extmatch
= NULL
;
2140 * If we found a match at the current column, use it.
2142 if (next_match_idx
>= 0 && next_match_col
== (int)current_col
)
2146 /* When a zero-width item matched which has a nextgroup,
2147 * don't push the item but set nextgroup. */
2148 lspp
= &(SYN_ITEMS(syn_buf
)[next_match_idx
]);
2149 if (next_match_m_endpos
.lnum
== current_lnum
2150 && next_match_m_endpos
.col
== current_col
2151 && lspp
->sp_next_list
!= NULL
)
2153 current_next_list
= lspp
->sp_next_list
;
2154 current_next_flags
= lspp
->sp_flags
;
2155 keep_next_list
= TRUE
;
2156 zero_width_next_list
= TRUE
;
2158 /* Add the index to a list, so that we can check
2159 * later that we don't match it again (and cause an
2161 if (ga_grow(&zero_width_next_ga
, 1) == OK
)
2163 ((int *)(zero_width_next_ga
.ga_data
))
2164 [zero_width_next_ga
.ga_len
++] = next_match_idx
;
2166 next_match_idx
= -1;
2169 cur_si
= push_next_match(cur_si
);
2176 * Handle searching for nextgroup match.
2178 if (current_next_list
!= NULL
&& !keep_next_list
)
2181 * If a nextgroup was not found, continue looking for one if:
2182 * - this is an empty line and the "skipempty" option was given
2183 * - we are on white space and the "skipwhite" option was given
2187 line
= syn_getcurline();
2188 if (((current_next_flags
& HL_SKIPWHITE
)
2189 && vim_iswhite(line
[current_col
]))
2190 || ((current_next_flags
& HL_SKIPEMPTY
)
2196 * If a nextgroup was found: Use it, and continue looking for
2197 * contained matches.
2198 * If a nextgroup was not found: Continue looking for a normal
2200 * When did set current_next_list for a zero-width item and no
2201 * match was found don't loop (would get stuck).
2203 current_next_list
= NULL
;
2204 next_match_idx
= -1;
2205 if (!zero_width_next_list
)
2209 } while (found_match
);
2212 * Use attributes from the current state, if within its highlighting.
2213 * If not, use attributes from the current-but-one state, etc.
2218 current_trans_id
= 0;
2223 int current_trans_id
= 0;
2225 for (idx
= current_state
.ga_len
- 1; idx
>= 0; --idx
)
2227 sip
= &CUR_STATE(idx
);
2228 if ((current_lnum
> sip
->si_h_startpos
.lnum
2229 || (current_lnum
== sip
->si_h_startpos
.lnum
2230 && current_col
>= sip
->si_h_startpos
.col
))
2231 && (sip
->si_h_endpos
.lnum
== 0
2232 || current_lnum
< sip
->si_h_endpos
.lnum
2233 || (current_lnum
== sip
->si_h_endpos
.lnum
2234 && current_col
< sip
->si_h_endpos
.col
)))
2236 current_attr
= sip
->si_attr
;
2238 current_id
= sip
->si_id
;
2240 current_trans_id
= sip
->si_trans_id
;
2245 if (can_spell
!= NULL
)
2250 * set "can_spell" to TRUE if spell checking is supposed to be
2251 * done in the current item.
2253 if (syn_buf
->b_spell_cluster_id
== 0)
2255 /* There is no @Spell cluster: Do spelling for items without
2256 * @NoSpell cluster. */
2257 if (syn_buf
->b_nospell_cluster_id
== 0 || current_trans_id
== 0)
2258 *can_spell
= (syn_buf
->b_syn_spell
!= SYNSPL_NOTOP
);
2262 sps
.id
= syn_buf
->b_nospell_cluster_id
;
2263 sps
.cont_in_list
= NULL
;
2264 *can_spell
= !in_id_list(sip
, sip
->si_cont_list
, &sps
, 0);
2269 /* The @Spell cluster is defined: Do spelling in items with
2270 * the @Spell cluster. But not when @NoSpell is also there.
2271 * At the toplevel only spell check when ":syn spell toplevel"
2273 if (current_trans_id
== 0)
2274 *can_spell
= (syn_buf
->b_syn_spell
== SYNSPL_TOP
);
2278 sps
.id
= syn_buf
->b_spell_cluster_id
;
2279 sps
.cont_in_list
= NULL
;
2280 *can_spell
= in_id_list(sip
, sip
->si_cont_list
, &sps
, 0);
2282 if (syn_buf
->b_nospell_cluster_id
!= 0)
2284 sps
.id
= syn_buf
->b_nospell_cluster_id
;
2285 if (in_id_list(sip
, sip
->si_cont_list
, &sps
, 0))
2294 * Check for end of current state (and the states before it) at the
2295 * next column. Don't do this for syncing, because we would miss a
2296 * single character match.
2297 * First check if the current state ends at the current column. It
2298 * may be for an empty match and a containing item might end in the
2304 if (current_state
.ga_len
> 0
2305 && syn_getcurline()[current_col
] != NUL
)
2313 else if (can_spell
!= NULL
)
2314 /* Default: Only do spelling when there is no @Spell cluster or when
2315 * ":syn spell toplevel" was used. */
2316 *can_spell
= syn_buf
->b_syn_spell
== SYNSPL_DEFAULT
2317 ? (syn_buf
->b_spell_cluster_id
== 0)
2318 : (syn_buf
->b_syn_spell
== SYNSPL_TOP
);
2320 /* nextgroup ends at end of line, unless "skipnl" or "skipemtpy" present */
2321 if (current_next_list
!= NULL
2322 && syn_getcurline()[current_col
+ 1] == NUL
2323 && !(current_next_flags
& (HL_SKIPNL
| HL_SKIPEMPTY
)))
2324 current_next_list
= NULL
;
2326 if (zero_width_next_ga
.ga_len
> 0)
2327 ga_clear(&zero_width_next_ga
);
2329 /* No longer need external matches. But keep next_match_extmatch. */
2330 unref_extmatch(re_extmatch_out
);
2331 re_extmatch_out
= NULL
;
2332 unref_extmatch(cur_extmatch
);
2334 return current_attr
;
2339 * Check if we already matched pattern "idx" at the current column.
2342 did_match_already(idx
, gap
)
2348 for (i
= current_state
.ga_len
; --i
>= 0; )
2349 if (CUR_STATE(i
).si_m_startcol
== (int)current_col
2350 && CUR_STATE(i
).si_m_lnum
== (int)current_lnum
2351 && CUR_STATE(i
).si_idx
== idx
)
2354 /* Zero-width matches with a nextgroup argument are not put on the syntax
2355 * stack, and can only be matched once anyway. */
2356 for (i
= gap
->ga_len
; --i
>= 0; )
2357 if (((int *)(gap
->ga_data
))[i
] == idx
)
2364 * Push the next match onto the stack.
2366 static stateitem_T
*
2367 push_next_match(cur_si
)
2368 stateitem_T
*cur_si
;
2372 spp
= &(SYN_ITEMS(syn_buf
)[next_match_idx
]);
2375 * Push the item in current_state stack;
2377 if (push_current_state(next_match_idx
) == OK
)
2380 * If it's a start-skip-end type that crosses lines, figure out how
2381 * much it continues in this line. Otherwise just fill in the length.
2383 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2384 cur_si
->si_h_startpos
= next_match_h_startpos
;
2385 cur_si
->si_m_startcol
= current_col
;
2386 cur_si
->si_m_lnum
= current_lnum
;
2387 cur_si
->si_flags
= spp
->sp_flags
;
2388 cur_si
->si_next_list
= spp
->sp_next_list
;
2389 cur_si
->si_extmatch
= ref_extmatch(next_match_extmatch
);
2390 if (spp
->sp_type
== SPTYPE_START
&& !(spp
->sp_flags
& HL_ONELINE
))
2392 /* Try to find the end pattern in the current line */
2393 update_si_end(cur_si
, (int)(next_match_m_endpos
.col
), TRUE
);
2398 cur_si
->si_m_endpos
= next_match_m_endpos
;
2399 cur_si
->si_h_endpos
= next_match_h_endpos
;
2400 cur_si
->si_ends
= TRUE
;
2401 cur_si
->si_flags
|= next_match_flags
;
2402 cur_si
->si_eoe_pos
= next_match_eoe_pos
;
2403 cur_si
->si_end_idx
= next_match_end_idx
;
2405 if (keepend_level
< 0 && (cur_si
->si_flags
& HL_KEEPEND
))
2406 keepend_level
= current_state
.ga_len
- 1;
2408 update_si_attr(current_state
.ga_len
- 1);
2411 * If the start pattern has another highlight group, push another item
2412 * on the stack for the start pattern.
2414 if ( spp
->sp_type
== SPTYPE_START
2415 && spp
->sp_syn_match_id
!= 0
2416 && push_current_state(next_match_idx
) == OK
)
2418 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2419 cur_si
->si_h_startpos
= next_match_h_startpos
;
2420 cur_si
->si_m_startcol
= current_col
;
2421 cur_si
->si_m_lnum
= current_lnum
;
2422 cur_si
->si_m_endpos
= next_match_eos_pos
;
2423 cur_si
->si_h_endpos
= next_match_eos_pos
;
2424 cur_si
->si_ends
= TRUE
;
2425 cur_si
->si_end_idx
= 0;
2426 cur_si
->si_flags
= HL_MATCH
;
2427 cur_si
->si_next_list
= NULL
;
2429 update_si_attr(current_state
.ga_len
- 1);
2433 next_match_idx
= -1; /* try other match next time */
2439 * Check for end of current state (and the states before it).
2444 stateitem_T
*cur_si
;
2445 int had_extend
= FALSE
;
2447 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2451 && (cur_si
->si_m_endpos
.lnum
< current_lnum
2452 || (cur_si
->si_m_endpos
.lnum
== current_lnum
2453 && cur_si
->si_m_endpos
.col
<= current_col
)))
2456 * If there is an end pattern group ID, highlight the end pattern
2457 * now. No need to pop the current item from the stack.
2458 * Only do this if the end pattern continues beyond the current
2461 if (cur_si
->si_end_idx
2462 && (cur_si
->si_eoe_pos
.lnum
> current_lnum
2463 || (cur_si
->si_eoe_pos
.lnum
== current_lnum
2464 && cur_si
->si_eoe_pos
.col
> current_col
)))
2466 cur_si
->si_idx
= cur_si
->si_end_idx
;
2467 cur_si
->si_end_idx
= 0;
2468 cur_si
->si_m_endpos
= cur_si
->si_eoe_pos
;
2469 cur_si
->si_h_endpos
= cur_si
->si_eoe_pos
;
2470 cur_si
->si_flags
|= HL_MATCH
;
2471 update_si_attr(current_state
.ga_len
- 1);
2473 /* what matches next may be different now, clear it */
2475 next_match_col
= MAXCOL
;
2480 /* handle next_list, unless at end of line and no "skipnl" or
2482 current_next_list
= cur_si
->si_next_list
;
2483 current_next_flags
= cur_si
->si_flags
;
2484 if (!(current_next_flags
& (HL_SKIPNL
| HL_SKIPEMPTY
))
2485 && syn_getcurline()[current_col
] == NUL
)
2486 current_next_list
= NULL
;
2488 /* When the ended item has "extend", another item with
2489 * "keepend" now needs to check for its end. */
2490 if (cur_si
->si_flags
& HL_EXTEND
)
2493 pop_current_state();
2495 if (current_state
.ga_len
== 0)
2500 syn_update_ends(FALSE
);
2501 if (current_state
.ga_len
== 0)
2505 cur_si
= &CUR_STATE(current_state
.ga_len
- 1);
2508 * Only for a region the search for the end continues after
2509 * the end of the contained item. If the contained match
2510 * included the end-of-line, break here, the region continues.
2511 * Don't do this when:
2512 * - "keepend" is used for the contained item
2513 * - not at the end of the line (could be end="x$"me=e-1).
2514 * - "excludenl" is used (HL_HAS_EOL won't be set)
2516 if (cur_si
->si_idx
>= 0
2517 && SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_type
2519 && !(cur_si
->si_flags
& (HL_MATCH
| HL_KEEPEND
)))
2521 update_si_end(cur_si
, (int)current_col
, TRUE
);
2523 if ((current_next_flags
& HL_HAS_EOL
)
2524 && keepend_level
< 0
2525 && syn_getcurline()[current_col
] == NUL
)
2536 * Update an entry in the current_state stack for a match or region. This
2537 * fills in si_attr, si_next_list and si_cont_list.
2543 stateitem_T
*sip
= &CUR_STATE(idx
);
2546 /* This should not happen... */
2547 if (sip
->si_idx
< 0)
2550 spp
= &(SYN_ITEMS(syn_buf
)[sip
->si_idx
]);
2551 if (sip
->si_flags
& HL_MATCH
)
2552 sip
->si_id
= spp
->sp_syn_match_id
;
2554 sip
->si_id
= spp
->sp_syn
.id
;
2555 sip
->si_attr
= syn_id2attr(sip
->si_id
);
2556 sip
->si_trans_id
= sip
->si_id
;
2557 if (sip
->si_flags
& HL_MATCH
)
2558 sip
->si_cont_list
= NULL
;
2560 sip
->si_cont_list
= spp
->sp_cont_list
;
2563 * For transparent items, take attr from outer item.
2564 * Also take cont_list, if there is none.
2565 * Don't do this for the matchgroup of a start or end pattern.
2567 if ((spp
->sp_flags
& HL_TRANSP
) && !(sip
->si_flags
& HL_MATCH
))
2572 sip
->si_trans_id
= 0;
2573 if (sip
->si_cont_list
== NULL
)
2574 sip
->si_cont_list
= ID_LIST_ALL
;
2578 sip
->si_attr
= CUR_STATE(idx
- 1).si_attr
;
2579 sip
->si_trans_id
= CUR_STATE(idx
- 1).si_trans_id
;
2580 sip
->si_h_startpos
= CUR_STATE(idx
- 1).si_h_startpos
;
2581 sip
->si_h_endpos
= CUR_STATE(idx
- 1).si_h_endpos
;
2582 if (sip
->si_cont_list
== NULL
)
2584 sip
->si_flags
|= HL_TRANS_CONT
;
2585 sip
->si_cont_list
= CUR_STATE(idx
- 1).si_cont_list
;
2592 * Check the current stack for patterns with "keepend" flag.
2593 * Propagate the match-end to contained items, until a "skipend" item is found.
2604 * This check can consume a lot of time; only do it from the level where
2605 * there really is a keepend.
2607 if (keepend_level
< 0)
2611 * Find the last index of an "extend" item. "keepend" items before that
2612 * won't do anything. If there is no "extend" item "i" will be
2613 * "keepend_level" and all "keepend" items will work normally.
2615 for (i
= current_state
.ga_len
- 1; i
> keepend_level
; --i
)
2616 if (CUR_STATE(i
).si_flags
& HL_EXTEND
)
2621 for ( ; i
< current_state
.ga_len
; ++i
)
2623 sip
= &CUR_STATE(i
);
2624 if (maxpos
.lnum
!= 0)
2626 limit_pos_zero(&sip
->si_m_endpos
, &maxpos
);
2627 limit_pos_zero(&sip
->si_h_endpos
, &maxpos_h
);
2628 limit_pos_zero(&sip
->si_eoe_pos
, &maxpos
);
2629 sip
->si_ends
= TRUE
;
2631 if (sip
->si_ends
&& (sip
->si_flags
& HL_KEEPEND
))
2633 if (maxpos
.lnum
== 0
2634 || maxpos
.lnum
> sip
->si_m_endpos
.lnum
2635 || (maxpos
.lnum
== sip
->si_m_endpos
.lnum
2636 && maxpos
.col
> sip
->si_m_endpos
.col
))
2637 maxpos
= sip
->si_m_endpos
;
2638 if (maxpos_h
.lnum
== 0
2639 || maxpos_h
.lnum
> sip
->si_h_endpos
.lnum
2640 || (maxpos_h
.lnum
== sip
->si_h_endpos
.lnum
2641 && maxpos_h
.col
> sip
->si_h_endpos
.col
))
2642 maxpos_h
= sip
->si_h_endpos
;
2648 * Update an entry in the current_state stack for a start-skip-end pattern.
2649 * This finds the end of the current item, if it's in the current line.
2651 * Return the flags for the matched END.
2654 update_si_end(sip
, startcol
, force
)
2656 int startcol
; /* where to start searching for the end */
2657 int force
; /* when TRUE overrule a previous end */
2665 /* return quickly for a keyword */
2666 if (sip
->si_idx
< 0)
2669 /* Don't update when it's already done. Can be a match of an end pattern
2670 * that started in a previous line. Watch out: can also be a "keepend"
2671 * from a containing item. */
2672 if (!force
&& sip
->si_m_endpos
.lnum
>= current_lnum
)
2676 * We need to find the end of the region. It may continue in the next
2680 startpos
.lnum
= current_lnum
;
2681 startpos
.col
= startcol
;
2682 find_endpos(sip
->si_idx
, &startpos
, &endpos
, &hl_endpos
,
2683 &(sip
->si_flags
), &end_endpos
, &end_idx
, sip
->si_extmatch
);
2685 if (endpos
.lnum
== 0)
2687 /* No end pattern matched. */
2688 if (SYN_ITEMS(syn_buf
)[sip
->si_idx
].sp_flags
& HL_ONELINE
)
2690 /* a "oneline" never continues in the next line */
2691 sip
->si_ends
= TRUE
;
2692 sip
->si_m_endpos
.lnum
= current_lnum
;
2693 sip
->si_m_endpos
.col
= (colnr_T
)STRLEN(syn_getcurline());
2697 /* continues in the next line */
2698 sip
->si_ends
= FALSE
;
2699 sip
->si_m_endpos
.lnum
= 0;
2701 sip
->si_h_endpos
= sip
->si_m_endpos
;
2705 /* match within this line */
2706 sip
->si_m_endpos
= endpos
;
2707 sip
->si_h_endpos
= hl_endpos
;
2708 sip
->si_eoe_pos
= end_endpos
;
2709 sip
->si_ends
= TRUE
;
2710 sip
->si_end_idx
= end_idx
;
2715 * Add a new state to the current state stack.
2716 * It is cleared and the index set to "idx".
2717 * Return FAIL if it's not possible (out of memory).
2720 push_current_state(idx
)
2723 if (ga_grow(¤t_state
, 1) == FAIL
)
2725 vim_memset(&CUR_STATE(current_state
.ga_len
), 0, sizeof(stateitem_T
));
2726 CUR_STATE(current_state
.ga_len
).si_idx
= idx
;
2727 ++current_state
.ga_len
;
2732 * Remove a state from the current_state stack.
2737 if (current_state
.ga_len
)
2739 unref_extmatch(CUR_STATE(current_state
.ga_len
- 1).si_extmatch
);
2740 --current_state
.ga_len
;
2742 /* after the end of a pattern, try matching a keyword or pattern */
2743 next_match_idx
= -1;
2745 /* if first state with "keepend" is popped, reset keepend_level */
2746 if (keepend_level
>= current_state
.ga_len
)
2751 * Find the end of a start/skip/end syntax region after "startpos".
2752 * Only checks one line.
2753 * Also handles a match item that continued from a previous line.
2754 * If not found, the syntax item continues in the next line. m_endpos->lnum
2756 * If found, the end of the region and the end of the highlighting is
2760 find_endpos(idx
, startpos
, m_endpos
, hl_endpos
, flagsp
, end_endpos
,
2762 int idx
; /* index of the pattern */
2763 lpos_T
*startpos
; /* where to start looking for an END match */
2764 lpos_T
*m_endpos
; /* return: end of match */
2765 lpos_T
*hl_endpos
; /* return: end of highlighting */
2766 long *flagsp
; /* return: flags of matching END */
2767 lpos_T
*end_endpos
; /* return: end of end pattern match */
2768 int *end_idx
; /* return: group ID for end pat. match, or 0 */
2769 reg_extmatch_T
*start_ext
; /* submatches from the start pattern */
2772 synpat_T
*spp
, *spp_skip
;
2775 regmmatch_T regmatch
;
2776 regmmatch_T best_regmatch
; /* startpos/endpos of best match */
2779 int had_match
= FALSE
;
2781 /* just in case we are invoked for a keyword */
2786 * Check for being called with a START pattern.
2787 * Can happen with a match that continues to the next line, because it
2788 * contained a region.
2790 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
2791 if (spp
->sp_type
!= SPTYPE_START
)
2793 *hl_endpos
= *startpos
;
2798 * Find the SKIP or first END pattern after the last START pattern.
2802 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
2803 if (spp
->sp_type
!= SPTYPE_START
)
2809 * Lookup the SKIP pattern (if present)
2811 if (spp
->sp_type
== SPTYPE_SKIP
)
2819 /* Setup external matches for syn_regexec(). */
2820 unref_extmatch(re_extmatch_in
);
2821 re_extmatch_in
= ref_extmatch(start_ext
);
2823 matchcol
= startpos
->col
; /* start looking for a match at sstart */
2824 start_idx
= idx
; /* remember the first END pattern. */
2825 best_regmatch
.startpos
[0].col
= 0; /* avoid compiler warning */
2829 * Find end pattern that matches first after "matchcol".
2832 for (idx
= start_idx
; idx
< syn_buf
->b_syn_patterns
.ga_len
; ++idx
)
2834 int lc_col
= matchcol
;
2836 spp
= &(SYN_ITEMS(syn_buf
)[idx
]);
2837 if (spp
->sp_type
!= SPTYPE_END
) /* past last END pattern */
2839 lc_col
-= spp
->sp_offsets
[SPO_LC_OFF
];
2843 regmatch
.rmm_ic
= spp
->sp_ic
;
2844 regmatch
.regprog
= spp
->sp_prog
;
2845 if (syn_regexec(®match
, startpos
->lnum
, lc_col
))
2847 if (best_idx
== -1 || regmatch
.startpos
[0].col
2848 < best_regmatch
.startpos
[0].col
)
2851 best_regmatch
.startpos
[0] = regmatch
.startpos
[0];
2852 best_regmatch
.endpos
[0] = regmatch
.endpos
[0];
2858 * If all end patterns have been tried, and there is no match, the
2859 * item continues until end-of-line.
2865 * If the skip pattern matches before the end pattern,
2866 * continue searching after the skip pattern.
2868 if (spp_skip
!= NULL
)
2870 int lc_col
= matchcol
- spp_skip
->sp_offsets
[SPO_LC_OFF
];
2874 regmatch
.rmm_ic
= spp_skip
->sp_ic
;
2875 regmatch
.regprog
= spp_skip
->sp_prog
;
2876 if (syn_regexec(®match
, startpos
->lnum
, lc_col
)
2877 && regmatch
.startpos
[0].col
2878 <= best_regmatch
.startpos
[0].col
)
2880 /* Add offset to skip pattern match */
2881 syn_add_end_off(&pos
, ®match
, spp_skip
, SPO_ME_OFF
, 1);
2883 /* If the skip pattern goes on to the next line, there is no
2884 * match with an end pattern in this line. */
2885 if (pos
.lnum
> startpos
->lnum
)
2888 line
= ml_get_buf(syn_buf
, startpos
->lnum
, FALSE
);
2890 /* take care of an empty match or negative offset */
2891 if (pos
.col
<= matchcol
)
2893 else if (pos
.col
<= regmatch
.endpos
[0].col
)
2896 /* Be careful not to jump over the NUL at the end-of-line */
2897 for (matchcol
= regmatch
.endpos
[0].col
;
2898 line
[matchcol
] != NUL
&& matchcol
< pos
.col
;
2902 /* if the skip pattern includes end-of-line, break here */
2903 if (line
[matchcol
] == NUL
)
2906 continue; /* start with first end pattern again */
2911 * Match from start pattern to end pattern.
2912 * Correct for match and highlight offset of end pattern.
2914 spp
= &(SYN_ITEMS(syn_buf
)[best_idx
]);
2915 syn_add_end_off(m_endpos
, &best_regmatch
, spp
, SPO_ME_OFF
, 1);
2916 /* can't end before the start */
2917 if (m_endpos
->lnum
== startpos
->lnum
&& m_endpos
->col
< startpos
->col
)
2918 m_endpos
->col
= startpos
->col
;
2920 syn_add_end_off(end_endpos
, &best_regmatch
, spp
, SPO_HE_OFF
, 1);
2921 /* can't end before the start */
2922 if (end_endpos
->lnum
== startpos
->lnum
2923 && end_endpos
->col
< startpos
->col
)
2924 end_endpos
->col
= startpos
->col
;
2925 /* can't end after the match */
2926 limit_pos(end_endpos
, m_endpos
);
2929 * If the end group is highlighted differently, adjust the pointers.
2931 if (spp
->sp_syn_match_id
!= spp
->sp_syn
.id
&& spp
->sp_syn_match_id
!= 0)
2933 *end_idx
= best_idx
;
2934 if (spp
->sp_off_flags
& (1 << (SPO_RE_OFF
+ SPO_COUNT
)))
2936 hl_endpos
->lnum
= best_regmatch
.endpos
[0].lnum
;
2937 hl_endpos
->col
= best_regmatch
.endpos
[0].col
;
2941 hl_endpos
->lnum
= best_regmatch
.startpos
[0].lnum
;
2942 hl_endpos
->col
= best_regmatch
.startpos
[0].col
;
2944 hl_endpos
->col
+= spp
->sp_offsets
[SPO_RE_OFF
];
2946 /* can't end before the start */
2947 if (hl_endpos
->lnum
== startpos
->lnum
2948 && hl_endpos
->col
< startpos
->col
)
2949 hl_endpos
->col
= startpos
->col
;
2950 limit_pos(hl_endpos
, m_endpos
);
2952 /* now the match ends where the highlighting ends, it is turned
2953 * into the matchgroup for the end */
2954 *m_endpos
= *hl_endpos
;
2959 *hl_endpos
= *end_endpos
;
2962 *flagsp
= spp
->sp_flags
;
2968 /* no match for an END pattern in this line */
2972 /* Remove external matches. */
2973 unref_extmatch(re_extmatch_in
);
2974 re_extmatch_in
= NULL
;
2978 * Limit "pos" not to be after "limit".
2981 limit_pos(pos
, limit
)
2985 if (pos
->lnum
> limit
->lnum
)
2987 else if (pos
->lnum
== limit
->lnum
&& pos
->col
> limit
->col
)
2988 pos
->col
= limit
->col
;
2992 * Limit "pos" not to be after "limit", unless pos->lnum is zero.
2995 limit_pos_zero(pos
, limit
)
3002 limit_pos(pos
, limit
);
3006 * Add offset to matched text for end of match or highlight.
3009 syn_add_end_off(result
, regmatch
, spp
, idx
, extra
)
3010 lpos_T
*result
; /* returned position */
3011 regmmatch_T
*regmatch
; /* start/end of match */
3012 synpat_T
*spp
; /* matched pattern */
3013 int idx
; /* index of offset */
3014 int extra
; /* extra chars for offset to start */
3019 if (spp
->sp_off_flags
& (1 << idx
))
3021 result
->lnum
= regmatch
->startpos
[0].lnum
;
3022 col
= regmatch
->startpos
[0].col
+ extra
;
3026 result
->lnum
= regmatch
->endpos
[0].lnum
;
3027 col
= regmatch
->endpos
[0].col
;
3029 col
+= spp
->sp_offsets
[idx
];
3034 /* Don't go past the end of the line. Matters for "rs=e+2" when there
3035 * is a matchgroup. Watch out for match with last NL in the buffer. */
3036 if (result
->lnum
> syn_buf
->b_ml
.ml_line_count
)
3039 len
= (int)STRLEN(ml_get_buf(syn_buf
, result
->lnum
, FALSE
));
3048 * Add offset to matched text for start of match or highlight.
3049 * Avoid resulting column to become negative.
3052 syn_add_start_off(result
, regmatch
, spp
, idx
, extra
)
3053 lpos_T
*result
; /* returned position */
3054 regmmatch_T
*regmatch
; /* start/end of match */
3057 int extra
; /* extra chars for offset to end */
3061 if (spp
->sp_off_flags
& (1 << (idx
+ SPO_COUNT
)))
3063 result
->lnum
= regmatch
->endpos
[0].lnum
;
3064 col
= regmatch
->endpos
[0].col
+ extra
;
3068 result
->lnum
= regmatch
->startpos
[0].lnum
;
3069 col
= regmatch
->startpos
[0].col
;
3071 col
+= spp
->sp_offsets
[idx
];
3079 * Get current line in syntax buffer.
3084 return ml_get_buf(syn_buf
, current_lnum
, FALSE
);
3088 * Call vim_regexec() to find a match with "rmp" in "syn_buf".
3089 * Returns TRUE when there is a match.
3092 syn_regexec(rmp
, lnum
, col
)
3097 rmp
->rmm_maxcol
= syn_buf
->b_p_smc
;
3098 if (vim_regexec_multi(rmp
, syn_win
, syn_buf
, lnum
, col
) > 0)
3100 rmp
->startpos
[0].lnum
+= lnum
;
3101 rmp
->endpos
[0].lnum
+= lnum
;
3108 * Check one position in a line for a matching keyword.
3109 * The caller must check if a keyword can start at startcol.
3110 * Return it's ID if found, 0 otherwise.
3113 check_keyword_id(line
, startcol
, endcolp
, flagsp
, next_listp
, cur_si
)
3115 int startcol
; /* position in line to check for keyword */
3116 int *endcolp
; /* return: character after found keyword */
3117 long *flagsp
; /* return: flags of matching keyword */
3118 short **next_listp
; /* return: next_list of matching keyword */
3119 stateitem_T
*cur_si
; /* item at the top of the stack */
3125 char_u keyword
[MAXKEYWLEN
+ 1]; /* assume max. keyword len is 80 */
3129 /* Find first character after the keyword. First character was already
3131 kwp
= line
+ startcol
;
3137 kwlen
+= (*mb_ptr2len
)(kwp
+ kwlen
);
3142 while (vim_iswordc_buf(kwp
+ kwlen
, syn_buf
));
3144 if (kwlen
> MAXKEYWLEN
)
3148 * Must make a copy of the keyword, so we can add a NUL and make it
3151 vim_strncpy(keyword
, kwp
, kwlen
);
3158 for (round
= 1; round
<= 2; ++round
)
3160 ht
= round
== 1 ? &syn_buf
->b_keywtab
: &syn_buf
->b_keywtab_ic
;
3161 if (ht
->ht_used
== 0)
3163 if (round
== 2) /* ignore case */
3164 (void)str_foldcase(kwp
, kwlen
, keyword
, MAXKEYWLEN
+ 1);
3167 * Find keywords that match. There can be several with different
3169 * When current_next_list is non-zero accept only that group, otherwise:
3170 * Accept a not-contained keyword at toplevel.
3171 * Accept a keyword at other levels only if it is in the contains list.
3173 hi
= hash_find(ht
, keyword
);
3174 if (!HASHITEM_EMPTY(hi
))
3175 for (kp
= HI2KE(hi
); kp
!= NULL
; kp
= kp
->ke_next
)
3177 if (current_next_list
!= 0
3178 ? in_id_list(NULL
, current_next_list
, &kp
->k_syn
, 0)
3180 ? !(kp
->flags
& HL_CONTAINED
)
3181 : in_id_list(cur_si
, cur_si
->si_cont_list
,
3182 &kp
->k_syn
, kp
->flags
& HL_CONTAINED
)))
3184 *endcolp
= startcol
+ kwlen
;
3185 *flagsp
= kp
->flags
;
3186 *next_listp
= kp
->next_list
;
3187 return kp
->k_syn
.id
;
3195 * Handle ":syntax case" command.
3199 syn_cmd_case(eap
, syncing
)
3201 int syncing
; /* not used */
3203 char_u
*arg
= eap
->arg
;
3206 eap
->nextcmd
= find_nextcmd(arg
);
3210 next
= skiptowhite(arg
);
3211 if (STRNICMP(arg
, "match", 5) == 0 && next
- arg
== 5)
3212 curbuf
->b_syn_ic
= FALSE
;
3213 else if (STRNICMP(arg
, "ignore", 6) == 0 && next
- arg
== 6)
3214 curbuf
->b_syn_ic
= TRUE
;
3216 EMSG2(_("E390: Illegal argument: %s"), arg
);
3220 * Handle ":syntax spell" command.
3224 syn_cmd_spell(eap
, syncing
)
3226 int syncing
; /* not used */
3228 char_u
*arg
= eap
->arg
;
3231 eap
->nextcmd
= find_nextcmd(arg
);
3235 next
= skiptowhite(arg
);
3236 if (STRNICMP(arg
, "toplevel", 8) == 0 && next
- arg
== 8)
3237 curbuf
->b_syn_spell
= SYNSPL_TOP
;
3238 else if (STRNICMP(arg
, "notoplevel", 10) == 0 && next
- arg
== 10)
3239 curbuf
->b_syn_spell
= SYNSPL_NOTOP
;
3240 else if (STRNICMP(arg
, "default", 7) == 0 && next
- arg
== 7)
3241 curbuf
->b_syn_spell
= SYNSPL_DEFAULT
;
3243 EMSG2(_("E390: Illegal argument: %s"), arg
);
3247 * Clear all syntax info for one buffer.
3255 buf
->b_syn_error
= FALSE
; /* clear previous error */
3256 buf
->b_syn_ic
= FALSE
; /* Use case, by default */
3257 buf
->b_syn_spell
= SYNSPL_DEFAULT
; /* default spell checking */
3258 buf
->b_syn_containedin
= FALSE
;
3260 /* free the keywords */
3261 clear_keywtab(&buf
->b_keywtab
);
3262 clear_keywtab(&buf
->b_keywtab_ic
);
3264 /* free the syntax patterns */
3265 for (i
= buf
->b_syn_patterns
.ga_len
; --i
>= 0; )
3266 syn_clear_pattern(buf
, i
);
3267 ga_clear(&buf
->b_syn_patterns
);
3269 /* free the syntax clusters */
3270 for (i
= buf
->b_syn_clusters
.ga_len
; --i
>= 0; )
3271 syn_clear_cluster(buf
, i
);
3272 ga_clear(&buf
->b_syn_clusters
);
3273 buf
->b_spell_cluster_id
= 0;
3274 buf
->b_nospell_cluster_id
= 0;
3276 buf
->b_syn_sync_flags
= 0;
3277 buf
->b_syn_sync_minlines
= 0;
3278 buf
->b_syn_sync_maxlines
= 0;
3279 buf
->b_syn_sync_linebreaks
= 0;
3281 vim_free(buf
->b_syn_linecont_prog
);
3282 buf
->b_syn_linecont_prog
= NULL
;
3283 vim_free(buf
->b_syn_linecont_pat
);
3284 buf
->b_syn_linecont_pat
= NULL
;
3286 buf
->b_syn_folditems
= 0;
3289 /* free the stored states */
3290 syn_stack_free_all(buf
);
3291 invalidate_current_state();
3295 * Clear syncing info for one buffer.
3302 /* free the syntax patterns */
3303 for (i
= curbuf
->b_syn_patterns
.ga_len
; --i
>= 0; )
3304 if (SYN_ITEMS(curbuf
)[i
].sp_syncing
)
3305 syn_remove_pattern(curbuf
, i
);
3307 curbuf
->b_syn_sync_flags
= 0;
3308 curbuf
->b_syn_sync_minlines
= 0;
3309 curbuf
->b_syn_sync_maxlines
= 0;
3310 curbuf
->b_syn_sync_linebreaks
= 0;
3312 vim_free(curbuf
->b_syn_linecont_prog
);
3313 curbuf
->b_syn_linecont_prog
= NULL
;
3314 vim_free(curbuf
->b_syn_linecont_pat
);
3315 curbuf
->b_syn_linecont_pat
= NULL
;
3317 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
3321 * Remove one pattern from the buffer's pattern list.
3324 syn_remove_pattern(buf
, idx
)
3330 spp
= &(SYN_ITEMS(buf
)[idx
]);
3332 if (spp
->sp_flags
& HL_FOLD
)
3333 --buf
->b_syn_folditems
;
3335 syn_clear_pattern(buf
, idx
);
3336 mch_memmove(spp
, spp
+ 1,
3337 sizeof(synpat_T
) * (buf
->b_syn_patterns
.ga_len
- idx
- 1));
3338 --buf
->b_syn_patterns
.ga_len
;
3342 * Clear and free one syntax pattern. When clearing all, must be called from
3346 syn_clear_pattern(buf
, i
)
3350 vim_free(SYN_ITEMS(buf
)[i
].sp_pattern
);
3351 vim_free(SYN_ITEMS(buf
)[i
].sp_prog
);
3352 /* Only free sp_cont_list and sp_next_list of first start pattern */
3353 if (i
== 0 || SYN_ITEMS(buf
)[i
- 1].sp_type
!= SPTYPE_START
)
3355 vim_free(SYN_ITEMS(buf
)[i
].sp_cont_list
);
3356 vim_free(SYN_ITEMS(buf
)[i
].sp_next_list
);
3361 * Clear and free one syntax cluster.
3364 syn_clear_cluster(buf
, i
)
3368 vim_free(SYN_CLSTR(buf
)[i
].scl_name
);
3369 vim_free(SYN_CLSTR(buf
)[i
].scl_name_u
);
3370 vim_free(SYN_CLSTR(buf
)[i
].scl_list
);
3374 * Handle ":syntax clear" command.
3377 syn_cmd_clear(eap
, syncing
)
3381 char_u
*arg
= eap
->arg
;
3385 eap
->nextcmd
= find_nextcmd(arg
);
3390 * We have to disable this within ":syn include @group filename",
3391 * because otherwise @group would get deleted.
3392 * Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
3395 if (curbuf
->b_syn_topgrp
!= 0)
3398 if (ends_excmd(*arg
))
3401 * No argument: Clear all syntax items.
3404 syntax_sync_clear();
3407 syntax_clear(curbuf
);
3408 do_unlet((char_u
*)"b:current_syntax", TRUE
);
3414 * Clear the group IDs that are in the argument.
3416 while (!ends_excmd(*arg
))
3418 arg_end
= skiptowhite(arg
);
3421 id
= syn_scl_namen2id(arg
+ 1, (int)(arg_end
- arg
- 1));
3424 EMSG2(_("E391: No such syntax cluster: %s"), arg
);
3430 * We can't physically delete a cluster without changing
3431 * the IDs of other clusters, so we do the next best thing
3432 * and make it empty.
3434 short scl_id
= id
- SYNID_CLUSTER
;
3436 vim_free(SYN_CLSTR(curbuf
)[scl_id
].scl_list
);
3437 SYN_CLSTR(curbuf
)[scl_id
].scl_list
= NULL
;
3442 id
= syn_namen2id(arg
, (int)(arg_end
- arg
));
3445 EMSG2(_(e_nogroup
), arg
);
3449 syn_clear_one(id
, syncing
);
3451 arg
= skipwhite(arg_end
);
3454 redraw_curbuf_later(SOME_VALID
);
3455 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
3459 * Clear one syntax group for the current buffer.
3462 syn_clear_one(id
, syncing
)
3469 /* Clear keywords only when not ":syn sync clear group-name" */
3472 (void)syn_clear_keyword(id
, &curbuf
->b_keywtab
);
3473 (void)syn_clear_keyword(id
, &curbuf
->b_keywtab_ic
);
3476 /* clear the patterns for "id" */
3477 for (idx
= curbuf
->b_syn_patterns
.ga_len
; --idx
>= 0; )
3479 spp
= &(SYN_ITEMS(curbuf
)[idx
]);
3480 if (spp
->sp_syn
.id
!= id
|| spp
->sp_syncing
!= syncing
)
3482 syn_remove_pattern(curbuf
, idx
);
3487 * Handle ":syntax on" command.
3491 syn_cmd_on(eap
, syncing
)
3493 int syncing
; /* not used */
3495 syn_cmd_onoff(eap
, "syntax");
3499 * Handle ":syntax enable" command.
3503 syn_cmd_enable(eap
, syncing
)
3505 int syncing
; /* not used */
3507 set_internal_string_var((char_u
*)"syntax_cmd", (char_u
*)"enable");
3508 syn_cmd_onoff(eap
, "syntax");
3509 do_unlet((char_u
*)"g:syntax_cmd", TRUE
);
3513 * Handle ":syntax reset" command.
3517 syn_cmd_reset(eap
, syncing
)
3519 int syncing
; /* not used */
3521 eap
->nextcmd
= check_nextcmd(eap
->arg
);
3524 set_internal_string_var((char_u
*)"syntax_cmd", (char_u
*)"reset");
3525 do_cmdline_cmd((char_u
*)"runtime! syntax/syncolor.vim");
3526 do_unlet((char_u
*)"g:syntax_cmd", TRUE
);
3531 * Handle ":syntax manual" command.
3535 syn_cmd_manual(eap
, syncing
)
3537 int syncing
; /* not used */
3539 syn_cmd_onoff(eap
, "manual");
3543 * Handle ":syntax off" command.
3547 syn_cmd_off(eap
, syncing
)
3549 int syncing
; /* not used */
3551 syn_cmd_onoff(eap
, "nosyntax");
3555 syn_cmd_onoff(eap
, name
)
3561 eap
->nextcmd
= check_nextcmd(eap
->arg
);
3565 vim_snprintf((char *)buf
+ 3, sizeof(buf
) - 3, SYNTAX_FNAME
, name
);
3566 do_cmdline_cmd(buf
);
3571 * Handle ":syntax [list]" command: list current syntax words.
3574 syn_cmd_list(eap
, syncing
)
3576 int syncing
; /* when TRUE: list syncing items */
3578 char_u
*arg
= eap
->arg
;
3582 eap
->nextcmd
= find_nextcmd(arg
);
3586 if (!syntax_present(curbuf
))
3588 MSG(_("No Syntax items defined for this buffer"));
3594 if (curbuf
->b_syn_sync_flags
& SF_CCOMMENT
)
3596 MSG_PUTS(_("syncing on C-style comments"));
3601 else if (!(curbuf
->b_syn_sync_flags
& SF_MATCH
))
3603 if (curbuf
->b_syn_sync_minlines
== 0)
3604 MSG_PUTS(_("no syncing"));
3607 MSG_PUTS(_("syncing starts "));
3608 msg_outnum(curbuf
->b_syn_sync_minlines
);
3609 MSG_PUTS(_(" lines before top line"));
3614 MSG_PUTS_TITLE(_("\n--- Syntax sync items ---"));
3615 if (curbuf
->b_syn_sync_minlines
> 0
3616 || curbuf
->b_syn_sync_maxlines
> 0
3617 || curbuf
->b_syn_sync_linebreaks
> 0)
3619 MSG_PUTS(_("\nsyncing on items"));
3625 MSG_PUTS_TITLE(_("\n--- Syntax items ---"));
3626 if (ends_excmd(*arg
))
3629 * No argument: List all group IDs and all syntax clusters.
3631 for (id
= 1; id
<= highlight_ga
.ga_len
&& !got_int
; ++id
)
3632 syn_list_one(id
, syncing
, FALSE
);
3633 for (id
= 0; id
< curbuf
->b_syn_clusters
.ga_len
&& !got_int
; ++id
)
3634 syn_list_cluster(id
);
3639 * List the group IDs and syntax clusters that are in the argument.
3641 while (!ends_excmd(*arg
) && !got_int
)
3643 arg_end
= skiptowhite(arg
);
3646 id
= syn_scl_namen2id(arg
+ 1, (int)(arg_end
- arg
- 1));
3648 EMSG2(_("E392: No such syntax cluster: %s"), arg
);
3650 syn_list_cluster(id
- SYNID_CLUSTER
);
3654 id
= syn_namen2id(arg
, (int)(arg_end
- arg
));
3656 EMSG2(_(e_nogroup
), arg
);
3658 syn_list_one(id
, syncing
, TRUE
);
3660 arg
= skipwhite(arg_end
);
3663 eap
->nextcmd
= check_nextcmd(arg
);
3669 if (curbuf
->b_syn_sync_maxlines
> 0 || curbuf
->b_syn_sync_minlines
> 0)
3672 if (curbuf
->b_syn_sync_minlines
> 0)
3674 MSG_PUTS(_("minimal "));
3675 msg_outnum(curbuf
->b_syn_sync_minlines
);
3676 if (curbuf
->b_syn_sync_maxlines
)
3679 if (curbuf
->b_syn_sync_maxlines
> 0)
3681 MSG_PUTS(_("maximal "));
3682 msg_outnum(curbuf
->b_syn_sync_maxlines
);
3684 MSG_PUTS(_(" lines before top line"));
3691 if (curbuf
->b_syn_sync_linebreaks
> 0)
3693 MSG_PUTS(_("; match "));
3694 msg_outnum(curbuf
->b_syn_sync_linebreaks
);
3695 MSG_PUTS(_(" line breaks"));
3699 static int last_matchgroup
;
3707 static void syn_list_flags
__ARGS((struct name_list
*nl
, int flags
, int attr
));
3710 * List one syntax item, for ":syntax" or "syntax list syntax_name".
3713 syn_list_one(id
, syncing
, link_only
)
3715 int syncing
; /* when TRUE: list syncing items */
3716 int link_only
; /* when TRUE; list link-only too */
3720 int did_header
= FALSE
;
3722 static struct name_list namelist1
[] =
3724 {HL_DISPLAY
, "display"},
3725 {HL_CONTAINED
, "contained"},
3726 {HL_ONELINE
, "oneline"},
3727 {HL_KEEPEND
, "keepend"},
3728 {HL_EXTEND
, "extend"},
3729 {HL_EXCLUDENL
, "excludenl"},
3730 {HL_TRANSP
, "transparent"},
3734 static struct name_list namelist2
[] =
3736 {HL_SKIPWHITE
, "skipwhite"},
3737 {HL_SKIPNL
, "skipnl"},
3738 {HL_SKIPEMPTY
, "skipempty"},
3742 attr
= hl_attr(HLF_D
); /* highlight like directories */
3744 /* list the keywords for "id" */
3747 did_header
= syn_list_keywords(id
, &curbuf
->b_keywtab
, FALSE
, attr
);
3748 did_header
= syn_list_keywords(id
, &curbuf
->b_keywtab_ic
,
3752 /* list the patterns for "id" */
3753 for (idx
= 0; idx
< curbuf
->b_syn_patterns
.ga_len
&& !got_int
; ++idx
)
3755 spp
= &(SYN_ITEMS(curbuf
)[idx
]);
3756 if (spp
->sp_syn
.id
!= id
|| spp
->sp_syncing
!= syncing
)
3759 (void)syn_list_header(did_header
, 999, id
);
3761 last_matchgroup
= 0;
3762 if (spp
->sp_type
== SPTYPE_MATCH
)
3764 put_pattern("match", ' ', spp
, attr
);
3767 else if (spp
->sp_type
== SPTYPE_START
)
3769 while (SYN_ITEMS(curbuf
)[idx
].sp_type
== SPTYPE_START
)
3770 put_pattern("start", '=', &SYN_ITEMS(curbuf
)[idx
++], attr
);
3771 if (SYN_ITEMS(curbuf
)[idx
].sp_type
== SPTYPE_SKIP
)
3772 put_pattern("skip", '=', &SYN_ITEMS(curbuf
)[idx
++], attr
);
3773 while (idx
< curbuf
->b_syn_patterns
.ga_len
3774 && SYN_ITEMS(curbuf
)[idx
].sp_type
== SPTYPE_END
)
3775 put_pattern("end", '=', &SYN_ITEMS(curbuf
)[idx
++], attr
);
3779 syn_list_flags(namelist1
, spp
->sp_flags
, attr
);
3781 if (spp
->sp_cont_list
!= NULL
)
3782 put_id_list((char_u
*)"contains", spp
->sp_cont_list
, attr
);
3784 if (spp
->sp_syn
.cont_in_list
!= NULL
)
3785 put_id_list((char_u
*)"containedin",
3786 spp
->sp_syn
.cont_in_list
, attr
);
3788 if (spp
->sp_next_list
!= NULL
)
3790 put_id_list((char_u
*)"nextgroup", spp
->sp_next_list
, attr
);
3791 syn_list_flags(namelist2
, spp
->sp_flags
, attr
);
3793 if (spp
->sp_flags
& (HL_SYNC_HERE
|HL_SYNC_THERE
))
3795 if (spp
->sp_flags
& HL_SYNC_HERE
)
3796 msg_puts_attr((char_u
*)"grouphere", attr
);
3798 msg_puts_attr((char_u
*)"groupthere", attr
);
3800 if (spp
->sp_sync_idx
>= 0)
3801 msg_outtrans(HL_TABLE()[SYN_ITEMS(curbuf
)
3802 [spp
->sp_sync_idx
].sp_syn
.id
- 1].sg_name
);
3809 /* list the link, if there is one */
3810 if (HL_TABLE()[id
- 1].sg_link
&& (did_header
|| link_only
) && !got_int
)
3812 (void)syn_list_header(did_header
, 999, id
);
3813 msg_puts_attr((char_u
*)"links to", attr
);
3815 msg_outtrans(HL_TABLE()[HL_TABLE()[id
- 1].sg_link
- 1].sg_name
);
3820 syn_list_flags(nl
, flags
, attr
)
3821 struct name_list
*nl
;
3827 for (i
= 0; nl
[i
].flag
!= 0; ++i
)
3828 if (flags
& nl
[i
].flag
)
3830 msg_puts_attr((char_u
*)nl
[i
].name
, attr
);
3836 * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
3839 syn_list_cluster(id
)
3844 /* slight hack: roughly duplicate the guts of syn_list_header() */
3846 msg_outtrans(SYN_CLSTR(curbuf
)[id
].scl_name
);
3848 if (msg_col
>= endcol
) /* output at least one space */
3849 endcol
= msg_col
+ 1;
3850 if (Columns
<= endcol
) /* avoid hang for tiny window */
3851 endcol
= Columns
- 1;
3853 msg_advance(endcol
);
3854 if (SYN_CLSTR(curbuf
)[id
].scl_list
!= NULL
)
3856 put_id_list((char_u
*)"cluster", SYN_CLSTR(curbuf
)[id
].scl_list
,
3861 msg_puts_attr((char_u
*)"cluster", hl_attr(HLF_D
));
3862 msg_puts((char_u
*)"=NONE");
3867 put_id_list(name
, list
, attr
)
3874 msg_puts_attr(name
, attr
);
3876 for (p
= list
; *p
; ++p
)
3878 if (*p
>= SYNID_ALLBUT
&& *p
< SYNID_TOP
)
3885 else if (*p
>= SYNID_TOP
&& *p
< SYNID_CONTAINED
)
3889 else if (*p
>= SYNID_CONTAINED
&& *p
< SYNID_CLUSTER
)
3891 MSG_PUTS("CONTAINED");
3893 else if (*p
>= SYNID_CLUSTER
)
3895 short scl_id
= *p
- SYNID_CLUSTER
;
3898 msg_outtrans(SYN_CLSTR(curbuf
)[scl_id
].scl_name
);
3901 msg_outtrans(HL_TABLE()[*p
- 1].sg_name
);
3909 put_pattern(s
, c
, spp
, attr
)
3918 static char *sepchars
= "/+=-#@\"|'^&";
3921 /* May have to write "matchgroup=group" */
3922 if (last_matchgroup
!= spp
->sp_syn_match_id
)
3924 last_matchgroup
= spp
->sp_syn_match_id
;
3925 msg_puts_attr((char_u
*)"matchgroup", attr
);
3927 if (last_matchgroup
== 0)
3928 msg_outtrans((char_u
*)"NONE");
3930 msg_outtrans(HL_TABLE()[last_matchgroup
- 1].sg_name
);
3934 /* output the name of the pattern and an '=' or ' ' */
3935 msg_puts_attr((char_u
*)s
, attr
);
3938 /* output the pattern, in between a char that is not in the pattern */
3939 for (i
= 0; vim_strchr(spp
->sp_pattern
, sepchars
[i
]) != NULL
; )
3940 if (sepchars
[++i
] == NUL
)
3942 i
= 0; /* no good char found, just use the first one */
3945 msg_putchar(sepchars
[i
]);
3946 msg_outtrans(spp
->sp_pattern
);
3947 msg_putchar(sepchars
[i
]);
3949 /* output any pattern options */
3951 for (i
= 0; i
< SPO_COUNT
; ++i
)
3954 if (spp
->sp_off_flags
& (mask
+ (mask
<< SPO_COUNT
)))
3957 msg_putchar(','); /* separate with commas */
3958 msg_puts((char_u
*)spo_name_tab
[i
]);
3959 n
= spp
->sp_offsets
[i
];
3960 if (i
!= SPO_LC_OFF
)
3962 if (spp
->sp_off_flags
& mask
)
3969 if (n
|| i
== SPO_LC_OFF
)
3978 * List or clear the keywords for one syntax group.
3979 * Return TRUE if the header has been printed.
3982 syn_list_keywords(id
, ht
, did_header
, attr
)
3985 int did_header
; /* header has already been printed */
3992 int prev_contained
= 0;
3993 short *prev_next_list
= NULL
;
3994 short *prev_cont_in_list
= NULL
;
3995 int prev_skipnl
= 0;
3996 int prev_skipwhite
= 0;
3997 int prev_skipempty
= 0;
4000 * Unfortunately, this list of keywords is not sorted on alphabet but on
4003 todo
= (int)ht
->ht_used
;
4004 for (hi
= ht
->ht_array
; todo
> 0 && !got_int
; ++hi
)
4006 if (!HASHITEM_EMPTY(hi
))
4009 for (kp
= HI2KE(hi
); kp
!= NULL
&& !got_int
; kp
= kp
->ke_next
)
4011 if (kp
->k_syn
.id
== id
)
4013 if (prev_contained
!= (kp
->flags
& HL_CONTAINED
)
4014 || prev_skipnl
!= (kp
->flags
& HL_SKIPNL
)
4015 || prev_skipwhite
!= (kp
->flags
& HL_SKIPWHITE
)
4016 || prev_skipempty
!= (kp
->flags
& HL_SKIPEMPTY
)
4017 || prev_cont_in_list
!= kp
->k_syn
.cont_in_list
4018 || prev_next_list
!= kp
->next_list
)
4021 outlen
= (int)STRLEN(kp
->keyword
);
4022 /* output "contained" and "nextgroup" on each line */
4023 if (syn_list_header(did_header
, outlen
, id
))
4026 prev_next_list
= NULL
;
4027 prev_cont_in_list
= NULL
;
4033 if (prev_contained
!= (kp
->flags
& HL_CONTAINED
))
4035 msg_puts_attr((char_u
*)"contained", attr
);
4037 prev_contained
= (kp
->flags
& HL_CONTAINED
);
4039 if (kp
->k_syn
.cont_in_list
!= prev_cont_in_list
)
4041 put_id_list((char_u
*)"containedin",
4042 kp
->k_syn
.cont_in_list
, attr
);
4044 prev_cont_in_list
= kp
->k_syn
.cont_in_list
;
4046 if (kp
->next_list
!= prev_next_list
)
4048 put_id_list((char_u
*)"nextgroup", kp
->next_list
, attr
);
4050 prev_next_list
= kp
->next_list
;
4051 if (kp
->flags
& HL_SKIPNL
)
4053 msg_puts_attr((char_u
*)"skipnl", attr
);
4055 prev_skipnl
= (kp
->flags
& HL_SKIPNL
);
4057 if (kp
->flags
& HL_SKIPWHITE
)
4059 msg_puts_attr((char_u
*)"skipwhite", attr
);
4061 prev_skipwhite
= (kp
->flags
& HL_SKIPWHITE
);
4063 if (kp
->flags
& HL_SKIPEMPTY
)
4065 msg_puts_attr((char_u
*)"skipempty", attr
);
4067 prev_skipempty
= (kp
->flags
& HL_SKIPEMPTY
);
4070 msg_outtrans(kp
->keyword
);
4080 syn_clear_keyword(id
, ht
)
4086 keyentry_T
*kp_prev
;
4087 keyentry_T
*kp_next
;
4091 todo
= (int)ht
->ht_used
;
4092 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
4094 if (!HASHITEM_EMPTY(hi
))
4098 for (kp
= HI2KE(hi
); kp
!= NULL
; )
4100 if (kp
->k_syn
.id
== id
)
4102 kp_next
= kp
->ke_next
;
4103 if (kp_prev
== NULL
)
4105 if (kp_next
== NULL
)
4106 hash_remove(ht
, hi
);
4108 hi
->hi_key
= KE2HIKEY(kp_next
);
4111 kp_prev
->ke_next
= kp_next
;
4112 vim_free(kp
->next_list
);
4113 vim_free(kp
->k_syn
.cont_in_list
);
4129 * Clear a whole keyword table.
4138 keyentry_T
*kp_next
;
4140 todo
= (int)ht
->ht_used
;
4141 for (hi
= ht
->ht_array
; todo
> 0; ++hi
)
4143 if (!HASHITEM_EMPTY(hi
))
4147 for (kp
= HI2KE(hi
); kp
!= NULL
; kp
= kp_next
)
4149 kp_next
= kp
->ke_next
;
4150 vim_free(kp
->next_list
);
4151 vim_free(kp
->k_syn
.cont_in_list
);
4161 * Add a keyword to the list of keywords.
4164 add_keyword(name
, id
, flags
, cont_in_list
, next_list
)
4165 char_u
*name
; /* name of keyword */
4166 int id
; /* group ID for this keyword */
4167 int flags
; /* flags for this keyword */
4168 short *cont_in_list
; /* containedin for this keyword */
4169 short *next_list
; /* nextgroup for this keyword */
4176 char_u name_folded
[MAXKEYWLEN
+ 1];
4178 if (curbuf
->b_syn_ic
)
4179 name_ic
= str_foldcase(name
, (int)STRLEN(name
),
4180 name_folded
, MAXKEYWLEN
+ 1);
4183 kp
= (keyentry_T
*)alloc((int)(sizeof(keyentry_T
) + STRLEN(name_ic
)));
4186 STRCPY(kp
->keyword
, name_ic
);
4188 kp
->k_syn
.inc_tag
= current_syn_inc_tag
;
4190 kp
->k_syn
.cont_in_list
= copy_id_list(cont_in_list
);
4191 if (cont_in_list
!= NULL
)
4192 curbuf
->b_syn_containedin
= TRUE
;
4193 kp
->next_list
= copy_id_list(next_list
);
4195 if (curbuf
->b_syn_ic
)
4196 ht
= &curbuf
->b_keywtab_ic
;
4198 ht
= &curbuf
->b_keywtab
;
4200 hash
= hash_hash(kp
->keyword
);
4201 hi
= hash_lookup(ht
, kp
->keyword
, hash
);
4202 if (HASHITEM_EMPTY(hi
))
4204 /* new keyword, add to hashtable */
4206 hash_add_item(ht
, hi
, kp
->keyword
, hash
);
4210 /* keyword already exists, prepend to list */
4211 kp
->ke_next
= HI2KE(hi
);
4212 hi
->hi_key
= KE2HIKEY(kp
);
4217 * Get the start and end of the group name argument.
4218 * Return a pointer to the first argument.
4219 * Return NULL if the end of the command was found instead of further args.
4222 get_group_name(arg
, name_end
)
4223 char_u
*arg
; /* start of the argument */
4224 char_u
**name_end
; /* pointer to end of the name */
4228 *name_end
= skiptowhite(arg
);
4229 rest
= skipwhite(*name_end
);
4232 * Check if there are enough arguments. The first argument may be a
4233 * pattern, where '|' is allowed, so only check for NUL.
4235 if (ends_excmd(*arg
) || *rest
== NUL
)
4241 * Check for syntax command option arguments.
4242 * This can be called at any place in the list of arguments, and just picks
4243 * out the arguments that are known. Can be called several times in a row to
4244 * collect all options in between other arguments.
4245 * Return a pointer to the next argument (which isn't an option).
4246 * Return NULL for any error;
4249 get_syn_options(arg
, opt
)
4250 char_u
*arg
; /* next argument to be checked */
4251 syn_opt_arg_T
*opt
; /* various things */
4253 char_u
*gname_start
, *gname
;
4264 } flagtab
[] = { {"cCoOnNtTaAiInNeEdD", 0, HL_CONTAINED
},
4265 {"oOnNeElLiInNeE", 0, HL_ONELINE
},
4266 {"kKeEeEpPeEnNdD", 0, HL_KEEPEND
},
4267 {"eExXtTeEnNdD", 0, HL_EXTEND
},
4268 {"eExXcClLuUdDeEnNlL", 0, HL_EXCLUDENL
},
4269 {"tTrRaAnNsSpPaArReEnNtT", 0, HL_TRANSP
},
4270 {"sSkKiIpPnNlL", 0, HL_SKIPNL
},
4271 {"sSkKiIpPwWhHiItTeE", 0, HL_SKIPWHITE
},
4272 {"sSkKiIpPeEmMpPtTyY", 0, HL_SKIPEMPTY
},
4273 {"gGrRoOuUpPhHeErReE", 0, HL_SYNC_HERE
},
4274 {"gGrRoOuUpPtThHeErReE", 0, HL_SYNC_THERE
},
4275 {"dDiIsSpPlLaAyY", 0, HL_DISPLAY
},
4276 {"fFoOlLdD", 0, HL_FOLD
},
4277 {"cCoOnNtTaAiInNsS", 1, 0},
4278 {"cCoOnNtTaAiInNeEdDiInN", 2, 0},
4279 {"nNeExXtTgGrRoOuUpP", 3, 0},
4281 static char *first_letters
= "cCoOkKeEtTsSgGdDfFnN";
4283 if (arg
== NULL
) /* already detected error */
4289 * This is used very often when a large number of keywords is defined.
4290 * Need to skip quickly when no option name is found.
4291 * Also avoid tolower(), it's slow.
4293 if (strchr(first_letters
, *arg
) == NULL
)
4296 for (fidx
= sizeof(flagtab
) / sizeof(struct flag
); --fidx
>= 0; )
4298 p
= flagtab
[fidx
].name
;
4299 for (i
= 0, len
= 0; p
[i
] != NUL
; i
+= 2, ++len
)
4300 if (arg
[len
] != p
[i
] && arg
[len
] != p
[i
+ 1])
4302 if (p
[i
] == NUL
&& (vim_iswhite(arg
[len
])
4303 || (flagtab
[fidx
].argtype
> 0
4305 : ends_excmd(arg
[len
]))))
4308 && (flagtab
[fidx
].flags
== HL_DISPLAY
4309 || flagtab
[fidx
].flags
== HL_FOLD
4310 || flagtab
[fidx
].flags
== HL_EXTEND
))
4311 /* treat "display", "fold" and "extend" as a keyword */
4316 if (fidx
< 0) /* no match found */
4319 if (flagtab
[fidx
].argtype
== 1)
4321 if (!opt
->has_cont_list
)
4323 EMSG(_("E395: contains argument not accepted here"));
4326 if (get_id_list(&arg
, 8, &opt
->cont_list
) == FAIL
)
4329 else if (flagtab
[fidx
].argtype
== 2)
4331 #if 0 /* cannot happen */
4332 if (opt
->cont_in_list
== NULL
)
4334 EMSG(_("E396: containedin argument not accepted here"));
4338 if (get_id_list(&arg
, 11, &opt
->cont_in_list
) == FAIL
)
4341 else if (flagtab
[fidx
].argtype
== 3)
4343 if (get_id_list(&arg
, 9, &opt
->next_list
) == FAIL
)
4348 opt
->flags
|= flagtab
[fidx
].flags
;
4349 arg
= skipwhite(arg
+ len
);
4351 if (flagtab
[fidx
].flags
== HL_SYNC_HERE
4352 || flagtab
[fidx
].flags
== HL_SYNC_THERE
)
4354 if (opt
->sync_idx
== NULL
)
4356 EMSG(_("E393: group[t]here not accepted here"));
4360 arg
= skiptowhite(arg
);
4361 if (gname_start
== arg
)
4363 gname
= vim_strnsave(gname_start
, (int)(arg
- gname_start
));
4366 if (STRCMP(gname
, "NONE") == 0)
4367 *opt
->sync_idx
= NONE_IDX
;
4370 syn_id
= syn_name2id(gname
);
4371 for (i
= curbuf
->b_syn_patterns
.ga_len
; --i
>= 0; )
4372 if (SYN_ITEMS(curbuf
)[i
].sp_syn
.id
== syn_id
4373 && SYN_ITEMS(curbuf
)[i
].sp_type
== SPTYPE_START
)
4380 EMSG2(_("E394: Didn't find region item for %s"), gname
);
4387 arg
= skipwhite(arg
);
4390 else if (flagtab
[fidx
].flags
== HL_FOLD
4391 && foldmethodIsSyntax(curwin
))
4392 /* Need to update folds later. */
4393 foldUpdateAll(curwin
);
4402 * Adjustments to syntax item when declared in a ":syn include"'d file.
4403 * Set the contained flag, and if the item is not already contained, add it
4404 * to the specified top-level group, if any.
4407 syn_incl_toplevel(id
, flagsp
)
4411 if ((*flagsp
& HL_CONTAINED
) || curbuf
->b_syn_topgrp
== 0)
4413 *flagsp
|= HL_CONTAINED
;
4414 if (curbuf
->b_syn_topgrp
>= SYNID_CLUSTER
)
4416 /* We have to alloc this, because syn_combine_list() will free it. */
4417 short *grp_list
= (short *)alloc((unsigned)(2 * sizeof(short)));
4418 int tlg_id
= curbuf
->b_syn_topgrp
- SYNID_CLUSTER
;
4420 if (grp_list
!= NULL
)
4424 syn_combine_list(&SYN_CLSTR(curbuf
)[tlg_id
].scl_list
, &grp_list
,
4431 * Handle ":syntax include [@{group-name}] filename" command.
4435 syn_cmd_include(eap
, syncing
)
4437 int syncing
; /* not used */
4439 char_u
*arg
= eap
->arg
;
4441 char_u
*group_name_end
;
4443 char_u
*errormsg
= NULL
;
4444 int prev_toplvl_grp
;
4445 int prev_syn_inc_tag
;
4448 eap
->nextcmd
= find_nextcmd(arg
);
4455 rest
= get_group_name(arg
, &group_name_end
);
4458 EMSG((char_u
*)_("E397: Filename required"));
4461 sgl_id
= syn_check_cluster(arg
, (int)(group_name_end
- arg
));
4462 /* separate_nextcmd() and expand_filename() depend on this */
4467 * Everything that's left, up to the next command, should be the
4468 * filename to include.
4470 eap
->argt
|= (XFILE
| NOSPC
);
4471 separate_nextcmd(eap
);
4472 if (*eap
->arg
== '<' || *eap
->arg
== '$' || mch_isFullName(eap
->arg
))
4474 /* For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the
4475 * file. Need to expand the file name first. In other cases
4476 * ":runtime!" is used. */
4478 if (expand_filename(eap
, syn_cmdlinep
, &errormsg
) == FAIL
)
4480 if (errormsg
!= NULL
)
4487 * Save and restore the existing top-level grouplist id and ":syn
4488 * include" tag around the actual inclusion.
4490 prev_syn_inc_tag
= current_syn_inc_tag
;
4491 current_syn_inc_tag
= ++running_syn_inc_tag
;
4492 prev_toplvl_grp
= curbuf
->b_syn_topgrp
;
4493 curbuf
->b_syn_topgrp
= sgl_id
;
4494 if (source
? do_source(eap
->arg
, FALSE
, DOSO_NONE
) == FAIL
4495 : source_runtime(eap
->arg
, TRUE
) == FAIL
)
4496 EMSG2(_(e_notopen
), eap
->arg
);
4497 curbuf
->b_syn_topgrp
= prev_toplvl_grp
;
4498 current_syn_inc_tag
= prev_syn_inc_tag
;
4502 * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
4506 syn_cmd_keyword(eap
, syncing
)
4508 int syncing
; /* not used */
4510 char_u
*arg
= eap
->arg
;
4511 char_u
*group_name_end
;
4514 char_u
*keyword_copy
;
4517 syn_opt_arg_T syn_opt_arg
;
4520 rest
= get_group_name(arg
, &group_name_end
);
4524 syn_id
= syn_check_group(arg
, (int)(group_name_end
- arg
));
4526 /* allocate a buffer, for removing the backslashes in the keyword */
4527 keyword_copy
= alloc((unsigned)STRLEN(rest
) + 1);
4528 if (keyword_copy
!= NULL
)
4530 syn_opt_arg
.flags
= 0;
4531 syn_opt_arg
.keyword
= TRUE
;
4532 syn_opt_arg
.sync_idx
= NULL
;
4533 syn_opt_arg
.has_cont_list
= FALSE
;
4534 syn_opt_arg
.cont_in_list
= NULL
;
4535 syn_opt_arg
.next_list
= NULL
;
4538 * The options given apply to ALL keywords, so all options must be
4539 * found before keywords can be created.
4540 * 1: collect the options and copy the keywords to keyword_copy.
4544 for ( ; rest
!= NULL
&& !ends_excmd(*rest
); rest
= skipwhite(rest
))
4546 rest
= get_syn_options(rest
, &syn_opt_arg
);
4547 if (rest
== NULL
|| ends_excmd(*rest
))
4549 /* Copy the keyword, removing backslashes, and add a NUL. */
4550 while (*rest
!= NUL
&& !vim_iswhite(*rest
))
4552 if (*rest
== '\\' && rest
[1] != NUL
)
4562 /* Adjust flags for use of ":syn include". */
4563 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4566 * 2: Add an entry for each keyword.
4568 for (kw
= keyword_copy
; --cnt
>= 0; kw
+= STRLEN(kw
) + 1)
4570 for (p
= vim_strchr(kw
, '['); ; )
4574 add_keyword(kw
, syn_id
, syn_opt_arg
.flags
,
4575 syn_opt_arg
.cont_in_list
,
4576 syn_opt_arg
.next_list
);
4581 EMSG2(_("E789: Missing ']': %s"), kw
);
4582 kw
= p
+ 2; /* skip over the NUL */
4587 kw
= p
+ 1; /* skip over the "]" */
4593 int l
= (*mb_ptr2len
)(p
+ 1);
4595 mch_memmove(p
, p
+ 1, l
);
4608 vim_free(keyword_copy
);
4609 vim_free(syn_opt_arg
.cont_in_list
);
4610 vim_free(syn_opt_arg
.next_list
);
4615 eap
->nextcmd
= check_nextcmd(rest
);
4617 EMSG2(_(e_invarg2
), arg
);
4619 redraw_curbuf_later(SOME_VALID
);
4620 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4624 * Handle ":syntax match {name} [{options}] {pattern} [{options}]".
4626 * Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
4629 syn_cmd_match(eap
, syncing
)
4631 int syncing
; /* TRUE for ":syntax sync match .. " */
4633 char_u
*arg
= eap
->arg
;
4634 char_u
*group_name_end
;
4636 synpat_T item
; /* the item found in the line */
4639 syn_opt_arg_T syn_opt_arg
;
4642 /* Isolate the group name, check for validity */
4643 rest
= get_group_name(arg
, &group_name_end
);
4645 /* Get options before the pattern */
4646 syn_opt_arg
.flags
= 0;
4647 syn_opt_arg
.keyword
= FALSE
;
4648 syn_opt_arg
.sync_idx
= syncing
? &sync_idx
: NULL
;
4649 syn_opt_arg
.has_cont_list
= TRUE
;
4650 syn_opt_arg
.cont_list
= NULL
;
4651 syn_opt_arg
.cont_in_list
= NULL
;
4652 syn_opt_arg
.next_list
= NULL
;
4653 rest
= get_syn_options(rest
, &syn_opt_arg
);
4655 /* get the pattern. */
4656 init_syn_patterns();
4657 vim_memset(&item
, 0, sizeof(item
));
4658 rest
= get_syn_pattern(rest
, &item
);
4659 if (vim_regcomp_had_eol() && !(syn_opt_arg
.flags
& HL_EXCLUDENL
))
4660 syn_opt_arg
.flags
|= HL_HAS_EOL
;
4662 /* Get options after the pattern */
4663 rest
= get_syn_options(rest
, &syn_opt_arg
);
4665 if (rest
!= NULL
) /* all arguments are valid */
4668 * Check for trailing command and illegal trailing arguments.
4670 eap
->nextcmd
= check_nextcmd(rest
);
4671 if (!ends_excmd(*rest
) || eap
->skip
)
4673 else if (ga_grow(&curbuf
->b_syn_patterns
, 1) != FAIL
4674 && (syn_id
= syn_check_group(arg
,
4675 (int)(group_name_end
- arg
))) != 0)
4677 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4679 * Store the pattern in the syn_items list
4681 idx
= curbuf
->b_syn_patterns
.ga_len
;
4682 SYN_ITEMS(curbuf
)[idx
] = item
;
4683 SYN_ITEMS(curbuf
)[idx
].sp_syncing
= syncing
;
4684 SYN_ITEMS(curbuf
)[idx
].sp_type
= SPTYPE_MATCH
;
4685 SYN_ITEMS(curbuf
)[idx
].sp_syn
.id
= syn_id
;
4686 SYN_ITEMS(curbuf
)[idx
].sp_syn
.inc_tag
= current_syn_inc_tag
;
4687 SYN_ITEMS(curbuf
)[idx
].sp_flags
= syn_opt_arg
.flags
;
4688 SYN_ITEMS(curbuf
)[idx
].sp_sync_idx
= sync_idx
;
4689 SYN_ITEMS(curbuf
)[idx
].sp_cont_list
= syn_opt_arg
.cont_list
;
4690 SYN_ITEMS(curbuf
)[idx
].sp_syn
.cont_in_list
=
4691 syn_opt_arg
.cont_in_list
;
4692 if (syn_opt_arg
.cont_in_list
!= NULL
)
4693 curbuf
->b_syn_containedin
= TRUE
;
4694 SYN_ITEMS(curbuf
)[idx
].sp_next_list
= syn_opt_arg
.next_list
;
4695 ++curbuf
->b_syn_patterns
.ga_len
;
4697 /* remember that we found a match for syncing on */
4698 if (syn_opt_arg
.flags
& (HL_SYNC_HERE
|HL_SYNC_THERE
))
4699 curbuf
->b_syn_sync_flags
|= SF_MATCH
;
4701 if (syn_opt_arg
.flags
& HL_FOLD
)
4702 ++curbuf
->b_syn_folditems
;
4705 redraw_curbuf_later(SOME_VALID
);
4706 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4707 return; /* don't free the progs and patterns now */
4712 * Something failed, free the allocated memory.
4714 vim_free(item
.sp_prog
);
4715 vim_free(item
.sp_pattern
);
4716 vim_free(syn_opt_arg
.cont_list
);
4717 vim_free(syn_opt_arg
.cont_in_list
);
4718 vim_free(syn_opt_arg
.next_list
);
4721 EMSG2(_(e_invarg2
), arg
);
4725 * Handle ":syntax region {group-name} [matchgroup={group-name}]
4726 * start {start} .. [skip {skip}] end {end} .. [{options}]".
4729 syn_cmd_region(eap
, syncing
)
4731 int syncing
; /* TRUE for ":syntax sync region .." */
4733 char_u
*arg
= eap
->arg
;
4734 char_u
*group_name_end
;
4735 char_u
*rest
; /* next arg, NULL on error */
4740 #define ITEM_START 0
4743 #define ITEM_MATCHGROUP 3
4746 synpat_T
*pp_synp
; /* pointer to syn_pattern */
4747 int pp_matchgroup_id
; /* matchgroup ID */
4748 struct pat_ptr
*pp_next
; /* pointer to next pat_ptr */
4750 /* patterns found in the line */
4751 struct pat_ptr
*ppp
;
4752 struct pat_ptr
*ppp_next
;
4753 int pat_count
= 0; /* nr of syn_patterns found */
4755 int matchgroup_id
= 0;
4756 int not_enough
= FALSE
; /* not enough arguments */
4757 int illegal
= FALSE
; /* illegal arguments */
4758 int success
= FALSE
;
4760 syn_opt_arg_T syn_opt_arg
;
4762 /* Isolate the group name, check for validity */
4763 rest
= get_group_name(arg
, &group_name_end
);
4769 init_syn_patterns();
4771 syn_opt_arg
.flags
= 0;
4772 syn_opt_arg
.keyword
= FALSE
;
4773 syn_opt_arg
.sync_idx
= NULL
;
4774 syn_opt_arg
.has_cont_list
= TRUE
;
4775 syn_opt_arg
.cont_list
= NULL
;
4776 syn_opt_arg
.cont_in_list
= NULL
;
4777 syn_opt_arg
.next_list
= NULL
;
4780 * get the options, patterns and matchgroup.
4782 while (rest
!= NULL
&& !ends_excmd(*rest
))
4784 /* Check for option arguments */
4785 rest
= get_syn_options(rest
, &syn_opt_arg
);
4786 if (rest
== NULL
|| ends_excmd(*rest
))
4789 /* must be a pattern or matchgroup then */
4791 while (*key_end
&& !vim_iswhite(*key_end
) && *key_end
!= '=')
4794 key
= vim_strnsave_up(rest
, (int)(key_end
- rest
));
4795 if (key
== NULL
) /* out of memory */
4800 if (STRCMP(key
, "MATCHGROUP") == 0)
4801 item
= ITEM_MATCHGROUP
;
4802 else if (STRCMP(key
, "START") == 0)
4804 else if (STRCMP(key
, "END") == 0)
4806 else if (STRCMP(key
, "SKIP") == 0)
4808 if (pat_ptrs
[ITEM_SKIP
] != NULL
) /* one skip pattern allowed */
4817 rest
= skipwhite(key_end
);
4821 EMSG2(_("E398: Missing '=': %s"), arg
);
4824 rest
= skipwhite(rest
+ 1);
4831 if (item
== ITEM_MATCHGROUP
)
4833 p
= skiptowhite(rest
);
4834 if ((p
- rest
== 4 && STRNCMP(rest
, "NONE", 4) == 0) || eap
->skip
)
4838 matchgroup_id
= syn_check_group(rest
, (int)(p
- rest
));
4839 if (matchgroup_id
== 0)
4845 rest
= skipwhite(p
);
4850 * Allocate room for a syn_pattern, and link it in the list of
4851 * syn_patterns for this item, at the start (because the list is
4852 * used from end to start).
4854 ppp
= (struct pat_ptr
*)alloc((unsigned)sizeof(struct pat_ptr
));
4860 ppp
->pp_next
= pat_ptrs
[item
];
4861 pat_ptrs
[item
] = ppp
;
4862 ppp
->pp_synp
= (synpat_T
*)alloc_clear((unsigned)sizeof(synpat_T
));
4863 if (ppp
->pp_synp
== NULL
)
4870 * Get the syntax pattern and the following offset(s).
4872 /* Enable the appropriate \z specials. */
4873 if (item
== ITEM_START
)
4874 reg_do_extmatch
= REX_SET
;
4875 else if (item
== ITEM_SKIP
|| item
== ITEM_END
)
4876 reg_do_extmatch
= REX_USE
;
4877 rest
= get_syn_pattern(rest
, ppp
->pp_synp
);
4878 reg_do_extmatch
= 0;
4879 if (item
== ITEM_END
&& vim_regcomp_had_eol()
4880 && !(syn_opt_arg
.flags
& HL_EXCLUDENL
))
4881 ppp
->pp_synp
->sp_flags
|= HL_HAS_EOL
;
4882 ppp
->pp_matchgroup_id
= matchgroup_id
;
4887 if (illegal
|| not_enough
)
4891 * Must have a "start" and "end" pattern.
4893 if (rest
!= NULL
&& (pat_ptrs
[ITEM_START
] == NULL
||
4894 pat_ptrs
[ITEM_END
] == NULL
))
4903 * Check for trailing garbage or command.
4904 * If OK, add the item.
4906 eap
->nextcmd
= check_nextcmd(rest
);
4907 if (!ends_excmd(*rest
) || eap
->skip
)
4909 else if (ga_grow(&(curbuf
->b_syn_patterns
), pat_count
) != FAIL
4910 && (syn_id
= syn_check_group(arg
,
4911 (int)(group_name_end
- arg
))) != 0)
4913 syn_incl_toplevel(syn_id
, &syn_opt_arg
.flags
);
4915 * Store the start/skip/end in the syn_items list
4917 idx
= curbuf
->b_syn_patterns
.ga_len
;
4918 for (item
= ITEM_START
; item
<= ITEM_END
; ++item
)
4920 for (ppp
= pat_ptrs
[item
]; ppp
!= NULL
; ppp
= ppp
->pp_next
)
4922 SYN_ITEMS(curbuf
)[idx
] = *(ppp
->pp_synp
);
4923 SYN_ITEMS(curbuf
)[idx
].sp_syncing
= syncing
;
4924 SYN_ITEMS(curbuf
)[idx
].sp_type
=
4925 (item
== ITEM_START
) ? SPTYPE_START
:
4926 (item
== ITEM_SKIP
) ? SPTYPE_SKIP
: SPTYPE_END
;
4927 SYN_ITEMS(curbuf
)[idx
].sp_flags
|= syn_opt_arg
.flags
;
4928 SYN_ITEMS(curbuf
)[idx
].sp_syn
.id
= syn_id
;
4929 SYN_ITEMS(curbuf
)[idx
].sp_syn
.inc_tag
= current_syn_inc_tag
;
4930 SYN_ITEMS(curbuf
)[idx
].sp_syn_match_id
=
4931 ppp
->pp_matchgroup_id
;
4932 if (item
== ITEM_START
)
4934 SYN_ITEMS(curbuf
)[idx
].sp_cont_list
=
4935 syn_opt_arg
.cont_list
;
4936 SYN_ITEMS(curbuf
)[idx
].sp_syn
.cont_in_list
=
4937 syn_opt_arg
.cont_in_list
;
4938 if (syn_opt_arg
.cont_in_list
!= NULL
)
4939 curbuf
->b_syn_containedin
= TRUE
;
4940 SYN_ITEMS(curbuf
)[idx
].sp_next_list
=
4941 syn_opt_arg
.next_list
;
4943 ++curbuf
->b_syn_patterns
.ga_len
;
4946 if (syn_opt_arg
.flags
& HL_FOLD
)
4947 ++curbuf
->b_syn_folditems
;
4952 redraw_curbuf_later(SOME_VALID
);
4953 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
4954 success
= TRUE
; /* don't free the progs and patterns now */
4959 * Free the allocated memory.
4961 for (item
= ITEM_START
; item
<= ITEM_END
; ++item
)
4962 for (ppp
= pat_ptrs
[item
]; ppp
!= NULL
; ppp
= ppp_next
)
4966 vim_free(ppp
->pp_synp
->sp_prog
);
4967 vim_free(ppp
->pp_synp
->sp_pattern
);
4969 vim_free(ppp
->pp_synp
);
4970 ppp_next
= ppp
->pp_next
;
4976 vim_free(syn_opt_arg
.cont_list
);
4977 vim_free(syn_opt_arg
.cont_in_list
);
4978 vim_free(syn_opt_arg
.next_list
);
4980 EMSG2(_("E399: Not enough arguments: syntax region %s"), arg
);
4981 else if (illegal
|| rest
== NULL
)
4982 EMSG2(_(e_invarg2
), arg
);
4987 * A simple syntax group ID comparison function suitable for use in qsort()
4993 syn_compare_stub(v1
, v2
)
4997 const short *s1
= v1
;
4998 const short *s2
= v2
;
5000 return (*s1
> *s2
? 1 : *s1
< *s2
? -1 : 0);
5004 * Combines lists of syntax clusters.
5005 * *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
5008 syn_combine_list(clstr1
, clstr2
, list_op
)
5017 short *clstr
= NULL
;
5022 * Handle degenerate cases.
5024 if (*clstr2
== NULL
)
5026 if (*clstr1
== NULL
|| list_op
== CLUSTER_REPLACE
)
5028 if (list_op
== CLUSTER_REPLACE
)
5030 if (list_op
== CLUSTER_REPLACE
|| list_op
== CLUSTER_ADD
)
5037 for (g1
= *clstr1
; *g1
; g1
++)
5039 for (g2
= *clstr2
; *g2
; g2
++)
5043 * For speed purposes, sort both lists.
5045 qsort(*clstr1
, (size_t)count1
, sizeof(short), syn_compare_stub
);
5046 qsort(*clstr2
, (size_t)count2
, sizeof(short), syn_compare_stub
);
5049 * We proceed in two passes; in round 1, we count the elements to place
5050 * in the new list, and in round 2, we allocate and populate the new
5051 * list. For speed, we use a mergesort-like method, adding the smaller
5052 * of the current elements in each list to the new list.
5054 for (round
= 1; round
<= 2; round
++)
5061 * First, loop through the lists until one of them is empty.
5066 * We always want to add from the first list.
5077 * We only want to add from the second list if we're adding the
5080 if (list_op
== CLUSTER_ADD
)
5092 * Now add the leftovers from whichever list didn't get finished
5093 * first. As before, we only want to add from the second list if
5094 * we're adding the lists.
5096 for (; *g1
; g1
++, count
++)
5099 if (list_op
== CLUSTER_ADD
)
5100 for (; *g2
; g2
++, count
++)
5107 * If the group ended up empty, we don't need to allocate any
5115 clstr
= (short *)alloc((unsigned)((count
+ 1) * sizeof(short)));
5123 * Finally, put the new list in place.
5131 * Lookup a syntax cluster name and return it's ID.
5132 * If it is not found, 0 is returned.
5135 syn_scl_name2id(name
)
5141 /* Avoid using stricmp() too much, it's slow on some systems */
5142 name_u
= vim_strsave_up(name
);
5145 for (i
= curbuf
->b_syn_clusters
.ga_len
; --i
>= 0; )
5146 if (SYN_CLSTR(curbuf
)[i
].scl_name_u
!= NULL
5147 && STRCMP(name_u
, SYN_CLSTR(curbuf
)[i
].scl_name_u
) == 0)
5150 return (i
< 0 ? 0 : i
+ SYNID_CLUSTER
);
5154 * Like syn_scl_name2id(), but take a pointer + length argument.
5157 syn_scl_namen2id(linep
, len
)
5164 name
= vim_strnsave(linep
, len
);
5167 id
= syn_scl_name2id(name
);
5174 * Find syntax cluster name in the table and return it's ID.
5175 * The argument is a pointer to the name and the length of the name.
5176 * If it doesn't exist yet, a new entry is created.
5177 * Return 0 for failure.
5180 syn_check_cluster(pp
, len
)
5187 name
= vim_strnsave(pp
, len
);
5191 id
= syn_scl_name2id(name
);
5192 if (id
== 0) /* doesn't exist yet */
5193 id
= syn_add_cluster(name
);
5200 * Add new syntax cluster and return it's ID.
5201 * "name" must be an allocated string, it will be consumed.
5202 * Return 0 for failure.
5205 syn_add_cluster(name
)
5211 * First call for this growarray: init growing array.
5213 if (curbuf
->b_syn_clusters
.ga_data
== NULL
)
5215 curbuf
->b_syn_clusters
.ga_itemsize
= sizeof(syn_cluster_T
);
5216 curbuf
->b_syn_clusters
.ga_growsize
= 10;
5220 * Make room for at least one other cluster entry.
5222 if (ga_grow(&curbuf
->b_syn_clusters
, 1) == FAIL
)
5227 len
= curbuf
->b_syn_clusters
.ga_len
;
5229 vim_memset(&(SYN_CLSTR(curbuf
)[len
]), 0, sizeof(syn_cluster_T
));
5230 SYN_CLSTR(curbuf
)[len
].scl_name
= name
;
5231 SYN_CLSTR(curbuf
)[len
].scl_name_u
= vim_strsave_up(name
);
5232 SYN_CLSTR(curbuf
)[len
].scl_list
= NULL
;
5233 ++curbuf
->b_syn_clusters
.ga_len
;
5235 if (STRICMP(name
, "Spell") == 0)
5236 curbuf
->b_spell_cluster_id
= len
+ SYNID_CLUSTER
;
5237 if (STRICMP(name
, "NoSpell") == 0)
5238 curbuf
->b_nospell_cluster_id
= len
+ SYNID_CLUSTER
;
5240 return len
+ SYNID_CLUSTER
;
5244 * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
5245 * [add={groupname},..] [remove={groupname},..]".
5249 syn_cmd_cluster(eap
, syncing
)
5251 int syncing
; /* not used */
5253 char_u
*arg
= eap
->arg
;
5254 char_u
*group_name_end
;
5258 int got_clstr
= FALSE
;
5262 eap
->nextcmd
= find_nextcmd(arg
);
5266 rest
= get_group_name(arg
, &group_name_end
);
5270 scl_id
= syn_check_cluster(arg
, (int)(group_name_end
- arg
))
5275 if (STRNICMP(rest
, "add", 3) == 0
5276 && (vim_iswhite(rest
[3]) || rest
[3] == '='))
5279 list_op
= CLUSTER_ADD
;
5281 else if (STRNICMP(rest
, "remove", 6) == 0
5282 && (vim_iswhite(rest
[6]) || rest
[6] == '='))
5285 list_op
= CLUSTER_SUBTRACT
;
5287 else if (STRNICMP(rest
, "contains", 8) == 0
5288 && (vim_iswhite(rest
[8]) || rest
[8] == '='))
5291 list_op
= CLUSTER_REPLACE
;
5297 if (get_id_list(&rest
, opt_len
, &clstr_list
) == FAIL
)
5299 EMSG2(_(e_invarg2
), rest
);
5302 syn_combine_list(&SYN_CLSTR(curbuf
)[scl_id
].scl_list
,
5303 &clstr_list
, list_op
);
5309 redraw_curbuf_later(SOME_VALID
);
5310 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
5315 EMSG(_("E400: No cluster specified"));
5316 if (rest
== NULL
|| !ends_excmd(*rest
))
5317 EMSG2(_(e_invarg2
), arg
);
5321 * On first call for current buffer: Init growing array.
5326 curbuf
->b_syn_patterns
.ga_itemsize
= sizeof(synpat_T
);
5327 curbuf
->b_syn_patterns
.ga_growsize
= 10;
5331 * Get one pattern for a ":syntax match" or ":syntax region" command.
5332 * Stores the pattern and program in a synpat_T.
5333 * Returns a pointer to the next argument, or NULL in case of an error.
5336 get_syn_pattern(arg
, ci
)
5345 /* need at least three chars */
5346 if (arg
== NULL
|| arg
[1] == NUL
|| arg
[2] == NUL
)
5349 end
= skip_regexp(arg
+ 1, *arg
, TRUE
, NULL
);
5350 if (*end
!= *arg
) /* end delimiter not found */
5352 EMSG2(_("E401: Pattern delimiter not found: %s"), arg
);
5355 /* store the pattern and compiled regexp program */
5356 if ((ci
->sp_pattern
= vim_strnsave(arg
+ 1, (int)(end
- arg
- 1))) == NULL
)
5359 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5361 p_cpo
= (char_u
*)"";
5362 ci
->sp_prog
= vim_regcomp(ci
->sp_pattern
, RE_MAGIC
);
5365 if (ci
->sp_prog
== NULL
)
5367 ci
->sp_ic
= curbuf
->b_syn_ic
;
5370 * Check for a match, highlight or region offset.
5375 for (idx
= SPO_COUNT
; --idx
>= 0; )
5376 if (STRNCMP(end
, spo_name_tab
[idx
], 3) == 0)
5380 p
= &(ci
->sp_offsets
[idx
]);
5381 if (idx
!= SPO_LC_OFF
)
5386 case 'e': idx
+= SPO_COUNT
; break;
5387 default: idx
= -1; break;
5391 ci
->sp_off_flags
|= (1 << idx
);
5392 if (idx
== SPO_LC_OFF
) /* lc=99 */
5395 *p
= getdigits(&end
);
5397 /* "lc=" offset automatically sets "ms=" offset */
5398 if (!(ci
->sp_off_flags
& (1 << SPO_MS_OFF
)))
5400 ci
->sp_off_flags
|= (1 << SPO_MS_OFF
);
5401 ci
->sp_offsets
[SPO_MS_OFF
] = *p
;
5410 *p
= getdigits(&end
); /* positive offset */
5412 else if (*end
== '-')
5415 *p
= -getdigits(&end
); /* negative offset */
5425 if (!ends_excmd(*end
) && !vim_iswhite(*end
))
5427 EMSG2(_("E402: Garbage after pattern: %s"), arg
);
5430 return skipwhite(end
);
5434 * Handle ":syntax sync .." command.
5438 syn_cmd_sync(eap
, syncing
)
5440 int syncing
; /* not used */
5442 char_u
*arg_start
= eap
->arg
;
5446 int illegal
= FALSE
;
5447 int finished
= FALSE
;
5451 if (ends_excmd(*arg_start
))
5453 syn_cmd_list(eap
, TRUE
);
5457 while (!ends_excmd(*arg_start
))
5459 arg_end
= skiptowhite(arg_start
);
5460 next_arg
= skipwhite(arg_end
);
5462 key
= vim_strnsave_up(arg_start
, (int)(arg_end
- arg_start
));
5463 if (STRCMP(key
, "CCOMMENT") == 0)
5466 curbuf
->b_syn_sync_flags
|= SF_CCOMMENT
;
5467 if (!ends_excmd(*next_arg
))
5469 arg_end
= skiptowhite(next_arg
);
5471 curbuf
->b_syn_sync_id
= syn_check_group(next_arg
,
5472 (int)(arg_end
- next_arg
));
5473 next_arg
= skipwhite(arg_end
);
5475 else if (!eap
->skip
)
5476 curbuf
->b_syn_sync_id
= syn_name2id((char_u
*)"Comment");
5478 else if ( STRNCMP(key
, "LINES", 5) == 0
5479 || STRNCMP(key
, "MINLINES", 8) == 0
5480 || STRNCMP(key
, "MAXLINES", 8) == 0
5481 || STRNCMP(key
, "LINEBREAKS", 10) == 0)
5485 else if (key
[0] == 'L')
5489 if (arg_end
[-1] != '=' || !VIM_ISDIGIT(*arg_end
))
5494 n
= getdigits(&arg_end
);
5498 curbuf
->b_syn_sync_linebreaks
= n
;
5499 else if (key
[1] == 'A')
5500 curbuf
->b_syn_sync_maxlines
= n
;
5502 curbuf
->b_syn_sync_minlines
= n
;
5505 else if (STRCMP(key
, "FROMSTART") == 0)
5509 curbuf
->b_syn_sync_minlines
= MAXLNUM
;
5510 curbuf
->b_syn_sync_maxlines
= 0;
5513 else if (STRCMP(key
, "LINECONT") == 0)
5515 if (curbuf
->b_syn_linecont_pat
!= NULL
)
5517 EMSG(_("E403: syntax sync: line continuations pattern specified twice"));
5521 arg_end
= skip_regexp(next_arg
+ 1, *next_arg
, TRUE
, NULL
);
5522 if (*arg_end
!= *next_arg
) /* end delimiter not found */
5530 /* store the pattern and compiled regexp program */
5531 if ((curbuf
->b_syn_linecont_pat
= vim_strnsave(next_arg
+ 1,
5532 (int)(arg_end
- next_arg
- 1))) == NULL
)
5537 curbuf
->b_syn_linecont_ic
= curbuf
->b_syn_ic
;
5539 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5541 p_cpo
= (char_u
*)"";
5542 curbuf
->b_syn_linecont_prog
=
5543 vim_regcomp(curbuf
->b_syn_linecont_pat
, RE_MAGIC
);
5546 if (curbuf
->b_syn_linecont_prog
== NULL
)
5548 vim_free(curbuf
->b_syn_linecont_pat
);
5549 curbuf
->b_syn_linecont_pat
= NULL
;
5554 next_arg
= skipwhite(arg_end
+ 1);
5558 eap
->arg
= next_arg
;
5559 if (STRCMP(key
, "MATCH") == 0)
5560 syn_cmd_match(eap
, TRUE
);
5561 else if (STRCMP(key
, "REGION") == 0)
5562 syn_cmd_region(eap
, TRUE
);
5563 else if (STRCMP(key
, "CLEAR") == 0)
5564 syn_cmd_clear(eap
, TRUE
);
5570 arg_start
= next_arg
;
5574 EMSG2(_("E404: Illegal arguments: %s"), arg_start
);
5577 eap
->nextcmd
= check_nextcmd(arg_start
);
5578 redraw_curbuf_later(SOME_VALID
);
5579 syn_stack_free_all(curbuf
); /* Need to recompute all syntax. */
5584 * Convert a line of highlight group names into a list of group ID numbers.
5585 * "arg" should point to the "contains" or "nextgroup" keyword.
5586 * "arg" is advanced to after the last group name.
5587 * Careful: the argument is modified (NULs added).
5588 * returns FAIL for some error, OK for success.
5591 get_id_list(arg
, keylen
, list
)
5593 int keylen
; /* length of keyword */
5594 short **list
; /* where to store the resulting list, if not
5595 NULL, the list is silently skipped! */
5601 int total_count
= 0;
5602 short *retval
= NULL
;
5604 regmatch_T regmatch
;
5610 * We parse the list twice:
5611 * round == 1: count the number of items, allocate the array.
5612 * round == 2: fill the array with the items.
5613 * In round 1 new groups may be added, causing the number of items to
5614 * grow when a regexp is used. In that case round 1 is done once again.
5616 for (round
= 1; round
<= 2; ++round
)
5621 p
= skipwhite(*arg
+ keylen
);
5624 EMSG2(_("E405: Missing equal sign: %s"), *arg
);
5627 p
= skipwhite(p
+ 1);
5630 EMSG2(_("E406: Empty argument: %s"), *arg
);
5635 * parse the arguments after "contains"
5638 while (!ends_excmd(*p
))
5640 for (end
= p
; *end
&& !vim_iswhite(*end
) && *end
!= ','; ++end
)
5642 name
= alloc((int)(end
- p
+ 3)); /* leave room for "^$" */
5648 vim_strncpy(name
+ 1, p
, end
- p
);
5649 if ( STRCMP(name
+ 1, "ALLBUT") == 0
5650 || STRCMP(name
+ 1, "ALL") == 0
5651 || STRCMP(name
+ 1, "TOP") == 0
5652 || STRCMP(name
+ 1, "CONTAINED") == 0)
5654 if (TOUPPER_ASC(**arg
) != 'C')
5656 EMSG2(_("E407: %s not allowed here"), name
+ 1);
5663 EMSG2(_("E408: %s must be first in contains list"), name
+ 1);
5670 else if (name
[1] == 'T')
5673 id
= SYNID_CONTAINED
;
5674 id
+= current_syn_inc_tag
;
5676 else if (name
[1] == '@')
5678 id
= syn_check_cluster(name
+ 2, (int)(end
- p
- 1));
5683 * Handle full group name.
5685 if (vim_strpbrk(name
+ 1, (char_u
*)"\\.*^$~[") == NULL
)
5686 id
= syn_check_group(name
+ 1, (int)(end
- p
));
5690 * Handle match of regexp with group names.
5694 regmatch
.regprog
= vim_regcomp(name
, RE_MAGIC
);
5695 if (regmatch
.regprog
== NULL
)
5702 regmatch
.rm_ic
= TRUE
;
5704 for (i
= highlight_ga
.ga_len
; --i
>= 0; )
5706 if (vim_regexec(®match
, HL_TABLE()[i
].sg_name
,
5711 /* Got more items than expected; can happen
5712 * when adding items that match:
5713 * "contains=a.*b,axb".
5714 * Go back to first round */
5715 if (count
>= total_count
)
5721 retval
[count
] = i
+ 1;
5724 id
= -1; /* remember that we found one */
5727 vim_free(regmatch
.regprog
);
5733 EMSG2(_("E409: Unknown group name: %s"), p
);
5741 /* Got more items than expected, go back to first round */
5742 if (count
>= total_count
)
5755 p
= skipwhite(p
+ 1); /* skip comma in between arguments */
5761 retval
= (short *)alloc((unsigned)((count
+ 1) * sizeof(short)));
5764 retval
[count
] = 0; /* zero means end of the list */
5765 total_count
= count
;
5770 if (failed
|| retval
== NULL
)
5779 vim_free(retval
); /* list already found, don't overwrite it */
5785 * Make a copy of an ID list.
5798 for (count
= 0; list
[count
]; ++count
)
5800 len
= (count
+ 1) * sizeof(short);
5801 retval
= (short *)alloc((unsigned)len
);
5803 mch_memmove(retval
, list
, (size_t)len
);
5809 * Check if syntax group "ssp" is in the ID list "list" of "cur_si".
5810 * "cur_si" can be NULL if not checking the "containedin" list.
5811 * Used to check if a syntax item is in the "contains" or "nextgroup" list of
5813 * This function is called very often, keep it fast!!
5816 in_id_list(cur_si
, list
, ssp
, contained
)
5817 stateitem_T
*cur_si
; /* current item or NULL */
5818 short *list
; /* id list */
5819 struct sp_syn
*ssp
; /* group id and ":syn include" tag of group */
5820 int contained
; /* group id is contained */
5826 static int depth
= 0;
5829 /* If spp has a "containedin" list and "cur_si" is in it, return TRUE. */
5830 if (cur_si
!= NULL
&& ssp
->cont_in_list
!= NULL
5831 && !(cur_si
->si_flags
& HL_MATCH
))
5833 /* Ignore transparent items without a contains argument. Double check
5834 * that we don't go back past the first one. */
5835 while ((cur_si
->si_flags
& HL_TRANS_CONT
)
5836 && cur_si
> (stateitem_T
*)(current_state
.ga_data
))
5838 /* cur_si->si_idx is -1 for keywords, these never contain anything. */
5839 if (cur_si
->si_idx
>= 0 && in_id_list(NULL
, ssp
->cont_in_list
,
5840 &(SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_syn
),
5841 SYN_ITEMS(syn_buf
)[cur_si
->si_idx
].sp_flags
& HL_CONTAINED
))
5849 * If list is ID_LIST_ALL, we are in a transparent item that isn't
5850 * inside anything. Only allow not-contained groups.
5852 if (list
== ID_LIST_ALL
)
5856 * If the first item is "ALLBUT", return TRUE if "id" is NOT in the
5857 * contains list. We also require that "id" is at the same ":syn include"
5858 * level as the list.
5861 if (item
>= SYNID_ALLBUT
&& item
< SYNID_CLUSTER
)
5863 if (item
< SYNID_TOP
)
5865 /* ALL or ALLBUT: accept all groups in the same file */
5866 if (item
- SYNID_ALLBUT
!= ssp
->inc_tag
)
5869 else if (item
< SYNID_CONTAINED
)
5871 /* TOP: accept all not-contained groups in the same file */
5872 if (item
- SYNID_TOP
!= ssp
->inc_tag
|| contained
)
5877 /* CONTAINED: accept all contained groups in the same file */
5878 if (item
- SYNID_CONTAINED
!= ssp
->inc_tag
|| !contained
)
5888 * Return "retval" if id is in the contains list.
5894 if (item
>= SYNID_CLUSTER
)
5896 scl_list
= SYN_CLSTR(syn_buf
)[item
- SYNID_CLUSTER
].scl_list
;
5897 /* restrict recursiveness to 30 to avoid an endless loop for a
5898 * cluster that includes itself (indirectly) */
5899 if (scl_list
!= NULL
&& depth
< 30)
5902 r
= in_id_list(NULL
, scl_list
, ssp
, contained
);
5915 char *name
; /* subcommand name */
5916 void (*func
)__ARGS((exarg_T
*, int)); /* function to call */
5919 static struct subcommand subcommands
[] =
5921 {"case", syn_cmd_case
},
5922 {"clear", syn_cmd_clear
},
5923 {"cluster", syn_cmd_cluster
},
5924 {"enable", syn_cmd_enable
},
5925 {"include", syn_cmd_include
},
5926 {"keyword", syn_cmd_keyword
},
5927 {"list", syn_cmd_list
},
5928 {"manual", syn_cmd_manual
},
5929 {"match", syn_cmd_match
},
5931 {"off", syn_cmd_off
},
5932 {"region", syn_cmd_region
},
5933 {"reset", syn_cmd_reset
},
5934 {"spell", syn_cmd_spell
},
5935 {"sync", syn_cmd_sync
},
5942 * This searches the subcommands[] table for the subcommand name, and calls a
5943 * syntax_subcommand() function to do the rest.
5949 char_u
*arg
= eap
->arg
;
5951 char_u
*subcmd_name
;
5954 syn_cmdlinep
= eap
->cmdlinep
;
5956 /* isolate subcommand name */
5957 for (subcmd_end
= arg
; ASCII_ISALPHA(*subcmd_end
); ++subcmd_end
)
5959 subcmd_name
= vim_strnsave(arg
, (int)(subcmd_end
- arg
));
5960 if (subcmd_name
!= NULL
)
5962 if (eap
->skip
) /* skip error messages for all subcommands */
5966 if (subcommands
[i
].name
== NULL
)
5968 EMSG2(_("E410: Invalid :syntax subcommand: %s"), subcmd_name
);
5971 if (STRCMP(subcmd_name
, (char_u
*)subcommands
[i
].name
) == 0)
5973 eap
->arg
= skipwhite(subcmd_end
);
5974 (subcommands
[i
].func
)(eap
, FALSE
);
5978 vim_free(subcmd_name
);
5988 return (buf
->b_syn_patterns
.ga_len
!= 0
5989 || buf
->b_syn_clusters
.ga_len
!= 0
5990 || buf
->b_keywtab
.ht_used
> 0
5991 || buf
->b_keywtab_ic
.ht_used
> 0);
5994 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
5998 EXP_SUBCMD
, /* expand ":syn" sub-commands */
5999 EXP_CASE
/* expand ":syn case" arguments */
6003 * Reset include_link, include_default, include_none to 0.
6004 * Called when we are done expanding.
6007 reset_expand_highlight()
6009 include_link
= include_default
= include_none
= 0;
6013 * Handle command line completion for :match and :echohl command: Add "None"
6014 * as highlight group.
6017 set_context_in_echohl_cmd(xp
, arg
)
6021 xp
->xp_context
= EXPAND_HIGHLIGHT
;
6022 xp
->xp_pattern
= arg
;
6027 * Handle command line completion for :syntax command.
6030 set_context_in_syntax_cmd(xp
, arg
)
6036 /* Default: expand subcommands */
6037 xp
->xp_context
= EXPAND_SYNTAX
;
6038 expand_what
= EXP_SUBCMD
;
6039 xp
->xp_pattern
= arg
;
6041 include_default
= 0;
6043 /* (part of) subcommand already typed */
6046 p
= skiptowhite(arg
);
6047 if (*p
!= NUL
) /* past first word */
6049 xp
->xp_pattern
= skipwhite(p
);
6050 if (*skiptowhite(xp
->xp_pattern
) != NUL
)
6051 xp
->xp_context
= EXPAND_NOTHING
;
6052 else if (STRNICMP(arg
, "case", p
- arg
) == 0)
6053 expand_what
= EXP_CASE
;
6054 else if ( STRNICMP(arg
, "keyword", p
- arg
) == 0
6055 || STRNICMP(arg
, "region", p
- arg
) == 0
6056 || STRNICMP(arg
, "match", p
- arg
) == 0
6057 || STRNICMP(arg
, "list", p
- arg
) == 0)
6058 xp
->xp_context
= EXPAND_HIGHLIGHT
;
6060 xp
->xp_context
= EXPAND_NOTHING
;
6065 static char *(case_args
[]) = {"match", "ignore", NULL
};
6068 * Function given to ExpandGeneric() to obtain the list syntax names for
6073 get_syntax_name(xp
, idx
)
6077 if (expand_what
== EXP_SUBCMD
)
6078 return (char_u
*)subcommands
[idx
].name
;
6079 return (char_u
*)case_args
[idx
];
6082 #endif /* FEAT_CMDL_COMPL */
6085 * Function called for expression evaluation: get syntax ID at file position.
6088 syn_get_id(wp
, lnum
, col
, trans
, spellp
)
6092 int trans
; /* remove transparancy */
6093 int *spellp
; /* return: can do spell checking */
6095 /* When the position is not after the current position and in the same
6096 * line of the same buffer, need to restart parsing. */
6097 if (wp
->w_buffer
!= syn_buf
6098 || lnum
!= current_lnum
6099 || col
< current_col
)
6100 syntax_start(wp
, lnum
);
6102 (void)get_syntax_attr(col
, spellp
);
6104 return (trans
? current_trans_id
: current_id
);
6107 #if defined(FEAT_FOLDING) || defined(PROTO)
6109 * Function called to get folding level for line "lnum" in window "wp".
6112 syn_get_foldlevel(wp
, lnum
)
6119 /* Return quickly when there are no fold items at all. */
6120 if (wp
->w_buffer
->b_syn_folditems
!= 0)
6122 syntax_start(wp
, lnum
);
6124 for (i
= 0; i
< current_state
.ga_len
; ++i
)
6125 if (CUR_STATE(i
).si_flags
& HL_FOLD
)
6128 if (level
> wp
->w_p_fdn
)
6130 level
= wp
->w_p_fdn
;
6138 #endif /* FEAT_SYN_HL */
6141 /**************************************
6142 * Highlighting stuff *
6143 **************************************/
6146 * The default highlight groups. These are compiled-in for fast startup and
6147 * they still work when the runtime files can't be found.
6148 * When making changes here, also change runtime/colors/default.vim!
6149 * The #ifdefs are needed to reduce the amount of static data. Helps to make
6150 * the 16 bit DOS (museum) version compile.
6153 # define CENT(a, b) b
6155 # define CENT(a, b) a
6157 static char *(highlight_init_both
[]) =
6159 CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White",
6160 "ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"),
6161 #ifdef FEAT_SEARCH_EXTRA
6162 CENT("IncSearch term=reverse cterm=reverse",
6163 "IncSearch term=reverse cterm=reverse gui=reverse"),
6165 CENT("ModeMsg term=bold cterm=bold",
6166 "ModeMsg term=bold cterm=bold gui=bold"),
6167 CENT("NonText term=bold ctermfg=Blue",
6168 "NonText term=bold ctermfg=Blue gui=bold guifg=Blue"),
6169 CENT("StatusLine term=reverse,bold cterm=reverse,bold",
6170 "StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"),
6171 CENT("StatusLineNC term=reverse cterm=reverse",
6172 "StatusLineNC term=reverse cterm=reverse gui=reverse"),
6173 #ifdef FEAT_VERTSPLIT
6174 CENT("VertSplit term=reverse cterm=reverse",
6175 "VertSplit term=reverse cterm=reverse gui=reverse"),
6177 #ifdef FEAT_CLIPBOARD
6178 CENT("VisualNOS term=underline,bold cterm=underline,bold",
6179 "VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"),
6182 CENT("DiffText term=reverse cterm=bold ctermbg=Red",
6183 "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"),
6185 #ifdef FEAT_INS_EXPAND
6186 CENT("PmenuThumb cterm=reverse",
6187 "PmenuThumb cterm=reverse gui=reverse"),
6188 CENT("PmenuSbar ctermbg=Grey",
6189 "PmenuSbar ctermbg=Grey guibg=Grey"),
6192 CENT("TabLineSel term=bold cterm=bold",
6193 "TabLineSel term=bold cterm=bold gui=bold"),
6194 CENT("TabLineFill term=reverse cterm=reverse",
6195 "TabLineFill term=reverse cterm=reverse gui=reverse"),
6198 "Cursor guibg=fg guifg=bg",
6199 "lCursor guibg=fg guifg=bg", /* should be different, but what? */
6204 static char *(highlight_init_light
[]) =
6206 CENT("Directory term=bold ctermfg=DarkBlue",
6207 "Directory term=bold ctermfg=DarkBlue guifg=Blue"),
6208 CENT("LineNr term=underline ctermfg=Brown",
6209 "LineNr term=underline ctermfg=Brown guifg=Brown"),
6210 CENT("MoreMsg term=bold ctermfg=DarkGreen",
6211 "MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6212 CENT("Question term=standout ctermfg=DarkGreen",
6213 "Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6214 CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE",
6215 "Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"),
6217 CENT("SpellBad term=reverse ctermbg=LightRed",
6218 "SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"),
6219 CENT("SpellCap term=reverse ctermbg=LightBlue",
6220 "SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"),
6221 CENT("SpellRare term=reverse ctermbg=LightMagenta",
6222 "SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"),
6223 CENT("SpellLocal term=underline ctermbg=Cyan",
6224 "SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"),
6226 #ifdef FEAT_INS_EXPAND
6227 CENT("Pmenu ctermbg=LightMagenta",
6228 "Pmenu ctermbg=LightMagenta guibg=LightMagenta"),
6229 CENT("PmenuSel ctermbg=LightGrey",
6230 "PmenuSel ctermbg=LightGrey guibg=Grey"),
6232 CENT("SpecialKey term=bold ctermfg=DarkBlue",
6233 "SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"),
6234 CENT("Title term=bold ctermfg=DarkMagenta",
6235 "Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"),
6236 CENT("WarningMsg term=standout ctermfg=DarkRed",
6237 "WarningMsg term=standout ctermfg=DarkRed guifg=Red"),
6238 #ifdef FEAT_WILDMENU
6239 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6240 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6243 CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue",
6244 "Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"),
6245 CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6246 "FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6249 CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6250 "SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6253 CENT("Visual term=reverse",
6254 "Visual term=reverse guibg=LightGrey"),
6257 CENT("DiffAdd term=bold ctermbg=LightBlue",
6258 "DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"),
6259 CENT("DiffChange term=bold ctermbg=LightMagenta",
6260 "DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"),
6261 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan",
6262 "DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"),
6265 CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey",
6266 "TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"),
6269 CENT("CursorColumn term=reverse ctermbg=LightGrey",
6270 "CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"),
6271 CENT("CursorLine term=underline cterm=underline",
6272 "CursorLine term=underline cterm=underline guibg=Grey90"),
6275 CENT("MatchParen term=reverse ctermbg=Cyan",
6276 "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"),
6284 static char *(highlight_init_dark
[]) =
6286 CENT("Directory term=bold ctermfg=LightCyan",
6287 "Directory term=bold ctermfg=LightCyan guifg=Cyan"),
6288 CENT("LineNr term=underline ctermfg=Yellow",
6289 "LineNr term=underline ctermfg=Yellow guifg=Yellow"),
6290 CENT("MoreMsg term=bold ctermfg=LightGreen",
6291 "MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"),
6292 CENT("Question term=standout ctermfg=LightGreen",
6293 "Question term=standout ctermfg=LightGreen gui=bold guifg=Green"),
6294 CENT("Search term=reverse ctermbg=Yellow ctermfg=Black",
6295 "Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6296 CENT("SpecialKey term=bold ctermfg=LightBlue",
6297 "SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"),
6299 CENT("SpellBad term=reverse ctermbg=Red",
6300 "SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"),
6301 CENT("SpellCap term=reverse ctermbg=Blue",
6302 "SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"),
6303 CENT("SpellRare term=reverse ctermbg=Magenta",
6304 "SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"),
6305 CENT("SpellLocal term=underline ctermbg=Cyan",
6306 "SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"),
6308 #ifdef FEAT_INS_EXPAND
6309 CENT("Pmenu ctermbg=Magenta",
6310 "Pmenu ctermbg=Magenta guibg=Magenta"),
6311 CENT("PmenuSel ctermbg=DarkGrey",
6312 "PmenuSel ctermbg=DarkGrey guibg=DarkGrey"),
6314 CENT("Title term=bold ctermfg=LightMagenta",
6315 "Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"),
6316 CENT("WarningMsg term=standout ctermfg=LightRed",
6317 "WarningMsg term=standout ctermfg=LightRed guifg=Red"),
6318 #ifdef FEAT_WILDMENU
6319 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6320 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6323 CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan",
6324 "Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"),
6325 CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6326 "FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6329 CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6330 "SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6333 CENT("Visual term=reverse",
6334 "Visual term=reverse guibg=DarkGrey"),
6337 CENT("DiffAdd term=bold ctermbg=DarkBlue",
6338 "DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"),
6339 CENT("DiffChange term=bold ctermbg=DarkMagenta",
6340 "DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"),
6341 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan",
6342 "DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"),
6345 CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey",
6346 "TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"),
6349 CENT("CursorColumn term=reverse ctermbg=DarkGrey",
6350 "CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"),
6351 CENT("CursorLine term=underline cterm=underline",
6352 "CursorLine term=underline cterm=underline guibg=Grey40"),
6355 CENT("MatchParen term=reverse ctermbg=DarkCyan",
6356 "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"),
6365 init_highlight(both
, reset
)
6366 int both
; /* include groups where 'bg' doesn't matter */
6367 int reset
; /* clear group first */
6371 static int had_both
= FALSE
;
6376 * Try finding the color scheme file. Used when a color file was loaded
6377 * and 'background' or 't_Co' is changed.
6379 p
= get_var_value((char_u
*)"g:colors_name");
6380 if (p
!= NULL
&& load_colors(p
) == OK
)
6385 * Didn't use a color file, use the compiled-in colors.
6390 pp
= highlight_init_both
;
6391 for (i
= 0; pp
[i
] != NULL
; ++i
)
6392 do_highlight((char_u
*)pp
[i
], reset
, TRUE
);
6395 /* Don't do anything before the call with both == TRUE from main().
6396 * Not everything has been setup then, and that call will overrule
6397 * everything anyway. */
6401 pp
= highlight_init_light
;
6403 pp
= highlight_init_dark
;
6404 for (i
= 0; pp
[i
] != NULL
; ++i
)
6405 do_highlight((char_u
*)pp
[i
], reset
, TRUE
);
6407 /* Reverse looks ugly, but grey may not work for 8 colors. Thus let it
6408 * depend on the number of colors available.
6409 * With 8 colors brown is equal to yellow, need to use black for Search fg
6410 * to avoid Statement highlighted text disappears. */
6412 do_highlight((char_u
*)(*p_bg
== 'l' ? "Visual ctermbg=LightGrey"
6413 : "Visual ctermbg=DarkGrey"), FALSE
, TRUE
);
6416 do_highlight((char_u
*)"Visual cterm=reverse", FALSE
, TRUE
);
6418 do_highlight((char_u
*)"Search ctermfg=black", FALSE
, TRUE
);
6423 * If syntax highlighting is enabled load the highlighting for it.
6425 if (get_var_value((char_u
*)"g:syntax_on") != NULL
)
6427 static int recursive
= 0;
6430 EMSG(_("E679: recursive loop loading syncolor.vim"));
6434 (void)source_runtime((char_u
*)"syntax/syncolor.vim", TRUE
);
6442 * Load color file "name".
6443 * Return OK for success, FAIL for failure.
6451 static int recursive
= FALSE
;
6453 /* When being called recursively, this is probably because setting
6454 * 'background' caused the highlighting to be reloaded. This means it is
6455 * working, thus we should return OK. */
6460 buf
= alloc((unsigned)(STRLEN(name
) + 12));
6463 sprintf((char *)buf
, "colors/%s.vim", name
);
6464 retval
= source_runtime(buf
, FALSE
);
6467 apply_autocmds(EVENT_COLORSCHEME
, NULL
, NULL
, FALSE
, curbuf
);
6476 * Handle the ":highlight .." command.
6477 * When using ":hi clear" this is called recursively for each group with
6478 * "forceit" and "init" both TRUE.
6481 do_highlight(line
, forceit
, init
)
6484 int init
; /* TRUE when called for initializing */
6491 char_u
*key
= NULL
, *arg
= NULL
;
6498 int dodefault
= FALSE
;
6499 int doclear
= FALSE
;
6503 int is_normal_group
= FALSE
; /* "Normal" group */
6505 int is_menu_group
= FALSE
; /* "Menu" group */
6506 int is_scrollbar_group
= FALSE
; /* "Scrollbar" group */
6507 int is_tooltip_group
= FALSE
; /* "Tooltip" group */
6508 int do_colors
= FALSE
; /* need to update colors? */
6510 # define is_menu_group 0
6511 # define is_tooltip_group 0
6515 * If no argument, list current highlighting.
6517 if (ends_excmd(*line
))
6519 for (i
= 1; i
<= highlight_ga
.ga_len
&& !got_int
; ++i
)
6520 /* TODO: only call when the group has attributes set */
6521 highlight_list_one((int)i
);
6528 name_end
= skiptowhite(line
);
6529 linep
= skipwhite(name_end
);
6532 * Check for "default" argument.
6534 if (STRNCMP(line
, "default", name_end
- line
) == 0)
6538 name_end
= skiptowhite(line
);
6539 linep
= skipwhite(name_end
);
6543 * Check for "clear" or "link" argument.
6545 if (STRNCMP(line
, "clear", name_end
- line
) == 0)
6547 if (STRNCMP(line
, "link", name_end
- line
) == 0)
6551 * ":highlight {group-name}": list highlighting for one group.
6553 if (!doclear
&& !dolink
&& ends_excmd(*linep
))
6555 id
= syn_namen2id(line
, (int)(name_end
- line
));
6557 EMSG2(_("E411: highlight group not found: %s"), line
);
6559 highlight_list_one(id
);
6564 * Handle ":highlight link {from} {to}" command.
6568 char_u
*from_start
= linep
;
6575 from_end
= skiptowhite(from_start
);
6576 to_start
= skipwhite(from_end
);
6577 to_end
= skiptowhite(to_start
);
6579 if (ends_excmd(*from_start
) || ends_excmd(*to_start
))
6581 EMSG2(_("E412: Not enough arguments: \":highlight link %s\""),
6586 if (!ends_excmd(*skipwhite(to_end
)))
6588 EMSG2(_("E413: Too many arguments: \":highlight link %s\""), from_start
);
6592 from_id
= syn_check_group(from_start
, (int)(from_end
- from_start
));
6593 if (STRNCMP(to_start
, "NONE", 4) == 0)
6596 to_id
= syn_check_group(to_start
, (int)(to_end
- to_start
));
6598 if (from_id
> 0 && (!init
|| HL_TABLE()[from_id
- 1].sg_set
== 0))
6601 * Don't allow a link when there already is some highlighting
6602 * for the group, unless '!' is used
6604 if (to_id
> 0 && !forceit
&& !init
6605 && hl_has_settings(from_id
- 1, dodefault
))
6607 if (sourcing_name
== NULL
&& !dodefault
)
6608 EMSG(_("E414: group has settings, highlight link ignored"));
6613 HL_TABLE()[from_id
- 1].sg_set
|= SG_LINK
;
6614 HL_TABLE()[from_id
- 1].sg_link
= to_id
;
6616 HL_TABLE()[from_id
- 1].sg_scriptID
= current_SID
;
6618 redraw_all_later(SOME_VALID
);
6622 /* Only call highlight_changed() once, after sourcing a syntax file */
6623 need_highlight_changed
= TRUE
;
6631 * ":highlight clear [group]" command.
6634 if (ends_excmd(*line
))
6637 /* First, we do not destroy the old values, but allocate the new
6638 * ones and update the display. THEN we destroy the old values.
6639 * If we destroy the old values first, then the old values
6640 * (such as GuiFont's or GuiFontset's) will still be displayed but
6641 * invalid because they were free'd.
6645 # ifdef FEAT_BEVAL_TIP
6646 gui_init_tooltip_font();
6648 # if defined(FEAT_MENU) && (defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MOTIF))
6649 gui_init_menu_font();
6652 # if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11)
6653 gui_mch_def_colors();
6655 # ifdef FEAT_GUI_X11
6658 /* This only needs to be done when there is no Menu highlight
6659 * group defined by default, which IS currently the case.
6661 gui_mch_new_menu_colors();
6665 gui_new_scrollbar_colors();
6667 gui_mch_new_tooltip_colors();
6670 gui_mch_new_menu_font();
6675 /* Ok, we're done allocating the new default graphics items.
6676 * The screen should already be refreshed at this point.
6677 * It is now Ok to clear out the old data.
6681 do_unlet((char_u
*)"colors_name", TRUE
);
6683 restore_cterm_colors();
6686 * Clear all default highlight groups and load the defaults.
6688 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
6689 highlight_clear(idx
);
6690 init_highlight(TRUE
, TRUE
);
6693 highlight_gui_started();
6695 highlight_changed();
6696 redraw_later_clear();
6699 name_end
= skiptowhite(line
);
6700 linep
= skipwhite(name_end
);
6704 * Find the group name in the table. If it does not exist yet, add it.
6706 id
= syn_check_group(line
, (int)(name_end
- line
));
6707 if (id
== 0) /* failed (out of memory) */
6709 idx
= id
- 1; /* index is ID minus one */
6711 /* Return if "default" was used and the group already has settings. */
6712 if (dodefault
&& hl_has_settings(idx
, TRUE
))
6715 if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "NORMAL") == 0)
6716 is_normal_group
= TRUE
;
6718 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "MENU") == 0)
6719 is_menu_group
= TRUE
;
6720 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "SCROLLBAR") == 0)
6721 is_scrollbar_group
= TRUE
;
6722 else if (STRCMP(HL_TABLE()[idx
].sg_name_u
, "TOOLTIP") == 0)
6723 is_tooltip_group
= TRUE
;
6726 /* Clear the highlighting for ":hi clear {group}" and ":hi clear". */
6727 if (doclear
|| (forceit
&& init
))
6729 highlight_clear(idx
);
6731 HL_TABLE()[idx
].sg_set
= 0;
6735 while (!ends_excmd(*linep
))
6740 EMSG2(_("E415: unexpected equal sign: %s"), key_start
);
6746 * Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" or
6749 while (*linep
&& !vim_iswhite(*linep
) && *linep
!= '=')
6752 key
= vim_strnsave_up(key_start
, (int)(linep
- key_start
));
6758 linep
= skipwhite(linep
);
6760 if (STRCMP(key
, "NONE") == 0)
6762 if (!init
|| HL_TABLE()[idx
].sg_set
== 0)
6765 HL_TABLE()[idx
].sg_set
|= SG_TERM
+SG_CTERM
+SG_GUI
;
6766 highlight_clear(idx
);
6772 * Check for the equal sign.
6776 EMSG2(_("E416: missing equal sign: %s"), key_start
);
6783 * Isolate the argument.
6785 linep
= skipwhite(linep
);
6786 if (*linep
== '\'') /* guifg='color name' */
6788 arg_start
= ++linep
;
6789 linep
= vim_strchr(linep
, '\'');
6792 EMSG2(_(e_invarg2
), key_start
);
6800 linep
= skiptowhite(linep
);
6802 if (linep
== arg_start
)
6804 EMSG2(_("E417: missing argument: %s"), key_start
);
6809 arg
= vim_strnsave(arg_start
, (int)(linep
- arg_start
));
6819 * Store the argument.
6821 if ( STRCMP(key
, "TERM") == 0
6822 || STRCMP(key
, "CTERM") == 0
6823 || STRCMP(key
, "GUI") == 0)
6827 while (arg
[off
] != NUL
)
6829 for (i
= sizeof(hl_attr_table
) / sizeof(int); --i
>= 0; )
6831 len
= (int)STRLEN(hl_name_table
[i
]);
6832 if (STRNICMP(arg
+ off
, hl_name_table
[i
], len
) == 0)
6834 attr
|= hl_attr_table
[i
];
6841 EMSG2(_("E418: Illegal value: %s"), arg
);
6845 if (arg
[off
] == ',') /* another one follows */
6852 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_TERM
))
6855 HL_TABLE()[idx
].sg_set
|= SG_TERM
;
6856 HL_TABLE()[idx
].sg_term
= attr
;
6859 else if (*key
== 'C')
6861 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_CTERM
))
6864 HL_TABLE()[idx
].sg_set
|= SG_CTERM
;
6865 HL_TABLE()[idx
].sg_cterm
= attr
;
6866 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
6872 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
6875 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
6876 HL_TABLE()[idx
].sg_gui
= attr
;
6881 else if (STRCMP(key
, "FONT") == 0)
6883 /* in non-GUI fonts are simply ignored */
6885 if (!gui
.shell_created
)
6887 /* GUI not started yet, always accept the name. */
6888 vim_free(HL_TABLE()[idx
].sg_font_name
);
6889 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6893 GuiFont temp_sg_font
= HL_TABLE()[idx
].sg_font
;
6894 # ifdef FEAT_XFONTSET
6895 GuiFontset temp_sg_fontset
= HL_TABLE()[idx
].sg_fontset
;
6897 /* First, save the current font/fontset.
6898 * Then try to allocate the font/fontset.
6899 * If the allocation fails, HL_TABLE()[idx].sg_font OR
6900 * sg_fontset will be set to NOFONT or NOFONTSET respectively.
6903 HL_TABLE()[idx
].sg_font
= NOFONT
;
6904 # ifdef FEAT_XFONTSET
6905 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
6907 hl_do_font(idx
, arg
, is_normal_group
, is_menu_group
,
6910 # ifdef FEAT_XFONTSET
6911 if (HL_TABLE()[idx
].sg_fontset
!= NOFONTSET
)
6913 /* New fontset was accepted. Free the old one, if there was
6916 gui_mch_free_fontset(temp_sg_fontset
);
6917 vim_free(HL_TABLE()[idx
].sg_font_name
);
6918 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6921 HL_TABLE()[idx
].sg_fontset
= temp_sg_fontset
;
6923 if (HL_TABLE()[idx
].sg_font
!= NOFONT
)
6925 /* New font was accepted. Free the old one, if there was
6928 gui_mch_free_font(temp_sg_font
);
6929 vim_free(HL_TABLE()[idx
].sg_font_name
);
6930 HL_TABLE()[idx
].sg_font_name
= vim_strsave(arg
);
6933 HL_TABLE()[idx
].sg_font
= temp_sg_font
;
6937 else if (STRCMP(key
, "CTERMFG") == 0 || STRCMP(key
, "CTERMBG") == 0)
6939 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_CTERM
))
6942 HL_TABLE()[idx
].sg_set
|= SG_CTERM
;
6944 /* When setting the foreground color, and previously the "bold"
6945 * flag was set for a light color, reset it now */
6946 if (key
[5] == 'F' && HL_TABLE()[idx
].sg_cterm_bold
)
6948 HL_TABLE()[idx
].sg_cterm
&= ~HL_BOLD
;
6949 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
6952 if (VIM_ISDIGIT(*arg
))
6953 color
= atoi((char *)arg
);
6954 else if (STRICMP(arg
, "fg") == 0)
6956 if (cterm_normal_fg_color
)
6957 color
= cterm_normal_fg_color
- 1;
6960 EMSG(_("E419: FG color unknown"));
6965 else if (STRICMP(arg
, "bg") == 0)
6967 if (cterm_normal_bg_color
> 0)
6968 color
= cterm_normal_bg_color
- 1;
6971 EMSG(_("E420: BG color unknown"));
6978 static char *(color_names
[28]) = {
6979 "Black", "DarkBlue", "DarkGreen", "DarkCyan",
6980 "DarkRed", "DarkMagenta", "Brown", "DarkYellow",
6982 "LightGray", "LightGrey", "DarkGray", "DarkGrey",
6983 "Blue", "LightBlue", "Green", "LightGreen",
6984 "Cyan", "LightCyan", "Red", "LightRed", "Magenta",
6985 "LightMagenta", "Yellow", "LightYellow", "White", "NONE"};
6986 static int color_numbers_16
[28] = {0, 1, 2, 3,
6992 13, 14, 14, 15, -1};
6993 /* for xterm with 88 colors... */
6994 static int color_numbers_88
[28] = {0, 4, 2, 6,
7000 75, 11, 78, 15, -1};
7001 /* for xterm with 256 colors... */
7002 static int color_numbers_256
[28] = {0, 4, 2, 6,
7007 14, 159, 9, 224, 13,
7008 225, 11, 229, 15, -1};
7009 /* for terminals with less than 16 colors... */
7010 static int color_numbers_8
[28] = {0, 4, 2, 6,
7015 6+8, 6+8, 1+8, 1+8, 5+8,
7016 5+8, 3+8, 3+8, 7+8, -1};
7017 #if defined(__QNXNTO__)
7018 static int *color_numbers_8_qansi
= color_numbers_8
;
7019 /* On qnx, the 8 & 16 color arrays are the same */
7020 if (STRNCMP(T_NAME
, "qansi", 5) == 0)
7021 color_numbers_8_qansi
= color_numbers_16
;
7024 /* reduce calls to STRICMP a bit, it can be slow */
7025 off
= TOUPPER_ASC(*arg
);
7026 for (i
= (sizeof(color_names
) / sizeof(char *)); --i
>= 0; )
7027 if (off
== color_names
[i
][0]
7028 && STRICMP(arg
+ 1, color_names
[i
] + 1) == 0)
7032 EMSG2(_("E421: Color name or number not recognized: %s"), key_start
);
7037 /* Use the _16 table to check if its a valid color name. */
7038 color
= color_numbers_16
[i
];
7043 /* t_Co is 8: use the 8 colors table */
7044 #if defined(__QNXNTO__)
7045 color
= color_numbers_8_qansi
[i
];
7047 color
= color_numbers_8
[i
];
7051 /* set/reset bold attribute to get light foreground
7052 * colors (on some terminals, e.g. "linux") */
7055 HL_TABLE()[idx
].sg_cterm
|= HL_BOLD
;
7056 HL_TABLE()[idx
].sg_cterm_bold
= TRUE
;
7059 HL_TABLE()[idx
].sg_cterm
&= ~HL_BOLD
;
7061 color
&= 7; /* truncate to 8 colors */
7063 else if (t_colors
== 16 || t_colors
== 88
7067 * Guess: if the termcap entry ends in 'm', it is
7068 * probably an xterm-like terminal. Use the changed
7075 if (*p
!= NUL
&& *(p
+ STRLEN(p
) - 1) == 'm')
7079 color
= color_numbers_8
[i
];
7082 color
= color_numbers_88
[i
];
7085 color
= color_numbers_256
[i
];
7091 /* Add one to the argument, to avoid zero */
7094 HL_TABLE()[idx
].sg_cterm_fg
= color
+ 1;
7095 if (is_normal_group
)
7097 cterm_normal_fg_color
= color
+ 1;
7098 cterm_normal_fg_bold
= (HL_TABLE()[idx
].sg_cterm
& HL_BOLD
);
7100 /* Don't do this if the GUI is used. */
7101 if (!gui
.in_use
&& !gui
.starting
)
7104 must_redraw
= CLEAR
;
7106 term_fg_color(color
);
7112 HL_TABLE()[idx
].sg_cterm_bg
= color
+ 1;
7113 if (is_normal_group
)
7115 cterm_normal_bg_color
= color
+ 1;
7117 /* Don't mess with 'background' if the GUI is used. */
7118 if (!gui
.in_use
&& !gui
.starting
)
7121 must_redraw
= CLEAR
;
7123 term_bg_color(color
);
7125 i
= (color
== 0 || color
== 4);
7127 i
= (color
< 7 || color
== 8);
7128 /* Set the 'background' option if the value is wrong. */
7129 if (i
!= (*p_bg
== 'd'))
7130 set_option_value((char_u
*)"bg", 0L,
7131 i
? (char_u
*)"dark" : (char_u
*)"light", 0);
7137 else if (STRCMP(key
, "GUIFG") == 0)
7139 #ifdef FEAT_GUI /* in non-GUI guifg colors are simply ignored */
7140 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7143 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7145 i
= color_name2handle(arg
);
7146 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7148 HL_TABLE()[idx
].sg_gui_fg
= i
;
7149 vim_free(HL_TABLE()[idx
].sg_gui_fg_name
);
7150 if (STRCMP(arg
, "NONE"))
7151 HL_TABLE()[idx
].sg_gui_fg_name
= vim_strsave(arg
);
7153 HL_TABLE()[idx
].sg_gui_fg_name
= NULL
;
7154 # ifdef FEAT_GUI_X11
7156 gui
.menu_fg_pixel
= i
;
7157 if (is_scrollbar_group
)
7158 gui
.scroll_fg_pixel
= i
;
7160 if (is_tooltip_group
)
7161 gui
.tooltip_fg_pixel
= i
;
7169 else if (STRCMP(key
, "GUIBG") == 0)
7171 #ifdef FEAT_GUI /* in non-GUI guibg colors are simply ignored */
7172 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7175 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7177 i
= color_name2handle(arg
);
7178 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7180 HL_TABLE()[idx
].sg_gui_bg
= i
;
7181 vim_free(HL_TABLE()[idx
].sg_gui_bg_name
);
7182 if (STRCMP(arg
, "NONE") != 0)
7183 HL_TABLE()[idx
].sg_gui_bg_name
= vim_strsave(arg
);
7185 HL_TABLE()[idx
].sg_gui_bg_name
= NULL
;
7186 # ifdef FEAT_GUI_X11
7188 gui
.menu_bg_pixel
= i
;
7189 if (is_scrollbar_group
)
7190 gui
.scroll_bg_pixel
= i
;
7192 if (is_tooltip_group
)
7193 gui
.tooltip_bg_pixel
= i
;
7201 else if (STRCMP(key
, "GUISP") == 0)
7203 #ifdef FEAT_GUI /* in non-GUI guisp colors are simply ignored */
7204 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_GUI
))
7207 HL_TABLE()[idx
].sg_set
|= SG_GUI
;
7209 i
= color_name2handle(arg
);
7210 if (i
!= INVALCOLOR
|| STRCMP(arg
, "NONE") == 0 || !gui
.in_use
)
7212 HL_TABLE()[idx
].sg_gui_sp
= i
;
7213 vim_free(HL_TABLE()[idx
].sg_gui_sp_name
);
7214 if (STRCMP(arg
, "NONE") != 0)
7215 HL_TABLE()[idx
].sg_gui_sp_name
= vim_strsave(arg
);
7217 HL_TABLE()[idx
].sg_gui_sp_name
= NULL
;
7222 else if (STRCMP(key
, "START") == 0 || STRCMP(key
, "STOP") == 0)
7228 HL_TABLE()[idx
].sg_set
|= SG_TERM
;
7231 * The "start" and "stop" arguments can be a literal escape
7232 * sequence, or a comma separated list of terminal codes.
7234 if (STRNCMP(arg
, "t_", 2) == 0)
7238 while (arg
[off
] != NUL
)
7240 /* Isolate one termcap name */
7241 for (len
= 0; arg
[off
+ len
] &&
7242 arg
[off
+ len
] != ','; ++len
)
7244 tname
= vim_strnsave(arg
+ off
, len
);
7245 if (tname
== NULL
) /* out of memory */
7250 /* lookup the escape sequence for the item */
7251 p
= get_term_code(tname
);
7253 if (p
== NULL
) /* ignore non-existing things */
7256 /* Append it to the already found stuff */
7257 if ((int)(STRLEN(buf
) + STRLEN(p
)) >= 99)
7259 EMSG2(_("E422: terminal code too long: %s"), arg
);
7265 /* Advance to the next item */
7267 if (arg
[off
] == ',') /* another one follows */
7274 * Copy characters from arg[] to buf[], translating <> codes.
7276 for (p
= arg
, off
= 0; off
< 100 && *p
; )
7278 len
= trans_special(&p
, buf
+ off
, FALSE
);
7279 if (len
) /* recognized special char */
7281 else /* copy as normal char */
7289 if (STRCMP(buf
, "NONE") == 0) /* resetting the value */
7292 p
= vim_strsave(buf
);
7295 vim_free(HL_TABLE()[idx
].sg_start
);
7296 HL_TABLE()[idx
].sg_start
= p
;
7300 vim_free(HL_TABLE()[idx
].sg_stop
);
7301 HL_TABLE()[idx
].sg_stop
= p
;
7306 EMSG2(_("E423: Illegal argument: %s"), key_start
);
7312 * When highlighting has been given for a group, don't link it.
7314 if (!init
|| !(HL_TABLE()[idx
].sg_set
& SG_LINK
))
7315 HL_TABLE()[idx
].sg_link
= 0;
7318 * Continue with next argument.
7320 linep
= skipwhite(linep
);
7324 * If there is an error, and it's a new entry, remove it from the table.
7326 if (error
&& idx
== highlight_ga
.ga_len
)
7330 if (is_normal_group
)
7332 HL_TABLE()[idx
].sg_term_attr
= 0;
7333 HL_TABLE()[idx
].sg_cterm_attr
= 0;
7335 HL_TABLE()[idx
].sg_gui_attr
= 0;
7337 * Need to update all groups, because they might be using "bg"
7338 * and/or "fg", which have been changed now.
7341 highlight_gui_started();
7346 else if (is_menu_group
)
7348 if (gui
.in_use
&& do_colors
)
7349 gui_mch_new_menu_colors();
7352 else if (is_scrollbar_group
)
7354 if (gui
.in_use
&& do_colors
)
7355 gui_new_scrollbar_colors();
7358 else if (is_tooltip_group
)
7360 if (gui
.in_use
&& do_colors
)
7361 gui_mch_new_tooltip_colors();
7368 HL_TABLE()[idx
].sg_scriptID
= current_SID
;
7370 redraw_all_later(NOT_VALID
);
7375 /* Only call highlight_changed() once, after sourcing a syntax file */
7376 need_highlight_changed
= TRUE
;
7379 #if defined(EXITFREE) || defined(PROTO)
7385 for (i
= 0; i
< highlight_ga
.ga_len
; ++i
)
7388 vim_free(HL_TABLE()[i
].sg_name
);
7389 vim_free(HL_TABLE()[i
].sg_name_u
);
7391 ga_clear(&highlight_ga
);
7396 * Reset the cterm colors to what they were before Vim was started, if
7397 * possible. Otherwise reset them to zero.
7400 restore_cterm_colors()
7402 #if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32))
7403 /* Since t_me has been set, this probably means that the user
7404 * wants to use this as default colors. Need to reset default
7405 * background/foreground colors. */
7406 mch_set_normal_colors();
7408 cterm_normal_fg_color
= 0;
7409 cterm_normal_fg_bold
= 0;
7410 cterm_normal_bg_color
= 0;
7415 * Return TRUE if highlight group "idx" has any settings.
7416 * When "check_link" is TRUE also check for an existing link.
7419 hl_has_settings(idx
, check_link
)
7423 return ( HL_TABLE()[idx
].sg_term_attr
!= 0
7424 || HL_TABLE()[idx
].sg_cterm_attr
!= 0
7426 || HL_TABLE()[idx
].sg_gui_attr
!= 0
7428 || (check_link
&& (HL_TABLE()[idx
].sg_set
& SG_LINK
)));
7432 * Clear highlighting for one group.
7435 highlight_clear(idx
)
7438 HL_TABLE()[idx
].sg_term
= 0;
7439 vim_free(HL_TABLE()[idx
].sg_start
);
7440 HL_TABLE()[idx
].sg_start
= NULL
;
7441 vim_free(HL_TABLE()[idx
].sg_stop
);
7442 HL_TABLE()[idx
].sg_stop
= NULL
;
7443 HL_TABLE()[idx
].sg_term_attr
= 0;
7444 HL_TABLE()[idx
].sg_cterm
= 0;
7445 HL_TABLE()[idx
].sg_cterm_bold
= FALSE
;
7446 HL_TABLE()[idx
].sg_cterm_fg
= 0;
7447 HL_TABLE()[idx
].sg_cterm_bg
= 0;
7448 HL_TABLE()[idx
].sg_cterm_attr
= 0;
7449 #ifdef FEAT_GUI /* in non-GUI fonts are simply ignored */
7450 HL_TABLE()[idx
].sg_gui
= 0;
7451 HL_TABLE()[idx
].sg_gui_fg
= INVALCOLOR
;
7452 vim_free(HL_TABLE()[idx
].sg_gui_fg_name
);
7453 HL_TABLE()[idx
].sg_gui_fg_name
= NULL
;
7454 HL_TABLE()[idx
].sg_gui_bg
= INVALCOLOR
;
7455 vim_free(HL_TABLE()[idx
].sg_gui_bg_name
);
7456 HL_TABLE()[idx
].sg_gui_bg_name
= NULL
;
7457 HL_TABLE()[idx
].sg_gui_sp
= INVALCOLOR
;
7458 vim_free(HL_TABLE()[idx
].sg_gui_sp_name
);
7459 HL_TABLE()[idx
].sg_gui_sp_name
= NULL
;
7460 gui_mch_free_font(HL_TABLE()[idx
].sg_font
);
7461 HL_TABLE()[idx
].sg_font
= NOFONT
;
7462 # ifdef FEAT_XFONTSET
7463 gui_mch_free_fontset(HL_TABLE()[idx
].sg_fontset
);
7464 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
7466 vim_free(HL_TABLE()[idx
].sg_font_name
);
7467 HL_TABLE()[idx
].sg_font_name
= NULL
;
7468 HL_TABLE()[idx
].sg_gui_attr
= 0;
7471 /* Clear the script ID only when there is no link, since that is not
7473 if (HL_TABLE()[idx
].sg_link
== 0)
7474 HL_TABLE()[idx
].sg_scriptID
= 0;
7478 #if defined(FEAT_GUI) || defined(PROTO)
7480 * Set the normal foreground and background colors according to the "Normal"
7481 * highlighighting group. For X11 also set "Menu", "Scrollbar", and
7487 if (set_group_colors((char_u
*)"Normal",
7488 &gui
.norm_pixel
, &gui
.back_pixel
,
7489 FALSE
, TRUE
, FALSE
))
7491 gui_mch_new_colors();
7492 must_redraw
= CLEAR
;
7495 if (set_group_colors((char_u
*)"Menu",
7496 &gui
.menu_fg_pixel
, &gui
.menu_bg_pixel
,
7497 TRUE
, FALSE
, FALSE
))
7500 gui_mch_new_menu_colors();
7502 must_redraw
= CLEAR
;
7505 if (set_group_colors((char_u
*)"Tooltip",
7506 &gui
.tooltip_fg_pixel
, &gui
.tooltip_bg_pixel
,
7507 FALSE
, FALSE
, TRUE
))
7509 # ifdef FEAT_TOOLBAR
7510 gui_mch_new_tooltip_colors();
7512 must_redraw
= CLEAR
;
7515 if (set_group_colors((char_u
*)"Scrollbar",
7516 &gui
.scroll_fg_pixel
, &gui
.scroll_bg_pixel
,
7517 FALSE
, FALSE
, FALSE
))
7519 gui_new_scrollbar_colors();
7520 must_redraw
= CLEAR
;
7526 * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
7529 set_group_colors(name
, fgp
, bgp
, do_menu
, use_norm
, do_tooltip
)
7539 idx
= syn_name2id(name
) - 1;
7542 gui_do_one_color(idx
, do_menu
, do_tooltip
);
7544 if (HL_TABLE()[idx
].sg_gui_fg
!= INVALCOLOR
)
7545 *fgp
= HL_TABLE()[idx
].sg_gui_fg
;
7547 *fgp
= gui
.def_norm_pixel
;
7548 if (HL_TABLE()[idx
].sg_gui_bg
!= INVALCOLOR
)
7549 *bgp
= HL_TABLE()[idx
].sg_gui_bg
;
7551 *bgp
= gui
.def_back_pixel
;
7558 * Get the font of the "Normal" group.
7559 * Returns "" when it's not found or not set.
7567 id
= syn_name2id((char_u
*)"Normal");
7570 s
= HL_TABLE()[id
- 1].sg_font_name
;
7574 return (char_u
*)"";
7578 * Set font for "Normal" group. Called by gui_mch_init_font() when a font has
7579 * actually chosen to be used.
7582 hl_set_font_name(font_name
)
7587 id
= syn_name2id((char_u
*)"Normal");
7590 vim_free(HL_TABLE()[id
- 1].sg_font_name
);
7591 HL_TABLE()[id
- 1].sg_font_name
= vim_strsave(font_name
);
7596 * Set background color for "Normal" group. Called by gui_set_bg_color()
7597 * when the color is known.
7600 hl_set_bg_color_name(name
)
7601 char_u
*name
; /* must have been allocated */
7607 id
= syn_name2id((char_u
*)"Normal");
7610 vim_free(HL_TABLE()[id
- 1].sg_gui_bg_name
);
7611 HL_TABLE()[id
- 1].sg_gui_bg_name
= name
;
7617 * Set foreground color for "Normal" group. Called by gui_set_fg_color()
7618 * when the color is known.
7621 hl_set_fg_color_name(name
)
7622 char_u
*name
; /* must have been allocated */
7628 id
= syn_name2id((char_u
*)"Normal");
7631 vim_free(HL_TABLE()[id
- 1].sg_gui_fg_name
);
7632 HL_TABLE()[id
- 1].sg_gui_fg_name
= name
;
7638 * Return the handle for a color name.
7639 * Returns INVALCOLOR when failed.
7642 color_name2handle(name
)
7645 if (STRCMP(name
, "NONE") == 0)
7648 if (STRICMP(name
, "fg") == 0 || STRICMP(name
, "foreground") == 0)
7649 return gui
.norm_pixel
;
7650 if (STRICMP(name
, "bg") == 0 || STRICMP(name
, "background") == 0)
7651 return gui
.back_pixel
;
7653 return gui_get_color(name
);
7657 * Return the handle for a font name.
7658 * Returns NOFONT when failed.
7661 font_name2handle(name
)
7664 if (STRCMP(name
, "NONE") == 0)
7667 return gui_mch_get_font(name
, TRUE
);
7670 # ifdef FEAT_XFONTSET
7672 * Return the handle for a fontset name.
7673 * Returns NOFONTSET when failed.
7676 fontset_name2handle(name
, fixed_width
)
7680 if (STRCMP(name
, "NONE") == 0)
7683 return gui_mch_get_fontset(name
, TRUE
, fixed_width
);
7688 * Get the font or fontset for one highlight group.
7692 hl_do_font(idx
, arg
, do_normal
, do_menu
, do_tooltip
)
7695 int do_normal
; /* set normal font */
7696 int do_menu
; /* set menu font */
7697 int do_tooltip
; /* set tooltip font */
7699 # ifdef FEAT_XFONTSET
7700 /* If 'guifontset' is not empty, first try using the name as a
7701 * fontset. If that doesn't work, use it as a font name. */
7702 if (*p_guifontset
!= NUL
7703 # ifdef FONTSET_ALWAYS
7706 # ifdef FEAT_BEVAL_TIP
7707 /* In Athena & Motif, the Tooltip highlight group is always a fontset */
7711 HL_TABLE()[idx
].sg_fontset
= fontset_name2handle(arg
, 0
7712 # ifdef FONTSET_ALWAYS
7715 # ifdef FEAT_BEVAL_TIP
7719 if (HL_TABLE()[idx
].sg_fontset
!= NOFONTSET
)
7721 /* If it worked and it's the Normal group, use it as the
7722 * normal fontset. Same for the Menu group. */
7724 gui_init_font(arg
, TRUE
);
7725 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7728 # ifdef FONTSET_ALWAYS
7729 gui
.menu_fontset
= HL_TABLE()[idx
].sg_fontset
;
7731 /* YIKES! This is a bug waiting to crash the program */
7732 gui
.menu_font
= HL_TABLE()[idx
].sg_fontset
;
7734 gui_mch_new_menu_font();
7739 /* The Athena widget set cannot currently handle switching between
7740 * displaying a single font and a fontset.
7741 * If the XtNinternational resource is set to True at widget
7742 * creation, then a fontset is always used, otherwise an
7743 * XFontStruct is used.
7745 gui
.tooltip_fontset
= (XFontSet
)HL_TABLE()[idx
].sg_fontset
;
7746 gui_mch_new_tooltip_font();
7754 HL_TABLE()[idx
].sg_font
= font_name2handle(arg
);
7755 /* If it worked and it's the Normal group, use it as the
7756 * normal font. Same for the Menu group. */
7757 if (HL_TABLE()[idx
].sg_font
!= NOFONT
)
7760 gui_init_font(arg
, FALSE
);
7761 #ifndef FONTSET_ALWAYS
7762 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7765 gui
.menu_font
= HL_TABLE()[idx
].sg_font
;
7766 gui_mch_new_menu_font();
7774 #endif /* FEAT_GUI */
7777 * Table with the specifications for an attribute number.
7778 * Note that this table is used by ALL buffers. This is required because the
7779 * GUI can redraw at any time for any buffer.
7781 static garray_T term_attr_table
= {0, 0, 0, 0, NULL
};
7783 #define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx]
7785 static garray_T cterm_attr_table
= {0, 0, 0, 0, NULL
};
7787 #define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx]
7790 static garray_T gui_attr_table
= {0, 0, 0, 0, NULL
};
7792 #define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx]
7796 * Return the attr number for a set of colors and font.
7797 * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
7798 * if the combination is new.
7799 * Return 0 for error (no more room).
7802 get_attr_entry(table
, aep
)
7808 static int recursive
= FALSE
;
7811 * Init the table, in case it wasn't done yet.
7813 table
->ga_itemsize
= sizeof(attrentry_T
);
7814 table
->ga_growsize
= 7;
7817 * Try to find an entry with the same specifications.
7819 for (i
= 0; i
< table
->ga_len
; ++i
)
7821 taep
= &(((attrentry_T
*)table
->ga_data
)[i
]);
7822 if ( aep
->ae_attr
== taep
->ae_attr
7825 (table
== &gui_attr_table
7826 && (aep
->ae_u
.gui
.fg_color
== taep
->ae_u
.gui
.fg_color
7827 && aep
->ae_u
.gui
.bg_color
7828 == taep
->ae_u
.gui
.bg_color
7829 && aep
->ae_u
.gui
.sp_color
7830 == taep
->ae_u
.gui
.sp_color
7831 && aep
->ae_u
.gui
.font
== taep
->ae_u
.gui
.font
7832 # ifdef FEAT_XFONTSET
7833 && aep
->ae_u
.gui
.fontset
== taep
->ae_u
.gui
.fontset
7838 (table
== &term_attr_table
7839 && (aep
->ae_u
.term
.start
== NULL
)
7840 == (taep
->ae_u
.term
.start
== NULL
)
7841 && (aep
->ae_u
.term
.start
== NULL
7842 || STRCMP(aep
->ae_u
.term
.start
,
7843 taep
->ae_u
.term
.start
) == 0)
7844 && (aep
->ae_u
.term
.stop
== NULL
)
7845 == (taep
->ae_u
.term
.stop
== NULL
)
7846 && (aep
->ae_u
.term
.stop
== NULL
7847 || STRCMP(aep
->ae_u
.term
.stop
,
7848 taep
->ae_u
.term
.stop
) == 0))
7849 || (table
== &cterm_attr_table
7850 && aep
->ae_u
.cterm
.fg_color
7851 == taep
->ae_u
.cterm
.fg_color
7852 && aep
->ae_u
.cterm
.bg_color
7853 == taep
->ae_u
.cterm
.bg_color
)
7856 return i
+ ATTR_OFF
;
7859 if (table
->ga_len
+ ATTR_OFF
> MAX_TYPENR
)
7862 * Running out of attribute entries! remove all attributes, and
7863 * compute new ones for all groups.
7864 * When called recursively, we are really out of numbers.
7868 EMSG(_("E424: Too many different highlighting attributes in use"));
7875 must_redraw
= CLEAR
;
7877 for (i
= 0; i
< highlight_ga
.ga_len
; ++i
)
7884 * This is a new combination of colors and font, add an entry.
7886 if (ga_grow(table
, 1) == FAIL
)
7889 taep
= &(((attrentry_T
*)table
->ga_data
)[table
->ga_len
]);
7890 vim_memset(taep
, 0, sizeof(attrentry_T
));
7891 taep
->ae_attr
= aep
->ae_attr
;
7893 if (table
== &gui_attr_table
)
7895 taep
->ae_u
.gui
.fg_color
= aep
->ae_u
.gui
.fg_color
;
7896 taep
->ae_u
.gui
.bg_color
= aep
->ae_u
.gui
.bg_color
;
7897 taep
->ae_u
.gui
.sp_color
= aep
->ae_u
.gui
.sp_color
;
7898 taep
->ae_u
.gui
.font
= aep
->ae_u
.gui
.font
;
7899 # ifdef FEAT_XFONTSET
7900 taep
->ae_u
.gui
.fontset
= aep
->ae_u
.gui
.fontset
;
7904 if (table
== &term_attr_table
)
7906 if (aep
->ae_u
.term
.start
== NULL
)
7907 taep
->ae_u
.term
.start
= NULL
;
7909 taep
->ae_u
.term
.start
= vim_strsave(aep
->ae_u
.term
.start
);
7910 if (aep
->ae_u
.term
.stop
== NULL
)
7911 taep
->ae_u
.term
.stop
= NULL
;
7913 taep
->ae_u
.term
.stop
= vim_strsave(aep
->ae_u
.term
.stop
);
7915 else if (table
== &cterm_attr_table
)
7917 taep
->ae_u
.cterm
.fg_color
= aep
->ae_u
.cterm
.fg_color
;
7918 taep
->ae_u
.cterm
.bg_color
= aep
->ae_u
.cterm
.bg_color
;
7921 return (table
->ga_len
- 1 + ATTR_OFF
);
7925 * Clear all highlight tables.
7934 ga_clear(&gui_attr_table
);
7936 for (i
= 0; i
< term_attr_table
.ga_len
; ++i
)
7938 taep
= &(((attrentry_T
*)term_attr_table
.ga_data
)[i
]);
7939 vim_free(taep
->ae_u
.term
.start
);
7940 vim_free(taep
->ae_u
.term
.stop
);
7942 ga_clear(&term_attr_table
);
7943 ga_clear(&cterm_attr_table
);
7946 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO)
7948 * Combine special attributes (e.g., for spelling) with other attributes
7949 * (e.g., for syntax highlighting).
7950 * "prim_attr" overrules "char_attr".
7951 * This creates a new group when required.
7952 * Since we expect there to be few spelling mistakes we don't cache the
7954 * Return the resulting attributes.
7957 hl_combine_attr(char_attr
, prim_attr
)
7961 attrentry_T
*char_aep
= NULL
;
7962 attrentry_T
*spell_aep
;
7967 if (char_attr
<= HL_ALL
&& prim_attr
<= HL_ALL
)
7968 return char_attr
| prim_attr
;
7972 if (char_attr
> HL_ALL
)
7973 char_aep
= syn_gui_attr2entry(char_attr
);
7974 if (char_aep
!= NULL
)
7978 vim_memset(&new_en
, 0, sizeof(new_en
));
7979 new_en
.ae_u
.gui
.fg_color
= INVALCOLOR
;
7980 new_en
.ae_u
.gui
.bg_color
= INVALCOLOR
;
7981 new_en
.ae_u
.gui
.sp_color
= INVALCOLOR
;
7982 if (char_attr
<= HL_ALL
)
7983 new_en
.ae_attr
= char_attr
;
7986 if (prim_attr
<= HL_ALL
)
7987 new_en
.ae_attr
|= prim_attr
;
7990 spell_aep
= syn_gui_attr2entry(prim_attr
);
7991 if (spell_aep
!= NULL
)
7993 new_en
.ae_attr
|= spell_aep
->ae_attr
;
7994 if (spell_aep
->ae_u
.gui
.fg_color
!= INVALCOLOR
)
7995 new_en
.ae_u
.gui
.fg_color
= spell_aep
->ae_u
.gui
.fg_color
;
7996 if (spell_aep
->ae_u
.gui
.bg_color
!= INVALCOLOR
)
7997 new_en
.ae_u
.gui
.bg_color
= spell_aep
->ae_u
.gui
.bg_color
;
7998 if (spell_aep
->ae_u
.gui
.sp_color
!= INVALCOLOR
)
7999 new_en
.ae_u
.gui
.sp_color
= spell_aep
->ae_u
.gui
.sp_color
;
8000 if (spell_aep
->ae_u
.gui
.font
!= NOFONT
)
8001 new_en
.ae_u
.gui
.font
= spell_aep
->ae_u
.gui
.font
;
8002 # ifdef FEAT_XFONTSET
8003 if (spell_aep
->ae_u
.gui
.fontset
!= NOFONTSET
)
8004 new_en
.ae_u
.gui
.fontset
= spell_aep
->ae_u
.gui
.fontset
;
8008 return get_attr_entry(&gui_attr_table
, &new_en
);
8014 if (char_attr
> HL_ALL
)
8015 char_aep
= syn_cterm_attr2entry(char_attr
);
8016 if (char_aep
!= NULL
)
8020 vim_memset(&new_en
, 0, sizeof(new_en
));
8021 if (char_attr
<= HL_ALL
)
8022 new_en
.ae_attr
= char_attr
;
8025 if (prim_attr
<= HL_ALL
)
8026 new_en
.ae_attr
|= prim_attr
;
8029 spell_aep
= syn_cterm_attr2entry(prim_attr
);
8030 if (spell_aep
!= NULL
)
8032 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8033 if (spell_aep
->ae_u
.cterm
.fg_color
> 0)
8034 new_en
.ae_u
.cterm
.fg_color
= spell_aep
->ae_u
.cterm
.fg_color
;
8035 if (spell_aep
->ae_u
.cterm
.bg_color
> 0)
8036 new_en
.ae_u
.cterm
.bg_color
= spell_aep
->ae_u
.cterm
.bg_color
;
8039 return get_attr_entry(&cterm_attr_table
, &new_en
);
8042 if (char_attr
> HL_ALL
)
8043 char_aep
= syn_term_attr2entry(char_attr
);
8044 if (char_aep
!= NULL
)
8048 vim_memset(&new_en
, 0, sizeof(new_en
));
8049 if (char_attr
<= HL_ALL
)
8050 new_en
.ae_attr
= char_attr
;
8053 if (prim_attr
<= HL_ALL
)
8054 new_en
.ae_attr
|= prim_attr
;
8057 spell_aep
= syn_term_attr2entry(prim_attr
);
8058 if (spell_aep
!= NULL
)
8060 new_en
.ae_attr
|= spell_aep
->ae_attr
;
8061 if (spell_aep
->ae_u
.term
.start
!= NULL
)
8063 new_en
.ae_u
.term
.start
= spell_aep
->ae_u
.term
.start
;
8064 new_en
.ae_u
.term
.stop
= spell_aep
->ae_u
.term
.stop
;
8068 return get_attr_entry(&term_attr_table
, &new_en
);
8075 syn_gui_attr2entry(attr
)
8079 if (attr
>= gui_attr_table
.ga_len
) /* did ":syntax clear" */
8081 return &(GUI_ATTR_ENTRY(attr
));
8083 #endif /* FEAT_GUI */
8086 * Get the highlight attributes (HL_BOLD etc.) from an attribute nr.
8087 * Only to be used when "attr" > HL_ALL.
8097 aep
= syn_gui_attr2entry(attr
);
8101 aep
= syn_cterm_attr2entry(attr
);
8103 aep
= syn_term_attr2entry(attr
);
8105 if (aep
== NULL
) /* highlighting not set */
8107 return aep
->ae_attr
;
8112 syn_term_attr2entry(attr
)
8116 if (attr
>= term_attr_table
.ga_len
) /* did ":syntax clear" */
8118 return &(TERM_ATTR_ENTRY(attr
));
8122 syn_cterm_attr2entry(attr
)
8126 if (attr
>= cterm_attr_table
.ga_len
) /* did ":syntax clear" */
8128 return &(CTERM_ATTR_ENTRY(attr
));
8132 #define LIST_STRING 2
8136 highlight_list_one(id
)
8139 struct hl_group
*sgp
;
8142 sgp
= &HL_TABLE()[id
- 1]; /* index is ID minus one */
8144 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8145 sgp
->sg_term
, NULL
, "term");
8146 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8147 0, sgp
->sg_start
, "start");
8148 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8149 0, sgp
->sg_stop
, "stop");
8151 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8152 sgp
->sg_cterm
, NULL
, "cterm");
8153 didh
= highlight_list_arg(id
, didh
, LIST_INT
,
8154 sgp
->sg_cterm_fg
, NULL
, "ctermfg");
8155 didh
= highlight_list_arg(id
, didh
, LIST_INT
,
8156 sgp
->sg_cterm_bg
, NULL
, "ctermbg");
8159 didh
= highlight_list_arg(id
, didh
, LIST_ATTR
,
8160 sgp
->sg_gui
, NULL
, "gui");
8161 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8162 0, sgp
->sg_gui_fg_name
, "guifg");
8163 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8164 0, sgp
->sg_gui_bg_name
, "guibg");
8165 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8166 0, sgp
->sg_gui_sp_name
, "guisp");
8167 didh
= highlight_list_arg(id
, didh
, LIST_STRING
,
8168 0, sgp
->sg_font_name
, "font");
8171 if (sgp
->sg_link
&& !got_int
)
8173 (void)syn_list_header(didh
, 9999, id
);
8175 msg_puts_attr((char_u
*)"links to", hl_attr(HLF_D
));
8177 msg_outtrans(HL_TABLE()[HL_TABLE()[id
- 1].sg_link
- 1].sg_name
);
8181 highlight_list_arg(id
, didh
, LIST_STRING
, 0, (char_u
*)"cleared", "");
8184 last_set_msg(sgp
->sg_scriptID
);
8189 highlight_list_arg(id
, didh
, type
, iarg
, sarg
, name
)
8203 if (type
== LIST_STRING
? (sarg
!= NULL
) : (iarg
!= 0))
8206 if (type
== LIST_INT
)
8207 sprintf((char *)buf
, "%d", iarg
- 1);
8208 else if (type
== LIST_STRING
)
8210 else /* type == LIST_ATTR */
8213 for (i
= 0; hl_attr_table
[i
] != 0; ++i
)
8215 if (iarg
& hl_attr_table
[i
])
8219 STRCAT(buf
, hl_name_table
[i
]);
8220 iarg
&= ~hl_attr_table
[i
]; /* don't want "inverse" */
8225 (void)syn_list_header(didh
,
8226 (int)(vim_strsize(ts
) + STRLEN(name
) + 1), id
);
8232 MSG_PUTS_ATTR(name
, hl_attr(HLF_D
));
8233 MSG_PUTS_ATTR("=", hl_attr(HLF_D
));
8241 #if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO)
8243 * Return "1" if highlight group "id" has attribute "flag".
8244 * Return NULL otherwise.
8247 highlight_has_attr(id
, flag
, modec
)
8250 int modec
; /* 'g' for GUI, 'c' for cterm, 't' for term */
8254 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8259 attr
= HL_TABLE()[id
- 1].sg_gui
;
8263 attr
= HL_TABLE()[id
- 1].sg_cterm
;
8265 attr
= HL_TABLE()[id
- 1].sg_term
;
8268 return (char_u
*)"1";
8273 #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
8275 * Return color name of highlight group "id".
8278 highlight_color(id
, what
, modec
)
8280 char_u
*what
; /* "fg", "bg", "sp", "fg#", "bg#" or "sp#" */
8281 int modec
; /* 'g' for GUI, 'c' for cterm, 't' for term */
8283 static char_u name
[20];
8290 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8293 if (TOLOWER_ASC(what
[0]) == 'f')
8296 else if (TOLOWER_ASC(what
[0]) == 's')
8300 /* return #RRGGBB form (only possible when GUI is running) */
8301 if (gui
.in_use
&& what
[1] && what
[2] == '#')
8305 static char_u buf
[10];
8308 color
= HL_TABLE()[id
- 1].sg_gui_fg
;
8310 color
= HL_TABLE()[id
- 1].sg_gui_sp
;
8312 color
= HL_TABLE()[id
- 1].sg_gui_bg
;
8313 if (color
== INVALCOLOR
)
8315 rgb
= gui_mch_get_rgb(color
);
8316 sprintf((char *)buf
, "#%02x%02x%02x",
8317 (unsigned)(rgb
>> 16),
8318 (unsigned)(rgb
>> 8) & 255,
8319 (unsigned)rgb
& 255);
8323 return (HL_TABLE()[id
- 1].sg_gui_fg_name
);
8325 return (HL_TABLE()[id
- 1].sg_gui_sp_name
);
8326 return (HL_TABLE()[id
- 1].sg_gui_bg_name
);
8332 n
= HL_TABLE()[id
- 1].sg_cterm_fg
- 1;
8334 n
= HL_TABLE()[id
- 1].sg_cterm_bg
- 1;
8335 sprintf((char *)name
, "%d", n
);
8338 /* term doesn't have color */
8343 #if (defined(FEAT_SYN_HL) && defined(FEAT_GUI) && defined(FEAT_PRINTER)) \
8346 * Return color name of highlight group "id" as RGB value.
8349 highlight_gui_color_rgb(id
, fg
)
8351 int fg
; /* TRUE = fg, FALSE = bg */
8355 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8359 color
= HL_TABLE()[id
- 1].sg_gui_fg
;
8361 color
= HL_TABLE()[id
- 1].sg_gui_bg
;
8363 if (color
== INVALCOLOR
)
8366 return gui_mch_get_rgb(color
);
8371 * Output the syntax list header.
8372 * Return TRUE when started a new line.
8375 syn_list_header(did_header
, outlen
, id
)
8376 int did_header
; /* did header already */
8377 int outlen
; /* length of string that comes */
8378 int id
; /* highlight group id */
8388 msg_outtrans(HL_TABLE()[id
- 1].sg_name
);
8391 else if (msg_col
+ outlen
+ 1 >= Columns
)
8399 if (msg_col
>= endcol
) /* wrap around is like starting a new line */
8403 if (msg_col
>= endcol
) /* output at least one space */
8404 endcol
= msg_col
+ 1;
8405 if (Columns
<= endcol
) /* avoid hang for tiny window */
8406 endcol
= Columns
- 1;
8408 msg_advance(endcol
);
8410 /* Show "xxx" with the attributes. */
8413 msg_puts_attr((char_u
*)"xxx", syn_id2attr(id
));
8421 * Set the attribute numbers for a highlight group.
8422 * Called after one of the attributes has changed.
8426 int idx
; /* index in array */
8429 struct hl_group
*sgp
= HL_TABLE() + idx
;
8431 /* The "Normal" group doesn't need an attribute number */
8432 if (sgp
->sg_name_u
!= NULL
&& STRCMP(sgp
->sg_name_u
, "NORMAL") == 0)
8437 * For the GUI mode: If there are other than "normal" highlighting
8438 * attributes, need to allocate an attr number.
8440 if (sgp
->sg_gui_fg
== INVALCOLOR
8441 && sgp
->sg_gui_bg
== INVALCOLOR
8442 && sgp
->sg_gui_sp
== INVALCOLOR
8443 && sgp
->sg_font
== NOFONT
8444 # ifdef FEAT_XFONTSET
8445 && sgp
->sg_fontset
== NOFONTSET
8449 sgp
->sg_gui_attr
= sgp
->sg_gui
;
8453 at_en
.ae_attr
= sgp
->sg_gui
;
8454 at_en
.ae_u
.gui
.fg_color
= sgp
->sg_gui_fg
;
8455 at_en
.ae_u
.gui
.bg_color
= sgp
->sg_gui_bg
;
8456 at_en
.ae_u
.gui
.sp_color
= sgp
->sg_gui_sp
;
8457 at_en
.ae_u
.gui
.font
= sgp
->sg_font
;
8458 # ifdef FEAT_XFONTSET
8459 at_en
.ae_u
.gui
.fontset
= sgp
->sg_fontset
;
8461 sgp
->sg_gui_attr
= get_attr_entry(&gui_attr_table
, &at_en
);
8465 * For the term mode: If there are other than "normal" highlighting
8466 * attributes, need to allocate an attr number.
8468 if (sgp
->sg_start
== NULL
&& sgp
->sg_stop
== NULL
)
8469 sgp
->sg_term_attr
= sgp
->sg_term
;
8472 at_en
.ae_attr
= sgp
->sg_term
;
8473 at_en
.ae_u
.term
.start
= sgp
->sg_start
;
8474 at_en
.ae_u
.term
.stop
= sgp
->sg_stop
;
8475 sgp
->sg_term_attr
= get_attr_entry(&term_attr_table
, &at_en
);
8479 * For the color term mode: If there are other than "normal"
8480 * highlighting attributes, need to allocate an attr number.
8482 if (sgp
->sg_cterm_fg
== 0 && sgp
->sg_cterm_bg
== 0)
8483 sgp
->sg_cterm_attr
= sgp
->sg_cterm
;
8486 at_en
.ae_attr
= sgp
->sg_cterm
;
8487 at_en
.ae_u
.cterm
.fg_color
= sgp
->sg_cterm_fg
;
8488 at_en
.ae_u
.cterm
.bg_color
= sgp
->sg_cterm_bg
;
8489 sgp
->sg_cterm_attr
= get_attr_entry(&cterm_attr_table
, &at_en
);
8494 * Lookup a highlight group name and return it's ID.
8495 * If it is not found, 0 is returned.
8504 /* Avoid using stricmp() too much, it's slow on some systems */
8505 /* Avoid alloc()/free(), these are slow too. ID names over 200 chars
8506 * don't deserve to be found! */
8507 vim_strncpy(name_u
, name
, 199);
8509 for (i
= highlight_ga
.ga_len
; --i
>= 0; )
8510 if (HL_TABLE()[i
].sg_name_u
!= NULL
8511 && STRCMP(name_u
, HL_TABLE()[i
].sg_name_u
) == 0)
8516 #if defined(FEAT_EVAL) || defined(PROTO)
8518 * Return TRUE if highlight group "name" exists.
8521 highlight_exists(name
)
8524 return (syn_name2id(name
) > 0);
8527 # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
8529 * Return the name of highlight group "id".
8530 * When not a valid ID return an empty string.
8536 if (id
<= 0 || id
> highlight_ga
.ga_len
)
8537 return (char_u
*)"";
8538 return HL_TABLE()[id
- 1].sg_name
;
8544 * Like syn_name2id(), but take a pointer + length argument.
8547 syn_namen2id(linep
, len
)
8554 name
= vim_strnsave(linep
, len
);
8557 id
= syn_name2id(name
);
8564 * Find highlight group name in the table and return it's ID.
8565 * The argument is a pointer to the name and the length of the name.
8566 * If it doesn't exist yet, a new entry is created.
8567 * Return 0 for failure.
8570 syn_check_group(pp
, len
)
8577 name
= vim_strnsave(pp
, len
);
8581 id
= syn_name2id(name
);
8582 if (id
== 0) /* doesn't exist yet */
8583 id
= syn_add_group(name
);
8590 * Add new highlight group and return it's ID.
8591 * "name" must be an allocated string, it will be consumed.
8592 * Return 0 for failure.
8600 /* Check that the name is ASCII letters, digits and underscore. */
8601 for (p
= name
; *p
!= NUL
; ++p
)
8603 if (!vim_isprintc(*p
))
8605 EMSG(_("E669: Unprintable character in group name"));
8608 else if (!ASCII_ISALNUM(*p
) && *p
!= '_')
8610 /* This is an error, but since there previously was no check only
8611 * give a warning. */
8612 msg_source(hl_attr(HLF_W
));
8613 MSG(_("W18: Invalid character in group name"));
8619 * First call for this growarray: init growing array.
8621 if (highlight_ga
.ga_data
== NULL
)
8623 highlight_ga
.ga_itemsize
= sizeof(struct hl_group
);
8624 highlight_ga
.ga_growsize
= 10;
8628 * Make room for at least one other syntax_highlight entry.
8630 if (ga_grow(&highlight_ga
, 1) == FAIL
)
8636 vim_memset(&(HL_TABLE()[highlight_ga
.ga_len
]), 0, sizeof(struct hl_group
));
8637 HL_TABLE()[highlight_ga
.ga_len
].sg_name
= name
;
8638 HL_TABLE()[highlight_ga
.ga_len
].sg_name_u
= vim_strsave_up(name
);
8640 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_bg
= INVALCOLOR
;
8641 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_fg
= INVALCOLOR
;
8642 HL_TABLE()[highlight_ga
.ga_len
].sg_gui_sp
= INVALCOLOR
;
8644 ++highlight_ga
.ga_len
;
8646 return highlight_ga
.ga_len
; /* ID is index plus one */
8650 * When, just after calling syn_add_group(), an error is discovered, this
8651 * function deletes the new name.
8656 --highlight_ga
.ga_len
;
8657 vim_free(HL_TABLE()[highlight_ga
.ga_len
].sg_name
);
8658 vim_free(HL_TABLE()[highlight_ga
.ga_len
].sg_name_u
);
8662 * Translate a group ID to highlight attributes.
8669 struct hl_group
*sgp
;
8671 hl_id
= syn_get_final_id(hl_id
);
8672 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8676 * Only use GUI attr when the GUI is being used.
8679 attr
= sgp
->sg_gui_attr
;
8683 attr
= sgp
->sg_cterm_attr
;
8685 attr
= sgp
->sg_term_attr
;
8692 * Get the GUI colors and attributes for a group ID.
8693 * NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
8696 syn_id2colors(hl_id
, fgp
, bgp
)
8701 struct hl_group
*sgp
;
8703 hl_id
= syn_get_final_id(hl_id
);
8704 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8706 *fgp
= sgp
->sg_gui_fg
;
8707 *bgp
= sgp
->sg_gui_bg
;
8713 * Translate a group ID to the final group ID (following links).
8716 syn_get_final_id(hl_id
)
8720 struct hl_group
*sgp
;
8722 if (hl_id
> highlight_ga
.ga_len
|| hl_id
< 1)
8723 return 0; /* Can be called from eval!! */
8726 * Follow links until there is no more.
8727 * Look out for loops! Break after 100 links.
8729 for (count
= 100; --count
>= 0; )
8731 sgp
= &HL_TABLE()[hl_id
- 1]; /* index is ID minus one */
8732 if (sgp
->sg_link
== 0 || sgp
->sg_link
> highlight_ga
.ga_len
)
8734 hl_id
= sgp
->sg_link
;
8742 * Call this function just after the GUI has started.
8743 * It finds the font and color handles for the highlighting groups.
8746 highlight_gui_started()
8750 /* First get the colors from the "Normal" and "Menu" group, if set */
8751 set_normal_colors();
8753 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
8754 gui_do_one_color(idx
, FALSE
, FALSE
);
8756 highlight_changed();
8760 gui_do_one_color(idx
, do_menu
, do_tooltip
)
8762 int do_menu
; /* TRUE: might set the menu font */
8763 int do_tooltip
; /* TRUE: might set the tooltip font */
8767 if (HL_TABLE()[idx
].sg_font_name
!= NULL
)
8769 hl_do_font(idx
, HL_TABLE()[idx
].sg_font_name
, FALSE
, do_menu
,
8773 if (HL_TABLE()[idx
].sg_gui_fg_name
!= NULL
)
8775 HL_TABLE()[idx
].sg_gui_fg
=
8776 color_name2handle(HL_TABLE()[idx
].sg_gui_fg_name
);
8779 if (HL_TABLE()[idx
].sg_gui_bg_name
!= NULL
)
8781 HL_TABLE()[idx
].sg_gui_bg
=
8782 color_name2handle(HL_TABLE()[idx
].sg_gui_bg_name
);
8785 if (HL_TABLE()[idx
].sg_gui_sp_name
!= NULL
)
8787 HL_TABLE()[idx
].sg_gui_sp
=
8788 color_name2handle(HL_TABLE()[idx
].sg_gui_sp_name
);
8791 if (didit
) /* need to get a new attr number */
8798 * Translate the 'highlight' option into attributes in highlight_attr[] and
8799 * set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of
8800 * corresponding highlights to use on top of HLF_SNC is computed.
8801 * Called only when the 'highlight' option has been changed and upon first
8802 * screen redraw after any :highlight command.
8803 * Return FAIL when an invalid flag is found in 'highlight'. OK otherwise.
8814 #ifdef USER_HIGHLIGHT
8816 # ifdef FEAT_STL_OPT
8822 static int hl_flags
[HLF_COUNT
] = HL_FLAGS
;
8824 need_highlight_changed
= FALSE
;
8827 * Clear all attributes.
8829 for (hlf
= 0; hlf
< (int)HLF_COUNT
; ++hlf
)
8830 highlight_attr
[hlf
] = 0;
8833 * First set all attributes to their default value.
8834 * Then use the attributes from the 'highlight' option.
8836 for (i
= 0; i
< 2; ++i
)
8841 p
= get_highlight_default();
8842 if (p
== NULL
) /* just in case */
8847 for (hlf
= 0; hlf
< (int)HLF_COUNT
; ++hlf
)
8848 if (hl_flags
[hlf
] == *p
)
8851 if (hlf
== (int)HLF_COUNT
|| *p
== NUL
)
8855 * Allow several hl_flags to be combined, like "bu" for
8859 for ( ; *p
&& *p
!= ','; ++p
) /* parse upto comma */
8861 if (vim_iswhite(*p
)) /* ignore white space */
8864 if (attr
> HL_ALL
) /* Combination with ':' is not allowed. */
8869 case 'b': attr
|= HL_BOLD
;
8871 case 'i': attr
|= HL_ITALIC
;
8874 case 'n': /* no highlighting */
8876 case 'r': attr
|= HL_INVERSE
;
8878 case 's': attr
|= HL_STANDOUT
;
8880 case 'u': attr
|= HL_UNDERLINE
;
8882 case 'c': attr
|= HL_UNDERCURL
;
8884 case ':': ++p
; /* highlight group name */
8885 if (attr
|| *p
== NUL
) /* no combinations */
8887 end
= vim_strchr(p
, ',');
8889 end
= p
+ STRLEN(p
);
8890 id
= syn_check_group(p
, (int)(end
- p
));
8893 attr
= syn_id2attr(id
);
8895 #if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT)
8896 if (hlf
== (int)HLF_SNC
)
8897 id_SNC
= syn_get_final_id(id
);
8898 else if (hlf
== (int)HLF_S
)
8899 id_S
= syn_get_final_id(id
);
8902 default: return FAIL
;
8905 highlight_attr
[hlf
] = attr
;
8907 p
= skip_to_option_part(p
); /* skip comma and spaces */
8911 #ifdef USER_HIGHLIGHT
8912 /* Setup the user highlights
8914 * Temporarily utilize 10 more hl entries. Have to be in there
8915 * simultaneously in case of table overflows in get_attr_entry()
8917 # ifdef FEAT_STL_OPT
8918 if (ga_grow(&highlight_ga
, 10) == FAIL
)
8920 hlcnt
= highlight_ga
.ga_len
;
8922 { /* Make sure id_S is always valid to simplify code below */
8923 memset(&HL_TABLE()[hlcnt
+ 9], 0, sizeof(struct hl_group
));
8924 HL_TABLE()[hlcnt
+ 9].sg_term
= highlight_attr
[HLF_S
];
8928 for (i
= 0; i
< 9; i
++)
8930 sprintf((char *)userhl
, "User%d", i
+ 1);
8931 id
= syn_name2id(userhl
);
8934 highlight_user
[i
] = 0;
8935 # ifdef FEAT_STL_OPT
8936 highlight_stlnc
[i
] = 0;
8941 # ifdef FEAT_STL_OPT
8942 struct hl_group
*hlt
= HL_TABLE();
8945 highlight_user
[i
] = syn_id2attr(id
);
8946 # ifdef FEAT_STL_OPT
8949 memset(&hlt
[hlcnt
+ i
], 0, sizeof(struct hl_group
));
8950 hlt
[hlcnt
+ i
].sg_term
= highlight_attr
[HLF_SNC
];
8951 hlt
[hlcnt
+ i
].sg_cterm
= highlight_attr
[HLF_SNC
];
8953 hlt
[hlcnt
+ i
].sg_gui
= highlight_attr
[HLF_SNC
];
8957 mch_memmove(&hlt
[hlcnt
+ i
],
8959 sizeof(struct hl_group
));
8960 hlt
[hlcnt
+ i
].sg_link
= 0;
8962 /* Apply difference between UserX and HLF_S to HLF_SNC */
8963 hlt
[hlcnt
+ i
].sg_term
^=
8964 hlt
[id
- 1].sg_term
^ hlt
[id_S
- 1].sg_term
;
8965 if (hlt
[id
- 1].sg_start
!= hlt
[id_S
- 1].sg_start
)
8966 hlt
[hlcnt
+ i
].sg_start
= hlt
[id
- 1].sg_start
;
8967 if (hlt
[id
- 1].sg_stop
!= hlt
[id_S
- 1].sg_stop
)
8968 hlt
[hlcnt
+ i
].sg_stop
= hlt
[id
- 1].sg_stop
;
8969 hlt
[hlcnt
+ i
].sg_cterm
^=
8970 hlt
[id
- 1].sg_cterm
^ hlt
[id_S
- 1].sg_cterm
;
8971 if (hlt
[id
- 1].sg_cterm_fg
!= hlt
[id_S
- 1].sg_cterm_fg
)
8972 hlt
[hlcnt
+ i
].sg_cterm_fg
= hlt
[id
- 1].sg_cterm_fg
;
8973 if (hlt
[id
- 1].sg_cterm_bg
!= hlt
[id_S
- 1].sg_cterm_bg
)
8974 hlt
[hlcnt
+ i
].sg_cterm_bg
= hlt
[id
- 1].sg_cterm_bg
;
8976 hlt
[hlcnt
+ i
].sg_gui
^=
8977 hlt
[id
- 1].sg_gui
^ hlt
[id_S
- 1].sg_gui
;
8978 if (hlt
[id
- 1].sg_gui_fg
!= hlt
[id_S
- 1].sg_gui_fg
)
8979 hlt
[hlcnt
+ i
].sg_gui_fg
= hlt
[id
- 1].sg_gui_fg
;
8980 if (hlt
[id
- 1].sg_gui_bg
!= hlt
[id_S
- 1].sg_gui_bg
)
8981 hlt
[hlcnt
+ i
].sg_gui_bg
= hlt
[id
- 1].sg_gui_bg
;
8982 if (hlt
[id
- 1].sg_gui_sp
!= hlt
[id_S
- 1].sg_gui_sp
)
8983 hlt
[hlcnt
+ i
].sg_gui_sp
= hlt
[id
- 1].sg_gui_sp
;
8984 if (hlt
[id
- 1].sg_font
!= hlt
[id_S
- 1].sg_font
)
8985 hlt
[hlcnt
+ i
].sg_font
= hlt
[id
- 1].sg_font
;
8986 # ifdef FEAT_XFONTSET
8987 if (hlt
[id
- 1].sg_fontset
!= hlt
[id_S
- 1].sg_fontset
)
8988 hlt
[hlcnt
+ i
].sg_fontset
= hlt
[id
- 1].sg_fontset
;
8991 highlight_ga
.ga_len
= hlcnt
+ i
+ 1;
8992 set_hl_attr(hlcnt
+ i
); /* At long last we can apply */
8993 highlight_stlnc
[i
] = syn_id2attr(hlcnt
+ i
+ 1);
8997 # ifdef FEAT_STL_OPT
8998 highlight_ga
.ga_len
= hlcnt
;
9001 #endif /* USER_HIGHLIGHT */
9006 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9008 static void highlight_list
__ARGS((void));
9009 static void highlight_list_two
__ARGS((int cnt
, int attr
));
9012 * Handle command line completion for :highlight command.
9015 set_context_in_highlight_cmd(xp
, arg
)
9021 /* Default: expand group names */
9022 xp
->xp_context
= EXPAND_HIGHLIGHT
;
9023 xp
->xp_pattern
= arg
;
9025 include_default
= 1;
9027 /* (part of) subcommand already typed */
9030 p
= skiptowhite(arg
);
9031 if (*p
!= NUL
) /* past "default" or group name */
9033 include_default
= 0;
9034 if (STRNCMP("default", arg
, p
- arg
) == 0)
9037 xp
->xp_pattern
= arg
;
9038 p
= skiptowhite(arg
);
9040 if (*p
!= NUL
) /* past group name */
9043 if (arg
[1] == 'i' && arg
[0] == 'N')
9045 if (STRNCMP("link", arg
, p
- arg
) == 0
9046 || STRNCMP("clear", arg
, p
- arg
) == 0)
9048 xp
->xp_pattern
= skipwhite(p
);
9049 p
= skiptowhite(xp
->xp_pattern
);
9050 if (*p
!= NUL
) /* past first group name */
9052 xp
->xp_pattern
= skipwhite(p
);
9053 p
= skiptowhite(xp
->xp_pattern
);
9056 if (*p
!= NUL
) /* past group name(s) */
9057 xp
->xp_context
= EXPAND_NOTHING
;
9064 * List highlighting matches in a nice way.
9071 for (i
= 10; --i
>= 0; )
9072 highlight_list_two(i
, hl_attr(HLF_D
));
9073 for (i
= 40; --i
>= 0; )
9074 highlight_list_two(99, 0);
9078 highlight_list_two(cnt
, attr
)
9082 msg_puts_attr((char_u
*)("N \bI \b! \b" + cnt
/ 11), attr
);
9085 ui_delay(cnt
== 99 ? 40L : (long)cnt
* 50L, FALSE
);
9088 #endif /* FEAT_CMDL_COMPL */
9090 #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) \
9091 || defined(FEAT_SIGNS) || defined(PROTO)
9093 * Function given to ExpandGeneric() to obtain the list of group names.
9094 * Also used for synIDattr() function.
9098 get_highlight_name(xp
, idx
)
9102 #ifdef FEAT_CMDL_COMPL
9103 if (idx
== highlight_ga
.ga_len
&& include_none
!= 0)
9104 return (char_u
*)"none";
9105 if (idx
== highlight_ga
.ga_len
+ include_none
&& include_default
!= 0)
9106 return (char_u
*)"default";
9107 if (idx
== highlight_ga
.ga_len
+ include_none
+ include_default
9108 && include_link
!= 0)
9109 return (char_u
*)"link";
9110 if (idx
== highlight_ga
.ga_len
+ include_none
+ include_default
+ 1
9111 && include_link
!= 0)
9112 return (char_u
*)"clear";
9114 if (idx
< 0 || idx
>= highlight_ga
.ga_len
)
9116 return HL_TABLE()[idx
].sg_name
;
9120 #if defined(FEAT_GUI) || defined(PROTO)
9122 * Free all the highlight group fonts.
9123 * Used when quitting for systems which need it.
9126 free_highlight_fonts()
9130 for (idx
= 0; idx
< highlight_ga
.ga_len
; ++idx
)
9132 gui_mch_free_font(HL_TABLE()[idx
].sg_font
);
9133 HL_TABLE()[idx
].sg_font
= NOFONT
;
9134 # ifdef FEAT_XFONTSET
9135 gui_mch_free_fontset(HL_TABLE()[idx
].sg_fontset
);
9136 HL_TABLE()[idx
].sg_fontset
= NOFONTSET
;
9140 gui_mch_free_font(gui
.norm_font
);
9141 # ifdef FEAT_XFONTSET
9142 gui_mch_free_fontset(gui
.fontset
);
9145 gui_mch_free_font(gui
.bold_font
);
9146 gui_mch_free_font(gui
.ital_font
);
9147 gui_mch_free_font(gui
.boldital_font
);
9152 /**************************************
9153 * End of Highlighting stuff *
9154 **************************************/