Enable compilation without FEAT_MBYTE.
[MacVim/KaoriYa.git] / src / syntax.c
bloba1ed8b142cd1cdc0c48499f032e7242efb046f9f
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.
8 */
11 * syntax.c: code for syntax highlighting
14 #include "vim.h"
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.
21 struct hl_group
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 */
36 #ifdef FEAT_GUI
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 */
46 #ifdef FEAT_XFONTSET
47 GuiFontset sg_fontset; /* GUI fontset handle */
48 #endif
49 char_u *sg_font_name; /* GUI font or fontset name */
50 int sg_gui_attr; /* Screen attr for GUI mode */
51 #endif
52 int sg_link; /* link to this highlight group ID */
53 int sg_set; /* combination of SG_* flags */
54 #ifdef FEAT_EVAL
55 scid_T sg_scriptID; /* script in which the group was last set */
56 #endif
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" */
73 #endif
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));
95 #ifdef FEAT_GUI
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));
102 # endif
103 static void hl_do_font __ARGS((int idx, char_u *arg, int do_normal, int do_menu, int do_tooltip));
104 #endif
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 */
123 #define SPO_COUNT 7
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
133 * end patterns.
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 */
156 } synpat_T;
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 */
207 #ifdef FEAT_EVAL
208 static int current_id = 0; /* ID of current char for syn_get_id() */
209 static int current_trans_id = 0; /* idem, transparancy removed */
210 #endif
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 */
217 } syn_cluster_T;
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
283 KEYWORD_IDX */
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
300 * pattern */
301 } stateitem_T;
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
309 * very often.
311 typedef struct
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
316 if not allowed */
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 */
321 } syn_opt_arg_T;
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));
435 #ifdef __BORLANDC__
436 static int _RTLENTRYF syn_compare_stub __ARGS((const void *v1, const void *v2));
437 #else
438 static int syn_compare_stub __ARGS((const void *v1, const void *v2));
439 #endif
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
457 * window.
459 void
460 syntax_start(wp, lnum)
461 win_T *wp;
462 linenr_T lnum;
464 synstate_T *p;
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;
470 int dist;
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
476 * then.
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;
484 syn_win = wp;
487 * Allocate syntax stack when needed.
489 syn_stack_alloc();
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(&current_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)
504 ++current_lnum;
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();
516 else
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(&current_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)
529 break;
530 if (p->sst_lnum <= lnum && p->sst_change_lnum == 0)
532 last_valid = p;
533 if (p->sst_lnum >= lnum - syn_buf->b_syn_sync_minlines)
534 last_min_valid = p;
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
543 * re-synchronize.
545 if (INVALID_STATE(&current_state))
547 syn_sync(wp, lnum, last_valid);
548 first_stored = current_lnum + syn_buf->b_syn_sync_minlines;
550 else
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)
558 dist = 999999;
559 else
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)
564 syn_start_line();
565 (void)syn_finish_line(FALSE);
566 ++current_lnum;
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. */
575 if (prev == NULL)
576 sp = syn_buf->b_sst_first;
577 else
578 sp = prev->sst_next;
579 if (sp != NULL
580 && sp->sst_lnum == current_lnum
581 && syn_stack_equal(sp))
583 parsed_lnum = current_lnum;
584 prev = sp;
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 */
589 prev = sp;
590 else if (sp->sst_change_lnum == 0)
591 /* past saved states depending on change, break here. */
592 break;
593 sp->sst_change_lnum = 0;
594 sp = sp->sst_next;
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. */
609 line_breakcheck();
610 if (got_int)
612 current_lnum = lnum;
613 break;
617 syn_start_line();
621 * We cannot simply discard growarrays full of state_items or buf_states; we
622 * have to manually release their extmatch pointers first.
624 static void
625 clear_syn_state(p)
626 synstate_T *p;
628 int i;
629 garray_T *gap;
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);
636 ga_clear(gap);
638 else
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.
648 static void
649 clear_current_state()
651 int i;
652 stateitem_T *sip;
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(&current_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
664 * used:
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".
669 static void
670 syn_sync(wp, start_lnum, last_valid)
671 win_T *wp;
672 linenr_T start_lnum;
673 synstate_T *last_valid;
675 buf_T *curbuf_save;
676 win_T *curwin_save;
677 pos_T cursor_save;
678 int idx;
679 linenr_T lnum;
680 linenr_T end_lnum;
681 linenr_T break_lnum;
682 int had_sync_point;
683 stateitem_T *cur_si;
684 synpat_T *spp;
685 char_u *line;
686 int found_flags = 0;
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
700 * there.
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)
707 start_lnum = 1;
708 else
710 if (syn_buf->b_syn_sync_minlines == 1)
711 lnum = 1;
712 else if (syn_buf->b_syn_sync_minlines < 10)
713 lnum = syn_buf->b_syn_sync_minlines * 2;
714 else
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)
720 start_lnum = 1;
721 else
722 start_lnum -= 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;
734 curwin = wp;
735 curbuf_save = curbuf;
736 curbuf = syn_buf;
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) != '\\')
745 break;
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);
768 break;
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;
786 else
787 break_lnum = 0;
789 found_m_endpos.lnum = 0;
790 found_m_endpos.col = 0;
791 end_lnum = start_lnum;
792 lnum = start_lnum;
793 while (--lnum > break_lnum)
795 /* This can take a long time: break when CTRL-C pressed. */
796 line_breakcheck();
797 if (got_int)
799 invalidate_current_state();
800 current_lnum = start_lnum;
801 break;
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);
808 break;
812 * Check if the previous line has the line-continuation pattern.
814 if (lnum > 1 && syn_match_linecont(lnum - 1))
815 continue;
818 * Start with nothing on the state stack
820 validate_current_state();
822 for (current_lnum = lnum; current_lnum < end_lnum; ++current_lnum)
824 syn_start_line();
825 for (;;)
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;
839 break;
841 if (cur_si->si_idx < 0)
843 /* Cannot happen? */
844 found_flags = 0;
845 found_match_idx = KEYWORD_IDX;
847 else
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
858 * match).
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)
865 break;
867 else if (found_m_endpos.col > current_col)
868 current_col = found_m_endpos.col;
869 else
870 ++current_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)
877 ++current_col;
878 check_state_ends();
879 current_col = prev_current_col;
881 else
882 break;
887 * If a sync point was encountered, break here.
889 if (found_flags)
892 * Put the item that was specified by the sync point on the
893 * state stack. If there was no item specified, make the
894 * state stack empty.
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
904 * the next line.
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);
915 check_keepend();
917 current_col = found_m_endpos.col;
918 current_lnum = found_m_endpos.lnum;
919 (void)syn_finish_line(FALSE);
920 ++current_lnum;
922 else
923 current_lnum = start_lnum;
925 break;
928 end_lnum = 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".
946 static int
947 syn_match_linecont(lnum)
948 linenr_T 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(&regmatch, lnum, (colnr_T)0);
958 return FALSE;
962 * Prepare the current state for the start of a line.
964 static void
965 syn_start_line()
967 current_finished = FALSE;
968 current_col = 0;
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);
977 next_match_idx = -1;
978 ++current_line_id;
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.
986 static void
987 syn_update_ends(startofline)
988 int startofline;
990 stateitem_T *cur_si;
991 int i;
992 int seen_keepend;
994 if (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
1003 == SPTYPE_MATCH
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)
1028 break;
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;
1048 check_keepend();
1049 check_state_ends();
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
1076 * the cached entry.
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.
1092 void
1093 syn_stack_free_all(buf)
1094 buf_T *buf;
1096 synstate_T *p;
1097 win_T *wp;
1099 if (buf->b_sst_array != NULL)
1101 for (p = buf->b_sst_first; p != NULL; p = p->sst_next)
1102 clear_syn_state(p);
1103 vim_free(buf->b_sst_array);
1104 buf->b_sst_array = NULL;
1105 buf->b_sst_len = 0;
1107 #ifdef FEAT_FOLDING
1108 /* When using "syntax" fold method, must update all folds. */
1109 FOR_ALL_WINDOWS(wp)
1111 if (wp->w_buffer == buf && foldmethodIsSyntax(wp))
1112 foldUpdateAll(wp);
1114 #endif
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.
1123 static void
1124 syn_stack_alloc()
1126 long len;
1127 synstate_T *to, *from;
1128 synstate_T *sstp;
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! */
1158 return;
1160 to = sstp - 1;
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)
1167 ++to;
1168 *to = *from;
1169 to->sst_next = to + 1;
1172 if (to != sstp - 1)
1174 to->sst_next = NULL;
1175 syn_buf->b_sst_first = sstp;
1176 syn_buf->b_sst_freecount = len - (int)(to - sstp) - 1;
1178 else
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
1198 * b_mod_* fields.
1199 * Called from update_screen(), before screen is being updated, once for each
1200 * displayed buffer.
1202 void
1203 syn_stack_apply_changes(buf)
1204 buf_T *buf;
1206 synstate_T *p, *prev, *np;
1207 linenr_T n;
1209 if (buf->b_sst_array == NULL) /* nothing to do */
1210 return;
1212 prev = NULL;
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 */
1221 np = p->sst_next;
1222 if (prev == NULL)
1223 buf->b_sst_first = np;
1224 else
1225 prev->sst_next = np;
1226 syn_stack_free_entry(buf, p);
1227 p = np;
1228 continue;
1230 /* This state is below the changed area. Remember the line
1231 * that needs to be parsed before this entry can be made valid
1232 * again. */
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;
1237 else
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;
1244 p->sst_lnum = n;
1246 prev = p;
1247 p = p->sst_next;
1252 * Reduce the number of entries in the state stack for syn_buf.
1253 * Returns TRUE if at least one entry was freed.
1255 static int
1256 syn_stack_cleanup()
1258 synstate_T *p, *prev;
1259 disptick_T tick;
1260 int above;
1261 int dist;
1262 int retval = FALSE;
1264 if (syn_buf->b_sst_array == NULL || syn_buf->b_sst_first == NULL)
1265 return retval;
1267 /* Compute normal distance between non-displayed entries. */
1268 if (syn_buf->b_sst_len <= Rows)
1269 dist = 999999;
1270 else
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;
1279 above = FALSE;
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)
1288 tick = p->sst_tick;
1289 above = TRUE;
1291 else if (!above && p->sst_tick < tick)
1292 tick = p->sst_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);
1308 p = prev;
1309 retval = TRUE;
1312 return retval;
1316 * Free the allocated memory for a syn_state item.
1317 * Move the entry into the free list.
1319 static void
1320 syn_stack_free_entry(buf, p)
1321 buf_T *buf;
1322 synstate_T *p;
1324 clear_syn_state(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".
1334 static synstate_T *
1335 syn_stack_find_entry(lnum)
1336 linenr_T lnum;
1338 synstate_T *p, *prev;
1340 prev = NULL;
1341 for (p = syn_buf->b_sst_first; p != NULL; prev = p, p = p->sst_next)
1343 if (p->sst_lnum == lnum)
1344 return p;
1345 if (p->sst_lnum > lnum)
1346 break;
1348 return prev;
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!
1355 static synstate_T *
1356 store_current_state(sp)
1357 synstate_T *sp; /* at or before where state is to be saved or
1358 NULL */
1360 int i;
1361 synstate_T *p;
1362 bufstate_T *bp;
1363 stateitem_T *cur_si;
1365 if (sp == NULL)
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))
1380 break;
1382 if (i >= 0)
1384 if (sp != NULL)
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;
1390 else
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)
1395 break;
1396 if (p != NULL) /* just in case */
1397 p->sst_next = sp->sst_next;
1399 syn_stack_free_entry(syn_buf, sp);
1400 sp = NULL;
1403 else if (sp == NULL || sp->sst_lnum != current_lnum)
1406 * Add a new entry
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)
1417 sp = NULL;
1418 else
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;
1425 if (sp == NULL)
1427 /* Insert in front of the list */
1428 p->sst_next = syn_buf->b_sst_first;
1429 syn_buf->b_sst_first = p;
1431 else
1433 /* insert in list after *sp */
1434 p->sst_next = sp->sst_next;
1435 sp->sst_next = p;
1437 sp = p;
1438 sp->sst_stacksize = 0;
1439 sp->sst_lnum = current_lnum;
1442 if (sp != NULL)
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;
1454 else
1455 sp->sst_union.sst_ga.ga_len = current_state.ga_len;
1456 bp = SYN_STATE_P(&(sp->sst_union.sst_ga));
1458 else
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;
1472 return sp;
1476 * Copy a state stack from "from" in b_sst_array[] to current_state;
1478 static void
1479 load_current_state(from)
1480 synstate_T *from;
1482 int i;
1483 bufstate_T *bp;
1485 clear_current_state();
1486 validate_current_state();
1487 keepend_level = -1;
1488 if (from->sst_stacksize
1489 && ga_grow(&current_state, from->sst_stacksize) != FAIL)
1491 if (from->sst_stacksize > SST_FIX_STATES)
1492 bp = SYN_STATE_P(&(from->sst_union.sst_ga));
1493 else
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))
1501 keepend_level = i;
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;
1507 else
1508 CUR_STATE(i).si_next_list = NULL;
1509 update_si_attr(i);
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.
1522 static int
1523 syn_stack_equal(sp)
1524 synstate_T *sp;
1526 int i, j;
1527 bufstate_T *bp;
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));
1537 else
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)
1544 break;
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
1553 * different. */
1554 if (bsx == NULL || six == NULL)
1555 break;
1556 for (j = 0; j < NSUBEXP; ++j)
1558 /* Check each referenced match string. They must all be
1559 * equal. */
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)
1567 break;
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)
1572 break;
1575 if (j != NSUBEXP)
1576 break;
1579 if (i < 0)
1580 return TRUE;
1582 return FALSE;
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
1591 * displayed line
1592 * displayed line
1593 * lnum -> line below window
1595 void
1596 syntax_end_parsing(lnum)
1597 linenr_T lnum;
1599 synstate_T *sp;
1601 sp = syn_stack_find_entry(lnum);
1602 if (sp != NULL && sp->sst_lnum < lnum)
1603 sp = sp->sst_next;
1605 if (sp != NULL && sp->sst_change_lnum != 0)
1606 sp->sst_change_lnum = lnum;
1610 * End of handling of the state stack.
1611 ****************************************/
1613 static void
1614 invalidate_current_state()
1616 clear_current_state();
1617 current_state.ga_itemsize = 0; /* mark current_state invalid */
1618 current_next_list = NULL;
1619 keepend_level = -1;
1622 static void
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)
1636 linenr_T lnum;
1638 int retval = TRUE;
1639 synstate_T *sp;
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(&current_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
1655 * drawn)
1657 (void)syn_finish_line(FALSE);
1660 * Compare the current state with the previously saved state of
1661 * the line.
1663 if (syn_stack_equal(sp))
1664 retval = FALSE;
1667 * Store the current state in b_sst_array[] for later use.
1669 ++current_lnum;
1670 (void)store_current_state(NULL);
1674 return retval;
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
1681 * is valid.
1683 static int
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)))
1707 return TRUE;
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
1711 * past the NUL. */
1712 prev_current_col = current_col;
1713 if (syn_getcurline()[current_col] != NUL)
1714 ++current_col;
1715 check_state_ends();
1716 current_col = prev_current_col;
1718 ++current_col;
1721 return FALSE;
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
1731 * done.
1734 get_syntax_attr(col, can_spell)
1735 colnr_T col;
1736 int *can_spell;
1738 int attr = 0;
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)
1749 return 0;
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();
1755 #ifdef FEAT_EVAL
1756 current_id = 0;
1757 current_trans_id = 0;
1758 #endif
1759 return 0;
1762 /* Make sure current_state is valid */
1763 if (INVALID_STATE(&current_state))
1764 validate_current_state();
1767 * Skip from the current column to "col", get the attributes for "col".
1769 while (current_col <= col)
1771 attr = syn_current_attr(FALSE, TRUE, can_spell);
1772 ++current_col;
1775 return attr;
1779 * Get syntax attributes for current_lnum, current_col.
1781 static int
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 */
1787 int syn_id;
1788 lpos_T endpos; /* was: char_u *endp; */
1789 lpos_T hl_startpos; /* was: int hl_startcol; */
1790 lpos_T hl_endpos;
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 */
1794 int idx;
1795 synpat_T *spp;
1796 stateitem_T *cur_si, *sip = NULL;
1797 int startcol;
1798 int endcol;
1799 long flags;
1800 short *next_list;
1801 int found_match; /* found usable match */
1802 static int try_next_column = FALSE; /* must try in next col */
1803 int do_keywords;
1804 regmmatch_T regmatch;
1805 lpos_T pos;
1806 int lc_col;
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 */
1812 int keep_next_list;
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;
1832 return 0;
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
1845 * the next column.
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
1865 * column.
1869 found_match = FALSE;
1870 keep_next_list = FALSE;
1871 syn_id = 0;
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);
1882 else
1883 cur_si = NULL;
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.
1892 if (do_keywords)
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
1898 #ifdef FEAT_MBYTE
1899 - (has_mbyte
1900 ? (*mb_head_off)(line, line + current_col - 1)
1901 : 0)
1902 #endif
1903 , syn_buf)))
1905 syn_id = check_keyword_id(line, (int)current_col,
1906 &endcol, &flags, &next_list, cur_si);
1907 if (syn_id != 0)
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;
1931 else
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;
1939 else
1940 cur_si->si_attr = syn_id2attr(syn_id);
1941 cur_si->si_cont_list = NULL;
1942 cur_si->si_next_list = next_list;
1943 check_keepend();
1945 else
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,
1979 &spp->sp_syn, 0)
1980 : (cur_si == NULL
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
1988 * this item. */
1989 if (spp->sp_line_id == current_line_id
1990 && spp->sp_startcol >= next_match_col)
1991 continue;
1992 spp->sp_line_id = current_line_id;
1994 lc_col = current_col - spp->sp_offsets[SPO_LC_OFF];
1995 if (lc_col < 0)
1996 lc_col = 0;
1998 regmatch.rmm_ic = spp->sp_ic;
1999 regmatch.regprog = spp->sp_prog;
2000 if (!syn_regexec(&regmatch, current_lnum,
2001 (colnr_T)lc_col))
2003 /* no match in this line, try another one */
2004 spp->sp_startcol = MAXCOL;
2005 continue;
2009 * Compute the first column of the match.
2011 syn_add_start_off(&pos, &regmatch,
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;
2018 continue;
2020 startcol = pos.col;
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)
2031 continue;
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;
2041 continue;
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, &regmatch,
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, &regmatch,
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;
2064 flags = 0;
2065 eoe_pos.lnum = 0; /* avoid warning */
2066 eoe_pos.col = 0;
2067 end_idx = 0;
2068 hl_endpos.lnum = 0;
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))
2079 lpos_T startpos;
2081 startpos = endpos;
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
2091 * syncing.
2093 else if (spp->sp_type == SPTYPE_MATCH)
2095 syn_add_end_off(&hl_endpos, &regmatch, spp,
2096 SPO_HE_OFF, 0);
2097 syn_add_end_off(&endpos, &regmatch, spp,
2098 SPO_ME_OFF, 0);
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;
2109 continue;
2114 * keep the best match so far in next_match_*
2116 /* Highlighting must start after startpos and end
2117 * before endpos. */
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)
2144 synpat_T *lspp;
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
2160 * endless loop). */
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;
2168 else
2169 cur_si = push_next_match(cur_si);
2170 found_match = TRUE;
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
2185 if (!found_match)
2187 line = syn_getcurline();
2188 if (((current_next_flags & HL_SKIPWHITE)
2189 && vim_iswhite(line[current_col]))
2190 || ((current_next_flags & HL_SKIPEMPTY)
2191 && *line == NUL))
2192 break;
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
2199 * match.
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)
2206 found_match = TRUE;
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.
2215 current_attr = 0;
2216 #ifdef FEAT_EVAL
2217 current_id = 0;
2218 current_trans_id = 0;
2219 #endif
2220 if (cur_si != NULL)
2222 #ifndef FEAT_EVAL
2223 int current_trans_id = 0;
2224 #endif
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;
2237 #ifdef FEAT_EVAL
2238 current_id = sip->si_id;
2239 #endif
2240 current_trans_id = sip->si_trans_id;
2241 break;
2245 if (can_spell != NULL)
2247 struct sp_syn sps;
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);
2259 else
2261 sps.inc_tag = 0;
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);
2267 else
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"
2272 * was used. */
2273 if (current_trans_id == 0)
2274 *can_spell = (syn_buf->b_syn_spell == SYNSPL_TOP);
2275 else
2277 sps.inc_tag = 0;
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))
2286 *can_spell = FALSE;
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
2299 * current column.
2301 if (!syncing)
2303 check_state_ends();
2304 if (current_state.ga_len > 0
2305 && syn_getcurline()[current_col] != NUL)
2307 ++current_col;
2308 check_state_ends();
2309 --current_col;
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.
2341 static int
2342 did_match_already(idx, gap)
2343 int idx;
2344 garray_T *gap;
2346 int i;
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)
2352 return TRUE;
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)
2358 return TRUE;
2360 return FALSE;
2364 * Push the next match onto the stack.
2366 static stateitem_T *
2367 push_next_match(cur_si)
2368 stateitem_T *cur_si;
2370 synpat_T *spp;
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);
2394 check_keepend();
2396 else
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;
2407 check_keepend();
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;
2428 check_keepend();
2429 update_si_attr(current_state.ga_len - 1);
2433 next_match_idx = -1; /* try other match next time */
2435 return cur_si;
2439 * Check for end of current state (and the states before it).
2441 static void
2442 check_state_ends()
2444 stateitem_T *cur_si;
2445 int had_extend = FALSE;
2447 cur_si = &CUR_STATE(current_state.ga_len - 1);
2448 for (;;)
2450 if (cur_si->si_ends
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
2459 * position.
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 */
2474 next_match_idx = 0;
2475 next_match_col = MAXCOL;
2476 break;
2478 else
2480 /* handle next_list, unless at end of line and no "skipnl" or
2481 * "skipempty" */
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)
2491 had_extend = TRUE;
2493 pop_current_state();
2495 if (current_state.ga_len == 0)
2496 break;
2498 if (had_extend)
2500 syn_update_ends(FALSE);
2501 if (current_state.ga_len == 0)
2502 break;
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
2518 == SPTYPE_START
2519 && !(cur_si->si_flags & (HL_MATCH | HL_KEEPEND)))
2521 update_si_end(cur_si, (int)current_col, TRUE);
2522 check_keepend();
2523 if ((current_next_flags & HL_HAS_EOL)
2524 && keepend_level < 0
2525 && syn_getcurline()[current_col] == NUL)
2526 break;
2530 else
2531 break;
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.
2539 static void
2540 update_si_attr(idx)
2541 int idx;
2543 stateitem_T *sip = &CUR_STATE(idx);
2544 synpat_T *spp;
2546 /* This should not happen... */
2547 if (sip->si_idx < 0)
2548 return;
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;
2553 else
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;
2559 else
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))
2569 if (idx == 0)
2571 sip->si_attr = 0;
2572 sip->si_trans_id = 0;
2573 if (sip->si_cont_list == NULL)
2574 sip->si_cont_list = ID_LIST_ALL;
2576 else
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.
2595 static void
2596 check_keepend()
2598 int i;
2599 lpos_T maxpos;
2600 lpos_T maxpos_h;
2601 stateitem_T *sip;
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)
2608 return;
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)
2617 break;
2619 maxpos.lnum = 0;
2620 maxpos_h.lnum = 0;
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.
2653 static void
2654 update_si_end(sip, startcol, force)
2655 stateitem_T *sip;
2656 int startcol; /* where to start searching for the end */
2657 int force; /* when TRUE overrule a previous end */
2659 lpos_T startpos;
2660 lpos_T endpos;
2661 lpos_T hl_endpos;
2662 lpos_T end_endpos;
2663 int end_idx;
2665 /* return quickly for a keyword */
2666 if (sip->si_idx < 0)
2667 return;
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)
2673 return;
2676 * We need to find the end of the region. It may continue in the next
2677 * line.
2679 end_idx = 0;
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());
2695 else
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;
2703 else
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).
2719 static int
2720 push_current_state(idx)
2721 int idx;
2723 if (ga_grow(&current_state, 1) == FAIL)
2724 return 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;
2728 return OK;
2732 * Remove a state from the current_state stack.
2734 static void
2735 pop_current_state()
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)
2747 keepend_level = -1;
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
2755 * will be 0.
2756 * If found, the end of the region and the end of the highlighting is
2757 * computed.
2759 static void
2760 find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos,
2761 end_idx, start_ext)
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 */
2771 colnr_T matchcol;
2772 synpat_T *spp, *spp_skip;
2773 int start_idx;
2774 int best_idx;
2775 regmmatch_T regmatch;
2776 regmmatch_T best_regmatch; /* startpos/endpos of best match */
2777 lpos_T pos;
2778 char_u *line;
2779 int had_match = FALSE;
2781 /* just in case we are invoked for a keyword */
2782 if (idx < 0)
2783 return;
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;
2794 return;
2798 * Find the SKIP or first END pattern after the last START pattern.
2800 for (;;)
2802 spp = &(SYN_ITEMS(syn_buf)[idx]);
2803 if (spp->sp_type != SPTYPE_START)
2804 break;
2805 ++idx;
2809 * Lookup the SKIP pattern (if present)
2811 if (spp->sp_type == SPTYPE_SKIP)
2813 spp_skip = spp;
2814 ++idx;
2816 else
2817 spp_skip = NULL;
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 */
2826 for (;;)
2829 * Find end pattern that matches first after "matchcol".
2831 best_idx = -1;
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 */
2838 break;
2839 lc_col -= spp->sp_offsets[SPO_LC_OFF];
2840 if (lc_col < 0)
2841 lc_col = 0;
2843 regmatch.rmm_ic = spp->sp_ic;
2844 regmatch.regprog = spp->sp_prog;
2845 if (syn_regexec(&regmatch, startpos->lnum, lc_col))
2847 if (best_idx == -1 || regmatch.startpos[0].col
2848 < best_regmatch.startpos[0].col)
2850 best_idx = idx;
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.
2861 if (best_idx == -1)
2862 break;
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];
2872 if (lc_col < 0)
2873 lc_col = 0;
2874 regmatch.rmm_ic = spp_skip->sp_ic;
2875 regmatch.regprog = spp_skip->sp_prog;
2876 if (syn_regexec(&regmatch, 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, &regmatch, 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)
2886 break;
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)
2892 ++matchcol;
2893 else if (pos.col <= regmatch.endpos[0].col)
2894 matchcol = pos.col;
2895 else
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;
2899 ++matchcol)
2902 /* if the skip pattern includes end-of-line, break here */
2903 if (line[matchcol] == NUL)
2904 break;
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;
2939 else
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;
2956 else
2958 *end_idx = 0;
2959 *hl_endpos = *end_endpos;
2962 *flagsp = spp->sp_flags;
2964 had_match = TRUE;
2965 break;
2968 /* no match for an END pattern in this line */
2969 if (!had_match)
2970 m_endpos->lnum = 0;
2972 /* Remove external matches. */
2973 unref_extmatch(re_extmatch_in);
2974 re_extmatch_in = NULL;
2978 * Limit "pos" not to be after "limit".
2980 static void
2981 limit_pos(pos, limit)
2982 lpos_T *pos;
2983 lpos_T *limit;
2985 if (pos->lnum > limit->lnum)
2986 *pos = *limit;
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.
2994 static void
2995 limit_pos_zero(pos, limit)
2996 lpos_T *pos;
2997 lpos_T *limit;
2999 if (pos->lnum == 0)
3000 *pos = *limit;
3001 else
3002 limit_pos(pos, limit);
3006 * Add offset to matched text for end of match or highlight.
3008 static void
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 */
3016 int col;
3017 int len;
3019 if (spp->sp_off_flags & (1 << idx))
3021 result->lnum = regmatch->startpos[0].lnum;
3022 col = regmatch->startpos[0].col + extra;
3024 else
3026 result->lnum = regmatch->endpos[0].lnum;
3027 col = regmatch->endpos[0].col;
3029 col += spp->sp_offsets[idx];
3030 if (col < 0)
3031 result->col = 0;
3032 else
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)
3037 len = 0;
3038 else
3039 len = (int)STRLEN(ml_get_buf(syn_buf, result->lnum, FALSE));
3040 if (col > len)
3041 result->col = len;
3042 else
3043 result->col = col;
3048 * Add offset to matched text for start of match or highlight.
3049 * Avoid resulting column to become negative.
3051 static void
3052 syn_add_start_off(result, regmatch, spp, idx, extra)
3053 lpos_T *result; /* returned position */
3054 regmmatch_T *regmatch; /* start/end of match */
3055 synpat_T *spp;
3056 int idx;
3057 int extra; /* extra chars for offset to end */
3059 int col;
3061 if (spp->sp_off_flags & (1 << (idx + SPO_COUNT)))
3063 result->lnum = regmatch->endpos[0].lnum;
3064 col = regmatch->endpos[0].col + extra;
3066 else
3068 result->lnum = regmatch->startpos[0].lnum;
3069 col = regmatch->startpos[0].col;
3071 col += spp->sp_offsets[idx];
3072 if (col < 0)
3073 result->col = 0;
3074 else
3075 result->col = col;
3079 * Get current line in syntax buffer.
3081 static char_u *
3082 syn_getcurline()
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.
3091 static int
3092 syn_regexec(rmp, lnum, col)
3093 regmmatch_T *rmp;
3094 linenr_T lnum;
3095 colnr_T 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;
3102 return TRUE;
3104 return FALSE;
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.
3112 static int
3113 check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si)
3114 char_u *line;
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 */
3121 keyentry_T *kp;
3122 char_u *kwp;
3123 int round;
3124 int kwlen;
3125 char_u keyword[MAXKEYWLEN + 1]; /* assume max. keyword len is 80 */
3126 hashtab_T *ht;
3127 hashitem_T *hi;
3129 /* Find first character after the keyword. First character was already
3130 * checked. */
3131 kwp = line + startcol;
3132 kwlen = 0;
3135 #ifdef FEAT_MBYTE
3136 if (has_mbyte)
3137 kwlen += (*mb_ptr2len)(kwp + kwlen);
3138 else
3139 #endif
3140 ++kwlen;
3142 while (vim_iswordc_buf(kwp + kwlen, syn_buf));
3144 if (kwlen > MAXKEYWLEN)
3145 return 0;
3148 * Must make a copy of the keyword, so we can add a NUL and make it
3149 * lowercase.
3151 vim_strncpy(keyword, kwp, kwlen);
3154 * Try twice:
3155 * 1. matching case
3156 * 2. ignoring case
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)
3162 continue;
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
3168 * attributes.
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)
3179 : (cur_si == NULL
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;
3191 return 0;
3195 * Handle ":syntax case" command.
3197 /* ARGSUSED */
3198 static void
3199 syn_cmd_case(eap, syncing)
3200 exarg_T *eap;
3201 int syncing; /* not used */
3203 char_u *arg = eap->arg;
3204 char_u *next;
3206 eap->nextcmd = find_nextcmd(arg);
3207 if (eap->skip)
3208 return;
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;
3215 else
3216 EMSG2(_("E390: Illegal argument: %s"), arg);
3220 * Handle ":syntax spell" command.
3222 /* ARGSUSED */
3223 static void
3224 syn_cmd_spell(eap, syncing)
3225 exarg_T *eap;
3226 int syncing; /* not used */
3228 char_u *arg = eap->arg;
3229 char_u *next;
3231 eap->nextcmd = find_nextcmd(arg);
3232 if (eap->skip)
3233 return;
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;
3242 else
3243 EMSG2(_("E390: Illegal argument: %s"), arg);
3247 * Clear all syntax info for one buffer.
3249 void
3250 syntax_clear(buf)
3251 buf_T *buf;
3253 int i;
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;
3285 #ifdef FEAT_FOLDING
3286 buf->b_syn_folditems = 0;
3287 #endif
3289 /* free the stored states */
3290 syn_stack_free_all(buf);
3291 invalidate_current_state();
3295 * Clear syncing info for one buffer.
3297 static void
3298 syntax_sync_clear()
3300 int i;
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.
3323 static void
3324 syn_remove_pattern(buf, idx)
3325 buf_T *buf;
3326 int idx;
3328 synpat_T *spp;
3330 spp = &(SYN_ITEMS(buf)[idx]);
3331 #ifdef FEAT_FOLDING
3332 if (spp->sp_flags & HL_FOLD)
3333 --buf->b_syn_folditems;
3334 #endif
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
3343 * last to first!
3345 static void
3346 syn_clear_pattern(buf, i)
3347 buf_T *buf;
3348 int 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);
3357 vim_free(SYN_ITEMS(buf)[i].sp_syn.cont_in_list);
3362 * Clear and free one syntax cluster.
3364 static void
3365 syn_clear_cluster(buf, i)
3366 buf_T *buf;
3367 int i;
3369 vim_free(SYN_CLSTR(buf)[i].scl_name);
3370 vim_free(SYN_CLSTR(buf)[i].scl_name_u);
3371 vim_free(SYN_CLSTR(buf)[i].scl_list);
3375 * Handle ":syntax clear" command.
3377 static void
3378 syn_cmd_clear(eap, syncing)
3379 exarg_T *eap;
3380 int syncing;
3382 char_u *arg = eap->arg;
3383 char_u *arg_end;
3384 int id;
3386 eap->nextcmd = find_nextcmd(arg);
3387 if (eap->skip)
3388 return;
3391 * We have to disable this within ":syn include @group filename",
3392 * because otherwise @group would get deleted.
3393 * Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
3394 * clear".
3396 if (curbuf->b_syn_topgrp != 0)
3397 return;
3399 if (ends_excmd(*arg))
3402 * No argument: Clear all syntax items.
3404 if (syncing)
3405 syntax_sync_clear();
3406 else
3408 syntax_clear(curbuf);
3409 do_unlet((char_u *)"b:current_syntax", TRUE);
3412 else
3415 * Clear the group IDs that are in the argument.
3417 while (!ends_excmd(*arg))
3419 arg_end = skiptowhite(arg);
3420 if (*arg == '@')
3422 id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
3423 if (id == 0)
3425 EMSG2(_("E391: No such syntax cluster: %s"), arg);
3426 break;
3428 else
3431 * We can't physically delete a cluster without changing
3432 * the IDs of other clusters, so we do the next best thing
3433 * and make it empty.
3435 short scl_id = id - SYNID_CLUSTER;
3437 vim_free(SYN_CLSTR(curbuf)[scl_id].scl_list);
3438 SYN_CLSTR(curbuf)[scl_id].scl_list = NULL;
3441 else
3443 id = syn_namen2id(arg, (int)(arg_end - arg));
3444 if (id == 0)
3446 EMSG2(_(e_nogroup), arg);
3447 break;
3449 else
3450 syn_clear_one(id, syncing);
3452 arg = skipwhite(arg_end);
3455 redraw_curbuf_later(SOME_VALID);
3456 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */
3460 * Clear one syntax group for the current buffer.
3462 static void
3463 syn_clear_one(id, syncing)
3464 int id;
3465 int syncing;
3467 synpat_T *spp;
3468 int idx;
3470 /* Clear keywords only when not ":syn sync clear group-name" */
3471 if (!syncing)
3473 (void)syn_clear_keyword(id, &curbuf->b_keywtab);
3474 (void)syn_clear_keyword(id, &curbuf->b_keywtab_ic);
3477 /* clear the patterns for "id" */
3478 for (idx = curbuf->b_syn_patterns.ga_len; --idx >= 0; )
3480 spp = &(SYN_ITEMS(curbuf)[idx]);
3481 if (spp->sp_syn.id != id || spp->sp_syncing != syncing)
3482 continue;
3483 syn_remove_pattern(curbuf, idx);
3488 * Handle ":syntax on" command.
3490 /* ARGSUSED */
3491 static void
3492 syn_cmd_on(eap, syncing)
3493 exarg_T *eap;
3494 int syncing; /* not used */
3496 syn_cmd_onoff(eap, "syntax");
3500 * Handle ":syntax enable" command.
3502 /* ARGSUSED */
3503 static void
3504 syn_cmd_enable(eap, syncing)
3505 exarg_T *eap;
3506 int syncing; /* not used */
3508 set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"enable");
3509 syn_cmd_onoff(eap, "syntax");
3510 do_unlet((char_u *)"g:syntax_cmd", TRUE);
3514 * Handle ":syntax reset" command.
3516 /* ARGSUSED */
3517 static void
3518 syn_cmd_reset(eap, syncing)
3519 exarg_T *eap;
3520 int syncing; /* not used */
3522 eap->nextcmd = check_nextcmd(eap->arg);
3523 if (!eap->skip)
3525 set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"reset");
3526 do_cmdline_cmd((char_u *)"runtime! syntax/syncolor.vim");
3527 do_unlet((char_u *)"g:syntax_cmd", TRUE);
3532 * Handle ":syntax manual" command.
3534 /* ARGSUSED */
3535 static void
3536 syn_cmd_manual(eap, syncing)
3537 exarg_T *eap;
3538 int syncing; /* not used */
3540 syn_cmd_onoff(eap, "manual");
3544 * Handle ":syntax off" command.
3546 /* ARGSUSED */
3547 static void
3548 syn_cmd_off(eap, syncing)
3549 exarg_T *eap;
3550 int syncing; /* not used */
3552 syn_cmd_onoff(eap, "nosyntax");
3555 static void
3556 syn_cmd_onoff(eap, name)
3557 exarg_T *eap;
3558 char *name;
3560 char_u buf[100];
3562 eap->nextcmd = check_nextcmd(eap->arg);
3563 if (!eap->skip)
3565 STRCPY(buf, "so ");
3566 vim_snprintf((char *)buf + 3, sizeof(buf) - 3, SYNTAX_FNAME, name);
3567 do_cmdline_cmd(buf);
3572 * Handle ":syntax [list]" command: list current syntax words.
3574 static void
3575 syn_cmd_list(eap, syncing)
3576 exarg_T *eap;
3577 int syncing; /* when TRUE: list syncing items */
3579 char_u *arg = eap->arg;
3580 int id;
3581 char_u *arg_end;
3583 eap->nextcmd = find_nextcmd(arg);
3584 if (eap->skip)
3585 return;
3587 if (!syntax_present(curbuf))
3589 MSG(_("No Syntax items defined for this buffer"));
3590 return;
3593 if (syncing)
3595 if (curbuf->b_syn_sync_flags & SF_CCOMMENT)
3597 MSG_PUTS(_("syncing on C-style comments"));
3598 syn_lines_msg();
3599 syn_match_msg();
3600 return;
3602 else if (!(curbuf->b_syn_sync_flags & SF_MATCH))
3604 if (curbuf->b_syn_sync_minlines == 0)
3605 MSG_PUTS(_("no syncing"));
3606 else
3608 MSG_PUTS(_("syncing starts "));
3609 msg_outnum(curbuf->b_syn_sync_minlines);
3610 MSG_PUTS(_(" lines before top line"));
3611 syn_match_msg();
3613 return;
3615 MSG_PUTS_TITLE(_("\n--- Syntax sync items ---"));
3616 if (curbuf->b_syn_sync_minlines > 0
3617 || curbuf->b_syn_sync_maxlines > 0
3618 || curbuf->b_syn_sync_linebreaks > 0)
3620 MSG_PUTS(_("\nsyncing on items"));
3621 syn_lines_msg();
3622 syn_match_msg();
3625 else
3626 MSG_PUTS_TITLE(_("\n--- Syntax items ---"));
3627 if (ends_excmd(*arg))
3630 * No argument: List all group IDs and all syntax clusters.
3632 for (id = 1; id <= highlight_ga.ga_len && !got_int; ++id)
3633 syn_list_one(id, syncing, FALSE);
3634 for (id = 0; id < curbuf->b_syn_clusters.ga_len && !got_int; ++id)
3635 syn_list_cluster(id);
3637 else
3640 * List the group IDs and syntax clusters that are in the argument.
3642 while (!ends_excmd(*arg) && !got_int)
3644 arg_end = skiptowhite(arg);
3645 if (*arg == '@')
3647 id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
3648 if (id == 0)
3649 EMSG2(_("E392: No such syntax cluster: %s"), arg);
3650 else
3651 syn_list_cluster(id - SYNID_CLUSTER);
3653 else
3655 id = syn_namen2id(arg, (int)(arg_end - arg));
3656 if (id == 0)
3657 EMSG2(_(e_nogroup), arg);
3658 else
3659 syn_list_one(id, syncing, TRUE);
3661 arg = skipwhite(arg_end);
3664 eap->nextcmd = check_nextcmd(arg);
3667 static void
3668 syn_lines_msg()
3670 if (curbuf->b_syn_sync_maxlines > 0 || curbuf->b_syn_sync_minlines > 0)
3672 MSG_PUTS("; ");
3673 if (curbuf->b_syn_sync_minlines > 0)
3675 MSG_PUTS(_("minimal "));
3676 msg_outnum(curbuf->b_syn_sync_minlines);
3677 if (curbuf->b_syn_sync_maxlines)
3678 MSG_PUTS(", ");
3680 if (curbuf->b_syn_sync_maxlines > 0)
3682 MSG_PUTS(_("maximal "));
3683 msg_outnum(curbuf->b_syn_sync_maxlines);
3685 MSG_PUTS(_(" lines before top line"));
3689 static void
3690 syn_match_msg()
3692 if (curbuf->b_syn_sync_linebreaks > 0)
3694 MSG_PUTS(_("; match "));
3695 msg_outnum(curbuf->b_syn_sync_linebreaks);
3696 MSG_PUTS(_(" line breaks"));
3700 static int last_matchgroup;
3702 struct name_list
3704 int flag;
3705 char *name;
3708 static void syn_list_flags __ARGS((struct name_list *nl, int flags, int attr));
3711 * List one syntax item, for ":syntax" or "syntax list syntax_name".
3713 static void
3714 syn_list_one(id, syncing, link_only)
3715 int id;
3716 int syncing; /* when TRUE: list syncing items */
3717 int link_only; /* when TRUE; list link-only too */
3719 int attr;
3720 int idx;
3721 int did_header = FALSE;
3722 synpat_T *spp;
3723 static struct name_list namelist1[] =
3725 {HL_DISPLAY, "display"},
3726 {HL_CONTAINED, "contained"},
3727 {HL_ONELINE, "oneline"},
3728 {HL_KEEPEND, "keepend"},
3729 {HL_EXTEND, "extend"},
3730 {HL_EXCLUDENL, "excludenl"},
3731 {HL_TRANSP, "transparent"},
3732 {HL_FOLD, "fold"},
3733 {0, NULL}
3735 static struct name_list namelist2[] =
3737 {HL_SKIPWHITE, "skipwhite"},
3738 {HL_SKIPNL, "skipnl"},
3739 {HL_SKIPEMPTY, "skipempty"},
3740 {0, NULL}
3743 attr = hl_attr(HLF_D); /* highlight like directories */
3745 /* list the keywords for "id" */
3746 if (!syncing)
3748 did_header = syn_list_keywords(id, &curbuf->b_keywtab, FALSE, attr);
3749 did_header = syn_list_keywords(id, &curbuf->b_keywtab_ic,
3750 did_header, attr);
3753 /* list the patterns for "id" */
3754 for (idx = 0; idx < curbuf->b_syn_patterns.ga_len && !got_int; ++idx)
3756 spp = &(SYN_ITEMS(curbuf)[idx]);
3757 if (spp->sp_syn.id != id || spp->sp_syncing != syncing)
3758 continue;
3760 (void)syn_list_header(did_header, 999, id);
3761 did_header = TRUE;
3762 last_matchgroup = 0;
3763 if (spp->sp_type == SPTYPE_MATCH)
3765 put_pattern("match", ' ', spp, attr);
3766 msg_putchar(' ');
3768 else if (spp->sp_type == SPTYPE_START)
3770 while (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_START)
3771 put_pattern("start", '=', &SYN_ITEMS(curbuf)[idx++], attr);
3772 if (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_SKIP)
3773 put_pattern("skip", '=', &SYN_ITEMS(curbuf)[idx++], attr);
3774 while (idx < curbuf->b_syn_patterns.ga_len
3775 && SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_END)
3776 put_pattern("end", '=', &SYN_ITEMS(curbuf)[idx++], attr);
3777 --idx;
3778 msg_putchar(' ');
3780 syn_list_flags(namelist1, spp->sp_flags, attr);
3782 if (spp->sp_cont_list != NULL)
3783 put_id_list((char_u *)"contains", spp->sp_cont_list, attr);
3785 if (spp->sp_syn.cont_in_list != NULL)
3786 put_id_list((char_u *)"containedin",
3787 spp->sp_syn.cont_in_list, attr);
3789 if (spp->sp_next_list != NULL)
3791 put_id_list((char_u *)"nextgroup", spp->sp_next_list, attr);
3792 syn_list_flags(namelist2, spp->sp_flags, attr);
3794 if (spp->sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE))
3796 if (spp->sp_flags & HL_SYNC_HERE)
3797 msg_puts_attr((char_u *)"grouphere", attr);
3798 else
3799 msg_puts_attr((char_u *)"groupthere", attr);
3800 msg_putchar(' ');
3801 if (spp->sp_sync_idx >= 0)
3802 msg_outtrans(HL_TABLE()[SYN_ITEMS(curbuf)
3803 [spp->sp_sync_idx].sp_syn.id - 1].sg_name);
3804 else
3805 MSG_PUTS("NONE");
3806 msg_putchar(' ');
3810 /* list the link, if there is one */
3811 if (HL_TABLE()[id - 1].sg_link && (did_header || link_only) && !got_int)
3813 (void)syn_list_header(did_header, 999, id);
3814 msg_puts_attr((char_u *)"links to", attr);
3815 msg_putchar(' ');
3816 msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name);
3820 static void
3821 syn_list_flags(nl, flags, attr)
3822 struct name_list *nl;
3823 int flags;
3824 int attr;
3826 int i;
3828 for (i = 0; nl[i].flag != 0; ++i)
3829 if (flags & nl[i].flag)
3831 msg_puts_attr((char_u *)nl[i].name, attr);
3832 msg_putchar(' ');
3837 * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
3839 static void
3840 syn_list_cluster(id)
3841 int id;
3843 int endcol = 15;
3845 /* slight hack: roughly duplicate the guts of syn_list_header() */
3846 msg_putchar('\n');
3847 msg_outtrans(SYN_CLSTR(curbuf)[id].scl_name);
3849 if (msg_col >= endcol) /* output at least one space */
3850 endcol = msg_col + 1;
3851 if (Columns <= endcol) /* avoid hang for tiny window */
3852 endcol = Columns - 1;
3854 msg_advance(endcol);
3855 if (SYN_CLSTR(curbuf)[id].scl_list != NULL)
3857 put_id_list((char_u *)"cluster", SYN_CLSTR(curbuf)[id].scl_list,
3858 hl_attr(HLF_D));
3860 else
3862 msg_puts_attr((char_u *)"cluster", hl_attr(HLF_D));
3863 msg_puts((char_u *)"=NONE");
3867 static void
3868 put_id_list(name, list, attr)
3869 char_u *name;
3870 short *list;
3871 int attr;
3873 short *p;
3875 msg_puts_attr(name, attr);
3876 msg_putchar('=');
3877 for (p = list; *p; ++p)
3879 if (*p >= SYNID_ALLBUT && *p < SYNID_TOP)
3881 if (p[1])
3882 MSG_PUTS("ALLBUT");
3883 else
3884 MSG_PUTS("ALL");
3886 else if (*p >= SYNID_TOP && *p < SYNID_CONTAINED)
3888 MSG_PUTS("TOP");
3890 else if (*p >= SYNID_CONTAINED && *p < SYNID_CLUSTER)
3892 MSG_PUTS("CONTAINED");
3894 else if (*p >= SYNID_CLUSTER)
3896 short scl_id = *p - SYNID_CLUSTER;
3898 msg_putchar('@');
3899 msg_outtrans(SYN_CLSTR(curbuf)[scl_id].scl_name);
3901 else
3902 msg_outtrans(HL_TABLE()[*p - 1].sg_name);
3903 if (p[1])
3904 msg_putchar(',');
3906 msg_putchar(' ');
3909 static void
3910 put_pattern(s, c, spp, attr)
3911 char *s;
3912 int c;
3913 synpat_T *spp;
3914 int attr;
3916 long n;
3917 int mask;
3918 int first;
3919 static char *sepchars = "/+=-#@\"|'^&";
3920 int i;
3922 /* May have to write "matchgroup=group" */
3923 if (last_matchgroup != spp->sp_syn_match_id)
3925 last_matchgroup = spp->sp_syn_match_id;
3926 msg_puts_attr((char_u *)"matchgroup", attr);
3927 msg_putchar('=');
3928 if (last_matchgroup == 0)
3929 msg_outtrans((char_u *)"NONE");
3930 else
3931 msg_outtrans(HL_TABLE()[last_matchgroup - 1].sg_name);
3932 msg_putchar(' ');
3935 /* output the name of the pattern and an '=' or ' ' */
3936 msg_puts_attr((char_u *)s, attr);
3937 msg_putchar(c);
3939 /* output the pattern, in between a char that is not in the pattern */
3940 for (i = 0; vim_strchr(spp->sp_pattern, sepchars[i]) != NULL; )
3941 if (sepchars[++i] == NUL)
3943 i = 0; /* no good char found, just use the first one */
3944 break;
3946 msg_putchar(sepchars[i]);
3947 msg_outtrans(spp->sp_pattern);
3948 msg_putchar(sepchars[i]);
3950 /* output any pattern options */
3951 first = TRUE;
3952 for (i = 0; i < SPO_COUNT; ++i)
3954 mask = (1 << i);
3955 if (spp->sp_off_flags & (mask + (mask << SPO_COUNT)))
3957 if (!first)
3958 msg_putchar(','); /* separate with commas */
3959 msg_puts((char_u *)spo_name_tab[i]);
3960 n = spp->sp_offsets[i];
3961 if (i != SPO_LC_OFF)
3963 if (spp->sp_off_flags & mask)
3964 msg_putchar('s');
3965 else
3966 msg_putchar('e');
3967 if (n > 0)
3968 msg_putchar('+');
3970 if (n || i == SPO_LC_OFF)
3971 msg_outnum(n);
3972 first = FALSE;
3975 msg_putchar(' ');
3979 * List or clear the keywords for one syntax group.
3980 * Return TRUE if the header has been printed.
3982 static int
3983 syn_list_keywords(id, ht, did_header, attr)
3984 int id;
3985 hashtab_T *ht;
3986 int did_header; /* header has already been printed */
3987 int attr;
3989 int outlen;
3990 hashitem_T *hi;
3991 keyentry_T *kp;
3992 int todo;
3993 int prev_contained = 0;
3994 short *prev_next_list = NULL;
3995 short *prev_cont_in_list = NULL;
3996 int prev_skipnl = 0;
3997 int prev_skipwhite = 0;
3998 int prev_skipempty = 0;
4001 * Unfortunately, this list of keywords is not sorted on alphabet but on
4002 * hash value...
4004 todo = (int)ht->ht_used;
4005 for (hi = ht->ht_array; todo > 0 && !got_int; ++hi)
4007 if (!HASHITEM_EMPTY(hi))
4009 --todo;
4010 for (kp = HI2KE(hi); kp != NULL && !got_int; kp = kp->ke_next)
4012 if (kp->k_syn.id == id)
4014 if (prev_contained != (kp->flags & HL_CONTAINED)
4015 || prev_skipnl != (kp->flags & HL_SKIPNL)
4016 || prev_skipwhite != (kp->flags & HL_SKIPWHITE)
4017 || prev_skipempty != (kp->flags & HL_SKIPEMPTY)
4018 || prev_cont_in_list != kp->k_syn.cont_in_list
4019 || prev_next_list != kp->next_list)
4020 outlen = 9999;
4021 else
4022 outlen = (int)STRLEN(kp->keyword);
4023 /* output "contained" and "nextgroup" on each line */
4024 if (syn_list_header(did_header, outlen, id))
4026 prev_contained = 0;
4027 prev_next_list = NULL;
4028 prev_cont_in_list = NULL;
4029 prev_skipnl = 0;
4030 prev_skipwhite = 0;
4031 prev_skipempty = 0;
4033 did_header = TRUE;
4034 if (prev_contained != (kp->flags & HL_CONTAINED))
4036 msg_puts_attr((char_u *)"contained", attr);
4037 msg_putchar(' ');
4038 prev_contained = (kp->flags & HL_CONTAINED);
4040 if (kp->k_syn.cont_in_list != prev_cont_in_list)
4042 put_id_list((char_u *)"containedin",
4043 kp->k_syn.cont_in_list, attr);
4044 msg_putchar(' ');
4045 prev_cont_in_list = kp->k_syn.cont_in_list;
4047 if (kp->next_list != prev_next_list)
4049 put_id_list((char_u *)"nextgroup", kp->next_list, attr);
4050 msg_putchar(' ');
4051 prev_next_list = kp->next_list;
4052 if (kp->flags & HL_SKIPNL)
4054 msg_puts_attr((char_u *)"skipnl", attr);
4055 msg_putchar(' ');
4056 prev_skipnl = (kp->flags & HL_SKIPNL);
4058 if (kp->flags & HL_SKIPWHITE)
4060 msg_puts_attr((char_u *)"skipwhite", attr);
4061 msg_putchar(' ');
4062 prev_skipwhite = (kp->flags & HL_SKIPWHITE);
4064 if (kp->flags & HL_SKIPEMPTY)
4066 msg_puts_attr((char_u *)"skipempty", attr);
4067 msg_putchar(' ');
4068 prev_skipempty = (kp->flags & HL_SKIPEMPTY);
4071 msg_outtrans(kp->keyword);
4077 return did_header;
4080 static void
4081 syn_clear_keyword(id, ht)
4082 int id;
4083 hashtab_T *ht;
4085 hashitem_T *hi;
4086 keyentry_T *kp;
4087 keyentry_T *kp_prev;
4088 keyentry_T *kp_next;
4089 int todo;
4091 hash_lock(ht);
4092 todo = (int)ht->ht_used;
4093 for (hi = ht->ht_array; todo > 0; ++hi)
4095 if (!HASHITEM_EMPTY(hi))
4097 --todo;
4098 kp_prev = NULL;
4099 for (kp = HI2KE(hi); kp != NULL; )
4101 if (kp->k_syn.id == id)
4103 kp_next = kp->ke_next;
4104 if (kp_prev == NULL)
4106 if (kp_next == NULL)
4107 hash_remove(ht, hi);
4108 else
4109 hi->hi_key = KE2HIKEY(kp_next);
4111 else
4112 kp_prev->ke_next = kp_next;
4113 vim_free(kp->next_list);
4114 vim_free(kp->k_syn.cont_in_list);
4115 vim_free(kp);
4116 kp = kp_next;
4118 else
4120 kp_prev = kp;
4121 kp = kp->ke_next;
4126 hash_unlock(ht);
4130 * Clear a whole keyword table.
4132 static void
4133 clear_keywtab(ht)
4134 hashtab_T *ht;
4136 hashitem_T *hi;
4137 int todo;
4138 keyentry_T *kp;
4139 keyentry_T *kp_next;
4141 todo = (int)ht->ht_used;
4142 for (hi = ht->ht_array; todo > 0; ++hi)
4144 if (!HASHITEM_EMPTY(hi))
4146 --todo;
4147 kp = HI2KE(hi);
4148 for (kp = HI2KE(hi); kp != NULL; kp = kp_next)
4150 kp_next = kp->ke_next;
4151 vim_free(kp->next_list);
4152 vim_free(kp->k_syn.cont_in_list);
4153 vim_free(kp);
4157 hash_clear(ht);
4158 hash_init(ht);
4162 * Add a keyword to the list of keywords.
4164 static void
4165 add_keyword(name, id, flags, cont_in_list, next_list)
4166 char_u *name; /* name of keyword */
4167 int id; /* group ID for this keyword */
4168 int flags; /* flags for this keyword */
4169 short *cont_in_list; /* containedin for this keyword */
4170 short *next_list; /* nextgroup for this keyword */
4172 keyentry_T *kp;
4173 hashtab_T *ht;
4174 hashitem_T *hi;
4175 char_u *name_ic;
4176 long_u hash;
4177 char_u name_folded[MAXKEYWLEN + 1];
4179 if (curbuf->b_syn_ic)
4180 name_ic = str_foldcase(name, (int)STRLEN(name),
4181 name_folded, MAXKEYWLEN + 1);
4182 else
4183 name_ic = name;
4184 kp = (keyentry_T *)alloc((int)(sizeof(keyentry_T) + STRLEN(name_ic)));
4185 if (kp == NULL)
4186 return;
4187 STRCPY(kp->keyword, name_ic);
4188 kp->k_syn.id = id;
4189 kp->k_syn.inc_tag = current_syn_inc_tag;
4190 kp->flags = flags;
4191 kp->k_syn.cont_in_list = copy_id_list(cont_in_list);
4192 if (cont_in_list != NULL)
4193 curbuf->b_syn_containedin = TRUE;
4194 kp->next_list = copy_id_list(next_list);
4196 if (curbuf->b_syn_ic)
4197 ht = &curbuf->b_keywtab_ic;
4198 else
4199 ht = &curbuf->b_keywtab;
4201 hash = hash_hash(kp->keyword);
4202 hi = hash_lookup(ht, kp->keyword, hash);
4203 if (HASHITEM_EMPTY(hi))
4205 /* new keyword, add to hashtable */
4206 kp->ke_next = NULL;
4207 hash_add_item(ht, hi, kp->keyword, hash);
4209 else
4211 /* keyword already exists, prepend to list */
4212 kp->ke_next = HI2KE(hi);
4213 hi->hi_key = KE2HIKEY(kp);
4218 * Get the start and end of the group name argument.
4219 * Return a pointer to the first argument.
4220 * Return NULL if the end of the command was found instead of further args.
4222 static char_u *
4223 get_group_name(arg, name_end)
4224 char_u *arg; /* start of the argument */
4225 char_u **name_end; /* pointer to end of the name */
4227 char_u *rest;
4229 *name_end = skiptowhite(arg);
4230 rest = skipwhite(*name_end);
4233 * Check if there are enough arguments. The first argument may be a
4234 * pattern, where '|' is allowed, so only check for NUL.
4236 if (ends_excmd(*arg) || *rest == NUL)
4237 return NULL;
4238 return rest;
4242 * Check for syntax command option arguments.
4243 * This can be called at any place in the list of arguments, and just picks
4244 * out the arguments that are known. Can be called several times in a row to
4245 * collect all options in between other arguments.
4246 * Return a pointer to the next argument (which isn't an option).
4247 * Return NULL for any error;
4249 static char_u *
4250 get_syn_options(arg, opt)
4251 char_u *arg; /* next argument to be checked */
4252 syn_opt_arg_T *opt; /* various things */
4254 char_u *gname_start, *gname;
4255 int syn_id;
4256 int len;
4257 char *p;
4258 int i;
4259 int fidx;
4260 static struct flag
4262 char *name;
4263 int argtype;
4264 int flags;
4265 } flagtab[] = { {"cCoOnNtTaAiInNeEdD", 0, HL_CONTAINED},
4266 {"oOnNeElLiInNeE", 0, HL_ONELINE},
4267 {"kKeEeEpPeEnNdD", 0, HL_KEEPEND},
4268 {"eExXtTeEnNdD", 0, HL_EXTEND},
4269 {"eExXcClLuUdDeEnNlL", 0, HL_EXCLUDENL},
4270 {"tTrRaAnNsSpPaArReEnNtT", 0, HL_TRANSP},
4271 {"sSkKiIpPnNlL", 0, HL_SKIPNL},
4272 {"sSkKiIpPwWhHiItTeE", 0, HL_SKIPWHITE},
4273 {"sSkKiIpPeEmMpPtTyY", 0, HL_SKIPEMPTY},
4274 {"gGrRoOuUpPhHeErReE", 0, HL_SYNC_HERE},
4275 {"gGrRoOuUpPtThHeErReE", 0, HL_SYNC_THERE},
4276 {"dDiIsSpPlLaAyY", 0, HL_DISPLAY},
4277 {"fFoOlLdD", 0, HL_FOLD},
4278 {"cCoOnNtTaAiInNsS", 1, 0},
4279 {"cCoOnNtTaAiInNeEdDiInN", 2, 0},
4280 {"nNeExXtTgGrRoOuUpP", 3, 0},
4282 static char *first_letters = "cCoOkKeEtTsSgGdDfFnN";
4284 if (arg == NULL) /* already detected error */
4285 return NULL;
4287 for (;;)
4290 * This is used very often when a large number of keywords is defined.
4291 * Need to skip quickly when no option name is found.
4292 * Also avoid tolower(), it's slow.
4294 if (strchr(first_letters, *arg) == NULL)
4295 break;
4297 for (fidx = sizeof(flagtab) / sizeof(struct flag); --fidx >= 0; )
4299 p = flagtab[fidx].name;
4300 for (i = 0, len = 0; p[i] != NUL; i += 2, ++len)
4301 if (arg[len] != p[i] && arg[len] != p[i + 1])
4302 break;
4303 if (p[i] == NUL && (vim_iswhite(arg[len])
4304 || (flagtab[fidx].argtype > 0
4305 ? arg[len] == '='
4306 : ends_excmd(arg[len]))))
4308 if (opt->keyword
4309 && (flagtab[fidx].flags == HL_DISPLAY
4310 || flagtab[fidx].flags == HL_FOLD
4311 || flagtab[fidx].flags == HL_EXTEND))
4312 /* treat "display", "fold" and "extend" as a keyword */
4313 fidx = -1;
4314 break;
4317 if (fidx < 0) /* no match found */
4318 break;
4320 if (flagtab[fidx].argtype == 1)
4322 if (!opt->has_cont_list)
4324 EMSG(_("E395: contains argument not accepted here"));
4325 return NULL;
4327 if (get_id_list(&arg, 8, &opt->cont_list) == FAIL)
4328 return NULL;
4330 else if (flagtab[fidx].argtype == 2)
4332 #if 0 /* cannot happen */
4333 if (opt->cont_in_list == NULL)
4335 EMSG(_("E396: containedin argument not accepted here"));
4336 return NULL;
4338 #endif
4339 if (get_id_list(&arg, 11, &opt->cont_in_list) == FAIL)
4340 return NULL;
4342 else if (flagtab[fidx].argtype == 3)
4344 if (get_id_list(&arg, 9, &opt->next_list) == FAIL)
4345 return NULL;
4347 else
4349 opt->flags |= flagtab[fidx].flags;
4350 arg = skipwhite(arg + len);
4352 if (flagtab[fidx].flags == HL_SYNC_HERE
4353 || flagtab[fidx].flags == HL_SYNC_THERE)
4355 if (opt->sync_idx == NULL)
4357 EMSG(_("E393: group[t]here not accepted here"));
4358 return NULL;
4360 gname_start = arg;
4361 arg = skiptowhite(arg);
4362 if (gname_start == arg)
4363 return NULL;
4364 gname = vim_strnsave(gname_start, (int)(arg - gname_start));
4365 if (gname == NULL)
4366 return NULL;
4367 if (STRCMP(gname, "NONE") == 0)
4368 *opt->sync_idx = NONE_IDX;
4369 else
4371 syn_id = syn_name2id(gname);
4372 for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; )
4373 if (SYN_ITEMS(curbuf)[i].sp_syn.id == syn_id
4374 && SYN_ITEMS(curbuf)[i].sp_type == SPTYPE_START)
4376 *opt->sync_idx = i;
4377 break;
4379 if (i < 0)
4381 EMSG2(_("E394: Didn't find region item for %s"), gname);
4382 vim_free(gname);
4383 return NULL;
4387 vim_free(gname);
4388 arg = skipwhite(arg);
4390 #ifdef FEAT_FOLDING
4391 else if (flagtab[fidx].flags == HL_FOLD
4392 && foldmethodIsSyntax(curwin))
4393 /* Need to update folds later. */
4394 foldUpdateAll(curwin);
4395 #endif
4399 return arg;
4403 * Adjustments to syntax item when declared in a ":syn include"'d file.
4404 * Set the contained flag, and if the item is not already contained, add it
4405 * to the specified top-level group, if any.
4407 static void
4408 syn_incl_toplevel(id, flagsp)
4409 int id;
4410 int *flagsp;
4412 if ((*flagsp & HL_CONTAINED) || curbuf->b_syn_topgrp == 0)
4413 return;
4414 *flagsp |= HL_CONTAINED;
4415 if (curbuf->b_syn_topgrp >= SYNID_CLUSTER)
4417 /* We have to alloc this, because syn_combine_list() will free it. */
4418 short *grp_list = (short *)alloc((unsigned)(2 * sizeof(short)));
4419 int tlg_id = curbuf->b_syn_topgrp - SYNID_CLUSTER;
4421 if (grp_list != NULL)
4423 grp_list[0] = id;
4424 grp_list[1] = 0;
4425 syn_combine_list(&SYN_CLSTR(curbuf)[tlg_id].scl_list, &grp_list,
4426 CLUSTER_ADD);
4432 * Handle ":syntax include [@{group-name}] filename" command.
4434 /* ARGSUSED */
4435 static void
4436 syn_cmd_include(eap, syncing)
4437 exarg_T *eap;
4438 int syncing; /* not used */
4440 char_u *arg = eap->arg;
4441 int sgl_id = 1;
4442 char_u *group_name_end;
4443 char_u *rest;
4444 char_u *errormsg = NULL;
4445 int prev_toplvl_grp;
4446 int prev_syn_inc_tag;
4447 int source = FALSE;
4449 eap->nextcmd = find_nextcmd(arg);
4450 if (eap->skip)
4451 return;
4453 if (arg[0] == '@')
4455 ++arg;
4456 rest = get_group_name(arg, &group_name_end);
4457 if (rest == NULL)
4459 EMSG((char_u *)_("E397: Filename required"));
4460 return;
4462 sgl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
4463 /* separate_nextcmd() and expand_filename() depend on this */
4464 eap->arg = rest;
4468 * Everything that's left, up to the next command, should be the
4469 * filename to include.
4471 eap->argt |= (XFILE | NOSPC);
4472 separate_nextcmd(eap);
4473 if (*eap->arg == '<' || *eap->arg == '$' || mch_isFullName(eap->arg))
4475 /* For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the
4476 * file. Need to expand the file name first. In other cases
4477 * ":runtime!" is used. */
4478 source = TRUE;
4479 if (expand_filename(eap, syn_cmdlinep, &errormsg) == FAIL)
4481 if (errormsg != NULL)
4482 EMSG(errormsg);
4483 return;
4488 * Save and restore the existing top-level grouplist id and ":syn
4489 * include" tag around the actual inclusion.
4491 prev_syn_inc_tag = current_syn_inc_tag;
4492 current_syn_inc_tag = ++running_syn_inc_tag;
4493 prev_toplvl_grp = curbuf->b_syn_topgrp;
4494 curbuf->b_syn_topgrp = sgl_id;
4495 if (source ? do_source(eap->arg, FALSE, DOSO_NONE) == FAIL
4496 : source_runtime(eap->arg, TRUE) == FAIL)
4497 EMSG2(_(e_notopen), eap->arg);
4498 curbuf->b_syn_topgrp = prev_toplvl_grp;
4499 current_syn_inc_tag = prev_syn_inc_tag;
4503 * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
4505 /* ARGSUSED */
4506 static void
4507 syn_cmd_keyword(eap, syncing)
4508 exarg_T *eap;
4509 int syncing; /* not used */
4511 char_u *arg = eap->arg;
4512 char_u *group_name_end;
4513 int syn_id;
4514 char_u *rest;
4515 char_u *keyword_copy;
4516 char_u *p;
4517 char_u *kw;
4518 syn_opt_arg_T syn_opt_arg;
4519 int cnt;
4521 rest = get_group_name(arg, &group_name_end);
4523 if (rest != NULL)
4525 syn_id = syn_check_group(arg, (int)(group_name_end - arg));
4527 /* allocate a buffer, for removing the backslashes in the keyword */
4528 keyword_copy = alloc((unsigned)STRLEN(rest) + 1);
4529 if (keyword_copy != NULL)
4531 syn_opt_arg.flags = 0;
4532 syn_opt_arg.keyword = TRUE;
4533 syn_opt_arg.sync_idx = NULL;
4534 syn_opt_arg.has_cont_list = FALSE;
4535 syn_opt_arg.cont_in_list = NULL;
4536 syn_opt_arg.next_list = NULL;
4539 * The options given apply to ALL keywords, so all options must be
4540 * found before keywords can be created.
4541 * 1: collect the options and copy the keywords to keyword_copy.
4543 cnt = 0;
4544 p = keyword_copy;
4545 for ( ; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest))
4547 rest = get_syn_options(rest, &syn_opt_arg);
4548 if (rest == NULL || ends_excmd(*rest))
4549 break;
4550 /* Copy the keyword, removing backslashes, and add a NUL. */
4551 while (*rest != NUL && !vim_iswhite(*rest))
4553 if (*rest == '\\' && rest[1] != NUL)
4554 ++rest;
4555 *p++ = *rest++;
4557 *p++ = NUL;
4558 ++cnt;
4561 if (!eap->skip)
4563 /* Adjust flags for use of ":syn include". */
4564 syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
4567 * 2: Add an entry for each keyword.
4569 for (kw = keyword_copy; --cnt >= 0; kw += STRLEN(kw) + 1)
4571 for (p = vim_strchr(kw, '['); ; )
4573 if (p != NULL)
4574 *p = NUL;
4575 add_keyword(kw, syn_id, syn_opt_arg.flags,
4576 syn_opt_arg.cont_in_list,
4577 syn_opt_arg.next_list);
4578 if (p == NULL)
4579 break;
4580 if (p[1] == NUL)
4582 EMSG2(_("E789: Missing ']': %s"), kw);
4583 kw = p + 2; /* skip over the NUL */
4584 break;
4586 if (p[1] == ']')
4588 kw = p + 1; /* skip over the "]" */
4589 break;
4591 #ifdef FEAT_MBYTE
4592 if (has_mbyte)
4594 int l = (*mb_ptr2len)(p + 1);
4596 mch_memmove(p, p + 1, l);
4597 p += l;
4599 else
4600 #endif
4602 p[0] = p[1];
4603 ++p;
4609 vim_free(keyword_copy);
4610 vim_free(syn_opt_arg.cont_in_list);
4611 vim_free(syn_opt_arg.next_list);
4615 if (rest != NULL)
4616 eap->nextcmd = check_nextcmd(rest);
4617 else
4618 EMSG2(_(e_invarg2), arg);
4620 redraw_curbuf_later(SOME_VALID);
4621 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */
4625 * Handle ":syntax match {name} [{options}] {pattern} [{options}]".
4627 * Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
4629 static void
4630 syn_cmd_match(eap, syncing)
4631 exarg_T *eap;
4632 int syncing; /* TRUE for ":syntax sync match .. " */
4634 char_u *arg = eap->arg;
4635 char_u *group_name_end;
4636 char_u *rest;
4637 synpat_T item; /* the item found in the line */
4638 int syn_id;
4639 int idx;
4640 syn_opt_arg_T syn_opt_arg;
4641 int sync_idx = 0;
4643 /* Isolate the group name, check for validity */
4644 rest = get_group_name(arg, &group_name_end);
4646 /* Get options before the pattern */
4647 syn_opt_arg.flags = 0;
4648 syn_opt_arg.keyword = FALSE;
4649 syn_opt_arg.sync_idx = syncing ? &sync_idx : NULL;
4650 syn_opt_arg.has_cont_list = TRUE;
4651 syn_opt_arg.cont_list = NULL;
4652 syn_opt_arg.cont_in_list = NULL;
4653 syn_opt_arg.next_list = NULL;
4654 rest = get_syn_options(rest, &syn_opt_arg);
4656 /* get the pattern. */
4657 init_syn_patterns();
4658 vim_memset(&item, 0, sizeof(item));
4659 rest = get_syn_pattern(rest, &item);
4660 if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL))
4661 syn_opt_arg.flags |= HL_HAS_EOL;
4663 /* Get options after the pattern */
4664 rest = get_syn_options(rest, &syn_opt_arg);
4666 if (rest != NULL) /* all arguments are valid */
4669 * Check for trailing command and illegal trailing arguments.
4671 eap->nextcmd = check_nextcmd(rest);
4672 if (!ends_excmd(*rest) || eap->skip)
4673 rest = NULL;
4674 else if (ga_grow(&curbuf->b_syn_patterns, 1) != FAIL
4675 && (syn_id = syn_check_group(arg,
4676 (int)(group_name_end - arg))) != 0)
4678 syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
4680 * Store the pattern in the syn_items list
4682 idx = curbuf->b_syn_patterns.ga_len;
4683 SYN_ITEMS(curbuf)[idx] = item;
4684 SYN_ITEMS(curbuf)[idx].sp_syncing = syncing;
4685 SYN_ITEMS(curbuf)[idx].sp_type = SPTYPE_MATCH;
4686 SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id;
4687 SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag;
4688 SYN_ITEMS(curbuf)[idx].sp_flags = syn_opt_arg.flags;
4689 SYN_ITEMS(curbuf)[idx].sp_sync_idx = sync_idx;
4690 SYN_ITEMS(curbuf)[idx].sp_cont_list = syn_opt_arg.cont_list;
4691 SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list =
4692 syn_opt_arg.cont_in_list;
4693 if (syn_opt_arg.cont_in_list != NULL)
4694 curbuf->b_syn_containedin = TRUE;
4695 SYN_ITEMS(curbuf)[idx].sp_next_list = syn_opt_arg.next_list;
4696 ++curbuf->b_syn_patterns.ga_len;
4698 /* remember that we found a match for syncing on */
4699 if (syn_opt_arg.flags & (HL_SYNC_HERE|HL_SYNC_THERE))
4700 curbuf->b_syn_sync_flags |= SF_MATCH;
4701 #ifdef FEAT_FOLDING
4702 if (syn_opt_arg.flags & HL_FOLD)
4703 ++curbuf->b_syn_folditems;
4704 #endif
4706 redraw_curbuf_later(SOME_VALID);
4707 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */
4708 return; /* don't free the progs and patterns now */
4713 * Something failed, free the allocated memory.
4715 vim_free(item.sp_prog);
4716 vim_free(item.sp_pattern);
4717 vim_free(syn_opt_arg.cont_list);
4718 vim_free(syn_opt_arg.cont_in_list);
4719 vim_free(syn_opt_arg.next_list);
4721 if (rest == NULL)
4722 EMSG2(_(e_invarg2), arg);
4726 * Handle ":syntax region {group-name} [matchgroup={group-name}]
4727 * start {start} .. [skip {skip}] end {end} .. [{options}]".
4729 static void
4730 syn_cmd_region(eap, syncing)
4731 exarg_T *eap;
4732 int syncing; /* TRUE for ":syntax sync region .." */
4734 char_u *arg = eap->arg;
4735 char_u *group_name_end;
4736 char_u *rest; /* next arg, NULL on error */
4737 char_u *key_end;
4738 char_u *key = NULL;
4739 char_u *p;
4740 int item;
4741 #define ITEM_START 0
4742 #define ITEM_SKIP 1
4743 #define ITEM_END 2
4744 #define ITEM_MATCHGROUP 3
4745 struct pat_ptr
4747 synpat_T *pp_synp; /* pointer to syn_pattern */
4748 int pp_matchgroup_id; /* matchgroup ID */
4749 struct pat_ptr *pp_next; /* pointer to next pat_ptr */
4750 } *(pat_ptrs[3]);
4751 /* patterns found in the line */
4752 struct pat_ptr *ppp;
4753 struct pat_ptr *ppp_next;
4754 int pat_count = 0; /* nr of syn_patterns found */
4755 int syn_id;
4756 int matchgroup_id = 0;
4757 int not_enough = FALSE; /* not enough arguments */
4758 int illegal = FALSE; /* illegal arguments */
4759 int success = FALSE;
4760 int idx;
4761 syn_opt_arg_T syn_opt_arg;
4763 /* Isolate the group name, check for validity */
4764 rest = get_group_name(arg, &group_name_end);
4766 pat_ptrs[0] = NULL;
4767 pat_ptrs[1] = NULL;
4768 pat_ptrs[2] = NULL;
4770 init_syn_patterns();
4772 syn_opt_arg.flags = 0;
4773 syn_opt_arg.keyword = FALSE;
4774 syn_opt_arg.sync_idx = NULL;
4775 syn_opt_arg.has_cont_list = TRUE;
4776 syn_opt_arg.cont_list = NULL;
4777 syn_opt_arg.cont_in_list = NULL;
4778 syn_opt_arg.next_list = NULL;
4781 * get the options, patterns and matchgroup.
4783 while (rest != NULL && !ends_excmd(*rest))
4785 /* Check for option arguments */
4786 rest = get_syn_options(rest, &syn_opt_arg);
4787 if (rest == NULL || ends_excmd(*rest))
4788 break;
4790 /* must be a pattern or matchgroup then */
4791 key_end = rest;
4792 while (*key_end && !vim_iswhite(*key_end) && *key_end != '=')
4793 ++key_end;
4794 vim_free(key);
4795 key = vim_strnsave_up(rest, (int)(key_end - rest));
4796 if (key == NULL) /* out of memory */
4798 rest = NULL;
4799 break;
4801 if (STRCMP(key, "MATCHGROUP") == 0)
4802 item = ITEM_MATCHGROUP;
4803 else if (STRCMP(key, "START") == 0)
4804 item = ITEM_START;
4805 else if (STRCMP(key, "END") == 0)
4806 item = ITEM_END;
4807 else if (STRCMP(key, "SKIP") == 0)
4809 if (pat_ptrs[ITEM_SKIP] != NULL) /* one skip pattern allowed */
4811 illegal = TRUE;
4812 break;
4814 item = ITEM_SKIP;
4816 else
4817 break;
4818 rest = skipwhite(key_end);
4819 if (*rest != '=')
4821 rest = NULL;
4822 EMSG2(_("E398: Missing '=': %s"), arg);
4823 break;
4825 rest = skipwhite(rest + 1);
4826 if (*rest == NUL)
4828 not_enough = TRUE;
4829 break;
4832 if (item == ITEM_MATCHGROUP)
4834 p = skiptowhite(rest);
4835 if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip)
4836 matchgroup_id = 0;
4837 else
4839 matchgroup_id = syn_check_group(rest, (int)(p - rest));
4840 if (matchgroup_id == 0)
4842 illegal = TRUE;
4843 break;
4846 rest = skipwhite(p);
4848 else
4851 * Allocate room for a syn_pattern, and link it in the list of
4852 * syn_patterns for this item, at the start (because the list is
4853 * used from end to start).
4855 ppp = (struct pat_ptr *)alloc((unsigned)sizeof(struct pat_ptr));
4856 if (ppp == NULL)
4858 rest = NULL;
4859 break;
4861 ppp->pp_next = pat_ptrs[item];
4862 pat_ptrs[item] = ppp;
4863 ppp->pp_synp = (synpat_T *)alloc_clear((unsigned)sizeof(synpat_T));
4864 if (ppp->pp_synp == NULL)
4866 rest = NULL;
4867 break;
4871 * Get the syntax pattern and the following offset(s).
4873 /* Enable the appropriate \z specials. */
4874 if (item == ITEM_START)
4875 reg_do_extmatch = REX_SET;
4876 else if (item == ITEM_SKIP || item == ITEM_END)
4877 reg_do_extmatch = REX_USE;
4878 rest = get_syn_pattern(rest, ppp->pp_synp);
4879 reg_do_extmatch = 0;
4880 if (item == ITEM_END && vim_regcomp_had_eol()
4881 && !(syn_opt_arg.flags & HL_EXCLUDENL))
4882 ppp->pp_synp->sp_flags |= HL_HAS_EOL;
4883 ppp->pp_matchgroup_id = matchgroup_id;
4884 ++pat_count;
4887 vim_free(key);
4888 if (illegal || not_enough)
4889 rest = NULL;
4892 * Must have a "start" and "end" pattern.
4894 if (rest != NULL && (pat_ptrs[ITEM_START] == NULL ||
4895 pat_ptrs[ITEM_END] == NULL))
4897 not_enough = TRUE;
4898 rest = NULL;
4901 if (rest != NULL)
4904 * Check for trailing garbage or command.
4905 * If OK, add the item.
4907 eap->nextcmd = check_nextcmd(rest);
4908 if (!ends_excmd(*rest) || eap->skip)
4909 rest = NULL;
4910 else if (ga_grow(&(curbuf->b_syn_patterns), pat_count) != FAIL
4911 && (syn_id = syn_check_group(arg,
4912 (int)(group_name_end - arg))) != 0)
4914 syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
4916 * Store the start/skip/end in the syn_items list
4918 idx = curbuf->b_syn_patterns.ga_len;
4919 for (item = ITEM_START; item <= ITEM_END; ++item)
4921 for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp->pp_next)
4923 SYN_ITEMS(curbuf)[idx] = *(ppp->pp_synp);
4924 SYN_ITEMS(curbuf)[idx].sp_syncing = syncing;
4925 SYN_ITEMS(curbuf)[idx].sp_type =
4926 (item == ITEM_START) ? SPTYPE_START :
4927 (item == ITEM_SKIP) ? SPTYPE_SKIP : SPTYPE_END;
4928 SYN_ITEMS(curbuf)[idx].sp_flags |= syn_opt_arg.flags;
4929 SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id;
4930 SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag;
4931 SYN_ITEMS(curbuf)[idx].sp_syn_match_id =
4932 ppp->pp_matchgroup_id;
4933 if (item == ITEM_START)
4935 SYN_ITEMS(curbuf)[idx].sp_cont_list =
4936 syn_opt_arg.cont_list;
4937 SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list =
4938 syn_opt_arg.cont_in_list;
4939 if (syn_opt_arg.cont_in_list != NULL)
4940 curbuf->b_syn_containedin = TRUE;
4941 SYN_ITEMS(curbuf)[idx].sp_next_list =
4942 syn_opt_arg.next_list;
4944 ++curbuf->b_syn_patterns.ga_len;
4945 ++idx;
4946 #ifdef FEAT_FOLDING
4947 if (syn_opt_arg.flags & HL_FOLD)
4948 ++curbuf->b_syn_folditems;
4949 #endif
4953 redraw_curbuf_later(SOME_VALID);
4954 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */
4955 success = TRUE; /* don't free the progs and patterns now */
4960 * Free the allocated memory.
4962 for (item = ITEM_START; item <= ITEM_END; ++item)
4963 for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp_next)
4965 if (!success)
4967 vim_free(ppp->pp_synp->sp_prog);
4968 vim_free(ppp->pp_synp->sp_pattern);
4970 vim_free(ppp->pp_synp);
4971 ppp_next = ppp->pp_next;
4972 vim_free(ppp);
4975 if (!success)
4977 vim_free(syn_opt_arg.cont_list);
4978 vim_free(syn_opt_arg.cont_in_list);
4979 vim_free(syn_opt_arg.next_list);
4980 if (not_enough)
4981 EMSG2(_("E399: Not enough arguments: syntax region %s"), arg);
4982 else if (illegal || rest == NULL)
4983 EMSG2(_(e_invarg2), arg);
4988 * A simple syntax group ID comparison function suitable for use in qsort()
4990 static int
4991 #ifdef __BORLANDC__
4992 _RTLENTRYF
4993 #endif
4994 syn_compare_stub(v1, v2)
4995 const void *v1;
4996 const void *v2;
4998 const short *s1 = v1;
4999 const short *s2 = v2;
5001 return (*s1 > *s2 ? 1 : *s1 < *s2 ? -1 : 0);
5005 * Combines lists of syntax clusters.
5006 * *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
5008 static void
5009 syn_combine_list(clstr1, clstr2, list_op)
5010 short **clstr1;
5011 short **clstr2;
5012 int list_op;
5014 int count1 = 0;
5015 int count2 = 0;
5016 short *g1;
5017 short *g2;
5018 short *clstr = NULL;
5019 int count;
5020 int round;
5023 * Handle degenerate cases.
5025 if (*clstr2 == NULL)
5026 return;
5027 if (*clstr1 == NULL || list_op == CLUSTER_REPLACE)
5029 if (list_op == CLUSTER_REPLACE)
5030 vim_free(*clstr1);
5031 if (list_op == CLUSTER_REPLACE || list_op == CLUSTER_ADD)
5032 *clstr1 = *clstr2;
5033 else
5034 vim_free(*clstr2);
5035 return;
5038 for (g1 = *clstr1; *g1; g1++)
5039 ++count1;
5040 for (g2 = *clstr2; *g2; g2++)
5041 ++count2;
5044 * For speed purposes, sort both lists.
5046 qsort(*clstr1, (size_t)count1, sizeof(short), syn_compare_stub);
5047 qsort(*clstr2, (size_t)count2, sizeof(short), syn_compare_stub);
5050 * We proceed in two passes; in round 1, we count the elements to place
5051 * in the new list, and in round 2, we allocate and populate the new
5052 * list. For speed, we use a mergesort-like method, adding the smaller
5053 * of the current elements in each list to the new list.
5055 for (round = 1; round <= 2; round++)
5057 g1 = *clstr1;
5058 g2 = *clstr2;
5059 count = 0;
5062 * First, loop through the lists until one of them is empty.
5064 while (*g1 && *g2)
5067 * We always want to add from the first list.
5069 if (*g1 < *g2)
5071 if (round == 2)
5072 clstr[count] = *g1;
5073 count++;
5074 g1++;
5075 continue;
5078 * We only want to add from the second list if we're adding the
5079 * lists.
5081 if (list_op == CLUSTER_ADD)
5083 if (round == 2)
5084 clstr[count] = *g2;
5085 count++;
5087 if (*g1 == *g2)
5088 g1++;
5089 g2++;
5093 * Now add the leftovers from whichever list didn't get finished
5094 * first. As before, we only want to add from the second list if
5095 * we're adding the lists.
5097 for (; *g1; g1++, count++)
5098 if (round == 2)
5099 clstr[count] = *g1;
5100 if (list_op == CLUSTER_ADD)
5101 for (; *g2; g2++, count++)
5102 if (round == 2)
5103 clstr[count] = *g2;
5105 if (round == 1)
5108 * If the group ended up empty, we don't need to allocate any
5109 * space for it.
5111 if (count == 0)
5113 clstr = NULL;
5114 break;
5116 clstr = (short *)alloc((unsigned)((count + 1) * sizeof(short)));
5117 if (clstr == NULL)
5118 break;
5119 clstr[count] = 0;
5124 * Finally, put the new list in place.
5126 vim_free(*clstr1);
5127 vim_free(*clstr2);
5128 *clstr1 = clstr;
5132 * Lookup a syntax cluster name and return it's ID.
5133 * If it is not found, 0 is returned.
5135 static int
5136 syn_scl_name2id(name)
5137 char_u *name;
5139 int i;
5140 char_u *name_u;
5142 /* Avoid using stricmp() too much, it's slow on some systems */
5143 name_u = vim_strsave_up(name);
5144 if (name_u == NULL)
5145 return 0;
5146 for (i = curbuf->b_syn_clusters.ga_len; --i >= 0; )
5147 if (SYN_CLSTR(curbuf)[i].scl_name_u != NULL
5148 && STRCMP(name_u, SYN_CLSTR(curbuf)[i].scl_name_u) == 0)
5149 break;
5150 vim_free(name_u);
5151 return (i < 0 ? 0 : i + SYNID_CLUSTER);
5155 * Like syn_scl_name2id(), but take a pointer + length argument.
5157 static int
5158 syn_scl_namen2id(linep, len)
5159 char_u *linep;
5160 int len;
5162 char_u *name;
5163 int id = 0;
5165 name = vim_strnsave(linep, len);
5166 if (name != NULL)
5168 id = syn_scl_name2id(name);
5169 vim_free(name);
5171 return id;
5175 * Find syntax cluster name in the table and return it's ID.
5176 * The argument is a pointer to the name and the length of the name.
5177 * If it doesn't exist yet, a new entry is created.
5178 * Return 0 for failure.
5180 static int
5181 syn_check_cluster(pp, len)
5182 char_u *pp;
5183 int len;
5185 int id;
5186 char_u *name;
5188 name = vim_strnsave(pp, len);
5189 if (name == NULL)
5190 return 0;
5192 id = syn_scl_name2id(name);
5193 if (id == 0) /* doesn't exist yet */
5194 id = syn_add_cluster(name);
5195 else
5196 vim_free(name);
5197 return id;
5201 * Add new syntax cluster and return it's ID.
5202 * "name" must be an allocated string, it will be consumed.
5203 * Return 0 for failure.
5205 static int
5206 syn_add_cluster(name)
5207 char_u *name;
5209 int len;
5212 * First call for this growarray: init growing array.
5214 if (curbuf->b_syn_clusters.ga_data == NULL)
5216 curbuf->b_syn_clusters.ga_itemsize = sizeof(syn_cluster_T);
5217 curbuf->b_syn_clusters.ga_growsize = 10;
5221 * Make room for at least one other cluster entry.
5223 if (ga_grow(&curbuf->b_syn_clusters, 1) == FAIL)
5225 vim_free(name);
5226 return 0;
5228 len = curbuf->b_syn_clusters.ga_len;
5230 vim_memset(&(SYN_CLSTR(curbuf)[len]), 0, sizeof(syn_cluster_T));
5231 SYN_CLSTR(curbuf)[len].scl_name = name;
5232 SYN_CLSTR(curbuf)[len].scl_name_u = vim_strsave_up(name);
5233 SYN_CLSTR(curbuf)[len].scl_list = NULL;
5234 ++curbuf->b_syn_clusters.ga_len;
5236 if (STRICMP(name, "Spell") == 0)
5237 curbuf->b_spell_cluster_id = len + SYNID_CLUSTER;
5238 if (STRICMP(name, "NoSpell") == 0)
5239 curbuf->b_nospell_cluster_id = len + SYNID_CLUSTER;
5241 return len + SYNID_CLUSTER;
5245 * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
5246 * [add={groupname},..] [remove={groupname},..]".
5248 /* ARGSUSED */
5249 static void
5250 syn_cmd_cluster(eap, syncing)
5251 exarg_T *eap;
5252 int syncing; /* not used */
5254 char_u *arg = eap->arg;
5255 char_u *group_name_end;
5256 char_u *rest;
5257 int scl_id;
5258 short *clstr_list;
5259 int got_clstr = FALSE;
5260 int opt_len;
5261 int list_op;
5263 eap->nextcmd = find_nextcmd(arg);
5264 if (eap->skip)
5265 return;
5267 rest = get_group_name(arg, &group_name_end);
5269 if (rest != NULL)
5271 scl_id = syn_check_cluster(arg, (int)(group_name_end - arg))
5272 - SYNID_CLUSTER;
5274 for (;;)
5276 if (STRNICMP(rest, "add", 3) == 0
5277 && (vim_iswhite(rest[3]) || rest[3] == '='))
5279 opt_len = 3;
5280 list_op = CLUSTER_ADD;
5282 else if (STRNICMP(rest, "remove", 6) == 0
5283 && (vim_iswhite(rest[6]) || rest[6] == '='))
5285 opt_len = 6;
5286 list_op = CLUSTER_SUBTRACT;
5288 else if (STRNICMP(rest, "contains", 8) == 0
5289 && (vim_iswhite(rest[8]) || rest[8] == '='))
5291 opt_len = 8;
5292 list_op = CLUSTER_REPLACE;
5294 else
5295 break;
5297 clstr_list = NULL;
5298 if (get_id_list(&rest, opt_len, &clstr_list) == FAIL)
5300 EMSG2(_(e_invarg2), rest);
5301 break;
5303 syn_combine_list(&SYN_CLSTR(curbuf)[scl_id].scl_list,
5304 &clstr_list, list_op);
5305 got_clstr = TRUE;
5308 if (got_clstr)
5310 redraw_curbuf_later(SOME_VALID);
5311 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */
5315 if (!got_clstr)
5316 EMSG(_("E400: No cluster specified"));
5317 if (rest == NULL || !ends_excmd(*rest))
5318 EMSG2(_(e_invarg2), arg);
5322 * On first call for current buffer: Init growing array.
5324 static void
5325 init_syn_patterns()
5327 curbuf->b_syn_patterns.ga_itemsize = sizeof(synpat_T);
5328 curbuf->b_syn_patterns.ga_growsize = 10;
5332 * Get one pattern for a ":syntax match" or ":syntax region" command.
5333 * Stores the pattern and program in a synpat_T.
5334 * Returns a pointer to the next argument, or NULL in case of an error.
5336 static char_u *
5337 get_syn_pattern(arg, ci)
5338 char_u *arg;
5339 synpat_T *ci;
5341 char_u *end;
5342 int *p;
5343 int idx;
5344 char_u *cpo_save;
5346 /* need at least three chars */
5347 if (arg == NULL || arg[1] == NUL || arg[2] == NUL)
5348 return NULL;
5350 end = skip_regexp(arg + 1, *arg, TRUE, NULL);
5351 if (*end != *arg) /* end delimiter not found */
5353 EMSG2(_("E401: Pattern delimiter not found: %s"), arg);
5354 return NULL;
5356 /* store the pattern and compiled regexp program */
5357 if ((ci->sp_pattern = vim_strnsave(arg + 1, (int)(end - arg - 1))) == NULL)
5358 return NULL;
5360 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5361 cpo_save = p_cpo;
5362 p_cpo = (char_u *)"";
5363 ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC);
5364 p_cpo = cpo_save;
5366 if (ci->sp_prog == NULL)
5367 return NULL;
5368 ci->sp_ic = curbuf->b_syn_ic;
5371 * Check for a match, highlight or region offset.
5373 ++end;
5376 for (idx = SPO_COUNT; --idx >= 0; )
5377 if (STRNCMP(end, spo_name_tab[idx], 3) == 0)
5378 break;
5379 if (idx >= 0)
5381 p = &(ci->sp_offsets[idx]);
5382 if (idx != SPO_LC_OFF)
5383 switch (end[3])
5385 case 's': break;
5386 case 'b': break;
5387 case 'e': idx += SPO_COUNT; break;
5388 default: idx = -1; break;
5390 if (idx >= 0)
5392 ci->sp_off_flags |= (1 << idx);
5393 if (idx == SPO_LC_OFF) /* lc=99 */
5395 end += 3;
5396 *p = getdigits(&end);
5398 /* "lc=" offset automatically sets "ms=" offset */
5399 if (!(ci->sp_off_flags & (1 << SPO_MS_OFF)))
5401 ci->sp_off_flags |= (1 << SPO_MS_OFF);
5402 ci->sp_offsets[SPO_MS_OFF] = *p;
5405 else /* yy=x+99 */
5407 end += 4;
5408 if (*end == '+')
5410 ++end;
5411 *p = getdigits(&end); /* positive offset */
5413 else if (*end == '-')
5415 ++end;
5416 *p = -getdigits(&end); /* negative offset */
5419 if (*end != ',')
5420 break;
5421 ++end;
5424 } while (idx >= 0);
5426 if (!ends_excmd(*end) && !vim_iswhite(*end))
5428 EMSG2(_("E402: Garbage after pattern: %s"), arg);
5429 return NULL;
5431 return skipwhite(end);
5435 * Handle ":syntax sync .." command.
5437 /* ARGSUSED */
5438 static void
5439 syn_cmd_sync(eap, syncing)
5440 exarg_T *eap;
5441 int syncing; /* not used */
5443 char_u *arg_start = eap->arg;
5444 char_u *arg_end;
5445 char_u *key = NULL;
5446 char_u *next_arg;
5447 int illegal = FALSE;
5448 int finished = FALSE;
5449 long n;
5450 char_u *cpo_save;
5452 if (ends_excmd(*arg_start))
5454 syn_cmd_list(eap, TRUE);
5455 return;
5458 while (!ends_excmd(*arg_start))
5460 arg_end = skiptowhite(arg_start);
5461 next_arg = skipwhite(arg_end);
5462 vim_free(key);
5463 key = vim_strnsave_up(arg_start, (int)(arg_end - arg_start));
5464 if (STRCMP(key, "CCOMMENT") == 0)
5466 if (!eap->skip)
5467 curbuf->b_syn_sync_flags |= SF_CCOMMENT;
5468 if (!ends_excmd(*next_arg))
5470 arg_end = skiptowhite(next_arg);
5471 if (!eap->skip)
5472 curbuf->b_syn_sync_id = syn_check_group(next_arg,
5473 (int)(arg_end - next_arg));
5474 next_arg = skipwhite(arg_end);
5476 else if (!eap->skip)
5477 curbuf->b_syn_sync_id = syn_name2id((char_u *)"Comment");
5479 else if ( STRNCMP(key, "LINES", 5) == 0
5480 || STRNCMP(key, "MINLINES", 8) == 0
5481 || STRNCMP(key, "MAXLINES", 8) == 0
5482 || STRNCMP(key, "LINEBREAKS", 10) == 0)
5484 if (key[4] == 'S')
5485 arg_end = key + 6;
5486 else if (key[0] == 'L')
5487 arg_end = key + 11;
5488 else
5489 arg_end = key + 9;
5490 if (arg_end[-1] != '=' || !VIM_ISDIGIT(*arg_end))
5492 illegal = TRUE;
5493 break;
5495 n = getdigits(&arg_end);
5496 if (!eap->skip)
5498 if (key[4] == 'B')
5499 curbuf->b_syn_sync_linebreaks = n;
5500 else if (key[1] == 'A')
5501 curbuf->b_syn_sync_maxlines = n;
5502 else
5503 curbuf->b_syn_sync_minlines = n;
5506 else if (STRCMP(key, "FROMSTART") == 0)
5508 if (!eap->skip)
5510 curbuf->b_syn_sync_minlines = MAXLNUM;
5511 curbuf->b_syn_sync_maxlines = 0;
5514 else if (STRCMP(key, "LINECONT") == 0)
5516 if (curbuf->b_syn_linecont_pat != NULL)
5518 EMSG(_("E403: syntax sync: line continuations pattern specified twice"));
5519 finished = TRUE;
5520 break;
5522 arg_end = skip_regexp(next_arg + 1, *next_arg, TRUE, NULL);
5523 if (*arg_end != *next_arg) /* end delimiter not found */
5525 illegal = TRUE;
5526 break;
5529 if (!eap->skip)
5531 /* store the pattern and compiled regexp program */
5532 if ((curbuf->b_syn_linecont_pat = vim_strnsave(next_arg + 1,
5533 (int)(arg_end - next_arg - 1))) == NULL)
5535 finished = TRUE;
5536 break;
5538 curbuf->b_syn_linecont_ic = curbuf->b_syn_ic;
5540 /* Make 'cpoptions' empty, to avoid the 'l' flag */
5541 cpo_save = p_cpo;
5542 p_cpo = (char_u *)"";
5543 curbuf->b_syn_linecont_prog =
5544 vim_regcomp(curbuf->b_syn_linecont_pat, RE_MAGIC);
5545 p_cpo = cpo_save;
5547 if (curbuf->b_syn_linecont_prog == NULL)
5549 vim_free(curbuf->b_syn_linecont_pat);
5550 curbuf->b_syn_linecont_pat = NULL;
5551 finished = TRUE;
5552 break;
5555 next_arg = skipwhite(arg_end + 1);
5557 else
5559 eap->arg = next_arg;
5560 if (STRCMP(key, "MATCH") == 0)
5561 syn_cmd_match(eap, TRUE);
5562 else if (STRCMP(key, "REGION") == 0)
5563 syn_cmd_region(eap, TRUE);
5564 else if (STRCMP(key, "CLEAR") == 0)
5565 syn_cmd_clear(eap, TRUE);
5566 else
5567 illegal = TRUE;
5568 finished = TRUE;
5569 break;
5571 arg_start = next_arg;
5573 vim_free(key);
5574 if (illegal)
5575 EMSG2(_("E404: Illegal arguments: %s"), arg_start);
5576 else if (!finished)
5578 eap->nextcmd = check_nextcmd(arg_start);
5579 redraw_curbuf_later(SOME_VALID);
5580 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */
5585 * Convert a line of highlight group names into a list of group ID numbers.
5586 * "arg" should point to the "contains" or "nextgroup" keyword.
5587 * "arg" is advanced to after the last group name.
5588 * Careful: the argument is modified (NULs added).
5589 * returns FAIL for some error, OK for success.
5591 static int
5592 get_id_list(arg, keylen, list)
5593 char_u **arg;
5594 int keylen; /* length of keyword */
5595 short **list; /* where to store the resulting list, if not
5596 NULL, the list is silently skipped! */
5598 char_u *p = NULL;
5599 char_u *end;
5600 int round;
5601 int count;
5602 int total_count = 0;
5603 short *retval = NULL;
5604 char_u *name;
5605 regmatch_T regmatch;
5606 int id;
5607 int i;
5608 int failed = FALSE;
5611 * We parse the list twice:
5612 * round == 1: count the number of items, allocate the array.
5613 * round == 2: fill the array with the items.
5614 * In round 1 new groups may be added, causing the number of items to
5615 * grow when a regexp is used. In that case round 1 is done once again.
5617 for (round = 1; round <= 2; ++round)
5620 * skip "contains"
5622 p = skipwhite(*arg + keylen);
5623 if (*p != '=')
5625 EMSG2(_("E405: Missing equal sign: %s"), *arg);
5626 break;
5628 p = skipwhite(p + 1);
5629 if (ends_excmd(*p))
5631 EMSG2(_("E406: Empty argument: %s"), *arg);
5632 break;
5636 * parse the arguments after "contains"
5638 count = 0;
5639 while (!ends_excmd(*p))
5641 for (end = p; *end && !vim_iswhite(*end) && *end != ','; ++end)
5643 name = alloc((int)(end - p + 3)); /* leave room for "^$" */
5644 if (name == NULL)
5646 failed = TRUE;
5647 break;
5649 vim_strncpy(name + 1, p, end - p);
5650 if ( STRCMP(name + 1, "ALLBUT") == 0
5651 || STRCMP(name + 1, "ALL") == 0
5652 || STRCMP(name + 1, "TOP") == 0
5653 || STRCMP(name + 1, "CONTAINED") == 0)
5655 if (TOUPPER_ASC(**arg) != 'C')
5657 EMSG2(_("E407: %s not allowed here"), name + 1);
5658 failed = TRUE;
5659 vim_free(name);
5660 break;
5662 if (count != 0)
5664 EMSG2(_("E408: %s must be first in contains list"), name + 1);
5665 failed = TRUE;
5666 vim_free(name);
5667 break;
5669 if (name[1] == 'A')
5670 id = SYNID_ALLBUT;
5671 else if (name[1] == 'T')
5672 id = SYNID_TOP;
5673 else
5674 id = SYNID_CONTAINED;
5675 id += current_syn_inc_tag;
5677 else if (name[1] == '@')
5679 id = syn_check_cluster(name + 2, (int)(end - p - 1));
5681 else
5684 * Handle full group name.
5686 if (vim_strpbrk(name + 1, (char_u *)"\\.*^$~[") == NULL)
5687 id = syn_check_group(name + 1, (int)(end - p));
5688 else
5691 * Handle match of regexp with group names.
5693 *name = '^';
5694 STRCAT(name, "$");
5695 regmatch.regprog = vim_regcomp(name, RE_MAGIC);
5696 if (regmatch.regprog == NULL)
5698 failed = TRUE;
5699 vim_free(name);
5700 break;
5703 regmatch.rm_ic = TRUE;
5704 id = 0;
5705 for (i = highlight_ga.ga_len; --i >= 0; )
5707 if (vim_regexec(&regmatch, HL_TABLE()[i].sg_name,
5708 (colnr_T)0))
5710 if (round == 2)
5712 /* Got more items than expected; can happen
5713 * when adding items that match:
5714 * "contains=a.*b,axb".
5715 * Go back to first round */
5716 if (count >= total_count)
5718 vim_free(retval);
5719 round = 1;
5721 else
5722 retval[count] = i + 1;
5724 ++count;
5725 id = -1; /* remember that we found one */
5728 vim_free(regmatch.regprog);
5731 vim_free(name);
5732 if (id == 0)
5734 EMSG2(_("E409: Unknown group name: %s"), p);
5735 failed = TRUE;
5736 break;
5738 if (id > 0)
5740 if (round == 2)
5742 /* Got more items than expected, go back to first round */
5743 if (count >= total_count)
5745 vim_free(retval);
5746 round = 1;
5748 else
5749 retval[count] = id;
5751 ++count;
5753 p = skipwhite(end);
5754 if (*p != ',')
5755 break;
5756 p = skipwhite(p + 1); /* skip comma in between arguments */
5758 if (failed)
5759 break;
5760 if (round == 1)
5762 retval = (short *)alloc((unsigned)((count + 1) * sizeof(short)));
5763 if (retval == NULL)
5764 break;
5765 retval[count] = 0; /* zero means end of the list */
5766 total_count = count;
5770 *arg = p;
5771 if (failed || retval == NULL)
5773 vim_free(retval);
5774 return FAIL;
5777 if (*list == NULL)
5778 *list = retval;
5779 else
5780 vim_free(retval); /* list already found, don't overwrite it */
5782 return OK;
5786 * Make a copy of an ID list.
5788 static short *
5789 copy_id_list(list)
5790 short *list;
5792 int len;
5793 int count;
5794 short *retval;
5796 if (list == NULL)
5797 return NULL;
5799 for (count = 0; list[count]; ++count)
5801 len = (count + 1) * sizeof(short);
5802 retval = (short *)alloc((unsigned)len);
5803 if (retval != NULL)
5804 mch_memmove(retval, list, (size_t)len);
5806 return retval;
5810 * Check if syntax group "ssp" is in the ID list "list" of "cur_si".
5811 * "cur_si" can be NULL if not checking the "containedin" list.
5812 * Used to check if a syntax item is in the "contains" or "nextgroup" list of
5813 * the current item.
5814 * This function is called very often, keep it fast!!
5816 static int
5817 in_id_list(cur_si, list, ssp, contained)
5818 stateitem_T *cur_si; /* current item or NULL */
5819 short *list; /* id list */
5820 struct sp_syn *ssp; /* group id and ":syn include" tag of group */
5821 int contained; /* group id is contained */
5823 int retval;
5824 short *scl_list;
5825 short item;
5826 short id = ssp->id;
5827 static int depth = 0;
5828 int r;
5830 /* If spp has a "containedin" list and "cur_si" is in it, return TRUE. */
5831 if (cur_si != NULL && ssp->cont_in_list != NULL
5832 && !(cur_si->si_flags & HL_MATCH))
5834 /* Ignore transparent items without a contains argument. Double check
5835 * that we don't go back past the first one. */
5836 while ((cur_si->si_flags & HL_TRANS_CONT)
5837 && cur_si > (stateitem_T *)(current_state.ga_data))
5838 --cur_si;
5839 /* cur_si->si_idx is -1 for keywords, these never contain anything. */
5840 if (cur_si->si_idx >= 0 && in_id_list(NULL, ssp->cont_in_list,
5841 &(SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_syn),
5842 SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags & HL_CONTAINED))
5843 return TRUE;
5846 if (list == NULL)
5847 return FALSE;
5850 * If list is ID_LIST_ALL, we are in a transparent item that isn't
5851 * inside anything. Only allow not-contained groups.
5853 if (list == ID_LIST_ALL)
5854 return !contained;
5857 * If the first item is "ALLBUT", return TRUE if "id" is NOT in the
5858 * contains list. We also require that "id" is at the same ":syn include"
5859 * level as the list.
5861 item = *list;
5862 if (item >= SYNID_ALLBUT && item < SYNID_CLUSTER)
5864 if (item < SYNID_TOP)
5866 /* ALL or ALLBUT: accept all groups in the same file */
5867 if (item - SYNID_ALLBUT != ssp->inc_tag)
5868 return FALSE;
5870 else if (item < SYNID_CONTAINED)
5872 /* TOP: accept all not-contained groups in the same file */
5873 if (item - SYNID_TOP != ssp->inc_tag || contained)
5874 return FALSE;
5876 else
5878 /* CONTAINED: accept all contained groups in the same file */
5879 if (item - SYNID_CONTAINED != ssp->inc_tag || !contained)
5880 return FALSE;
5882 item = *++list;
5883 retval = FALSE;
5885 else
5886 retval = TRUE;
5889 * Return "retval" if id is in the contains list.
5891 while (item != 0)
5893 if (item == id)
5894 return retval;
5895 if (item >= SYNID_CLUSTER)
5897 scl_list = SYN_CLSTR(syn_buf)[item - SYNID_CLUSTER].scl_list;
5898 /* restrict recursiveness to 30 to avoid an endless loop for a
5899 * cluster that includes itself (indirectly) */
5900 if (scl_list != NULL && depth < 30)
5902 ++depth;
5903 r = in_id_list(NULL, scl_list, ssp, contained);
5904 --depth;
5905 if (r)
5906 return retval;
5909 item = *++list;
5911 return !retval;
5914 struct subcommand
5916 char *name; /* subcommand name */
5917 void (*func)__ARGS((exarg_T *, int)); /* function to call */
5920 static struct subcommand subcommands[] =
5922 {"case", syn_cmd_case},
5923 {"clear", syn_cmd_clear},
5924 {"cluster", syn_cmd_cluster},
5925 {"enable", syn_cmd_enable},
5926 {"include", syn_cmd_include},
5927 {"keyword", syn_cmd_keyword},
5928 {"list", syn_cmd_list},
5929 {"manual", syn_cmd_manual},
5930 {"match", syn_cmd_match},
5931 {"on", syn_cmd_on},
5932 {"off", syn_cmd_off},
5933 {"region", syn_cmd_region},
5934 {"reset", syn_cmd_reset},
5935 {"spell", syn_cmd_spell},
5936 {"sync", syn_cmd_sync},
5937 {"", syn_cmd_list},
5938 {NULL, NULL}
5942 * ":syntax".
5943 * This searches the subcommands[] table for the subcommand name, and calls a
5944 * syntax_subcommand() function to do the rest.
5946 void
5947 ex_syntax(eap)
5948 exarg_T *eap;
5950 char_u *arg = eap->arg;
5951 char_u *subcmd_end;
5952 char_u *subcmd_name;
5953 int i;
5955 syn_cmdlinep = eap->cmdlinep;
5957 /* isolate subcommand name */
5958 for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); ++subcmd_end)
5960 subcmd_name = vim_strnsave(arg, (int)(subcmd_end - arg));
5961 if (subcmd_name != NULL)
5963 if (eap->skip) /* skip error messages for all subcommands */
5964 ++emsg_skip;
5965 for (i = 0; ; ++i)
5967 if (subcommands[i].name == NULL)
5969 EMSG2(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
5970 break;
5972 if (STRCMP(subcmd_name, (char_u *)subcommands[i].name) == 0)
5974 eap->arg = skipwhite(subcmd_end);
5975 (subcommands[i].func)(eap, FALSE);
5976 break;
5979 vim_free(subcmd_name);
5980 if (eap->skip)
5981 --emsg_skip;
5986 syntax_present(buf)
5987 buf_T *buf;
5989 return (buf->b_syn_patterns.ga_len != 0
5990 || buf->b_syn_clusters.ga_len != 0
5991 || buf->b_keywtab.ht_used > 0
5992 || buf->b_keywtab_ic.ht_used > 0);
5995 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
5997 static enum
5999 EXP_SUBCMD, /* expand ":syn" sub-commands */
6000 EXP_CASE /* expand ":syn case" arguments */
6001 } expand_what;
6004 * Reset include_link, include_default, include_none to 0.
6005 * Called when we are done expanding.
6007 void
6008 reset_expand_highlight()
6010 include_link = include_default = include_none = 0;
6014 * Handle command line completion for :match and :echohl command: Add "None"
6015 * as highlight group.
6017 void
6018 set_context_in_echohl_cmd(xp, arg)
6019 expand_T *xp;
6020 char_u *arg;
6022 xp->xp_context = EXPAND_HIGHLIGHT;
6023 xp->xp_pattern = arg;
6024 include_none = 1;
6028 * Handle command line completion for :syntax command.
6030 void
6031 set_context_in_syntax_cmd(xp, arg)
6032 expand_T *xp;
6033 char_u *arg;
6035 char_u *p;
6037 /* Default: expand subcommands */
6038 xp->xp_context = EXPAND_SYNTAX;
6039 expand_what = EXP_SUBCMD;
6040 xp->xp_pattern = arg;
6041 include_link = 0;
6042 include_default = 0;
6044 /* (part of) subcommand already typed */
6045 if (*arg != NUL)
6047 p = skiptowhite(arg);
6048 if (*p != NUL) /* past first word */
6050 xp->xp_pattern = skipwhite(p);
6051 if (*skiptowhite(xp->xp_pattern) != NUL)
6052 xp->xp_context = EXPAND_NOTHING;
6053 else if (STRNICMP(arg, "case", p - arg) == 0)
6054 expand_what = EXP_CASE;
6055 else if ( STRNICMP(arg, "keyword", p - arg) == 0
6056 || STRNICMP(arg, "region", p - arg) == 0
6057 || STRNICMP(arg, "match", p - arg) == 0
6058 || STRNICMP(arg, "list", p - arg) == 0)
6059 xp->xp_context = EXPAND_HIGHLIGHT;
6060 else
6061 xp->xp_context = EXPAND_NOTHING;
6066 static char *(case_args[]) = {"match", "ignore", NULL};
6069 * Function given to ExpandGeneric() to obtain the list syntax names for
6070 * expansion.
6072 /*ARGSUSED*/
6073 char_u *
6074 get_syntax_name(xp, idx)
6075 expand_T *xp;
6076 int idx;
6078 if (expand_what == EXP_SUBCMD)
6079 return (char_u *)subcommands[idx].name;
6080 return (char_u *)case_args[idx];
6083 #endif /* FEAT_CMDL_COMPL */
6086 * Function called for expression evaluation: get syntax ID at file position.
6089 syn_get_id(wp, lnum, col, trans, spellp)
6090 win_T *wp;
6091 long lnum;
6092 colnr_T col;
6093 int trans; /* remove transparancy */
6094 int *spellp; /* return: can do spell checking */
6096 /* When the position is not after the current position and in the same
6097 * line of the same buffer, need to restart parsing. */
6098 if (wp->w_buffer != syn_buf
6099 || lnum != current_lnum
6100 || col < current_col)
6101 syntax_start(wp, lnum);
6103 (void)get_syntax_attr(col, spellp);
6105 return (trans ? current_trans_id : current_id);
6108 #if defined(FEAT_FOLDING) || defined(PROTO)
6110 * Function called to get folding level for line "lnum" in window "wp".
6113 syn_get_foldlevel(wp, lnum)
6114 win_T *wp;
6115 long lnum;
6117 int level = 0;
6118 int i;
6120 /* Return quickly when there are no fold items at all. */
6121 if (wp->w_buffer->b_syn_folditems != 0)
6123 syntax_start(wp, lnum);
6125 for (i = 0; i < current_state.ga_len; ++i)
6126 if (CUR_STATE(i).si_flags & HL_FOLD)
6127 ++level;
6129 if (level > wp->w_p_fdn)
6131 level = wp->w_p_fdn;
6132 if (level < 0)
6133 level = 0;
6135 return level;
6137 #endif
6139 #endif /* FEAT_SYN_HL */
6142 /**************************************
6143 * Highlighting stuff *
6144 **************************************/
6147 * The default highlight groups. These are compiled-in for fast startup and
6148 * they still work when the runtime files can't be found.
6149 * When making changes here, also change runtime/colors/default.vim!
6150 * The #ifdefs are needed to reduce the amount of static data. Helps to make
6151 * the 16 bit DOS (museum) version compile.
6153 #ifdef FEAT_GUI
6154 # define CENT(a, b) b
6155 #else
6156 # define CENT(a, b) a
6157 #endif
6158 static char *(highlight_init_both[]) =
6160 CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White",
6161 "ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"),
6162 #ifdef FEAT_SEARCH_EXTRA
6163 CENT("IncSearch term=reverse cterm=reverse",
6164 "IncSearch term=reverse cterm=reverse gui=reverse"),
6165 #endif
6166 CENT("ModeMsg term=bold cterm=bold",
6167 "ModeMsg term=bold cterm=bold gui=bold"),
6168 CENT("NonText term=bold ctermfg=Blue",
6169 "NonText term=bold ctermfg=Blue gui=bold guifg=Blue"),
6170 CENT("StatusLine term=reverse,bold cterm=reverse,bold",
6171 "StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"),
6172 CENT("StatusLineNC term=reverse cterm=reverse",
6173 "StatusLineNC term=reverse cterm=reverse gui=reverse"),
6174 #ifdef FEAT_VERTSPLIT
6175 CENT("VertSplit term=reverse cterm=reverse",
6176 "VertSplit term=reverse cterm=reverse gui=reverse"),
6177 #endif
6178 #ifdef FEAT_CLIPBOARD
6179 CENT("VisualNOS term=underline,bold cterm=underline,bold",
6180 "VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"),
6181 #endif
6182 #ifdef FEAT_DIFF
6183 CENT("DiffText term=reverse cterm=bold ctermbg=Red",
6184 "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"),
6185 #endif
6186 #ifdef FEAT_INS_EXPAND
6187 CENT("PmenuThumb cterm=reverse",
6188 "PmenuThumb cterm=reverse gui=reverse"),
6189 CENT("PmenuSbar ctermbg=Grey",
6190 "PmenuSbar ctermbg=Grey guibg=Grey"),
6191 #endif
6192 #ifdef FEAT_WINDOWS
6193 CENT("TabLineSel term=bold cterm=bold",
6194 "TabLineSel term=bold cterm=bold gui=bold"),
6195 CENT("TabLineFill term=reverse cterm=reverse",
6196 "TabLineFill term=reverse cterm=reverse gui=reverse"),
6197 #endif
6198 #ifdef FEAT_GUI
6199 "Cursor guibg=fg guifg=bg",
6200 "lCursor guibg=fg guifg=bg", /* should be different, but what? */
6201 #endif
6202 NULL
6205 static char *(highlight_init_light[]) =
6207 CENT("Directory term=bold ctermfg=DarkBlue",
6208 "Directory term=bold ctermfg=DarkBlue guifg=Blue"),
6209 CENT("LineNr term=underline ctermfg=Brown",
6210 "LineNr term=underline ctermfg=Brown guifg=Brown"),
6211 CENT("MoreMsg term=bold ctermfg=DarkGreen",
6212 "MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6213 CENT("Question term=standout ctermfg=DarkGreen",
6214 "Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"),
6215 CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE",
6216 "Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"),
6217 #ifdef FEAT_SPELL
6218 CENT("SpellBad term=reverse ctermbg=LightRed",
6219 "SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"),
6220 CENT("SpellCap term=reverse ctermbg=LightBlue",
6221 "SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"),
6222 CENT("SpellRare term=reverse ctermbg=LightMagenta",
6223 "SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"),
6224 CENT("SpellLocal term=underline ctermbg=Cyan",
6225 "SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"),
6226 #endif
6227 #ifdef FEAT_INS_EXPAND
6228 CENT("Pmenu ctermbg=LightMagenta",
6229 "Pmenu ctermbg=LightMagenta guibg=LightMagenta"),
6230 CENT("PmenuSel ctermbg=LightGrey",
6231 "PmenuSel ctermbg=LightGrey guibg=Grey"),
6232 #endif
6233 CENT("SpecialKey term=bold ctermfg=DarkBlue",
6234 "SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"),
6235 CENT("Title term=bold ctermfg=DarkMagenta",
6236 "Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"),
6237 CENT("WarningMsg term=standout ctermfg=DarkRed",
6238 "WarningMsg term=standout ctermfg=DarkRed guifg=Red"),
6239 #ifdef FEAT_WILDMENU
6240 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6241 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6242 #endif
6243 #ifdef FEAT_FOLDING
6244 CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue",
6245 "Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"),
6246 CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6247 "FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6248 #endif
6249 #ifdef FEAT_SIGNS
6250 CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue",
6251 "SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"),
6252 #endif
6253 #ifdef FEAT_VISUAL
6254 CENT("Visual term=reverse",
6255 "Visual term=reverse guibg=LightGrey"),
6256 #endif
6257 #ifdef FEAT_DIFF
6258 CENT("DiffAdd term=bold ctermbg=LightBlue",
6259 "DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"),
6260 CENT("DiffChange term=bold ctermbg=LightMagenta",
6261 "DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"),
6262 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan",
6263 "DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"),
6264 #endif
6265 #ifdef FEAT_WINDOWS
6266 CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey",
6267 "TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"),
6268 #endif
6269 #ifdef FEAT_SYN_HL
6270 CENT("CursorColumn term=reverse ctermbg=LightGrey",
6271 "CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"),
6272 CENT("CursorLine term=underline cterm=underline",
6273 "CursorLine term=underline cterm=underline guibg=Grey90"),
6274 #endif
6275 #ifdef FEAT_AUTOCMD
6276 CENT("MatchParen term=reverse ctermbg=Cyan",
6277 "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"),
6278 #endif
6279 #ifdef FEAT_GUI
6280 "Normal gui=NONE",
6281 #endif
6282 NULL
6285 static char *(highlight_init_dark[]) =
6287 CENT("Directory term=bold ctermfg=LightCyan",
6288 "Directory term=bold ctermfg=LightCyan guifg=Cyan"),
6289 CENT("LineNr term=underline ctermfg=Yellow",
6290 "LineNr term=underline ctermfg=Yellow guifg=Yellow"),
6291 CENT("MoreMsg term=bold ctermfg=LightGreen",
6292 "MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"),
6293 CENT("Question term=standout ctermfg=LightGreen",
6294 "Question term=standout ctermfg=LightGreen gui=bold guifg=Green"),
6295 CENT("Search term=reverse ctermbg=Yellow ctermfg=Black",
6296 "Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6297 CENT("SpecialKey term=bold ctermfg=LightBlue",
6298 "SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"),
6299 #ifdef FEAT_SPELL
6300 CENT("SpellBad term=reverse ctermbg=Red",
6301 "SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"),
6302 CENT("SpellCap term=reverse ctermbg=Blue",
6303 "SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"),
6304 CENT("SpellRare term=reverse ctermbg=Magenta",
6305 "SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"),
6306 CENT("SpellLocal term=underline ctermbg=Cyan",
6307 "SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"),
6308 #endif
6309 #ifdef FEAT_INS_EXPAND
6310 CENT("Pmenu ctermbg=Magenta",
6311 "Pmenu ctermbg=Magenta guibg=Magenta"),
6312 CENT("PmenuSel ctermbg=DarkGrey",
6313 "PmenuSel ctermbg=DarkGrey guibg=DarkGrey"),
6314 #endif
6315 CENT("Title term=bold ctermfg=LightMagenta",
6316 "Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"),
6317 CENT("WarningMsg term=standout ctermfg=LightRed",
6318 "WarningMsg term=standout ctermfg=LightRed guifg=Red"),
6319 #ifdef FEAT_WILDMENU
6320 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black",
6321 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"),
6322 #endif
6323 #ifdef FEAT_FOLDING
6324 CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan",
6325 "Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"),
6326 CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6327 "FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6328 #endif
6329 #ifdef FEAT_SIGNS
6330 CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan",
6331 "SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"),
6332 #endif
6333 #ifdef FEAT_VISUAL
6334 CENT("Visual term=reverse",
6335 "Visual term=reverse guibg=DarkGrey"),
6336 #endif
6337 #ifdef FEAT_DIFF
6338 CENT("DiffAdd term=bold ctermbg=DarkBlue",
6339 "DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"),
6340 CENT("DiffChange term=bold ctermbg=DarkMagenta",
6341 "DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"),
6342 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan",
6343 "DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"),
6344 #endif
6345 #ifdef FEAT_WINDOWS
6346 CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey",
6347 "TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"),
6348 #endif
6349 #ifdef FEAT_SYN_HL
6350 CENT("CursorColumn term=reverse ctermbg=DarkGrey",
6351 "CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"),
6352 CENT("CursorLine term=underline cterm=underline",
6353 "CursorLine term=underline cterm=underline guibg=Grey40"),
6354 #endif
6355 #ifdef FEAT_AUTOCMD
6356 CENT("MatchParen term=reverse ctermbg=DarkCyan",
6357 "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"),
6358 #endif
6359 #ifdef FEAT_GUI
6360 "Normal gui=NONE",
6361 #endif
6362 NULL
6365 void
6366 init_highlight(both, reset)
6367 int both; /* include groups where 'bg' doesn't matter */
6368 int reset; /* clear group first */
6370 int i;
6371 char **pp;
6372 static int had_both = FALSE;
6373 #ifdef FEAT_EVAL
6374 char_u *p;
6377 * Try finding the color scheme file. Used when a color file was loaded
6378 * and 'background' or 't_Co' is changed.
6380 p = get_var_value((char_u *)"g:colors_name");
6381 if (p != NULL && load_colors(p) == OK)
6382 return;
6383 #endif
6386 * Didn't use a color file, use the compiled-in colors.
6388 if (both)
6390 had_both = TRUE;
6391 pp = highlight_init_both;
6392 for (i = 0; pp[i] != NULL; ++i)
6393 do_highlight((char_u *)pp[i], reset, TRUE);
6395 else if (!had_both)
6396 /* Don't do anything before the call with both == TRUE from main().
6397 * Not everything has been setup then, and that call will overrule
6398 * everything anyway. */
6399 return;
6401 if (*p_bg == 'l')
6402 pp = highlight_init_light;
6403 else
6404 pp = highlight_init_dark;
6405 for (i = 0; pp[i] != NULL; ++i)
6406 do_highlight((char_u *)pp[i], reset, TRUE);
6408 /* Reverse looks ugly, but grey may not work for 8 colors. Thus let it
6409 * depend on the number of colors available.
6410 * With 8 colors brown is equal to yellow, need to use black for Search fg
6411 * to avoid Statement highlighted text disappears. */
6412 if (t_colors > 8)
6413 do_highlight((char_u *)(*p_bg == 'l' ? "Visual ctermbg=LightGrey"
6414 : "Visual ctermbg=DarkGrey"), FALSE, TRUE);
6415 else
6417 do_highlight((char_u *)"Visual cterm=reverse", FALSE, TRUE);
6418 if (*p_bg == 'l')
6419 do_highlight((char_u *)"Search ctermfg=black", FALSE, TRUE);
6422 #ifdef FEAT_SYN_HL
6424 * If syntax highlighting is enabled load the highlighting for it.
6426 if (get_var_value((char_u *)"g:syntax_on") != NULL)
6428 static int recursive = 0;
6430 if (recursive >= 5)
6431 EMSG(_("E679: recursive loop loading syncolor.vim"));
6432 else
6434 ++recursive;
6435 (void)source_runtime((char_u *)"syntax/syncolor.vim", TRUE);
6436 --recursive;
6439 #endif
6443 * Load color file "name".
6444 * Return OK for success, FAIL for failure.
6447 load_colors(name)
6448 char_u *name;
6450 char_u *buf;
6451 int retval = FAIL;
6452 static int recursive = FALSE;
6454 /* When being called recursively, this is probably because setting
6455 * 'background' caused the highlighting to be reloaded. This means it is
6456 * working, thus we should return OK. */
6457 if (recursive)
6458 return OK;
6460 recursive = TRUE;
6461 buf = alloc((unsigned)(STRLEN(name) + 12));
6462 if (buf != NULL)
6464 sprintf((char *)buf, "colors/%s.vim", name);
6465 retval = source_runtime(buf, FALSE);
6466 vim_free(buf);
6467 #ifdef FEAT_AUTOCMD
6468 apply_autocmds(EVENT_COLORSCHEME, NULL, NULL, FALSE, curbuf);
6469 #endif
6471 recursive = FALSE;
6473 return retval;
6477 * Handle the ":highlight .." command.
6478 * When using ":hi clear" this is called recursively for each group with
6479 * "forceit" and "init" both TRUE.
6481 void
6482 do_highlight(line, forceit, init)
6483 char_u *line;
6484 int forceit;
6485 int init; /* TRUE when called for initializing */
6487 char_u *name_end;
6488 char_u *p;
6489 char_u *linep;
6490 char_u *key_start;
6491 char_u *arg_start;
6492 char_u *key = NULL, *arg = NULL;
6493 long i;
6494 int off;
6495 int len;
6496 int attr;
6497 int id;
6498 int idx;
6499 int dodefault = FALSE;
6500 int doclear = FALSE;
6501 int dolink = FALSE;
6502 int error = FALSE;
6503 int color;
6504 int is_normal_group = FALSE; /* "Normal" group */
6505 #ifdef FEAT_GUI_X11
6506 int is_menu_group = FALSE; /* "Menu" group */
6507 int is_scrollbar_group = FALSE; /* "Scrollbar" group */
6508 int is_tooltip_group = FALSE; /* "Tooltip" group */
6509 int do_colors = FALSE; /* need to update colors? */
6510 #else
6511 # define is_menu_group 0
6512 # define is_tooltip_group 0
6513 #endif
6516 * If no argument, list current highlighting.
6518 if (ends_excmd(*line))
6520 for (i = 1; i <= highlight_ga.ga_len && !got_int; ++i)
6521 /* TODO: only call when the group has attributes set */
6522 highlight_list_one((int)i);
6523 return;
6527 * Isolate the name.
6529 name_end = skiptowhite(line);
6530 linep = skipwhite(name_end);
6533 * Check for "default" argument.
6535 if (STRNCMP(line, "default", name_end - line) == 0)
6537 dodefault = TRUE;
6538 line = linep;
6539 name_end = skiptowhite(line);
6540 linep = skipwhite(name_end);
6544 * Check for "clear" or "link" argument.
6546 if (STRNCMP(line, "clear", name_end - line) == 0)
6547 doclear = TRUE;
6548 if (STRNCMP(line, "link", name_end - line) == 0)
6549 dolink = TRUE;
6552 * ":highlight {group-name}": list highlighting for one group.
6554 if (!doclear && !dolink && ends_excmd(*linep))
6556 id = syn_namen2id(line, (int)(name_end - line));
6557 if (id == 0)
6558 EMSG2(_("E411: highlight group not found: %s"), line);
6559 else
6560 highlight_list_one(id);
6561 return;
6565 * Handle ":highlight link {from} {to}" command.
6567 if (dolink)
6569 char_u *from_start = linep;
6570 char_u *from_end;
6571 char_u *to_start;
6572 char_u *to_end;
6573 int from_id;
6574 int to_id;
6576 from_end = skiptowhite(from_start);
6577 to_start = skipwhite(from_end);
6578 to_end = skiptowhite(to_start);
6580 if (ends_excmd(*from_start) || ends_excmd(*to_start))
6582 EMSG2(_("E412: Not enough arguments: \":highlight link %s\""),
6583 from_start);
6584 return;
6587 if (!ends_excmd(*skipwhite(to_end)))
6589 EMSG2(_("E413: Too many arguments: \":highlight link %s\""), from_start);
6590 return;
6593 from_id = syn_check_group(from_start, (int)(from_end - from_start));
6594 if (STRNCMP(to_start, "NONE", 4) == 0)
6595 to_id = 0;
6596 else
6597 to_id = syn_check_group(to_start, (int)(to_end - to_start));
6599 if (from_id > 0 && (!init || HL_TABLE()[from_id - 1].sg_set == 0))
6602 * Don't allow a link when there already is some highlighting
6603 * for the group, unless '!' is used
6605 if (to_id > 0 && !forceit && !init
6606 && hl_has_settings(from_id - 1, dodefault))
6608 if (sourcing_name == NULL && !dodefault)
6609 EMSG(_("E414: group has settings, highlight link ignored"));
6611 else
6613 if (!init)
6614 HL_TABLE()[from_id - 1].sg_set |= SG_LINK;
6615 HL_TABLE()[from_id - 1].sg_link = to_id;
6616 #ifdef FEAT_EVAL
6617 HL_TABLE()[from_id - 1].sg_scriptID = current_SID;
6618 #endif
6619 redraw_all_later(SOME_VALID);
6623 /* Only call highlight_changed() once, after sourcing a syntax file */
6624 need_highlight_changed = TRUE;
6626 return;
6629 if (doclear)
6632 * ":highlight clear [group]" command.
6634 line = linep;
6635 if (ends_excmd(*line))
6637 #ifdef FEAT_GUI
6638 /* First, we do not destroy the old values, but allocate the new
6639 * ones and update the display. THEN we destroy the old values.
6640 * If we destroy the old values first, then the old values
6641 * (such as GuiFont's or GuiFontset's) will still be displayed but
6642 * invalid because they were free'd.
6644 if (gui.in_use)
6646 # ifdef FEAT_BEVAL_TIP
6647 gui_init_tooltip_font();
6648 # endif
6649 # if defined(FEAT_MENU) && (defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MOTIF))
6650 gui_init_menu_font();
6651 # endif
6653 # if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11) \
6654 || defined(FEAT_GUI_MACVIM)
6655 gui_mch_def_colors();
6656 # endif
6657 # ifdef FEAT_GUI_X11
6658 # ifdef FEAT_MENU
6660 /* This only needs to be done when there is no Menu highlight
6661 * group defined by default, which IS currently the case.
6663 gui_mch_new_menu_colors();
6664 # endif
6665 if (gui.in_use)
6667 gui_new_scrollbar_colors();
6668 # ifdef FEAT_BEVAL
6669 gui_mch_new_tooltip_colors();
6670 # endif
6671 # ifdef FEAT_MENU
6672 gui_mch_new_menu_font();
6673 # endif
6675 # endif
6677 /* Ok, we're done allocating the new default graphics items.
6678 * The screen should already be refreshed at this point.
6679 * It is now Ok to clear out the old data.
6681 #endif
6682 #ifdef FEAT_EVAL
6683 do_unlet((char_u *)"colors_name", TRUE);
6684 #endif
6685 restore_cterm_colors();
6688 * Clear all default highlight groups and load the defaults.
6690 for (idx = 0; idx < highlight_ga.ga_len; ++idx)
6691 highlight_clear(idx);
6692 init_highlight(TRUE, TRUE);
6693 #ifdef FEAT_GUI
6694 if (gui.in_use)
6695 highlight_gui_started();
6696 #endif
6697 highlight_changed();
6698 redraw_later_clear();
6699 return;
6701 name_end = skiptowhite(line);
6702 linep = skipwhite(name_end);
6706 * Find the group name in the table. If it does not exist yet, add it.
6708 id = syn_check_group(line, (int)(name_end - line));
6709 if (id == 0) /* failed (out of memory) */
6710 return;
6711 idx = id - 1; /* index is ID minus one */
6713 /* Return if "default" was used and the group already has settings. */
6714 if (dodefault && hl_has_settings(idx, TRUE))
6715 return;
6717 if (STRCMP(HL_TABLE()[idx].sg_name_u, "NORMAL") == 0)
6718 is_normal_group = TRUE;
6719 #ifdef FEAT_GUI_X11
6720 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "MENU") == 0)
6721 is_menu_group = TRUE;
6722 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "SCROLLBAR") == 0)
6723 is_scrollbar_group = TRUE;
6724 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "TOOLTIP") == 0)
6725 is_tooltip_group = TRUE;
6726 #endif
6728 /* Clear the highlighting for ":hi clear {group}" and ":hi clear". */
6729 if (doclear || (forceit && init))
6731 highlight_clear(idx);
6732 if (!doclear)
6733 HL_TABLE()[idx].sg_set = 0;
6736 if (!doclear)
6737 while (!ends_excmd(*linep))
6739 key_start = linep;
6740 if (*linep == '=')
6742 EMSG2(_("E415: unexpected equal sign: %s"), key_start);
6743 error = TRUE;
6744 break;
6748 * Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" or
6749 * "guibg").
6751 while (*linep && !vim_iswhite(*linep) && *linep != '=')
6752 ++linep;
6753 vim_free(key);
6754 key = vim_strnsave_up(key_start, (int)(linep - key_start));
6755 if (key == NULL)
6757 error = TRUE;
6758 break;
6760 linep = skipwhite(linep);
6762 if (STRCMP(key, "NONE") == 0)
6764 if (!init || HL_TABLE()[idx].sg_set == 0)
6766 if (!init)
6767 HL_TABLE()[idx].sg_set |= SG_TERM+SG_CTERM+SG_GUI;
6768 highlight_clear(idx);
6770 continue;
6774 * Check for the equal sign.
6776 if (*linep != '=')
6778 EMSG2(_("E416: missing equal sign: %s"), key_start);
6779 error = TRUE;
6780 break;
6782 ++linep;
6785 * Isolate the argument.
6787 linep = skipwhite(linep);
6788 if (*linep == '\'') /* guifg='color name' */
6790 arg_start = ++linep;
6791 linep = vim_strchr(linep, '\'');
6792 if (linep == NULL)
6794 EMSG2(_(e_invarg2), key_start);
6795 error = TRUE;
6796 break;
6799 else
6801 arg_start = linep;
6802 linep = skiptowhite(linep);
6804 if (linep == arg_start)
6806 EMSG2(_("E417: missing argument: %s"), key_start);
6807 error = TRUE;
6808 break;
6810 vim_free(arg);
6811 arg = vim_strnsave(arg_start, (int)(linep - arg_start));
6812 if (arg == NULL)
6814 error = TRUE;
6815 break;
6817 if (*linep == '\'')
6818 ++linep;
6821 * Store the argument.
6823 if ( STRCMP(key, "TERM") == 0
6824 || STRCMP(key, "CTERM") == 0
6825 || STRCMP(key, "GUI") == 0)
6827 attr = 0;
6828 off = 0;
6829 while (arg[off] != NUL)
6831 for (i = sizeof(hl_attr_table) / sizeof(int); --i >= 0; )
6833 len = (int)STRLEN(hl_name_table[i]);
6834 if (STRNICMP(arg + off, hl_name_table[i], len) == 0)
6836 attr |= hl_attr_table[i];
6837 off += len;
6838 break;
6841 if (i < 0)
6843 EMSG2(_("E418: Illegal value: %s"), arg);
6844 error = TRUE;
6845 break;
6847 if (arg[off] == ',') /* another one follows */
6848 ++off;
6850 if (error)
6851 break;
6852 if (*key == 'T')
6854 if (!init || !(HL_TABLE()[idx].sg_set & SG_TERM))
6856 if (!init)
6857 HL_TABLE()[idx].sg_set |= SG_TERM;
6858 HL_TABLE()[idx].sg_term = attr;
6861 else if (*key == 'C')
6863 if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM))
6865 if (!init)
6866 HL_TABLE()[idx].sg_set |= SG_CTERM;
6867 HL_TABLE()[idx].sg_cterm = attr;
6868 HL_TABLE()[idx].sg_cterm_bold = FALSE;
6871 #ifdef FEAT_GUI
6872 else
6874 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
6876 if (!init)
6877 HL_TABLE()[idx].sg_set |= SG_GUI;
6878 HL_TABLE()[idx].sg_gui = attr;
6881 #endif
6883 else if (STRCMP(key, "FONT") == 0)
6885 /* in non-GUI fonts are simply ignored */
6886 #ifdef FEAT_GUI
6887 if (!gui.shell_created)
6889 /* GUI not started yet, always accept the name. */
6890 vim_free(HL_TABLE()[idx].sg_font_name);
6891 HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
6893 else
6895 GuiFont temp_sg_font = HL_TABLE()[idx].sg_font;
6896 # ifdef FEAT_XFONTSET
6897 GuiFontset temp_sg_fontset = HL_TABLE()[idx].sg_fontset;
6898 # endif
6899 /* First, save the current font/fontset.
6900 * Then try to allocate the font/fontset.
6901 * If the allocation fails, HL_TABLE()[idx].sg_font OR
6902 * sg_fontset will be set to NOFONT or NOFONTSET respectively.
6905 HL_TABLE()[idx].sg_font = NOFONT;
6906 # ifdef FEAT_XFONTSET
6907 HL_TABLE()[idx].sg_fontset = NOFONTSET;
6908 # endif
6909 hl_do_font(idx, arg, is_normal_group, is_menu_group,
6910 is_tooltip_group);
6912 # ifdef FEAT_XFONTSET
6913 if (HL_TABLE()[idx].sg_fontset != NOFONTSET)
6915 /* New fontset was accepted. Free the old one, if there was
6916 * one.
6918 gui_mch_free_fontset(temp_sg_fontset);
6919 vim_free(HL_TABLE()[idx].sg_font_name);
6920 HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
6922 else
6923 HL_TABLE()[idx].sg_fontset = temp_sg_fontset;
6924 # endif
6925 if (HL_TABLE()[idx].sg_font != NOFONT)
6927 /* New font was accepted. Free the old one, if there was
6928 * one.
6930 gui_mch_free_font(temp_sg_font);
6931 vim_free(HL_TABLE()[idx].sg_font_name);
6932 HL_TABLE()[idx].sg_font_name = vim_strsave(arg);
6934 else
6935 HL_TABLE()[idx].sg_font = temp_sg_font;
6937 #endif
6939 else if (STRCMP(key, "CTERMFG") == 0 || STRCMP(key, "CTERMBG") == 0)
6941 if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM))
6943 if (!init)
6944 HL_TABLE()[idx].sg_set |= SG_CTERM;
6946 /* When setting the foreground color, and previously the "bold"
6947 * flag was set for a light color, reset it now */
6948 if (key[5] == 'F' && HL_TABLE()[idx].sg_cterm_bold)
6950 HL_TABLE()[idx].sg_cterm &= ~HL_BOLD;
6951 HL_TABLE()[idx].sg_cterm_bold = FALSE;
6954 if (VIM_ISDIGIT(*arg))
6955 color = atoi((char *)arg);
6956 else if (STRICMP(arg, "fg") == 0)
6958 if (cterm_normal_fg_color)
6959 color = cterm_normal_fg_color - 1;
6960 else
6962 EMSG(_("E419: FG color unknown"));
6963 error = TRUE;
6964 break;
6967 else if (STRICMP(arg, "bg") == 0)
6969 if (cterm_normal_bg_color > 0)
6970 color = cterm_normal_bg_color - 1;
6971 else
6973 EMSG(_("E420: BG color unknown"));
6974 error = TRUE;
6975 break;
6978 else
6980 static char *(color_names[28]) = {
6981 "Black", "DarkBlue", "DarkGreen", "DarkCyan",
6982 "DarkRed", "DarkMagenta", "Brown", "DarkYellow",
6983 "Gray", "Grey",
6984 "LightGray", "LightGrey", "DarkGray", "DarkGrey",
6985 "Blue", "LightBlue", "Green", "LightGreen",
6986 "Cyan", "LightCyan", "Red", "LightRed", "Magenta",
6987 "LightMagenta", "Yellow", "LightYellow", "White", "NONE"};
6988 static int color_numbers_16[28] = {0, 1, 2, 3,
6989 4, 5, 6, 6,
6990 7, 7,
6991 7, 7, 8, 8,
6992 9, 9, 10, 10,
6993 11, 11, 12, 12, 13,
6994 13, 14, 14, 15, -1};
6995 /* for xterm with 88 colors... */
6996 static int color_numbers_88[28] = {0, 4, 2, 6,
6997 1, 5, 32, 72,
6998 84, 84,
6999 7, 7, 82, 82,
7000 12, 43, 10, 61,
7001 14, 63, 9, 74, 13,
7002 75, 11, 78, 15, -1};
7003 /* for xterm with 256 colors... */
7004 static int color_numbers_256[28] = {0, 4, 2, 6,
7005 1, 5, 130, 130,
7006 248, 248,
7007 7, 7, 242, 242,
7008 12, 81, 10, 121,
7009 14, 159, 9, 224, 13,
7010 225, 11, 229, 15, -1};
7011 /* for terminals with less than 16 colors... */
7012 static int color_numbers_8[28] = {0, 4, 2, 6,
7013 1, 5, 3, 3,
7014 7, 7,
7015 7, 7, 0+8, 0+8,
7016 4+8, 4+8, 2+8, 2+8,
7017 6+8, 6+8, 1+8, 1+8, 5+8,
7018 5+8, 3+8, 3+8, 7+8, -1};
7019 #if defined(__QNXNTO__)
7020 static int *color_numbers_8_qansi = color_numbers_8;
7021 /* On qnx, the 8 & 16 color arrays are the same */
7022 if (STRNCMP(T_NAME, "qansi", 5) == 0)
7023 color_numbers_8_qansi = color_numbers_16;
7024 #endif
7026 /* reduce calls to STRICMP a bit, it can be slow */
7027 off = TOUPPER_ASC(*arg);
7028 for (i = (sizeof(color_names) / sizeof(char *)); --i >= 0; )
7029 if (off == color_names[i][0]
7030 && STRICMP(arg + 1, color_names[i] + 1) == 0)
7031 break;
7032 if (i < 0)
7034 EMSG2(_("E421: Color name or number not recognized: %s"), key_start);
7035 error = TRUE;
7036 break;
7039 /* Use the _16 table to check if its a valid color name. */
7040 color = color_numbers_16[i];
7041 if (color >= 0)
7043 if (t_colors == 8)
7045 /* t_Co is 8: use the 8 colors table */
7046 #if defined(__QNXNTO__)
7047 color = color_numbers_8_qansi[i];
7048 #else
7049 color = color_numbers_8[i];
7050 #endif
7051 if (key[5] == 'F')
7053 /* set/reset bold attribute to get light foreground
7054 * colors (on some terminals, e.g. "linux") */
7055 if (color & 8)
7057 HL_TABLE()[idx].sg_cterm |= HL_BOLD;
7058 HL_TABLE()[idx].sg_cterm_bold = TRUE;
7060 else
7061 HL_TABLE()[idx].sg_cterm &= ~HL_BOLD;
7063 color &= 7; /* truncate to 8 colors */
7065 else if (t_colors == 16 || t_colors == 88
7066 || t_colors == 256)
7069 * Guess: if the termcap entry ends in 'm', it is
7070 * probably an xterm-like terminal. Use the changed
7071 * order for colors.
7073 if (*T_CAF != NUL)
7074 p = T_CAF;
7075 else
7076 p = T_CSF;
7077 if (*p != NUL && *(p + STRLEN(p) - 1) == 'm')
7078 switch (t_colors)
7080 case 16:
7081 color = color_numbers_8[i];
7082 break;
7083 case 88:
7084 color = color_numbers_88[i];
7085 break;
7086 case 256:
7087 color = color_numbers_256[i];
7088 break;
7093 /* Add one to the argument, to avoid zero */
7094 if (key[5] == 'F')
7096 HL_TABLE()[idx].sg_cterm_fg = color + 1;
7097 if (is_normal_group)
7099 cterm_normal_fg_color = color + 1;
7100 cterm_normal_fg_bold = (HL_TABLE()[idx].sg_cterm & HL_BOLD);
7101 #ifdef FEAT_GUI
7102 /* Don't do this if the GUI is used. */
7103 if (!gui.in_use && !gui.starting)
7104 #endif
7106 must_redraw = CLEAR;
7107 if (termcap_active)
7108 term_fg_color(color);
7112 else
7114 HL_TABLE()[idx].sg_cterm_bg = color + 1;
7115 if (is_normal_group)
7117 cterm_normal_bg_color = color + 1;
7118 #ifdef FEAT_GUI
7119 /* Don't mess with 'background' if the GUI is used. */
7120 if (!gui.in_use && !gui.starting)
7121 #endif
7123 must_redraw = CLEAR;
7124 if (termcap_active)
7125 term_bg_color(color);
7126 if (t_colors < 16)
7127 i = (color == 0 || color == 4);
7128 else
7129 i = (color < 7 || color == 8);
7130 /* Set the 'background' option if the value is wrong. */
7131 if (i != (*p_bg == 'd'))
7132 set_option_value((char_u *)"bg", 0L,
7133 i ? (char_u *)"dark" : (char_u *)"light", 0);
7139 else if (STRCMP(key, "GUIFG") == 0)
7141 #ifdef FEAT_GUI /* in non-GUI guifg colors are simply ignored */
7142 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
7144 if (!init)
7145 HL_TABLE()[idx].sg_set |= SG_GUI;
7147 i = color_name2handle(arg);
7148 if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use)
7150 HL_TABLE()[idx].sg_gui_fg = i;
7151 vim_free(HL_TABLE()[idx].sg_gui_fg_name);
7152 if (STRCMP(arg, "NONE"))
7153 HL_TABLE()[idx].sg_gui_fg_name = vim_strsave(arg);
7154 else
7155 HL_TABLE()[idx].sg_gui_fg_name = NULL;
7156 # ifdef FEAT_GUI_X11
7157 if (is_menu_group)
7158 gui.menu_fg_pixel = i;
7159 if (is_scrollbar_group)
7160 gui.scroll_fg_pixel = i;
7161 # ifdef FEAT_BEVAL
7162 if (is_tooltip_group)
7163 gui.tooltip_fg_pixel = i;
7164 # endif
7165 do_colors = TRUE;
7166 # endif
7169 #endif
7171 else if (STRCMP(key, "GUIBG") == 0)
7173 #ifdef FEAT_GUI /* in non-GUI guibg colors are simply ignored */
7174 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
7176 if (!init)
7177 HL_TABLE()[idx].sg_set |= SG_GUI;
7179 i = color_name2handle(arg);
7180 if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use)
7182 HL_TABLE()[idx].sg_gui_bg = i;
7183 vim_free(HL_TABLE()[idx].sg_gui_bg_name);
7184 if (STRCMP(arg, "NONE") != 0)
7185 HL_TABLE()[idx].sg_gui_bg_name = vim_strsave(arg);
7186 else
7187 HL_TABLE()[idx].sg_gui_bg_name = NULL;
7188 # ifdef FEAT_GUI_X11
7189 if (is_menu_group)
7190 gui.menu_bg_pixel = i;
7191 if (is_scrollbar_group)
7192 gui.scroll_bg_pixel = i;
7193 # ifdef FEAT_BEVAL
7194 if (is_tooltip_group)
7195 gui.tooltip_bg_pixel = i;
7196 # endif
7197 do_colors = TRUE;
7198 # endif
7201 #endif
7203 else if (STRCMP(key, "GUISP") == 0)
7205 #ifdef FEAT_GUI /* in non-GUI guisp colors are simply ignored */
7206 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI))
7208 if (!init)
7209 HL_TABLE()[idx].sg_set |= SG_GUI;
7211 i = color_name2handle(arg);
7212 if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use)
7214 HL_TABLE()[idx].sg_gui_sp = i;
7215 vim_free(HL_TABLE()[idx].sg_gui_sp_name);
7216 if (STRCMP(arg, "NONE") != 0)
7217 HL_TABLE()[idx].sg_gui_sp_name = vim_strsave(arg);
7218 else
7219 HL_TABLE()[idx].sg_gui_sp_name = NULL;
7222 #endif
7224 else if (STRCMP(key, "START") == 0 || STRCMP(key, "STOP") == 0)
7226 char_u buf[100];
7227 char_u *tname;
7229 if (!init)
7230 HL_TABLE()[idx].sg_set |= SG_TERM;
7233 * The "start" and "stop" arguments can be a literal escape
7234 * sequence, or a comma separated list of terminal codes.
7236 if (STRNCMP(arg, "t_", 2) == 0)
7238 off = 0;
7239 buf[0] = 0;
7240 while (arg[off] != NUL)
7242 /* Isolate one termcap name */
7243 for (len = 0; arg[off + len] &&
7244 arg[off + len] != ','; ++len)
7246 tname = vim_strnsave(arg + off, len);
7247 if (tname == NULL) /* out of memory */
7249 error = TRUE;
7250 break;
7252 /* lookup the escape sequence for the item */
7253 p = get_term_code(tname);
7254 vim_free(tname);
7255 if (p == NULL) /* ignore non-existing things */
7256 p = (char_u *)"";
7258 /* Append it to the already found stuff */
7259 if ((int)(STRLEN(buf) + STRLEN(p)) >= 99)
7261 EMSG2(_("E422: terminal code too long: %s"), arg);
7262 error = TRUE;
7263 break;
7265 STRCAT(buf, p);
7267 /* Advance to the next item */
7268 off += len;
7269 if (arg[off] == ',') /* another one follows */
7270 ++off;
7273 else
7276 * Copy characters from arg[] to buf[], translating <> codes.
7278 for (p = arg, off = 0; off < 100 && *p; )
7280 len = trans_special(&p, buf + off, FALSE);
7281 if (len) /* recognized special char */
7282 off += len;
7283 else /* copy as normal char */
7284 buf[off++] = *p++;
7286 buf[off] = NUL;
7288 if (error)
7289 break;
7291 if (STRCMP(buf, "NONE") == 0) /* resetting the value */
7292 p = NULL;
7293 else
7294 p = vim_strsave(buf);
7295 if (key[2] == 'A')
7297 vim_free(HL_TABLE()[idx].sg_start);
7298 HL_TABLE()[idx].sg_start = p;
7300 else
7302 vim_free(HL_TABLE()[idx].sg_stop);
7303 HL_TABLE()[idx].sg_stop = p;
7306 else
7308 EMSG2(_("E423: Illegal argument: %s"), key_start);
7309 error = TRUE;
7310 break;
7314 * When highlighting has been given for a group, don't link it.
7316 if (!init || !(HL_TABLE()[idx].sg_set & SG_LINK))
7317 HL_TABLE()[idx].sg_link = 0;
7320 * Continue with next argument.
7322 linep = skipwhite(linep);
7326 * If there is an error, and it's a new entry, remove it from the table.
7328 if (error && idx == highlight_ga.ga_len)
7329 syn_unadd_group();
7330 else
7332 if (is_normal_group)
7334 HL_TABLE()[idx].sg_term_attr = 0;
7335 HL_TABLE()[idx].sg_cterm_attr = 0;
7336 #ifdef FEAT_GUI
7337 HL_TABLE()[idx].sg_gui_attr = 0;
7339 * Need to update all groups, because they might be using "bg"
7340 * and/or "fg", which have been changed now.
7342 if (gui.in_use)
7343 highlight_gui_started();
7344 #endif
7346 #ifdef FEAT_GUI_X11
7347 # ifdef FEAT_MENU
7348 else if (is_menu_group)
7350 if (gui.in_use && do_colors)
7351 gui_mch_new_menu_colors();
7353 # endif
7354 else if (is_scrollbar_group)
7356 if (gui.in_use && do_colors)
7357 gui_new_scrollbar_colors();
7359 # ifdef FEAT_BEVAL
7360 else if (is_tooltip_group)
7362 if (gui.in_use && do_colors)
7363 gui_mch_new_tooltip_colors();
7365 # endif
7366 #endif
7367 else
7368 set_hl_attr(idx);
7369 #ifdef FEAT_EVAL
7370 HL_TABLE()[idx].sg_scriptID = current_SID;
7371 #endif
7372 redraw_all_later(NOT_VALID);
7374 vim_free(key);
7375 vim_free(arg);
7377 /* Only call highlight_changed() once, after sourcing a syntax file */
7378 need_highlight_changed = TRUE;
7381 #if defined(EXITFREE) || defined(PROTO)
7382 void
7383 free_highlight()
7385 int i;
7387 for (i = 0; i < highlight_ga.ga_len; ++i)
7389 highlight_clear(i);
7390 vim_free(HL_TABLE()[i].sg_name);
7391 vim_free(HL_TABLE()[i].sg_name_u);
7393 ga_clear(&highlight_ga);
7395 #endif
7398 * Reset the cterm colors to what they were before Vim was started, if
7399 * possible. Otherwise reset them to zero.
7401 void
7402 restore_cterm_colors()
7404 #if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32))
7405 /* Since t_me has been set, this probably means that the user
7406 * wants to use this as default colors. Need to reset default
7407 * background/foreground colors. */
7408 mch_set_normal_colors();
7409 #else
7410 cterm_normal_fg_color = 0;
7411 cterm_normal_fg_bold = 0;
7412 cterm_normal_bg_color = 0;
7413 #endif
7417 * Return TRUE if highlight group "idx" has any settings.
7418 * When "check_link" is TRUE also check for an existing link.
7420 static int
7421 hl_has_settings(idx, check_link)
7422 int idx;
7423 int check_link;
7425 return ( HL_TABLE()[idx].sg_term_attr != 0
7426 || HL_TABLE()[idx].sg_cterm_attr != 0
7427 #ifdef FEAT_GUI
7428 || HL_TABLE()[idx].sg_gui_attr != 0
7429 #endif
7430 || (check_link && (HL_TABLE()[idx].sg_set & SG_LINK)));
7434 * Clear highlighting for one group.
7436 static void
7437 highlight_clear(idx)
7438 int idx;
7440 HL_TABLE()[idx].sg_term = 0;
7441 vim_free(HL_TABLE()[idx].sg_start);
7442 HL_TABLE()[idx].sg_start = NULL;
7443 vim_free(HL_TABLE()[idx].sg_stop);
7444 HL_TABLE()[idx].sg_stop = NULL;
7445 HL_TABLE()[idx].sg_term_attr = 0;
7446 HL_TABLE()[idx].sg_cterm = 0;
7447 HL_TABLE()[idx].sg_cterm_bold = FALSE;
7448 HL_TABLE()[idx].sg_cterm_fg = 0;
7449 HL_TABLE()[idx].sg_cterm_bg = 0;
7450 HL_TABLE()[idx].sg_cterm_attr = 0;
7451 #ifdef FEAT_GUI /* in non-GUI fonts are simply ignored */
7452 HL_TABLE()[idx].sg_gui = 0;
7453 HL_TABLE()[idx].sg_gui_fg = INVALCOLOR;
7454 vim_free(HL_TABLE()[idx].sg_gui_fg_name);
7455 HL_TABLE()[idx].sg_gui_fg_name = NULL;
7456 HL_TABLE()[idx].sg_gui_bg = INVALCOLOR;
7457 vim_free(HL_TABLE()[idx].sg_gui_bg_name);
7458 HL_TABLE()[idx].sg_gui_bg_name = NULL;
7459 HL_TABLE()[idx].sg_gui_sp = INVALCOLOR;
7460 vim_free(HL_TABLE()[idx].sg_gui_sp_name);
7461 HL_TABLE()[idx].sg_gui_sp_name = NULL;
7462 gui_mch_free_font(HL_TABLE()[idx].sg_font);
7463 HL_TABLE()[idx].sg_font = NOFONT;
7464 # ifdef FEAT_XFONTSET
7465 gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
7466 HL_TABLE()[idx].sg_fontset = NOFONTSET;
7467 # endif
7468 vim_free(HL_TABLE()[idx].sg_font_name);
7469 HL_TABLE()[idx].sg_font_name = NULL;
7470 HL_TABLE()[idx].sg_gui_attr = 0;
7471 #endif
7472 #ifdef FEAT_EVAL
7473 /* Clear the script ID only when there is no link, since that is not
7474 * cleared. */
7475 if (HL_TABLE()[idx].sg_link == 0)
7476 HL_TABLE()[idx].sg_scriptID = 0;
7477 #endif
7480 #if defined(FEAT_GUI) || defined(PROTO)
7482 * Set the normal foreground and background colors according to the "Normal"
7483 * highlighighting group. For X11 also set "Menu", "Scrollbar", and
7484 * "Tooltip" colors.
7486 void
7487 set_normal_colors()
7489 if (set_group_colors((char_u *)"Normal",
7490 &gui.norm_pixel, &gui.back_pixel,
7491 FALSE, TRUE, FALSE))
7493 gui_mch_new_colors();
7494 must_redraw = CLEAR;
7496 #ifdef FEAT_GUI_X11
7497 if (set_group_colors((char_u *)"Menu",
7498 &gui.menu_fg_pixel, &gui.menu_bg_pixel,
7499 TRUE, FALSE, FALSE))
7501 # ifdef FEAT_MENU
7502 gui_mch_new_menu_colors();
7503 # endif
7504 must_redraw = CLEAR;
7506 # ifdef FEAT_BEVAL
7507 if (set_group_colors((char_u *)"Tooltip",
7508 &gui.tooltip_fg_pixel, &gui.tooltip_bg_pixel,
7509 FALSE, FALSE, TRUE))
7511 # ifdef FEAT_TOOLBAR
7512 gui_mch_new_tooltip_colors();
7513 # endif
7514 must_redraw = CLEAR;
7516 #endif
7517 if (set_group_colors((char_u *)"Scrollbar",
7518 &gui.scroll_fg_pixel, &gui.scroll_bg_pixel,
7519 FALSE, FALSE, FALSE))
7521 gui_new_scrollbar_colors();
7522 must_redraw = CLEAR;
7524 #endif
7528 * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
7530 static int
7531 set_group_colors(name, fgp, bgp, do_menu, use_norm, do_tooltip)
7532 char_u *name;
7533 guicolor_T *fgp;
7534 guicolor_T *bgp;
7535 int do_menu;
7536 int use_norm;
7537 int do_tooltip;
7539 int idx;
7541 idx = syn_name2id(name) - 1;
7542 if (idx >= 0)
7544 gui_do_one_color(idx, do_menu, do_tooltip);
7546 if (HL_TABLE()[idx].sg_gui_fg != INVALCOLOR)
7547 *fgp = HL_TABLE()[idx].sg_gui_fg;
7548 else if (use_norm)
7549 *fgp = gui.def_norm_pixel;
7550 if (HL_TABLE()[idx].sg_gui_bg != INVALCOLOR)
7551 *bgp = HL_TABLE()[idx].sg_gui_bg;
7552 else if (use_norm)
7553 *bgp = gui.def_back_pixel;
7554 return TRUE;
7556 return FALSE;
7560 * Get the font of the "Normal" group.
7561 * Returns "" when it's not found or not set.
7563 char_u *
7564 hl_get_font_name()
7566 int id;
7567 char_u *s;
7569 id = syn_name2id((char_u *)"Normal");
7570 if (id > 0)
7572 s = HL_TABLE()[id - 1].sg_font_name;
7573 if (s != NULL)
7574 return s;
7576 return (char_u *)"";
7580 * Set font for "Normal" group. Called by gui_mch_init_font() when a font has
7581 * actually chosen to be used.
7583 void
7584 hl_set_font_name(font_name)
7585 char_u *font_name;
7587 int id;
7589 id = syn_name2id((char_u *)"Normal");
7590 if (id > 0)
7592 vim_free(HL_TABLE()[id - 1].sg_font_name);
7593 HL_TABLE()[id - 1].sg_font_name = vim_strsave(font_name);
7598 * Set background color for "Normal" group. Called by gui_set_bg_color()
7599 * when the color is known.
7601 void
7602 hl_set_bg_color_name(name)
7603 char_u *name; /* must have been allocated */
7605 int id;
7607 if (name != NULL)
7609 id = syn_name2id((char_u *)"Normal");
7610 if (id > 0)
7612 vim_free(HL_TABLE()[id - 1].sg_gui_bg_name);
7613 HL_TABLE()[id - 1].sg_gui_bg_name = name;
7619 * Set foreground color for "Normal" group. Called by gui_set_fg_color()
7620 * when the color is known.
7622 void
7623 hl_set_fg_color_name(name)
7624 char_u *name; /* must have been allocated */
7626 int id;
7628 if (name != NULL)
7630 id = syn_name2id((char_u *)"Normal");
7631 if (id > 0)
7633 vim_free(HL_TABLE()[id - 1].sg_gui_fg_name);
7634 HL_TABLE()[id - 1].sg_gui_fg_name = name;
7640 * Return the handle for a color name.
7641 * Returns INVALCOLOR when failed.
7643 static guicolor_T
7644 color_name2handle(name)
7645 char_u *name;
7647 if (STRCMP(name, "NONE") == 0)
7648 return INVALCOLOR;
7650 if (STRICMP(name, "fg") == 0 || STRICMP(name, "foreground") == 0)
7651 return gui.norm_pixel;
7652 if (STRICMP(name, "bg") == 0 || STRICMP(name, "background") == 0)
7653 return gui.back_pixel;
7655 return gui_get_color(name);
7659 * Return the handle for a font name.
7660 * Returns NOFONT when failed.
7662 static GuiFont
7663 font_name2handle(name)
7664 char_u *name;
7666 if (STRCMP(name, "NONE") == 0)
7667 return NOFONT;
7669 return gui_mch_get_font(name, TRUE);
7672 # ifdef FEAT_XFONTSET
7674 * Return the handle for a fontset name.
7675 * Returns NOFONTSET when failed.
7677 static GuiFontset
7678 fontset_name2handle(name, fixed_width)
7679 char_u *name;
7680 int fixed_width;
7682 if (STRCMP(name, "NONE") == 0)
7683 return NOFONTSET;
7685 return gui_mch_get_fontset(name, TRUE, fixed_width);
7687 # endif
7690 * Get the font or fontset for one highlight group.
7692 /*ARGSUSED*/
7693 static void
7694 hl_do_font(idx, arg, do_normal, do_menu, do_tooltip)
7695 int idx;
7696 char_u *arg;
7697 int do_normal; /* set normal font */
7698 int do_menu; /* set menu font */
7699 int do_tooltip; /* set tooltip font */
7701 # ifdef FEAT_XFONTSET
7702 /* If 'guifontset' is not empty, first try using the name as a
7703 * fontset. If that doesn't work, use it as a font name. */
7704 if (*p_guifontset != NUL
7705 # ifdef FONTSET_ALWAYS
7706 || do_menu
7707 # endif
7708 # ifdef FEAT_BEVAL_TIP
7709 /* In Athena & Motif, the Tooltip highlight group is always a fontset */
7710 || do_tooltip
7711 # endif
7713 HL_TABLE()[idx].sg_fontset = fontset_name2handle(arg, 0
7714 # ifdef FONTSET_ALWAYS
7715 || do_menu
7716 # endif
7717 # ifdef FEAT_BEVAL_TIP
7718 || do_tooltip
7719 # endif
7721 if (HL_TABLE()[idx].sg_fontset != NOFONTSET)
7723 /* If it worked and it's the Normal group, use it as the
7724 * normal fontset. Same for the Menu group. */
7725 if (do_normal)
7726 gui_init_font(arg, TRUE);
7727 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7728 if (do_menu)
7730 # ifdef FONTSET_ALWAYS
7731 gui.menu_fontset = HL_TABLE()[idx].sg_fontset;
7732 # else
7733 /* YIKES! This is a bug waiting to crash the program */
7734 gui.menu_font = HL_TABLE()[idx].sg_fontset;
7735 # endif
7736 gui_mch_new_menu_font();
7738 # ifdef FEAT_BEVAL
7739 if (do_tooltip)
7741 /* The Athena widget set cannot currently handle switching between
7742 * displaying a single font and a fontset.
7743 * If the XtNinternational resource is set to True at widget
7744 * creation, then a fontset is always used, otherwise an
7745 * XFontStruct is used.
7747 gui.tooltip_fontset = (XFontSet)HL_TABLE()[idx].sg_fontset;
7748 gui_mch_new_tooltip_font();
7750 # endif
7751 # endif
7753 else
7754 # endif
7756 HL_TABLE()[idx].sg_font = font_name2handle(arg);
7757 /* If it worked and it's the Normal group, use it as the
7758 * normal font. Same for the Menu group. */
7759 if (HL_TABLE()[idx].sg_font != NOFONT)
7761 if (do_normal)
7762 gui_init_font(arg, FALSE);
7763 #ifndef FONTSET_ALWAYS
7764 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU)
7765 if (do_menu)
7767 gui.menu_font = HL_TABLE()[idx].sg_font;
7768 gui_mch_new_menu_font();
7770 # endif
7771 #endif
7776 #endif /* FEAT_GUI */
7779 * Table with the specifications for an attribute number.
7780 * Note that this table is used by ALL buffers. This is required because the
7781 * GUI can redraw at any time for any buffer.
7783 static garray_T term_attr_table = {0, 0, 0, 0, NULL};
7785 #define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx]
7787 static garray_T cterm_attr_table = {0, 0, 0, 0, NULL};
7789 #define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx]
7791 #ifdef FEAT_GUI
7792 static garray_T gui_attr_table = {0, 0, 0, 0, NULL};
7794 #define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx]
7795 #endif
7798 * Return the attr number for a set of colors and font.
7799 * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
7800 * if the combination is new.
7801 * Return 0 for error (no more room).
7803 static int
7804 get_attr_entry(table, aep)
7805 garray_T *table;
7806 attrentry_T *aep;
7808 int i;
7809 attrentry_T *taep;
7810 static int recursive = FALSE;
7813 * Init the table, in case it wasn't done yet.
7815 table->ga_itemsize = sizeof(attrentry_T);
7816 table->ga_growsize = 7;
7819 * Try to find an entry with the same specifications.
7821 for (i = 0; i < table->ga_len; ++i)
7823 taep = &(((attrentry_T *)table->ga_data)[i]);
7824 if ( aep->ae_attr == taep->ae_attr
7825 && (
7826 #ifdef FEAT_GUI
7827 (table == &gui_attr_table
7828 && (aep->ae_u.gui.fg_color == taep->ae_u.gui.fg_color
7829 && aep->ae_u.gui.bg_color
7830 == taep->ae_u.gui.bg_color
7831 && aep->ae_u.gui.sp_color
7832 == taep->ae_u.gui.sp_color
7833 && aep->ae_u.gui.font == taep->ae_u.gui.font
7834 # ifdef FEAT_XFONTSET
7835 && aep->ae_u.gui.fontset == taep->ae_u.gui.fontset
7836 # endif
7839 #endif
7840 (table == &term_attr_table
7841 && (aep->ae_u.term.start == NULL)
7842 == (taep->ae_u.term.start == NULL)
7843 && (aep->ae_u.term.start == NULL
7844 || STRCMP(aep->ae_u.term.start,
7845 taep->ae_u.term.start) == 0)
7846 && (aep->ae_u.term.stop == NULL)
7847 == (taep->ae_u.term.stop == NULL)
7848 && (aep->ae_u.term.stop == NULL
7849 || STRCMP(aep->ae_u.term.stop,
7850 taep->ae_u.term.stop) == 0))
7851 || (table == &cterm_attr_table
7852 && aep->ae_u.cterm.fg_color
7853 == taep->ae_u.cterm.fg_color
7854 && aep->ae_u.cterm.bg_color
7855 == taep->ae_u.cterm.bg_color)
7858 return i + ATTR_OFF;
7861 if (table->ga_len + ATTR_OFF > MAX_TYPENR)
7864 * Running out of attribute entries! remove all attributes, and
7865 * compute new ones for all groups.
7866 * When called recursively, we are really out of numbers.
7868 if (recursive)
7870 EMSG(_("E424: Too many different highlighting attributes in use"));
7871 return 0;
7873 recursive = TRUE;
7875 clear_hl_tables();
7877 must_redraw = CLEAR;
7879 for (i = 0; i < highlight_ga.ga_len; ++i)
7880 set_hl_attr(i);
7882 recursive = FALSE;
7886 * This is a new combination of colors and font, add an entry.
7888 if (ga_grow(table, 1) == FAIL)
7889 return 0;
7891 taep = &(((attrentry_T *)table->ga_data)[table->ga_len]);
7892 vim_memset(taep, 0, sizeof(attrentry_T));
7893 taep->ae_attr = aep->ae_attr;
7894 #ifdef FEAT_GUI
7895 if (table == &gui_attr_table)
7897 taep->ae_u.gui.fg_color = aep->ae_u.gui.fg_color;
7898 taep->ae_u.gui.bg_color = aep->ae_u.gui.bg_color;
7899 taep->ae_u.gui.sp_color = aep->ae_u.gui.sp_color;
7900 taep->ae_u.gui.font = aep->ae_u.gui.font;
7901 # ifdef FEAT_XFONTSET
7902 taep->ae_u.gui.fontset = aep->ae_u.gui.fontset;
7903 # endif
7905 #endif
7906 if (table == &term_attr_table)
7908 if (aep->ae_u.term.start == NULL)
7909 taep->ae_u.term.start = NULL;
7910 else
7911 taep->ae_u.term.start = vim_strsave(aep->ae_u.term.start);
7912 if (aep->ae_u.term.stop == NULL)
7913 taep->ae_u.term.stop = NULL;
7914 else
7915 taep->ae_u.term.stop = vim_strsave(aep->ae_u.term.stop);
7917 else if (table == &cterm_attr_table)
7919 taep->ae_u.cterm.fg_color = aep->ae_u.cterm.fg_color;
7920 taep->ae_u.cterm.bg_color = aep->ae_u.cterm.bg_color;
7922 ++table->ga_len;
7923 return (table->ga_len - 1 + ATTR_OFF);
7927 * Clear all highlight tables.
7929 void
7930 clear_hl_tables()
7932 int i;
7933 attrentry_T *taep;
7935 #ifdef FEAT_GUI
7936 ga_clear(&gui_attr_table);
7937 #endif
7938 for (i = 0; i < term_attr_table.ga_len; ++i)
7940 taep = &(((attrentry_T *)term_attr_table.ga_data)[i]);
7941 vim_free(taep->ae_u.term.start);
7942 vim_free(taep->ae_u.term.stop);
7944 ga_clear(&term_attr_table);
7945 ga_clear(&cterm_attr_table);
7948 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO)
7950 * Combine special attributes (e.g., for spelling) with other attributes
7951 * (e.g., for syntax highlighting).
7952 * "prim_attr" overrules "char_attr".
7953 * This creates a new group when required.
7954 * Since we expect there to be few spelling mistakes we don't cache the
7955 * result.
7956 * Return the resulting attributes.
7959 hl_combine_attr(char_attr, prim_attr)
7960 int char_attr;
7961 int prim_attr;
7963 attrentry_T *char_aep = NULL;
7964 attrentry_T *spell_aep;
7965 attrentry_T new_en;
7967 if (char_attr == 0)
7968 return prim_attr;
7969 if (char_attr <= HL_ALL && prim_attr <= HL_ALL)
7970 return char_attr | prim_attr;
7971 #ifdef FEAT_GUI
7972 if (gui.in_use)
7974 if (char_attr > HL_ALL)
7975 char_aep = syn_gui_attr2entry(char_attr);
7976 if (char_aep != NULL)
7977 new_en = *char_aep;
7978 else
7980 vim_memset(&new_en, 0, sizeof(new_en));
7981 new_en.ae_u.gui.fg_color = INVALCOLOR;
7982 new_en.ae_u.gui.bg_color = INVALCOLOR;
7983 new_en.ae_u.gui.sp_color = INVALCOLOR;
7984 if (char_attr <= HL_ALL)
7985 new_en.ae_attr = char_attr;
7988 if (prim_attr <= HL_ALL)
7989 new_en.ae_attr |= prim_attr;
7990 else
7992 spell_aep = syn_gui_attr2entry(prim_attr);
7993 if (spell_aep != NULL)
7995 new_en.ae_attr |= spell_aep->ae_attr;
7996 if (spell_aep->ae_u.gui.fg_color != INVALCOLOR)
7997 new_en.ae_u.gui.fg_color = spell_aep->ae_u.gui.fg_color;
7998 if (spell_aep->ae_u.gui.bg_color != INVALCOLOR)
7999 new_en.ae_u.gui.bg_color = spell_aep->ae_u.gui.bg_color;
8000 if (spell_aep->ae_u.gui.sp_color != INVALCOLOR)
8001 new_en.ae_u.gui.sp_color = spell_aep->ae_u.gui.sp_color;
8002 if (spell_aep->ae_u.gui.font != NOFONT)
8003 new_en.ae_u.gui.font = spell_aep->ae_u.gui.font;
8004 # ifdef FEAT_XFONTSET
8005 if (spell_aep->ae_u.gui.fontset != NOFONTSET)
8006 new_en.ae_u.gui.fontset = spell_aep->ae_u.gui.fontset;
8007 # endif
8010 return get_attr_entry(&gui_attr_table, &new_en);
8012 #endif
8014 if (t_colors > 1)
8016 if (char_attr > HL_ALL)
8017 char_aep = syn_cterm_attr2entry(char_attr);
8018 if (char_aep != NULL)
8019 new_en = *char_aep;
8020 else
8022 vim_memset(&new_en, 0, sizeof(new_en));
8023 if (char_attr <= HL_ALL)
8024 new_en.ae_attr = char_attr;
8027 if (prim_attr <= HL_ALL)
8028 new_en.ae_attr |= prim_attr;
8029 else
8031 spell_aep = syn_cterm_attr2entry(prim_attr);
8032 if (spell_aep != NULL)
8034 new_en.ae_attr |= spell_aep->ae_attr;
8035 if (spell_aep->ae_u.cterm.fg_color > 0)
8036 new_en.ae_u.cterm.fg_color = spell_aep->ae_u.cterm.fg_color;
8037 if (spell_aep->ae_u.cterm.bg_color > 0)
8038 new_en.ae_u.cterm.bg_color = spell_aep->ae_u.cterm.bg_color;
8041 return get_attr_entry(&cterm_attr_table, &new_en);
8044 if (char_attr > HL_ALL)
8045 char_aep = syn_term_attr2entry(char_attr);
8046 if (char_aep != NULL)
8047 new_en = *char_aep;
8048 else
8050 vim_memset(&new_en, 0, sizeof(new_en));
8051 if (char_attr <= HL_ALL)
8052 new_en.ae_attr = char_attr;
8055 if (prim_attr <= HL_ALL)
8056 new_en.ae_attr |= prim_attr;
8057 else
8059 spell_aep = syn_term_attr2entry(prim_attr);
8060 if (spell_aep != NULL)
8062 new_en.ae_attr |= spell_aep->ae_attr;
8063 if (spell_aep->ae_u.term.start != NULL)
8065 new_en.ae_u.term.start = spell_aep->ae_u.term.start;
8066 new_en.ae_u.term.stop = spell_aep->ae_u.term.stop;
8070 return get_attr_entry(&term_attr_table, &new_en);
8072 #endif
8074 #ifdef FEAT_GUI
8076 attrentry_T *
8077 syn_gui_attr2entry(attr)
8078 int attr;
8080 attr -= ATTR_OFF;
8081 if (attr >= gui_attr_table.ga_len) /* did ":syntax clear" */
8082 return NULL;
8083 return &(GUI_ATTR_ENTRY(attr));
8085 #endif /* FEAT_GUI */
8088 * Get the highlight attributes (HL_BOLD etc.) from an attribute nr.
8089 * Only to be used when "attr" > HL_ALL.
8092 syn_attr2attr(attr)
8093 int attr;
8095 attrentry_T *aep;
8097 #ifdef FEAT_GUI
8098 if (gui.in_use)
8099 aep = syn_gui_attr2entry(attr);
8100 else
8101 #endif
8102 if (t_colors > 1)
8103 aep = syn_cterm_attr2entry(attr);
8104 else
8105 aep = syn_term_attr2entry(attr);
8107 if (aep == NULL) /* highlighting not set */
8108 return 0;
8109 return aep->ae_attr;
8113 attrentry_T *
8114 syn_term_attr2entry(attr)
8115 int attr;
8117 attr -= ATTR_OFF;
8118 if (attr >= term_attr_table.ga_len) /* did ":syntax clear" */
8119 return NULL;
8120 return &(TERM_ATTR_ENTRY(attr));
8123 attrentry_T *
8124 syn_cterm_attr2entry(attr)
8125 int attr;
8127 attr -= ATTR_OFF;
8128 if (attr >= cterm_attr_table.ga_len) /* did ":syntax clear" */
8129 return NULL;
8130 return &(CTERM_ATTR_ENTRY(attr));
8133 #define LIST_ATTR 1
8134 #define LIST_STRING 2
8135 #define LIST_INT 3
8137 static void
8138 highlight_list_one(id)
8139 int id;
8141 struct hl_group *sgp;
8142 int didh = FALSE;
8144 sgp = &HL_TABLE()[id - 1]; /* index is ID minus one */
8146 didh = highlight_list_arg(id, didh, LIST_ATTR,
8147 sgp->sg_term, NULL, "term");
8148 didh = highlight_list_arg(id, didh, LIST_STRING,
8149 0, sgp->sg_start, "start");
8150 didh = highlight_list_arg(id, didh, LIST_STRING,
8151 0, sgp->sg_stop, "stop");
8153 didh = highlight_list_arg(id, didh, LIST_ATTR,
8154 sgp->sg_cterm, NULL, "cterm");
8155 didh = highlight_list_arg(id, didh, LIST_INT,
8156 sgp->sg_cterm_fg, NULL, "ctermfg");
8157 didh = highlight_list_arg(id, didh, LIST_INT,
8158 sgp->sg_cterm_bg, NULL, "ctermbg");
8160 #ifdef FEAT_GUI
8161 didh = highlight_list_arg(id, didh, LIST_ATTR,
8162 sgp->sg_gui, NULL, "gui");
8163 didh = highlight_list_arg(id, didh, LIST_STRING,
8164 0, sgp->sg_gui_fg_name, "guifg");
8165 didh = highlight_list_arg(id, didh, LIST_STRING,
8166 0, sgp->sg_gui_bg_name, "guibg");
8167 didh = highlight_list_arg(id, didh, LIST_STRING,
8168 0, sgp->sg_gui_sp_name, "guisp");
8169 didh = highlight_list_arg(id, didh, LIST_STRING,
8170 0, sgp->sg_font_name, "font");
8171 #endif
8173 if (sgp->sg_link && !got_int)
8175 (void)syn_list_header(didh, 9999, id);
8176 didh = TRUE;
8177 msg_puts_attr((char_u *)"links to", hl_attr(HLF_D));
8178 msg_putchar(' ');
8179 msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name);
8182 if (!didh)
8183 highlight_list_arg(id, didh, LIST_STRING, 0, (char_u *)"cleared", "");
8184 #ifdef FEAT_EVAL
8185 if (p_verbose > 0)
8186 last_set_msg(sgp->sg_scriptID);
8187 #endif
8190 static int
8191 highlight_list_arg(id, didh, type, iarg, sarg, name)
8192 int id;
8193 int didh;
8194 int type;
8195 int iarg;
8196 char_u *sarg;
8197 char *name;
8199 char_u buf[100];
8200 char_u *ts;
8201 int i;
8203 if (got_int)
8204 return FALSE;
8205 if (type == LIST_STRING ? (sarg != NULL) : (iarg != 0))
8207 ts = buf;
8208 if (type == LIST_INT)
8209 sprintf((char *)buf, "%d", iarg - 1);
8210 else if (type == LIST_STRING)
8211 ts = sarg;
8212 else /* type == LIST_ATTR */
8214 buf[0] = NUL;
8215 for (i = 0; hl_attr_table[i] != 0; ++i)
8217 if (iarg & hl_attr_table[i])
8219 if (buf[0] != NUL)
8220 STRCAT(buf, ",");
8221 STRCAT(buf, hl_name_table[i]);
8222 iarg &= ~hl_attr_table[i]; /* don't want "inverse" */
8227 (void)syn_list_header(didh,
8228 (int)(vim_strsize(ts) + STRLEN(name) + 1), id);
8229 didh = TRUE;
8230 if (!got_int)
8232 if (*name != NUL)
8234 MSG_PUTS_ATTR(name, hl_attr(HLF_D));
8235 MSG_PUTS_ATTR("=", hl_attr(HLF_D));
8237 msg_outtrans(ts);
8240 return didh;
8243 #if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO)
8245 * Return "1" if highlight group "id" has attribute "flag".
8246 * Return NULL otherwise.
8248 char_u *
8249 highlight_has_attr(id, flag, modec)
8250 int id;
8251 int flag;
8252 int modec; /* 'g' for GUI, 'c' for cterm, 't' for term */
8254 int attr;
8256 if (id <= 0 || id > highlight_ga.ga_len)
8257 return NULL;
8259 #ifdef FEAT_GUI
8260 if (modec == 'g')
8261 attr = HL_TABLE()[id - 1].sg_gui;
8262 else
8263 #endif
8264 if (modec == 'c')
8265 attr = HL_TABLE()[id - 1].sg_cterm;
8266 else
8267 attr = HL_TABLE()[id - 1].sg_term;
8269 if (attr & flag)
8270 return (char_u *)"1";
8271 return NULL;
8273 #endif
8275 #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
8277 * Return color name of highlight group "id".
8279 char_u *
8280 highlight_color(id, what, modec)
8281 int id;
8282 char_u *what; /* "fg", "bg", "sp", "fg#", "bg#" or "sp#" */
8283 int modec; /* 'g' for GUI, 'c' for cterm, 't' for term */
8285 static char_u name[20];
8286 int n;
8287 int fg = FALSE;
8288 # ifdef FEAT_GUI
8289 int sp = FALSE;
8290 # endif
8292 if (id <= 0 || id > highlight_ga.ga_len)
8293 return NULL;
8295 if (TOLOWER_ASC(what[0]) == 'f')
8296 fg = TRUE;
8297 # ifdef FEAT_GUI
8298 else if (TOLOWER_ASC(what[0]) == 's')
8299 sp = TRUE;
8300 if (modec == 'g')
8302 /* return #RRGGBB form (only possible when GUI is running) */
8303 if (gui.in_use && what[1] && what[2] == '#')
8305 guicolor_T color;
8306 long_u rgb;
8307 static char_u buf[10];
8309 if (fg)
8310 color = HL_TABLE()[id - 1].sg_gui_fg;
8311 else if (sp)
8312 color = HL_TABLE()[id - 1].sg_gui_sp;
8313 else
8314 color = HL_TABLE()[id - 1].sg_gui_bg;
8315 if (color == INVALCOLOR)
8316 return NULL;
8317 rgb = gui_mch_get_rgb(color);
8318 sprintf((char *)buf, "#%02x%02x%02x",
8319 (unsigned)(rgb >> 16),
8320 (unsigned)(rgb >> 8) & 255,
8321 (unsigned)rgb & 255);
8322 return buf;
8324 if (fg)
8325 return (HL_TABLE()[id - 1].sg_gui_fg_name);
8326 if (sp)
8327 return (HL_TABLE()[id - 1].sg_gui_sp_name);
8328 return (HL_TABLE()[id - 1].sg_gui_bg_name);
8330 # endif
8331 if (modec == 'c')
8333 if (fg)
8334 n = HL_TABLE()[id - 1].sg_cterm_fg - 1;
8335 else
8336 n = HL_TABLE()[id - 1].sg_cterm_bg - 1;
8337 sprintf((char *)name, "%d", n);
8338 return name;
8340 /* term doesn't have color */
8341 return NULL;
8343 #endif
8345 #if (defined(FEAT_SYN_HL) && defined(FEAT_GUI) && defined(FEAT_PRINTER)) \
8346 || defined(PROTO)
8348 * Return color name of highlight group "id" as RGB value.
8350 long_u
8351 highlight_gui_color_rgb(id, fg)
8352 int id;
8353 int fg; /* TRUE = fg, FALSE = bg */
8355 guicolor_T color;
8357 if (id <= 0 || id > highlight_ga.ga_len)
8358 return 0L;
8360 if (fg)
8361 color = HL_TABLE()[id - 1].sg_gui_fg;
8362 else
8363 color = HL_TABLE()[id - 1].sg_gui_bg;
8365 if (color == INVALCOLOR)
8366 return 0L;
8368 return gui_mch_get_rgb(color);
8370 #endif
8373 * Output the syntax list header.
8374 * Return TRUE when started a new line.
8376 static int
8377 syn_list_header(did_header, outlen, id)
8378 int did_header; /* did header already */
8379 int outlen; /* length of string that comes */
8380 int id; /* highlight group id */
8382 int endcol = 19;
8383 int newline = TRUE;
8385 if (!did_header)
8387 msg_putchar('\n');
8388 if (got_int)
8389 return TRUE;
8390 msg_outtrans(HL_TABLE()[id - 1].sg_name);
8391 endcol = 15;
8393 else if (msg_col + outlen + 1 >= Columns)
8395 msg_putchar('\n');
8396 if (got_int)
8397 return TRUE;
8399 else
8401 if (msg_col >= endcol) /* wrap around is like starting a new line */
8402 newline = FALSE;
8405 if (msg_col >= endcol) /* output at least one space */
8406 endcol = msg_col + 1;
8407 if (Columns <= endcol) /* avoid hang for tiny window */
8408 endcol = Columns - 1;
8410 msg_advance(endcol);
8412 /* Show "xxx" with the attributes. */
8413 if (!did_header)
8415 msg_puts_attr((char_u *)"xxx", syn_id2attr(id));
8416 msg_putchar(' ');
8419 return newline;
8423 * Set the attribute numbers for a highlight group.
8424 * Called after one of the attributes has changed.
8426 static void
8427 set_hl_attr(idx)
8428 int idx; /* index in array */
8430 attrentry_T at_en;
8431 struct hl_group *sgp = HL_TABLE() + idx;
8433 /* The "Normal" group doesn't need an attribute number */
8434 if (sgp->sg_name_u != NULL && STRCMP(sgp->sg_name_u, "NORMAL") == 0)
8435 return;
8437 #ifdef FEAT_GUI
8439 * For the GUI mode: If there are other than "normal" highlighting
8440 * attributes, need to allocate an attr number.
8442 if (sgp->sg_gui_fg == INVALCOLOR
8443 && sgp->sg_gui_bg == INVALCOLOR
8444 && sgp->sg_gui_sp == INVALCOLOR
8445 && sgp->sg_font == NOFONT
8446 # ifdef FEAT_XFONTSET
8447 && sgp->sg_fontset == NOFONTSET
8448 # endif
8451 sgp->sg_gui_attr = sgp->sg_gui;
8453 else
8455 at_en.ae_attr = sgp->sg_gui;
8456 at_en.ae_u.gui.fg_color = sgp->sg_gui_fg;
8457 at_en.ae_u.gui.bg_color = sgp->sg_gui_bg;
8458 at_en.ae_u.gui.sp_color = sgp->sg_gui_sp;
8459 at_en.ae_u.gui.font = sgp->sg_font;
8460 # ifdef FEAT_XFONTSET
8461 at_en.ae_u.gui.fontset = sgp->sg_fontset;
8462 # endif
8463 sgp->sg_gui_attr = get_attr_entry(&gui_attr_table, &at_en);
8465 #endif
8467 * For the term mode: If there are other than "normal" highlighting
8468 * attributes, need to allocate an attr number.
8470 if (sgp->sg_start == NULL && sgp->sg_stop == NULL)
8471 sgp->sg_term_attr = sgp->sg_term;
8472 else
8474 at_en.ae_attr = sgp->sg_term;
8475 at_en.ae_u.term.start = sgp->sg_start;
8476 at_en.ae_u.term.stop = sgp->sg_stop;
8477 sgp->sg_term_attr = get_attr_entry(&term_attr_table, &at_en);
8481 * For the color term mode: If there are other than "normal"
8482 * highlighting attributes, need to allocate an attr number.
8484 if (sgp->sg_cterm_fg == 0 && sgp->sg_cterm_bg == 0)
8485 sgp->sg_cterm_attr = sgp->sg_cterm;
8486 else
8488 at_en.ae_attr = sgp->sg_cterm;
8489 at_en.ae_u.cterm.fg_color = sgp->sg_cterm_fg;
8490 at_en.ae_u.cterm.bg_color = sgp->sg_cterm_bg;
8491 sgp->sg_cterm_attr = get_attr_entry(&cterm_attr_table, &at_en);
8496 * Lookup a highlight group name and return it's ID.
8497 * If it is not found, 0 is returned.
8500 syn_name2id(name)
8501 char_u *name;
8503 int i;
8504 char_u name_u[200];
8506 /* Avoid using stricmp() too much, it's slow on some systems */
8507 /* Avoid alloc()/free(), these are slow too. ID names over 200 chars
8508 * don't deserve to be found! */
8509 vim_strncpy(name_u, name, 199);
8510 vim_strup(name_u);
8511 for (i = highlight_ga.ga_len; --i >= 0; )
8512 if (HL_TABLE()[i].sg_name_u != NULL
8513 && STRCMP(name_u, HL_TABLE()[i].sg_name_u) == 0)
8514 break;
8515 return i + 1;
8518 #if defined(FEAT_EVAL) || defined(PROTO)
8520 * Return TRUE if highlight group "name" exists.
8523 highlight_exists(name)
8524 char_u *name;
8526 return (syn_name2id(name) > 0);
8529 # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
8531 * Return the name of highlight group "id".
8532 * When not a valid ID return an empty string.
8534 char_u *
8535 syn_id2name(id)
8536 int id;
8538 if (id <= 0 || id > highlight_ga.ga_len)
8539 return (char_u *)"";
8540 return HL_TABLE()[id - 1].sg_name;
8542 # endif
8543 #endif
8546 * Like syn_name2id(), but take a pointer + length argument.
8549 syn_namen2id(linep, len)
8550 char_u *linep;
8551 int len;
8553 char_u *name;
8554 int id = 0;
8556 name = vim_strnsave(linep, len);
8557 if (name != NULL)
8559 id = syn_name2id(name);
8560 vim_free(name);
8562 return id;
8566 * Find highlight group name in the table and return it's ID.
8567 * The argument is a pointer to the name and the length of the name.
8568 * If it doesn't exist yet, a new entry is created.
8569 * Return 0 for failure.
8572 syn_check_group(pp, len)
8573 char_u *pp;
8574 int len;
8576 int id;
8577 char_u *name;
8579 name = vim_strnsave(pp, len);
8580 if (name == NULL)
8581 return 0;
8583 id = syn_name2id(name);
8584 if (id == 0) /* doesn't exist yet */
8585 id = syn_add_group(name);
8586 else
8587 vim_free(name);
8588 return id;
8592 * Add new highlight group and return it's ID.
8593 * "name" must be an allocated string, it will be consumed.
8594 * Return 0 for failure.
8596 static int
8597 syn_add_group(name)
8598 char_u *name;
8600 char_u *p;
8602 /* Check that the name is ASCII letters, digits and underscore. */
8603 for (p = name; *p != NUL; ++p)
8605 if (!vim_isprintc(*p))
8607 EMSG(_("E669: Unprintable character in group name"));
8608 return 0;
8610 else if (!ASCII_ISALNUM(*p) && *p != '_')
8612 /* This is an error, but since there previously was no check only
8613 * give a warning. */
8614 msg_source(hl_attr(HLF_W));
8615 MSG(_("W18: Invalid character in group name"));
8616 break;
8621 * First call for this growarray: init growing array.
8623 if (highlight_ga.ga_data == NULL)
8625 highlight_ga.ga_itemsize = sizeof(struct hl_group);
8626 highlight_ga.ga_growsize = 10;
8630 * Make room for at least one other syntax_highlight entry.
8632 if (ga_grow(&highlight_ga, 1) == FAIL)
8634 vim_free(name);
8635 return 0;
8638 vim_memset(&(HL_TABLE()[highlight_ga.ga_len]), 0, sizeof(struct hl_group));
8639 HL_TABLE()[highlight_ga.ga_len].sg_name = name;
8640 HL_TABLE()[highlight_ga.ga_len].sg_name_u = vim_strsave_up(name);
8641 #ifdef FEAT_GUI
8642 HL_TABLE()[highlight_ga.ga_len].sg_gui_bg = INVALCOLOR;
8643 HL_TABLE()[highlight_ga.ga_len].sg_gui_fg = INVALCOLOR;
8644 HL_TABLE()[highlight_ga.ga_len].sg_gui_sp = INVALCOLOR;
8645 #endif
8646 ++highlight_ga.ga_len;
8648 return highlight_ga.ga_len; /* ID is index plus one */
8652 * When, just after calling syn_add_group(), an error is discovered, this
8653 * function deletes the new name.
8655 static void
8656 syn_unadd_group()
8658 --highlight_ga.ga_len;
8659 vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name);
8660 vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name_u);
8664 * Translate a group ID to highlight attributes.
8667 syn_id2attr(hl_id)
8668 int hl_id;
8670 int attr;
8671 struct hl_group *sgp;
8673 hl_id = syn_get_final_id(hl_id);
8674 sgp = &HL_TABLE()[hl_id - 1]; /* index is ID minus one */
8676 #ifdef FEAT_GUI
8678 * Only use GUI attr when the GUI is being used.
8680 if (gui.in_use)
8681 attr = sgp->sg_gui_attr;
8682 else
8683 #endif
8684 if (t_colors > 1)
8685 attr = sgp->sg_cterm_attr;
8686 else
8687 attr = sgp->sg_term_attr;
8689 return attr;
8692 #ifdef FEAT_GUI
8694 * Get the GUI colors and attributes for a group ID.
8695 * NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
8698 syn_id2colors(hl_id, fgp, bgp)
8699 int hl_id;
8700 guicolor_T *fgp;
8701 guicolor_T *bgp;
8703 struct hl_group *sgp;
8705 hl_id = syn_get_final_id(hl_id);
8706 sgp = &HL_TABLE()[hl_id - 1]; /* index is ID minus one */
8708 *fgp = sgp->sg_gui_fg;
8709 *bgp = sgp->sg_gui_bg;
8710 return sgp->sg_gui;
8712 #endif
8715 * Translate a group ID to the final group ID (following links).
8718 syn_get_final_id(hl_id)
8719 int hl_id;
8721 int count;
8722 struct hl_group *sgp;
8724 if (hl_id > highlight_ga.ga_len || hl_id < 1)
8725 return 0; /* Can be called from eval!! */
8728 * Follow links until there is no more.
8729 * Look out for loops! Break after 100 links.
8731 for (count = 100; --count >= 0; )
8733 sgp = &HL_TABLE()[hl_id - 1]; /* index is ID minus one */
8734 if (sgp->sg_link == 0 || sgp->sg_link > highlight_ga.ga_len)
8735 break;
8736 hl_id = sgp->sg_link;
8739 return hl_id;
8742 #ifdef FEAT_GUI
8744 * Call this function just after the GUI has started.
8745 * It finds the font and color handles for the highlighting groups.
8747 void
8748 highlight_gui_started()
8750 int idx;
8752 /* First get the colors from the "Normal" and "Menu" group, if set */
8753 set_normal_colors();
8755 for (idx = 0; idx < highlight_ga.ga_len; ++idx)
8756 gui_do_one_color(idx, FALSE, FALSE);
8758 highlight_changed();
8761 static void
8762 gui_do_one_color(idx, do_menu, do_tooltip)
8763 int idx;
8764 int do_menu; /* TRUE: might set the menu font */
8765 int do_tooltip; /* TRUE: might set the tooltip font */
8767 int didit = FALSE;
8769 if (HL_TABLE()[idx].sg_font_name != NULL)
8771 hl_do_font(idx, HL_TABLE()[idx].sg_font_name, FALSE, do_menu,
8772 do_tooltip);
8773 didit = TRUE;
8775 if (HL_TABLE()[idx].sg_gui_fg_name != NULL)
8777 HL_TABLE()[idx].sg_gui_fg =
8778 color_name2handle(HL_TABLE()[idx].sg_gui_fg_name);
8779 didit = TRUE;
8781 if (HL_TABLE()[idx].sg_gui_bg_name != NULL)
8783 HL_TABLE()[idx].sg_gui_bg =
8784 color_name2handle(HL_TABLE()[idx].sg_gui_bg_name);
8785 didit = TRUE;
8787 if (HL_TABLE()[idx].sg_gui_sp_name != NULL)
8789 HL_TABLE()[idx].sg_gui_sp =
8790 color_name2handle(HL_TABLE()[idx].sg_gui_sp_name);
8791 didit = TRUE;
8793 if (didit) /* need to get a new attr number */
8794 set_hl_attr(idx);
8797 #endif
8800 * Translate the 'highlight' option into attributes in highlight_attr[] and
8801 * set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of
8802 * corresponding highlights to use on top of HLF_SNC is computed.
8803 * Called only when the 'highlight' option has been changed and upon first
8804 * screen redraw after any :highlight command.
8805 * Return FAIL when an invalid flag is found in 'highlight'. OK otherwise.
8808 highlight_changed()
8810 int hlf;
8811 int i;
8812 char_u *p;
8813 int attr;
8814 char_u *end;
8815 int id;
8816 #ifdef USER_HIGHLIGHT
8817 char_u userhl[10];
8818 # ifdef FEAT_STL_OPT
8819 int id_SNC = -1;
8820 int id_S = -1;
8821 int hlcnt;
8822 # endif
8823 #endif
8824 static int hl_flags[HLF_COUNT] = HL_FLAGS;
8826 need_highlight_changed = FALSE;
8829 * Clear all attributes.
8831 for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf)
8832 highlight_attr[hlf] = 0;
8835 * First set all attributes to their default value.
8836 * Then use the attributes from the 'highlight' option.
8838 for (i = 0; i < 2; ++i)
8840 if (i)
8841 p = p_hl;
8842 else
8843 p = get_highlight_default();
8844 if (p == NULL) /* just in case */
8845 continue;
8847 while (*p)
8849 for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf)
8850 if (hl_flags[hlf] == *p)
8851 break;
8852 ++p;
8853 if (hlf == (int)HLF_COUNT || *p == NUL)
8854 return FAIL;
8857 * Allow several hl_flags to be combined, like "bu" for
8858 * bold-underlined.
8860 attr = 0;
8861 for ( ; *p && *p != ','; ++p) /* parse upto comma */
8863 if (vim_iswhite(*p)) /* ignore white space */
8864 continue;
8866 if (attr > HL_ALL) /* Combination with ':' is not allowed. */
8867 return FAIL;
8869 switch (*p)
8871 case 'b': attr |= HL_BOLD;
8872 break;
8873 case 'i': attr |= HL_ITALIC;
8874 break;
8875 case '-':
8876 case 'n': /* no highlighting */
8877 break;
8878 case 'r': attr |= HL_INVERSE;
8879 break;
8880 case 's': attr |= HL_STANDOUT;
8881 break;
8882 case 'u': attr |= HL_UNDERLINE;
8883 break;
8884 case 'c': attr |= HL_UNDERCURL;
8885 break;
8886 case ':': ++p; /* highlight group name */
8887 if (attr || *p == NUL) /* no combinations */
8888 return FAIL;
8889 end = vim_strchr(p, ',');
8890 if (end == NULL)
8891 end = p + STRLEN(p);
8892 id = syn_check_group(p, (int)(end - p));
8893 if (id == 0)
8894 return FAIL;
8895 attr = syn_id2attr(id);
8896 p = end - 1;
8897 #if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT)
8898 if (hlf == (int)HLF_SNC)
8899 id_SNC = syn_get_final_id(id);
8900 else if (hlf == (int)HLF_S)
8901 id_S = syn_get_final_id(id);
8902 #endif
8903 break;
8904 default: return FAIL;
8907 highlight_attr[hlf] = attr;
8909 p = skip_to_option_part(p); /* skip comma and spaces */
8913 #ifdef USER_HIGHLIGHT
8914 /* Setup the user highlights
8916 * Temporarily utilize 10 more hl entries. Have to be in there
8917 * simultaneously in case of table overflows in get_attr_entry()
8919 # ifdef FEAT_STL_OPT
8920 if (ga_grow(&highlight_ga, 10) == FAIL)
8921 return FAIL;
8922 hlcnt = highlight_ga.ga_len;
8923 if (id_S == 0)
8924 { /* Make sure id_S is always valid to simplify code below */
8925 memset(&HL_TABLE()[hlcnt + 9], 0, sizeof(struct hl_group));
8926 HL_TABLE()[hlcnt + 9].sg_term = highlight_attr[HLF_S];
8927 id_S = hlcnt + 10;
8929 # endif
8930 for (i = 0; i < 9; i++)
8932 sprintf((char *)userhl, "User%d", i + 1);
8933 id = syn_name2id(userhl);
8934 if (id == 0)
8936 highlight_user[i] = 0;
8937 # ifdef FEAT_STL_OPT
8938 highlight_stlnc[i] = 0;
8939 # endif
8941 else
8943 # ifdef FEAT_STL_OPT
8944 struct hl_group *hlt = HL_TABLE();
8945 # endif
8947 highlight_user[i] = syn_id2attr(id);
8948 # ifdef FEAT_STL_OPT
8949 if (id_SNC == 0)
8951 memset(&hlt[hlcnt + i], 0, sizeof(struct hl_group));
8952 hlt[hlcnt + i].sg_term = highlight_attr[HLF_SNC];
8953 hlt[hlcnt + i].sg_cterm = highlight_attr[HLF_SNC];
8954 # ifdef FEAT_GUI
8955 hlt[hlcnt + i].sg_gui = highlight_attr[HLF_SNC];
8956 # endif
8958 else
8959 mch_memmove(&hlt[hlcnt + i],
8960 &hlt[id_SNC - 1],
8961 sizeof(struct hl_group));
8962 hlt[hlcnt + i].sg_link = 0;
8964 /* Apply difference between UserX and HLF_S to HLF_SNC */
8965 hlt[hlcnt + i].sg_term ^=
8966 hlt[id - 1].sg_term ^ hlt[id_S - 1].sg_term;
8967 if (hlt[id - 1].sg_start != hlt[id_S - 1].sg_start)
8968 hlt[hlcnt + i].sg_start = hlt[id - 1].sg_start;
8969 if (hlt[id - 1].sg_stop != hlt[id_S - 1].sg_stop)
8970 hlt[hlcnt + i].sg_stop = hlt[id - 1].sg_stop;
8971 hlt[hlcnt + i].sg_cterm ^=
8972 hlt[id - 1].sg_cterm ^ hlt[id_S - 1].sg_cterm;
8973 if (hlt[id - 1].sg_cterm_fg != hlt[id_S - 1].sg_cterm_fg)
8974 hlt[hlcnt + i].sg_cterm_fg = hlt[id - 1].sg_cterm_fg;
8975 if (hlt[id - 1].sg_cterm_bg != hlt[id_S - 1].sg_cterm_bg)
8976 hlt[hlcnt + i].sg_cterm_bg = hlt[id - 1].sg_cterm_bg;
8977 # ifdef FEAT_GUI
8978 hlt[hlcnt + i].sg_gui ^=
8979 hlt[id - 1].sg_gui ^ hlt[id_S - 1].sg_gui;
8980 if (hlt[id - 1].sg_gui_fg != hlt[id_S - 1].sg_gui_fg)
8981 hlt[hlcnt + i].sg_gui_fg = hlt[id - 1].sg_gui_fg;
8982 if (hlt[id - 1].sg_gui_bg != hlt[id_S - 1].sg_gui_bg)
8983 hlt[hlcnt + i].sg_gui_bg = hlt[id - 1].sg_gui_bg;
8984 if (hlt[id - 1].sg_gui_sp != hlt[id_S - 1].sg_gui_sp)
8985 hlt[hlcnt + i].sg_gui_sp = hlt[id - 1].sg_gui_sp;
8986 if (hlt[id - 1].sg_font != hlt[id_S - 1].sg_font)
8987 hlt[hlcnt + i].sg_font = hlt[id - 1].sg_font;
8988 # ifdef FEAT_XFONTSET
8989 if (hlt[id - 1].sg_fontset != hlt[id_S - 1].sg_fontset)
8990 hlt[hlcnt + i].sg_fontset = hlt[id - 1].sg_fontset;
8991 # endif
8992 # endif
8993 highlight_ga.ga_len = hlcnt + i + 1;
8994 set_hl_attr(hlcnt + i); /* At long last we can apply */
8995 highlight_stlnc[i] = syn_id2attr(hlcnt + i + 1);
8996 # endif
8999 # ifdef FEAT_STL_OPT
9000 highlight_ga.ga_len = hlcnt;
9001 # endif
9003 #endif /* USER_HIGHLIGHT */
9005 return OK;
9008 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
9010 static void highlight_list __ARGS((void));
9011 static void highlight_list_two __ARGS((int cnt, int attr));
9014 * Handle command line completion for :highlight command.
9016 void
9017 set_context_in_highlight_cmd(xp, arg)
9018 expand_T *xp;
9019 char_u *arg;
9021 char_u *p;
9023 /* Default: expand group names */
9024 xp->xp_context = EXPAND_HIGHLIGHT;
9025 xp->xp_pattern = arg;
9026 include_link = 2;
9027 include_default = 1;
9029 /* (part of) subcommand already typed */
9030 if (*arg != NUL)
9032 p = skiptowhite(arg);
9033 if (*p != NUL) /* past "default" or group name */
9035 include_default = 0;
9036 if (STRNCMP("default", arg, p - arg) == 0)
9038 arg = skipwhite(p);
9039 xp->xp_pattern = arg;
9040 p = skiptowhite(arg);
9042 if (*p != NUL) /* past group name */
9044 include_link = 0;
9045 if (arg[1] == 'i' && arg[0] == 'N')
9046 highlight_list();
9047 if (STRNCMP("link", arg, p - arg) == 0
9048 || STRNCMP("clear", arg, p - arg) == 0)
9050 xp->xp_pattern = skipwhite(p);
9051 p = skiptowhite(xp->xp_pattern);
9052 if (*p != NUL) /* past first group name */
9054 xp->xp_pattern = skipwhite(p);
9055 p = skiptowhite(xp->xp_pattern);
9058 if (*p != NUL) /* past group name(s) */
9059 xp->xp_context = EXPAND_NOTHING;
9066 * List highlighting matches in a nice way.
9068 static void
9069 highlight_list()
9071 int i;
9073 for (i = 10; --i >= 0; )
9074 highlight_list_two(i, hl_attr(HLF_D));
9075 for (i = 40; --i >= 0; )
9076 highlight_list_two(99, 0);
9079 static void
9080 highlight_list_two(cnt, attr)
9081 int cnt;
9082 int attr;
9084 msg_puts_attr((char_u *)("N \bI \b! \b" + cnt / 11), attr);
9085 msg_clr_eos();
9086 out_flush();
9087 ui_delay(cnt == 99 ? 40L : (long)cnt * 50L, FALSE);
9090 #endif /* FEAT_CMDL_COMPL */
9092 #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) \
9093 || defined(FEAT_SIGNS) || defined(PROTO)
9095 * Function given to ExpandGeneric() to obtain the list of group names.
9096 * Also used for synIDattr() function.
9098 /*ARGSUSED*/
9099 char_u *
9100 get_highlight_name(xp, idx)
9101 expand_T *xp;
9102 int idx;
9104 #ifdef FEAT_CMDL_COMPL
9105 if (idx == highlight_ga.ga_len && include_none != 0)
9106 return (char_u *)"none";
9107 if (idx == highlight_ga.ga_len + include_none && include_default != 0)
9108 return (char_u *)"default";
9109 if (idx == highlight_ga.ga_len + include_none + include_default
9110 && include_link != 0)
9111 return (char_u *)"link";
9112 if (idx == highlight_ga.ga_len + include_none + include_default + 1
9113 && include_link != 0)
9114 return (char_u *)"clear";
9115 #endif
9116 if (idx < 0 || idx >= highlight_ga.ga_len)
9117 return NULL;
9118 return HL_TABLE()[idx].sg_name;
9120 #endif
9122 #if defined(FEAT_GUI) || defined(PROTO)
9124 * Free all the highlight group fonts.
9125 * Used when quitting for systems which need it.
9127 void
9128 free_highlight_fonts()
9130 int idx;
9132 for (idx = 0; idx < highlight_ga.ga_len; ++idx)
9134 gui_mch_free_font(HL_TABLE()[idx].sg_font);
9135 HL_TABLE()[idx].sg_font = NOFONT;
9136 # ifdef FEAT_XFONTSET
9137 gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset);
9138 HL_TABLE()[idx].sg_fontset = NOFONTSET;
9139 # endif
9142 gui_mch_free_font(gui.norm_font);
9143 # ifdef FEAT_XFONTSET
9144 gui_mch_free_fontset(gui.fontset);
9145 # endif
9146 # ifndef HAVE_GTK2
9147 gui_mch_free_font(gui.bold_font);
9148 gui_mch_free_font(gui.ital_font);
9149 gui_mch_free_font(gui.boldital_font);
9150 # endif
9152 #endif
9154 /**************************************
9155 * End of Highlighting stuff *
9156 **************************************/