1 /* vi:set ts=8 sts=4 sw=4: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 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 */ 9 10 /* 11 * syntax.c: code for syntax highlighting 12 */ 13 14 #include "vim.h" 15 16 /* 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. 20 */ 21 struct hl_group 22 { 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 57 }; 58 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 */ 63 64 static garray_T highlight_ga; /* highlight groups for 'highlight' option */ 65 66 #define HL_TABLE() ((struct hl_group *)((highlight_ga.ga_data))) 67 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 74 75 /* 76 * The "term", "cterm" and "gui" arguments can be any combination of the 77 * following names, separated by commas (but no spaces!). 78 */ 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}; 84 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)); 94 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 105 106 /* 107 * An attribute number is the index in attr_table plus ATTR_OFF. 108 */ 109 #define ATTR_OFF (HL_ALL + 1) 110 111 #if defined(FEAT_SYN_HL) || defined(PROTO) 112 113 #define SYN_NAMELEN 50 /* maximum length of a syntax name */ 114 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 124 125 static char *(spo_name_tab[SPO_COUNT]) = 126 {"ms=", "me=", "hs=", "he=", "rs=", "re=", "lc="}; 127 128 /* 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. 135 * 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). 138 */ 139 typedef struct syn_pattern 140 { 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; 157 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. 162 */ 163 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 */ 168 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 */ 188 189 #define SYN_ITEMS(buf) ((synpat_T *)((buf)->b_syn_patterns.ga_data)) 190 191 #define NONE_IDX -2 /* value of sp_sync_idx for "NONE" */ 192 193 /* 194 * Flags for b_syn_sync_flags: 195 */ 196 #define SF_CCOMMENT 0x01 /* sync on a C-style comment */ 197 #define SF_MATCH 0x02 /* sync by matching a pattern */ 198 199 #define SYN_STATE_P(ssp) ((bufstate_T *)((ssp)->ga_data)) 200 201 #define MAXKEYWLEN 80 /* maximum length of a keyword */ 202 203 /* 204 * The attributes of the syntax item that has been recognized. 205 */ 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 211 212 typedef struct syn_cluster_S 213 { 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; 218 219 /* 220 * Methods of combining two clusters 221 */ 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 */ 225 226 #define SYN_CLSTR(buf) ((syn_cluster_T *)((buf)->b_syn_clusters.ga_data)) 227 228 /* 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) 235 */ 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 */ 240 241 /* 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. 245 */ 246 static char_u **syn_cmdlinep; 247 248 /* 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. 252 */ 253 static int current_syn_inc_tag = 0; 254 static int running_syn_inc_tag = 0; 255 256 /* 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. 262 */ 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) 267 268 /* 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. 272 */ 273 static int keepend_level = -1; 274 275 /* 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) 279 */ 280 typedef struct state_item 281 { 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; 302 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 */ 306 307 /* 308 * Struct to reduce the number of arguments to get_syn_options(), it's used 309 * very often. 310 */ 311 typedef struct 312 { 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; 322 323 /* 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) 329 */ 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; 340 341 /* 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. 344 */ 345 #define INVALID_STATE(ssp) ((ssp)->ga_itemsize == 0) 346 #define VALID_STATE(ssp) ((ssp)->ga_itemsize != 0) 347 348 /* 349 * The current state (within the line) of the recognition engine. 350 * When current_state.ga_itemsize is 0 the current state is invalid. 351 */ 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 */ 364 365 #define CUR_STATE(idx) ((stateitem_T *)(current_state.ga_data))[idx] 366 367 static void syn_sync __ARGS((win_T *wp, linenr_T lnum, synstate_T *last_valid)); 368 static int syn_match_linecont __ARGS((linenr_T lnum)); 369 static void syn_start_line __ARGS((void)); 370 static void syn_update_ends __ARGS((int startofline)); 371 static void syn_stack_alloc __ARGS((void)); 372 static int syn_stack_cleanup __ARGS((void)); 373 static void syn_stack_free_entry __ARGS((buf_T *buf, synstate_T *p)); 374 static synstate_T *syn_stack_find_entry __ARGS((linenr_T lnum)); 375 static synstate_T *store_current_state __ARGS((void)); 376 static void load_current_state __ARGS((synstate_T *from)); 377 static void invalidate_current_state __ARGS((void)); 378 static int syn_stack_equal __ARGS((synstate_T *sp)); 379 static void validate_current_state __ARGS((void)); 380 static int syn_finish_line __ARGS((int syncing)); 381 static int syn_current_attr __ARGS((int syncing, int displaying, int *can_spell, int keep_state)); 382 static int did_match_already __ARGS((int idx, garray_T *gap)); 383 static stateitem_T *push_next_match __ARGS((stateitem_T *cur_si)); 384 static void check_state_ends __ARGS((void)); 385 static void update_si_attr __ARGS((int idx)); 386 static void check_keepend __ARGS((void)); 387 static void update_si_end __ARGS((stateitem_T *sip, int startcol, int force)); 388 static short *copy_id_list __ARGS((short *list)); 389 static int in_id_list __ARGS((stateitem_T *item, short *cont_list, struct sp_syn *ssp, int contained)); 390 static int push_current_state __ARGS((int idx)); 391 static void pop_current_state __ARGS((void)); 392 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)); 396 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)); 451 452 /* 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. 458 */ 459 void 460 syntax_start(wp, lnum) 461 win_T *wp; 462 linenr_T lnum; 463 { 464 synstate_T *p; 465 synstate_T *last_valid = NULL; 466 synstate_T *last_min_valid = NULL; 467 synstate_T *sp, *prev = NULL; 468 linenr_T parsed_lnum; 469 linenr_T first_stored; 470 int dist; 471 static int changedtick = 0; /* remember the last change ID */ 472 473 /* 474 * After switching buffers, invalidate current_state. 475 * Also do this when a change was made, the current state may be invalid 476 * then. 477 */ 478 if (syn_buf != wp->w_buffer || changedtick != syn_buf->b_changedtick) 479 { 480 invalidate_current_state(); 481 syn_buf = wp->w_buffer; 482 } 483 changedtick = syn_buf->b_changedtick; 484 syn_win = wp; 485 486 /* 487 * Allocate syntax stack when needed. 488 */ 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; 493 494 /* 495 * If the state of the end of the previous line is useful, store it. 496 */ 497 if (VALID_STATE(¤t_state) 498 && current_lnum < lnum 499 && current_lnum < syn_buf->b_ml.ml_line_count) 500 { 501 (void)syn_finish_line(FALSE); 502 if (!current_state_stored) 503 { 504 ++current_lnum; 505 (void)store_current_state(); 506 } 507 508 /* 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. 512 */ 513 if (current_lnum != lnum) 514 invalidate_current_state(); 515 } 516 else 517 invalidate_current_state(); 518 519 /* 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. 522 */ 523 if (INVALID_STATE(¤t_state) && syn_buf->b_sst_array != NULL) 524 { 525 /* Find last valid saved state before start_lnum. */ 526 for (p = syn_buf->b_sst_first; p != NULL; p = p->sst_next) 527 { 528 if (p->sst_lnum > lnum) 529 break; 530 if (p->sst_lnum <= lnum && p->sst_change_lnum == 0) 531 { 532 last_valid = p; 533 if (p->sst_lnum >= lnum - syn_buf->b_syn_sync_minlines) 534 last_min_valid = p; 535 } 536 } 537 if (last_min_valid != NULL) 538 load_current_state(last_min_valid); 539 } 540 541 /* 542 * If "lnum" is before or far beyond a line with a saved state, need to 543 * re-synchronize. 544 */ 545 if (INVALID_STATE(¤t_state)) 546 { 547 syn_sync(wp, lnum, last_valid); 548 first_stored = current_lnum + syn_buf->b_syn_sync_minlines; 549 } 550 else 551 first_stored = current_lnum; 552 553 /* 554 * Advance from the sync point or saved state until the current line. 555 * Save some entries for syncing with later on. 556 */ 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 while (current_lnum < lnum) 562 { 563 syn_start_line(); 564 (void)syn_finish_line(FALSE); 565 ++current_lnum; 566 567 /* If we parsed at least "minlines" lines or started at a valid 568 * state, the current state is considered valid. */ 569 if (current_lnum >= first_stored) 570 { 571 /* Check if the saved state entry is for the current line and is 572 * equal to the current state. If so, then validate all saved 573 * states that depended on a change before the parsed line. */ 574 if (prev == NULL) 575 prev = syn_stack_find_entry(current_lnum - 1); 576 if (prev == NULL) 577 sp = syn_buf->b_sst_first; 578 else 579 sp = prev; 580 while (sp != NULL && sp->sst_lnum < current_lnum) 581 sp = sp->sst_next; 582 if (sp != NULL 583 && sp->sst_lnum == current_lnum 584 && syn_stack_equal(sp)) 585 { 586 parsed_lnum = current_lnum; 587 prev = sp; 588 while (sp != NULL && sp->sst_change_lnum <= parsed_lnum) 589 { 590 if (sp->sst_lnum <= lnum) 591 /* valid state before desired line, use this one */ 592 prev = sp; 593 else if (sp->sst_change_lnum == 0) 594 /* past saved states depending on change, break here. */ 595 break; 596 sp->sst_change_lnum = 0; 597 sp = sp->sst_next; 598 } 599 load_current_state(prev); 600 } 601 /* Store the state at this line when it's the first one, the line 602 * where we start parsing, or some distance from the previously 603 * saved state. But only when parsed at least 'minlines'. */ 604 else if (prev == NULL 605 || current_lnum == lnum 606 || current_lnum >= prev->sst_lnum + dist) 607 prev = store_current_state(); 608 } 609 610 /* This can take a long time: break when CTRL-C pressed. The current 611 * state will be wrong then. */ 612 line_breakcheck(); 613 if (got_int) 614 { 615 current_lnum = lnum; 616 break; 617 } 618 } 619 620 syn_start_line(); 621 } 622 623 /* 624 * We cannot simply discard growarrays full of state_items or buf_states; we 625 * have to manually release their extmatch pointers first. 626 */ 627 static void 628 clear_syn_state(p) 629 synstate_T *p; 630 { 631 int i; 632 garray_T *gap; 633 634 if (p->sst_stacksize > SST_FIX_STATES) 635 { 636 gap = &(p->sst_union.sst_ga); 637 for (i = 0; i < gap->ga_len; i++) 638 unref_extmatch(SYN_STATE_P(gap)[i].bs_extmatch); 639 ga_clear(gap); 640 } 641 else 642 { 643 for (i = 0; i < p->sst_stacksize; i++) 644 unref_extmatch(p->sst_union.sst_stack[i].bs_extmatch); 645 } 646 } 647 648 /* 649 * Cleanup the current_state stack. 650 */ 651 static void 652 clear_current_state() 653 { 654 int i; 655 stateitem_T *sip; 656 657 sip = (stateitem_T *)(current_state.ga_data); 658 for (i = 0; i < current_state.ga_len; i++) 659 unref_extmatch(sip[i].si_extmatch); 660 ga_clear(¤t_state); 661 } 662 663 /* 664 * Try to find a synchronisation point for line "lnum". 665 * 666 * This sets current_lnum and the current state. One of three methods is 667 * used: 668 * 1. Search backwards for the end of a C-comment. 669 * 2. Search backwards for given sync patterns. 670 * 3. Simply start on a given number of lines above "lnum". 671 */ 672 static void 673 syn_sync(wp, start_lnum, last_valid) 674 win_T *wp; 675 linenr_T start_lnum; 676 synstate_T *last_valid; 677 { 678 buf_T *curbuf_save; 679 win_T *curwin_save; 680 pos_T cursor_save; 681 int idx; 682 linenr_T lnum; 683 linenr_T end_lnum; 684 linenr_T break_lnum; 685 int had_sync_point; 686 stateitem_T *cur_si; 687 synpat_T *spp; 688 char_u *line; 689 int found_flags = 0; 690 int found_match_idx = 0; 691 linenr_T found_current_lnum = 0; 692 int found_current_col= 0; 693 lpos_T found_m_endpos; 694 colnr_T prev_current_col; 695 696 /* 697 * Clear any current state that might be hanging around. 698 */ 699 invalidate_current_state(); 700 701 /* 702 * Start at least "minlines" back. Default starting point for parsing is 703 * there. 704 * Start further back, to avoid that scrolling backwards will result in 705 * resyncing for every line. Now it resyncs only one out of N lines, 706 * where N is minlines * 1.5, or minlines * 2 if minlines is small. 707 * Watch out for overflow when minlines is MAXLNUM. 708 */ 709 if (syn_buf->b_syn_sync_minlines > start_lnum) 710 start_lnum = 1; 711 else 712 { 713 if (syn_buf->b_syn_sync_minlines == 1) 714 lnum = 1; 715 else if (syn_buf->b_syn_sync_minlines < 10) 716 lnum = syn_buf->b_syn_sync_minlines * 2; 717 else 718 lnum = syn_buf->b_syn_sync_minlines * 3 / 2; 719 if (syn_buf->b_syn_sync_maxlines != 0 720 && lnum > syn_buf->b_syn_sync_maxlines) 721 lnum = syn_buf->b_syn_sync_maxlines; 722 if (lnum >= start_lnum) 723 start_lnum = 1; 724 else 725 start_lnum -= lnum; 726 } 727 current_lnum = start_lnum; 728 729 /* 730 * 1. Search backwards for the end of a C-style comment. 731 */ 732 if (syn_buf->b_syn_sync_flags & SF_CCOMMENT) 733 { 734 /* Need to make syn_buf the current buffer for a moment, to be able to 735 * use find_start_comment(). */ 736 curwin_save = curwin; 737 curwin = wp; 738 curbuf_save = curbuf; 739 curbuf = syn_buf; 740 741 /* 742 * Skip lines that end in a backslash. 743 */ 744 for ( ; start_lnum > 1; --start_lnum) 745 { 746 line = ml_get(start_lnum - 1); 747 if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') 748 break; 749 } 750 current_lnum = start_lnum; 751 752 /* set cursor to start of search */ 753 cursor_save = wp->w_cursor; 754 wp->w_cursor.lnum = start_lnum; 755 wp->w_cursor.col = 0; 756 757 /* 758 * If the line is inside a comment, need to find the syntax item that 759 * defines the comment. 760 * Restrict the search for the end of a comment to b_syn_sync_maxlines. 761 */ 762 if (find_start_comment((int)syn_buf->b_syn_sync_maxlines) != NULL) 763 { 764 for (idx = syn_buf->b_syn_patterns.ga_len; --idx >= 0; ) 765 if (SYN_ITEMS(syn_buf)[idx].sp_syn.id == syn_buf->b_syn_sync_id 766 && SYN_ITEMS(syn_buf)[idx].sp_type == SPTYPE_START) 767 { 768 validate_current_state(); 769 if (push_current_state(idx) == OK) 770 update_si_attr(current_state.ga_len - 1); 771 break; 772 } 773 } 774 775 /* restore cursor and buffer */ 776 wp->w_cursor = cursor_save; 777 curwin = curwin_save; 778 curbuf = curbuf_save; 779 } 780 781 /* 782 * 2. Search backwards for given sync patterns. 783 */ 784 else if (syn_buf->b_syn_sync_flags & SF_MATCH) 785 { 786 if (syn_buf->b_syn_sync_maxlines != 0 787 && start_lnum > syn_buf->b_syn_sync_maxlines) 788 break_lnum = start_lnum - syn_buf->b_syn_sync_maxlines; 789 else 790 break_lnum = 0; 791 792 found_m_endpos.lnum = 0; 793 found_m_endpos.col = 0; 794 end_lnum = start_lnum; 795 lnum = start_lnum; 796 while (--lnum > break_lnum) 797 { 798 /* This can take a long time: break when CTRL-C pressed. */ 799 line_breakcheck(); 800 if (got_int) 801 { 802 invalidate_current_state(); 803 current_lnum = start_lnum; 804 break; 805 } 806 807 /* Check if we have run into a valid saved state stack now. */ 808 if (last_valid != NULL && lnum == last_valid->sst_lnum) 809 { 810 load_current_state(last_valid); 811 break; 812 } 813 814 /* 815 * Check if the previous line has the line-continuation pattern. 816 */ 817 if (lnum > 1 && syn_match_linecont(lnum - 1)) 818 continue; 819 820 /* 821 * Start with nothing on the state stack 822 */ 823 validate_current_state(); 824 825 for (current_lnum = lnum; current_lnum < end_lnum; ++current_lnum) 826 { 827 syn_start_line(); 828 for (;;) 829 { 830 had_sync_point = syn_finish_line(TRUE); 831 /* 832 * When a sync point has been found, remember where, and 833 * continue to look for another one, further on in the line. 834 */ 835 if (had_sync_point && current_state.ga_len) 836 { 837 cur_si = &CUR_STATE(current_state.ga_len - 1); 838 if (cur_si->si_m_endpos.lnum > start_lnum) 839 { 840 /* ignore match that goes to after where started */ 841 current_lnum = end_lnum; 842 break; 843 } 844 if (cur_si->si_idx < 0) 845 { 846 /* Cannot happen? */ 847 found_flags = 0; 848 found_match_idx = KEYWORD_IDX; 849 } 850 else 851 { 852 spp = &(SYN_ITEMS(syn_buf)[cur_si->si_idx]); 853 found_flags = spp->sp_flags; 854 found_match_idx = spp->sp_sync_idx; 855 } 856 found_current_lnum = current_lnum; 857 found_current_col = current_col; 858 found_m_endpos = cur_si->si_m_endpos; 859 /* 860 * Continue after the match (be aware of a zero-length 861 * match). 862 */ 863 if (found_m_endpos.lnum > current_lnum) 864 { 865 current_lnum = found_m_endpos.lnum; 866 current_col = found_m_endpos.col; 867 if (current_lnum >= end_lnum) 868 break; 869 } 870 else if (found_m_endpos.col > current_col) 871 current_col = found_m_endpos.col; 872 else 873 ++current_col; 874 875 /* syn_current_attr() will have skipped the check for 876 * an item that ends here, need to do that now. Be 877 * careful not to go past the NUL. */ 878 prev_current_col = current_col; 879 if (syn_getcurline()[current_col] != NUL) 880 ++current_col; 881 check_state_ends(); 882 current_col = prev_current_col; 883 } 884 else 885 break; 886 } 887 } 888 889 /* 890 * If a sync point was encountered, break here. 891 */ 892 if (found_flags) 893 { 894 /* 895 * Put the item that was specified by the sync point on the 896 * state stack. If there was no item specified, make the 897 * state stack empty. 898 */ 899 clear_current_state(); 900 if (found_match_idx >= 0 901 && push_current_state(found_match_idx) == OK) 902 update_si_attr(current_state.ga_len - 1); 903 904 /* 905 * When using "grouphere", continue from the sync point 906 * match, until the end of the line. Parsing starts at 907 * the next line. 908 * For "groupthere" the parsing starts at start_lnum. 909 */ 910 if (found_flags & HL_SYNC_HERE) 911 { 912 if (current_state.ga_len) 913 { 914 cur_si = &CUR_STATE(current_state.ga_len - 1); 915 cur_si->si_h_startpos.lnum = found_current_lnum; 916 cur_si->si_h_startpos.col = found_current_col; 917 update_si_end(cur_si, (int)current_col, TRUE); 918 check_keepend(); 919 } 920 current_col = found_m_endpos.col; 921 current_lnum = found_m_endpos.lnum; 922 (void)syn_finish_line(FALSE); 923 ++current_lnum; 924 } 925 else 926 current_lnum = start_lnum; 927 928 break; 929 } 930 931 end_lnum = lnum; 932 invalidate_current_state(); 933 } 934 935 /* Ran into start of the file or exceeded maximum number of lines */ 936 if (lnum <= break_lnum) 937 { 938 invalidate_current_state(); 939 current_lnum = break_lnum + 1; 940 } 941 } 942 943 validate_current_state(); 944 } 945 946 /* 947 * Return TRUE if the line-continuation pattern matches in line "lnum". 948 */ 949 static int 950 syn_match_linecont(lnum) 951 linenr_T lnum; 952 { 953 regmmatch_T regmatch; 954 955 if (syn_buf->b_syn_linecont_prog != NULL) 956 { 957 regmatch.rmm_ic = syn_buf->b_syn_linecont_ic; 958 regmatch.regprog = syn_buf->b_syn_linecont_prog; 959 return syn_regexec(®match, lnum, (colnr_T)0); 960 } 961 return FALSE; 962 } 963 964 /* 965 * Prepare the current state for the start of a line. 966 */ 967 static void 968 syn_start_line() 969 { 970 current_finished = FALSE; 971 current_col = 0; 972 973 /* 974 * Need to update the end of a start/skip/end that continues from the 975 * previous line and regions that have "keepend". 976 */ 977 if (current_state.ga_len > 0) 978 syn_update_ends(TRUE); 979 980 next_match_idx = -1; 981 ++current_line_id; 982 } 983 984 /* 985 * Check for items in the stack that need their end updated. 986 * When "startofline" is TRUE the last item is always updated. 987 * When "startofline" is FALSE the item with "keepend" is forcefully updated. 988 */ 989 static void 990 syn_update_ends(startofline) 991 int startofline; 992 { 993 stateitem_T *cur_si; 994 int i; 995 int seen_keepend; 996 997 if (startofline) 998 { 999 /* Check for a match carried over from a previous line with a 1000 * contained region. The match ends as soon as the region ends. */ 1001 for (i = 0; i < current_state.ga_len; ++i) 1002 { 1003 cur_si = &CUR_STATE(i); 1004 if (cur_si->si_idx >= 0 1005 && (SYN_ITEMS(syn_buf)[cur_si->si_idx]).sp_type 1006 == SPTYPE_MATCH 1007 && cur_si->si_m_endpos.lnum < current_lnum) 1008 { 1009 cur_si->si_flags |= HL_MATCHCONT; 1010 cur_si->si_m_endpos.lnum = 0; 1011 cur_si->si_m_endpos.col = 0; 1012 cur_si->si_h_endpos = cur_si->si_m_endpos; 1013 cur_si->si_ends = TRUE; 1014 } 1015 } 1016 } 1017 1018 /* 1019 * Need to update the end of a start/skip/end that continues from the 1020 * previous line. And regions that have "keepend", because they may 1021 * influence contained items. If we've just removed "extend" 1022 * (startofline == 0) then we should update ends of normal regions 1023 * contained inside "keepend" because "extend" could have extended 1024 * these "keepend" regions as well as contained normal regions. 1025 * Then check for items ending in column 0. 1026 */ 1027 i = current_state.ga_len - 1; 1028 if (keepend_level >= 0) 1029 for ( ; i > keepend_level; --i) 1030 if (CUR_STATE(i).si_flags & HL_EXTEND) 1031 break; 1032 1033 seen_keepend = FALSE; 1034 for ( ; i < current_state.ga_len; ++i) 1035 { 1036 cur_si = &CUR_STATE(i); 1037 if ((cur_si->si_flags & HL_KEEPEND) 1038 || (seen_keepend && !startofline) 1039 || (i == current_state.ga_len - 1 && startofline)) 1040 { 1041 cur_si->si_h_startpos.col = 0; /* start highl. in col 0 */ 1042 cur_si->si_h_startpos.lnum = current_lnum; 1043 1044 if (!(cur_si->si_flags & HL_MATCHCONT)) 1045 update_si_end(cur_si, (int)current_col, !startofline); 1046 1047 if (!startofline && (cur_si->si_flags & HL_KEEPEND)) 1048 seen_keepend = TRUE; 1049 } 1050 } 1051 check_keepend(); 1052 check_state_ends(); 1053 } 1054 1055 /**************************************** 1056 * Handling of the state stack cache. 1057 */ 1058 1059 /* 1060 * EXPLANATION OF THE SYNTAX STATE STACK CACHE 1061 * 1062 * To speed up syntax highlighting, the state stack for the start of some 1063 * lines is cached. These entries can be used to start parsing at that point. 1064 * 1065 * The stack is kept in b_sst_array[] for each buffer. There is a list of 1066 * valid entries. b_sst_first points to the first one, then follow sst_next. 1067 * The entries are sorted on line number. The first entry is often for line 2 1068 * (line 1 always starts with an empty stack). 1069 * There is also a list for free entries. This construction is used to avoid 1070 * having to allocate and free memory blocks too often. 1071 * 1072 * When making changes to the buffer, this is logged in b_mod_*. When calling 1073 * update_screen() to update the display, it will call 1074 * syn_stack_apply_changes() for each displayed buffer to adjust the cached 1075 * entries. The entries which are inside the changed area are removed, 1076 * because they must be recomputed. Entries below the changed have their line 1077 * number adjusted for deleted/inserted lines, and have their sst_change_lnum 1078 * set to indicate that a check must be made if the changed lines would change 1079 * the cached entry. 1080 * 1081 * When later displaying lines, an entry is stored for each line. Displayed 1082 * lines are likely to be displayed again, in which case the state at the 1083 * start of the line is needed. 1084 * For not displayed lines, an entry is stored for every so many lines. These 1085 * entries will be used e.g., when scrolling backwards. The distance between 1086 * entries depends on the number of lines in the buffer. For small buffers 1087 * the distance is fixed at SST_DIST, for large buffers there is a fixed 1088 * number of entries SST_MAX_ENTRIES, and the distance is computed. 1089 */ 1090 1091 /* 1092 * Free b_sst_array[] for buffer "buf". 1093 * Used when syntax items changed to force resyncing everywhere. 1094 */ 1095 void 1096 syn_stack_free_all(buf) 1097 buf_T *buf; 1098 { 1099 synstate_T *p; 1100 win_T *wp; 1101 1102 if (buf->b_sst_array != NULL) 1103 { 1104 for (p = buf->b_sst_first; p != NULL; p = p->sst_next) 1105 clear_syn_state(p); 1106 vim_free(buf->b_sst_array); 1107 buf->b_sst_array = NULL; 1108 buf->b_sst_len = 0; 1109 } 1110 #ifdef FEAT_FOLDING 1111 /* When using "syntax" fold method, must update all folds. */ 1112 FOR_ALL_WINDOWS(wp) 1113 { 1114 if (wp->w_buffer == buf && foldmethodIsSyntax(wp)) 1115 foldUpdateAll(wp); 1116 } 1117 #endif 1118 } 1119 1120 /* 1121 * Allocate the syntax state stack for syn_buf when needed. 1122 * If the number of entries in b_sst_array[] is much too big or a bit too 1123 * small, reallocate it. 1124 * Also used to allocate b_sst_array[] for the first time. 1125 */ 1126 static void 1127 syn_stack_alloc() 1128 { 1129 long len; 1130 synstate_T *to, *from; 1131 synstate_T *sstp; 1132 1133 len = syn_buf->b_ml.ml_line_count / SST_DIST + Rows * 2; 1134 if (len < SST_MIN_ENTRIES) 1135 len = SST_MIN_ENTRIES; 1136 else if (len > SST_MAX_ENTRIES) 1137 len = SST_MAX_ENTRIES; 1138 if (syn_buf->b_sst_len > len * 2 || syn_buf->b_sst_len < len) 1139 { 1140 /* Allocate 50% too much, to avoid reallocating too often. */ 1141 len = syn_buf->b_ml.ml_line_count; 1142 len = (len + len / 2) / SST_DIST + Rows * 2; 1143 if (len < SST_MIN_ENTRIES) 1144 len = SST_MIN_ENTRIES; 1145 else if (len > SST_MAX_ENTRIES) 1146 len = SST_MAX_ENTRIES; 1147 1148 if (syn_buf->b_sst_array != NULL) 1149 { 1150 /* When shrinking the array, cleanup the existing stack. 1151 * Make sure that all valid entries fit in the new array. */ 1152 while (syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2 > len 1153 && syn_stack_cleanup()) 1154 ; 1155 if (len < syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2) 1156 len = syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2; 1157 } 1158 1159 sstp = (synstate_T *)alloc_clear((unsigned)(len * sizeof(synstate_T))); 1160 if (sstp == NULL) /* out of memory! */ 1161 return; 1162 1163 to = sstp - 1; 1164 if (syn_buf->b_sst_array != NULL) 1165 { 1166 /* Move the states from the old array to the new one. */ 1167 for (from = syn_buf->b_sst_first; from != NULL; 1168 from = from->sst_next) 1169 { 1170 ++to; 1171 *to = *from; 1172 to->sst_next = to + 1; 1173 } 1174 } 1175 if (to != sstp - 1) 1176 { 1177 to->sst_next = NULL; 1178 syn_buf->b_sst_first = sstp; 1179 syn_buf->b_sst_freecount = len - (int)(to - sstp) - 1; 1180 } 1181 else 1182 { 1183 syn_buf->b_sst_first = NULL; 1184 syn_buf->b_sst_freecount = len; 1185 } 1186 1187 /* Create the list of free entries. */ 1188 syn_buf->b_sst_firstfree = to + 1; 1189 while (++to < sstp + len) 1190 to->sst_next = to + 1; 1191 (sstp + len - 1)->sst_next = NULL; 1192 1193 vim_free(syn_buf->b_sst_array); 1194 syn_buf->b_sst_array = sstp; 1195 syn_buf->b_sst_len = len; 1196 } 1197 } 1198 1199 /* 1200 * Check for changes in a buffer to affect stored syntax states. Uses the 1201 * b_mod_* fields. 1202 * Called from update_screen(), before screen is being updated, once for each 1203 * displayed buffer. 1204 */ 1205 void 1206 syn_stack_apply_changes(buf) 1207 buf_T *buf; 1208 { 1209 synstate_T *p, *prev, *np; 1210 linenr_T n; 1211 1212 if (buf->b_sst_array == NULL) /* nothing to do */ 1213 return; 1214 1215 prev = NULL; 1216 for (p = buf->b_sst_first; p != NULL; ) 1217 { 1218 if (p->sst_lnum + buf->b_syn_sync_linebreaks > buf->b_mod_top) 1219 { 1220 n = p->sst_lnum + buf->b_mod_xlines; 1221 if (n <= buf->b_mod_bot) 1222 { 1223 /* this state is inside the changed area, remove it */ 1224 np = p->sst_next; 1225 if (prev == NULL) 1226 buf->b_sst_first = np; 1227 else 1228 prev->sst_next = np; 1229 syn_stack_free_entry(buf, p); 1230 p = np; 1231 continue; 1232 } 1233 /* This state is below the changed area. Remember the line 1234 * that needs to be parsed before this entry can be made valid 1235 * again. */ 1236 if (p->sst_change_lnum != 0 && p->sst_change_lnum > buf->b_mod_top) 1237 { 1238 if (p->sst_change_lnum + buf->b_mod_xlines > buf->b_mod_top) 1239 p->sst_change_lnum += buf->b_mod_xlines; 1240 else 1241 p->sst_change_lnum = buf->b_mod_top; 1242 } 1243 if (p->sst_change_lnum == 0 1244 || p->sst_change_lnum < buf->b_mod_bot) 1245 p->sst_change_lnum = buf->b_mod_bot; 1246 1247 p->sst_lnum = n; 1248 } 1249 prev = p; 1250 p = p->sst_next; 1251 } 1252 } 1253 1254 /* 1255 * Reduce the number of entries in the state stack for syn_buf. 1256 * Returns TRUE if at least one entry was freed. 1257 */ 1258 static int 1259 syn_stack_cleanup() 1260 { 1261 synstate_T *p, *prev; 1262 disptick_T tick; 1263 int above; 1264 int dist; 1265 int retval = FALSE; 1266 1267 if (syn_buf->b_sst_array == NULL || syn_buf->b_sst_first == NULL) 1268 return retval; 1269 1270 /* Compute normal distance between non-displayed entries. */ 1271 if (syn_buf->b_sst_len <= Rows) 1272 dist = 999999; 1273 else 1274 dist = syn_buf->b_ml.ml_line_count / (syn_buf->b_sst_len - Rows) + 1; 1275 1276 /* 1277 * Go throught the list to find the "tick" for the oldest entry that can 1278 * be removed. Set "above" when the "tick" for the oldest entry is above 1279 * "b_sst_lasttick" (the display tick wraps around). 1280 */ 1281 tick = syn_buf->b_sst_lasttick; 1282 above = FALSE; 1283 prev = syn_buf->b_sst_first; 1284 for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next) 1285 { 1286 if (prev->sst_lnum + dist > p->sst_lnum) 1287 { 1288 if (p->sst_tick > syn_buf->b_sst_lasttick) 1289 { 1290 if (!above || p->sst_tick < tick) 1291 tick = p->sst_tick; 1292 above = TRUE; 1293 } 1294 else if (!above && p->sst_tick < tick) 1295 tick = p->sst_tick; 1296 } 1297 } 1298 1299 /* 1300 * Go through the list to make the entries for the oldest tick at an 1301 * interval of several lines. 1302 */ 1303 prev = syn_buf->b_sst_first; 1304 for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next) 1305 { 1306 if (p->sst_tick == tick && prev->sst_lnum + dist > p->sst_lnum) 1307 { 1308 /* Move this entry from used list to free list */ 1309 prev->sst_next = p->sst_next; 1310 syn_stack_free_entry(syn_buf, p); 1311 p = prev; 1312 retval = TRUE; 1313 } 1314 } 1315 return retval; 1316 } 1317 1318 /* 1319 * Free the allocated memory for a syn_state item. 1320 * Move the entry into the free list. 1321 */ 1322 static void 1323 syn_stack_free_entry(buf, p) 1324 buf_T *buf; 1325 synstate_T *p; 1326 { 1327 clear_syn_state(p); 1328 p->sst_next = buf->b_sst_firstfree; 1329 buf->b_sst_firstfree = p; 1330 ++buf->b_sst_freecount; 1331 } 1332 1333 /* 1334 * Find an entry in the list of state stacks at or before "lnum". 1335 * Returns NULL when there is no entry or the first entry is after "lnum". 1336 */ 1337 static synstate_T * 1338 syn_stack_find_entry(lnum) 1339 linenr_T lnum; 1340 { 1341 synstate_T *p, *prev; 1342 1343 prev = NULL; 1344 for (p = syn_buf->b_sst_first; p != NULL; prev = p, p = p->sst_next) 1345 { 1346 if (p->sst_lnum == lnum) 1347 return p; 1348 if (p->sst_lnum > lnum) 1349 break; 1350 } 1351 return prev; 1352 } 1353 1354 /* 1355 * Try saving the current state in b_sst_array[]. 1356 * The current state must be valid for the start of the current_lnum line! 1357 */ 1358 static synstate_T * 1359 store_current_state() 1360 { 1361 int i; 1362 synstate_T *p; 1363 bufstate_T *bp; 1364 stateitem_T *cur_si; 1365 synstate_T *sp = syn_stack_find_entry(current_lnum); 1366 1367 /* 1368 * If the current state contains a start or end pattern that continues 1369 * from the previous line, we can't use it. Don't store it then. 1370 */ 1371 for (i = current_state.ga_len - 1; i >= 0; --i) 1372 { 1373 cur_si = &CUR_STATE(i); 1374 if (cur_si->si_h_startpos.lnum >= current_lnum 1375 || cur_si->si_m_endpos.lnum >= current_lnum 1376 || cur_si->si_h_endpos.lnum >= current_lnum 1377 || (cur_si->si_end_idx 1378 && cur_si->si_eoe_pos.lnum >= current_lnum)) 1379 break; 1380 } 1381 if (i >= 0) 1382 { 1383 if (sp != NULL) 1384 { 1385 /* find "sp" in the list and remove it */ 1386 if (syn_buf->b_sst_first == sp) 1387 /* it's the first entry */ 1388 syn_buf->b_sst_first = sp->sst_next; 1389 else 1390 { 1391 /* find the entry just before this one to adjust sst_next */ 1392 for (p = syn_buf->b_sst_first; p != NULL; p = p->sst_next) 1393 if (p->sst_next == sp) 1394 break; 1395 if (p != NULL) /* just in case */ 1396 p->sst_next = sp->sst_next; 1397 } 1398 syn_stack_free_entry(syn_buf, sp); 1399 sp = NULL; 1400 } 1401 } 1402 else if (sp == NULL || sp->sst_lnum != current_lnum) 1403 { 1404 /* 1405 * Add a new entry 1406 */ 1407 /* If no free items, cleanup the array first. */ 1408 if (syn_buf->b_sst_freecount == 0) 1409 { 1410 (void)syn_stack_cleanup(); 1411 /* "sp" may have been moved to the freelist now */ 1412 sp = syn_stack_find_entry(current_lnum); 1413 } 1414 /* Still no free items? Must be a strange problem... */ 1415 if (syn_buf->b_sst_freecount == 0) 1416 sp = NULL; 1417 else 1418 { 1419 /* Take the first item from the free list and put it in the used 1420 * list, after *sp */ 1421 p = syn_buf->b_sst_firstfree; 1422 syn_buf->b_sst_firstfree = p->sst_next; 1423 --syn_buf->b_sst_freecount; 1424 if (sp == NULL) 1425 { 1426 /* Insert in front of the list */ 1427 p->sst_next = syn_buf->b_sst_first; 1428 syn_buf->b_sst_first = p; 1429 } 1430 else 1431 { 1432 /* insert in list after *sp */ 1433 p->sst_next = sp->sst_next; 1434 sp->sst_next = p; 1435 } 1436 sp = p; 1437 sp->sst_stacksize = 0; 1438 sp->sst_lnum = current_lnum; 1439 } 1440 } 1441 if (sp != NULL) 1442 { 1443 /* When overwriting an existing state stack, clear it first */ 1444 clear_syn_state(sp); 1445 sp->sst_stacksize = current_state.ga_len; 1446 if (current_state.ga_len > SST_FIX_STATES) 1447 { 1448 /* Need to clear it, might be something remaining from when the 1449 * length was less than SST_FIX_STATES. */ 1450 ga_init2(&sp->sst_union.sst_ga, (int)sizeof(bufstate_T), 1); 1451 if (ga_grow(&sp->sst_union.sst_ga, current_state.ga_len) == FAIL) 1452 sp->sst_stacksize = 0; 1453 else 1454 sp->sst_union.sst_ga.ga_len = current_state.ga_len; 1455 bp = SYN_STATE_P(&(sp->sst_union.sst_ga)); 1456 } 1457 else 1458 bp = sp->sst_union.sst_stack; 1459 for (i = 0; i < sp->sst_stacksize; ++i) 1460 { 1461 bp[i].bs_idx = CUR_STATE(i).si_idx; 1462 bp[i].bs_flags = CUR_STATE(i).si_flags; 1463 bp[i].bs_extmatch = ref_extmatch(CUR_STATE(i).si_extmatch); 1464 } 1465 sp->sst_next_flags = current_next_flags; 1466 sp->sst_next_list = current_next_list; 1467 sp->sst_tick = display_tick; 1468 sp->sst_change_lnum = 0; 1469 } 1470 current_state_stored = TRUE; 1471 return sp; 1472 } 1473 1474 /* 1475 * Copy a state stack from "from" in b_sst_array[] to current_state; 1476 */ 1477 static void 1478 load_current_state(from) 1479 synstate_T *from; 1480 { 1481 int i; 1482 bufstate_T *bp; 1483 1484 clear_current_state(); 1485 validate_current_state(); 1486 keepend_level = -1; 1487 if (from->sst_stacksize 1488 && ga_grow(¤t_state, from->sst_stacksize) != FAIL) 1489 { 1490 if (from->sst_stacksize > SST_FIX_STATES) 1491 bp = SYN_STATE_P(&(from->sst_union.sst_ga)); 1492 else 1493 bp = from->sst_union.sst_stack; 1494 for (i = 0; i < from->sst_stacksize; ++i) 1495 { 1496 CUR_STATE(i).si_idx = bp[i].bs_idx; 1497 CUR_STATE(i).si_flags = bp[i].bs_flags; 1498 CUR_STATE(i).si_extmatch = ref_extmatch(bp[i].bs_extmatch); 1499 if (keepend_level < 0 && (CUR_STATE(i).si_flags & HL_KEEPEND)) 1500 keepend_level = i; 1501 CUR_STATE(i).si_ends = FALSE; 1502 CUR_STATE(i).si_m_lnum = 0; 1503 if (CUR_STATE(i).si_idx >= 0) 1504 CUR_STATE(i).si_next_list = 1505 (SYN_ITEMS(syn_buf)[CUR_STATE(i).si_idx]).sp_next_list; 1506 else 1507 CUR_STATE(i).si_next_list = NULL; 1508 update_si_attr(i); 1509 } 1510 current_state.ga_len = from->sst_stacksize; 1511 } 1512 current_next_list = from->sst_next_list; 1513 current_next_flags = from->sst_next_flags; 1514 current_lnum = from->sst_lnum; 1515 } 1516 1517 /* 1518 * Compare saved state stack "*sp" with the current state. 1519 * Return TRUE when they are equal. 1520 */ 1521 static int 1522 syn_stack_equal(sp) 1523 synstate_T *sp; 1524 { 1525 int i, j; 1526 bufstate_T *bp; 1527 reg_extmatch_T *six, *bsx; 1528 1529 /* First a quick check if the stacks have the same size end nextlist. */ 1530 if (sp->sst_stacksize == current_state.ga_len 1531 && sp->sst_next_list == current_next_list) 1532 { 1533 /* Need to compare all states on both stacks. */ 1534 if (sp->sst_stacksize > SST_FIX_STATES) 1535 bp = SYN_STATE_P(&(sp->sst_union.sst_ga)); 1536 else 1537 bp = sp->sst_union.sst_stack; 1538 1539 for (i = current_state.ga_len; --i >= 0; ) 1540 { 1541 /* If the item has another index the state is different. */ 1542 if (bp[i].bs_idx != CUR_STATE(i).si_idx) 1543 break; 1544 if (bp[i].bs_extmatch != CUR_STATE(i).si_extmatch) 1545 { 1546 /* When the extmatch pointers are different, the strings in 1547 * them can still be the same. Check if the extmatch 1548 * references are equal. */ 1549 bsx = bp[i].bs_extmatch; 1550 six = CUR_STATE(i).si_extmatch; 1551 /* If one of the extmatch pointers is NULL the states are 1552 * different. */ 1553 if (bsx == NULL || six == NULL) 1554 break; 1555 for (j = 0; j < NSUBEXP; ++j) 1556 { 1557 /* Check each referenced match string. They must all be 1558 * equal. */ 1559 if (bsx->matches[j] != six->matches[j]) 1560 { 1561 /* If the pointer is different it can still be the 1562 * same text. Compare the strings, ignore case when 1563 * the start item has the sp_ic flag set. */ 1564 if (bsx->matches[j] == NULL 1565 || six->matches[j] == NULL) 1566 break; 1567 if ((SYN_ITEMS(syn_buf)[CUR_STATE(i).si_idx]).sp_ic 1568 ? MB_STRICMP(bsx->matches[j], 1569 six->matches[j]) != 0 1570 : STRCMP(bsx->matches[j], six->matches[j]) != 0) 1571 break; 1572 } 1573 } 1574 if (j != NSUBEXP) 1575 break; 1576 } 1577 } 1578 if (i < 0) 1579 return TRUE; 1580 } 1581 return FALSE; 1582 } 1583 1584 /* 1585 * We stop parsing syntax above line "lnum". If the stored state at or below 1586 * this line depended on a change before it, it now depends on the line below 1587 * the last parsed line. 1588 * The window looks like this: 1589 * line which changed 1590 * displayed line 1591 * displayed line 1592 * lnum -> line below window 1593 */ 1594 void 1595 syntax_end_parsing(lnum) 1596 linenr_T lnum; 1597 { 1598 synstate_T *sp; 1599 1600 sp = syn_stack_find_entry(lnum); 1601 if (sp != NULL && sp->sst_lnum < lnum) 1602 sp = sp->sst_next; 1603 1604 if (sp != NULL && sp->sst_change_lnum != 0) 1605 sp->sst_change_lnum = lnum; 1606 } 1607 1608 /* 1609 * End of handling of the state stack. 1610 ****************************************/ 1611 1612 static void 1613 invalidate_current_state() 1614 { 1615 clear_current_state(); 1616 current_state.ga_itemsize = 0; /* mark current_state invalid */ 1617 current_next_list = NULL; 1618 keepend_level = -1; 1619 } 1620 1621 static void 1622 validate_current_state() 1623 { 1624 current_state.ga_itemsize = sizeof(stateitem_T); 1625 current_state.ga_growsize = 3; 1626 } 1627 1628 /* 1629 * Return TRUE if the syntax at start of lnum changed since last time. 1630 * This will only be called just after get_syntax_attr() for the previous 1631 * line, to check if the next line needs to be redrawn too. 1632 */ 1633 int 1634 syntax_check_changed(lnum) 1635 linenr_T lnum; 1636 { 1637 int retval = TRUE; 1638 synstate_T *sp; 1639 1640 /* 1641 * Check the state stack when: 1642 * - lnum is just below the previously syntaxed line. 1643 * - lnum is not before the lines with saved states. 1644 * - lnum is not past the lines with saved states. 1645 * - lnum is at or before the last changed line. 1646 */ 1647 if (VALID_STATE(¤t_state) && lnum == current_lnum + 1) 1648 { 1649 sp = syn_stack_find_entry(lnum); 1650 if (sp != NULL && sp->sst_lnum == lnum) 1651 { 1652 /* 1653 * finish the previous line (needed when not all of the line was 1654 * drawn) 1655 */ 1656 (void)syn_finish_line(FALSE); 1657 1658 /* 1659 * Compare the current state with the previously saved state of 1660 * the line. 1661 */ 1662 if (syn_stack_equal(sp)) 1663 retval = FALSE; 1664 1665 /* 1666 * Store the current state in b_sst_array[] for later use. 1667 */ 1668 ++current_lnum; 1669 (void)store_current_state(); 1670 } 1671 } 1672 1673 return retval; 1674 } 1675 1676 /* 1677 * Finish the current line. 1678 * This doesn't return any attributes, it only gets the state at the end of 1679 * the line. It can start anywhere in the line, as long as the current state 1680 * is valid. 1681 */ 1682 static int 1683 syn_finish_line(syncing) 1684 int syncing; /* called for syncing */ 1685 { 1686 stateitem_T *cur_si; 1687 colnr_T prev_current_col; 1688 1689 if (!current_finished) 1690 { 1691 while (!current_finished) 1692 { 1693 (void)syn_current_attr(syncing, FALSE, NULL, FALSE); 1694 /* 1695 * When syncing, and found some item, need to check the item. 1696 */ 1697 if (syncing && current_state.ga_len) 1698 { 1699 /* 1700 * Check for match with sync item. 1701 */ 1702 cur_si = &CUR_STATE(current_state.ga_len - 1); 1703 if (cur_si->si_idx >= 0 1704 && (SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags 1705 & (HL_SYNC_HERE|HL_SYNC_THERE))) 1706 return TRUE; 1707 1708 /* syn_current_attr() will have skipped the check for an item 1709 * that ends here, need to do that now. Be careful not to go 1710 * past the NUL. */ 1711 prev_current_col = current_col; 1712 if (syn_getcurline()[current_col] != NUL) 1713 ++current_col; 1714 check_state_ends(); 1715 current_col = prev_current_col; 1716 } 1717 ++current_col; 1718 } 1719 } 1720 return FALSE; 1721 } 1722 1723 /* 1724 * Return highlight attributes for next character. 1725 * Must first call syntax_start() once for the line. 1726 * "col" is normally 0 for the first use in a line, and increments by one each 1727 * time. It's allowed to skip characters and to stop before the end of the 1728 * line. But only a "col" after a previously used column is allowed. 1729 * When "can_spell" is not NULL set it to TRUE when spell-checking should be 1730 * done. 1731 */ 1732 int 1733 get_syntax_attr(col, can_spell, keep_state) 1734 colnr_T col; 1735 int *can_spell; 1736 int keep_state; /* keep state of char at "col" */ 1737 { 1738 int attr = 0; 1739 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); 1746 1747 /* check for out of memory situation */ 1748 if (syn_buf->b_sst_array == NULL) 1749 return 0; 1750 1751 /* After 'synmaxcol' the attribute is always zero. */ 1752 if (syn_buf->b_p_smc > 0 && col >= (colnr_T)syn_buf->b_p_smc) 1753 { 1754 clear_current_state(); 1755 #ifdef FEAT_EVAL 1756 current_id = 0; 1757 current_trans_id = 0; 1758 #endif 1759 return 0; 1760 } 1761 1762 /* Make sure current_state is valid */ 1763 if (INVALID_STATE(¤t_state)) 1764 validate_current_state(); 1765 1766 /* 1767 * Skip from the current column to "col", get the attributes for "col". 1768 */ 1769 while (current_col <= col) 1770 { 1771 attr = syn_current_attr(FALSE, TRUE, can_spell, 1772 current_col == col ? keep_state : FALSE); 1773 ++current_col; 1774 } 1775 1776 return attr; 1777 } 1778 1779 /* 1780 * Get syntax attributes for current_lnum, current_col. 1781 */ 1782 static int 1783 syn_current_attr(syncing, displaying, can_spell, keep_state) 1784 int syncing; /* When 1: called for syncing */ 1785 int displaying; /* result will be displayed */ 1786 int *can_spell; /* return: do spell checking */ 1787 int keep_state; /* keep syntax stack afterwards */ 1788 { 1789 int syn_id; 1790 lpos_T endpos; /* was: char_u *endp; */ 1791 lpos_T hl_startpos; /* was: int hl_startcol; */ 1792 lpos_T hl_endpos; 1793 lpos_T eos_pos; /* end-of-start match (start region) */ 1794 lpos_T eoe_pos; /* end-of-end pattern */ 1795 int end_idx; /* group ID for end pattern */ 1796 int idx; 1797 synpat_T *spp; 1798 stateitem_T *cur_si, *sip = NULL; 1799 int startcol; 1800 int endcol; 1801 long flags; 1802 short *next_list; 1803 int found_match; /* found usable match */ 1804 static int try_next_column = FALSE; /* must try in next col */ 1805 int do_keywords; 1806 regmmatch_T regmatch; 1807 lpos_T pos; 1808 int lc_col; 1809 reg_extmatch_T *cur_extmatch = NULL; 1810 char_u *line; /* current line. NOTE: becomes invalid after 1811 looking for a pattern match! */ 1812 1813 /* variables for zero-width matches that have a "nextgroup" argument */ 1814 int keep_next_list; 1815 int zero_width_next_list = FALSE; 1816 garray_T zero_width_next_ga; 1817 1818 /* 1819 * No character, no attributes! Past end of line? 1820 * Do try matching with an empty line (could be the start of a region). 1821 */ 1822 line = syn_getcurline(); 1823 if (line[current_col] == NUL && current_col != 0) 1824 { 1825 /* 1826 * If we found a match after the last column, use it. 1827 */ 1828 if (next_match_idx >= 0 && next_match_col >= (int)current_col 1829 && next_match_col != MAXCOL) 1830 (void)push_next_match(NULL); 1831 1832 current_finished = TRUE; 1833 current_state_stored = FALSE; 1834 return 0; 1835 } 1836 1837 /* if the current or next character is NUL, we will finish the line now */ 1838 if (line[current_col] == NUL || line[current_col + 1] == NUL) 1839 { 1840 current_finished = TRUE; 1841 current_state_stored = FALSE; 1842 } 1843 1844 /* 1845 * When in the previous column there was a match but it could not be used 1846 * (empty match or already matched in this column) need to try again in 1847 * the next column. 1848 */ 1849 if (try_next_column) 1850 { 1851 next_match_idx = -1; 1852 try_next_column = FALSE; 1853 } 1854 1855 /* Only check for keywords when not syncing and there are some. */ 1856 do_keywords = !syncing 1857 && (syn_buf->b_keywtab.ht_used > 0 1858 || syn_buf->b_keywtab_ic.ht_used > 0); 1859 1860 /* Init the list of zero-width matches with a nextlist. This is used to 1861 * avoid matching the same item in the same position twice. */ 1862 ga_init2(&zero_width_next_ga, (int)sizeof(int), 10); 1863 1864 /* 1865 * Repeat matching keywords and patterns, to find contained items at the 1866 * same column. This stops when there are no extra matches at the current 1867 * column. 1868 */ 1869 do 1870 { 1871 found_match = FALSE; 1872 keep_next_list = FALSE; 1873 syn_id = 0; 1874 1875 /* 1876 * 1. Check for a current state. 1877 * Only when there is no current state, or if the current state may 1878 * contain other things, we need to check for keywords and patterns. 1879 * Always need to check for contained items if some item has the 1880 * "containedin" argument (takes extra time!). 1881 */ 1882 if (current_state.ga_len) 1883 cur_si = &CUR_STATE(current_state.ga_len - 1); 1884 else 1885 cur_si = NULL; 1886 1887 if (syn_buf->b_syn_containedin || cur_si == NULL 1888 || cur_si->si_cont_list != NULL) 1889 { 1890 /* 1891 * 2. Check for keywords, if on a keyword char after a non-keyword 1892 * char. Don't do this when syncing. 1893 */ 1894 if (do_keywords) 1895 { 1896 line = syn_getcurline(); 1897 if (vim_iswordc_buf(line + current_col, syn_buf) 1898 && (current_col == 0 1899 || !vim_iswordc_buf(line + current_col - 1 1900 #ifdef FEAT_MBYTE 1901 - (has_mbyte 1902 ? (*mb_head_off)(line, line + current_col - 1) 1903 : 0) 1904 #endif 1905 , syn_buf))) 1906 { 1907 syn_id = check_keyword_id(line, (int)current_col, 1908 &endcol, &flags, &next_list, cur_si); 1909 if (syn_id != 0) 1910 { 1911 if (push_current_state(KEYWORD_IDX) == OK) 1912 { 1913 cur_si = &CUR_STATE(current_state.ga_len - 1); 1914 cur_si->si_m_startcol = current_col; 1915 cur_si->si_h_startpos.lnum = current_lnum; 1916 cur_si->si_h_startpos.col = 0; /* starts right away */ 1917 cur_si->si_m_endpos.lnum = current_lnum; 1918 cur_si->si_m_endpos.col = endcol; 1919 cur_si->si_h_endpos.lnum = current_lnum; 1920 cur_si->si_h_endpos.col = endcol; 1921 cur_si->si_ends = TRUE; 1922 cur_si->si_end_idx = 0; 1923 cur_si->si_flags = flags; 1924 cur_si->si_id = syn_id; 1925 cur_si->si_trans_id = syn_id; 1926 if (flags & HL_TRANSP) 1927 { 1928 if (current_state.ga_len < 2) 1929 { 1930 cur_si->si_attr = 0; 1931 cur_si->si_trans_id = 0; 1932 } 1933 else 1934 { 1935 cur_si->si_attr = CUR_STATE( 1936 current_state.ga_len - 2).si_attr; 1937 cur_si->si_trans_id = CUR_STATE( 1938 current_state.ga_len - 2).si_trans_id; 1939 } 1940 } 1941 else 1942 cur_si->si_attr = syn_id2attr(syn_id); 1943 cur_si->si_cont_list = NULL; 1944 cur_si->si_next_list = next_list; 1945 check_keepend(); 1946 } 1947 else 1948 vim_free(next_list); 1949 } 1950 } 1951 } 1952 1953 /* 1954 * 3. Check for patterns (only if no keyword found). 1955 */ 1956 if (syn_id == 0 && syn_buf->b_syn_patterns.ga_len) 1957 { 1958 /* 1959 * If we didn't check for a match yet, or we are past it, check 1960 * for any match with a pattern. 1961 */ 1962 if (next_match_idx < 0 || next_match_col < (int)current_col) 1963 { 1964 /* 1965 * Check all relevant patterns for a match at this 1966 * position. This is complicated, because matching with a 1967 * pattern takes quite a bit of time, thus we want to 1968 * avoid doing it when it's not needed. 1969 */ 1970 next_match_idx = 0; /* no match in this line yet */ 1971 next_match_col = MAXCOL; 1972 for (idx = syn_buf->b_syn_patterns.ga_len; --idx >= 0; ) 1973 { 1974 spp = &(SYN_ITEMS(syn_buf)[idx]); 1975 if ( spp->sp_syncing == syncing 1976 && (displaying || !(spp->sp_flags & HL_DISPLAY)) 1977 && (spp->sp_type == SPTYPE_MATCH 1978 || spp->sp_type == SPTYPE_START) 1979 && (current_next_list != NULL 1980 ? in_id_list(NULL, current_next_list, 1981 &spp->sp_syn, 0) 1982 : (cur_si == NULL 1983 ? !(spp->sp_flags & HL_CONTAINED) 1984 : in_id_list(cur_si, 1985 cur_si->si_cont_list, &spp->sp_syn, 1986 spp->sp_flags & HL_CONTAINED)))) 1987 { 1988 /* If we already tried matching in this line, and 1989 * there isn't a match before next_match_col, skip 1990 * this item. */ 1991 if (spp->sp_line_id == current_line_id 1992 && spp->sp_startcol >= next_match_col) 1993 continue; 1994 spp->sp_line_id = current_line_id; 1995 1996 lc_col = current_col - spp->sp_offsets[SPO_LC_OFF]; 1997 if (lc_col < 0) 1998 lc_col = 0; 1999 2000 regmatch.rmm_ic = spp->sp_ic; 2001 regmatch.regprog = spp->sp_prog; 2002 if (!syn_regexec(®match, current_lnum, 2003 (colnr_T)lc_col)) 2004 { 2005 /* no match in this line, try another one */ 2006 spp->sp_startcol = MAXCOL; 2007 continue; 2008 } 2009 2010 /* 2011 * Compute the first column of the match. 2012 */ 2013 syn_add_start_off(&pos, ®match, 2014 spp, SPO_MS_OFF, -1); 2015 if (pos.lnum > current_lnum) 2016 { 2017 /* must have used end of match in a next line, 2018 * we can't handle that */ 2019 spp->sp_startcol = MAXCOL; 2020 continue; 2021 } 2022 startcol = pos.col; 2023 2024 /* remember the next column where this pattern 2025 * matches in the current line */ 2026 spp->sp_startcol = startcol; 2027 2028 /* 2029 * If a previously found match starts at a lower 2030 * column number, don't use this one. 2031 */ 2032 if (startcol >= next_match_col) 2033 continue; 2034 2035 /* 2036 * If we matched this pattern at this position 2037 * before, skip it. Must retry in the next 2038 * column, because it may match from there. 2039 */ 2040 if (did_match_already(idx, &zero_width_next_ga)) 2041 { 2042 try_next_column = TRUE; 2043 continue; 2044 } 2045 2046 endpos.lnum = regmatch.endpos[0].lnum; 2047 endpos.col = regmatch.endpos[0].col; 2048 2049 /* Compute the highlight start. */ 2050 syn_add_start_off(&hl_startpos, ®match, 2051 spp, SPO_HS_OFF, -1); 2052 2053 /* Compute the region start. */ 2054 /* Default is to use the end of the match. */ 2055 syn_add_end_off(&eos_pos, ®match, 2056 spp, SPO_RS_OFF, 0); 2057 2058 /* 2059 * Grab the external submatches before they get 2060 * overwritten. Reference count doesn't change. 2061 */ 2062 unref_extmatch(cur_extmatch); 2063 cur_extmatch = re_extmatch_out; 2064 re_extmatch_out = NULL; 2065 2066 flags = 0; 2067 eoe_pos.lnum = 0; /* avoid warning */ 2068 eoe_pos.col = 0; 2069 end_idx = 0; 2070 hl_endpos.lnum = 0; 2071 2072 /* 2073 * For a "oneline" the end must be found in the 2074 * same line too. Search for it after the end of 2075 * the match with the start pattern. Set the 2076 * resulting end positions at the same time. 2077 */ 2078 if (spp->sp_type == SPTYPE_START 2079 && (spp->sp_flags & HL_ONELINE)) 2080 { 2081 lpos_T startpos; 2082 2083 startpos = endpos; 2084 find_endpos(idx, &startpos, &endpos, &hl_endpos, 2085 &flags, &eoe_pos, &end_idx, cur_extmatch); 2086 if (endpos.lnum == 0) 2087 continue; /* not found */ 2088 } 2089 2090 /* 2091 * For a "match" the size must be > 0 after the 2092 * end offset needs has been added. Except when 2093 * syncing. 2094 */ 2095 else if (spp->sp_type == SPTYPE_MATCH) 2096 { 2097 syn_add_end_off(&hl_endpos, ®match, spp, 2098 SPO_HE_OFF, 0); 2099 syn_add_end_off(&endpos, ®match, spp, 2100 SPO_ME_OFF, 0); 2101 if (endpos.lnum == current_lnum 2102 && (int)endpos.col + syncing < startcol) 2103 { 2104 /* 2105 * If an empty string is matched, may need 2106 * to try matching again at next column. 2107 */ 2108 if (regmatch.startpos[0].col 2109 == regmatch.endpos[0].col) 2110 try_next_column = TRUE; 2111 continue; 2112 } 2113 } 2114 2115 /* 2116 * keep the best match so far in next_match_* 2117 */ 2118 /* Highlighting must start after startpos and end 2119 * before endpos. */ 2120 if (hl_startpos.lnum == current_lnum 2121 && (int)hl_startpos.col < startcol) 2122 hl_startpos.col = startcol; 2123 limit_pos_zero(&hl_endpos, &endpos); 2124 2125 next_match_idx = idx; 2126 next_match_col = startcol; 2127 next_match_m_endpos = endpos; 2128 next_match_h_endpos = hl_endpos; 2129 next_match_h_startpos = hl_startpos; 2130 next_match_flags = flags; 2131 next_match_eos_pos = eos_pos; 2132 next_match_eoe_pos = eoe_pos; 2133 next_match_end_idx = end_idx; 2134 unref_extmatch(next_match_extmatch); 2135 next_match_extmatch = cur_extmatch; 2136 cur_extmatch = NULL; 2137 } 2138 } 2139 } 2140 2141 /* 2142 * If we found a match at the current column, use it. 2143 */ 2144 if (next_match_idx >= 0 && next_match_col == (int)current_col) 2145 { 2146 synpat_T *lspp; 2147 2148 /* When a zero-width item matched which has a nextgroup, 2149 * don't push the item but set nextgroup. */ 2150 lspp = &(SYN_ITEMS(syn_buf)[next_match_idx]); 2151 if (next_match_m_endpos.lnum == current_lnum 2152 && next_match_m_endpos.col == current_col 2153 && lspp->sp_next_list != NULL) 2154 { 2155 current_next_list = lspp->sp_next_list; 2156 current_next_flags = lspp->sp_flags; 2157 keep_next_list = TRUE; 2158 zero_width_next_list = TRUE; 2159 2160 /* Add the index to a list, so that we can check 2161 * later that we don't match it again (and cause an 2162 * endless loop). */ 2163 if (ga_grow(&zero_width_next_ga, 1) == OK) 2164 { 2165 ((int *)(zero_width_next_ga.ga_data)) 2166 [zero_width_next_ga.ga_len++] = next_match_idx; 2167 } 2168 next_match_idx = -1; 2169 } 2170 else 2171 cur_si = push_next_match(cur_si); 2172 found_match = TRUE; 2173 } 2174 } 2175 } 2176 2177 /* 2178 * Handle searching for nextgroup match. 2179 */ 2180 if (current_next_list != NULL && !keep_next_list) 2181 { 2182 /* 2183 * If a nextgroup was not found, continue looking for one if: 2184 * - this is an empty line and the "skipempty" option was given 2185 * - we are on white space and the "skipwhite" option was given 2186 */ 2187 if (!found_match) 2188 { 2189 line = syn_getcurline(); 2190 if (((current_next_flags & HL_SKIPWHITE) 2191 && vim_iswhite(line[current_col])) 2192 || ((current_next_flags & HL_SKIPEMPTY) 2193 && *line == NUL)) 2194 break; 2195 } 2196 2197 /* 2198 * If a nextgroup was found: Use it, and continue looking for 2199 * contained matches. 2200 * If a nextgroup was not found: Continue looking for a normal 2201 * match. 2202 * When did set current_next_list for a zero-width item and no 2203 * match was found don't loop (would get stuck). 2204 */ 2205 current_next_list = NULL; 2206 next_match_idx = -1; 2207 if (!zero_width_next_list) 2208 found_match = TRUE; 2209 } 2210 2211 } while (found_match); 2212 2213 /* 2214 * Use attributes from the current state, if within its highlighting. 2215 * If not, use attributes from the current-but-one state, etc. 2216 */ 2217 current_attr = 0; 2218 #ifdef FEAT_EVAL 2219 current_id = 0; 2220 current_trans_id = 0; 2221 #endif 2222 if (cur_si != NULL) 2223 { 2224 #ifndef FEAT_EVAL 2225 int current_trans_id = 0; 2226 #endif 2227 for (idx = current_state.ga_len - 1; idx >= 0; --idx) 2228 { 2229 sip = &CUR_STATE(idx); 2230 if ((current_lnum > sip->si_h_startpos.lnum 2231 || (current_lnum == sip->si_h_startpos.lnum 2232 && current_col >= sip->si_h_startpos.col)) 2233 && (sip->si_h_endpos.lnum == 0 2234 || current_lnum < sip->si_h_endpos.lnum 2235 || (current_lnum == sip->si_h_endpos.lnum 2236 && current_col < sip->si_h_endpos.col))) 2237 { 2238 current_attr = sip->si_attr; 2239 #ifdef FEAT_EVAL 2240 current_id = sip->si_id; 2241 #endif 2242 current_trans_id = sip->si_trans_id; 2243 break; 2244 } 2245 } 2246 2247 if (can_spell != NULL) 2248 { 2249 struct sp_syn sps; 2250 2251 /* 2252 * set "can_spell" to TRUE if spell checking is supposed to be 2253 * done in the current item. 2254 */ 2255 if (syn_buf->b_spell_cluster_id == 0) 2256 { 2257 /* There is no @Spell cluster: Do spelling for items without 2258 * @NoSpell cluster. */ 2259 if (syn_buf->b_nospell_cluster_id == 0 || current_trans_id == 0) 2260 *can_spell = (syn_buf->b_syn_spell != SYNSPL_NOTOP); 2261 else 2262 { 2263 sps.inc_tag = 0; 2264 sps.id = syn_buf->b_nospell_cluster_id; 2265 sps.cont_in_list = NULL; 2266 *can_spell = !in_id_list(sip, sip->si_cont_list, &sps, 0); 2267 } 2268 } 2269 else 2270 { 2271 /* The @Spell cluster is defined: Do spelling in items with 2272 * the @Spell cluster. But not when @NoSpell is also there. 2273 * At the toplevel only spell check when ":syn spell toplevel" 2274 * was used. */ 2275 if (current_trans_id == 0) 2276 *can_spell = (syn_buf->b_syn_spell == SYNSPL_TOP); 2277 else 2278 { 2279 sps.inc_tag = 0; 2280 sps.id = syn_buf->b_spell_cluster_id; 2281 sps.cont_in_list = NULL; 2282 *can_spell = in_id_list(sip, sip->si_cont_list, &sps, 0); 2283 2284 if (syn_buf->b_nospell_cluster_id != 0) 2285 { 2286 sps.id = syn_buf->b_nospell_cluster_id; 2287 if (in_id_list(sip, sip->si_cont_list, &sps, 0)) 2288 *can_spell = FALSE; 2289 } 2290 } 2291 } 2292 } 2293 2294 2295 /* 2296 * Check for end of current state (and the states before it) at the 2297 * next column. Don't do this for syncing, because we would miss a 2298 * single character match. 2299 * First check if the current state ends at the current column. It 2300 * may be for an empty match and a containing item might end in the 2301 * current column. 2302 */ 2303 if (!syncing && !keep_state) 2304 { 2305 check_state_ends(); 2306 if (current_state.ga_len > 0 2307 && syn_getcurline()[current_col] != NUL) 2308 { 2309 ++current_col; 2310 check_state_ends(); 2311 --current_col; 2312 } 2313 } 2314 } 2315 else if (can_spell != NULL) 2316 /* Default: Only do spelling when there is no @Spell cluster or when 2317 * ":syn spell toplevel" was used. */ 2318 *can_spell = syn_buf->b_syn_spell == SYNSPL_DEFAULT 2319 ? (syn_buf->b_spell_cluster_id == 0) 2320 : (syn_buf->b_syn_spell == SYNSPL_TOP); 2321 2322 /* nextgroup ends at end of line, unless "skipnl" or "skipemtpy" present */ 2323 if (current_next_list != NULL 2324 && syn_getcurline()[current_col + 1] == NUL 2325 && !(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))) 2326 current_next_list = NULL; 2327 2328 if (zero_width_next_ga.ga_len > 0) 2329 ga_clear(&zero_width_next_ga); 2330 2331 /* No longer need external matches. But keep next_match_extmatch. */ 2332 unref_extmatch(re_extmatch_out); 2333 re_extmatch_out = NULL; 2334 unref_extmatch(cur_extmatch); 2335 2336 return current_attr; 2337 } 2338 2339 2340 /* 2341 * Check if we already matched pattern "idx" at the current column. 2342 */ 2343 static int 2344 did_match_already(idx, gap) 2345 int idx; 2346 garray_T *gap; 2347 { 2348 int i; 2349 2350 for (i = current_state.ga_len; --i >= 0; ) 2351 if (CUR_STATE(i).si_m_startcol == (int)current_col 2352 && CUR_STATE(i).si_m_lnum == (int)current_lnum 2353 && CUR_STATE(i).si_idx == idx) 2354 return TRUE; 2355 2356 /* Zero-width matches with a nextgroup argument are not put on the syntax 2357 * stack, and can only be matched once anyway. */ 2358 for (i = gap->ga_len; --i >= 0; ) 2359 if (((int *)(gap->ga_data))[i] == idx) 2360 return TRUE; 2361 2362 return FALSE; 2363 } 2364 2365 /* 2366 * Push the next match onto the stack. 2367 */ 2368 static stateitem_T * 2369 push_next_match(cur_si) 2370 stateitem_T *cur_si; 2371 { 2372 synpat_T *spp; 2373 2374 spp = &(SYN_ITEMS(syn_buf)[next_match_idx]); 2375 2376 /* 2377 * Push the item in current_state stack; 2378 */ 2379 if (push_current_state(next_match_idx) == OK) 2380 { 2381 /* 2382 * If it's a start-skip-end type that crosses lines, figure out how 2383 * much it continues in this line. Otherwise just fill in the length. 2384 */ 2385 cur_si = &CUR_STATE(current_state.ga_len - 1); 2386 cur_si->si_h_startpos = next_match_h_startpos; 2387 cur_si->si_m_startcol = current_col; 2388 cur_si->si_m_lnum = current_lnum; 2389 cur_si->si_flags = spp->sp_flags; 2390 cur_si->si_next_list = spp->sp_next_list; 2391 cur_si->si_extmatch = ref_extmatch(next_match_extmatch); 2392 if (spp->sp_type == SPTYPE_START && !(spp->sp_flags & HL_ONELINE)) 2393 { 2394 /* Try to find the end pattern in the current line */ 2395 update_si_end(cur_si, (int)(next_match_m_endpos.col), TRUE); 2396 check_keepend(); 2397 } 2398 else 2399 { 2400 cur_si->si_m_endpos = next_match_m_endpos; 2401 cur_si->si_h_endpos = next_match_h_endpos; 2402 cur_si->si_ends = TRUE; 2403 cur_si->si_flags |= next_match_flags; 2404 cur_si->si_eoe_pos = next_match_eoe_pos; 2405 cur_si->si_end_idx = next_match_end_idx; 2406 } 2407 if (keepend_level < 0 && (cur_si->si_flags & HL_KEEPEND)) 2408 keepend_level = current_state.ga_len - 1; 2409 check_keepend(); 2410 update_si_attr(current_state.ga_len - 1); 2411 2412 /* 2413 * If the start pattern has another highlight group, push another item 2414 * on the stack for the start pattern. 2415 */ 2416 if ( spp->sp_type == SPTYPE_START 2417 && spp->sp_syn_match_id != 0 2418 && push_current_state(next_match_idx) == OK) 2419 { 2420 cur_si = &CUR_STATE(current_state.ga_len - 1); 2421 cur_si->si_h_startpos = next_match_h_startpos; 2422 cur_si->si_m_startcol = current_col; 2423 cur_si->si_m_lnum = current_lnum; 2424 cur_si->si_m_endpos = next_match_eos_pos; 2425 cur_si->si_h_endpos = next_match_eos_pos; 2426 cur_si->si_ends = TRUE; 2427 cur_si->si_end_idx = 0; 2428 cur_si->si_flags = HL_MATCH; 2429 cur_si->si_next_list = NULL; 2430 check_keepend(); 2431 update_si_attr(current_state.ga_len - 1); 2432 } 2433 } 2434 2435 next_match_idx = -1; /* try other match next time */ 2436 2437 return cur_si; 2438 } 2439 2440 /* 2441 * Check for end of current state (and the states before it). 2442 */ 2443 static void 2444 check_state_ends() 2445 { 2446 stateitem_T *cur_si; 2447 int had_extend = FALSE; 2448 2449 cur_si = &CUR_STATE(current_state.ga_len - 1); 2450 for (;;) 2451 { 2452 if (cur_si->si_ends 2453 && (cur_si->si_m_endpos.lnum < current_lnum 2454 || (cur_si->si_m_endpos.lnum == current_lnum 2455 && cur_si->si_m_endpos.col <= current_col))) 2456 { 2457 /* 2458 * If there is an end pattern group ID, highlight the end pattern 2459 * now. No need to pop the current item from the stack. 2460 * Only do this if the end pattern continues beyond the current 2461 * position. 2462 */ 2463 if (cur_si->si_end_idx 2464 && (cur_si->si_eoe_pos.lnum > current_lnum 2465 || (cur_si->si_eoe_pos.lnum == current_lnum 2466 && cur_si->si_eoe_pos.col > current_col))) 2467 { 2468 cur_si->si_idx = cur_si->si_end_idx; 2469 cur_si->si_end_idx = 0; 2470 cur_si->si_m_endpos = cur_si->si_eoe_pos; 2471 cur_si->si_h_endpos = cur_si->si_eoe_pos; 2472 cur_si->si_flags |= HL_MATCH; 2473 update_si_attr(current_state.ga_len - 1); 2474 2475 /* what matches next may be different now, clear it */ 2476 next_match_idx = 0; 2477 next_match_col = MAXCOL; 2478 break; 2479 } 2480 else 2481 { 2482 /* handle next_list, unless at end of line and no "skipnl" or 2483 * "skipempty" */ 2484 current_next_list = cur_si->si_next_list; 2485 current_next_flags = cur_si->si_flags; 2486 if (!(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY)) 2487 && syn_getcurline()[current_col] == NUL) 2488 current_next_list = NULL; 2489 2490 /* When the ended item has "extend", another item with 2491 * "keepend" now needs to check for its end. */ 2492 if (cur_si->si_flags & HL_EXTEND) 2493 had_extend = TRUE; 2494 2495 pop_current_state(); 2496 2497 if (current_state.ga_len == 0) 2498 break; 2499 2500 if (had_extend && keepend_level >= 0) 2501 { 2502 syn_update_ends(FALSE); 2503 if (current_state.ga_len == 0) 2504 break; 2505 } 2506 2507 cur_si = &CUR_STATE(current_state.ga_len - 1); 2508 2509 /* 2510 * Only for a region the search for the end continues after 2511 * the end of the contained item. If the contained match 2512 * included the end-of-line, break here, the region continues. 2513 * Don't do this when: 2514 * - "keepend" is used for the contained item 2515 * - not at the end of the line (could be end="x$"me=e-1). 2516 * - "excludenl" is used (HL_HAS_EOL won't be set) 2517 */ 2518 if (cur_si->si_idx >= 0 2519 && SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_type 2520 == SPTYPE_START 2521 && !(cur_si->si_flags & (HL_MATCH | HL_KEEPEND))) 2522 { 2523 update_si_end(cur_si, (int)current_col, TRUE); 2524 check_keepend(); 2525 if ((current_next_flags & HL_HAS_EOL) 2526 && keepend_level < 0 2527 && syn_getcurline()[current_col] == NUL) 2528 break; 2529 } 2530 } 2531 } 2532 else 2533 break; 2534 } 2535 } 2536 2537 /* 2538 * Update an entry in the current_state stack for a match or region. This 2539 * fills in si_attr, si_next_list and si_cont_list. 2540 */ 2541 static void 2542 update_si_attr(idx) 2543 int idx; 2544 { 2545 stateitem_T *sip = &CUR_STATE(idx); 2546 synpat_T *spp; 2547 2548 /* This should not happen... */ 2549 if (sip->si_idx < 0) 2550 return; 2551 2552 spp = &(SYN_ITEMS(syn_buf)[sip->si_idx]); 2553 if (sip->si_flags & HL_MATCH) 2554 sip->si_id = spp->sp_syn_match_id; 2555 else 2556 sip->si_id = spp->sp_syn.id; 2557 sip->si_attr = syn_id2attr(sip->si_id); 2558 sip->si_trans_id = sip->si_id; 2559 if (sip->si_flags & HL_MATCH) 2560 sip->si_cont_list = NULL; 2561 else 2562 sip->si_cont_list = spp->sp_cont_list; 2563 2564 /* 2565 * For transparent items, take attr from outer item. 2566 * Also take cont_list, if there is none. 2567 * Don't do this for the matchgroup of a start or end pattern. 2568 */ 2569 if ((spp->sp_flags & HL_TRANSP) && !(sip->si_flags & HL_MATCH)) 2570 { 2571 if (idx == 0) 2572 { 2573 sip->si_attr = 0; 2574 sip->si_trans_id = 0; 2575 if (sip->si_cont_list == NULL) 2576 sip->si_cont_list = ID_LIST_ALL; 2577 } 2578 else 2579 { 2580 sip->si_attr = CUR_STATE(idx - 1).si_attr; 2581 sip->si_trans_id = CUR_STATE(idx - 1).si_trans_id; 2582 sip->si_h_startpos = CUR_STATE(idx - 1).si_h_startpos; 2583 sip->si_h_endpos = CUR_STATE(idx - 1).si_h_endpos; 2584 if (sip->si_cont_list == NULL) 2585 { 2586 sip->si_flags |= HL_TRANS_CONT; 2587 sip->si_cont_list = CUR_STATE(idx - 1).si_cont_list; 2588 } 2589 } 2590 } 2591 } 2592 2593 /* 2594 * Check the current stack for patterns with "keepend" flag. 2595 * Propagate the match-end to contained items, until a "skipend" item is found. 2596 */ 2597 static void 2598 check_keepend() 2599 { 2600 int i; 2601 lpos_T maxpos; 2602 lpos_T maxpos_h; 2603 stateitem_T *sip; 2604 2605 /* 2606 * This check can consume a lot of time; only do it from the level where 2607 * there really is a keepend. 2608 */ 2609 if (keepend_level < 0) 2610 return; 2611 2612 /* 2613 * Find the last index of an "extend" item. "keepend" items before that 2614 * won't do anything. If there is no "extend" item "i" will be 2615 * "keepend_level" and all "keepend" items will work normally. 2616 */ 2617 for (i = current_state.ga_len - 1; i > keepend_level; --i) 2618 if (CUR_STATE(i).si_flags & HL_EXTEND) 2619 break; 2620 2621 maxpos.lnum = 0; 2622 maxpos_h.lnum = 0; 2623 for ( ; i < current_state.ga_len; ++i) 2624 { 2625 sip = &CUR_STATE(i); 2626 if (maxpos.lnum != 0) 2627 { 2628 limit_pos_zero(&sip->si_m_endpos, &maxpos); 2629 limit_pos_zero(&sip->si_h_endpos, &maxpos_h); 2630 limit_pos_zero(&sip->si_eoe_pos, &maxpos); 2631 sip->si_ends = TRUE; 2632 } 2633 if (sip->si_ends && (sip->si_flags & HL_KEEPEND)) 2634 { 2635 if (maxpos.lnum == 0 2636 || maxpos.lnum > sip->si_m_endpos.lnum 2637 || (maxpos.lnum == sip->si_m_endpos.lnum 2638 && maxpos.col > sip->si_m_endpos.col)) 2639 maxpos = sip->si_m_endpos; 2640 if (maxpos_h.lnum == 0 2641 || maxpos_h.lnum > sip->si_h_endpos.lnum 2642 || (maxpos_h.lnum == sip->si_h_endpos.lnum 2643 && maxpos_h.col > sip->si_h_endpos.col)) 2644 maxpos_h = sip->si_h_endpos; 2645 } 2646 } 2647 } 2648 2649 /* 2650 * Update an entry in the current_state stack for a start-skip-end pattern. 2651 * This finds the end of the current item, if it's in the current line. 2652 * 2653 * Return the flags for the matched END. 2654 */ 2655 static void 2656 update_si_end(sip, startcol, force) 2657 stateitem_T *sip; 2658 int startcol; /* where to start searching for the end */ 2659 int force; /* when TRUE overrule a previous end */ 2660 { 2661 lpos_T startpos; 2662 lpos_T endpos; 2663 lpos_T hl_endpos; 2664 lpos_T end_endpos; 2665 int end_idx; 2666 2667 /* return quickly for a keyword */ 2668 if (sip->si_idx < 0) 2669 return; 2670 2671 /* Don't update when it's already done. Can be a match of an end pattern 2672 * that started in a previous line. Watch out: can also be a "keepend" 2673 * from a containing item. */ 2674 if (!force && sip->si_m_endpos.lnum >= current_lnum) 2675 return; 2676 2677 /* 2678 * We need to find the end of the region. It may continue in the next 2679 * line. 2680 */ 2681 end_idx = 0; 2682 startpos.lnum = current_lnum; 2683 startpos.col = startcol; 2684 find_endpos(sip->si_idx, &startpos, &endpos, &hl_endpos, 2685 &(sip->si_flags), &end_endpos, &end_idx, sip->si_extmatch); 2686 2687 if (endpos.lnum == 0) 2688 { 2689 /* No end pattern matched. */ 2690 if (SYN_ITEMS(syn_buf)[sip->si_idx].sp_flags & HL_ONELINE) 2691 { 2692 /* a "oneline" never continues in the next line */ 2693 sip->si_ends = TRUE; 2694 sip->si_m_endpos.lnum = current_lnum; 2695 sip->si_m_endpos.col = (colnr_T)STRLEN(syn_getcurline()); 2696 } 2697 else 2698 { 2699 /* continues in the next line */ 2700 sip->si_ends = FALSE; 2701 sip->si_m_endpos.lnum = 0; 2702 } 2703 sip->si_h_endpos = sip->si_m_endpos; 2704 } 2705 else 2706 { 2707 /* match within this line */ 2708 sip->si_m_endpos = endpos; 2709 sip->si_h_endpos = hl_endpos; 2710 sip->si_eoe_pos = end_endpos; 2711 sip->si_ends = TRUE; 2712 sip->si_end_idx = end_idx; 2713 } 2714 } 2715 2716 /* 2717 * Add a new state to the current state stack. 2718 * It is cleared and the index set to "idx". 2719 * Return FAIL if it's not possible (out of memory). 2720 */ 2721 static int 2722 push_current_state(idx) 2723 int idx; 2724 { 2725 if (ga_grow(¤t_state, 1) == FAIL) 2726 return FAIL; 2727 vim_memset(&CUR_STATE(current_state.ga_len), 0, sizeof(stateitem_T)); 2728 CUR_STATE(current_state.ga_len).si_idx = idx; 2729 ++current_state.ga_len; 2730 return OK; 2731 } 2732 2733 /* 2734 * Remove a state from the current_state stack. 2735 */ 2736 static void 2737 pop_current_state() 2738 { 2739 if (current_state.ga_len) 2740 { 2741 unref_extmatch(CUR_STATE(current_state.ga_len - 1).si_extmatch); 2742 --current_state.ga_len; 2743 } 2744 /* after the end of a pattern, try matching a keyword or pattern */ 2745 next_match_idx = -1; 2746 2747 /* if first state with "keepend" is popped, reset keepend_level */ 2748 if (keepend_level >= current_state.ga_len) 2749 keepend_level = -1; 2750 } 2751 2752 /* 2753 * Find the end of a start/skip/end syntax region after "startpos". 2754 * Only checks one line. 2755 * Also handles a match item that continued from a previous line. 2756 * If not found, the syntax item continues in the next line. m_endpos->lnum 2757 * will be 0. 2758 * If found, the end of the region and the end of the highlighting is 2759 * computed. 2760 */ 2761 static void 2762 find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos, 2763 end_idx, start_ext) 2764 int idx; /* index of the pattern */ 2765 lpos_T *startpos; /* where to start looking for an END match */ 2766 lpos_T *m_endpos; /* return: end of match */ 2767 lpos_T *hl_endpos; /* return: end of highlighting */ 2768 long *flagsp; /* return: flags of matching END */ 2769 lpos_T *end_endpos; /* return: end of end pattern match */ 2770 int *end_idx; /* return: group ID for end pat. match, or 0 */ 2771 reg_extmatch_T *start_ext; /* submatches from the start pattern */ 2772 { 2773 colnr_T matchcol; 2774 synpat_T *spp, *spp_skip; 2775 int start_idx; 2776 int best_idx; 2777 regmmatch_T regmatch; 2778 regmmatch_T best_regmatch; /* startpos/endpos of best match */ 2779 lpos_T pos; 2780 char_u *line; 2781 int had_match = FALSE; 2782 2783 /* just in case we are invoked for a keyword */ 2784 if (idx < 0) 2785 return; 2786 2787 /* 2788 * Check for being called with a START pattern. 2789 * Can happen with a match that continues to the next line, because it 2790 * contained a region. 2791 */ 2792 spp = &(SYN_ITEMS(syn_buf)[idx]); 2793 if (spp->sp_type != SPTYPE_START) 2794 { 2795 *hl_endpos = *startpos; 2796 return; 2797 } 2798 2799 /* 2800 * Find the SKIP or first END pattern after the last START pattern. 2801 */ 2802 for (;;) 2803 { 2804 spp = &(SYN_ITEMS(syn_buf)[idx]); 2805 if (spp->sp_type != SPTYPE_START) 2806 break; 2807 ++idx; 2808 } 2809 2810 /* 2811 * Lookup the SKIP pattern (if present) 2812 */ 2813 if (spp->sp_type == SPTYPE_SKIP) 2814 { 2815 spp_skip = spp; 2816 ++idx; 2817 } 2818 else 2819 spp_skip = NULL; 2820 2821 /* Setup external matches for syn_regexec(). */ 2822 unref_extmatch(re_extmatch_in); 2823 re_extmatch_in = ref_extmatch(start_ext); 2824 2825 matchcol = startpos->col; /* start looking for a match at sstart */ 2826 start_idx = idx; /* remember the first END pattern. */ 2827 best_regmatch.startpos[0].col = 0; /* avoid compiler warning */ 2828 for (;;) 2829 { 2830 /* 2831 * Find end pattern that matches first after "matchcol". 2832 */ 2833 best_idx = -1; 2834 for (idx = start_idx; idx < syn_buf->b_syn_patterns.ga_len; ++idx) 2835 { 2836 int lc_col = matchcol; 2837 2838 spp = &(SYN_ITEMS(syn_buf)[idx]); 2839 if (spp->sp_type != SPTYPE_END) /* past last END pattern */ 2840 break; 2841 lc_col -= spp->sp_offsets[SPO_LC_OFF]; 2842 if (lc_col < 0) 2843 lc_col = 0; 2844 2845 regmatch.rmm_ic = spp->sp_ic; 2846 regmatch.regprog = spp->sp_prog; 2847 if (syn_regexec(®match, startpos->lnum, lc_col)) 2848 { 2849 if (best_idx == -1 || regmatch.startpos[0].col 2850 < best_regmatch.startpos[0].col) 2851 { 2852 best_idx = idx; 2853 best_regmatch.startpos[0] = regmatch.startpos[0]; 2854 best_regmatch.endpos[0] = regmatch.endpos[0]; 2855 } 2856 } 2857 } 2858 2859 /* 2860 * If all end patterns have been tried, and there is no match, the 2861 * item continues until end-of-line. 2862 */ 2863 if (best_idx == -1) 2864 break; 2865 2866 /* 2867 * If the skip pattern matches before the end pattern, 2868 * continue searching after the skip pattern. 2869 */ 2870 if (spp_skip != NULL) 2871 { 2872 int lc_col = matchcol - spp_skip->sp_offsets[SPO_LC_OFF]; 2873 2874 if (lc_col < 0) 2875 lc_col = 0; 2876 regmatch.rmm_ic = spp_skip->sp_ic; 2877 regmatch.regprog = spp_skip->sp_prog; 2878 if (syn_regexec(®match, startpos->lnum, lc_col) 2879 && regmatch.startpos[0].col 2880 <= best_regmatch.startpos[0].col) 2881 { 2882 /* Add offset to skip pattern match */ 2883 syn_add_end_off(&pos, ®match, spp_skip, SPO_ME_OFF, 1); 2884 2885 /* If the skip pattern goes on to the next line, there is no 2886 * match with an end pattern in this line. */ 2887 if (pos.lnum > startpos->lnum) 2888 break; 2889 2890 line = ml_get_buf(syn_buf, startpos->lnum, FALSE); 2891 2892 /* take care of an empty match or negative offset */ 2893 if (pos.col <= matchcol) 2894 ++matchcol; 2895 else if (pos.col <= regmatch.endpos[0].col) 2896 matchcol = pos.col; 2897 else 2898 /* Be careful not to jump over the NUL at the end-of-line */ 2899 for (matchcol = regmatch.endpos[0].col; 2900 line[matchcol] != NUL && matchcol < pos.col; 2901 ++matchcol) 2902 ; 2903 2904 /* if the skip pattern includes end-of-line, break here */ 2905 if (line[matchcol] == NUL) 2906 break; 2907 2908 continue; /* start with first end pattern again */ 2909 } 2910 } 2911 2912 /* 2913 * Match from start pattern to end pattern. 2914 * Correct for match and highlight offset of end pattern. 2915 */ 2916 spp = &(SYN_ITEMS(syn_buf)[best_idx]); 2917 syn_add_end_off(m_endpos, &best_regmatch, spp, SPO_ME_OFF, 1); 2918 /* can't end before the start */ 2919 if (m_endpos->lnum == startpos->lnum && m_endpos->col < startpos->col) 2920 m_endpos->col = startpos->col; 2921 2922 syn_add_end_off(end_endpos, &best_regmatch, spp, SPO_HE_OFF, 1); 2923 /* can't end before the start */ 2924 if (end_endpos->lnum == startpos->lnum 2925 && end_endpos->col < startpos->col) 2926 end_endpos->col = startpos->col; 2927 /* can't end after the match */ 2928 limit_pos(end_endpos, m_endpos); 2929 2930 /* 2931 * If the end group is highlighted differently, adjust the pointers. 2932 */ 2933 if (spp->sp_syn_match_id != spp->sp_syn.id && spp->sp_syn_match_id != 0) 2934 { 2935 *end_idx = best_idx; 2936 if (spp->sp_off_flags & (1 << (SPO_RE_OFF + SPO_COUNT))) 2937 { 2938 hl_endpos->lnum = best_regmatch.endpos[0].lnum; 2939 hl_endpos->col = best_regmatch.endpos[0].col; 2940 } 2941 else 2942 { 2943 hl_endpos->lnum = best_regmatch.startpos[0].lnum; 2944 hl_endpos->col = best_regmatch.startpos[0].col; 2945 } 2946 hl_endpos->col += spp->sp_offsets[SPO_RE_OFF]; 2947 2948 /* can't end before the start */ 2949 if (hl_endpos->lnum == startpos->lnum 2950 && hl_endpos->col < startpos->col) 2951 hl_endpos->col = startpos->col; 2952 limit_pos(hl_endpos, m_endpos); 2953 2954 /* now the match ends where the highlighting ends, it is turned 2955 * into the matchgroup for the end */ 2956 *m_endpos = *hl_endpos; 2957 } 2958 else 2959 { 2960 *end_idx = 0; 2961 *hl_endpos = *end_endpos; 2962 } 2963 2964 *flagsp = spp->sp_flags; 2965 2966 had_match = TRUE; 2967 break; 2968 } 2969 2970 /* no match for an END pattern in this line */ 2971 if (!had_match) 2972 m_endpos->lnum = 0; 2973 2974 /* Remove external matches. */ 2975 unref_extmatch(re_extmatch_in); 2976 re_extmatch_in = NULL; 2977 } 2978 2979 /* 2980 * Limit "pos" not to be after "limit". 2981 */ 2982 static void 2983 limit_pos(pos, limit) 2984 lpos_T *pos; 2985 lpos_T *limit; 2986 { 2987 if (pos->lnum > limit->lnum) 2988 *pos = *limit; 2989 else if (pos->lnum == limit->lnum && pos->col > limit->col) 2990 pos->col = limit->col; 2991 } 2992 2993 /* 2994 * Limit "pos" not to be after "limit", unless pos->lnum is zero. 2995 */ 2996 static void 2997 limit_pos_zero(pos, limit) 2998 lpos_T *pos; 2999 lpos_T *limit; 3000 { 3001 if (pos->lnum == 0) 3002 *pos = *limit; 3003 else 3004 limit_pos(pos, limit); 3005 } 3006 3007 /* 3008 * Add offset to matched text for end of match or highlight. 3009 */ 3010 static void 3011 syn_add_end_off(result, regmatch, spp, idx, extra) 3012 lpos_T *result; /* returned position */ 3013 regmmatch_T *regmatch; /* start/end of match */ 3014 synpat_T *spp; /* matched pattern */ 3015 int idx; /* index of offset */ 3016 int extra; /* extra chars for offset to start */ 3017 { 3018 int col; 3019 int off; 3020 char_u *base; 3021 char_u *p; 3022 3023 if (spp->sp_off_flags & (1 << idx)) 3024 { 3025 result->lnum = regmatch->startpos[0].lnum; 3026 col = regmatch->startpos[0].col; 3027 off = spp->sp_offsets[idx] + extra; 3028 } 3029 else 3030 { 3031 result->lnum = regmatch->endpos[0].lnum; 3032 col = regmatch->endpos[0].col; 3033 off = spp->sp_offsets[idx]; 3034 } 3035 /* Don't go past the end of the line. Matters for "rs=e+2" when there 3036 * is a matchgroup. Watch out for match with last NL in the buffer. */ 3037 if (result->lnum > syn_buf->b_ml.ml_line_count) 3038 col = 0; 3039 else if (off != 0) 3040 { 3041 base = ml_get_buf(syn_buf, result->lnum, FALSE); 3042 p = base + col; 3043 if (off > 0) 3044 { 3045 while (off-- > 0 && *p != NUL) 3046 mb_ptr_adv(p); 3047 } 3048 else if (off < 0) 3049 { 3050 while (off++ < 0 && base < p) 3051 mb_ptr_back(base, p); 3052 } 3053 col = (int)(p - base); 3054 } 3055 result->col = col; 3056 } 3057 3058 /* 3059 * Add offset to matched text for start of match or highlight. 3060 * Avoid resulting column to become negative. 3061 */ 3062 static void 3063 syn_add_start_off(result, regmatch, spp, idx, extra) 3064 lpos_T *result; /* returned position */ 3065 regmmatch_T *regmatch; /* start/end of match */ 3066 synpat_T *spp; 3067 int idx; 3068 int extra; /* extra chars for offset to end */ 3069 { 3070 int col; 3071 int off; 3072 char_u *base; 3073 char_u *p; 3074 3075 if (spp->sp_off_flags & (1 << (idx + SPO_COUNT))) 3076 { 3077 result->lnum = regmatch->endpos[0].lnum; 3078 col = regmatch->endpos[0].col; 3079 off = spp->sp_offsets[idx] + extra; 3080 } 3081 else 3082 { 3083 result->lnum = regmatch->startpos[0].lnum; 3084 col = regmatch->startpos[0].col; 3085 off = spp->sp_offsets[idx]; 3086 } 3087 if (off != 0) 3088 { 3089 base = ml_get_buf(syn_buf, result->lnum, FALSE); 3090 p = base + col; 3091 if (off > 0) 3092 { 3093 while (off-- && *p != NUL) 3094 mb_ptr_adv(p); 3095 } 3096 else if (off < 0) 3097 { 3098 while (off++ && base < p) 3099 mb_ptr_back(base, p); 3100 } 3101 col = (int)(p - base); 3102 } 3103 result->col = col; 3104 } 3105 3106 /* 3107 * Get current line in syntax buffer. 3108 */ 3109 static char_u * 3110 syn_getcurline() 3111 { 3112 return ml_get_buf(syn_buf, current_lnum, FALSE); 3113 } 3114 3115 /* 3116 * Call vim_regexec() to find a match with "rmp" in "syn_buf". 3117 * Returns TRUE when there is a match. 3118 */ 3119 static int 3120 syn_regexec(rmp, lnum, col) 3121 regmmatch_T *rmp; 3122 linenr_T lnum; 3123 colnr_T col; 3124 { 3125 rmp->rmm_maxcol = syn_buf->b_p_smc; 3126 if (vim_regexec_multi(rmp, syn_win, syn_buf, lnum, col, NULL) > 0) 3127 { 3128 rmp->startpos[0].lnum += lnum; 3129 rmp->endpos[0].lnum += lnum; 3130 return TRUE; 3131 } 3132 return FALSE; 3133 } 3134 3135 /* 3136 * Check one position in a line for a matching keyword. 3137 * The caller must check if a keyword can start at startcol. 3138 * Return it's ID if found, 0 otherwise. 3139 */ 3140 static int 3141 check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si) 3142 char_u *line; 3143 int startcol; /* position in line to check for keyword */ 3144 int *endcolp; /* return: character after found keyword */ 3145 long *flagsp; /* return: flags of matching keyword */ 3146 short **next_listp; /* return: next_list of matching keyword */ 3147 stateitem_T *cur_si; /* item at the top of the stack */ 3148 { 3149 keyentry_T *kp; 3150 char_u *kwp; 3151 int round; 3152 int kwlen; 3153 char_u keyword[MAXKEYWLEN + 1]; /* assume max. keyword len is 80 */ 3154 hashtab_T *ht; 3155 hashitem_T *hi; 3156 3157 /* Find first character after the keyword. First character was already 3158 * checked. */ 3159 kwp = line + startcol; 3160 kwlen = 0; 3161 do 3162 { 3163 #ifdef FEAT_MBYTE 3164 if (has_mbyte) 3165 kwlen += (*mb_ptr2len)(kwp + kwlen); 3166 else 3167 #endif 3168 ++kwlen; 3169 } 3170 while (vim_iswordc_buf(kwp + kwlen, syn_buf)); 3171 3172 if (kwlen > MAXKEYWLEN) 3173 return 0; 3174 3175 /* 3176 * Must make a copy of the keyword, so we can add a NUL and make it 3177 * lowercase. 3178 */ 3179 vim_strncpy(keyword, kwp, kwlen); 3180 3181 /* 3182 * Try twice: 3183 * 1. matching case 3184 * 2. ignoring case 3185 */ 3186 for (round = 1; round <= 2; ++round) 3187 { 3188 ht = round == 1 ? &syn_buf->b_keywtab : &syn_buf->b_keywtab_ic; 3189 if (ht->ht_used == 0) 3190 continue; 3191 if (round == 2) /* ignore case */ 3192 (void)str_foldcase(kwp, kwlen, keyword, MAXKEYWLEN + 1); 3193 3194 /* 3195 * Find keywords that match. There can be several with different 3196 * attributes. 3197 * When current_next_list is non-zero accept only that group, otherwise: 3198 * Accept a not-contained keyword at toplevel. 3199 * Accept a keyword at other levels only if it is in the contains list. 3200 */ 3201 hi = hash_find(ht, keyword); 3202 if (!HASHITEM_EMPTY(hi)) 3203 for (kp = HI2KE(hi); kp != NULL; kp = kp->ke_next) 3204 { 3205 if (current_next_list != 0 3206 ? in_id_list(NULL, current_next_list, &kp->k_syn, 0) 3207 : (cur_si == NULL 3208 ? !(kp->flags & HL_CONTAINED) 3209 : in_id_list(cur_si, cur_si->si_cont_list, 3210 &kp->k_syn, kp->flags & HL_CONTAINED))) 3211 { 3212 *endcolp = startcol + kwlen; 3213 *flagsp = kp->flags; 3214 *next_listp = kp->next_list; 3215 return kp->k_syn.id; 3216 } 3217 } 3218 } 3219 return 0; 3220 } 3221 3222 /* 3223 * Handle ":syntax case" command. 3224 */ 3225 /* ARGSUSED */ 3226 static void 3227 syn_cmd_case(eap, syncing) 3228 exarg_T *eap; 3229 int syncing; /* not used */ 3230 { 3231 char_u *arg = eap->arg; 3232 char_u *next; 3233 3234 eap->nextcmd = find_nextcmd(arg); 3235 if (eap->skip) 3236 return; 3237 3238 next = skiptowhite(arg); 3239 if (STRNICMP(arg, "match", 5) == 0 && next - arg == 5) 3240 curbuf->b_syn_ic = FALSE; 3241 else if (STRNICMP(arg, "ignore", 6) == 0 && next - arg == 6) 3242 curbuf->b_syn_ic = TRUE; 3243 else 3244 EMSG2(_("E390: Illegal argument: %s"), arg); 3245 } 3246 3247 /* 3248 * Handle ":syntax spell" command. 3249 */ 3250 /* ARGSUSED */ 3251 static void 3252 syn_cmd_spell(eap, syncing) 3253 exarg_T *eap; 3254 int syncing; /* not used */ 3255 { 3256 char_u *arg = eap->arg; 3257 char_u *next; 3258 3259 eap->nextcmd = find_nextcmd(arg); 3260 if (eap->skip) 3261 return; 3262 3263 next = skiptowhite(arg); 3264 if (STRNICMP(arg, "toplevel", 8) == 0 && next - arg == 8) 3265 curbuf->b_syn_spell = SYNSPL_TOP; 3266 else if (STRNICMP(arg, "notoplevel", 10) == 0 && next - arg == 10) 3267 curbuf->b_syn_spell = SYNSPL_NOTOP; 3268 else if (STRNICMP(arg, "default", 7) == 0 && next - arg == 7) 3269 curbuf->b_syn_spell = SYNSPL_DEFAULT; 3270 else 3271 EMSG2(_("E390: Illegal argument: %s"), arg); 3272 } 3273 3274 /* 3275 * Clear all syntax info for one buffer. 3276 */ 3277 void 3278 syntax_clear(buf) 3279 buf_T *buf; 3280 { 3281 int i; 3282 3283 buf->b_syn_error = FALSE; /* clear previous error */ 3284 buf->b_syn_ic = FALSE; /* Use case, by default */ 3285 buf->b_syn_spell = SYNSPL_DEFAULT; /* default spell checking */ 3286 buf->b_syn_containedin = FALSE; 3287 3288 /* free the keywords */ 3289 clear_keywtab(&buf->b_keywtab); 3290 clear_keywtab(&buf->b_keywtab_ic); 3291 3292 /* free the syntax patterns */ 3293 for (i = buf->b_syn_patterns.ga_len; --i >= 0; ) 3294 syn_clear_pattern(buf, i); 3295 ga_clear(&buf->b_syn_patterns); 3296 3297 /* free the syntax clusters */ 3298 for (i = buf->b_syn_clusters.ga_len; --i >= 0; ) 3299 syn_clear_cluster(buf, i); 3300 ga_clear(&buf->b_syn_clusters); 3301 buf->b_spell_cluster_id = 0; 3302 buf->b_nospell_cluster_id = 0; 3303 3304 buf->b_syn_sync_flags = 0; 3305 buf->b_syn_sync_minlines = 0; 3306 buf->b_syn_sync_maxlines = 0; 3307 buf->b_syn_sync_linebreaks = 0; 3308 3309 vim_free(buf->b_syn_linecont_prog); 3310 buf->b_syn_linecont_prog = NULL; 3311 vim_free(buf->b_syn_linecont_pat); 3312 buf->b_syn_linecont_pat = NULL; 3313 #ifdef FEAT_FOLDING 3314 buf->b_syn_folditems = 0; 3315 #endif 3316 3317 /* free the stored states */ 3318 syn_stack_free_all(buf); 3319 invalidate_current_state(); 3320 } 3321 3322 /* 3323 * Clear syncing info for one buffer. 3324 */ 3325 static void 3326 syntax_sync_clear() 3327 { 3328 int i; 3329 3330 /* free the syntax patterns */ 3331 for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; ) 3332 if (SYN_ITEMS(curbuf)[i].sp_syncing) 3333 syn_remove_pattern(curbuf, i); 3334 3335 curbuf->b_syn_sync_flags = 0; 3336 curbuf->b_syn_sync_minlines = 0; 3337 curbuf->b_syn_sync_maxlines = 0; 3338 curbuf->b_syn_sync_linebreaks = 0; 3339 3340 vim_free(curbuf->b_syn_linecont_prog); 3341 curbuf->b_syn_linecont_prog = NULL; 3342 vim_free(curbuf->b_syn_linecont_pat); 3343 curbuf->b_syn_linecont_pat = NULL; 3344 3345 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 3346 } 3347 3348 /* 3349 * Remove one pattern from the buffer's pattern list. 3350 */ 3351 static void 3352 syn_remove_pattern(buf, idx) 3353 buf_T *buf; 3354 int idx; 3355 { 3356 synpat_T *spp; 3357 3358 spp = &(SYN_ITEMS(buf)[idx]); 3359 #ifdef FEAT_FOLDING 3360 if (spp->sp_flags & HL_FOLD) 3361 --buf->b_syn_folditems; 3362 #endif 3363 syn_clear_pattern(buf, idx); 3364 mch_memmove(spp, spp + 1, 3365 sizeof(synpat_T) * (buf->b_syn_patterns.ga_len - idx - 1)); 3366 --buf->b_syn_patterns.ga_len; 3367 } 3368 3369 /* 3370 * Clear and free one syntax pattern. When clearing all, must be called from 3371 * last to first! 3372 */ 3373 static void 3374 syn_clear_pattern(buf, i) 3375 buf_T *buf; 3376 int i; 3377 { 3378 vim_free(SYN_ITEMS(buf)[i].sp_pattern); 3379 vim_free(SYN_ITEMS(buf)[i].sp_prog); 3380 /* Only free sp_cont_list and sp_next_list of first start pattern */ 3381 if (i == 0 || SYN_ITEMS(buf)[i - 1].sp_type != SPTYPE_START) 3382 { 3383 vim_free(SYN_ITEMS(buf)[i].sp_cont_list); 3384 vim_free(SYN_ITEMS(buf)[i].sp_next_list); 3385 vim_free(SYN_ITEMS(buf)[i].sp_syn.cont_in_list); 3386 } 3387 } 3388 3389 /* 3390 * Clear and free one syntax cluster. 3391 */ 3392 static void 3393 syn_clear_cluster(buf, i) 3394 buf_T *buf; 3395 int i; 3396 { 3397 vim_free(SYN_CLSTR(buf)[i].scl_name); 3398 vim_free(SYN_CLSTR(buf)[i].scl_name_u); 3399 vim_free(SYN_CLSTR(buf)[i].scl_list); 3400 } 3401 3402 /* 3403 * Handle ":syntax clear" command. 3404 */ 3405 static void 3406 syn_cmd_clear(eap, syncing) 3407 exarg_T *eap; 3408 int syncing; 3409 { 3410 char_u *arg = eap->arg; 3411 char_u *arg_end; 3412 int id; 3413 3414 eap->nextcmd = find_nextcmd(arg); 3415 if (eap->skip) 3416 return; 3417 3418 /* 3419 * We have to disable this within ":syn include @group filename", 3420 * because otherwise @group would get deleted. 3421 * Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn 3422 * clear". 3423 */ 3424 if (curbuf->b_syn_topgrp != 0) 3425 return; 3426 3427 if (ends_excmd(*arg)) 3428 { 3429 /* 3430 * No argument: Clear all syntax items. 3431 */ 3432 if (syncing) 3433 syntax_sync_clear(); 3434 else 3435 { 3436 syntax_clear(curbuf); 3437 do_unlet((char_u *)"b:current_syntax", TRUE); 3438 } 3439 } 3440 else 3441 { 3442 /* 3443 * Clear the group IDs that are in the argument. 3444 */ 3445 while (!ends_excmd(*arg)) 3446 { 3447 arg_end = skiptowhite(arg); 3448 if (*arg == '@') 3449 { 3450 id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1)); 3451 if (id == 0) 3452 { 3453 EMSG2(_("E391: No such syntax cluster: %s"), arg); 3454 break; 3455 } 3456 else 3457 { 3458 /* 3459 * We can't physically delete a cluster without changing 3460 * the IDs of other clusters, so we do the next best thing 3461 * and make it empty. 3462 */ 3463 short scl_id = id - SYNID_CLUSTER; 3464 3465 vim_free(SYN_CLSTR(curbuf)[scl_id].scl_list); 3466 SYN_CLSTR(curbuf)[scl_id].scl_list = NULL; 3467 } 3468 } 3469 else 3470 { 3471 id = syn_namen2id(arg, (int)(arg_end - arg)); 3472 if (id == 0) 3473 { 3474 EMSG2(_(e_nogroup), arg); 3475 break; 3476 } 3477 else 3478 syn_clear_one(id, syncing); 3479 } 3480 arg = skipwhite(arg_end); 3481 } 3482 } 3483 redraw_curbuf_later(SOME_VALID); 3484 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 3485 } 3486 3487 /* 3488 * Clear one syntax group for the current buffer. 3489 */ 3490 static void 3491 syn_clear_one(id, syncing) 3492 int id; 3493 int syncing; 3494 { 3495 synpat_T *spp; 3496 int idx; 3497 3498 /* Clear keywords only when not ":syn sync clear group-name" */ 3499 if (!syncing) 3500 { 3501 (void)syn_clear_keyword(id, &curbuf->b_keywtab); 3502 (void)syn_clear_keyword(id, &curbuf->b_keywtab_ic); 3503 } 3504 3505 /* clear the patterns for "id" */ 3506 for (idx = curbuf->b_syn_patterns.ga_len; --idx >= 0; ) 3507 { 3508 spp = &(SYN_ITEMS(curbuf)[idx]); 3509 if (spp->sp_syn.id != id || spp->sp_syncing != syncing) 3510 continue; 3511 syn_remove_pattern(curbuf, idx); 3512 } 3513 } 3514 3515 /* 3516 * Handle ":syntax on" command. 3517 */ 3518 /* ARGSUSED */ 3519 static void 3520 syn_cmd_on(eap, syncing) 3521 exarg_T *eap; 3522 int syncing; /* not used */ 3523 { 3524 syn_cmd_onoff(eap, "syntax"); 3525 } 3526 3527 /* 3528 * Handle ":syntax enable" command. 3529 */ 3530 /* ARGSUSED */ 3531 static void 3532 syn_cmd_enable(eap, syncing) 3533 exarg_T *eap; 3534 int syncing; /* not used */ 3535 { 3536 set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"enable"); 3537 syn_cmd_onoff(eap, "syntax"); 3538 do_unlet((char_u *)"g:syntax_cmd", TRUE); 3539 } 3540 3541 /* 3542 * Handle ":syntax reset" command. 3543 */ 3544 /* ARGSUSED */ 3545 static void 3546 syn_cmd_reset(eap, syncing) 3547 exarg_T *eap; 3548 int syncing; /* not used */ 3549 { 3550 eap->nextcmd = check_nextcmd(eap->arg); 3551 if (!eap->skip) 3552 { 3553 set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"reset"); 3554 do_cmdline_cmd((char_u *)"runtime! syntax/syncolor.vim"); 3555 do_unlet((char_u *)"g:syntax_cmd", TRUE); 3556 } 3557 } 3558 3559 /* 3560 * Handle ":syntax manual" command. 3561 */ 3562 /* ARGSUSED */ 3563 static void 3564 syn_cmd_manual(eap, syncing) 3565 exarg_T *eap; 3566 int syncing; /* not used */ 3567 { 3568 syn_cmd_onoff(eap, "manual"); 3569 } 3570 3571 /* 3572 * Handle ":syntax off" command. 3573 */ 3574 /* ARGSUSED */ 3575 static void 3576 syn_cmd_off(eap, syncing) 3577 exarg_T *eap; 3578 int syncing; /* not used */ 3579 { 3580 syn_cmd_onoff(eap, "nosyntax"); 3581 } 3582 3583 static void 3584 syn_cmd_onoff(eap, name) 3585 exarg_T *eap; 3586 char *name; 3587 { 3588 char_u buf[100]; 3589 3590 eap->nextcmd = check_nextcmd(eap->arg); 3591 if (!eap->skip) 3592 { 3593 STRCPY(buf, "so "); 3594 vim_snprintf((char *)buf + 3, sizeof(buf) - 3, SYNTAX_FNAME, name); 3595 do_cmdline_cmd(buf); 3596 } 3597 } 3598 3599 /* 3600 * Handle ":syntax [list]" command: list current syntax words. 3601 */ 3602 static void 3603 syn_cmd_list(eap, syncing) 3604 exarg_T *eap; 3605 int syncing; /* when TRUE: list syncing items */ 3606 { 3607 char_u *arg = eap->arg; 3608 int id; 3609 char_u *arg_end; 3610 3611 eap->nextcmd = find_nextcmd(arg); 3612 if (eap->skip) 3613 return; 3614 3615 if (!syntax_present(curbuf)) 3616 { 3617 MSG(_("No Syntax items defined for this buffer")); 3618 return; 3619 } 3620 3621 if (syncing) 3622 { 3623 if (curbuf->b_syn_sync_flags & SF_CCOMMENT) 3624 { 3625 MSG_PUTS(_("syncing on C-style comments")); 3626 syn_lines_msg(); 3627 syn_match_msg(); 3628 return; 3629 } 3630 else if (!(curbuf->b_syn_sync_flags & SF_MATCH)) 3631 { 3632 if (curbuf->b_syn_sync_minlines == 0) 3633 MSG_PUTS(_("no syncing")); 3634 else 3635 { 3636 MSG_PUTS(_("syncing starts ")); 3637 msg_outnum(curbuf->b_syn_sync_minlines); 3638 MSG_PUTS(_(" lines before top line")); 3639 syn_match_msg(); 3640 } 3641 return; 3642 } 3643 MSG_PUTS_TITLE(_("\n--- Syntax sync items ---")); 3644 if (curbuf->b_syn_sync_minlines > 0 3645 || curbuf->b_syn_sync_maxlines > 0 3646 || curbuf->b_syn_sync_linebreaks > 0) 3647 { 3648 MSG_PUTS(_("\nsyncing on items")); 3649 syn_lines_msg(); 3650 syn_match_msg(); 3651 } 3652 } 3653 else 3654 MSG_PUTS_TITLE(_("\n--- Syntax items ---")); 3655 if (ends_excmd(*arg)) 3656 { 3657 /* 3658 * No argument: List all group IDs and all syntax clusters. 3659 */ 3660 for (id = 1; id <= highlight_ga.ga_len && !got_int; ++id) 3661 syn_list_one(id, syncing, FALSE); 3662 for (id = 0; id < curbuf->b_syn_clusters.ga_len && !got_int; ++id) 3663 syn_list_cluster(id); 3664 } 3665 else 3666 { 3667 /* 3668 * List the group IDs and syntax clusters that are in the argument. 3669 */ 3670 while (!ends_excmd(*arg) && !got_int) 3671 { 3672 arg_end = skiptowhite(arg); 3673 if (*arg == '@') 3674 { 3675 id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1)); 3676 if (id == 0) 3677 EMSG2(_("E392: No such syntax cluster: %s"), arg); 3678 else 3679 syn_list_cluster(id - SYNID_CLUSTER); 3680 } 3681 else 3682 { 3683 id = syn_namen2id(arg, (int)(arg_end - arg)); 3684 if (id == 0) 3685 EMSG2(_(e_nogroup), arg); 3686 else 3687 syn_list_one(id, syncing, TRUE); 3688 } 3689 arg = skipwhite(arg_end); 3690 } 3691 } 3692 eap->nextcmd = check_nextcmd(arg); 3693 } 3694 3695 static void 3696 syn_lines_msg() 3697 { 3698 if (curbuf->b_syn_sync_maxlines > 0 || curbuf->b_syn_sync_minlines > 0) 3699 { 3700 MSG_PUTS("; "); 3701 if (curbuf->b_syn_sync_minlines > 0) 3702 { 3703 MSG_PUTS(_("minimal ")); 3704 msg_outnum(curbuf->b_syn_sync_minlines); 3705 if (curbuf->b_syn_sync_maxlines) 3706 MSG_PUTS(", "); 3707 } 3708 if (curbuf->b_syn_sync_maxlines > 0) 3709 { 3710 MSG_PUTS(_("maximal ")); 3711 msg_outnum(curbuf->b_syn_sync_maxlines); 3712 } 3713 MSG_PUTS(_(" lines before top line")); 3714 } 3715 } 3716 3717 static void 3718 syn_match_msg() 3719 { 3720 if (curbuf->b_syn_sync_linebreaks > 0) 3721 { 3722 MSG_PUTS(_("; match ")); 3723 msg_outnum(curbuf->b_syn_sync_linebreaks); 3724 MSG_PUTS(_(" line breaks")); 3725 } 3726 } 3727 3728 static int last_matchgroup; 3729 3730 struct name_list 3731 { 3732 int flag; 3733 char *name; 3734 }; 3735 3736 static void syn_list_flags __ARGS((struct name_list *nl, int flags, int attr)); 3737 3738 /* 3739 * List one syntax item, for ":syntax" or "syntax list syntax_name". 3740 */ 3741 static void 3742 syn_list_one(id, syncing, link_only) 3743 int id; 3744 int syncing; /* when TRUE: list syncing items */ 3745 int link_only; /* when TRUE; list link-only too */ 3746 { 3747 int attr; 3748 int idx; 3749 int did_header = FALSE; 3750 synpat_T *spp; 3751 static struct name_list namelist1[] = 3752 { 3753 {HL_DISPLAY, "display"}, 3754 {HL_CONTAINED, "contained"}, 3755 {HL_ONELINE, "oneline"}, 3756 {HL_KEEPEND, "keepend"}, 3757 {HL_EXTEND, "extend"}, 3758 {HL_EXCLUDENL, "excludenl"}, 3759 {HL_TRANSP, "transparent"}, 3760 {HL_FOLD, "fold"}, 3761 {0, NULL} 3762 }; 3763 static struct name_list namelist2[] = 3764 { 3765 {HL_SKIPWHITE, "skipwhite"}, 3766 {HL_SKIPNL, "skipnl"}, 3767 {HL_SKIPEMPTY, "skipempty"}, 3768 {0, NULL} 3769 }; 3770 3771 attr = hl_attr(HLF_D); /* highlight like directories */ 3772 3773 /* list the keywords for "id" */ 3774 if (!syncing) 3775 { 3776 did_header = syn_list_keywords(id, &curbuf->b_keywtab, FALSE, attr); 3777 did_header = syn_list_keywords(id, &curbuf->b_keywtab_ic, 3778 did_header, attr); 3779 } 3780 3781 /* list the patterns for "id" */ 3782 for (idx = 0; idx < curbuf->b_syn_patterns.ga_len && !got_int; ++idx) 3783 { 3784 spp = &(SYN_ITEMS(curbuf)[idx]); 3785 if (spp->sp_syn.id != id || spp->sp_syncing != syncing) 3786 continue; 3787 3788 (void)syn_list_header(did_header, 999, id); 3789 did_header = TRUE; 3790 last_matchgroup = 0; 3791 if (spp->sp_type == SPTYPE_MATCH) 3792 { 3793 put_pattern("match", ' ', spp, attr); 3794 msg_putchar(' '); 3795 } 3796 else if (spp->sp_type == SPTYPE_START) 3797 { 3798 while (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_START) 3799 put_pattern("start", '=', &SYN_ITEMS(curbuf)[idx++], attr); 3800 if (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_SKIP) 3801 put_pattern("skip", '=', &SYN_ITEMS(curbuf)[idx++], attr); 3802 while (idx < curbuf->b_syn_patterns.ga_len 3803 && SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_END) 3804 put_pattern("end", '=', &SYN_ITEMS(curbuf)[idx++], attr); 3805 --idx; 3806 msg_putchar(' '); 3807 } 3808 syn_list_flags(namelist1, spp->sp_flags, attr); 3809 3810 if (spp->sp_cont_list != NULL) 3811 put_id_list((char_u *)"contains", spp->sp_cont_list, attr); 3812 3813 if (spp->sp_syn.cont_in_list != NULL) 3814 put_id_list((char_u *)"containedin", 3815 spp->sp_syn.cont_in_list, attr); 3816 3817 if (spp->sp_next_list != NULL) 3818 { 3819 put_id_list((char_u *)"nextgroup", spp->sp_next_list, attr); 3820 syn_list_flags(namelist2, spp->sp_flags, attr); 3821 } 3822 if (spp->sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE)) 3823 { 3824 if (spp->sp_flags & HL_SYNC_HERE) 3825 msg_puts_attr((char_u *)"grouphere", attr); 3826 else 3827 msg_puts_attr((char_u *)"groupthere", attr); 3828 msg_putchar(' '); 3829 if (spp->sp_sync_idx >= 0) 3830 msg_outtrans(HL_TABLE()[SYN_ITEMS(curbuf) 3831 [spp->sp_sync_idx].sp_syn.id - 1].sg_name); 3832 else 3833 MSG_PUTS("NONE"); 3834 msg_putchar(' '); 3835 } 3836 } 3837 3838 /* list the link, if there is one */ 3839 if (HL_TABLE()[id - 1].sg_link && (did_header || link_only) && !got_int) 3840 { 3841 (void)syn_list_header(did_header, 999, id); 3842 msg_puts_attr((char_u *)"links to", attr); 3843 msg_putchar(' '); 3844 msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name); 3845 } 3846 } 3847 3848 static void 3849 syn_list_flags(nl, flags, attr) 3850 struct name_list *nl; 3851 int flags; 3852 int attr; 3853 { 3854 int i; 3855 3856 for (i = 0; nl[i].flag != 0; ++i) 3857 if (flags & nl[i].flag) 3858 { 3859 msg_puts_attr((char_u *)nl[i].name, attr); 3860 msg_putchar(' '); 3861 } 3862 } 3863 3864 /* 3865 * List one syntax cluster, for ":syntax" or "syntax list syntax_name". 3866 */ 3867 static void 3868 syn_list_cluster(id) 3869 int id; 3870 { 3871 int endcol = 15; 3872 3873 /* slight hack: roughly duplicate the guts of syn_list_header() */ 3874 msg_putchar('\n'); 3875 msg_outtrans(SYN_CLSTR(curbuf)[id].scl_name); 3876 3877 if (msg_col >= endcol) /* output at least one space */ 3878 endcol = msg_col + 1; 3879 if (Columns <= endcol) /* avoid hang for tiny window */ 3880 endcol = Columns - 1; 3881 3882 msg_advance(endcol); 3883 if (SYN_CLSTR(curbuf)[id].scl_list != NULL) 3884 { 3885 put_id_list((char_u *)"cluster", SYN_CLSTR(curbuf)[id].scl_list, 3886 hl_attr(HLF_D)); 3887 } 3888 else 3889 { 3890 msg_puts_attr((char_u *)"cluster", hl_attr(HLF_D)); 3891 msg_puts((char_u *)"=NONE"); 3892 } 3893 } 3894 3895 static void 3896 put_id_list(name, list, attr) 3897 char_u *name; 3898 short *list; 3899 int attr; 3900 { 3901 short *p; 3902 3903 msg_puts_attr(name, attr); 3904 msg_putchar('='); 3905 for (p = list; *p; ++p) 3906 { 3907 if (*p >= SYNID_ALLBUT && *p < SYNID_TOP) 3908 { 3909 if (p[1]) 3910 MSG_PUTS("ALLBUT"); 3911 else 3912 MSG_PUTS("ALL"); 3913 } 3914 else if (*p >= SYNID_TOP && *p < SYNID_CONTAINED) 3915 { 3916 MSG_PUTS("TOP"); 3917 } 3918 else if (*p >= SYNID_CONTAINED && *p < SYNID_CLUSTER) 3919 { 3920 MSG_PUTS("CONTAINED"); 3921 } 3922 else if (*p >= SYNID_CLUSTER) 3923 { 3924 short scl_id = *p - SYNID_CLUSTER; 3925 3926 msg_putchar('@'); 3927 msg_outtrans(SYN_CLSTR(curbuf)[scl_id].scl_name); 3928 } 3929 else 3930 msg_outtrans(HL_TABLE()[*p - 1].sg_name); 3931 if (p[1]) 3932 msg_putchar(','); 3933 } 3934 msg_putchar(' '); 3935 } 3936 3937 static void 3938 put_pattern(s, c, spp, attr) 3939 char *s; 3940 int c; 3941 synpat_T *spp; 3942 int attr; 3943 { 3944 long n; 3945 int mask; 3946 int first; 3947 static char *sepchars = "/+=-#@\"|'^&"; 3948 int i; 3949 3950 /* May have to write "matchgroup=group" */ 3951 if (last_matchgroup != spp->sp_syn_match_id) 3952 { 3953 last_matchgroup = spp->sp_syn_match_id; 3954 msg_puts_attr((char_u *)"matchgroup", attr); 3955 msg_putchar('='); 3956 if (last_matchgroup == 0) 3957 msg_outtrans((char_u *)"NONE"); 3958 else 3959 msg_outtrans(HL_TABLE()[last_matchgroup - 1].sg_name); 3960 msg_putchar(' '); 3961 } 3962 3963 /* output the name of the pattern and an '=' or ' ' */ 3964 msg_puts_attr((char_u *)s, attr); 3965 msg_putchar(c); 3966 3967 /* output the pattern, in between a char that is not in the pattern */ 3968 for (i = 0; vim_strchr(spp->sp_pattern, sepchars[i]) != NULL; ) 3969 if (sepchars[++i] == NUL) 3970 { 3971 i = 0; /* no good char found, just use the first one */ 3972 break; 3973 } 3974 msg_putchar(sepchars[i]); 3975 msg_outtrans(spp->sp_pattern); 3976 msg_putchar(sepchars[i]); 3977 3978 /* output any pattern options */ 3979 first = TRUE; 3980 for (i = 0; i < SPO_COUNT; ++i) 3981 { 3982 mask = (1 << i); 3983 if (spp->sp_off_flags & (mask + (mask << SPO_COUNT))) 3984 { 3985 if (!first) 3986 msg_putchar(','); /* separate with commas */ 3987 msg_puts((char_u *)spo_name_tab[i]); 3988 n = spp->sp_offsets[i]; 3989 if (i != SPO_LC_OFF) 3990 { 3991 if (spp->sp_off_flags & mask) 3992 msg_putchar('s'); 3993 else 3994 msg_putchar('e'); 3995 if (n > 0) 3996 msg_putchar('+'); 3997 } 3998 if (n || i == SPO_LC_OFF) 3999 msg_outnum(n); 4000 first = FALSE; 4001 } 4002 } 4003 msg_putchar(' '); 4004 } 4005 4006 /* 4007 * List or clear the keywords for one syntax group. 4008 * Return TRUE if the header has been printed. 4009 */ 4010 static int 4011 syn_list_keywords(id, ht, did_header, attr) 4012 int id; 4013 hashtab_T *ht; 4014 int did_header; /* header has already been printed */ 4015 int attr; 4016 { 4017 int outlen; 4018 hashitem_T *hi; 4019 keyentry_T *kp; 4020 int todo; 4021 int prev_contained = 0; 4022 short *prev_next_list = NULL; 4023 short *prev_cont_in_list = NULL; 4024 int prev_skipnl = 0; 4025 int prev_skipwhite = 0; 4026 int prev_skipempty = 0; 4027 4028 /* 4029 * Unfortunately, this list of keywords is not sorted on alphabet but on 4030 * hash value... 4031 */ 4032 todo = (int)ht->ht_used; 4033 for (hi = ht->ht_array; todo > 0 && !got_int; ++hi) 4034 { 4035 if (!HASHITEM_EMPTY(hi)) 4036 { 4037 --todo; 4038 for (kp = HI2KE(hi); kp != NULL && !got_int; kp = kp->ke_next) 4039 { 4040 if (kp->k_syn.id == id) 4041 { 4042 if (prev_contained != (kp->flags & HL_CONTAINED) 4043 || prev_skipnl != (kp->flags & HL_SKIPNL) 4044 || prev_skipwhite != (kp->flags & HL_SKIPWHITE) 4045 || prev_skipempty != (kp->flags & HL_SKIPEMPTY) 4046 || prev_cont_in_list != kp->k_syn.cont_in_list 4047 || prev_next_list != kp->next_list) 4048 outlen = 9999; 4049 else 4050 outlen = (int)STRLEN(kp->keyword); 4051 /* output "contained" and "nextgroup" on each line */ 4052 if (syn_list_header(did_header, outlen, id)) 4053 { 4054 prev_contained = 0; 4055 prev_next_list = NULL; 4056 prev_cont_in_list = NULL; 4057 prev_skipnl = 0; 4058 prev_skipwhite = 0; 4059 prev_skipempty = 0; 4060 } 4061 did_header = TRUE; 4062 if (prev_contained != (kp->flags & HL_CONTAINED)) 4063 { 4064 msg_puts_attr((char_u *)"contained", attr); 4065 msg_putchar(' '); 4066 prev_contained = (kp->flags & HL_CONTAINED); 4067 } 4068 if (kp->k_syn.cont_in_list != prev_cont_in_list) 4069 { 4070 put_id_list((char_u *)"containedin", 4071 kp->k_syn.cont_in_list, attr); 4072 msg_putchar(' '); 4073 prev_cont_in_list = kp->k_syn.cont_in_list; 4074 } 4075 if (kp->next_list != prev_next_list) 4076 { 4077 put_id_list((char_u *)"nextgroup", kp->next_list, attr); 4078 msg_putchar(' '); 4079 prev_next_list = kp->next_list; 4080 if (kp->flags & HL_SKIPNL) 4081 { 4082 msg_puts_attr((char_u *)"skipnl", attr); 4083 msg_putchar(' '); 4084 prev_skipnl = (kp->flags & HL_SKIPNL); 4085 } 4086 if (kp->flags & HL_SKIPWHITE) 4087 { 4088 msg_puts_attr((char_u *)"skipwhite", attr); 4089 msg_putchar(' '); 4090 prev_skipwhite = (kp->flags & HL_SKIPWHITE); 4091 } 4092 if (kp->flags & HL_SKIPEMPTY) 4093 { 4094 msg_puts_attr((char_u *)"skipempty", attr); 4095 msg_putchar(' '); 4096 prev_skipempty = (kp->flags & HL_SKIPEMPTY); 4097 } 4098 } 4099 msg_outtrans(kp->keyword); 4100 } 4101 } 4102 } 4103 } 4104 4105 return did_header; 4106 } 4107 4108 static void 4109 syn_clear_keyword(id, ht) 4110 int id; 4111 hashtab_T *ht; 4112 { 4113 hashitem_T *hi; 4114 keyentry_T *kp; 4115 keyentry_T *kp_prev; 4116 keyentry_T *kp_next; 4117 int todo; 4118 4119 hash_lock(ht); 4120 todo = (int)ht->ht_used; 4121 for (hi = ht->ht_array; todo > 0; ++hi) 4122 { 4123 if (!HASHITEM_EMPTY(hi)) 4124 { 4125 --todo; 4126 kp_prev = NULL; 4127 for (kp = HI2KE(hi); kp != NULL; ) 4128 { 4129 if (kp->k_syn.id == id) 4130 { 4131 kp_next = kp->ke_next; 4132 if (kp_prev == NULL) 4133 { 4134 if (kp_next == NULL) 4135 hash_remove(ht, hi); 4136 else 4137 hi->hi_key = KE2HIKEY(kp_next); 4138 } 4139 else 4140 kp_prev->ke_next = kp_next; 4141 vim_free(kp->next_list); 4142 vim_free(kp->k_syn.cont_in_list); 4143 vim_free(kp); 4144 kp = kp_next; 4145 } 4146 else 4147 { 4148 kp_prev = kp; 4149 kp = kp->ke_next; 4150 } 4151 } 4152 } 4153 } 4154 hash_unlock(ht); 4155 } 4156 4157 /* 4158 * Clear a whole keyword table. 4159 */ 4160 static void 4161 clear_keywtab(ht) 4162 hashtab_T *ht; 4163 { 4164 hashitem_T *hi; 4165 int todo; 4166 keyentry_T *kp; 4167 keyentry_T *kp_next; 4168 4169 todo = (int)ht->ht_used; 4170 for (hi = ht->ht_array; todo > 0; ++hi) 4171 { 4172 if (!HASHITEM_EMPTY(hi)) 4173 { 4174 --todo; 4175 kp = HI2KE(hi); 4176 for (kp = HI2KE(hi); kp != NULL; kp = kp_next) 4177 { 4178 kp_next = kp->ke_next; 4179 vim_free(kp->next_list); 4180 vim_free(kp->k_syn.cont_in_list); 4181 vim_free(kp); 4182 } 4183 } 4184 } 4185 hash_clear(ht); 4186 hash_init(ht); 4187 } 4188 4189 /* 4190 * Add a keyword to the list of keywords. 4191 */ 4192 static void 4193 add_keyword(name, id, flags, cont_in_list, next_list) 4194 char_u *name; /* name of keyword */ 4195 int id; /* group ID for this keyword */ 4196 int flags; /* flags for this keyword */ 4197 short *cont_in_list; /* containedin for this keyword */ 4198 short *next_list; /* nextgroup for this keyword */ 4199 { 4200 keyentry_T *kp; 4201 hashtab_T *ht; 4202 hashitem_T *hi; 4203 char_u *name_ic; 4204 long_u hash; 4205 char_u name_folded[MAXKEYWLEN + 1]; 4206 4207 if (curbuf->b_syn_ic) 4208 name_ic = str_foldcase(name, (int)STRLEN(name), 4209 name_folded, MAXKEYWLEN + 1); 4210 else 4211 name_ic = name; 4212 kp = (keyentry_T *)alloc((int)(sizeof(keyentry_T) + STRLEN(name_ic))); 4213 if (kp == NULL) 4214 return; 4215 STRCPY(kp->keyword, name_ic); 4216 kp->k_syn.id = id; 4217 kp->k_syn.inc_tag = current_syn_inc_tag; 4218 kp->flags = flags; 4219 kp->k_syn.cont_in_list = copy_id_list(cont_in_list); 4220 if (cont_in_list != NULL) 4221 curbuf->b_syn_containedin = TRUE; 4222 kp->next_list = copy_id_list(next_list); 4223 4224 if (curbuf->b_syn_ic) 4225 ht = &curbuf->b_keywtab_ic; 4226 else 4227 ht = &curbuf->b_keywtab; 4228 4229 hash = hash_hash(kp->keyword); 4230 hi = hash_lookup(ht, kp->keyword, hash); 4231 if (HASHITEM_EMPTY(hi)) 4232 { 4233 /* new keyword, add to hashtable */ 4234 kp->ke_next = NULL; 4235 hash_add_item(ht, hi, kp->keyword, hash); 4236 } 4237 else 4238 { 4239 /* keyword already exists, prepend to list */ 4240 kp->ke_next = HI2KE(hi); 4241 hi->hi_key = KE2HIKEY(kp); 4242 } 4243 } 4244 4245 /* 4246 * Get the start and end of the group name argument. 4247 * Return a pointer to the first argument. 4248 * Return NULL if the end of the command was found instead of further args. 4249 */ 4250 static char_u * 4251 get_group_name(arg, name_end) 4252 char_u *arg; /* start of the argument */ 4253 char_u **name_end; /* pointer to end of the name */ 4254 { 4255 char_u *rest; 4256 4257 *name_end = skiptowhite(arg); 4258 rest = skipwhite(*name_end); 4259 4260 /* 4261 * Check if there are enough arguments. The first argument may be a 4262 * pattern, where '|' is allowed, so only check for NUL. 4263 */ 4264 if (ends_excmd(*arg) || *rest == NUL) 4265 return NULL; 4266 return rest; 4267 } 4268 4269 /* 4270 * Check for syntax command option arguments. 4271 * This can be called at any place in the list of arguments, and just picks 4272 * out the arguments that are known. Can be called several times in a row to 4273 * collect all options in between other arguments. 4274 * Return a pointer to the next argument (which isn't an option). 4275 * Return NULL for any error; 4276 */ 4277 static char_u * 4278 get_syn_options(arg, opt) 4279 char_u *arg; /* next argument to be checked */ 4280 syn_opt_arg_T *opt; /* various things */ 4281 { 4282 char_u *gname_start, *gname; 4283 int syn_id; 4284 int len; 4285 char *p; 4286 int i; 4287 int fidx; 4288 static struct flag 4289 { 4290 char *name; 4291 int argtype; 4292 int flags; 4293 } flagtab[] = { {"cCoOnNtTaAiInNeEdD", 0, HL_CONTAINED}, 4294 {"oOnNeElLiInNeE", 0, HL_ONELINE}, 4295 {"kKeEeEpPeEnNdD", 0, HL_KEEPEND}, 4296 {"eExXtTeEnNdD", 0, HL_EXTEND}, 4297 {"eExXcClLuUdDeEnNlL", 0, HL_EXCLUDENL}, 4298 {"tTrRaAnNsSpPaArReEnNtT", 0, HL_TRANSP}, 4299 {"sSkKiIpPnNlL", 0, HL_SKIPNL}, 4300 {"sSkKiIpPwWhHiItTeE", 0, HL_SKIPWHITE}, 4301 {"sSkKiIpPeEmMpPtTyY", 0, HL_SKIPEMPTY}, 4302 {"gGrRoOuUpPhHeErReE", 0, HL_SYNC_HERE}, 4303 {"gGrRoOuUpPtThHeErReE", 0, HL_SYNC_THERE}, 4304 {"dDiIsSpPlLaAyY", 0, HL_DISPLAY}, 4305 {"fFoOlLdD", 0, HL_FOLD}, 4306 {"cCoOnNtTaAiInNsS", 1, 0}, 4307 {"cCoOnNtTaAiInNeEdDiInN", 2, 0}, 4308 {"nNeExXtTgGrRoOuUpP", 3, 0}, 4309 }; 4310 static char *first_letters = "cCoOkKeEtTsSgGdDfFnN"; 4311 4312 if (arg == NULL) /* already detected error */ 4313 return NULL; 4314 4315 for (;;) 4316 { 4317 /* 4318 * This is used very often when a large number of keywords is defined. 4319 * Need to skip quickly when no option name is found. 4320 * Also avoid tolower(), it's slow. 4321 */ 4322 if (strchr(first_letters, *arg) == NULL) 4323 break; 4324 4325 for (fidx = sizeof(flagtab) / sizeof(struct flag); --fidx >= 0; ) 4326 { 4327 p = flagtab[fidx].name; 4328 for (i = 0, len = 0; p[i] != NUL; i += 2, ++len) 4329 if (arg[len] != p[i] && arg[len] != p[i + 1]) 4330 break; 4331 if (p[i] == NUL && (vim_iswhite(arg[len]) 4332 || (flagtab[fidx].argtype > 0 4333 ? arg[len] == '=' 4334 : ends_excmd(arg[len])))) 4335 { 4336 if (opt->keyword 4337 && (flagtab[fidx].flags == HL_DISPLAY 4338 || flagtab[fidx].flags == HL_FOLD 4339 || flagtab[fidx].flags == HL_EXTEND)) 4340 /* treat "display", "fold" and "extend" as a keyword */ 4341 fidx = -1; 4342 break; 4343 } 4344 } 4345 if (fidx < 0) /* no match found */ 4346 break; 4347 4348 if (flagtab[fidx].argtype == 1) 4349 { 4350 if (!opt->has_cont_list) 4351 { 4352 EMSG(_("E395: contains argument not accepted here")); 4353 return NULL; 4354 } 4355 if (get_id_list(&arg, 8, &opt->cont_list) == FAIL) 4356 return NULL; 4357 } 4358 else if (flagtab[fidx].argtype == 2) 4359 { 4360 #if 0 /* cannot happen */ 4361 if (opt->cont_in_list == NULL) 4362 { 4363 EMSG(_("E396: containedin argument not accepted here")); 4364 return NULL; 4365 } 4366 #endif 4367 if (get_id_list(&arg, 11, &opt->cont_in_list) == FAIL) 4368 return NULL; 4369 } 4370 else if (flagtab[fidx].argtype == 3) 4371 { 4372 if (get_id_list(&arg, 9, &opt->next_list) == FAIL) 4373 return NULL; 4374 } 4375 else 4376 { 4377 opt->flags |= flagtab[fidx].flags; 4378 arg = skipwhite(arg + len); 4379 4380 if (flagtab[fidx].flags == HL_SYNC_HERE 4381 || flagtab[fidx].flags == HL_SYNC_THERE) 4382 { 4383 if (opt->sync_idx == NULL) 4384 { 4385 EMSG(_("E393: group[t]here not accepted here")); 4386 return NULL; 4387 } 4388 gname_start = arg; 4389 arg = skiptowhite(arg); 4390 if (gname_start == arg) 4391 return NULL; 4392 gname = vim_strnsave(gname_start, (int)(arg - gname_start)); 4393 if (gname == NULL) 4394 return NULL; 4395 if (STRCMP(gname, "NONE") == 0) 4396 *opt->sync_idx = NONE_IDX; 4397 else 4398 { 4399 syn_id = syn_name2id(gname); 4400 for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; ) 4401 if (SYN_ITEMS(curbuf)[i].sp_syn.id == syn_id 4402 && SYN_ITEMS(curbuf)[i].sp_type == SPTYPE_START) 4403 { 4404 *opt->sync_idx = i; 4405 break; 4406 } 4407 if (i < 0) 4408 { 4409 EMSG2(_("E394: Didn't find region item for %s"), gname); 4410 vim_free(gname); 4411 return NULL; 4412 } 4413 } 4414 4415 vim_free(gname); 4416 arg = skipwhite(arg); 4417 } 4418 #ifdef FEAT_FOLDING 4419 else if (flagtab[fidx].flags == HL_FOLD 4420 && foldmethodIsSyntax(curwin)) 4421 /* Need to update folds later. */ 4422 foldUpdateAll(curwin); 4423 #endif 4424 } 4425 } 4426 4427 return arg; 4428 } 4429 4430 /* 4431 * Adjustments to syntax item when declared in a ":syn include"'d file. 4432 * Set the contained flag, and if the item is not already contained, add it 4433 * to the specified top-level group, if any. 4434 */ 4435 static void 4436 syn_incl_toplevel(id, flagsp) 4437 int id; 4438 int *flagsp; 4439 { 4440 if ((*flagsp & HL_CONTAINED) || curbuf->b_syn_topgrp == 0) 4441 return; 4442 *flagsp |= HL_CONTAINED; 4443 if (curbuf->b_syn_topgrp >= SYNID_CLUSTER) 4444 { 4445 /* We have to alloc this, because syn_combine_list() will free it. */ 4446 short *grp_list = (short *)alloc((unsigned)(2 * sizeof(short))); 4447 int tlg_id = curbuf->b_syn_topgrp - SYNID_CLUSTER; 4448 4449 if (grp_list != NULL) 4450 { 4451 grp_list[0] = id; 4452 grp_list[1] = 0; 4453 syn_combine_list(&SYN_CLSTR(curbuf)[tlg_id].scl_list, &grp_list, 4454 CLUSTER_ADD); 4455 } 4456 } 4457 } 4458 4459 /* 4460 * Handle ":syntax include [@{group-name}] filename" command. 4461 */ 4462 /* ARGSUSED */ 4463 static void 4464 syn_cmd_include(eap, syncing) 4465 exarg_T *eap; 4466 int syncing; /* not used */ 4467 { 4468 char_u *arg = eap->arg; 4469 int sgl_id = 1; 4470 char_u *group_name_end; 4471 char_u *rest; 4472 char_u *errormsg = NULL; 4473 int prev_toplvl_grp; 4474 int prev_syn_inc_tag; 4475 int source = FALSE; 4476 4477 eap->nextcmd = find_nextcmd(arg); 4478 if (eap->skip) 4479 return; 4480 4481 if (arg[0] == '@') 4482 { 4483 ++arg; 4484 rest = get_group_name(arg, &group_name_end); 4485 if (rest == NULL) 4486 { 4487 EMSG((char_u *)_("E397: Filename required")); 4488 return; 4489 } 4490 sgl_id = syn_check_cluster(arg, (int)(group_name_end - arg)); 4491 /* separate_nextcmd() and expand_filename() depend on this */ 4492 eap->arg = rest; 4493 } 4494 4495 /* 4496 * Everything that's left, up to the next command, should be the 4497 * filename to include. 4498 */ 4499 eap->argt |= (XFILE | NOSPC); 4500 separate_nextcmd(eap); 4501 if (*eap->arg == '<' || *eap->arg == '$' || mch_isFullName(eap->arg)) 4502 { 4503 /* For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the 4504 * file. Need to expand the file name first. In other cases 4505 * ":runtime!" is used. */ 4506 source = TRUE; 4507 if (expand_filename(eap, syn_cmdlinep, &errormsg) == FAIL) 4508 { 4509 if (errormsg != NULL) 4510 EMSG(errormsg); 4511 return; 4512 } 4513 } 4514 4515 /* 4516 * Save and restore the existing top-level grouplist id and ":syn 4517 * include" tag around the actual inclusion. 4518 */ 4519 prev_syn_inc_tag = current_syn_inc_tag; 4520 current_syn_inc_tag = ++running_syn_inc_tag; 4521 prev_toplvl_grp = curbuf->b_syn_topgrp; 4522 curbuf->b_syn_topgrp = sgl_id; 4523 if (source ? do_source(eap->arg, FALSE, DOSO_NONE) == FAIL 4524 : source_runtime(eap->arg, TRUE) == FAIL) 4525 EMSG2(_(e_notopen), eap->arg); 4526 curbuf->b_syn_topgrp = prev_toplvl_grp; 4527 current_syn_inc_tag = prev_syn_inc_tag; 4528 } 4529 4530 /* 4531 * Handle ":syntax keyword {group-name} [{option}] keyword .." command. 4532 */ 4533 /* ARGSUSED */ 4534 static void 4535 syn_cmd_keyword(eap, syncing) 4536 exarg_T *eap; 4537 int syncing; /* not used */ 4538 { 4539 char_u *arg = eap->arg; 4540 char_u *group_name_end; 4541 int syn_id; 4542 char_u *rest; 4543 char_u *keyword_copy; 4544 char_u *p; 4545 char_u *kw; 4546 syn_opt_arg_T syn_opt_arg; 4547 int cnt; 4548 4549 rest = get_group_name(arg, &group_name_end); 4550 4551 if (rest != NULL) 4552 { 4553 syn_id = syn_check_group(arg, (int)(group_name_end - arg)); 4554 4555 /* allocate a buffer, for removing the backslashes in the keyword */ 4556 keyword_copy = alloc((unsigned)STRLEN(rest) + 1); 4557 if (keyword_copy != NULL) 4558 { 4559 syn_opt_arg.flags = 0; 4560 syn_opt_arg.keyword = TRUE; 4561 syn_opt_arg.sync_idx = NULL; 4562 syn_opt_arg.has_cont_list = FALSE; 4563 syn_opt_arg.cont_in_list = NULL; 4564 syn_opt_arg.next_list = NULL; 4565 4566 /* 4567 * The options given apply to ALL keywords, so all options must be 4568 * found before keywords can be created. 4569 * 1: collect the options and copy the keywords to keyword_copy. 4570 */ 4571 cnt = 0; 4572 p = keyword_copy; 4573 for ( ; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest)) 4574 { 4575 rest = get_syn_options(rest, &syn_opt_arg); 4576 if (rest == NULL || ends_excmd(*rest)) 4577 break; 4578 /* Copy the keyword, removing backslashes, and add a NUL. */ 4579 while (*rest != NUL && !vim_iswhite(*rest)) 4580 { 4581 if (*rest == '\\' && rest[1] != NUL) 4582 ++rest; 4583 *p++ = *rest++; 4584 } 4585 *p++ = NUL; 4586 ++cnt; 4587 } 4588 4589 if (!eap->skip) 4590 { 4591 /* Adjust flags for use of ":syn include". */ 4592 syn_incl_toplevel(syn_id, &syn_opt_arg.flags); 4593 4594 /* 4595 * 2: Add an entry for each keyword. 4596 */ 4597 for (kw = keyword_copy; --cnt >= 0; kw += STRLEN(kw) + 1) 4598 { 4599 for (p = vim_strchr(kw, '['); ; ) 4600 { 4601 if (p != NULL) 4602 *p = NUL; 4603 add_keyword(kw, syn_id, syn_opt_arg.flags, 4604 syn_opt_arg.cont_in_list, 4605 syn_opt_arg.next_list); 4606 if (p == NULL) 4607 break; 4608 if (p[1] == NUL) 4609 { 4610 EMSG2(_("E789: Missing ']': %s"), kw); 4611 kw = p + 2; /* skip over the NUL */ 4612 break; 4613 } 4614 if (p[1] == ']') 4615 { 4616 kw = p + 1; /* skip over the "]" */ 4617 break; 4618 } 4619 #ifdef FEAT_MBYTE 4620 if (has_mbyte) 4621 { 4622 int l = (*mb_ptr2len)(p + 1); 4623 4624 mch_memmove(p, p + 1, l); 4625 p += l; 4626 } 4627 else 4628 #endif 4629 { 4630 p[0] = p[1]; 4631 ++p; 4632 } 4633 } 4634 } 4635 } 4636 4637 vim_free(keyword_copy); 4638 vim_free(syn_opt_arg.cont_in_list); 4639 vim_free(syn_opt_arg.next_list); 4640 } 4641 } 4642 4643 if (rest != NULL) 4644 eap->nextcmd = check_nextcmd(rest); 4645 else 4646 EMSG2(_(e_invarg2), arg); 4647 4648 redraw_curbuf_later(SOME_VALID); 4649 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 4650 } 4651 4652 /* 4653 * Handle ":syntax match {name} [{options}] {pattern} [{options}]". 4654 * 4655 * Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .." 4656 */ 4657 static void 4658 syn_cmd_match(eap, syncing) 4659 exarg_T *eap; 4660 int syncing; /* TRUE for ":syntax sync match .. " */ 4661 { 4662 char_u *arg = eap->arg; 4663 char_u *group_name_end; 4664 char_u *rest; 4665 synpat_T item; /* the item found in the line */ 4666 int syn_id; 4667 int idx; 4668 syn_opt_arg_T syn_opt_arg; 4669 int sync_idx = 0; 4670 4671 /* Isolate the group name, check for validity */ 4672 rest = get_group_name(arg, &group_name_end); 4673 4674 /* Get options before the pattern */ 4675 syn_opt_arg.flags = 0; 4676 syn_opt_arg.keyword = FALSE; 4677 syn_opt_arg.sync_idx = syncing ? &sync_idx : NULL; 4678 syn_opt_arg.has_cont_list = TRUE; 4679 syn_opt_arg.cont_list = NULL; 4680 syn_opt_arg.cont_in_list = NULL; 4681 syn_opt_arg.next_list = NULL; 4682 rest = get_syn_options(rest, &syn_opt_arg); 4683 4684 /* get the pattern. */ 4685 init_syn_patterns(); 4686 vim_memset(&item, 0, sizeof(item)); 4687 rest = get_syn_pattern(rest, &item); 4688 if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL)) 4689 syn_opt_arg.flags |= HL_HAS_EOL; 4690 4691 /* Get options after the pattern */ 4692 rest = get_syn_options(rest, &syn_opt_arg); 4693 4694 if (rest != NULL) /* all arguments are valid */ 4695 { 4696 /* 4697 * Check for trailing command and illegal trailing arguments. 4698 */ 4699 eap->nextcmd = check_nextcmd(rest); 4700 if (!ends_excmd(*rest) || eap->skip) 4701 rest = NULL; 4702 else if (ga_grow(&curbuf->b_syn_patterns, 1) != FAIL 4703 && (syn_id = syn_check_group(arg, 4704 (int)(group_name_end - arg))) != 0) 4705 { 4706 syn_incl_toplevel(syn_id, &syn_opt_arg.flags); 4707 /* 4708 * Store the pattern in the syn_items list 4709 */ 4710 idx = curbuf->b_syn_patterns.ga_len; 4711 SYN_ITEMS(curbuf)[idx] = item; 4712 SYN_ITEMS(curbuf)[idx].sp_syncing = syncing; 4713 SYN_ITEMS(curbuf)[idx].sp_type = SPTYPE_MATCH; 4714 SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id; 4715 SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag; 4716 SYN_ITEMS(curbuf)[idx].sp_flags = syn_opt_arg.flags; 4717 SYN_ITEMS(curbuf)[idx].sp_sync_idx = sync_idx; 4718 SYN_ITEMS(curbuf)[idx].sp_cont_list = syn_opt_arg.cont_list; 4719 SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list = 4720 syn_opt_arg.cont_in_list; 4721 if (syn_opt_arg.cont_in_list != NULL) 4722 curbuf->b_syn_containedin = TRUE; 4723 SYN_ITEMS(curbuf)[idx].sp_next_list = syn_opt_arg.next_list; 4724 ++curbuf->b_syn_patterns.ga_len; 4725 4726 /* remember that we found a match for syncing on */ 4727 if (syn_opt_arg.flags & (HL_SYNC_HERE|HL_SYNC_THERE)) 4728 curbuf->b_syn_sync_flags |= SF_MATCH; 4729 #ifdef FEAT_FOLDING 4730 if (syn_opt_arg.flags & HL_FOLD) 4731 ++curbuf->b_syn_folditems; 4732 #endif 4733 4734 redraw_curbuf_later(SOME_VALID); 4735 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 4736 return; /* don't free the progs and patterns now */ 4737 } 4738 } 4739 4740 /* 4741 * Something failed, free the allocated memory. 4742 */ 4743 vim_free(item.sp_prog); 4744 vim_free(item.sp_pattern); 4745 vim_free(syn_opt_arg.cont_list); 4746 vim_free(syn_opt_arg.cont_in_list); 4747 vim_free(syn_opt_arg.next_list); 4748 4749 if (rest == NULL) 4750 EMSG2(_(e_invarg2), arg); 4751 } 4752 4753 /* 4754 * Handle ":syntax region {group-name} [matchgroup={group-name}] 4755 * start {start} .. [skip {skip}] end {end} .. [{options}]". 4756 */ 4757 static void 4758 syn_cmd_region(eap, syncing) 4759 exarg_T *eap; 4760 int syncing; /* TRUE for ":syntax sync region .." */ 4761 { 4762 char_u *arg = eap->arg; 4763 char_u *group_name_end; 4764 char_u *rest; /* next arg, NULL on error */ 4765 char_u *key_end; 4766 char_u *key = NULL; 4767 char_u *p; 4768 int item; 4769 #define ITEM_START 0 4770 #define ITEM_SKIP 1 4771 #define ITEM_END 2 4772 #define ITEM_MATCHGROUP 3 4773 struct pat_ptr 4774 { 4775 synpat_T *pp_synp; /* pointer to syn_pattern */ 4776 int pp_matchgroup_id; /* matchgroup ID */ 4777 struct pat_ptr *pp_next; /* pointer to next pat_ptr */ 4778 } *(pat_ptrs[3]); 4779 /* patterns found in the line */ 4780 struct pat_ptr *ppp; 4781 struct pat_ptr *ppp_next; 4782 int pat_count = 0; /* nr of syn_patterns found */ 4783 int syn_id; 4784 int matchgroup_id = 0; 4785 int not_enough = FALSE; /* not enough arguments */ 4786 int illegal = FALSE; /* illegal arguments */ 4787 int success = FALSE; 4788 int idx; 4789 syn_opt_arg_T syn_opt_arg; 4790 4791 /* Isolate the group name, check for validity */ 4792 rest = get_group_name(arg, &group_name_end); 4793 4794 pat_ptrs[0] = NULL; 4795 pat_ptrs[1] = NULL; 4796 pat_ptrs[2] = NULL; 4797 4798 init_syn_patterns(); 4799 4800 syn_opt_arg.flags = 0; 4801 syn_opt_arg.keyword = FALSE; 4802 syn_opt_arg.sync_idx = NULL; 4803 syn_opt_arg.has_cont_list = TRUE; 4804 syn_opt_arg.cont_list = NULL; 4805 syn_opt_arg.cont_in_list = NULL; 4806 syn_opt_arg.next_list = NULL; 4807 4808 /* 4809 * get the options, patterns and matchgroup. 4810 */ 4811 while (rest != NULL && !ends_excmd(*rest)) 4812 { 4813 /* Check for option arguments */ 4814 rest = get_syn_options(rest, &syn_opt_arg); 4815 if (rest == NULL || ends_excmd(*rest)) 4816 break; 4817 4818 /* must be a pattern or matchgroup then */ 4819 key_end = rest; 4820 while (*key_end && !vim_iswhite(*key_end) && *key_end != '=') 4821 ++key_end; 4822 vim_free(key); 4823 key = vim_strnsave_up(rest, (int)(key_end - rest)); 4824 if (key == NULL) /* out of memory */ 4825 { 4826 rest = NULL; 4827 break; 4828 } 4829 if (STRCMP(key, "MATCHGROUP") == 0) 4830 item = ITEM_MATCHGROUP; 4831 else if (STRCMP(key, "START") == 0) 4832 item = ITEM_START; 4833 else if (STRCMP(key, "END") == 0) 4834 item = ITEM_END; 4835 else if (STRCMP(key, "SKIP") == 0) 4836 { 4837 if (pat_ptrs[ITEM_SKIP] != NULL) /* one skip pattern allowed */ 4838 { 4839 illegal = TRUE; 4840 break; 4841 } 4842 item = ITEM_SKIP; 4843 } 4844 else 4845 break; 4846 rest = skipwhite(key_end); 4847 if (*rest != '=') 4848 { 4849 rest = NULL; 4850 EMSG2(_("E398: Missing '=': %s"), arg); 4851 break; 4852 } 4853 rest = skipwhite(rest + 1); 4854 if (*rest == NUL) 4855 { 4856 not_enough = TRUE; 4857 break; 4858 } 4859 4860 if (item == ITEM_MATCHGROUP) 4861 { 4862 p = skiptowhite(rest); 4863 if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip) 4864 matchgroup_id = 0; 4865 else 4866 { 4867 matchgroup_id = syn_check_group(rest, (int)(p - rest)); 4868 if (matchgroup_id == 0) 4869 { 4870 illegal = TRUE; 4871 break; 4872 } 4873 } 4874 rest = skipwhite(p); 4875 } 4876 else 4877 { 4878 /* 4879 * Allocate room for a syn_pattern, and link it in the list of 4880 * syn_patterns for this item, at the start (because the list is 4881 * used from end to start). 4882 */ 4883 ppp = (struct pat_ptr *)alloc((unsigned)sizeof(struct pat_ptr)); 4884 if (ppp == NULL) 4885 { 4886 rest = NULL; 4887 break; 4888 } 4889 ppp->pp_next = pat_ptrs[item]; 4890 pat_ptrs[item] = ppp; 4891 ppp->pp_synp = (synpat_T *)alloc_clear((unsigned)sizeof(synpat_T)); 4892 if (ppp->pp_synp == NULL) 4893 { 4894 rest = NULL; 4895 break; 4896 } 4897 4898 /* 4899 * Get the syntax pattern and the following offset(s). 4900 */ 4901 /* Enable the appropriate \z specials. */ 4902 if (item == ITEM_START) 4903 reg_do_extmatch = REX_SET; 4904 else if (item == ITEM_SKIP || item == ITEM_END) 4905 reg_do_extmatch = REX_USE; 4906 rest = get_syn_pattern(rest, ppp->pp_synp); 4907 reg_do_extmatch = 0; 4908 if (item == ITEM_END && vim_regcomp_had_eol() 4909 && !(syn_opt_arg.flags & HL_EXCLUDENL)) 4910 ppp->pp_synp->sp_flags |= HL_HAS_EOL; 4911 ppp->pp_matchgroup_id = matchgroup_id; 4912 ++pat_count; 4913 } 4914 } 4915 vim_free(key); 4916 if (illegal || not_enough) 4917 rest = NULL; 4918 4919 /* 4920 * Must have a "start" and "end" pattern. 4921 */ 4922 if (rest != NULL && (pat_ptrs[ITEM_START] == NULL || 4923 pat_ptrs[ITEM_END] == NULL)) 4924 { 4925 not_enough = TRUE; 4926 rest = NULL; 4927 } 4928 4929 if (rest != NULL) 4930 { 4931 /* 4932 * Check for trailing garbage or command. 4933 * If OK, add the item. 4934 */ 4935 eap->nextcmd = check_nextcmd(rest); 4936 if (!ends_excmd(*rest) || eap->skip) 4937 rest = NULL; 4938 else if (ga_grow(&(curbuf->b_syn_patterns), pat_count) != FAIL 4939 && (syn_id = syn_check_group(arg, 4940 (int)(group_name_end - arg))) != 0) 4941 { 4942 syn_incl_toplevel(syn_id, &syn_opt_arg.flags); 4943 /* 4944 * Store the start/skip/end in the syn_items list 4945 */ 4946 idx = curbuf->b_syn_patterns.ga_len; 4947 for (item = ITEM_START; item <= ITEM_END; ++item) 4948 { 4949 for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp->pp_next) 4950 { 4951 SYN_ITEMS(curbuf)[idx] = *(ppp->pp_synp); 4952 SYN_ITEMS(curbuf)[idx].sp_syncing = syncing; 4953 SYN_ITEMS(curbuf)[idx].sp_type = 4954 (item == ITEM_START) ? SPTYPE_START : 4955 (item == ITEM_SKIP) ? SPTYPE_SKIP : SPTYPE_END; 4956 SYN_ITEMS(curbuf)[idx].sp_flags |= syn_opt_arg.flags; 4957 SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id; 4958 SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag; 4959 SYN_ITEMS(curbuf)[idx].sp_syn_match_id = 4960 ppp->pp_matchgroup_id; 4961 if (item == ITEM_START) 4962 { 4963 SYN_ITEMS(curbuf)[idx].sp_cont_list = 4964 syn_opt_arg.cont_list; 4965 SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list = 4966 syn_opt_arg.cont_in_list; 4967 if (syn_opt_arg.cont_in_list != NULL) 4968 curbuf->b_syn_containedin = TRUE; 4969 SYN_ITEMS(curbuf)[idx].sp_next_list = 4970 syn_opt_arg.next_list; 4971 } 4972 ++curbuf->b_syn_patterns.ga_len; 4973 ++idx; 4974 #ifdef FEAT_FOLDING 4975 if (syn_opt_arg.flags & HL_FOLD) 4976 ++curbuf->b_syn_folditems; 4977 #endif 4978 } 4979 } 4980 4981 redraw_curbuf_later(SOME_VALID); 4982 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 4983 success = TRUE; /* don't free the progs and patterns now */ 4984 } 4985 } 4986 4987 /* 4988 * Free the allocated memory. 4989 */ 4990 for (item = ITEM_START; item <= ITEM_END; ++item) 4991 for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp_next) 4992 { 4993 if (!success) 4994 { 4995 vim_free(ppp->pp_synp->sp_prog); 4996 vim_free(ppp->pp_synp->sp_pattern); 4997 } 4998 vim_free(ppp->pp_synp); 4999 ppp_next = ppp->pp_next; 5000 vim_free(ppp); 5001 } 5002 5003 if (!success) 5004 { 5005 vim_free(syn_opt_arg.cont_list); 5006 vim_free(syn_opt_arg.cont_in_list); 5007 vim_free(syn_opt_arg.next_list); 5008 if (not_enough) 5009 EMSG2(_("E399: Not enough arguments: syntax region %s"), arg); 5010 else if (illegal || rest == NULL) 5011 EMSG2(_(e_invarg2), arg); 5012 } 5013 } 5014 5015 /* 5016 * A simple syntax group ID comparison function suitable for use in qsort() 5017 */ 5018 static int 5019 #ifdef __BORLANDC__ 5020 _RTLENTRYF 5021 #endif 5022 syn_compare_stub(v1, v2) 5023 const void *v1; 5024 const void *v2; 5025 { 5026 const short *s1 = v1; 5027 const short *s2 = v2; 5028 5029 return (*s1 > *s2 ? 1 : *s1 < *s2 ? -1 : 0); 5030 } 5031 5032 /* 5033 * Combines lists of syntax clusters. 5034 * *clstr1 and *clstr2 must both be allocated memory; they will be consumed. 5035 */ 5036 static void 5037 syn_combine_list(clstr1, clstr2, list_op) 5038 short **clstr1; 5039 short **clstr2; 5040 int list_op; 5041 { 5042 int count1 = 0; 5043 int count2 = 0; 5044 short *g1; 5045 short *g2; 5046 short *clstr = NULL; 5047 int count; 5048 int round; 5049 5050 /* 5051 * Handle degenerate cases. 5052 */ 5053 if (*clstr2 == NULL) 5054 return; 5055 if (*clstr1 == NULL || list_op == CLUSTER_REPLACE) 5056 { 5057 if (list_op == CLUSTER_REPLACE) 5058 vim_free(*clstr1); 5059 if (list_op == CLUSTER_REPLACE || list_op == CLUSTER_ADD) 5060 *clstr1 = *clstr2; 5061 else 5062 vim_free(*clstr2); 5063 return; 5064 } 5065 5066 for (g1 = *clstr1; *g1; g1++) 5067 ++count1; 5068 for (g2 = *clstr2; *g2; g2++) 5069 ++count2; 5070 5071 /* 5072 * For speed purposes, sort both lists. 5073 */ 5074 qsort(*clstr1, (size_t)count1, sizeof(short), syn_compare_stub); 5075 qsort(*clstr2, (size_t)count2, sizeof(short), syn_compare_stub); 5076 5077 /* 5078 * We proceed in two passes; in round 1, we count the elements to place 5079 * in the new list, and in round 2, we allocate and populate the new 5080 * list. For speed, we use a mergesort-like method, adding the smaller 5081 * of the current elements in each list to the new list. 5082 */ 5083 for (round = 1; round <= 2; round++) 5084 { 5085 g1 = *clstr1; 5086 g2 = *clstr2; 5087 count = 0; 5088 5089 /* 5090 * First, loop through the lists until one of them is empty. 5091 */ 5092 while (*g1 && *g2) 5093 { 5094 /* 5095 * We always want to add from the first list. 5096 */ 5097 if (*g1 < *g2) 5098 { 5099 if (round == 2) 5100 clstr[count] = *g1; 5101 count++; 5102 g1++; 5103 continue; 5104 } 5105 /* 5106 * We only want to add from the second list if we're adding the 5107 * lists. 5108 */ 5109 if (list_op == CLUSTER_ADD) 5110 { 5111 if (round == 2) 5112 clstr[count] = *g2; 5113 count++; 5114 } 5115 if (*g1 == *g2) 5116 g1++; 5117 g2++; 5118 } 5119 5120 /* 5121 * Now add the leftovers from whichever list didn't get finished 5122 * first. As before, we only want to add from the second list if 5123 * we're adding the lists. 5124 */ 5125 for (; *g1; g1++, count++) 5126 if (round == 2) 5127 clstr[count] = *g1; 5128 if (list_op == CLUSTER_ADD) 5129 for (; *g2; g2++, count++) 5130 if (round == 2) 5131 clstr[count] = *g2; 5132 5133 if (round == 1) 5134 { 5135 /* 5136 * If the group ended up empty, we don't need to allocate any 5137 * space for it. 5138 */ 5139 if (count == 0) 5140 { 5141 clstr = NULL; 5142 break; 5143 } 5144 clstr = (short *)alloc((unsigned)((count + 1) * sizeof(short))); 5145 if (clstr == NULL) 5146 break; 5147 clstr[count] = 0; 5148 } 5149 } 5150 5151 /* 5152 * Finally, put the new list in place. 5153 */ 5154 vim_free(*clstr1); 5155 vim_free(*clstr2); 5156 *clstr1 = clstr; 5157 } 5158 5159 /* 5160 * Lookup a syntax cluster name and return it's ID. 5161 * If it is not found, 0 is returned. 5162 */ 5163 static int 5164 syn_scl_name2id(name) 5165 char_u *name; 5166 { 5167 int i; 5168 char_u *name_u; 5169 5170 /* Avoid using stricmp() too much, it's slow on some systems */ 5171 name_u = vim_strsave_up(name); 5172 if (name_u == NULL) 5173 return 0; 5174 for (i = curbuf->b_syn_clusters.ga_len; --i >= 0; ) 5175 if (SYN_CLSTR(curbuf)[i].scl_name_u != NULL 5176 && STRCMP(name_u, SYN_CLSTR(curbuf)[i].scl_name_u) == 0) 5177 break; 5178 vim_free(name_u); 5179 return (i < 0 ? 0 : i + SYNID_CLUSTER); 5180 } 5181 5182 /* 5183 * Like syn_scl_name2id(), but take a pointer + length argument. 5184 */ 5185 static int 5186 syn_scl_namen2id(linep, len) 5187 char_u *linep; 5188 int len; 5189 { 5190 char_u *name; 5191 int id = 0; 5192 5193 name = vim_strnsave(linep, len); 5194 if (name != NULL) 5195 { 5196 id = syn_scl_name2id(name); 5197 vim_free(name); 5198 } 5199 return id; 5200 } 5201 5202 /* 5203 * Find syntax cluster name in the table and return it's ID. 5204 * The argument is a pointer to the name and the length of the name. 5205 * If it doesn't exist yet, a new entry is created. 5206 * Return 0 for failure. 5207 */ 5208 static int 5209 syn_check_cluster(pp, len) 5210 char_u *pp; 5211 int len; 5212 { 5213 int id; 5214 char_u *name; 5215 5216 name = vim_strnsave(pp, len); 5217 if (name == NULL) 5218 return 0; 5219 5220 id = syn_scl_name2id(name); 5221 if (id == 0) /* doesn't exist yet */ 5222 id = syn_add_cluster(name); 5223 else 5224 vim_free(name); 5225 return id; 5226 } 5227 5228 /* 5229 * Add new syntax cluster and return it's ID. 5230 * "name" must be an allocated string, it will be consumed. 5231 * Return 0 for failure. 5232 */ 5233 static int 5234 syn_add_cluster(name) 5235 char_u *name; 5236 { 5237 int len; 5238 5239 /* 5240 * First call for this growarray: init growing array. 5241 */ 5242 if (curbuf->b_syn_clusters.ga_data == NULL) 5243 { 5244 curbuf->b_syn_clusters.ga_itemsize = sizeof(syn_cluster_T); 5245 curbuf->b_syn_clusters.ga_growsize = 10; 5246 } 5247 5248 /* 5249 * Make room for at least one other cluster entry. 5250 */ 5251 if (ga_grow(&curbuf->b_syn_clusters, 1) == FAIL) 5252 { 5253 vim_free(name); 5254 return 0; 5255 } 5256 len = curbuf->b_syn_clusters.ga_len; 5257 5258 vim_memset(&(SYN_CLSTR(curbuf)[len]), 0, sizeof(syn_cluster_T)); 5259 SYN_CLSTR(curbuf)[len].scl_name = name; 5260 SYN_CLSTR(curbuf)[len].scl_name_u = vim_strsave_up(name); 5261 SYN_CLSTR(curbuf)[len].scl_list = NULL; 5262 ++curbuf->b_syn_clusters.ga_len; 5263 5264 if (STRICMP(name, "Spell") == 0) 5265 curbuf->b_spell_cluster_id = len + SYNID_CLUSTER; 5266 if (STRICMP(name, "NoSpell") == 0) 5267 curbuf->b_nospell_cluster_id = len + SYNID_CLUSTER; 5268 5269 return len + SYNID_CLUSTER; 5270 } 5271 5272 /* 5273 * Handle ":syntax cluster {cluster-name} [contains={groupname},..] 5274 * [add={groupname},..] [remove={groupname},..]". 5275 */ 5276 /* ARGSUSED */ 5277 static void 5278 syn_cmd_cluster(eap, syncing) 5279 exarg_T *eap; 5280 int syncing; /* not used */ 5281 { 5282 char_u *arg = eap->arg; 5283 char_u *group_name_end; 5284 char_u *rest; 5285 int scl_id; 5286 short *clstr_list; 5287 int got_clstr = FALSE; 5288 int opt_len; 5289 int list_op; 5290 5291 eap->nextcmd = find_nextcmd(arg); 5292 if (eap->skip) 5293 return; 5294 5295 rest = get_group_name(arg, &group_name_end); 5296 5297 if (rest != NULL) 5298 { 5299 scl_id = syn_check_cluster(arg, (int)(group_name_end - arg)) 5300 - SYNID_CLUSTER; 5301 5302 for (;;) 5303 { 5304 if (STRNICMP(rest, "add", 3) == 0 5305 && (vim_iswhite(rest[3]) || rest[3] == '=')) 5306 { 5307 opt_len = 3; 5308 list_op = CLUSTER_ADD; 5309 } 5310 else if (STRNICMP(rest, "remove", 6) == 0 5311 && (vim_iswhite(rest[6]) || rest[6] == '=')) 5312 { 5313 opt_len = 6; 5314 list_op = CLUSTER_SUBTRACT; 5315 } 5316 else if (STRNICMP(rest, "contains", 8) == 0 5317 && (vim_iswhite(rest[8]) || rest[8] == '=')) 5318 { 5319 opt_len = 8; 5320 list_op = CLUSTER_REPLACE; 5321 } 5322 else 5323 break; 5324 5325 clstr_list = NULL; 5326 if (get_id_list(&rest, opt_len, &clstr_list) == FAIL) 5327 { 5328 EMSG2(_(e_invarg2), rest); 5329 break; 5330 } 5331 syn_combine_list(&SYN_CLSTR(curbuf)[scl_id].scl_list, 5332 &clstr_list, list_op); 5333 got_clstr = TRUE; 5334 } 5335 5336 if (got_clstr) 5337 { 5338 redraw_curbuf_later(SOME_VALID); 5339 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 5340 } 5341 } 5342 5343 if (!got_clstr) 5344 EMSG(_("E400: No cluster specified")); 5345 if (rest == NULL || !ends_excmd(*rest)) 5346 EMSG2(_(e_invarg2), arg); 5347 } 5348 5349 /* 5350 * On first call for current buffer: Init growing array. 5351 */ 5352 static void 5353 init_syn_patterns() 5354 { 5355 curbuf->b_syn_patterns.ga_itemsize = sizeof(synpat_T); 5356 curbuf->b_syn_patterns.ga_growsize = 10; 5357 } 5358 5359 /* 5360 * Get one pattern for a ":syntax match" or ":syntax region" command. 5361 * Stores the pattern and program in a synpat_T. 5362 * Returns a pointer to the next argument, or NULL in case of an error. 5363 */ 5364 static char_u * 5365 get_syn_pattern(arg, ci) 5366 char_u *arg; 5367 synpat_T *ci; 5368 { 5369 char_u *end; 5370 int *p; 5371 int idx; 5372 char_u *cpo_save; 5373 5374 /* need at least three chars */ 5375 if (arg == NULL || arg[1] == NUL || arg[2] == NUL) 5376 return NULL; 5377 5378 end = skip_regexp(arg + 1, *arg, TRUE, NULL); 5379 if (*end != *arg) /* end delimiter not found */ 5380 { 5381 EMSG2(_("E401: Pattern delimiter not found: %s"), arg); 5382 return NULL; 5383 } 5384 /* store the pattern and compiled regexp program */ 5385 if ((ci->sp_pattern = vim_strnsave(arg + 1, (int)(end - arg - 1))) == NULL) 5386 return NULL; 5387 5388 /* Make 'cpoptions' empty, to avoid the 'l' flag */ 5389 cpo_save = p_cpo; 5390 p_cpo = (char_u *)""; 5391 ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC); 5392 p_cpo = cpo_save; 5393 5394 if (ci->sp_prog == NULL) 5395 return NULL; 5396 ci->sp_ic = curbuf->b_syn_ic; 5397 5398 /* 5399 * Check for a match, highlight or region offset. 5400 */ 5401 ++end; 5402 do 5403 { 5404 for (idx = SPO_COUNT; --idx >= 0; ) 5405 if (STRNCMP(end, spo_name_tab[idx], 3) == 0) 5406 break; 5407 if (idx >= 0) 5408 { 5409 p = &(ci->sp_offsets[idx]); 5410 if (idx != SPO_LC_OFF) 5411 switch (end[3]) 5412 { 5413 case 's': break; 5414 case 'b': break; 5415 case 'e': idx += SPO_COUNT; break; 5416 default: idx = -1; break; 5417 } 5418 if (idx >= 0) 5419 { 5420 ci->sp_off_flags |= (1 << idx); 5421 if (idx == SPO_LC_OFF) /* lc=99 */ 5422 { 5423 end += 3; 5424 *p = getdigits(&end); 5425 5426 /* "lc=" offset automatically sets "ms=" offset */ 5427 if (!(ci->sp_off_flags & (1 << SPO_MS_OFF))) 5428 { 5429 ci->sp_off_flags |= (1 << SPO_MS_OFF); 5430 ci->sp_offsets[SPO_MS_OFF] = *p; 5431 } 5432 } 5433 else /* yy=x+99 */ 5434 { 5435 end += 4; 5436 if (*end == '+') 5437 { 5438 ++end; 5439 *p = getdigits(&end); /* positive offset */ 5440 } 5441 else if (*end == '-') 5442 { 5443 ++end; 5444 *p = -getdigits(&end); /* negative offset */ 5445 } 5446 } 5447 if (*end != ',') 5448 break; 5449 ++end; 5450 } 5451 } 5452 } while (idx >= 0); 5453 5454 if (!ends_excmd(*end) && !vim_iswhite(*end)) 5455 { 5456 EMSG2(_("E402: Garbage after pattern: %s"), arg); 5457 return NULL; 5458 } 5459 return skipwhite(end); 5460 } 5461 5462 /* 5463 * Handle ":syntax sync .." command. 5464 */ 5465 /* ARGSUSED */ 5466 static void 5467 syn_cmd_sync(eap, syncing) 5468 exarg_T *eap; 5469 int syncing; /* not used */ 5470 { 5471 char_u *arg_start = eap->arg; 5472 char_u *arg_end; 5473 char_u *key = NULL; 5474 char_u *next_arg; 5475 int illegal = FALSE; 5476 int finished = FALSE; 5477 long n; 5478 char_u *cpo_save; 5479 5480 if (ends_excmd(*arg_start)) 5481 { 5482 syn_cmd_list(eap, TRUE); 5483 return; 5484 } 5485 5486 while (!ends_excmd(*arg_start)) 5487 { 5488 arg_end = skiptowhite(arg_start); 5489 next_arg = skipwhite(arg_end); 5490 vim_free(key); 5491 key = vim_strnsave_up(arg_start, (int)(arg_end - arg_start)); 5492 if (STRCMP(key, "CCOMMENT") == 0) 5493 { 5494 if (!eap->skip) 5495 curbuf->b_syn_sync_flags |= SF_CCOMMENT; 5496 if (!ends_excmd(*next_arg)) 5497 { 5498 arg_end = skiptowhite(next_arg); 5499 if (!eap->skip) 5500 curbuf->b_syn_sync_id = syn_check_group(next_arg, 5501 (int)(arg_end - next_arg)); 5502 next_arg = skipwhite(arg_end); 5503 } 5504 else if (!eap->skip) 5505 curbuf->b_syn_sync_id = syn_name2id((char_u *)"Comment"); 5506 } 5507 else if ( STRNCMP(key, "LINES", 5) == 0 5508 || STRNCMP(key, "MINLINES", 8) == 0 5509 || STRNCMP(key, "MAXLINES", 8) == 0 5510 || STRNCMP(key, "LINEBREAKS", 10) == 0) 5511 { 5512 if (key[4] == 'S') 5513 arg_end = key + 6; 5514 else if (key[0] == 'L') 5515 arg_end = key + 11; 5516 else 5517 arg_end = key + 9; 5518 if (arg_end[-1] != '=' || !VIM_ISDIGIT(*arg_end)) 5519 { 5520 illegal = TRUE; 5521 break; 5522 } 5523 n = getdigits(&arg_end); 5524 if (!eap->skip) 5525 { 5526 if (key[4] == 'B') 5527 curbuf->b_syn_sync_linebreaks = n; 5528 else if (key[1] == 'A') 5529 curbuf->b_syn_sync_maxlines = n; 5530 else 5531 curbuf->b_syn_sync_minlines = n; 5532 } 5533 } 5534 else if (STRCMP(key, "FROMSTART") == 0) 5535 { 5536 if (!eap->skip) 5537 { 5538 curbuf->b_syn_sync_minlines = MAXLNUM; 5539 curbuf->b_syn_sync_maxlines = 0; 5540 } 5541 } 5542 else if (STRCMP(key, "LINECONT") == 0) 5543 { 5544 if (curbuf->b_syn_linecont_pat != NULL) 5545 { 5546 EMSG(_("E403: syntax sync: line continuations pattern specified twice")); 5547 finished = TRUE; 5548 break; 5549 } 5550 arg_end = skip_regexp(next_arg + 1, *next_arg, TRUE, NULL); 5551 if (*arg_end != *next_arg) /* end delimiter not found */ 5552 { 5553 illegal = TRUE; 5554 break; 5555 } 5556 5557 if (!eap->skip) 5558 { 5559 /* store the pattern and compiled regexp program */ 5560 if ((curbuf->b_syn_linecont_pat = vim_strnsave(next_arg + 1, 5561 (int)(arg_end - next_arg - 1))) == NULL) 5562 { 5563 finished = TRUE; 5564 break; 5565 } 5566 curbuf->b_syn_linecont_ic = curbuf->b_syn_ic; 5567 5568 /* Make 'cpoptions' empty, to avoid the 'l' flag */ 5569 cpo_save = p_cpo; 5570 p_cpo = (char_u *)""; 5571 curbuf->b_syn_linecont_prog = 5572 vim_regcomp(curbuf->b_syn_linecont_pat, RE_MAGIC); 5573 p_cpo = cpo_save; 5574 5575 if (curbuf->b_syn_linecont_prog == NULL) 5576 { 5577 vim_free(curbuf->b_syn_linecont_pat); 5578 curbuf->b_syn_linecont_pat = NULL; 5579 finished = TRUE; 5580 break; 5581 } 5582 } 5583 next_arg = skipwhite(arg_end + 1); 5584 } 5585 else 5586 { 5587 eap->arg = next_arg; 5588 if (STRCMP(key, "MATCH") == 0) 5589 syn_cmd_match(eap, TRUE); 5590 else if (STRCMP(key, "REGION") == 0) 5591 syn_cmd_region(eap, TRUE); 5592 else if (STRCMP(key, "CLEAR") == 0) 5593 syn_cmd_clear(eap, TRUE); 5594 else 5595 illegal = TRUE; 5596 finished = TRUE; 5597 break; 5598 } 5599 arg_start = next_arg; 5600 } 5601 vim_free(key); 5602 if (illegal) 5603 EMSG2(_("E404: Illegal arguments: %s"), arg_start); 5604 else if (!finished) 5605 { 5606 eap->nextcmd = check_nextcmd(arg_start); 5607 redraw_curbuf_later(SOME_VALID); 5608 syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ 5609 } 5610 } 5611 5612 /* 5613 * Convert a line of highlight group names into a list of group ID numbers. 5614 * "arg" should point to the "contains" or "nextgroup" keyword. 5615 * "arg" is advanced to after the last group name. 5616 * Careful: the argument is modified (NULs added). 5617 * returns FAIL for some error, OK for success. 5618 */ 5619 static int 5620 get_id_list(arg, keylen, list) 5621 char_u **arg; 5622 int keylen; /* length of keyword */ 5623 short **list; /* where to store the resulting list, if not 5624 NULL, the list is silently skipped! */ 5625 { 5626 char_u *p = NULL; 5627 char_u *end; 5628 int round; 5629 int count; 5630 int total_count = 0; 5631 short *retval = NULL; 5632 char_u *name; 5633 regmatch_T regmatch; 5634 int id; 5635 int i; 5636 int failed = FALSE; 5637 5638 /* 5639 * We parse the list twice: 5640 * round == 1: count the number of items, allocate the array. 5641 * round == 2: fill the array with the items. 5642 * In round 1 new groups may be added, causing the number of items to 5643 * grow when a regexp is used. In that case round 1 is done once again. 5644 */ 5645 for (round = 1; round <= 2; ++round) 5646 { 5647 /* 5648 * skip "contains" 5649 */ 5650 p = skipwhite(*arg + keylen); 5651 if (*p != '=') 5652 { 5653 EMSG2(_("E405: Missing equal sign: %s"), *arg); 5654 break; 5655 } 5656 p = skipwhite(p + 1); 5657 if (ends_excmd(*p)) 5658 { 5659 EMSG2(_("E406: Empty argument: %s"), *arg); 5660 break; 5661 } 5662 5663 /* 5664 * parse the arguments after "contains" 5665 */ 5666 count = 0; 5667 while (!ends_excmd(*p)) 5668 { 5669 for (end = p; *end && !vim_iswhite(*end) && *end != ','; ++end) 5670 ; 5671 name = alloc((int)(end - p + 3)); /* leave room for "^$" */ 5672 if (name == NULL) 5673 { 5674 failed = TRUE; 5675 break; 5676 } 5677 vim_strncpy(name + 1, p, end - p); 5678 if ( STRCMP(name + 1, "ALLBUT") == 0 5679 || STRCMP(name + 1, "ALL") == 0 5680 || STRCMP(name + 1, "TOP") == 0 5681 || STRCMP(name + 1, "CONTAINED") == 0) 5682 { 5683 if (TOUPPER_ASC(**arg) != 'C') 5684 { 5685 EMSG2(_("E407: %s not allowed here"), name + 1); 5686 failed = TRUE; 5687 vim_free(name); 5688 break; 5689 } 5690 if (count != 0) 5691 { 5692 EMSG2(_("E408: %s must be first in contains list"), name + 1); 5693 failed = TRUE; 5694 vim_free(name); 5695 break; 5696 } 5697 if (name[1] == 'A') 5698 id = SYNID_ALLBUT; 5699 else if (name[1] == 'T') 5700 id = SYNID_TOP; 5701 else 5702 id = SYNID_CONTAINED; 5703 id += current_syn_inc_tag; 5704 } 5705 else if (name[1] == '@') 5706 { 5707 id = syn_check_cluster(name + 2, (int)(end - p - 1)); 5708 } 5709 else 5710 { 5711 /* 5712 * Handle full group name. 5713 */ 5714 if (vim_strpbrk(name + 1, (char_u *)"\\.*^$~[") == NULL) 5715 id = syn_check_group(name + 1, (int)(end - p)); 5716 else 5717 { 5718 /* 5719 * Handle match of regexp with group names. 5720 */ 5721 *name = '^'; 5722 STRCAT(name, "$"); 5723 regmatch.regprog = vim_regcomp(name, RE_MAGIC); 5724 if (regmatch.regprog == NULL) 5725 { 5726 failed = TRUE; 5727 vim_free(name); 5728 break; 5729 } 5730 5731 regmatch.rm_ic = TRUE; 5732 id = 0; 5733 for (i = highlight_ga.ga_len; --i >= 0; ) 5734 { 5735 if (vim_regexec(®match, HL_TABLE()[i].sg_name, 5736 (colnr_T)0)) 5737 { 5738 if (round == 2) 5739 { 5740 /* Got more items than expected; can happen 5741 * when adding items that match: 5742 * "contains=a.*b,axb". 5743 * Go back to first round */ 5744 if (count >= total_count) 5745 { 5746 vim_free(retval); 5747 round = 1; 5748 } 5749 else 5750 retval[count] = i + 1; 5751 } 5752 ++count; 5753 id = -1; /* remember that we found one */ 5754 } 5755 } 5756 vim_free(regmatch.regprog); 5757 } 5758 } 5759 vim_free(name); 5760 if (id == 0) 5761 { 5762 EMSG2(_("E409: Unknown group name: %s"), p); 5763 failed = TRUE; 5764 break; 5765 } 5766 if (id > 0) 5767 { 5768 if (round == 2) 5769 { 5770 /* Got more items than expected, go back to first round */ 5771 if (count >= total_count) 5772 { 5773 vim_free(retval); 5774 round = 1; 5775 } 5776 else 5777 retval[count] = id; 5778 } 5779 ++count; 5780 } 5781 p = skipwhite(end); 5782 if (*p != ',') 5783 break; 5784 p = skipwhite(p + 1); /* skip comma in between arguments */ 5785 } 5786 if (failed) 5787 break; 5788 if (round == 1) 5789 { 5790 retval = (short *)alloc((unsigned)((count + 1) * sizeof(short))); 5791 if (retval == NULL) 5792 break; 5793 retval[count] = 0; /* zero means end of the list */ 5794 total_count = count; 5795 } 5796 } 5797 5798 *arg = p; 5799 if (failed || retval == NULL) 5800 { 5801 vim_free(retval); 5802 return FAIL; 5803 } 5804 5805 if (*list == NULL) 5806 *list = retval; 5807 else 5808 vim_free(retval); /* list already found, don't overwrite it */ 5809 5810 return OK; 5811 } 5812 5813 /* 5814 * Make a copy of an ID list. 5815 */ 5816 static short * 5817 copy_id_list(list) 5818 short *list; 5819 { 5820 int len; 5821 int count; 5822 short *retval; 5823 5824 if (list == NULL) 5825 return NULL; 5826 5827 for (count = 0; list[count]; ++count) 5828 ; 5829 len = (count + 1) * sizeof(short); 5830 retval = (short *)alloc((unsigned)len); 5831 if (retval != NULL) 5832 mch_memmove(retval, list, (size_t)len); 5833 5834 return retval; 5835 } 5836 5837 /* 5838 * Check if syntax group "ssp" is in the ID list "list" of "cur_si". 5839 * "cur_si" can be NULL if not checking the "containedin" list. 5840 * Used to check if a syntax item is in the "contains" or "nextgroup" list of 5841 * the current item. 5842 * This function is called very often, keep it fast!! 5843 */ 5844 static int 5845 in_id_list(cur_si, list, ssp, contained) 5846 stateitem_T *cur_si; /* current item or NULL */ 5847 short *list; /* id list */ 5848 struct sp_syn *ssp; /* group id and ":syn include" tag of group */ 5849 int contained; /* group id is contained */ 5850 { 5851 int retval; 5852 short *scl_list; 5853 short item; 5854 short id = ssp->id; 5855 static int depth = 0; 5856 int r; 5857 5858 /* If spp has a "containedin" list and "cur_si" is in it, return TRUE. */ 5859 if (cur_si != NULL && ssp->cont_in_list != NULL 5860 && !(cur_si->si_flags & HL_MATCH)) 5861 { 5862 /* Ignore transparent items without a contains argument. Double check 5863 * that we don't go back past the first one. */ 5864 while ((cur_si->si_flags & HL_TRANS_CONT) 5865 && cur_si > (stateitem_T *)(current_state.ga_data)) 5866 --cur_si; 5867 /* cur_si->si_idx is -1 for keywords, these never contain anything. */ 5868 if (cur_si->si_idx >= 0 && in_id_list(NULL, ssp->cont_in_list, 5869 &(SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_syn), 5870 SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags & HL_CONTAINED)) 5871 return TRUE; 5872 } 5873 5874 if (list == NULL) 5875 return FALSE; 5876 5877 /* 5878 * If list is ID_LIST_ALL, we are in a transparent item that isn't 5879 * inside anything. Only allow not-contained groups. 5880 */ 5881 if (list == ID_LIST_ALL) 5882 return !contained; 5883 5884 /* 5885 * If the first item is "ALLBUT", return TRUE if "id" is NOT in the 5886 * contains list. We also require that "id" is at the same ":syn include" 5887 * level as the list. 5888 */ 5889 item = *list; 5890 if (item >= SYNID_ALLBUT && item < SYNID_CLUSTER) 5891 { 5892 if (item < SYNID_TOP) 5893 { 5894 /* ALL or ALLBUT: accept all groups in the same file */ 5895 if (item - SYNID_ALLBUT != ssp->inc_tag) 5896 return FALSE; 5897 } 5898 else if (item < SYNID_CONTAINED) 5899 { 5900 /* TOP: accept all not-contained groups in the same file */ 5901 if (item - SYNID_TOP != ssp->inc_tag || contained) 5902 return FALSE; 5903 } 5904 else 5905 { 5906 /* CONTAINED: accept all contained groups in the same file */ 5907 if (item - SYNID_CONTAINED != ssp->inc_tag || !contained) 5908 return FALSE; 5909 } 5910 item = *++list; 5911 retval = FALSE; 5912 } 5913 else 5914 retval = TRUE; 5915 5916 /* 5917 * Return "retval" if id is in the contains list. 5918 */ 5919 while (item != 0) 5920 { 5921 if (item == id) 5922 return retval; 5923 if (item >= SYNID_CLUSTER) 5924 { 5925 scl_list = SYN_CLSTR(syn_buf)[item - SYNID_CLUSTER].scl_list; 5926 /* restrict recursiveness to 30 to avoid an endless loop for a 5927 * cluster that includes itself (indirectly) */ 5928 if (scl_list != NULL && depth < 30) 5929 { 5930 ++depth; 5931 r = in_id_list(NULL, scl_list, ssp, contained); 5932 --depth; 5933 if (r) 5934 return retval; 5935 } 5936 } 5937 item = *++list; 5938 } 5939 return !retval; 5940 } 5941 5942 struct subcommand 5943 { 5944 char *name; /* subcommand name */ 5945 void (*func)__ARGS((exarg_T *, int)); /* function to call */ 5946 }; 5947 5948 static struct subcommand subcommands[] = 5949 { 5950 {"case", syn_cmd_case}, 5951 {"clear", syn_cmd_clear}, 5952 {"cluster", syn_cmd_cluster}, 5953 {"enable", syn_cmd_enable}, 5954 {"include", syn_cmd_include}, 5955 {"keyword", syn_cmd_keyword}, 5956 {"list", syn_cmd_list}, 5957 {"manual", syn_cmd_manual}, 5958 {"match", syn_cmd_match}, 5959 {"on", syn_cmd_on}, 5960 {"off", syn_cmd_off}, 5961 {"region", syn_cmd_region}, 5962 {"reset", syn_cmd_reset}, 5963 {"spell", syn_cmd_spell}, 5964 {"sync", syn_cmd_sync}, 5965 {"", syn_cmd_list}, 5966 {NULL, NULL} 5967 }; 5968 5969 /* 5970 * ":syntax". 5971 * This searches the subcommands[] table for the subcommand name, and calls a 5972 * syntax_subcommand() function to do the rest. 5973 */ 5974 void 5975 ex_syntax(eap) 5976 exarg_T *eap; 5977 { 5978 char_u *arg = eap->arg; 5979 char_u *subcmd_end; 5980 char_u *subcmd_name; 5981 int i; 5982 5983 syn_cmdlinep = eap->cmdlinep; 5984 5985 /* isolate subcommand name */ 5986 for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); ++subcmd_end) 5987 ; 5988 subcmd_name = vim_strnsave(arg, (int)(subcmd_end - arg)); 5989 if (subcmd_name != NULL) 5990 { 5991 if (eap->skip) /* skip error messages for all subcommands */ 5992 ++emsg_skip; 5993 for (i = 0; ; ++i) 5994 { 5995 if (subcommands[i].name == NULL) 5996 { 5997 EMSG2(_("E410: Invalid :syntax subcommand: %s"), subcmd_name); 5998 break; 5999 } 6000 if (STRCMP(subcmd_name, (char_u *)subcommands[i].name) == 0) 6001 { 6002 eap->arg = skipwhite(subcmd_end); 6003 (subcommands[i].func)(eap, FALSE); 6004 break; 6005 } 6006 } 6007 vim_free(subcmd_name); 6008 if (eap->skip) 6009 --emsg_skip; 6010 } 6011 } 6012 6013 int 6014 syntax_present(buf) 6015 buf_T *buf; 6016 { 6017 return (buf->b_syn_patterns.ga_len != 0 6018 || buf->b_syn_clusters.ga_len != 0 6019 || buf->b_keywtab.ht_used > 0 6020 || buf->b_keywtab_ic.ht_used > 0); 6021 } 6022 6023 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 6024 6025 static enum 6026 { 6027 EXP_SUBCMD, /* expand ":syn" sub-commands */ 6028 EXP_CASE /* expand ":syn case" arguments */ 6029 } expand_what; 6030 6031 /* 6032 * Reset include_link, include_default, include_none to 0. 6033 * Called when we are done expanding. 6034 */ 6035 void 6036 reset_expand_highlight() 6037 { 6038 include_link = include_default = include_none = 0; 6039 } 6040 6041 /* 6042 * Handle command line completion for :match and :echohl command: Add "None" 6043 * as highlight group. 6044 */ 6045 void 6046 set_context_in_echohl_cmd(xp, arg) 6047 expand_T *xp; 6048 char_u *arg; 6049 { 6050 xp->xp_context = EXPAND_HIGHLIGHT; 6051 xp->xp_pattern = arg; 6052 include_none = 1; 6053 } 6054 6055 /* 6056 * Handle command line completion for :syntax command. 6057 */ 6058 void 6059 set_context_in_syntax_cmd(xp, arg) 6060 expand_T *xp; 6061 char_u *arg; 6062 { 6063 char_u *p; 6064 6065 /* Default: expand subcommands */ 6066 xp->xp_context = EXPAND_SYNTAX; 6067 expand_what = EXP_SUBCMD; 6068 xp->xp_pattern = arg; 6069 include_link = 0; 6070 include_default = 0; 6071 6072 /* (part of) subcommand already typed */ 6073 if (*arg != NUL) 6074 { 6075 p = skiptowhite(arg); 6076 if (*p != NUL) /* past first word */ 6077 { 6078 xp->xp_pattern = skipwhite(p); 6079 if (*skiptowhite(xp->xp_pattern) != NUL) 6080 xp->xp_context = EXPAND_NOTHING; 6081 else if (STRNICMP(arg, "case", p - arg) == 0) 6082 expand_what = EXP_CASE; 6083 else if ( STRNICMP(arg, "keyword", p - arg) == 0 6084 || STRNICMP(arg, "region", p - arg) == 0 6085 || STRNICMP(arg, "match", p - arg) == 0 6086 || STRNICMP(arg, "list", p - arg) == 0) 6087 xp->xp_context = EXPAND_HIGHLIGHT; 6088 else 6089 xp->xp_context = EXPAND_NOTHING; 6090 } 6091 } 6092 } 6093 6094 static char *(case_args[]) = {"match", "ignore", NULL}; 6095 6096 /* 6097 * Function given to ExpandGeneric() to obtain the list syntax names for 6098 * expansion. 6099 */ 6100 /*ARGSUSED*/ 6101 char_u * 6102 get_syntax_name(xp, idx) 6103 expand_T *xp; 6104 int idx; 6105 { 6106 if (expand_what == EXP_SUBCMD) 6107 return (char_u *)subcommands[idx].name; 6108 return (char_u *)case_args[idx]; 6109 } 6110 6111 #endif /* FEAT_CMDL_COMPL */ 6112 6113 /* 6114 * Function called for expression evaluation: get syntax ID at file position. 6115 */ 6116 int 6117 syn_get_id(wp, lnum, col, trans, spellp, keep_state) 6118 win_T *wp; 6119 long lnum; 6120 colnr_T col; 6121 int trans; /* remove transparancy */ 6122 int *spellp; /* return: can do spell checking */ 6123 int keep_state; /* keep state of char at "col" */ 6124 { 6125 /* When the position is not after the current position and in the same 6126 * line of the same buffer, need to restart parsing. */ 6127 if (wp->w_buffer != syn_buf 6128 || lnum != current_lnum 6129 || col < current_col) 6130 syntax_start(wp, lnum); 6131 6132 (void)get_syntax_attr(col, spellp, keep_state); 6133 6134 return (trans ? current_trans_id : current_id); 6135 } 6136 6137 #if defined(FEAT_EVAL) || defined(PROTO) 6138 /* 6139 * Return the syntax ID at position "i" in the current stack. 6140 * The caller must have called syn_get_id() before to fill the stack. 6141 * Returns -1 when "i" is out of range. 6142 */ 6143 int 6144 syn_get_stack_item(i) 6145 int i; 6146 { 6147 if (i >= current_state.ga_len) 6148 { 6149 /* Need to invalidate the state, because we didn't properly finish it 6150 * for the last character, "keep_state" was TRUE. */ 6151 invalidate_current_state(); 6152 current_col = MAXCOL; 6153 return -1; 6154 } 6155 return CUR_STATE(i).si_id; 6156 } 6157 #endif 6158 6159 #if defined(FEAT_FOLDING) || defined(PROTO) 6160 /* 6161 * Function called to get folding level for line "lnum" in window "wp". 6162 */ 6163 int 6164 syn_get_foldlevel(wp, lnum) 6165 win_T *wp; 6166 long lnum; 6167 { 6168 int level = 0; 6169 int i; 6170 6171 /* Return quickly when there are no fold items at all. */ 6172 if (wp->w_buffer->b_syn_folditems != 0) 6173 { 6174 syntax_start(wp, lnum); 6175 6176 for (i = 0; i < current_state.ga_len; ++i) 6177 if (CUR_STATE(i).si_flags & HL_FOLD) 6178 ++level; 6179 } 6180 if (level > wp->w_p_fdn) 6181 { 6182 level = wp->w_p_fdn; 6183 if (level < 0) 6184 level = 0; 6185 } 6186 return level; 6187 } 6188 #endif 6189 6190 #endif /* FEAT_SYN_HL */ 6191 6192 6193 /************************************** 6194 * Highlighting stuff * 6195 **************************************/ 6196 6197 /* 6198 * The default highlight groups. These are compiled-in for fast startup and 6199 * they still work when the runtime files can't be found. 6200 * When making changes here, also change runtime/colors/default.vim! 6201 * The #ifdefs are needed to reduce the amount of static data. Helps to make 6202 * the 16 bit DOS (museum) version compile. 6203 */ 6204 #ifdef FEAT_GUI 6205 # define CENT(a, b) b 6206 #else 6207 # define CENT(a, b) a 6208 #endif 6209 static char *(highlight_init_both[]) = 6210 { 6211 CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White", 6212 "ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"), 6213 #ifdef FEAT_SEARCH_EXTRA 6214 CENT("IncSearch term=reverse cterm=reverse", 6215 "IncSearch term=reverse cterm=reverse gui=reverse"), 6216 #endif 6217 CENT("ModeMsg term=bold cterm=bold", 6218 "ModeMsg term=bold cterm=bold gui=bold"), 6219 CENT("NonText term=bold ctermfg=Blue", 6220 "NonText term=bold ctermfg=Blue gui=bold guifg=Blue"), 6221 CENT("StatusLine term=reverse,bold cterm=reverse,bold", 6222 "StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"), 6223 CENT("StatusLineNC term=reverse cterm=reverse", 6224 "StatusLineNC term=reverse cterm=reverse gui=reverse"), 6225 #ifdef FEAT_VERTSPLIT 6226 CENT("VertSplit term=reverse cterm=reverse", 6227 "VertSplit term=reverse cterm=reverse gui=reverse"), 6228 #endif 6229 #ifdef FEAT_CLIPBOARD 6230 CENT("VisualNOS term=underline,bold cterm=underline,bold", 6231 "VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"), 6232 #endif 6233 #ifdef FEAT_DIFF 6234 CENT("DiffText term=reverse cterm=bold ctermbg=Red", 6235 "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"), 6236 #endif 6237 #ifdef FEAT_INS_EXPAND 6238 CENT("PmenuThumb cterm=reverse", 6239 "PmenuThumb cterm=reverse gui=reverse"), 6240 CENT("PmenuSbar ctermbg=Grey", 6241 "PmenuSbar ctermbg=Grey guibg=Grey"), 6242 #endif 6243 #ifdef FEAT_WINDOWS 6244 CENT("TabLineSel term=bold cterm=bold", 6245 "TabLineSel term=bold cterm=bold gui=bold"), 6246 CENT("TabLineFill term=reverse cterm=reverse", 6247 "TabLineFill term=reverse cterm=reverse gui=reverse"), 6248 #endif 6249 #ifdef FEAT_GUI 6250 "Cursor guibg=fg guifg=bg", 6251 "lCursor guibg=fg guifg=bg", /* should be different, but what? */ 6252 #endif 6253 NULL 6254 }; 6255 6256 static char *(highlight_init_light[]) = 6257 { 6258 CENT("Directory term=bold ctermfg=DarkBlue", 6259 "Directory term=bold ctermfg=DarkBlue guifg=Blue"), 6260 CENT("LineNr term=underline ctermfg=Brown", 6261 "LineNr term=underline ctermfg=Brown guifg=Brown"), 6262 CENT("MoreMsg term=bold ctermfg=DarkGreen", 6263 "MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"), 6264 CENT("Question term=standout ctermfg=DarkGreen", 6265 "Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"), 6266 CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE", 6267 "Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"), 6268 #ifdef FEAT_SPELL 6269 CENT("SpellBad term=reverse ctermbg=LightRed", 6270 "SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"), 6271 CENT("SpellCap term=reverse ctermbg=LightBlue", 6272 "SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"), 6273 CENT("SpellRare term=reverse ctermbg=LightMagenta", 6274 "SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"), 6275 CENT("SpellLocal term=underline ctermbg=Cyan", 6276 "SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"), 6277 #endif 6278 #ifdef FEAT_INS_EXPAND 6279 CENT("Pmenu ctermbg=LightMagenta", 6280 "Pmenu ctermbg=LightMagenta guibg=LightMagenta"), 6281 CENT("PmenuSel ctermbg=LightGrey", 6282 "PmenuSel ctermbg=LightGrey guibg=Grey"), 6283 #endif 6284 CENT("SpecialKey term=bold ctermfg=DarkBlue", 6285 "SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"), 6286 CENT("Title term=bold ctermfg=DarkMagenta", 6287 "Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"), 6288 CENT("WarningMsg term=standout ctermfg=DarkRed", 6289 "WarningMsg term=standout ctermfg=DarkRed guifg=Red"), 6290 #ifdef FEAT_WILDMENU 6291 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black", 6292 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"), 6293 #endif 6294 #ifdef FEAT_FOLDING 6295 CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue", 6296 "Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"), 6297 CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue", 6298 "FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"), 6299 #endif 6300 #ifdef FEAT_SIGNS 6301 CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue", 6302 "SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"), 6303 #endif 6304 #ifdef FEAT_VISUAL 6305 CENT("Visual term=reverse", 6306 "Visual term=reverse guibg=LightGrey"), 6307 #endif 6308 #ifdef FEAT_DIFF 6309 CENT("DiffAdd term=bold ctermbg=LightBlue", 6310 "DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"), 6311 CENT("DiffChange term=bold ctermbg=LightMagenta", 6312 "DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"), 6313 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan", 6314 "DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"), 6315 #endif 6316 #ifdef FEAT_WINDOWS 6317 CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey", 6318 "TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"), 6319 #endif 6320 #ifdef FEAT_SYN_HL 6321 CENT("CursorColumn term=reverse ctermbg=LightGrey", 6322 "CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"), 6323 CENT("CursorLine term=underline cterm=underline", 6324 "CursorLine term=underline cterm=underline guibg=Grey90"), 6325 #endif 6326 #ifdef FEAT_AUTOCMD 6327 CENT("MatchParen term=reverse ctermbg=Cyan", 6328 "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"), 6329 #endif 6330 #ifdef FEAT_GUI 6331 "Normal gui=NONE", 6332 #endif 6333 NULL 6334 }; 6335 6336 static char *(highlight_init_dark[]) = 6337 { 6338 CENT("Directory term=bold ctermfg=LightCyan", 6339 "Directory term=bold ctermfg=LightCyan guifg=Cyan"), 6340 CENT("LineNr term=underline ctermfg=Yellow", 6341 "LineNr term=underline ctermfg=Yellow guifg=Yellow"), 6342 CENT("MoreMsg term=bold ctermfg=LightGreen", 6343 "MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"), 6344 CENT("Question term=standout ctermfg=LightGreen", 6345 "Question term=standout ctermfg=LightGreen gui=bold guifg=Green"), 6346 CENT("Search term=reverse ctermbg=Yellow ctermfg=Black", 6347 "Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"), 6348 CENT("SpecialKey term=bold ctermfg=LightBlue", 6349 "SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"), 6350 #ifdef FEAT_SPELL 6351 CENT("SpellBad term=reverse ctermbg=Red", 6352 "SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"), 6353 CENT("SpellCap term=reverse ctermbg=Blue", 6354 "SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"), 6355 CENT("SpellRare term=reverse ctermbg=Magenta", 6356 "SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"), 6357 CENT("SpellLocal term=underline ctermbg=Cyan", 6358 "SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"), 6359 #endif 6360 #ifdef FEAT_INS_EXPAND 6361 CENT("Pmenu ctermbg=Magenta", 6362 "Pmenu ctermbg=Magenta guibg=Magenta"), 6363 CENT("PmenuSel ctermbg=DarkGrey", 6364 "PmenuSel ctermbg=DarkGrey guibg=DarkGrey"), 6365 #endif 6366 CENT("Title term=bold ctermfg=LightMagenta", 6367 "Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"), 6368 CENT("WarningMsg term=standout ctermfg=LightRed", 6369 "WarningMsg term=standout ctermfg=LightRed guifg=Red"), 6370 #ifdef FEAT_WILDMENU 6371 CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black", 6372 "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"), 6373 #endif 6374 #ifdef FEAT_FOLDING 6375 CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan", 6376 "Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"), 6377 CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan", 6378 "FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"), 6379 #endif 6380 #ifdef FEAT_SIGNS 6381 CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan", 6382 "SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"), 6383 #endif 6384 #ifdef FEAT_VISUAL 6385 CENT("Visual term=reverse", 6386 "Visual term=reverse guibg=DarkGrey"), 6387 #endif 6388 #ifdef FEAT_DIFF 6389 CENT("DiffAdd term=bold ctermbg=DarkBlue", 6390 "DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"), 6391 CENT("DiffChange term=bold ctermbg=DarkMagenta", 6392 "DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"), 6393 CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan", 6394 "DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"), 6395 #endif 6396 #ifdef FEAT_WINDOWS 6397 CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey", 6398 "TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"), 6399 #endif 6400 #ifdef FEAT_SYN_HL 6401 CENT("CursorColumn term=reverse ctermbg=DarkGrey", 6402 "CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"), 6403 CENT("CursorLine term=underline cterm=underline", 6404 "CursorLine term=underline cterm=underline guibg=Grey40"), 6405 #endif 6406 #ifdef FEAT_AUTOCMD 6407 CENT("MatchParen term=reverse ctermbg=DarkCyan", 6408 "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"), 6409 #endif 6410 #ifdef FEAT_GUI 6411 "Normal gui=NONE", 6412 #endif 6413 NULL 6414 }; 6415 6416 void 6417 init_highlight(both, reset) 6418 int both; /* include groups where 'bg' doesn't matter */ 6419 int reset; /* clear group first */ 6420 { 6421 int i; 6422 char **pp; 6423 static int had_both = FALSE; 6424 #ifdef FEAT_EVAL 6425 char_u *p; 6426 6427 /* 6428 * Try finding the color scheme file. Used when a color file was loaded 6429 * and 'background' or 't_Co' is changed. 6430 */ 6431 p = get_var_value((char_u *)"g:colors_name"); 6432 if (p != NULL && load_colors(p) == OK) 6433 return; 6434 #endif 6435 6436 /* 6437 * Didn't use a color file, use the compiled-in colors. 6438 */ 6439 if (both) 6440 { 6441 had_both = TRUE; 6442 pp = highlight_init_both; 6443 for (i = 0; pp[i] != NULL; ++i) 6444 do_highlight((char_u *)pp[i], reset, TRUE); 6445 } 6446 else if (!had_both) 6447 /* Don't do anything before the call with both == TRUE from main(). 6448 * Not everything has been setup then, and that call will overrule 6449 * everything anyway. */ 6450 return; 6451 6452 if (*p_bg == 'l') 6453 pp = highlight_init_light; 6454 else 6455 pp = highlight_init_dark; 6456 for (i = 0; pp[i] != NULL; ++i) 6457 do_highlight((char_u *)pp[i], reset, TRUE); 6458 6459 /* Reverse looks ugly, but grey may not work for 8 colors. Thus let it 6460 * depend on the number of colors available. 6461 * With 8 colors brown is equal to yellow, need to use black for Search fg 6462 * to avoid Statement highlighted text disappears. 6463 * Clear the attributes, needed when changing the t_Co value. */ 6464 if (t_colors > 8) 6465 do_highlight((char_u *)(*p_bg == 'l' 6466 ? "Visual cterm=NONE ctermbg=LightGrey" 6467 : "Visual cterm=NONE ctermbg=DarkGrey"), FALSE, TRUE); 6468 else 6469 { 6470 do_highlight((char_u *)"Visual cterm=reverse ctermbg=NONE", 6471 FALSE, TRUE); 6472 if (*p_bg == 'l') 6473 do_highlight((char_u *)"Search ctermfg=black", FALSE, TRUE); 6474 } 6475 6476 #ifdef FEAT_SYN_HL 6477 /* 6478 * If syntax highlighting is enabled load the highlighting for it. 6479 */ 6480 if (get_var_value((char_u *)"g:syntax_on") != NULL) 6481 { 6482 static int recursive = 0; 6483 6484 if (recursive >= 5) 6485 EMSG(_("E679: recursive loop loading syncolor.vim")); 6486 else 6487 { 6488 ++recursive; 6489 (void)source_runtime((char_u *)"syntax/syncolor.vim", TRUE); 6490 --recursive; 6491 } 6492 } 6493 #endif 6494 } 6495 6496 /* 6497 * Load color file "name". 6498 * Return OK for success, FAIL for failure. 6499 */ 6500 int 6501 load_colors(name) 6502 char_u *name; 6503 { 6504 char_u *buf; 6505 int retval = FAIL; 6506 static int recursive = FALSE; 6507 6508 /* When being called recursively, this is probably because setting 6509 * 'background' caused the highlighting to be reloaded. This means it is 6510 * working, thus we should return OK. */ 6511 if (recursive) 6512 return OK; 6513 6514 recursive = TRUE; 6515 buf = alloc((unsigned)(STRLEN(name) + 12)); 6516 if (buf != NULL) 6517 { 6518 sprintf((char *)buf, "colors/%s.vim", name); 6519 retval = source_runtime(buf, FALSE); 6520 vim_free(buf); 6521 #ifdef FEAT_AUTOCMD 6522 apply_autocmds(EVENT_COLORSCHEME, NULL, NULL, FALSE, curbuf); 6523 #endif 6524 } 6525 recursive = FALSE; 6526 6527 return retval; 6528 } 6529 6530 /* 6531 * Handle the ":highlight .." command. 6532 * When using ":hi clear" this is called recursively for each group with 6533 * "forceit" and "init" both TRUE. 6534 */ 6535 void 6536 do_highlight(line, forceit, init) 6537 char_u *line; 6538 int forceit; 6539 int init; /* TRUE when called for initializing */ 6540 { 6541 char_u *name_end; 6542 char_u *p; 6543 char_u *linep; 6544 char_u *key_start; 6545 char_u *arg_start; 6546 char_u *key = NULL, *arg = NULL; 6547 long i; 6548 int off; 6549 int len; 6550 int attr; 6551 int id; 6552 int idx; 6553 int dodefault = FALSE; 6554 int doclear = FALSE; 6555 int dolink = FALSE; 6556 int error = FALSE; 6557 int color; 6558 int is_normal_group = FALSE; /* "Normal" group */ 6559 #ifdef FEAT_GUI_X11 6560 int is_menu_group = FALSE; /* "Menu" group */ 6561 int is_scrollbar_group = FALSE; /* "Scrollbar" group */ 6562 int is_tooltip_group = FALSE; /* "Tooltip" group */ 6563 int do_colors = FALSE; /* need to update colors? */ 6564 #else 6565 # define is_menu_group 0 6566 # define is_tooltip_group 0 6567 #endif 6568 6569 /* 6570 * If no argument, list current highlighting. 6571 */ 6572 if (ends_excmd(*line)) 6573 { 6574 for (i = 1; i <= highlight_ga.ga_len && !got_int; ++i) 6575 /* TODO: only call when the group has attributes set */ 6576 highlight_list_one((int)i); 6577 return; 6578 } 6579 6580 /* 6581 * Isolate the name. 6582 */ 6583 name_end = skiptowhite(line); 6584 linep = skipwhite(name_end); 6585 6586 /* 6587 * Check for "default" argument. 6588 */ 6589 if (STRNCMP(line, "default", name_end - line) == 0) 6590 { 6591 dodefault = TRUE; 6592 line = linep; 6593 name_end = skiptowhite(line); 6594 linep = skipwhite(name_end); 6595 } 6596 6597 /* 6598 * Check for "clear" or "link" argument. 6599 */ 6600 if (STRNCMP(line, "clear", name_end - line) == 0) 6601 doclear = TRUE; 6602 if (STRNCMP(line, "link", name_end - line) == 0) 6603 dolink = TRUE; 6604 6605 /* 6606 * ":highlight {group-name}": list highlighting for one group. 6607 */ 6608 if (!doclear && !dolink && ends_excmd(*linep)) 6609 { 6610 id = syn_namen2id(line, (int)(name_end - line)); 6611 if (id == 0) 6612 EMSG2(_("E411: highlight group not found: %s"), line); 6613 else 6614 highlight_list_one(id); 6615 return; 6616 } 6617 6618 /* 6619 * Handle ":highlight link {from} {to}" command. 6620 */ 6621 if (dolink) 6622 { 6623 char_u *from_start = linep; 6624 char_u *from_end; 6625 char_u *to_start; 6626 char_u *to_end; 6627 int from_id; 6628 int to_id; 6629 6630 from_end = skiptowhite(from_start); 6631 to_start = skipwhite(from_end); 6632 to_end = skiptowhite(to_start); 6633 6634 if (ends_excmd(*from_start) || ends_excmd(*to_start)) 6635 { 6636 EMSG2(_("E412: Not enough arguments: \":highlight link %s\""), 6637 from_start); 6638 return; 6639 } 6640 6641 if (!ends_excmd(*skipwhite(to_end))) 6642 { 6643 EMSG2(_("E413: Too many arguments: \":highlight link %s\""), from_start); 6644 return; 6645 } 6646 6647 from_id = syn_check_group(from_start, (int)(from_end - from_start)); 6648 if (STRNCMP(to_start, "NONE", 4) == 0) 6649 to_id = 0; 6650 else 6651 to_id = syn_check_group(to_start, (int)(to_end - to_start)); 6652 6653 if (from_id > 0 && (!init || HL_TABLE()[from_id - 1].sg_set == 0)) 6654 { 6655 /* 6656 * Don't allow a link when there already is some highlighting 6657 * for the group, unless '!' is used 6658 */ 6659 if (to_id > 0 && !forceit && !init 6660 && hl_has_settings(from_id - 1, dodefault)) 6661 { 6662 if (sourcing_name == NULL && !dodefault) 6663 EMSG(_("E414: group has settings, highlight link ignored")); 6664 } 6665 else 6666 { 6667 if (!init) 6668 HL_TABLE()[from_id - 1].sg_set |= SG_LINK; 6669 HL_TABLE()[from_id - 1].sg_link = to_id; 6670 #ifdef FEAT_EVAL 6671 HL_TABLE()[from_id - 1].sg_scriptID = current_SID; 6672 #endif 6673 redraw_all_later(SOME_VALID); 6674 } 6675 } 6676 6677 /* Only call highlight_changed() once, after sourcing a syntax file */ 6678 need_highlight_changed = TRUE; 6679 6680 return; 6681 } 6682 6683 if (doclear) 6684 { 6685 /* 6686 * ":highlight clear [group]" command. 6687 */ 6688 line = linep; 6689 if (ends_excmd(*line)) 6690 { 6691 #ifdef FEAT_GUI 6692 /* First, we do not destroy the old values, but allocate the new 6693 * ones and update the display. THEN we destroy the old values. 6694 * If we destroy the old values first, then the old values 6695 * (such as GuiFont's or GuiFontset's) will still be displayed but 6696 * invalid because they were free'd. 6697 */ 6698 if (gui.in_use) 6699 { 6700 # ifdef FEAT_BEVAL_TIP 6701 gui_init_tooltip_font(); 6702 # endif 6703 # if defined(FEAT_MENU) && (defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MOTIF)) 6704 gui_init_menu_font(); 6705 # endif 6706 } 6707 # if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11) 6708 gui_mch_def_colors(); 6709 # endif 6710 # ifdef FEAT_GUI_X11 6711 # ifdef FEAT_MENU 6712 6713 /* This only needs to be done when there is no Menu highlight 6714 * group defined by default, which IS currently the case. 6715 */ 6716 gui_mch_new_menu_colors(); 6717 # endif 6718 if (gui.in_use) 6719 { 6720 gui_new_scrollbar_colors(); 6721 # ifdef FEAT_BEVAL 6722 gui_mch_new_tooltip_colors(); 6723 # endif 6724 # ifdef FEAT_MENU 6725 gui_mch_new_menu_font(); 6726 # endif 6727 } 6728 # endif 6729 6730 /* Ok, we're done allocating the new default graphics items. 6731 * The screen should already be refreshed at this point. 6732 * It is now Ok to clear out the old data. 6733 */ 6734 #endif 6735 #ifdef FEAT_EVAL 6736 do_unlet((char_u *)"colors_name", TRUE); 6737 #endif 6738 restore_cterm_colors(); 6739 6740 /* 6741 * Clear all default highlight groups and load the defaults. 6742 */ 6743 for (idx = 0; idx < highlight_ga.ga_len; ++idx) 6744 highlight_clear(idx); 6745 init_highlight(TRUE, TRUE); 6746 #ifdef FEAT_GUI 6747 if (gui.in_use) 6748 highlight_gui_started(); 6749 #endif 6750 highlight_changed(); 6751 redraw_later_clear(); 6752 return; 6753 } 6754 name_end = skiptowhite(line); 6755 linep = skipwhite(name_end); 6756 } 6757 6758 /* 6759 * Find the group name in the table. If it does not exist yet, add it. 6760 */ 6761 id = syn_check_group(line, (int)(name_end - line)); 6762 if (id == 0) /* failed (out of memory) */ 6763 return; 6764 idx = id - 1; /* index is ID minus one */ 6765 6766 /* Return if "default" was used and the group already has settings. */ 6767 if (dodefault && hl_has_settings(idx, TRUE)) 6768 return; 6769 6770 if (STRCMP(HL_TABLE()[idx].sg_name_u, "NORMAL") == 0) 6771 is_normal_group = TRUE; 6772 #ifdef FEAT_GUI_X11 6773 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "MENU") == 0) 6774 is_menu_group = TRUE; 6775 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "SCROLLBAR") == 0) 6776 is_scrollbar_group = TRUE; 6777 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "TOOLTIP") == 0) 6778 is_tooltip_group = TRUE; 6779 #endif 6780 6781 /* Clear the highlighting for ":hi clear {group}" and ":hi clear". */ 6782 if (doclear || (forceit && init)) 6783 { 6784 highlight_clear(idx); 6785 if (!doclear) 6786 HL_TABLE()[idx].sg_set = 0; 6787 } 6788 6789 if (!doclear) 6790 while (!ends_excmd(*linep)) 6791 { 6792 key_start = linep; 6793 if (*linep == '=') 6794 { 6795 EMSG2(_("E415: unexpected equal sign: %s"), key_start); 6796 error = TRUE; 6797 break; 6798 } 6799 6800 /* 6801 * Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" or 6802 * "guibg"). 6803 */ 6804 while (*linep && !vim_iswhite(*linep) && *linep != '=') 6805 ++linep; 6806 vim_free(key); 6807 key = vim_strnsave_up(key_start, (int)(linep - key_start)); 6808 if (key == NULL) 6809 { 6810 error = TRUE; 6811 break; 6812 } 6813 linep = skipwhite(linep); 6814 6815 if (STRCMP(key, "NONE") == 0) 6816 { 6817 if (!init || HL_TABLE()[idx].sg_set == 0) 6818 { 6819 if (!init) 6820 HL_TABLE()[idx].sg_set |= SG_TERM+SG_CTERM+SG_GUI; 6821 highlight_clear(idx); 6822 } 6823 continue; 6824 } 6825 6826 /* 6827 * Check for the equal sign. 6828 */ 6829 if (*linep != '=') 6830 { 6831 EMSG2(_("E416: missing equal sign: %s"), key_start); 6832 error = TRUE; 6833 break; 6834 } 6835 ++linep; 6836 6837 /* 6838 * Isolate the argument. 6839 */ 6840 linep = skipwhite(linep); 6841 if (*linep == '\'') /* guifg='color name' */ 6842 { 6843 arg_start = ++linep; 6844 linep = vim_strchr(linep, '\''); 6845 if (linep == NULL) 6846 { 6847 EMSG2(_(e_invarg2), key_start); 6848 error = TRUE; 6849 break; 6850 } 6851 } 6852 else 6853 { 6854 arg_start = linep; 6855 linep = skiptowhite(linep); 6856 } 6857 if (linep == arg_start) 6858 { 6859 EMSG2(_("E417: missing argument: %s"), key_start); 6860 error = TRUE; 6861 break; 6862 } 6863 vim_free(arg); 6864 arg = vim_strnsave(arg_start, (int)(linep - arg_start)); 6865 if (arg == NULL) 6866 { 6867 error = TRUE; 6868 break; 6869 } 6870 if (*linep == '\'') 6871 ++linep; 6872 6873 /* 6874 * Store the argument. 6875 */ 6876 if ( STRCMP(key, "TERM") == 0 6877 || STRCMP(key, "CTERM") == 0 6878 || STRCMP(key, "GUI") == 0) 6879 { 6880 attr = 0; 6881 off = 0; 6882 while (arg[off] != NUL) 6883 { 6884 for (i = sizeof(hl_attr_table) / sizeof(int); --i >= 0; ) 6885 { 6886 len = (int)STRLEN(hl_name_table[i]); 6887 if (STRNICMP(arg + off, hl_name_table[i], len) == 0) 6888 { 6889 attr |= hl_attr_table[i]; 6890 off += len; 6891 break; 6892 } 6893 } 6894 if (i < 0) 6895 { 6896 EMSG2(_("E418: Illegal value: %s"), arg); 6897 error = TRUE; 6898 break; 6899 } 6900 if (arg[off] == ',') /* another one follows */ 6901 ++off; 6902 } 6903 if (error) 6904 break; 6905 if (*key == 'T') 6906 { 6907 if (!init || !(HL_TABLE()[idx].sg_set & SG_TERM)) 6908 { 6909 if (!init) 6910 HL_TABLE()[idx].sg_set |= SG_TERM; 6911 HL_TABLE()[idx].sg_term = attr; 6912 } 6913 } 6914 else if (*key == 'C') 6915 { 6916 if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM)) 6917 { 6918 if (!init) 6919 HL_TABLE()[idx].sg_set |= SG_CTERM; 6920 HL_TABLE()[idx].sg_cterm = attr; 6921 HL_TABLE()[idx].sg_cterm_bold = FALSE; 6922 } 6923 } 6924 #ifdef FEAT_GUI 6925 else 6926 { 6927 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI)) 6928 { 6929 if (!init) 6930 HL_TABLE()[idx].sg_set |= SG_GUI; 6931 HL_TABLE()[idx].sg_gui = attr; 6932 } 6933 } 6934 #endif 6935 } 6936 else if (STRCMP(key, "FONT") == 0) 6937 { 6938 /* in non-GUI fonts are simply ignored */ 6939 #ifdef FEAT_GUI 6940 if (!gui.shell_created) 6941 { 6942 /* GUI not started yet, always accept the name. */ 6943 vim_free(HL_TABLE()[idx].sg_font_name); 6944 HL_TABLE()[idx].sg_font_name = vim_strsave(arg); 6945 } 6946 else 6947 { 6948 GuiFont temp_sg_font = HL_TABLE()[idx].sg_font; 6949 # ifdef FEAT_XFONTSET 6950 GuiFontset temp_sg_fontset = HL_TABLE()[idx].sg_fontset; 6951 # endif 6952 /* First, save the current font/fontset. 6953 * Then try to allocate the font/fontset. 6954 * If the allocation fails, HL_TABLE()[idx].sg_font OR 6955 * sg_fontset will be set to NOFONT or NOFONTSET respectively. 6956 */ 6957 6958 HL_TABLE()[idx].sg_font = NOFONT; 6959 # ifdef FEAT_XFONTSET 6960 HL_TABLE()[idx].sg_fontset = NOFONTSET; 6961 # endif 6962 hl_do_font(idx, arg, is_normal_group, is_menu_group, 6963 is_tooltip_group); 6964 6965 # ifdef FEAT_XFONTSET 6966 if (HL_TABLE()[idx].sg_fontset != NOFONTSET) 6967 { 6968 /* New fontset was accepted. Free the old one, if there was 6969 * one. 6970 */ 6971 gui_mch_free_fontset(temp_sg_fontset); 6972 vim_free(HL_TABLE()[idx].sg_font_name); 6973 HL_TABLE()[idx].sg_font_name = vim_strsave(arg); 6974 } 6975 else 6976 HL_TABLE()[idx].sg_fontset = temp_sg_fontset; 6977 # endif 6978 if (HL_TABLE()[idx].sg_font != NOFONT) 6979 { 6980 /* New font was accepted. Free the old one, if there was 6981 * one. 6982 */ 6983 gui_mch_free_font(temp_sg_font); 6984 vim_free(HL_TABLE()[idx].sg_font_name); 6985 HL_TABLE()[idx].sg_font_name = vim_strsave(arg); 6986 } 6987 else 6988 HL_TABLE()[idx].sg_font = temp_sg_font; 6989 } 6990 #endif 6991 } 6992 else if (STRCMP(key, "CTERMFG") == 0 || STRCMP(key, "CTERMBG") == 0) 6993 { 6994 if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM)) 6995 { 6996 if (!init) 6997 HL_TABLE()[idx].sg_set |= SG_CTERM; 6998 6999 /* When setting the foreground color, and previously the "bold" 7000 * flag was set for a light color, reset it now */ 7001 if (key[5] == 'F' && HL_TABLE()[idx].sg_cterm_bold) 7002 { 7003 HL_TABLE()[idx].sg_cterm &= ~HL_BOLD; 7004 HL_TABLE()[idx].sg_cterm_bold = FALSE; 7005 } 7006 7007 if (VIM_ISDIGIT(*arg)) 7008 color = atoi((char *)arg); 7009 else if (STRICMP(arg, "fg") == 0) 7010 { 7011 if (cterm_normal_fg_color) 7012 color = cterm_normal_fg_color - 1; 7013 else 7014 { 7015 EMSG(_("E419: FG color unknown")); 7016 error = TRUE; 7017 break; 7018 } 7019 } 7020 else if (STRICMP(arg, "bg") == 0) 7021 { 7022 if (cterm_normal_bg_color > 0) 7023 color = cterm_normal_bg_color - 1; 7024 else 7025 { 7026 EMSG(_("E420: BG color unknown")); 7027 error = TRUE; 7028 break; 7029 } 7030 } 7031 else 7032 { 7033 static char *(color_names[28]) = { 7034 "Black", "DarkBlue", "DarkGreen", "DarkCyan", 7035 "DarkRed", "DarkMagenta", "Brown", "DarkYellow", 7036 "Gray", "Grey", 7037 "LightGray", "LightGrey", "DarkGray", "DarkGrey", 7038 "Blue", "LightBlue", "Green", "LightGreen", 7039 "Cyan", "LightCyan", "Red", "LightRed", "Magenta", 7040 "LightMagenta", "Yellow", "LightYellow", "White", "NONE"}; 7041 static int color_numbers_16[28] = {0, 1, 2, 3, 7042 4, 5, 6, 6, 7043 7, 7, 7044 7, 7, 8, 8, 7045 9, 9, 10, 10, 7046 11, 11, 12, 12, 13, 7047 13, 14, 14, 15, -1}; 7048 /* for xterm with 88 colors... */ 7049 static int color_numbers_88[28] = {0, 4, 2, 6, 7050 1, 5, 32, 72, 7051 84, 84, 7052 7, 7, 82, 82, 7053 12, 43, 10, 61, 7054 14, 63, 9, 74, 13, 7055 75, 11, 78, 15, -1}; 7056 /* for xterm with 256 colors... */ 7057 static int color_numbers_256[28] = {0, 4, 2, 6, 7058 1, 5, 130, 130, 7059 248, 248, 7060 7, 7, 242, 242, 7061 12, 81, 10, 121, 7062 14, 159, 9, 224, 13, 7063 225, 11, 229, 15, -1}; 7064 /* for terminals with less than 16 colors... */ 7065 static int color_numbers_8[28] = {0, 4, 2, 6, 7066 1, 5, 3, 3, 7067 7, 7, 7068 7, 7, 0+8, 0+8, 7069 4+8, 4+8, 2+8, 2+8, 7070 6+8, 6+8, 1+8, 1+8, 5+8, 7071 5+8, 3+8, 3+8, 7+8, -1}; 7072 #if defined(__QNXNTO__) 7073 static int *color_numbers_8_qansi = color_numbers_8; 7074 /* On qnx, the 8 & 16 color arrays are the same */ 7075 if (STRNCMP(T_NAME, "qansi", 5) == 0) 7076 color_numbers_8_qansi = color_numbers_16; 7077 #endif 7078 7079 /* reduce calls to STRICMP a bit, it can be slow */ 7080 off = TOUPPER_ASC(*arg); 7081 for (i = (sizeof(color_names) / sizeof(char *)); --i >= 0; ) 7082 if (off == color_names[i][0] 7083 && STRICMP(arg + 1, color_names[i] + 1) == 0) 7084 break; 7085 if (i < 0) 7086 { 7087 EMSG2(_("E421: Color name or number not recognized: %s"), key_start); 7088 error = TRUE; 7089 break; 7090 } 7091 7092 /* Use the _16 table to check if its a valid color name. */ 7093 color = color_numbers_16[i]; 7094 if (color >= 0) 7095 { 7096 if (t_colors == 8) 7097 { 7098 /* t_Co is 8: use the 8 colors table */ 7099 #if defined(__QNXNTO__) 7100 color = color_numbers_8_qansi[i]; 7101 #else 7102 color = color_numbers_8[i]; 7103 #endif 7104 if (key[5] == 'F') 7105 { 7106 /* set/reset bold attribute to get light foreground 7107 * colors (on some terminals, e.g. "linux") */ 7108 if (color & 8) 7109 { 7110 HL_TABLE()[idx].sg_cterm |= HL_BOLD; 7111 HL_TABLE()[idx].sg_cterm_bold = TRUE; 7112 } 7113 else 7114 HL_TABLE()[idx].sg_cterm &= ~HL_BOLD; 7115 } 7116 color &= 7; /* truncate to 8 colors */ 7117 } 7118 else if (t_colors == 16 || t_colors == 88 7119 || t_colors == 256) 7120 { 7121 /* 7122 * Guess: if the termcap entry ends in 'm', it is 7123 * probably an xterm-like terminal. Use the changed 7124 * order for colors. 7125 */ 7126 if (*T_CAF != NUL) 7127 p = T_CAF; 7128 else 7129 p = T_CSF; 7130 if (*p != NUL && *(p + STRLEN(p) - 1) == 'm') 7131 switch (t_colors) 7132 { 7133 case 16: 7134 color = color_numbers_8[i]; 7135 break; 7136 case 88: 7137 color = color_numbers_88[i]; 7138 break; 7139 case 256: 7140 color = color_numbers_256[i]; 7141 break; 7142 } 7143 } 7144 } 7145 } 7146 /* Add one to the argument, to avoid zero */ 7147 if (key[5] == 'F') 7148 { 7149 HL_TABLE()[idx].sg_cterm_fg = color + 1; 7150 if (is_normal_group) 7151 { 7152 cterm_normal_fg_color = color + 1; 7153 cterm_normal_fg_bold = (HL_TABLE()[idx].sg_cterm & HL_BOLD); 7154 #ifdef FEAT_GUI 7155 /* Don't do this if the GUI is used. */ 7156 if (!gui.in_use && !gui.starting) 7157 #endif 7158 { 7159 must_redraw = CLEAR; 7160 if (termcap_active) 7161 term_fg_color(color); 7162 } 7163 } 7164 } 7165 else 7166 { 7167 HL_TABLE()[idx].sg_cterm_bg = color + 1; 7168 if (is_normal_group) 7169 { 7170 cterm_normal_bg_color = color + 1; 7171 #ifdef FEAT_GUI 7172 /* Don't mess with 'background' if the GUI is used. */ 7173 if (!gui.in_use && !gui.starting) 7174 #endif 7175 { 7176 must_redraw = CLEAR; 7177 if (termcap_active) 7178 term_bg_color(color); 7179 if (t_colors < 16) 7180 i = (color == 0 || color == 4); 7181 else 7182 i = (color < 7 || color == 8); 7183 /* Set the 'background' option if the value is wrong. */ 7184 if (i != (*p_bg == 'd')) 7185 set_option_value((char_u *)"bg", 0L, 7186 i ? (char_u *)"dark" : (char_u *)"light", 0); 7187 } 7188 } 7189 } 7190 } 7191 } 7192 else if (STRCMP(key, "GUIFG") == 0) 7193 { 7194 #ifdef FEAT_GUI /* in non-GUI guifg colors are simply ignored */ 7195 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI)) 7196 { 7197 if (!init) 7198 HL_TABLE()[idx].sg_set |= SG_GUI; 7199 7200 i = color_name2handle(arg); 7201 if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use) 7202 { 7203 HL_TABLE()[idx].sg_gui_fg = i; 7204 vim_free(HL_TABLE()[idx].sg_gui_fg_name); 7205 if (STRCMP(arg, "NONE")) 7206 HL_TABLE()[idx].sg_gui_fg_name = vim_strsave(arg); 7207 else 7208 HL_TABLE()[idx].sg_gui_fg_name = NULL; 7209 # ifdef FEAT_GUI_X11 7210 if (is_menu_group) 7211 gui.menu_fg_pixel = i; 7212 if (is_scrollbar_group) 7213 gui.scroll_fg_pixel = i; 7214 # ifdef FEAT_BEVAL 7215 if (is_tooltip_group) 7216 gui.tooltip_fg_pixel = i; 7217 # endif 7218 do_colors = TRUE; 7219 # endif 7220 } 7221 } 7222 #endif 7223 } 7224 else if (STRCMP(key, "GUIBG") == 0) 7225 { 7226 #ifdef FEAT_GUI /* in non-GUI guibg colors are simply ignored */ 7227 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI)) 7228 { 7229 if (!init) 7230 HL_TABLE()[idx].sg_set |= SG_GUI; 7231 7232 i = color_name2handle(arg); 7233 if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use) 7234 { 7235 HL_TABLE()[idx].sg_gui_bg = i; 7236 vim_free(HL_TABLE()[idx].sg_gui_bg_name); 7237 if (STRCMP(arg, "NONE") != 0) 7238 HL_TABLE()[idx].sg_gui_bg_name = vim_strsave(arg); 7239 else 7240 HL_TABLE()[idx].sg_gui_bg_name = NULL; 7241 # ifdef FEAT_GUI_X11 7242 if (is_menu_group) 7243 gui.menu_bg_pixel = i; 7244 if (is_scrollbar_group) 7245 gui.scroll_bg_pixel = i; 7246 # ifdef FEAT_BEVAL 7247 if (is_tooltip_group) 7248 gui.tooltip_bg_pixel = i; 7249 # endif 7250 do_colors = TRUE; 7251 # endif 7252 } 7253 } 7254 #endif 7255 } 7256 else if (STRCMP(key, "GUISP") == 0) 7257 { 7258 #ifdef FEAT_GUI /* in non-GUI guisp colors are simply ignored */ 7259 if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI)) 7260 { 7261 if (!init) 7262 HL_TABLE()[idx].sg_set |= SG_GUI; 7263 7264 i = color_name2handle(arg); 7265 if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !gui.in_use) 7266 { 7267 HL_TABLE()[idx].sg_gui_sp = i; 7268 vim_free(HL_TABLE()[idx].sg_gui_sp_name); 7269 if (STRCMP(arg, "NONE") != 0) 7270 HL_TABLE()[idx].sg_gui_sp_name = vim_strsave(arg); 7271 else 7272 HL_TABLE()[idx].sg_gui_sp_name = NULL; 7273 } 7274 } 7275 #endif 7276 } 7277 else if (STRCMP(key, "START") == 0 || STRCMP(key, "STOP") == 0) 7278 { 7279 char_u buf[100]; 7280 char_u *tname; 7281 7282 if (!init) 7283 HL_TABLE()[idx].sg_set |= SG_TERM; 7284 7285 /* 7286 * The "start" and "stop" arguments can be a literal escape 7287 * sequence, or a comma separated list of terminal codes. 7288 */ 7289 if (STRNCMP(arg, "t_", 2) == 0) 7290 { 7291 off = 0; 7292 buf[0] = 0; 7293 while (arg[off] != NUL) 7294 { 7295 /* Isolate one termcap name */ 7296 for (len = 0; arg[off + len] && 7297 arg[off + len] != ','; ++len) 7298 ; 7299 tname = vim_strnsave(arg + off, len); 7300 if (tname == NULL) /* out of memory */ 7301 { 7302 error = TRUE; 7303 break; 7304 } 7305 /* lookup the escape sequence for the item */ 7306 p = get_term_code(tname); 7307 vim_free(tname); 7308 if (p == NULL) /* ignore non-existing things */ 7309 p = (char_u *)""; 7310 7311 /* Append it to the already found stuff */ 7312 if ((int)(STRLEN(buf) + STRLEN(p)) >= 99) 7313 { 7314 EMSG2(_("E422: terminal code too long: %s"), arg); 7315 error = TRUE; 7316 break; 7317 } 7318 STRCAT(buf, p); 7319 7320 /* Advance to the next item */ 7321 off += len; 7322 if (arg[off] == ',') /* another one follows */ 7323 ++off; 7324 } 7325 } 7326 else 7327 { 7328 /* 7329 * Copy characters from arg[] to buf[], translating <> codes. 7330 */ 7331 for (p = arg, off = 0; off < 100 && *p; ) 7332 { 7333 len = trans_special(&p, buf + off, FALSE); 7334 if (len) /* recognized special char */ 7335 off += len; 7336 else /* copy as normal char */ 7337 buf[off++] = *p++; 7338 } 7339 buf[off] = NUL; 7340 } 7341 if (error) 7342 break; 7343 7344 if (STRCMP(buf, "NONE") == 0) /* resetting the value */ 7345 p = NULL; 7346 else 7347 p = vim_strsave(buf); 7348 if (key[2] == 'A') 7349 { 7350 vim_free(HL_TABLE()[idx].sg_start); 7351 HL_TABLE()[idx].sg_start = p; 7352 } 7353 else 7354 { 7355 vim_free(HL_TABLE()[idx].sg_stop); 7356 HL_TABLE()[idx].sg_stop = p; 7357 } 7358 } 7359 else 7360 { 7361 EMSG2(_("E423: Illegal argument: %s"), key_start); 7362 error = TRUE; 7363 break; 7364 } 7365 7366 /* 7367 * When highlighting has been given for a group, don't link it. 7368 */ 7369 if (!init || !(HL_TABLE()[idx].sg_set & SG_LINK)) 7370 HL_TABLE()[idx].sg_link = 0; 7371 7372 /* 7373 * Continue with next argument. 7374 */ 7375 linep = skipwhite(linep); 7376 } 7377 7378 /* 7379 * If there is an error, and it's a new entry, remove it from the table. 7380 */ 7381 if (error && idx == highlight_ga.ga_len) 7382 syn_unadd_group(); 7383 else 7384 { 7385 if (is_normal_group) 7386 { 7387 HL_TABLE()[idx].sg_term_attr = 0; 7388 HL_TABLE()[idx].sg_cterm_attr = 0; 7389 #ifdef FEAT_GUI 7390 HL_TABLE()[idx].sg_gui_attr = 0; 7391 /* 7392 * Need to update all groups, because they might be using "bg" 7393 * and/or "fg", which have been changed now. 7394 */ 7395 if (gui.in_use) 7396 highlight_gui_started(); 7397 #endif 7398 } 7399 #ifdef FEAT_GUI_X11 7400 # ifdef FEAT_MENU 7401 else if (is_menu_group) 7402 { 7403 if (gui.in_use && do_colors) 7404 gui_mch_new_menu_colors(); 7405 } 7406 # endif 7407 else if (is_scrollbar_group) 7408 { 7409 if (gui.in_use && do_colors) 7410 gui_new_scrollbar_colors(); 7411 } 7412 # ifdef FEAT_BEVAL 7413 else if (is_tooltip_group) 7414 { 7415 if (gui.in_use && do_colors) 7416 gui_mch_new_tooltip_colors(); 7417 } 7418 # endif 7419 #endif 7420 else 7421 set_hl_attr(idx); 7422 #ifdef FEAT_EVAL 7423 HL_TABLE()[idx].sg_scriptID = current_SID; 7424 #endif 7425 redraw_all_later(NOT_VALID); 7426 } 7427 vim_free(key); 7428 vim_free(arg); 7429 7430 /* Only call highlight_changed() once, after sourcing a syntax file */ 7431 need_highlight_changed = TRUE; 7432 } 7433 7434 #if defined(EXITFREE) || defined(PROTO) 7435 void 7436 free_highlight() 7437 { 7438 int i; 7439 7440 for (i = 0; i < highlight_ga.ga_len; ++i) 7441 { 7442 highlight_clear(i); 7443 vim_free(HL_TABLE()[i].sg_name); 7444 vim_free(HL_TABLE()[i].sg_name_u); 7445 } 7446 ga_clear(&highlight_ga); 7447 } 7448 #endif 7449 7450 /* 7451 * Reset the cterm colors to what they were before Vim was started, if 7452 * possible. Otherwise reset them to zero. 7453 */ 7454 void 7455 restore_cterm_colors() 7456 { 7457 #if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32)) 7458 /* Since t_me has been set, this probably means that the user 7459 * wants to use this as default colors. Need to reset default 7460 * background/foreground colors. */ 7461 mch_set_normal_colors(); 7462 #else 7463 cterm_normal_fg_color = 0; 7464 cterm_normal_fg_bold = 0; 7465 cterm_normal_bg_color = 0; 7466 #endif 7467 } 7468 7469 /* 7470 * Return TRUE if highlight group "idx" has any settings. 7471 * When "check_link" is TRUE also check for an existing link. 7472 */ 7473 static int 7474 hl_has_settings(idx, check_link) 7475 int idx; 7476 int check_link; 7477 { 7478 return ( HL_TABLE()[idx].sg_term_attr != 0 7479 || HL_TABLE()[idx].sg_cterm_attr != 0 7480 #ifdef FEAT_GUI 7481 || HL_TABLE()[idx].sg_gui_attr != 0 7482 #endif 7483 || (check_link && (HL_TABLE()[idx].sg_set & SG_LINK))); 7484 } 7485 7486 /* 7487 * Clear highlighting for one group. 7488 */ 7489 static void 7490 highlight_clear(idx) 7491 int idx; 7492 { 7493 HL_TABLE()[idx].sg_term = 0; 7494 vim_free(HL_TABLE()[idx].sg_start); 7495 HL_TABLE()[idx].sg_start = NULL; 7496 vim_free(HL_TABLE()[idx].sg_stop); 7497 HL_TABLE()[idx].sg_stop = NULL; 7498 HL_TABLE()[idx].sg_term_attr = 0; 7499 HL_TABLE()[idx].sg_cterm = 0; 7500 HL_TABLE()[idx].sg_cterm_bold = FALSE; 7501 HL_TABLE()[idx].sg_cterm_fg = 0; 7502 HL_TABLE()[idx].sg_cterm_bg = 0; 7503 HL_TABLE()[idx].sg_cterm_attr = 0; 7504 #ifdef FEAT_GUI /* in non-GUI fonts are simply ignored */ 7505 HL_TABLE()[idx].sg_gui = 0; 7506 HL_TABLE()[idx].sg_gui_fg = INVALCOLOR; 7507 vim_free(HL_TABLE()[idx].sg_gui_fg_name); 7508 HL_TABLE()[idx].sg_gui_fg_name = NULL; 7509 HL_TABLE()[idx].sg_gui_bg = INVALCOLOR; 7510 vim_free(HL_TABLE()[idx].sg_gui_bg_name); 7511 HL_TABLE()[idx].sg_gui_bg_name = NULL; 7512 HL_TABLE()[idx].sg_gui_sp = INVALCOLOR; 7513 vim_free(HL_TABLE()[idx].sg_gui_sp_name); 7514 HL_TABLE()[idx].sg_gui_sp_name = NULL; 7515 gui_mch_free_font(HL_TABLE()[idx].sg_font); 7516 HL_TABLE()[idx].sg_font = NOFONT; 7517 # ifdef FEAT_XFONTSET 7518 gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset); 7519 HL_TABLE()[idx].sg_fontset = NOFONTSET; 7520 # endif 7521 vim_free(HL_TABLE()[idx].sg_font_name); 7522 HL_TABLE()[idx].sg_font_name = NULL; 7523 HL_TABLE()[idx].sg_gui_attr = 0; 7524 #endif 7525 #ifdef FEAT_EVAL 7526 /* Clear the script ID only when there is no link, since that is not 7527 * cleared. */ 7528 if (HL_TABLE()[idx].sg_link == 0) 7529 HL_TABLE()[idx].sg_scriptID = 0; 7530 #endif 7531 } 7532 7533 #if defined(FEAT_GUI) || defined(PROTO) 7534 /* 7535 * Set the normal foreground and background colors according to the "Normal" 7536 * highlighighting group. For X11 also set "Menu", "Scrollbar", and 7537 * "Tooltip" colors. 7538 */ 7539 void 7540 set_normal_colors() 7541 { 7542 if (set_group_colors((char_u *)"Normal", 7543 &gui.norm_pixel, &gui.back_pixel, 7544 FALSE, TRUE, FALSE)) 7545 { 7546 gui_mch_new_colors(); 7547 must_redraw = CLEAR; 7548 } 7549 #ifdef FEAT_GUI_X11 7550 if (set_group_colors((char_u *)"Menu", 7551 &gui.menu_fg_pixel, &gui.menu_bg_pixel, 7552 TRUE, FALSE, FALSE)) 7553 { 7554 # ifdef FEAT_MENU 7555 gui_mch_new_menu_colors(); 7556 # endif 7557 must_redraw = CLEAR; 7558 } 7559 # ifdef FEAT_BEVAL 7560 if (set_group_colors((char_u *)"Tooltip", 7561 &gui.tooltip_fg_pixel, &gui.tooltip_bg_pixel, 7562 FALSE, FALSE, TRUE)) 7563 { 7564 # ifdef FEAT_TOOLBAR 7565 gui_mch_new_tooltip_colors(); 7566 # endif 7567 must_redraw = CLEAR; 7568 } 7569 #endif 7570 if (set_group_colors((char_u *)"Scrollbar", 7571 &gui.scroll_fg_pixel, &gui.scroll_bg_pixel, 7572 FALSE, FALSE, FALSE)) 7573 { 7574 gui_new_scrollbar_colors(); 7575 must_redraw = CLEAR; 7576 } 7577 #endif 7578 } 7579 7580 /* 7581 * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar". 7582 */ 7583 static int 7584 set_group_colors(name, fgp, bgp, do_menu, use_norm, do_tooltip) 7585 char_u *name; 7586 guicolor_T *fgp; 7587 guicolor_T *bgp; 7588 int do_menu; 7589 int use_norm; 7590 int do_tooltip; 7591 { 7592 int idx; 7593 7594 idx = syn_name2id(name) - 1; 7595 if (idx >= 0) 7596 { 7597 gui_do_one_color(idx, do_menu, do_tooltip); 7598 7599 if (HL_TABLE()[idx].sg_gui_fg != INVALCOLOR) 7600 *fgp = HL_TABLE()[idx].sg_gui_fg; 7601 else if (use_norm) 7602 *fgp = gui.def_norm_pixel; 7603 if (HL_TABLE()[idx].sg_gui_bg != INVALCOLOR) 7604 *bgp = HL_TABLE()[idx].sg_gui_bg; 7605 else if (use_norm) 7606 *bgp = gui.def_back_pixel; 7607 return TRUE; 7608 } 7609 return FALSE; 7610 } 7611 7612 /* 7613 * Get the font of the "Normal" group. 7614 * Returns "" when it's not found or not set. 7615 */ 7616 char_u * 7617 hl_get_font_name() 7618 { 7619 int id; 7620 char_u *s; 7621 7622 id = syn_name2id((char_u *)"Normal"); 7623 if (id > 0) 7624 { 7625 s = HL_TABLE()[id - 1].sg_font_name; 7626 if (s != NULL) 7627 return s; 7628 } 7629 return (char_u *)""; 7630 } 7631 7632 /* 7633 * Set font for "Normal" group. Called by gui_mch_init_font() when a font has 7634 * actually chosen to be used. 7635 */ 7636 void 7637 hl_set_font_name(font_name) 7638 char_u *font_name; 7639 { 7640 int id; 7641 7642 id = syn_name2id((char_u *)"Normal"); 7643 if (id > 0) 7644 { 7645 vim_free(HL_TABLE()[id - 1].sg_font_name); 7646 HL_TABLE()[id - 1].sg_font_name = vim_strsave(font_name); 7647 } 7648 } 7649 7650 /* 7651 * Set background color for "Normal" group. Called by gui_set_bg_color() 7652 * when the color is known. 7653 */ 7654 void 7655 hl_set_bg_color_name(name) 7656 char_u *name; /* must have been allocated */ 7657 { 7658 int id; 7659 7660 if (name != NULL) 7661 { 7662 id = syn_name2id((char_u *)"Normal"); 7663 if (id > 0) 7664 { 7665 vim_free(HL_TABLE()[id - 1].sg_gui_bg_name); 7666 HL_TABLE()[id - 1].sg_gui_bg_name = name; 7667 } 7668 } 7669 } 7670 7671 /* 7672 * Set foreground color for "Normal" group. Called by gui_set_fg_color() 7673 * when the color is known. 7674 */ 7675 void 7676 hl_set_fg_color_name(name) 7677 char_u *name; /* must have been allocated */ 7678 { 7679 int id; 7680 7681 if (name != NULL) 7682 { 7683 id = syn_name2id((char_u *)"Normal"); 7684 if (id > 0) 7685 { 7686 vim_free(HL_TABLE()[id - 1].sg_gui_fg_name); 7687 HL_TABLE()[id - 1].sg_gui_fg_name = name; 7688 } 7689 } 7690 } 7691 7692 /* 7693 * Return the handle for a color name. 7694 * Returns INVALCOLOR when failed. 7695 */ 7696 static guicolor_T 7697 color_name2handle(name) 7698 char_u *name; 7699 { 7700 if (STRCMP(name, "NONE") == 0) 7701 return INVALCOLOR; 7702 7703 if (STRICMP(name, "fg") == 0 || STRICMP(name, "foreground") == 0) 7704 return gui.norm_pixel; 7705 if (STRICMP(name, "bg") == 0 || STRICMP(name, "background") == 0) 7706 return gui.back_pixel; 7707 7708 return gui_get_color(name); 7709 } 7710 7711 /* 7712 * Return the handle for a font name. 7713 * Returns NOFONT when failed. 7714 */ 7715 static GuiFont 7716 font_name2handle(name) 7717 char_u *name; 7718 { 7719 if (STRCMP(name, "NONE") == 0) 7720 return NOFONT; 7721 7722 return gui_mch_get_font(name, TRUE); 7723 } 7724 7725 # ifdef FEAT_XFONTSET 7726 /* 7727 * Return the handle for a fontset name. 7728 * Returns NOFONTSET when failed. 7729 */ 7730 static GuiFontset 7731 fontset_name2handle(name, fixed_width) 7732 char_u *name; 7733 int fixed_width; 7734 { 7735 if (STRCMP(name, "NONE") == 0) 7736 return NOFONTSET; 7737 7738 return gui_mch_get_fontset(name, TRUE, fixed_width); 7739 } 7740 # endif 7741 7742 /* 7743 * Get the font or fontset for one highlight group. 7744 */ 7745 /*ARGSUSED*/ 7746 static void 7747 hl_do_font(idx, arg, do_normal, do_menu, do_tooltip) 7748 int idx; 7749 char_u *arg; 7750 int do_normal; /* set normal font */ 7751 int do_menu; /* set menu font */ 7752 int do_tooltip; /* set tooltip font */ 7753 { 7754 # ifdef FEAT_XFONTSET 7755 /* If 'guifontset' is not empty, first try using the name as a 7756 * fontset. If that doesn't work, use it as a font name. */ 7757 if (*p_guifontset != NUL 7758 # ifdef FONTSET_ALWAYS 7759 || do_menu 7760 # endif 7761 # ifdef FEAT_BEVAL_TIP 7762 /* In Athena & Motif, the Tooltip highlight group is always a fontset */ 7763 || do_tooltip 7764 # endif 7765 ) 7766 HL_TABLE()[idx].sg_fontset = fontset_name2handle(arg, 0 7767 # ifdef FONTSET_ALWAYS 7768 || do_menu 7769 # endif 7770 # ifdef FEAT_BEVAL_TIP 7771 || do_tooltip 7772 # endif 7773 ); 7774 if (HL_TABLE()[idx].sg_fontset != NOFONTSET) 7775 { 7776 /* If it worked and it's the Normal group, use it as the 7777 * normal fontset. Same for the Menu group. */ 7778 if (do_normal) 7779 gui_init_font(arg, TRUE); 7780 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU) 7781 if (do_menu) 7782 { 7783 # ifdef FONTSET_ALWAYS 7784 gui.menu_fontset = HL_TABLE()[idx].sg_fontset; 7785 # else 7786 /* YIKES! This is a bug waiting to crash the program */ 7787 gui.menu_font = HL_TABLE()[idx].sg_fontset; 7788 # endif 7789 gui_mch_new_menu_font(); 7790 } 7791 # ifdef FEAT_BEVAL 7792 if (do_tooltip) 7793 { 7794 /* The Athena widget set cannot currently handle switching between 7795 * displaying a single font and a fontset. 7796 * If the XtNinternational resource is set to True at widget 7797 * creation, then a fontset is always used, otherwise an 7798 * XFontStruct is used. 7799 */ 7800 gui.tooltip_fontset = (XFontSet)HL_TABLE()[idx].sg_fontset; 7801 gui_mch_new_tooltip_font(); 7802 } 7803 # endif 7804 # endif 7805 } 7806 else 7807 # endif 7808 { 7809 HL_TABLE()[idx].sg_font = font_name2handle(arg); 7810 /* If it worked and it's the Normal group, use it as the 7811 * normal font. Same for the Menu group. */ 7812 if (HL_TABLE()[idx].sg_font != NOFONT) 7813 { 7814 if (do_normal) 7815 gui_init_font(arg, FALSE); 7816 #ifndef FONTSET_ALWAYS 7817 # if (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)) && defined(FEAT_MENU) 7818 if (do_menu) 7819 { 7820 gui.menu_font = HL_TABLE()[idx].sg_font; 7821 gui_mch_new_menu_font(); 7822 } 7823 # endif 7824 #endif 7825 } 7826 } 7827 } 7828 7829 #endif /* FEAT_GUI */ 7830 7831 /* 7832 * Table with the specifications for an attribute number. 7833 * Note that this table is used by ALL buffers. This is required because the 7834 * GUI can redraw at any time for any buffer. 7835 */ 7836 static garray_T term_attr_table = {0, 0, 0, 0, NULL}; 7837 7838 #define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx] 7839 7840 static garray_T cterm_attr_table = {0, 0, 0, 0, NULL}; 7841 7842 #define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx] 7843 7844 #ifdef FEAT_GUI 7845 static garray_T gui_attr_table = {0, 0, 0, 0, NULL}; 7846 7847 #define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx] 7848 #endif 7849 7850 /* 7851 * Return the attr number for a set of colors and font. 7852 * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table 7853 * if the combination is new. 7854 * Return 0 for error (no more room). 7855 */ 7856 static int 7857 get_attr_entry(table, aep) 7858 garray_T *table; 7859 attrentry_T *aep; 7860 { 7861 int i; 7862 attrentry_T *taep; 7863 static int recursive = FALSE; 7864 7865 /* 7866 * Init the table, in case it wasn't done yet. 7867 */ 7868 table->ga_itemsize = sizeof(attrentry_T); 7869 table->ga_growsize = 7; 7870 7871 /* 7872 * Try to find an entry with the same specifications. 7873 */ 7874 for (i = 0; i < table->ga_len; ++i) 7875 { 7876 taep = &(((attrentry_T *)table->ga_data)[i]); 7877 if ( aep->ae_attr == taep->ae_attr 7878 && ( 7879 #ifdef FEAT_GUI 7880 (table == &gui_attr_table 7881 && (aep->ae_u.gui.fg_color == taep->ae_u.gui.fg_color 7882 && aep->ae_u.gui.bg_color 7883 == taep->ae_u.gui.bg_color 7884 && aep->ae_u.gui.sp_color 7885 == taep->ae_u.gui.sp_color 7886 && aep->ae_u.gui.font == taep->ae_u.gui.font 7887 # ifdef FEAT_XFONTSET 7888 && aep->ae_u.gui.fontset == taep->ae_u.gui.fontset 7889 # endif 7890 )) 7891 || 7892 #endif 7893 (table == &term_attr_table 7894 && (aep->ae_u.term.start == NULL) 7895 == (taep->ae_u.term.start == NULL) 7896 && (aep->ae_u.term.start == NULL 7897 || STRCMP(aep->ae_u.term.start, 7898 taep->ae_u.term.start) == 0) 7899 && (aep->ae_u.term.stop == NULL) 7900 == (taep->ae_u.term.stop == NULL) 7901 && (aep->ae_u.term.stop == NULL 7902 || STRCMP(aep->ae_u.term.stop, 7903 taep->ae_u.term.stop) == 0)) 7904 || (table == &cterm_attr_table 7905 && aep->ae_u.cterm.fg_color 7906 == taep->ae_u.cterm.fg_color 7907 && aep->ae_u.cterm.bg_color 7908 == taep->ae_u.cterm.bg_color) 7909 )) 7910 7911 return i + ATTR_OFF; 7912 } 7913 7914 if (table->ga_len + ATTR_OFF > MAX_TYPENR) 7915 { 7916 /* 7917 * Running out of attribute entries! remove all attributes, and 7918 * compute new ones for all groups. 7919 * When called recursively, we are really out of numbers. 7920 */ 7921 if (recursive) 7922 { 7923 EMSG(_("E424: Too many different highlighting attributes in use")); 7924 return 0; 7925 } 7926 recursive = TRUE; 7927 7928 clear_hl_tables(); 7929 7930 must_redraw = CLEAR; 7931 7932 for (i = 0; i < highlight_ga.ga_len; ++i) 7933 set_hl_attr(i); 7934 7935 recursive = FALSE; 7936 } 7937 7938 /* 7939 * This is a new combination of colors and font, add an entry. 7940 */ 7941 if (ga_grow(table, 1) == FAIL) 7942 return 0; 7943 7944 taep = &(((attrentry_T *)table->ga_data)[table->ga_len]); 7945 vim_memset(taep, 0, sizeof(attrentry_T)); 7946 taep->ae_attr = aep->ae_attr; 7947 #ifdef FEAT_GUI 7948 if (table == &gui_attr_table) 7949 { 7950 taep->ae_u.gui.fg_color = aep->ae_u.gui.fg_color; 7951 taep->ae_u.gui.bg_color = aep->ae_u.gui.bg_color; 7952 taep->ae_u.gui.sp_color = aep->ae_u.gui.sp_color; 7953 taep->ae_u.gui.font = aep->ae_u.gui.font; 7954 # ifdef FEAT_XFONTSET 7955 taep->ae_u.gui.fontset = aep->ae_u.gui.fontset; 7956 # endif 7957 } 7958 #endif 7959 if (table == &term_attr_table) 7960 { 7961 if (aep->ae_u.term.start == NULL) 7962 taep->ae_u.term.start = NULL; 7963 else 7964 taep->ae_u.term.start = vim_strsave(aep->ae_u.term.start); 7965 if (aep->ae_u.term.stop == NULL) 7966 taep->ae_u.term.stop = NULL; 7967 else 7968 taep->ae_u.term.stop = vim_strsave(aep->ae_u.term.stop); 7969 } 7970 else if (table == &cterm_attr_table) 7971 { 7972 taep->ae_u.cterm.fg_color = aep->ae_u.cterm.fg_color; 7973 taep->ae_u.cterm.bg_color = aep->ae_u.cterm.bg_color; 7974 } 7975 ++table->ga_len; 7976 return (table->ga_len - 1 + ATTR_OFF); 7977 } 7978 7979 /* 7980 * Clear all highlight tables. 7981 */ 7982 void 7983 clear_hl_tables() 7984 { 7985 int i; 7986 attrentry_T *taep; 7987 7988 #ifdef FEAT_GUI 7989 ga_clear(&gui_attr_table); 7990 #endif 7991 for (i = 0; i < term_attr_table.ga_len; ++i) 7992 { 7993 taep = &(((attrentry_T *)term_attr_table.ga_data)[i]); 7994 vim_free(taep->ae_u.term.start); 7995 vim_free(taep->ae_u.term.stop); 7996 } 7997 ga_clear(&term_attr_table); 7998 ga_clear(&cterm_attr_table); 7999 } 8000 8001 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO) 8002 /* 8003 * Combine special attributes (e.g., for spelling) with other attributes 8004 * (e.g., for syntax highlighting). 8005 * "prim_attr" overrules "char_attr". 8006 * This creates a new group when required. 8007 * Since we expect there to be few spelling mistakes we don't cache the 8008 * result. 8009 * Return the resulting attributes. 8010 */ 8011 int 8012 hl_combine_attr(char_attr, prim_attr) 8013 int char_attr; 8014 int prim_attr; 8015 { 8016 attrentry_T *char_aep = NULL; 8017 attrentry_T *spell_aep; 8018 attrentry_T new_en; 8019 8020 if (char_attr == 0) 8021 return prim_attr; 8022 if (char_attr <= HL_ALL && prim_attr <= HL_ALL) 8023 return char_attr | prim_attr; 8024 #ifdef FEAT_GUI 8025 if (gui.in_use) 8026 { 8027 if (char_attr > HL_ALL) 8028 char_aep = syn_gui_attr2entry(char_attr); 8029 if (char_aep != NULL) 8030 new_en = *char_aep; 8031 else 8032 { 8033 vim_memset(&new_en, 0, sizeof(new_en)); 8034 new_en.ae_u.gui.fg_color = INVALCOLOR; 8035 new_en.ae_u.gui.bg_color = INVALCOLOR; 8036 new_en.ae_u.gui.sp_color = INVALCOLOR; 8037 if (char_attr <= HL_ALL) 8038 new_en.ae_attr = char_attr; 8039 } 8040 8041 if (prim_attr <= HL_ALL) 8042 new_en.ae_attr |= prim_attr; 8043 else 8044 { 8045 spell_aep = syn_gui_attr2entry(prim_attr); 8046 if (spell_aep != NULL) 8047 { 8048 new_en.ae_attr |= spell_aep->ae_attr; 8049 if (spell_aep->ae_u.gui.fg_color != INVALCOLOR) 8050 new_en.ae_u.gui.fg_color = spell_aep->ae_u.gui.fg_color; 8051 if (spell_aep->ae_u.gui.bg_color != INVALCOLOR) 8052 new_en.ae_u.gui.bg_color = spell_aep->ae_u.gui.bg_color; 8053 if (spell_aep->ae_u.gui.sp_color != INVALCOLOR) 8054 new_en.ae_u.gui.sp_color = spell_aep->ae_u.gui.sp_color; 8055 if (spell_aep->ae_u.gui.font != NOFONT) 8056 new_en.ae_u.gui.font = spell_aep->ae_u.gui.font; 8057 # ifdef FEAT_XFONTSET 8058 if (spell_aep->ae_u.gui.fontset != NOFONTSET) 8059 new_en.ae_u.gui.fontset = spell_aep->ae_u.gui.fontset; 8060 # endif 8061 } 8062 } 8063 return get_attr_entry(&gui_attr_table, &new_en); 8064 } 8065 #endif 8066 8067 if (t_colors > 1) 8068 { 8069 if (char_attr > HL_ALL) 8070 char_aep = syn_cterm_attr2entry(char_attr); 8071 if (char_aep != NULL) 8072 new_en = *char_aep; 8073 else 8074 { 8075 vim_memset(&new_en, 0, sizeof(new_en)); 8076 if (char_attr <= HL_ALL) 8077 new_en.ae_attr = char_attr; 8078 } 8079 8080 if (prim_attr <= HL_ALL) 8081 new_en.ae_attr |= prim_attr; 8082 else 8083 { 8084 spell_aep = syn_cterm_attr2entry(prim_attr); 8085 if (spell_aep != NULL) 8086 { 8087 new_en.ae_attr |= spell_aep->ae_attr; 8088 if (spell_aep->ae_u.cterm.fg_color > 0) 8089 new_en.ae_u.cterm.fg_color = spell_aep->ae_u.cterm.fg_color; 8090 if (spell_aep->ae_u.cterm.bg_color > 0) 8091 new_en.ae_u.cterm.bg_color = spell_aep->ae_u.cterm.bg_color; 8092 } 8093 } 8094 return get_attr_entry(&cterm_attr_table, &new_en); 8095 } 8096 8097 if (char_attr > HL_ALL) 8098 char_aep = syn_term_attr2entry(char_attr); 8099 if (char_aep != NULL) 8100 new_en = *char_aep; 8101 else 8102 { 8103 vim_memset(&new_en, 0, sizeof(new_en)); 8104 if (char_attr <= HL_ALL) 8105 new_en.ae_attr = char_attr; 8106 } 8107 8108 if (prim_attr <= HL_ALL) 8109 new_en.ae_attr |= prim_attr; 8110 else 8111 { 8112 spell_aep = syn_term_attr2entry(prim_attr); 8113 if (spell_aep != NULL) 8114 { 8115 new_en.ae_attr |= spell_aep->ae_attr; 8116 if (spell_aep->ae_u.term.start != NULL) 8117 { 8118 new_en.ae_u.term.start = spell_aep->ae_u.term.start; 8119 new_en.ae_u.term.stop = spell_aep->ae_u.term.stop; 8120 } 8121 } 8122 } 8123 return get_attr_entry(&term_attr_table, &new_en); 8124 } 8125 #endif 8126 8127 #ifdef FEAT_GUI 8128 8129 attrentry_T * 8130 syn_gui_attr2entry(attr) 8131 int attr; 8132 { 8133 attr -= ATTR_OFF; 8134 if (attr >= gui_attr_table.ga_len) /* did ":syntax clear" */ 8135 return NULL; 8136 return &(GUI_ATTR_ENTRY(attr)); 8137 } 8138 #endif /* FEAT_GUI */ 8139 8140 /* 8141 * Get the highlight attributes (HL_BOLD etc.) from an attribute nr. 8142 * Only to be used when "attr" > HL_ALL. 8143 */ 8144 int 8145 syn_attr2attr(attr) 8146 int attr; 8147 { 8148 attrentry_T *aep; 8149 8150 #ifdef FEAT_GUI 8151 if (gui.in_use) 8152 aep = syn_gui_attr2entry(attr); 8153 else 8154 #endif 8155 if (t_colors > 1) 8156 aep = syn_cterm_attr2entry(attr); 8157 else 8158 aep = syn_term_attr2entry(attr); 8159 8160 if (aep == NULL) /* highlighting not set */ 8161 return 0; 8162 return aep->ae_attr; 8163 } 8164 8165 8166 attrentry_T * 8167 syn_term_attr2entry(attr) 8168 int attr; 8169 { 8170 attr -= ATTR_OFF; 8171 if (attr >= term_attr_table.ga_len) /* did ":syntax clear" */ 8172 return NULL; 8173 return &(TERM_ATTR_ENTRY(attr)); 8174 } 8175 8176 attrentry_T * 8177 syn_cterm_attr2entry(attr) 8178 int attr; 8179 { 8180 attr -= ATTR_OFF; 8181 if (attr >= cterm_attr_table.ga_len) /* did ":syntax clear" */ 8182 return NULL; 8183 return &(CTERM_ATTR_ENTRY(attr)); 8184 } 8185 8186 #define LIST_ATTR 1 8187 #define LIST_STRING 2 8188 #define LIST_INT 3 8189 8190 static void 8191 highlight_list_one(id) 8192 int id; 8193 { 8194 struct hl_group *sgp; 8195 int didh = FALSE; 8196 8197 sgp = &HL_TABLE()[id - 1]; /* index is ID minus one */ 8198 8199 didh = highlight_list_arg(id, didh, LIST_ATTR, 8200 sgp->sg_term, NULL, "term"); 8201 didh = highlight_list_arg(id, didh, LIST_STRING, 8202 0, sgp->sg_start, "start"); 8203 didh = highlight_list_arg(id, didh, LIST_STRING, 8204 0, sgp->sg_stop, "stop"); 8205 8206 didh = highlight_list_arg(id, didh, LIST_ATTR, 8207 sgp->sg_cterm, NULL, "cterm"); 8208 didh = highlight_list_arg(id, didh, LIST_INT, 8209 sgp->sg_cterm_fg, NULL, "ctermfg"); 8210 didh = highlight_list_arg(id, didh, LIST_INT, 8211 sgp->sg_cterm_bg, NULL, "ctermbg"); 8212 8213 #ifdef FEAT_GUI 8214 didh = highlight_list_arg(id, didh, LIST_ATTR, 8215 sgp->sg_gui, NULL, "gui"); 8216 didh = highlight_list_arg(id, didh, LIST_STRING, 8217 0, sgp->sg_gui_fg_name, "guifg"); 8218 didh = highlight_list_arg(id, didh, LIST_STRING, 8219 0, sgp->sg_gui_bg_name, "guibg"); 8220 didh = highlight_list_arg(id, didh, LIST_STRING, 8221 0, sgp->sg_gui_sp_name, "guisp"); 8222 didh = highlight_list_arg(id, didh, LIST_STRING, 8223 0, sgp->sg_font_name, "font"); 8224 #endif 8225 8226 if (sgp->sg_link && !got_int) 8227 { 8228 (void)syn_list_header(didh, 9999, id); 8229 didh = TRUE; 8230 msg_puts_attr((char_u *)"links to", hl_attr(HLF_D)); 8231 msg_putchar(' '); 8232 msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name); 8233 } 8234 8235 if (!didh) 8236 highlight_list_arg(id, didh, LIST_STRING, 0, (char_u *)"cleared", ""); 8237 #ifdef FEAT_EVAL 8238 if (p_verbose > 0) 8239 last_set_msg(sgp->sg_scriptID); 8240 #endif 8241 } 8242 8243 static int 8244 highlight_list_arg(id, didh, type, iarg, sarg, name) 8245 int id; 8246 int didh; 8247 int type; 8248 int iarg; 8249 char_u *sarg; 8250 char *name; 8251 { 8252 char_u buf[100]; 8253 char_u *ts; 8254 int i; 8255 8256 if (got_int) 8257 return FALSE; 8258 if (type == LIST_STRING ? (sarg != NULL) : (iarg != 0)) 8259 { 8260 ts = buf; 8261 if (type == LIST_INT) 8262 sprintf((char *)buf, "%d", iarg - 1); 8263 else if (type == LIST_STRING) 8264 ts = sarg; 8265 else /* type == LIST_ATTR */ 8266 { 8267 buf[0] = NUL; 8268 for (i = 0; hl_attr_table[i] != 0; ++i) 8269 { 8270 if (iarg & hl_attr_table[i]) 8271 { 8272 if (buf[0] != NUL) 8273 STRCAT(buf, ","); 8274 STRCAT(buf, hl_name_table[i]); 8275 iarg &= ~hl_attr_table[i]; /* don't want "inverse" */ 8276 } 8277 } 8278 } 8279 8280 (void)syn_list_header(didh, 8281 (int)(vim_strsize(ts) + STRLEN(name) + 1), id); 8282 didh = TRUE; 8283 if (!got_int) 8284 { 8285 if (*name != NUL) 8286 { 8287 MSG_PUTS_ATTR(name, hl_attr(HLF_D)); 8288 MSG_PUTS_ATTR("=", hl_attr(HLF_D)); 8289 } 8290 msg_outtrans(ts); 8291 } 8292 } 8293 return didh; 8294 } 8295 8296 #if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO) 8297 /* 8298 * Return "1" if highlight group "id" has attribute "flag". 8299 * Return NULL otherwise. 8300 */ 8301 char_u * 8302 highlight_has_attr(id, flag, modec) 8303 int id; 8304 int flag; 8305 int modec; /* 'g' for GUI, 'c' for cterm, 't' for term */ 8306 { 8307 int attr; 8308 8309 if (id <= 0 || id > highlight_ga.ga_len) 8310 return NULL; 8311 8312 #ifdef FEAT_GUI 8313 if (modec == 'g') 8314 attr = HL_TABLE()[id - 1].sg_gui; 8315 else 8316 #endif 8317 if (modec == 'c') 8318 attr = HL_TABLE()[id - 1].sg_cterm; 8319 else 8320 attr = HL_TABLE()[id - 1].sg_term; 8321 8322 if (attr & flag) 8323 return (char_u *)"1"; 8324 return NULL; 8325 } 8326 #endif 8327 8328 #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO) 8329 /* 8330 * Return color name of highlight group "id". 8331 */ 8332 char_u * 8333 highlight_color(id, what, modec) 8334 int id; 8335 char_u *what; /* "fg", "bg", "sp", "fg#", "bg#" or "sp#" */ 8336 int modec; /* 'g' for GUI, 'c' for cterm, 't' for term */ 8337 { 8338 static char_u name[20]; 8339 int n; 8340 int fg = FALSE; 8341 # ifdef FEAT_GUI 8342 int sp = FALSE; 8343 # endif 8344 8345 if (id <= 0 || id > highlight_ga.ga_len) 8346 return NULL; 8347 8348 if (TOLOWER_ASC(what[0]) == 'f') 8349 fg = TRUE; 8350 # ifdef FEAT_GUI 8351 else if (TOLOWER_ASC(what[0]) == 's') 8352 sp = TRUE; 8353 if (modec == 'g') 8354 { 8355 /* return #RRGGBB form (only possible when GUI is running) */ 8356 if (gui.in_use && what[1] && what[2] == '#') 8357 { 8358 guicolor_T color; 8359 long_u rgb; 8360 static char_u buf[10]; 8361 8362 if (fg) 8363 color = HL_TABLE()[id - 1].sg_gui_fg; 8364 else if (sp) 8365 color = HL_TABLE()[id - 1].sg_gui_sp; 8366 else 8367 color = HL_TABLE()[id - 1].sg_gui_bg; 8368 if (color == INVALCOLOR) 8369 return NULL; 8370 rgb = gui_mch_get_rgb(color); 8371 sprintf((char *)buf, "#%02x%02x%02x", 8372 (unsigned)(rgb >> 16), 8373 (unsigned)(rgb >> 8) & 255, 8374 (unsigned)rgb & 255); 8375 return buf; 8376 } 8377 if (fg) 8378 return (HL_TABLE()[id - 1].sg_gui_fg_name); 8379 if (sp) 8380 return (HL_TABLE()[id - 1].sg_gui_sp_name); 8381 return (HL_TABLE()[id - 1].sg_gui_bg_name); 8382 } 8383 # endif 8384 if (modec == 'c') 8385 { 8386 if (fg) 8387 n = HL_TABLE()[id - 1].sg_cterm_fg - 1; 8388 else 8389 n = HL_TABLE()[id - 1].sg_cterm_bg - 1; 8390 sprintf((char *)name, "%d", n); 8391 return name; 8392 } 8393 /* term doesn't have color */ 8394 return NULL; 8395 } 8396 #endif 8397 8398 #if (defined(FEAT_SYN_HL) && defined(FEAT_GUI) && defined(FEAT_PRINTER)) \ 8399 || defined(PROTO) 8400 /* 8401 * Return color name of highlight group "id" as RGB value. 8402 */ 8403 long_u 8404 highlight_gui_color_rgb(id, fg) 8405 int id; 8406 int fg; /* TRUE = fg, FALSE = bg */ 8407 { 8408 guicolor_T color; 8409 8410 if (id <= 0 || id > highlight_ga.ga_len) 8411 return 0L; 8412 8413 if (fg) 8414 color = HL_TABLE()[id - 1].sg_gui_fg; 8415 else 8416 color = HL_TABLE()[id - 1].sg_gui_bg; 8417 8418 if (color == INVALCOLOR) 8419 return 0L; 8420 8421 return gui_mch_get_rgb(color); 8422 } 8423 #endif 8424 8425 /* 8426 * Output the syntax list header. 8427 * Return TRUE when started a new line. 8428 */ 8429 static int 8430 syn_list_header(did_header, outlen, id) 8431 int did_header; /* did header already */ 8432 int outlen; /* length of string that comes */ 8433 int id; /* highlight group id */ 8434 { 8435 int endcol = 19; 8436 int newline = TRUE; 8437 8438 if (!did_header) 8439 { 8440 msg_putchar('\n'); 8441 if (got_int) 8442 return TRUE; 8443 msg_outtrans(HL_TABLE()[id - 1].sg_name); 8444 endcol = 15; 8445 } 8446 else if (msg_col + outlen + 1 >= Columns) 8447 { 8448 msg_putchar('\n'); 8449 if (got_int) 8450 return TRUE; 8451 } 8452 else 8453 { 8454 if (msg_col >= endcol) /* wrap around is like starting a new line */ 8455 newline = FALSE; 8456 } 8457 8458 if (msg_col >= endcol) /* output at least one space */ 8459 endcol = msg_col + 1; 8460 if (Columns <= endcol) /* avoid hang for tiny window */ 8461 endcol = Columns - 1; 8462 8463 msg_advance(endcol); 8464 8465 /* Show "xxx" with the attributes. */ 8466 if (!did_header) 8467 { 8468 msg_puts_attr((char_u *)"xxx", syn_id2attr(id)); 8469 msg_putchar(' '); 8470 } 8471 8472 return newline; 8473 } 8474 8475 /* 8476 * Set the attribute numbers for a highlight group. 8477 * Called after one of the attributes has changed. 8478 */ 8479 static void 8480 set_hl_attr(idx) 8481 int idx; /* index in array */ 8482 { 8483 attrentry_T at_en; 8484 struct hl_group *sgp = HL_TABLE() + idx; 8485 8486 /* The "Normal" group doesn't need an attribute number */ 8487 if (sgp->sg_name_u != NULL && STRCMP(sgp->sg_name_u, "NORMAL") == 0) 8488 return; 8489 8490 #ifdef FEAT_GUI 8491 /* 8492 * For the GUI mode: If there are other than "normal" highlighting 8493 * attributes, need to allocate an attr number. 8494 */ 8495 if (sgp->sg_gui_fg == INVALCOLOR 8496 && sgp->sg_gui_bg == INVALCOLOR 8497 && sgp->sg_gui_sp == INVALCOLOR 8498 && sgp->sg_font == NOFONT 8499 # ifdef FEAT_XFONTSET 8500 && sgp->sg_fontset == NOFONTSET 8501 # endif 8502 ) 8503 { 8504 sgp->sg_gui_attr = sgp->sg_gui; 8505 } 8506 else 8507 { 8508 at_en.ae_attr = sgp->sg_gui; 8509 at_en.ae_u.gui.fg_color = sgp->sg_gui_fg; 8510 at_en.ae_u.gui.bg_color = sgp->sg_gui_bg; 8511 at_en.ae_u.gui.sp_color = sgp->sg_gui_sp; 8512 at_en.ae_u.gui.font = sgp->sg_font; 8513 # ifdef FEAT_XFONTSET 8514 at_en.ae_u.gui.fontset = sgp->sg_fontset; 8515 # endif 8516 sgp->sg_gui_attr = get_attr_entry(&gui_attr_table, &at_en); 8517 } 8518 #endif 8519 /* 8520 * For the term mode: If there are other than "normal" highlighting 8521 * attributes, need to allocate an attr number. 8522 */ 8523 if (sgp->sg_start == NULL && sgp->sg_stop == NULL) 8524 sgp->sg_term_attr = sgp->sg_term; 8525 else 8526 { 8527 at_en.ae_attr = sgp->sg_term; 8528 at_en.ae_u.term.start = sgp->sg_start; 8529 at_en.ae_u.term.stop = sgp->sg_stop; 8530 sgp->sg_term_attr = get_attr_entry(&term_attr_table, &at_en); 8531 } 8532 8533 /* 8534 * For the color term mode: If there are other than "normal" 8535 * highlighting attributes, need to allocate an attr number. 8536 */ 8537 if (sgp->sg_cterm_fg == 0 && sgp->sg_cterm_bg == 0) 8538 sgp->sg_cterm_attr = sgp->sg_cterm; 8539 else 8540 { 8541 at_en.ae_attr = sgp->sg_cterm; 8542 at_en.ae_u.cterm.fg_color = sgp->sg_cterm_fg; 8543 at_en.ae_u.cterm.bg_color = sgp->sg_cterm_bg; 8544 sgp->sg_cterm_attr = get_attr_entry(&cterm_attr_table, &at_en); 8545 } 8546 } 8547 8548 /* 8549 * Lookup a highlight group name and return it's ID. 8550 * If it is not found, 0 is returned. 8551 */ 8552 int 8553 syn_name2id(name) 8554 char_u *name; 8555 { 8556 int i; 8557 char_u name_u[200]; 8558 8559 /* Avoid using stricmp() too much, it's slow on some systems */ 8560 /* Avoid alloc()/free(), these are slow too. ID names over 200 chars 8561 * don't deserve to be found! */ 8562 vim_strncpy(name_u, name, 199); 8563 vim_strup(name_u); 8564 for (i = highlight_ga.ga_len; --i >= 0; ) 8565 if (HL_TABLE()[i].sg_name_u != NULL 8566 && STRCMP(name_u, HL_TABLE()[i].sg_name_u) == 0) 8567 break; 8568 return i + 1; 8569 } 8570 8571 #if defined(FEAT_EVAL) || defined(PROTO) 8572 /* 8573 * Return TRUE if highlight group "name" exists. 8574 */ 8575 int 8576 highlight_exists(name) 8577 char_u *name; 8578 { 8579 return (syn_name2id(name) > 0); 8580 } 8581 8582 # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO) 8583 /* 8584 * Return the name of highlight group "id". 8585 * When not a valid ID return an empty string. 8586 */ 8587 char_u * 8588 syn_id2name(id) 8589 int id; 8590 { 8591 if (id <= 0 || id > highlight_ga.ga_len) 8592 return (char_u *)""; 8593 return HL_TABLE()[id - 1].sg_name; 8594 } 8595 # endif 8596 #endif 8597 8598 /* 8599 * Like syn_name2id(), but take a pointer + length argument. 8600 */ 8601 int 8602 syn_namen2id(linep, len) 8603 char_u *linep; 8604 int len; 8605 { 8606 char_u *name; 8607 int id = 0; 8608 8609 name = vim_strnsave(linep, len); 8610 if (name != NULL) 8611 { 8612 id = syn_name2id(name); 8613 vim_free(name); 8614 } 8615 return id; 8616 } 8617 8618 /* 8619 * Find highlight group name in the table and return it's ID. 8620 * The argument is a pointer to the name and the length of the name. 8621 * If it doesn't exist yet, a new entry is created. 8622 * Return 0 for failure. 8623 */ 8624 int 8625 syn_check_group(pp, len) 8626 char_u *pp; 8627 int len; 8628 { 8629 int id; 8630 char_u *name; 8631 8632 name = vim_strnsave(pp, len); 8633 if (name == NULL) 8634 return 0; 8635 8636 id = syn_name2id(name); 8637 if (id == 0) /* doesn't exist yet */ 8638 id = syn_add_group(name); 8639 else 8640 vim_free(name); 8641 return id; 8642 } 8643 8644 /* 8645 * Add new highlight group and return it's ID. 8646 * "name" must be an allocated string, it will be consumed. 8647 * Return 0 for failure. 8648 */ 8649 static int 8650 syn_add_group(name) 8651 char_u *name; 8652 { 8653 char_u *p; 8654 8655 /* Check that the name is ASCII letters, digits and underscore. */ 8656 for (p = name; *p != NUL; ++p) 8657 { 8658 if (!vim_isprintc(*p)) 8659 { 8660 EMSG(_("E669: Unprintable character in group name")); 8661 return 0; 8662 } 8663 else if (!ASCII_ISALNUM(*p) && *p != '_') 8664 { 8665 /* This is an error, but since there previously was no check only 8666 * give a warning. */ 8667 msg_source(hl_attr(HLF_W)); 8668 MSG(_("W18: Invalid character in group name")); 8669 break; 8670 } 8671 } 8672 8673 /* 8674 * First call for this growarray: init growing array. 8675 */ 8676 if (highlight_ga.ga_data == NULL) 8677 { 8678 highlight_ga.ga_itemsize = sizeof(struct hl_group); 8679 highlight_ga.ga_growsize = 10; 8680 } 8681 8682 /* 8683 * Make room for at least one other syntax_highlight entry. 8684 */ 8685 if (ga_grow(&highlight_ga, 1) == FAIL) 8686 { 8687 vim_free(name); 8688 return 0; 8689 } 8690 8691 vim_memset(&(HL_TABLE()[highlight_ga.ga_len]), 0, sizeof(struct hl_group)); 8692 HL_TABLE()[highlight_ga.ga_len].sg_name = name; 8693 HL_TABLE()[highlight_ga.ga_len].sg_name_u = vim_strsave_up(name); 8694 #ifdef FEAT_GUI 8695 HL_TABLE()[highlight_ga.ga_len].sg_gui_bg = INVALCOLOR; 8696 HL_TABLE()[highlight_ga.ga_len].sg_gui_fg = INVALCOLOR; 8697 HL_TABLE()[highlight_ga.ga_len].sg_gui_sp = INVALCOLOR; 8698 #endif 8699 ++highlight_ga.ga_len; 8700 8701 return highlight_ga.ga_len; /* ID is index plus one */ 8702 } 8703 8704 /* 8705 * When, just after calling syn_add_group(), an error is discovered, this 8706 * function deletes the new name. 8707 */ 8708 static void 8709 syn_unadd_group() 8710 { 8711 --highlight_ga.ga_len; 8712 vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name); 8713 vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name_u); 8714 } 8715 8716 /* 8717 * Translate a group ID to highlight attributes. 8718 */ 8719 int 8720 syn_id2attr(hl_id) 8721 int hl_id; 8722 { 8723 int attr; 8724 struct hl_group *sgp; 8725 8726 hl_id = syn_get_final_id(hl_id); 8727 sgp = &HL_TABLE()[hl_id - 1]; /* index is ID minus one */ 8728 8729 #ifdef FEAT_GUI 8730 /* 8731 * Only use GUI attr when the GUI is being used. 8732 */ 8733 if (gui.in_use) 8734 attr = sgp->sg_gui_attr; 8735 else 8736 #endif 8737 if (t_colors > 1) 8738 attr = sgp->sg_cterm_attr; 8739 else 8740 attr = sgp->sg_term_attr; 8741 8742 return attr; 8743 } 8744 8745 #ifdef FEAT_GUI 8746 /* 8747 * Get the GUI colors and attributes for a group ID. 8748 * NOTE: the colors will be INVALCOLOR when not set, the color otherwise. 8749 */ 8750 int 8751 syn_id2colors(hl_id, fgp, bgp) 8752 int hl_id; 8753 guicolor_T *fgp; 8754 guicolor_T *bgp; 8755 { 8756 struct hl_group *sgp; 8757 8758 hl_id = syn_get_final_id(hl_id); 8759 sgp = &HL_TABLE()[hl_id - 1]; /* index is ID minus one */ 8760 8761 *fgp = sgp->sg_gui_fg; 8762 *bgp = sgp->sg_gui_bg; 8763 return sgp->sg_gui; 8764 } 8765 #endif 8766 8767 /* 8768 * Translate a group ID to the final group ID (following links). 8769 */ 8770 int 8771 syn_get_final_id(hl_id) 8772 int hl_id; 8773 { 8774 int count; 8775 struct hl_group *sgp; 8776 8777 if (hl_id > highlight_ga.ga_len || hl_id < 1) 8778 return 0; /* Can be called from eval!! */ 8779 8780 /* 8781 * Follow links until there is no more. 8782 * Look out for loops! Break after 100 links. 8783 */ 8784 for (count = 100; --count >= 0; ) 8785 { 8786 sgp = &HL_TABLE()[hl_id - 1]; /* index is ID minus one */ 8787 if (sgp->sg_link == 0 || sgp->sg_link > highlight_ga.ga_len) 8788 break; 8789 hl_id = sgp->sg_link; 8790 } 8791 8792 return hl_id; 8793 } 8794 8795 #ifdef FEAT_GUI 8796 /* 8797 * Call this function just after the GUI has started. 8798 * It finds the font and color handles for the highlighting groups. 8799 */ 8800 void 8801 highlight_gui_started() 8802 { 8803 int idx; 8804 8805 /* First get the colors from the "Normal" and "Menu" group, if set */ 8806 set_normal_colors(); 8807 8808 for (idx = 0; idx < highlight_ga.ga_len; ++idx) 8809 gui_do_one_color(idx, FALSE, FALSE); 8810 8811 highlight_changed(); 8812 } 8813 8814 static void 8815 gui_do_one_color(idx, do_menu, do_tooltip) 8816 int idx; 8817 int do_menu; /* TRUE: might set the menu font */ 8818 int do_tooltip; /* TRUE: might set the tooltip font */ 8819 { 8820 int didit = FALSE; 8821 8822 if (HL_TABLE()[idx].sg_font_name != NULL) 8823 { 8824 hl_do_font(idx, HL_TABLE()[idx].sg_font_name, FALSE, do_menu, 8825 do_tooltip); 8826 didit = TRUE; 8827 } 8828 if (HL_TABLE()[idx].sg_gui_fg_name != NULL) 8829 { 8830 HL_TABLE()[idx].sg_gui_fg = 8831 color_name2handle(HL_TABLE()[idx].sg_gui_fg_name); 8832 didit = TRUE; 8833 } 8834 if (HL_TABLE()[idx].sg_gui_bg_name != NULL) 8835 { 8836 HL_TABLE()[idx].sg_gui_bg = 8837 color_name2handle(HL_TABLE()[idx].sg_gui_bg_name); 8838 didit = TRUE; 8839 } 8840 if (HL_TABLE()[idx].sg_gui_sp_name != NULL) 8841 { 8842 HL_TABLE()[idx].sg_gui_sp = 8843 color_name2handle(HL_TABLE()[idx].sg_gui_sp_name); 8844 didit = TRUE; 8845 } 8846 if (didit) /* need to get a new attr number */ 8847 set_hl_attr(idx); 8848 } 8849 8850 #endif 8851 8852 /* 8853 * Translate the 'highlight' option into attributes in highlight_attr[] and 8854 * set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of 8855 * corresponding highlights to use on top of HLF_SNC is computed. 8856 * Called only when the 'highlight' option has been changed and upon first 8857 * screen redraw after any :highlight command. 8858 * Return FAIL when an invalid flag is found in 'highlight'. OK otherwise. 8859 */ 8860 int 8861 highlight_changed() 8862 { 8863 int hlf; 8864 int i; 8865 char_u *p; 8866 int attr; 8867 char_u *end; 8868 int id; 8869 #ifdef USER_HIGHLIGHT 8870 char_u userhl[10]; 8871 # ifdef FEAT_STL_OPT 8872 int id_SNC = -1; 8873 int id_S = -1; 8874 int hlcnt; 8875 # endif 8876 #endif 8877 static int hl_flags[HLF_COUNT] = HL_FLAGS; 8878 8879 need_highlight_changed = FALSE; 8880 8881 /* 8882 * Clear all attributes. 8883 */ 8884 for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf) 8885 highlight_attr[hlf] = 0; 8886 8887 /* 8888 * First set all attributes to their default value. 8889 * Then use the attributes from the 'highlight' option. 8890 */ 8891 for (i = 0; i < 2; ++i) 8892 { 8893 if (i) 8894 p = p_hl; 8895 else 8896 p = get_highlight_default(); 8897 if (p == NULL) /* just in case */ 8898 continue; 8899 8900 while (*p) 8901 { 8902 for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf) 8903 if (hl_flags[hlf] == *p) 8904 break; 8905 ++p; 8906 if (hlf == (int)HLF_COUNT || *p == NUL) 8907 return FAIL; 8908 8909 /* 8910 * Allow several hl_flags to be combined, like "bu" for 8911 * bold-underlined. 8912 */ 8913 attr = 0; 8914 for ( ; *p && *p != ','; ++p) /* parse upto comma */ 8915 { 8916 if (vim_iswhite(*p)) /* ignore white space */ 8917 continue; 8918 8919 if (attr > HL_ALL) /* Combination with ':' is not allowed. */ 8920 return FAIL; 8921 8922 switch (*p) 8923 { 8924 case 'b': attr |= HL_BOLD; 8925 break; 8926 case 'i': attr |= HL_ITALIC; 8927 break; 8928 case '-': 8929 case 'n': /* no highlighting */ 8930 break; 8931 case 'r': attr |= HL_INVERSE; 8932 break; 8933 case 's': attr |= HL_STANDOUT; 8934 break; 8935 case 'u': attr |= HL_UNDERLINE; 8936 break; 8937 case 'c': attr |= HL_UNDERCURL; 8938 break; 8939 case ':': ++p; /* highlight group name */ 8940 if (attr || *p == NUL) /* no combinations */ 8941 return FAIL; 8942 end = vim_strchr(p, ','); 8943 if (end == NULL) 8944 end = p + STRLEN(p); 8945 id = syn_check_group(p, (int)(end - p)); 8946 if (id == 0) 8947 return FAIL; 8948 attr = syn_id2attr(id); 8949 p = end - 1; 8950 #if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT) 8951 if (hlf == (int)HLF_SNC) 8952 id_SNC = syn_get_final_id(id); 8953 else if (hlf == (int)HLF_S) 8954 id_S = syn_get_final_id(id); 8955 #endif 8956 break; 8957 default: return FAIL; 8958 } 8959 } 8960 highlight_attr[hlf] = attr; 8961 8962 p = skip_to_option_part(p); /* skip comma and spaces */ 8963 } 8964 } 8965 8966 #ifdef USER_HIGHLIGHT 8967 /* Setup the user highlights 8968 * 8969 * Temporarily utilize 10 more hl entries. Have to be in there 8970 * simultaneously in case of table overflows in get_attr_entry() 8971 */ 8972 # ifdef FEAT_STL_OPT 8973 if (ga_grow(&highlight_ga, 10) == FAIL) 8974 return FAIL; 8975 hlcnt = highlight_ga.ga_len; 8976 if (id_S == 0) 8977 { /* Make sure id_S is always valid to simplify code below */ 8978 memset(&HL_TABLE()[hlcnt + 9], 0, sizeof(struct hl_group)); 8979 HL_TABLE()[hlcnt + 9].sg_term = highlight_attr[HLF_S]; 8980 id_S = hlcnt + 10; 8981 } 8982 # endif 8983 for (i = 0; i < 9; i++) 8984 { 8985 sprintf((char *)userhl, "User%d", i + 1); 8986 id = syn_name2id(userhl); 8987 if (id == 0) 8988 { 8989 highlight_user[i] = 0; 8990 # ifdef FEAT_STL_OPT 8991 highlight_stlnc[i] = 0; 8992 # endif 8993 } 8994 else 8995 { 8996 # ifdef FEAT_STL_OPT 8997 struct hl_group *hlt = HL_TABLE(); 8998 # endif 8999 9000 highlight_user[i] = syn_id2attr(id); 9001 # ifdef FEAT_STL_OPT 9002 if (id_SNC == 0) 9003 { 9004 memset(&hlt[hlcnt + i], 0, sizeof(struct hl_group)); 9005 hlt[hlcnt + i].sg_term = highlight_attr[HLF_SNC]; 9006 hlt[hlcnt + i].sg_cterm = highlight_attr[HLF_SNC]; 9007 # ifdef FEAT_GUI 9008 hlt[hlcnt + i].sg_gui = highlight_attr[HLF_SNC]; 9009 # endif 9010 } 9011 else 9012 mch_memmove(&hlt[hlcnt + i], 9013 &hlt[id_SNC - 1], 9014 sizeof(struct hl_group)); 9015 hlt[hlcnt + i].sg_link = 0; 9016 9017 /* Apply difference between UserX and HLF_S to HLF_SNC */ 9018 hlt[hlcnt + i].sg_term ^= 9019 hlt[id - 1].sg_term ^ hlt[id_S - 1].sg_term; 9020 if (hlt[id - 1].sg_start != hlt[id_S - 1].sg_start) 9021 hlt[hlcnt + i].sg_start = hlt[id - 1].sg_start; 9022 if (hlt[id - 1].sg_stop != hlt[id_S - 1].sg_stop) 9023 hlt[hlcnt + i].sg_stop = hlt[id - 1].sg_stop; 9024 hlt[hlcnt + i].sg_cterm ^= 9025 hlt[id - 1].sg_cterm ^ hlt[id_S - 1].sg_cterm; 9026 if (hlt[id - 1].sg_cterm_fg != hlt[id_S - 1].sg_cterm_fg) 9027 hlt[hlcnt + i].sg_cterm_fg = hlt[id - 1].sg_cterm_fg; 9028 if (hlt[id - 1].sg_cterm_bg != hlt[id_S - 1].sg_cterm_bg) 9029 hlt[hlcnt + i].sg_cterm_bg = hlt[id - 1].sg_cterm_bg; 9030 # ifdef FEAT_GUI 9031 hlt[hlcnt + i].sg_gui ^= 9032 hlt[id - 1].sg_gui ^ hlt[id_S - 1].sg_gui; 9033 if (hlt[id - 1].sg_gui_fg != hlt[id_S - 1].sg_gui_fg) 9034 hlt[hlcnt + i].sg_gui_fg = hlt[id - 1].sg_gui_fg; 9035 if (hlt[id - 1].sg_gui_bg != hlt[id_S - 1].sg_gui_bg) 9036 hlt[hlcnt + i].sg_gui_bg = hlt[id - 1].sg_gui_bg; 9037 if (hlt[id - 1].sg_gui_sp != hlt[id_S - 1].sg_gui_sp) 9038 hlt[hlcnt + i].sg_gui_sp = hlt[id - 1].sg_gui_sp; 9039 if (hlt[id - 1].sg_font != hlt[id_S - 1].sg_font) 9040 hlt[hlcnt + i].sg_font = hlt[id - 1].sg_font; 9041 # ifdef FEAT_XFONTSET 9042 if (hlt[id - 1].sg_fontset != hlt[id_S - 1].sg_fontset) 9043 hlt[hlcnt + i].sg_fontset = hlt[id - 1].sg_fontset; 9044 # endif 9045 # endif 9046 highlight_ga.ga_len = hlcnt + i + 1; 9047 set_hl_attr(hlcnt + i); /* At long last we can apply */ 9048 highlight_stlnc[i] = syn_id2attr(hlcnt + i + 1); 9049 # endif 9050 } 9051 } 9052 # ifdef FEAT_STL_OPT 9053 highlight_ga.ga_len = hlcnt; 9054 # endif 9055 9056 #endif /* USER_HIGHLIGHT */ 9057 9058 return OK; 9059 } 9060 9061 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 9062 9063 static void highlight_list __ARGS((void)); 9064 static void highlight_list_two __ARGS((int cnt, int attr)); 9065 9066 /* 9067 * Handle command line completion for :highlight command. 9068 */ 9069 void 9070 set_context_in_highlight_cmd(xp, arg) 9071 expand_T *xp; 9072 char_u *arg; 9073 { 9074 char_u *p; 9075 9076 /* Default: expand group names */ 9077 xp->xp_context = EXPAND_HIGHLIGHT; 9078 xp->xp_pattern = arg; 9079 include_link = 2; 9080 include_default = 1; 9081 9082 /* (part of) subcommand already typed */ 9083 if (*arg != NUL) 9084 { 9085 p = skiptowhite(arg); 9086 if (*p != NUL) /* past "default" or group name */ 9087 { 9088 include_default = 0; 9089 if (STRNCMP("default", arg, p - arg) == 0) 9090 { 9091 arg = skipwhite(p); 9092 xp->xp_pattern = arg; 9093 p = skiptowhite(arg); 9094 } 9095 if (*p != NUL) /* past group name */ 9096 { 9097 include_link = 0; 9098 if (arg[1] == 'i' && arg[0] == 'N') 9099 highlight_list(); 9100 if (STRNCMP("link", arg, p - arg) == 0 9101 || STRNCMP("clear", arg, p - arg) == 0) 9102 { 9103 xp->xp_pattern = skipwhite(p); 9104 p = skiptowhite(xp->xp_pattern); 9105 if (*p != NUL) /* past first group name */ 9106 { 9107 xp->xp_pattern = skipwhite(p); 9108 p = skiptowhite(xp->xp_pattern); 9109 } 9110 } 9111 if (*p != NUL) /* past group name(s) */ 9112 xp->xp_context = EXPAND_NOTHING; 9113 } 9114 } 9115 } 9116 } 9117 9118 /* 9119 * List highlighting matches in a nice way. 9120 */ 9121 static void 9122 highlight_list() 9123 { 9124 int i; 9125 9126 for (i = 10; --i >= 0; ) 9127 highlight_list_two(i, hl_attr(HLF_D)); 9128 for (i = 40; --i >= 0; ) 9129 highlight_list_two(99, 0); 9130 } 9131 9132 static void 9133 highlight_list_two(cnt, attr) 9134 int cnt; 9135 int attr; 9136 { 9137 msg_puts_attr((char_u *)("N \bI \b! \b" + cnt / 11), attr); 9138 msg_clr_eos(); 9139 out_flush(); 9140 ui_delay(cnt == 99 ? 40L : (long)cnt * 50L, FALSE); 9141 } 9142 9143 #endif /* FEAT_CMDL_COMPL */ 9144 9145 #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) \ 9146 || defined(FEAT_SIGNS) || defined(PROTO) 9147 /* 9148 * Function given to ExpandGeneric() to obtain the list of group names. 9149 * Also used for synIDattr() function. 9150 */ 9151 /*ARGSUSED*/ 9152 char_u * 9153 get_highlight_name(xp, idx) 9154 expand_T *xp; 9155 int idx; 9156 { 9157 #ifdef FEAT_CMDL_COMPL 9158 if (idx == highlight_ga.ga_len && include_none != 0) 9159 return (char_u *)"none"; 9160 if (idx == highlight_ga.ga_len + include_none && include_default != 0) 9161 return (char_u *)"default"; 9162 if (idx == highlight_ga.ga_len + include_none + include_default 9163 && include_link != 0) 9164 return (char_u *)"link"; 9165 if (idx == highlight_ga.ga_len + include_none + include_default + 1 9166 && include_link != 0) 9167 return (char_u *)"clear"; 9168 #endif 9169 if (idx < 0 || idx >= highlight_ga.ga_len) 9170 return NULL; 9171 return HL_TABLE()[idx].sg_name; 9172 } 9173 #endif 9174 9175 #if defined(FEAT_GUI) || defined(PROTO) 9176 /* 9177 * Free all the highlight group fonts. 9178 * Used when quitting for systems which need it. 9179 */ 9180 void 9181 free_highlight_fonts() 9182 { 9183 int idx; 9184 9185 for (idx = 0; idx < highlight_ga.ga_len; ++idx) 9186 { 9187 gui_mch_free_font(HL_TABLE()[idx].sg_font); 9188 HL_TABLE()[idx].sg_font = NOFONT; 9189 # ifdef FEAT_XFONTSET 9190 gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset); 9191 HL_TABLE()[idx].sg_fontset = NOFONTSET; 9192 # endif 9193 } 9194 9195 gui_mch_free_font(gui.norm_font); 9196 # ifdef FEAT_XFONTSET 9197 gui_mch_free_fontset(gui.fontset); 9198 # endif 9199 # ifndef HAVE_GTK2 9200 gui_mch_free_font(gui.bold_font); 9201 gui_mch_free_font(gui.ital_font); 9202 gui_mch_free_font(gui.boldital_font); 9203 # endif 9204 } 9205 #endif 9206 9207 /************************************** 9208 * End of Highlighting stuff * 9209 **************************************/ 9210