diff options
Diffstat (limited to 'src/syntax.c')
| -rw-r--r-- | src/syntax.c | 920 |
1 files changed, 552 insertions, 368 deletions
diff --git a/src/syntax.c b/src/syntax.c index 961348290..c19c5d964 100644 --- a/src/syntax.c +++ b/src/syntax.c @@ -140,7 +140,10 @@ typedef struct syn_pattern { char sp_type; /* see SPTYPE_ defines below */ char sp_syncing; /* this item used for syncing */ - short sp_flags; /* see HL_ defines below */ + int sp_flags; /* see HL_ defines below */ +#ifdef FEAT_CONCEAL + int sp_char; /* conceal substitute character */ +#endif struct sp_syn sp_syn; /* struct passed to in_id_list() */ short sp_syn_match_id; /* highlight group ID of pattern */ char_u *sp_pattern; /* regexp to match, pattern */ @@ -166,25 +169,6 @@ typedef struct syn_pattern #define SPTYPE_END 3 /* match a regexp, end of item */ #define SPTYPE_SKIP 4 /* match a regexp, skip within item */ -#define HL_CONTAINED 0x01 /* not used on toplevel */ -#define HL_TRANSP 0x02 /* has no highlighting */ -#define HL_ONELINE 0x04 /* match within one line only */ -#define HL_HAS_EOL 0x08 /* end pattern that matches with $ */ -#define HL_SYNC_HERE 0x10 /* sync point after this item (syncing only) */ -#define HL_SYNC_THERE 0x20 /* sync point at current line (syncing only) */ -#define HL_MATCH 0x40 /* use match ID instead of item ID */ -#define HL_SKIPNL 0x80 /* nextgroup can skip newlines */ -#define HL_SKIPWHITE 0x100 /* nextgroup can skip white space */ -#define HL_SKIPEMPTY 0x200 /* nextgroup can skip empty lines */ -#define HL_KEEPEND 0x400 /* end match always kept */ -#define HL_EXCLUDENL 0x800 /* exclude NL from match */ -#define HL_DISPLAY 0x1000 /* only used for displaying, not syncing */ -#define HL_FOLD 0x2000 /* define fold */ -#define HL_EXTEND 0x4000 /* ignore a keepend */ -/* These don't fit in a short, thus can't be used for syntax items, only for - * si_flags and bs_flags. */ -#define HL_MATCHCONT 0x8000 /* match continued from previous line */ -#define HL_TRANS_CONT 0x10000L /* transparent item without contains arg */ #define SYN_ITEMS(buf) ((synpat_T *)((buf)->b_syn_patterns.ga_data)) @@ -208,6 +192,10 @@ static int current_attr = 0; /* attr of current syntax word */ static int current_id = 0; /* ID of current char for syn_get_id() */ static int current_trans_id = 0; /* idem, transparency removed */ #endif +#ifdef FEAT_CONCEAL +static int current_flags = 0; +static int current_sub_char = 0; +#endif typedef struct syn_cluster_S { @@ -294,6 +282,9 @@ typedef struct state_item int si_attr; /* attributes in this state */ long si_flags; /* HL_HAS_EOL flag in this state, and * HL_SKIP* for si_next_list */ +#ifdef FEAT_CONCEAL + int si_char; /* substitution character for conceal */ +#endif short *si_cont_list; /* list of contained groups */ short *si_next_list; /* nextgroup IDs after this item ends */ reg_extmatch_T *si_extmatch; /* \z(...\) matches from start @@ -351,6 +342,7 @@ static reg_extmatch_T *next_match_extmatch = NULL; */ static win_T *syn_win; /* current window for highlighting */ static buf_T *syn_buf; /* current buffer for highlighting */ +static synblock_T *syn_block; /* current buffer for highlighting */ static linenr_T current_lnum = 0; /* lnum of current state */ static colnr_T current_col = 0; /* column of current state */ static int current_state_stored = 0; /* TRUE if stored current state @@ -370,7 +362,7 @@ static void syn_start_line __ARGS((void)); static void syn_update_ends __ARGS((int startofline)); static void syn_stack_alloc __ARGS((void)); static int syn_stack_cleanup __ARGS((void)); -static void syn_stack_free_entry __ARGS((buf_T *buf, synstate_T *p)); +static void syn_stack_free_entry __ARGS((synblock_T *block, synstate_T *p)); static synstate_T *syn_stack_find_entry __ARGS((linenr_T lnum)); static synstate_T *store_current_state __ARGS((void)); static void load_current_state __ARGS((synstate_T *from)); @@ -390,6 +382,7 @@ static int in_id_list __ARGS((stateitem_T *item, short *cont_list, struct sp_syn static int push_current_state __ARGS((int idx)); static void pop_current_state __ARGS((void)); +static void syn_stack_apply_changes_block __ARGS((synblock_T *block, buf_T *buf)); 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)); static void clear_syn_state __ARGS((synstate_T *p)); static void clear_current_state __ARGS((void)); @@ -400,14 +393,15 @@ static void syn_add_end_off __ARGS((lpos_T *result, regmmatch_T *regmatch, synpa static void syn_add_start_off __ARGS((lpos_T *result, regmmatch_T *regmatch, synpat_T *spp, int idx, int extra)); static char_u *syn_getcurline __ARGS((void)); static int syn_regexec __ARGS((regmmatch_T *rmp, linenr_T lnum, colnr_T col)); -static int check_keyword_id __ARGS((char_u *line, int startcol, int *endcol, long *flags, short **next_list, stateitem_T *cur_si)); +static int check_keyword_id __ARGS((char_u *line, int startcol, int *endcol, long *flags, short **next_list, stateitem_T *cur_si, int *ccharp)); static void syn_cmd_case __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_spell __ARGS((exarg_T *eap, int syncing)); static void syntax_sync_clear __ARGS((void)); -static void syn_remove_pattern __ARGS((buf_T *buf, int idx)); -static void syn_clear_pattern __ARGS((buf_T *buf, int i)); -static void syn_clear_cluster __ARGS((buf_T *buf, int i)); +static void syn_remove_pattern __ARGS((synblock_T *block, int idx)); +static void syn_clear_pattern __ARGS((synblock_T *block, int i)); +static void syn_clear_cluster __ARGS((synblock_T *block, int i)); static void syn_cmd_clear __ARGS((exarg_T *eap, int syncing)); +static void syn_cmd_conceal __ARGS((exarg_T *eap, int syncing)); static void syn_clear_one __ARGS((int id, int syncing)); static void syn_cmd_on __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_enable __ARGS((exarg_T *eap, int syncing)); @@ -418,6 +412,7 @@ static void syn_cmd_onoff __ARGS((exarg_T *eap, char *name)); static void syn_cmd_list __ARGS((exarg_T *eap, int syncing)); static void syn_lines_msg __ARGS((void)); static void syn_match_msg __ARGS((void)); +static void syn_stack_free_block __ARGS((synblock_T *block)); static void syn_list_one __ARGS((int id, int syncing, int link_only)); static void syn_list_cluster __ARGS((int id)); static void put_id_list __ARGS((char_u *name, short *list, int attr)); @@ -425,9 +420,9 @@ static void put_pattern __ARGS((char *s, int c, synpat_T *spp, int attr)); static int syn_list_keywords __ARGS((int id, hashtab_T *ht, int did_header, int attr)); static void syn_clear_keyword __ARGS((int id, hashtab_T *ht)); static void clear_keywtab __ARGS((hashtab_T *ht)); -static void add_keyword __ARGS((char_u *name, int id, int flags, short *cont_in_list, short *next_list)); +static void add_keyword __ARGS((char_u *name, int id, int flags, short *cont_in_list, short *next_list, int conceal_char)); static char_u *get_group_name __ARGS((char_u *arg, char_u **name_end)); -static char_u *get_syn_options __ARGS((char_u *arg, syn_opt_arg_T *opt)); +static char_u *get_syn_options __ARGS((char_u *arg, syn_opt_arg_T *opt, int *conceal_char)); static void syn_cmd_include __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_keyword __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_match __ARGS((exarg_T *eap, int syncing)); @@ -475,10 +470,11 @@ syntax_start(wp, lnum) * Also do this when a change was made, the current state may be invalid * then. */ - if (syn_buf != wp->w_buffer || changedtick != syn_buf->b_changedtick) + if (syn_block != wp->w_s || changedtick != syn_buf->b_changedtick) { invalidate_current_state(); syn_buf = wp->w_buffer; + syn_block = wp->w_s; } changedtick = syn_buf->b_changedtick; syn_win = wp; @@ -487,9 +483,9 @@ syntax_start(wp, lnum) * Allocate syntax stack when needed. */ syn_stack_alloc(); - if (syn_buf->b_sst_array == NULL) + if (syn_block->b_sst_array == NULL) return; /* out of memory */ - syn_buf->b_sst_lasttick = display_tick; + syn_block->b_sst_lasttick = display_tick; /* * If the state of the end of the previous line is useful, store it. @@ -520,17 +516,17 @@ syntax_start(wp, lnum) * Try to synchronize from a saved state in b_sst_array[]. * Only do this if lnum is not before and not to far beyond a saved state. */ - if (INVALID_STATE(¤t_state) && syn_buf->b_sst_array != NULL) + if (INVALID_STATE(¤t_state) && syn_block->b_sst_array != NULL) { /* Find last valid saved state before start_lnum. */ - for (p = syn_buf->b_sst_first; p != NULL; p = p->sst_next) + for (p = syn_block->b_sst_first; p != NULL; p = p->sst_next) { if (p->sst_lnum > lnum) break; if (p->sst_lnum <= lnum && p->sst_change_lnum == 0) { last_valid = p; - if (p->sst_lnum >= lnum - syn_buf->b_syn_sync_minlines) + if (p->sst_lnum >= lnum - syn_block->b_syn_sync_minlines) last_min_valid = p; } } @@ -545,7 +541,7 @@ syntax_start(wp, lnum) if (INVALID_STATE(¤t_state)) { syn_sync(wp, lnum, last_valid); - first_stored = current_lnum + syn_buf->b_syn_sync_minlines; + first_stored = current_lnum + syn_block->b_syn_sync_minlines; } else first_stored = current_lnum; @@ -554,10 +550,10 @@ syntax_start(wp, lnum) * Advance from the sync point or saved state until the current line. * Save some entries for syncing with later on. */ - if (syn_buf->b_sst_len <= Rows) + if (syn_block->b_sst_len <= Rows) dist = 999999; else - dist = syn_buf->b_ml.ml_line_count / (syn_buf->b_sst_len - Rows) + 1; + dist = syn_buf->b_ml.ml_line_count / (syn_block->b_sst_len - Rows) + 1; while (current_lnum < lnum) { syn_start_line(); @@ -574,7 +570,7 @@ syntax_start(wp, lnum) if (prev == NULL) prev = syn_stack_find_entry(current_lnum - 1); if (prev == NULL) - sp = syn_buf->b_sst_first; + sp = syn_block->b_sst_first; else sp = prev; while (sp != NULL && sp->sst_lnum < current_lnum) @@ -706,19 +702,19 @@ syn_sync(wp, start_lnum, last_valid) * where N is minlines * 1.5, or minlines * 2 if minlines is small. * Watch out for overflow when minlines is MAXLNUM. */ - if (syn_buf->b_syn_sync_minlines > start_lnum) + if (syn_block->b_syn_sync_minlines > start_lnum) start_lnum = 1; else { - if (syn_buf->b_syn_sync_minlines == 1) + if (syn_block->b_syn_sync_minlines == 1) lnum = 1; - else if (syn_buf->b_syn_sync_minlines < 10) - lnum = syn_buf->b_syn_sync_minlines * 2; + else if (syn_block->b_syn_sync_minlines < 10) + lnum = syn_block->b_syn_sync_minlines * 2; else - lnum = syn_buf->b_syn_sync_minlines * 3 / 2; - if (syn_buf->b_syn_sync_maxlines != 0 - && lnum > syn_buf->b_syn_sync_maxlines) - lnum = syn_buf->b_syn_sync_maxlines; + lnum = syn_block->b_syn_sync_minlines * 3 / 2; + if (syn_block->b_syn_sync_maxlines != 0 + && lnum > syn_block->b_syn_sync_maxlines) + lnum = syn_block->b_syn_sync_maxlines; if (lnum >= start_lnum) start_lnum = 1; else @@ -729,7 +725,7 @@ syn_sync(wp, start_lnum, last_valid) /* * 1. Search backwards for the end of a C-style comment. */ - if (syn_buf->b_syn_sync_flags & SF_CCOMMENT) + if (syn_block->b_syn_sync_flags & SF_CCOMMENT) { /* Need to make syn_buf the current buffer for a moment, to be able to * use find_start_comment(). */ @@ -759,11 +755,12 @@ syn_sync(wp, start_lnum, last_valid) * defines the comment. * Restrict the search for the end of a comment to b_syn_sync_maxlines. */ - if (find_start_comment((int)syn_buf->b_syn_sync_maxlines) != NULL) + if (find_start_comment((int)syn_block->b_syn_sync_maxlines) != NULL) { - for (idx = syn_buf->b_syn_patterns.ga_len; --idx >= 0; ) - if (SYN_ITEMS(syn_buf)[idx].sp_syn.id == syn_buf->b_syn_sync_id - && SYN_ITEMS(syn_buf)[idx].sp_type == SPTYPE_START) + for (idx = syn_block->b_syn_patterns.ga_len; --idx >= 0; ) + if (SYN_ITEMS(syn_block)[idx].sp_syn.id + == syn_block->b_syn_sync_id + && SYN_ITEMS(syn_block)[idx].sp_type == SPTYPE_START) { validate_current_state(); if (push_current_state(idx) == OK) @@ -781,11 +778,11 @@ syn_sync(wp, start_lnum, last_valid) /* * 2. Search backwards for given sync patterns. */ - else if (syn_buf->b_syn_sync_flags & SF_MATCH) + else if (syn_block->b_syn_sync_flags & SF_MATCH) { - if (syn_buf->b_syn_sync_maxlines != 0 - && start_lnum > syn_buf->b_syn_sync_maxlines) - break_lnum = start_lnum - syn_buf->b_syn_sync_maxlines; + if (syn_block->b_syn_sync_maxlines != 0 + && start_lnum > syn_block->b_syn_sync_maxlines) + break_lnum = start_lnum - syn_block->b_syn_sync_maxlines; else break_lnum = 0; @@ -849,7 +846,7 @@ syn_sync(wp, start_lnum, last_valid) } else { - spp = &(SYN_ITEMS(syn_buf)[cur_si->si_idx]); + spp = &(SYN_ITEMS(syn_block)[cur_si->si_idx]); found_flags = spp->sp_flags; found_match_idx = spp->sp_sync_idx; } @@ -952,10 +949,10 @@ syn_match_linecont(lnum) { regmmatch_T regmatch; - if (syn_buf->b_syn_linecont_prog != NULL) + if (syn_block->b_syn_linecont_prog != NULL) { - regmatch.rmm_ic = syn_buf->b_syn_linecont_ic; - regmatch.regprog = syn_buf->b_syn_linecont_prog; + regmatch.rmm_ic = syn_block->b_syn_linecont_ic; + regmatch.regprog = syn_block->b_syn_linecont_prog; return syn_regexec(®match, lnum, (colnr_T)0); } return FALSE; @@ -1002,7 +999,7 @@ syn_update_ends(startofline) { cur_si = &CUR_STATE(i); if (cur_si->si_idx >= 0 - && (SYN_ITEMS(syn_buf)[cur_si->si_idx]).sp_type + && (SYN_ITEMS(syn_block)[cur_si->si_idx]).sp_type == SPTYPE_MATCH && cur_si->si_m_endpos.lnum < current_lnum) { @@ -1088,30 +1085,39 @@ syn_update_ends(startofline) * number of entries SST_MAX_ENTRIES, and the distance is computed. */ + static void +syn_stack_free_block(block) + synblock_T *block; +{ + synstate_T *p; + + if (block->b_sst_array != NULL) + { + for (p = block->b_sst_first; p != NULL; p = p->sst_next) + clear_syn_state(p); + vim_free(block->b_sst_array); + block->b_sst_array = NULL; + block->b_sst_len = 0; + } +} /* * Free b_sst_array[] for buffer "buf". * Used when syntax items changed to force resyncing everywhere. */ void -syn_stack_free_all(buf) - buf_T *buf; +syn_stack_free_all(block) + synblock_T *block; { - synstate_T *p; win_T *wp; - if (buf->b_sst_array != NULL) - { - for (p = buf->b_sst_first; p != NULL; p = p->sst_next) - clear_syn_state(p); - vim_free(buf->b_sst_array); - buf->b_sst_array = NULL; - buf->b_sst_len = 0; - } + syn_stack_free_block(block); + + #ifdef FEAT_FOLDING /* When using "syntax" fold method, must update all folds. */ FOR_ALL_WINDOWS(wp) { - if (wp->w_buffer == buf && foldmethodIsSyntax(wp)) + if (wp->w_s == block && foldmethodIsSyntax(wp)) foldUpdateAll(wp); } #endif @@ -1135,7 +1141,7 @@ syn_stack_alloc() len = SST_MIN_ENTRIES; else if (len > SST_MAX_ENTRIES) len = SST_MAX_ENTRIES; - if (syn_buf->b_sst_len > len * 2 || syn_buf->b_sst_len < len) + if (syn_block->b_sst_len > len * 2 || syn_block->b_sst_len < len) { /* Allocate 50% too much, to avoid reallocating too often. */ len = syn_buf->b_ml.ml_line_count; @@ -1145,15 +1151,15 @@ syn_stack_alloc() else if (len > SST_MAX_ENTRIES) len = SST_MAX_ENTRIES; - if (syn_buf->b_sst_array != NULL) + if (syn_block->b_sst_array != NULL) { /* When shrinking the array, cleanup the existing stack. * Make sure that all valid entries fit in the new array. */ - while (syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2 > len + while (syn_block->b_sst_len - syn_block->b_sst_freecount + 2 > len && syn_stack_cleanup()) ; - if (len < syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2) - len = syn_buf->b_sst_len - syn_buf->b_sst_freecount + 2; + if (len < syn_block->b_sst_len - syn_block->b_sst_freecount + 2) + len = syn_block->b_sst_len - syn_block->b_sst_freecount + 2; } sstp = (synstate_T *)alloc_clear((unsigned)(len * sizeof(synstate_T))); @@ -1161,10 +1167,10 @@ syn_stack_alloc() return; to = sstp - 1; - if (syn_buf->b_sst_array != NULL) + if (syn_block->b_sst_array != NULL) { /* Move the states from the old array to the new one. */ - for (from = syn_buf->b_sst_first; from != NULL; + for (from = syn_block->b_sst_first; from != NULL; from = from->sst_next) { ++to; @@ -1175,24 +1181,24 @@ syn_stack_alloc() if (to != sstp - 1) { to->sst_next = NULL; - syn_buf->b_sst_first = sstp; - syn_buf->b_sst_freecount = len - (int)(to - sstp) - 1; + syn_block->b_sst_first = sstp; + syn_block->b_sst_freecount = len - (int)(to - sstp) - 1; } else { - syn_buf->b_sst_first = NULL; - syn_buf->b_sst_freecount = len; + syn_block->b_sst_first = NULL; + syn_block->b_sst_freecount = len; } /* Create the list of free entries. */ - syn_buf->b_sst_firstfree = to + 1; + syn_block->b_sst_firstfree = to + 1; while (++to < sstp + len) to->sst_next = to + 1; (sstp + len - 1)->sst_next = NULL; - vim_free(syn_buf->b_sst_array); - syn_buf->b_sst_array = sstp; - syn_buf->b_sst_len = len; + vim_free(syn_block->b_sst_array); + syn_block->b_sst_array = sstp; + syn_block->b_sst_len = len; } } @@ -1206,16 +1212,32 @@ syn_stack_alloc() syn_stack_apply_changes(buf) buf_T *buf; { + win_T *wp; + + syn_stack_apply_changes_block(&buf->b_s, buf); + + FOR_ALL_WINDOWS(wp) + { + if ((wp->w_buffer == buf) && (wp->w_s != &buf->b_s)) + syn_stack_apply_changes_block(wp->w_s, buf); + } +} + + static void +syn_stack_apply_changes_block(block, buf) + synblock_T *block; + buf_T *buf; +{ synstate_T *p, *prev, *np; linenr_T n; - if (buf->b_sst_array == NULL) /* nothing to do */ + if (block->b_sst_array == NULL) /* nothing to do */ return; prev = NULL; - for (p = buf->b_sst_first; p != NULL; ) + for (p = block->b_sst_first; p != NULL; ) { - if (p->sst_lnum + buf->b_syn_sync_linebreaks > buf->b_mod_top) + if (p->sst_lnum + block->b_syn_sync_linebreaks > buf->b_mod_top) { n = p->sst_lnum + buf->b_mod_xlines; if (n <= buf->b_mod_bot) @@ -1223,10 +1245,10 @@ syn_stack_apply_changes(buf) /* this state is inside the changed area, remove it */ np = p->sst_next; if (prev == NULL) - buf->b_sst_first = np; + block->b_sst_first = np; else prev->sst_next = np; - syn_stack_free_entry(buf, p); + syn_stack_free_entry(block, p); p = np; continue; } @@ -1264,28 +1286,28 @@ syn_stack_cleanup() int dist; int retval = FALSE; - if (syn_buf->b_sst_array == NULL || syn_buf->b_sst_first == NULL) + if (syn_block->b_sst_array == NULL || syn_block->b_sst_first == NULL) return retval; /* Compute normal distance between non-displayed entries. */ - if (syn_buf->b_sst_len <= Rows) + if (syn_block->b_sst_len <= Rows) dist = 999999; else - dist = syn_buf->b_ml.ml_line_count / (syn_buf->b_sst_len - Rows) + 1; + dist = syn_buf->b_ml.ml_line_count / (syn_block->b_sst_len - Rows) + 1; /* * Go through the list to find the "tick" for the oldest entry that can * be removed. Set "above" when the "tick" for the oldest entry is above * "b_sst_lasttick" (the display tick wraps around). */ - tick = syn_buf->b_sst_lasttick; + tick = syn_block->b_sst_lasttick; above = FALSE; - prev = syn_buf->b_sst_first; + prev = syn_block->b_sst_first; for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next) { if (prev->sst_lnum + dist > p->sst_lnum) { - if (p->sst_tick > syn_buf->b_sst_lasttick) + if (p->sst_tick > syn_block->b_sst_lasttick) { if (!above || p->sst_tick < tick) tick = p->sst_tick; @@ -1300,14 +1322,14 @@ syn_stack_cleanup() * Go through the list to make the entries for the oldest tick at an * interval of several lines. */ - prev = syn_buf->b_sst_first; + prev = syn_block->b_sst_first; for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next) { if (p->sst_tick == tick && prev->sst_lnum + dist > p->sst_lnum) { /* Move this entry from used list to free list */ prev->sst_next = p->sst_next; - syn_stack_free_entry(syn_buf, p); + syn_stack_free_entry(syn_block, p); p = prev; retval = TRUE; } @@ -1320,14 +1342,14 @@ syn_stack_cleanup() * Move the entry into the free list. */ static void -syn_stack_free_entry(buf, p) - buf_T *buf; +syn_stack_free_entry(block, p) + synblock_T *block; synstate_T *p; { clear_syn_state(p); - p->sst_next = buf->b_sst_firstfree; - buf->b_sst_firstfree = p; - ++buf->b_sst_freecount; + p->sst_next = block->b_sst_firstfree; + block->b_sst_firstfree = p; + ++block->b_sst_freecount; } /* @@ -1341,7 +1363,7 @@ syn_stack_find_entry(lnum) synstate_T *p, *prev; prev = NULL; - for (p = syn_buf->b_sst_first; p != NULL; prev = p, p = p->sst_next) + for (p = syn_block->b_sst_first; p != NULL; prev = p, p = p->sst_next) { if (p->sst_lnum == lnum) return p; @@ -1383,19 +1405,19 @@ store_current_state() if (sp != NULL) { /* find "sp" in the list and remove it */ - if (syn_buf->b_sst_first == sp) + if (syn_block->b_sst_first == sp) /* it's the first entry */ - syn_buf->b_sst_first = sp->sst_next; + syn_block->b_sst_first = sp->sst_next; else { /* find the entry just before this one to adjust sst_next */ - for (p = syn_buf->b_sst_first; p != NULL; p = p->sst_next) + for (p = syn_block->b_sst_first; p != NULL; p = p->sst_next) if (p->sst_next == sp) break; if (p != NULL) /* just in case */ p->sst_next = sp->sst_next; } - syn_stack_free_entry(syn_buf, sp); + syn_stack_free_entry(syn_block, sp); sp = NULL; } } @@ -1405,27 +1427,27 @@ store_current_state() * Add a new entry */ /* If no free items, cleanup the array first. */ - if (syn_buf->b_sst_freecount == 0) + if (syn_block->b_sst_freecount == 0) { (void)syn_stack_cleanup(); /* "sp" may have been moved to the freelist now */ sp = syn_stack_find_entry(current_lnum); } /* Still no free items? Must be a strange problem... */ - if (syn_buf->b_sst_freecount == 0) + if (syn_block->b_sst_freecount == 0) sp = NULL; else { /* Take the first item from the free list and put it in the used * list, after *sp */ - p = syn_buf->b_sst_firstfree; - syn_buf->b_sst_firstfree = p->sst_next; - --syn_buf->b_sst_freecount; + p = syn_block->b_sst_firstfree; + syn_block->b_sst_firstfree = p->sst_next; + --syn_block->b_sst_freecount; if (sp == NULL) { /* Insert in front of the list */ - p->sst_next = syn_buf->b_sst_first; - syn_buf->b_sst_first = p; + p->sst_next = syn_block->b_sst_first; + syn_block->b_sst_first = p; } else { @@ -1502,7 +1524,7 @@ load_current_state(from) CUR_STATE(i).si_m_lnum = 0; if (CUR_STATE(i).si_idx >= 0) CUR_STATE(i).si_next_list = - (SYN_ITEMS(syn_buf)[CUR_STATE(i).si_idx]).sp_next_list; + (SYN_ITEMS(syn_block)[CUR_STATE(i).si_idx]).sp_next_list; else CUR_STATE(i).si_next_list = NULL; update_si_attr(i); @@ -1564,7 +1586,7 @@ syn_stack_equal(sp) if (bsx->matches[j] == NULL || six->matches[j] == NULL) break; - if ((SYN_ITEMS(syn_buf)[CUR_STATE(i).si_idx]).sp_ic + if ((SYN_ITEMS(syn_block)[CUR_STATE(i).si_idx]).sp_ic ? MB_STRICMP(bsx->matches[j], six->matches[j]) != 0 : STRCMP(bsx->matches[j], six->matches[j]) != 0) @@ -1701,7 +1723,7 @@ syn_finish_line(syncing) */ cur_si = &CUR_STATE(current_state.ga_len - 1); if (cur_si->si_idx >= 0 - && (SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags + && (SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE))) return TRUE; @@ -1730,8 +1752,9 @@ syn_finish_line(syncing) * done. */ int -get_syntax_attr(col, can_spell, keep_state) +get_syntax_attr(col, p_flags, can_spell, keep_state) colnr_T col; + int *p_flags UNUSED; int *can_spell; int keep_state; /* keep state of char at "col" */ { @@ -1740,12 +1763,12 @@ get_syntax_attr(col, can_spell, keep_state) if (can_spell != NULL) /* Default: Only do spelling when there is no @Spell cluster or when * ":syn spell toplevel" was used. */ - *can_spell = syn_buf->b_syn_spell == SYNSPL_DEFAULT - ? (syn_buf->b_spell_cluster_id == 0) - : (syn_buf->b_syn_spell == SYNSPL_TOP); + *can_spell = syn_block->b_syn_spell == SYNSPL_DEFAULT + ? (syn_block->b_spell_cluster_id == 0) + : (syn_block->b_syn_spell == SYNSPL_TOP); /* check for out of memory situation */ - if (syn_buf->b_sst_array == NULL) + if (syn_block->b_sst_array == NULL) return 0; /* After 'synmaxcol' the attribute is always zero. */ @@ -1773,6 +1796,10 @@ get_syntax_attr(col, can_spell, keep_state) ++current_col; } +#ifdef FEAT_CONCEAL + if (p_flags != NULL) + *p_flags = current_flags; +#endif return attr; } @@ -1799,6 +1826,7 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) int startcol; int endcol; long flags; + int cchar; short *next_list; int found_match; /* found usable match */ static int try_next_column = FALSE; /* must try in next col */ @@ -1854,8 +1882,8 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) /* Only check for keywords when not syncing and there are some. */ do_keywords = !syncing - && (syn_buf->b_keywtab.ht_used > 0 - || syn_buf->b_keywtab_ic.ht_used > 0); + && (syn_block->b_keywtab.ht_used > 0 + || syn_block->b_keywtab_ic.ht_used > 0); /* Init the list of zero-width matches with a nextlist. This is used to * avoid matching the same item in the same position twice. */ @@ -1884,7 +1912,7 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) else cur_si = NULL; - if (syn_buf->b_syn_containedin || cur_si == NULL + if (syn_block->b_syn_containedin || cur_si == NULL || cur_si->si_cont_list != NULL) { /* @@ -1905,7 +1933,8 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) , syn_buf))) { syn_id = check_keyword_id(line, (int)current_col, - &endcol, &flags, &next_list, cur_si); + &endcol, &flags, &next_list, cur_si, + &cchar); if (syn_id != 0) { if (push_current_state(KEYWORD_IDX) == OK) @@ -1921,6 +1950,13 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) cur_si->si_ends = TRUE; cur_si->si_end_idx = 0; cur_si->si_flags = flags; +#ifdef FEAT_CONCEAL + cur_si->si_char = cchar; + if (current_state.ga_len > 1) + cur_si->si_flags |= + CUR_STATE(current_state.ga_len - 2).si_flags + & HL_CONCEAL; +#endif cur_si->si_id = syn_id; cur_si->si_trans_id = syn_id; if (flags & HL_TRANSP) @@ -1953,7 +1989,7 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) /* * 3. Check for patterns (only if no keyword found). */ - if (syn_id == 0 && syn_buf->b_syn_patterns.ga_len) + if (syn_id == 0 && syn_block->b_syn_patterns.ga_len) { /* * If we didn't check for a match yet, or we are past it, check @@ -1969,9 +2005,9 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) */ next_match_idx = 0; /* no match in this line yet */ next_match_col = MAXCOL; - for (idx = syn_buf->b_syn_patterns.ga_len; --idx >= 0; ) + for (idx = syn_block->b_syn_patterns.ga_len; --idx >= 0; ) { - spp = &(SYN_ITEMS(syn_buf)[idx]); + spp = &(SYN_ITEMS(syn_block)[idx]); if ( spp->sp_syncing == syncing && (displaying || !(spp->sp_flags & HL_DISPLAY)) && (spp->sp_type == SPTYPE_MATCH @@ -2147,7 +2183,7 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) /* When a zero-width item matched which has a nextgroup, * don't push the item but set nextgroup. */ - lspp = &(SYN_ITEMS(syn_buf)[next_match_idx]); + lspp = &(SYN_ITEMS(syn_block)[next_match_idx]); if (next_match_m_endpos.lnum == current_lnum && next_match_m_endpos.col == current_col && lspp->sp_next_list != NULL) @@ -2219,6 +2255,9 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) current_id = 0; current_trans_id = 0; #endif +#ifdef FEAT_CONCEAL + current_flags = 0; +#endif if (cur_si != NULL) { #ifndef FEAT_EVAL @@ -2240,6 +2279,10 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) current_id = sip->si_id; #endif current_trans_id = sip->si_trans_id; +#ifdef FEAT_CONCEAL + current_flags = sip->si_flags; + current_sub_char = sip->si_char; +#endif break; } } @@ -2252,16 +2295,17 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) * set "can_spell" to TRUE if spell checking is supposed to be * done in the current item. */ - if (syn_buf->b_spell_cluster_id == 0) + if (syn_block->b_spell_cluster_id == 0) { /* There is no @Spell cluster: Do spelling for items without * @NoSpell cluster. */ - if (syn_buf->b_nospell_cluster_id == 0 || current_trans_id == 0) - *can_spell = (syn_buf->b_syn_spell != SYNSPL_NOTOP); + if (syn_block->b_nospell_cluster_id == 0 + || current_trans_id == 0) + *can_spell = (syn_block->b_syn_spell != SYNSPL_NOTOP); else { sps.inc_tag = 0; - sps.id = syn_buf->b_nospell_cluster_id; + sps.id = syn_block->b_nospell_cluster_id; sps.cont_in_list = NULL; *can_spell = !in_id_list(sip, sip->si_cont_list, &sps, 0); } @@ -2273,17 +2317,17 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) * At the toplevel only spell check when ":syn spell toplevel" * was used. */ if (current_trans_id == 0) - *can_spell = (syn_buf->b_syn_spell == SYNSPL_TOP); + *can_spell = (syn_block->b_syn_spell == SYNSPL_TOP); else { sps.inc_tag = 0; - sps.id = syn_buf->b_spell_cluster_id; + sps.id = syn_block->b_spell_cluster_id; sps.cont_in_list = NULL; *can_spell = in_id_list(sip, sip->si_cont_list, &sps, 0); - if (syn_buf->b_nospell_cluster_id != 0) + if (syn_block->b_nospell_cluster_id != 0) { - sps.id = syn_buf->b_nospell_cluster_id; + sps.id = syn_block->b_nospell_cluster_id; if (in_id_list(sip, sip->si_cont_list, &sps, 0)) *can_spell = FALSE; } @@ -2315,9 +2359,9 @@ syn_current_attr(syncing, displaying, can_spell, keep_state) else if (can_spell != NULL) /* Default: Only do spelling when there is no @Spell cluster or when * ":syn spell toplevel" was used. */ - *can_spell = syn_buf->b_syn_spell == SYNSPL_DEFAULT - ? (syn_buf->b_spell_cluster_id == 0) - : (syn_buf->b_syn_spell == SYNSPL_TOP); + *can_spell = syn_block->b_syn_spell == SYNSPL_DEFAULT + ? (syn_block->b_spell_cluster_id == 0) + : (syn_block->b_syn_spell == SYNSPL_TOP); /* nextgroup ends at end of line, unless "skipnl" or "skipempty" present */ if (current_next_list != NULL @@ -2370,8 +2414,11 @@ push_next_match(cur_si) stateitem_T *cur_si; { synpat_T *spp; +#ifdef FEAT_CONCEAL + int save_flags; +#endif - spp = &(SYN_ITEMS(syn_buf)[next_match_idx]); + spp = &(SYN_ITEMS(syn_block)[next_match_idx]); /* * Push the item in current_state stack; @@ -2387,6 +2434,12 @@ push_next_match(cur_si) cur_si->si_m_startcol = current_col; cur_si->si_m_lnum = current_lnum; cur_si->si_flags = spp->sp_flags; +#ifdef FEAT_CONCEAL + cur_si->si_char = spp->sp_char; + if (current_state.ga_len > 1) + cur_si->si_flags |= + CUR_STATE(current_state.ga_len - 2).si_flags & HL_CONCEAL; +#endif cur_si->si_next_list = spp->sp_next_list; cur_si->si_extmatch = ref_extmatch(next_match_extmatch); if (spp->sp_type == SPTYPE_START && !(spp->sp_flags & HL_ONELINE)) @@ -2409,6 +2462,9 @@ push_next_match(cur_si) check_keepend(); update_si_attr(current_state.ga_len - 1); +#ifdef FEAT_CONCEAL + save_flags = cur_si->si_flags & (HL_CONCEAL | HL_CONCEALENDS); +#endif /* * If the start pattern has another highlight group, push another item * on the stack for the start pattern. @@ -2426,6 +2482,11 @@ push_next_match(cur_si) cur_si->si_ends = TRUE; cur_si->si_end_idx = 0; cur_si->si_flags = HL_MATCH; +#ifdef FEAT_CONCEAL + cur_si->si_flags |= save_flags; + if (cur_si->si_flags & HL_CONCEALENDS) + cur_si->si_flags |= HL_CONCEAL; +#endif cur_si->si_next_list = NULL; check_keepend(); update_si_attr(current_state.ga_len - 1); @@ -2470,6 +2531,10 @@ check_state_ends() cur_si->si_m_endpos = cur_si->si_eoe_pos; cur_si->si_h_endpos = cur_si->si_eoe_pos; cur_si->si_flags |= HL_MATCH; +#ifdef FEAT_CONCEAL + if (cur_si->si_flags & HL_CONCEALENDS) + cur_si->si_flags |= HL_CONCEAL; +#endif update_si_attr(current_state.ga_len - 1); /* what matches next may be different now, clear it */ @@ -2516,7 +2581,7 @@ check_state_ends() * - "excludenl" is used (HL_HAS_EOL won't be set) */ if (cur_si->si_idx >= 0 - && SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_type + && SYN_ITEMS(syn_block)[cur_si->si_idx].sp_type == SPTYPE_START && !(cur_si->si_flags & (HL_MATCH | HL_KEEPEND))) { @@ -2549,7 +2614,7 @@ update_si_attr(idx) if (sip->si_idx < 0) return; - spp = &(SYN_ITEMS(syn_buf)[sip->si_idx]); + spp = &(SYN_ITEMS(syn_block)[sip->si_idx]); if (sip->si_flags & HL_MATCH) sip->si_id = spp->sp_syn_match_id; else @@ -2689,7 +2754,7 @@ update_si_end(sip, startcol, force) if (endpos.lnum == 0) { /* No end pattern matched. */ - if (SYN_ITEMS(syn_buf)[sip->si_idx].sp_flags & HL_ONELINE) + if (SYN_ITEMS(syn_block)[sip->si_idx].sp_flags & HL_ONELINE) { /* a "oneline" never continues in the next line */ sip->si_ends = TRUE; @@ -2791,7 +2856,7 @@ find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos, * Can happen with a match that continues to the next line, because it * contained a region. */ - spp = &(SYN_ITEMS(syn_buf)[idx]); + spp = &(SYN_ITEMS(syn_block)[idx]); if (spp->sp_type != SPTYPE_START) { *hl_endpos = *startpos; @@ -2803,7 +2868,7 @@ find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos, */ for (;;) { - spp = &(SYN_ITEMS(syn_buf)[idx]); + spp = &(SYN_ITEMS(syn_block)[idx]); if (spp->sp_type != SPTYPE_START) break; ++idx; @@ -2833,11 +2898,11 @@ find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos, * Find end pattern that matches first after "matchcol". */ best_idx = -1; - for (idx = start_idx; idx < syn_buf->b_syn_patterns.ga_len; ++idx) + for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; ++idx) { int lc_col = matchcol; - spp = &(SYN_ITEMS(syn_buf)[idx]); + spp = &(SYN_ITEMS(syn_block)[idx]); if (spp->sp_type != SPTYPE_END) /* past last END pattern */ break; lc_col -= spp->sp_offsets[SPO_LC_OFF]; @@ -2915,7 +2980,7 @@ find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos, * Match from start pattern to end pattern. * Correct for match and highlight offset of end pattern. */ - spp = &(SYN_ITEMS(syn_buf)[best_idx]); + spp = &(SYN_ITEMS(syn_block)[best_idx]); syn_add_end_off(m_endpos, &best_regmatch, spp, SPO_ME_OFF, 1); /* can't end before the start */ if (m_endpos->lnum == startpos->lnum && m_endpos->col < startpos->col) @@ -3146,13 +3211,14 @@ syn_regexec(rmp, lnum, col) * Return it's ID if found, 0 otherwise. */ static int -check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si) +check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si, ccharp) char_u *line; int startcol; /* position in line to check for keyword */ int *endcolp; /* return: character after found keyword */ long *flagsp; /* return: flags of matching keyword */ short **next_listp; /* return: next_list of matching keyword */ stateitem_T *cur_si; /* item at the top of the stack */ + int *ccharp UNUSED; /* conceal substitution char */ { keyentry_T *kp; char_u *kwp; @@ -3193,7 +3259,7 @@ check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si) */ for (round = 1; round <= 2; ++round) { - ht = round == 1 ? &syn_buf->b_keywtab : &syn_buf->b_keywtab_ic; + ht = round == 1 ? &syn_block->b_keywtab : &syn_block->b_keywtab_ic; if (ht->ht_used == 0) continue; if (round == 2) /* ignore case */ @@ -3220,6 +3286,9 @@ check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si) *endcolp = startcol + kwlen; *flagsp = kp->flags; *next_listp = kp->next_list; +#ifdef FEAT_CONCEAL + *ccharp = kp->k_char; +#endif return kp->k_syn.id; } } @@ -3228,6 +3297,32 @@ check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si) } /* + * Handle ":syntax conceal" command. + */ + static void +syn_cmd_conceal(eap, syncing) + exarg_T *eap UNUSED; + int syncing UNUSED; +{ +#ifdef FEAT_CONCEAL + char_u *arg = eap->arg; + char_u *next; + + eap->nextcmd = find_nextcmd(arg); + if (eap->skip) + return; + + next = skiptowhite(arg); + if (STRNICMP(arg, "on", 2) == 0 && next - arg == 2) + curwin->w_s->b_syn_conceal = TRUE; + else if (STRNICMP(arg, "off", 3) == 0 && next - arg == 3) + curwin->w_s->b_syn_conceal = FALSE; + else + EMSG2(_("E390: Illegal argument: %s"), arg); +#endif +} + +/* * Handle ":syntax case" command. */ static void @@ -3244,9 +3339,9 @@ syn_cmd_case(eap, syncing) next = skiptowhite(arg); if (STRNICMP(arg, "match", 5) == 0 && next - arg == 5) - curbuf->b_syn_ic = FALSE; + curwin->w_s->b_syn_ic = FALSE; else if (STRNICMP(arg, "ignore", 6) == 0 && next - arg == 6) - curbuf->b_syn_ic = TRUE; + curwin->w_s->b_syn_ic = TRUE; else EMSG2(_("E390: Illegal argument: %s"), arg); } @@ -3268,11 +3363,11 @@ syn_cmd_spell(eap, syncing) next = skiptowhite(arg); if (STRNICMP(arg, "toplevel", 8) == 0 && next - arg == 8) - curbuf->b_syn_spell = SYNSPL_TOP; + curwin->w_s->b_syn_spell = SYNSPL_TOP; else if (STRNICMP(arg, "notoplevel", 10) == 0 && next - arg == 10) - curbuf->b_syn_spell = SYNSPL_NOTOP; + curwin->w_s->b_syn_spell = SYNSPL_NOTOP; else if (STRNICMP(arg, "default", 7) == 0 && next - arg == 7) - curbuf->b_syn_spell = SYNSPL_DEFAULT; + curwin->w_s->b_syn_spell = SYNSPL_DEFAULT; else EMSG2(_("E390: Illegal argument: %s"), arg); } @@ -3281,47 +3376,47 @@ syn_cmd_spell(eap, syncing) * Clear all syntax info for one buffer. */ void -syntax_clear(buf) - buf_T *buf; +syntax_clear(block) + synblock_T *block; { int i; - buf->b_syn_error = FALSE; /* clear previous error */ - buf->b_syn_ic = FALSE; /* Use case, by default */ - buf->b_syn_spell = SYNSPL_DEFAULT; /* default spell checking */ - buf->b_syn_containedin = FALSE; + block->b_syn_error = FALSE; /* clear previous error */ + block->b_syn_ic = FALSE; /* Use case, by default */ + block->b_syn_spell = SYNSPL_DEFAULT; /* default spell checking */ + block->b_syn_containedin = FALSE; /* free the keywords */ - clear_keywtab(&buf->b_keywtab); - clear_keywtab(&buf->b_keywtab_ic); + clear_keywtab(&block->b_keywtab); + clear_keywtab(&block->b_keywtab_ic); /* free the syntax patterns */ - for (i = buf->b_syn_patterns.ga_len; --i >= 0; ) - syn_clear_pattern(buf, i); - ga_clear(&buf->b_syn_patterns); + for (i = block->b_syn_patterns.ga_len; --i >= 0; ) + syn_clear_pattern(block, i); + ga_clear(&block->b_syn_patterns); /* free the syntax clusters */ - for (i = buf->b_syn_clusters.ga_len; --i >= 0; ) - syn_clear_cluster(buf, i); - ga_clear(&buf->b_syn_clusters); - buf->b_spell_cluster_id = 0; - buf->b_nospell_cluster_id = 0; - - buf->b_syn_sync_flags = 0; - buf->b_syn_sync_minlines = 0; - buf->b_syn_sync_maxlines = 0; - buf->b_syn_sync_linebreaks = 0; - - vim_free(buf->b_syn_linecont_prog); - buf->b_syn_linecont_prog = NULL; - vim_free(buf->b_syn_linecont_pat); - buf->b_syn_linecont_pat = NULL; + for (i = block->b_syn_clusters.ga_len; --i >= 0; ) + syn_clear_cluster(block, i); + ga_clear(&block->b_syn_clusters); + block->b_spell_cluster_id = 0; + block->b_nospell_cluster_id = 0; + + block->b_syn_sync_flags = 0; + block->b_syn_sync_minlines = 0; + block->b_syn_sync_maxlines = 0; + block->b_syn_sync_linebreaks = 0; + + vim_free(block->b_syn_linecont_prog); + block->b_syn_linecont_prog = NULL; + vim_free(block->b_syn_linecont_pat); + block->b_syn_linecont_pat = NULL; #ifdef FEAT_FOLDING - buf->b_syn_folditems = 0; + block->b_syn_folditems = 0; #endif /* free the stored states */ - syn_stack_free_all(buf); + syn_stack_free_all(block); invalidate_current_state(); } @@ -3334,42 +3429,42 @@ syntax_sync_clear() int i; /* free the syntax patterns */ - for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; ) - if (SYN_ITEMS(curbuf)[i].sp_syncing) - syn_remove_pattern(curbuf, i); + for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0; ) + if (SYN_ITEMS(curwin->w_s)[i].sp_syncing) + syn_remove_pattern(curwin->w_s, i); - curbuf->b_syn_sync_flags = 0; - curbuf->b_syn_sync_minlines = 0; - curbuf->b_syn_sync_maxlines = 0; - curbuf->b_syn_sync_linebreaks = 0; + curwin->w_s->b_syn_sync_flags = 0; + curwin->w_s->b_syn_sync_minlines = 0; + curwin->w_s->b_syn_sync_maxlines = 0; + curwin->w_s->b_syn_sync_linebreaks = 0; - vim_free(curbuf->b_syn_linecont_prog); - curbuf->b_syn_linecont_prog = NULL; - vim_free(curbuf->b_syn_linecont_pat); - curbuf->b_syn_linecont_pat = NULL; + vim_free(curwin->w_s->b_syn_linecont_prog); + curwin->w_s->b_syn_linecont_prog = NULL; + vim_free(curwin->w_s->b_syn_linecont_pat); + curwin->w_s->b_syn_linecont_pat = NULL; - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ } /* * Remove one pattern from the buffer's pattern list. */ static void -syn_remove_pattern(buf, idx) - buf_T *buf; +syn_remove_pattern(block, idx) + synblock_T *block; int idx; { synpat_T *spp; - spp = &(SYN_ITEMS(buf)[idx]); + spp = &(SYN_ITEMS(block)[idx]); #ifdef FEAT_FOLDING if (spp->sp_flags & HL_FOLD) - --buf->b_syn_folditems; + --block->b_syn_folditems; #endif - syn_clear_pattern(buf, idx); + syn_clear_pattern(block, idx); mch_memmove(spp, spp + 1, - sizeof(synpat_T) * (buf->b_syn_patterns.ga_len - idx - 1)); - --buf->b_syn_patterns.ga_len; + sizeof(synpat_T) * (block->b_syn_patterns.ga_len - idx - 1)); + --block->b_syn_patterns.ga_len; } /* @@ -3377,18 +3472,18 @@ syn_remove_pattern(buf, idx) * last to first! */ static void -syn_clear_pattern(buf, i) - buf_T *buf; +syn_clear_pattern(block, i) + synblock_T *block; int i; { - vim_free(SYN_ITEMS(buf)[i].sp_pattern); - vim_free(SYN_ITEMS(buf)[i].sp_prog); + vim_free(SYN_ITEMS(block)[i].sp_pattern); + vim_free(SYN_ITEMS(block)[i].sp_prog); /* Only free sp_cont_list and sp_next_list of first start pattern */ - if (i == 0 || SYN_ITEMS(buf)[i - 1].sp_type != SPTYPE_START) + if (i == 0 || SYN_ITEMS(block)[i - 1].sp_type != SPTYPE_START) { - vim_free(SYN_ITEMS(buf)[i].sp_cont_list); - vim_free(SYN_ITEMS(buf)[i].sp_next_list); - vim_free(SYN_ITEMS(buf)[i].sp_syn.cont_in_list); + vim_free(SYN_ITEMS(block)[i].sp_cont_list); + vim_free(SYN_ITEMS(block)[i].sp_next_list); + vim_free(SYN_ITEMS(block)[i].sp_syn.cont_in_list); } } @@ -3396,13 +3491,13 @@ syn_clear_pattern(buf, i) * Clear and free one syntax cluster. */ static void -syn_clear_cluster(buf, i) - buf_T *buf; +syn_clear_cluster(block, i) + synblock_T *block; int i; { - vim_free(SYN_CLSTR(buf)[i].scl_name); - vim_free(SYN_CLSTR(buf)[i].scl_name_u); - vim_free(SYN_CLSTR(buf)[i].scl_list); + vim_free(SYN_CLSTR(block)[i].scl_name); + vim_free(SYN_CLSTR(block)[i].scl_name_u); + vim_free(SYN_CLSTR(block)[i].scl_list); } /* @@ -3427,7 +3522,7 @@ syn_cmd_clear(eap, syncing) * Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn * clear". */ - if (curbuf->b_syn_topgrp != 0) + if (curwin->w_s->b_syn_topgrp != 0) return; if (ends_excmd(*arg)) @@ -3439,8 +3534,12 @@ syn_cmd_clear(eap, syncing) syntax_sync_clear(); else { - syntax_clear(curbuf); - do_unlet((char_u *)"b:current_syntax", TRUE); + syntax_clear(curwin->w_s); + if (curwin->w_s == &curwin->w_buffer->b_s) + do_unlet((char_u *)"b:current_syntax", TRUE); + else + do_unlet((char_u *)"w:current_syntax", TRUE); + } } else @@ -3468,8 +3567,8 @@ syn_cmd_clear(eap, syncing) */ short scl_id = id - SYNID_CLUSTER; - vim_free(SYN_CLSTR(curbuf)[scl_id].scl_list); - SYN_CLSTR(curbuf)[scl_id].scl_list = NULL; + vim_free(SYN_CLSTR(curwin->w_s)[scl_id].scl_list); + SYN_CLSTR(curwin->w_s)[scl_id].scl_list = NULL; } } else @@ -3487,7 +3586,7 @@ syn_cmd_clear(eap, syncing) } } redraw_curbuf_later(SOME_VALID); - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ } /* @@ -3504,17 +3603,17 @@ syn_clear_one(id, syncing) /* Clear keywords only when not ":syn sync clear group-name" */ if (!syncing) { - (void)syn_clear_keyword(id, &curbuf->b_keywtab); - (void)syn_clear_keyword(id, &curbuf->b_keywtab_ic); + (void)syn_clear_keyword(id, &curwin->w_s->b_keywtab); + (void)syn_clear_keyword(id, &curwin->w_s->b_keywtab_ic); } /* clear the patterns for "id" */ - for (idx = curbuf->b_syn_patterns.ga_len; --idx >= 0; ) + for (idx = curwin->w_s->b_syn_patterns.ga_len; --idx >= 0; ) { - spp = &(SYN_ITEMS(curbuf)[idx]); + spp = &(SYN_ITEMS(curwin->w_s)[idx]); if (spp->sp_syn.id != id || spp->sp_syncing != syncing) continue; - syn_remove_pattern(curbuf, idx); + syn_remove_pattern(curwin->w_s, idx); } } @@ -3613,7 +3712,7 @@ syn_cmd_list(eap, syncing) if (eap->skip) return; - if (!syntax_present(curbuf)) + if (!syntax_present(curwin)) { MSG(_("No Syntax items defined for this buffer")); return; @@ -3621,30 +3720,30 @@ syn_cmd_list(eap, syncing) if (syncing) { - if (curbuf->b_syn_sync_flags & SF_CCOMMENT) + if (curwin->w_s->b_syn_sync_flags & SF_CCOMMENT) { MSG_PUTS(_("syncing on C-style comments")); syn_lines_msg(); syn_match_msg(); return; } - else if (!(curbuf->b_syn_sync_flags & SF_MATCH)) + else if (!(curwin->w_s->b_syn_sync_flags & SF_MATCH)) { - if (curbuf->b_syn_sync_minlines == 0) + if (curwin->w_s->b_syn_sync_minlines == 0) MSG_PUTS(_("no syncing")); else { MSG_PUTS(_("syncing starts ")); - msg_outnum(curbuf->b_syn_sync_minlines); + msg_outnum(curwin->w_s->b_syn_sync_minlines); MSG_PUTS(_(" lines before top line")); syn_match_msg(); } return; } MSG_PUTS_TITLE(_("\n--- Syntax sync items ---")); - if (curbuf->b_syn_sync_minlines > 0 - || curbuf->b_syn_sync_maxlines > 0 - || curbuf->b_syn_sync_linebreaks > 0) + if (curwin->w_s->b_syn_sync_minlines > 0 + || curwin->w_s->b_syn_sync_maxlines > 0 + || curwin->w_s->b_syn_sync_linebreaks > 0) { MSG_PUTS(_("\nsyncing on items")); syn_lines_msg(); @@ -3660,7 +3759,7 @@ syn_cmd_list(eap, syncing) */ for (id = 1; id <= highlight_ga.ga_len && !got_int; ++id) syn_list_one(id, syncing, FALSE); - for (id = 0; id < curbuf->b_syn_clusters.ga_len && !got_int; ++id) + for (id = 0; id < curwin->w_s->b_syn_clusters.ga_len && !got_int; ++id) syn_list_cluster(id); } else @@ -3696,20 +3795,21 @@ syn_cmd_list(eap, syncing) static void syn_lines_msg() { - if (curbuf->b_syn_sync_maxlines > 0 || curbuf->b_syn_sync_minlines > 0) + if (curwin->w_s->b_syn_sync_maxlines > 0 + || curwin->w_s->b_syn_sync_minlines > 0) { MSG_PUTS("; "); - if (curbuf->b_syn_sync_minlines > 0) + if (curwin->w_s->b_syn_sync_minlines > 0) { MSG_PUTS(_("minimal ")); - msg_outnum(curbuf->b_syn_sync_minlines); - if (curbuf->b_syn_sync_maxlines) + msg_outnum(curwin->w_s->b_syn_sync_minlines); + if (curwin->w_s->b_syn_sync_maxlines) MSG_PUTS(", "); } - if (curbuf->b_syn_sync_maxlines > 0) + if (curwin->w_s->b_syn_sync_maxlines > 0) { MSG_PUTS(_("maximal ")); - msg_outnum(curbuf->b_syn_sync_maxlines); + msg_outnum(curwin->w_s->b_syn_sync_maxlines); } MSG_PUTS(_(" lines before top line")); } @@ -3718,10 +3818,10 @@ syn_lines_msg() static void syn_match_msg() { - if (curbuf->b_syn_sync_linebreaks > 0) + if (curwin->w_s->b_syn_sync_linebreaks > 0) { MSG_PUTS(_("; match ")); - msg_outnum(curbuf->b_syn_sync_linebreaks); + msg_outnum(curwin->w_s->b_syn_sync_linebreaks); MSG_PUTS(_(" line breaks")); } } @@ -3759,6 +3859,10 @@ syn_list_one(id, syncing, link_only) {HL_EXCLUDENL, "excludenl"}, {HL_TRANSP, "transparent"}, {HL_FOLD, "fold"}, +#ifdef FEAT_CONCEAL + {HL_CONCEAL, "conceal"}, + {HL_CONCEALENDS, "concealends"}, +#endif {0, NULL} }; static struct name_list namelist2[] = @@ -3774,15 +3878,15 @@ syn_list_one(id, syncing, link_only) /* list the keywords for "id" */ if (!syncing) { - did_header = syn_list_keywords(id, &curbuf->b_keywtab, FALSE, attr); - did_header = syn_list_keywords(id, &curbuf->b_keywtab_ic, + did_header = syn_list_keywords(id, &curwin->w_s->b_keywtab, FALSE, attr); + did_header = syn_list_keywords(id, &curwin->w_s->b_keywtab_ic, did_header, attr); } /* list the patterns for "id" */ - for (idx = 0; idx < curbuf->b_syn_patterns.ga_len && !got_int; ++idx) + for (idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len && !got_int; ++idx) { - spp = &(SYN_ITEMS(curbuf)[idx]); + spp = &(SYN_ITEMS(curwin->w_s)[idx]); if (spp->sp_syn.id != id || spp->sp_syncing != syncing) continue; @@ -3796,13 +3900,13 @@ syn_list_one(id, syncing, link_only) } else if (spp->sp_type == SPTYPE_START) { - while (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_START) - put_pattern("start", '=', &SYN_ITEMS(curbuf)[idx++], attr); - if (SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_SKIP) - put_pattern("skip", '=', &SYN_ITEMS(curbuf)[idx++], attr); - while (idx < curbuf->b_syn_patterns.ga_len - && SYN_ITEMS(curbuf)[idx].sp_type == SPTYPE_END) - put_pattern("end", '=', &SYN_ITEMS(curbuf)[idx++], attr); + while (SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_START) + put_pattern("start", '=', &SYN_ITEMS(curwin->w_s)[idx++], attr); + if (SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_SKIP) + put_pattern("skip", '=', &SYN_ITEMS(curwin->w_s)[idx++], attr); + while (idx < curwin->w_s->b_syn_patterns.ga_len + && SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_END) + put_pattern("end", '=', &SYN_ITEMS(curwin->w_s)[idx++], attr); --idx; msg_putchar(' '); } @@ -3828,7 +3932,7 @@ syn_list_one(id, syncing, link_only) msg_puts_attr((char_u *)"groupthere", attr); msg_putchar(' '); if (spp->sp_sync_idx >= 0) - msg_outtrans(HL_TABLE()[SYN_ITEMS(curbuf) + msg_outtrans(HL_TABLE()[SYN_ITEMS(curwin->w_s) [spp->sp_sync_idx].sp_syn.id - 1].sg_name); else MSG_PUTS("NONE"); @@ -3873,7 +3977,7 @@ syn_list_cluster(id) /* slight hack: roughly duplicate the guts of syn_list_header() */ msg_putchar('\n'); - msg_outtrans(SYN_CLSTR(curbuf)[id].scl_name); + msg_outtrans(SYN_CLSTR(curwin->w_s)[id].scl_name); if (msg_col >= endcol) /* output at least one space */ endcol = msg_col + 1; @@ -3881,9 +3985,9 @@ syn_list_cluster(id) endcol = Columns - 1; msg_advance(endcol); - if (SYN_CLSTR(curbuf)[id].scl_list != NULL) + if (SYN_CLSTR(curwin->w_s)[id].scl_list != NULL) { - put_id_list((char_u *)"cluster", SYN_CLSTR(curbuf)[id].scl_list, + put_id_list((char_u *)"cluster", SYN_CLSTR(curwin->w_s)[id].scl_list, hl_attr(HLF_D)); } else @@ -3925,7 +4029,7 @@ put_id_list(name, list, attr) short scl_id = *p - SYNID_CLUSTER; msg_putchar('@'); - msg_outtrans(SYN_CLSTR(curbuf)[scl_id].scl_name); + msg_outtrans(SYN_CLSTR(curwin->w_s)[scl_id].scl_name); } else msg_outtrans(HL_TABLE()[*p - 1].sg_name); @@ -4190,12 +4294,13 @@ clear_keywtab(ht) * Add a keyword to the list of keywords. */ static void -add_keyword(name, id, flags, cont_in_list, next_list) +add_keyword(name, id, flags, cont_in_list, next_list, conceal_char) char_u *name; /* name of keyword */ int id; /* group ID for this keyword */ int flags; /* flags for this keyword */ short *cont_in_list; /* containedin for this keyword */ short *next_list; /* nextgroup for this keyword */ + int conceal_char; { keyentry_T *kp; hashtab_T *ht; @@ -4204,7 +4309,7 @@ add_keyword(name, id, flags, cont_in_list, next_list) long_u hash; char_u name_folded[MAXKEYWLEN + 1]; - if (curbuf->b_syn_ic) + if (curwin->w_s->b_syn_ic) name_ic = str_foldcase(name, (int)STRLEN(name), name_folded, MAXKEYWLEN + 1); else @@ -4216,15 +4321,16 @@ add_keyword(name, id, flags, cont_in_list, next_list) kp->k_syn.id = id; kp->k_syn.inc_tag = current_syn_inc_tag; kp->flags = flags; + kp->k_char = conceal_char; kp->k_syn.cont_in_list = copy_id_list(cont_in_list); if (cont_in_list != NULL) - curbuf->b_syn_containedin = TRUE; + curwin->w_s->b_syn_containedin = TRUE; kp->next_list = copy_id_list(next_list); - if (curbuf->b_syn_ic) - ht = &curbuf->b_keywtab_ic; + if (curwin->w_s->b_syn_ic) + ht = &curwin->w_s->b_keywtab_ic; else - ht = &curbuf->b_keywtab; + ht = &curwin->w_s->b_keywtab; hash = hash_hash(kp->keyword); hi = hash_lookup(ht, kp->keyword, hash); @@ -4275,9 +4381,10 @@ get_group_name(arg, name_end) * Return NULL for any error; */ static char_u * -get_syn_options(arg, opt) +get_syn_options(arg, opt, conceal_char) char_u *arg; /* next argument to be checked */ syn_opt_arg_T *opt; /* various things */ + int *conceal_char UNUSED; { char_u *gname_start, *gname; int syn_id; @@ -4303,6 +4410,9 @@ get_syn_options(arg, opt) {"gGrRoOuUpPtThHeErReE", 0, HL_SYNC_THERE}, {"dDiIsSpPlLaAyY", 0, HL_DISPLAY}, {"fFoOlLdD", 0, HL_FOLD}, + {"cCoOnNcCeEaAlL", 0, HL_CONCEAL}, + {"cCoOnNcCeEaAlLeEnNdDsS", 0, HL_CONCEALENDS}, + {"cCcChHaArR", 11, 0}, {"cCoOnNtTaAiInNsS", 1, 0}, {"cCoOnNtTaAiInNeEdDiInN", 2, 0}, {"nNeExXtTgGrRoOuUpP", 3, 0}, @@ -4312,6 +4422,11 @@ get_syn_options(arg, opt) if (arg == NULL) /* already detected error */ return NULL; +#ifdef FEAT_CONCEAL + if (curwin->w_s->b_syn_conceal) + opt->flags |= HL_CONCEAL; +#endif + for (;;) { /* @@ -4372,6 +4487,26 @@ get_syn_options(arg, opt) if (get_id_list(&arg, 9, &opt->next_list) == FAIL) return NULL; } + else if (flagtab[fidx].argtype == 11 && arg[5] == '=') + { +#ifdef FEAT_MBYTE + /* cchar=? */ + if (has_mbyte) + { +# ifdef FEAT_CONCEAL + *conceal_char = mb_ptr2char(arg + 6); +# endif + arg += mb_ptr2len(arg + 6) - 1; + } + else +#endif +#ifdef FEAT_CONCEAL + *conceal_char = arg[6]; +#else + ; +#endif + arg = skipwhite(arg + 7); + } else { opt->flags |= flagtab[fidx].flags; @@ -4397,9 +4532,9 @@ get_syn_options(arg, opt) else { syn_id = syn_name2id(gname); - for (i = curbuf->b_syn_patterns.ga_len; --i >= 0; ) - if (SYN_ITEMS(curbuf)[i].sp_syn.id == syn_id - && SYN_ITEMS(curbuf)[i].sp_type == SPTYPE_START) + for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0; ) + if (SYN_ITEMS(curwin->w_s)[i].sp_syn.id == syn_id + && SYN_ITEMS(curwin->w_s)[i].sp_type == SPTYPE_START) { *opt->sync_idx = i; break; @@ -4437,20 +4572,20 @@ syn_incl_toplevel(id, flagsp) int id; int *flagsp; { - if ((*flagsp & HL_CONTAINED) || curbuf->b_syn_topgrp == 0) + if ((*flagsp & HL_CONTAINED) || curwin->w_s->b_syn_topgrp == 0) return; *flagsp |= HL_CONTAINED; - if (curbuf->b_syn_topgrp >= SYNID_CLUSTER) + if (curwin->w_s->b_syn_topgrp >= SYNID_CLUSTER) { /* We have to alloc this, because syn_combine_list() will free it. */ short *grp_list = (short *)alloc((unsigned)(2 * sizeof(short))); - int tlg_id = curbuf->b_syn_topgrp - SYNID_CLUSTER; + int tlg_id = curwin->w_s->b_syn_topgrp - SYNID_CLUSTER; if (grp_list != NULL) { grp_list[0] = id; grp_list[1] = 0; - syn_combine_list(&SYN_CLSTR(curbuf)[tlg_id].scl_list, &grp_list, + syn_combine_list(&SYN_CLSTR(curwin->w_s)[tlg_id].scl_list, &grp_list, CLUSTER_ADD); } } @@ -4517,12 +4652,12 @@ syn_cmd_include(eap, syncing) */ prev_syn_inc_tag = current_syn_inc_tag; current_syn_inc_tag = ++running_syn_inc_tag; - prev_toplvl_grp = curbuf->b_syn_topgrp; - curbuf->b_syn_topgrp = sgl_id; + prev_toplvl_grp = curwin->w_s->b_syn_topgrp; + curwin->w_s->b_syn_topgrp = sgl_id; if (source ? do_source(eap->arg, FALSE, DOSO_NONE) == FAIL : source_runtime(eap->arg, TRUE) == FAIL) EMSG2(_(e_notopen), eap->arg); - curbuf->b_syn_topgrp = prev_toplvl_grp; + curwin->w_s->b_syn_topgrp = prev_toplvl_grp; current_syn_inc_tag = prev_syn_inc_tag; } @@ -4543,6 +4678,7 @@ syn_cmd_keyword(eap, syncing) char_u *kw; syn_opt_arg_T syn_opt_arg; int cnt; + int conceal_char = NUL; rest = get_group_name(arg, &group_name_end); @@ -4570,7 +4706,7 @@ syn_cmd_keyword(eap, syncing) p = keyword_copy; for ( ; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest)) { - rest = get_syn_options(rest, &syn_opt_arg); + rest = get_syn_options(rest, &syn_opt_arg, &conceal_char); if (rest == NULL || ends_excmd(*rest)) break; /* Copy the keyword, removing backslashes, and add a NUL. */ @@ -4599,8 +4735,8 @@ syn_cmd_keyword(eap, syncing) if (p != NULL) *p = NUL; add_keyword(kw, syn_id, syn_opt_arg.flags, - syn_opt_arg.cont_in_list, - syn_opt_arg.next_list); + syn_opt_arg.cont_in_list, + syn_opt_arg.next_list, conceal_char); if (p == NULL) break; if (p[1] == NUL) @@ -4644,7 +4780,7 @@ syn_cmd_keyword(eap, syncing) EMSG2(_(e_invarg2), arg); redraw_curbuf_later(SOME_VALID); - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ } /* @@ -4665,6 +4801,7 @@ syn_cmd_match(eap, syncing) int idx; syn_opt_arg_T syn_opt_arg; int sync_idx = 0; + int conceal_char = NUL; /* Isolate the group name, check for validity */ rest = get_group_name(arg, &group_name_end); @@ -4677,7 +4814,7 @@ syn_cmd_match(eap, syncing) syn_opt_arg.cont_list = NULL; syn_opt_arg.cont_in_list = NULL; syn_opt_arg.next_list = NULL; - rest = get_syn_options(rest, &syn_opt_arg); + rest = get_syn_options(rest, &syn_opt_arg, &conceal_char); /* get the pattern. */ init_syn_patterns(); @@ -4687,7 +4824,7 @@ syn_cmd_match(eap, syncing) syn_opt_arg.flags |= HL_HAS_EOL; /* Get options after the pattern */ - rest = get_syn_options(rest, &syn_opt_arg); + rest = get_syn_options(rest, &syn_opt_arg, &conceal_char); if (rest != NULL) /* all arguments are valid */ { @@ -4697,7 +4834,7 @@ syn_cmd_match(eap, syncing) eap->nextcmd = check_nextcmd(rest); if (!ends_excmd(*rest) || eap->skip) rest = NULL; - else if (ga_grow(&curbuf->b_syn_patterns, 1) != FAIL + else if (ga_grow(&curwin->w_s->b_syn_patterns, 1) != FAIL && (syn_id = syn_check_group(arg, (int)(group_name_end - arg))) != 0) { @@ -4705,32 +4842,35 @@ syn_cmd_match(eap, syncing) /* * Store the pattern in the syn_items list */ - idx = curbuf->b_syn_patterns.ga_len; - SYN_ITEMS(curbuf)[idx] = item; - SYN_ITEMS(curbuf)[idx].sp_syncing = syncing; - SYN_ITEMS(curbuf)[idx].sp_type = SPTYPE_MATCH; - SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id; - SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag; - SYN_ITEMS(curbuf)[idx].sp_flags = syn_opt_arg.flags; - SYN_ITEMS(curbuf)[idx].sp_sync_idx = sync_idx; - SYN_ITEMS(curbuf)[idx].sp_cont_list = syn_opt_arg.cont_list; - SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list = + idx = curwin->w_s->b_syn_patterns.ga_len; + SYN_ITEMS(curwin->w_s)[idx] = item; + SYN_ITEMS(curwin->w_s)[idx].sp_syncing = syncing; + SYN_ITEMS(curwin->w_s)[idx].sp_type = SPTYPE_MATCH; + SYN_ITEMS(curwin->w_s)[idx].sp_syn.id = syn_id; + SYN_ITEMS(curwin->w_s)[idx].sp_syn.inc_tag = current_syn_inc_tag; + SYN_ITEMS(curwin->w_s)[idx].sp_flags = syn_opt_arg.flags; + SYN_ITEMS(curwin->w_s)[idx].sp_sync_idx = sync_idx; + SYN_ITEMS(curwin->w_s)[idx].sp_cont_list = syn_opt_arg.cont_list; + SYN_ITEMS(curwin->w_s)[idx].sp_syn.cont_in_list = syn_opt_arg.cont_in_list; +#ifdef FEAT_CONCEAL + SYN_ITEMS(curwin->w_s)[idx].sp_char = conceal_char; +#endif if (syn_opt_arg.cont_in_list != NULL) - curbuf->b_syn_containedin = TRUE; - SYN_ITEMS(curbuf)[idx].sp_next_list = syn_opt_arg.next_list; - ++curbuf->b_syn_patterns.ga_len; + curwin->w_s->b_syn_containedin = TRUE; + SYN_ITEMS(curwin->w_s)[idx].sp_next_list = syn_opt_arg.next_list; + ++curwin->w_s->b_syn_patterns.ga_len; /* remember that we found a match for syncing on */ if (syn_opt_arg.flags & (HL_SYNC_HERE|HL_SYNC_THERE)) - curbuf->b_syn_sync_flags |= SF_MATCH; + curwin->w_s->b_syn_sync_flags |= SF_MATCH; #ifdef FEAT_FOLDING if (syn_opt_arg.flags & HL_FOLD) - ++curbuf->b_syn_folditems; + ++curwin->w_s->b_syn_folditems; #endif redraw_curbuf_later(SOME_VALID); - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ return; /* don't free the progs and patterns now */ } } @@ -4785,6 +4925,7 @@ syn_cmd_region(eap, syncing) int success = FALSE; int idx; syn_opt_arg_T syn_opt_arg; + int conceal_char = NUL; /* Isolate the group name, check for validity */ rest = get_group_name(arg, &group_name_end); @@ -4809,7 +4950,7 @@ syn_cmd_region(eap, syncing) while (rest != NULL && !ends_excmd(*rest)) { /* Check for option arguments */ - rest = get_syn_options(rest, &syn_opt_arg); + rest = get_syn_options(rest, &syn_opt_arg, &conceal_char); if (rest == NULL || ends_excmd(*rest)) break; @@ -4933,7 +5074,7 @@ syn_cmd_region(eap, syncing) eap->nextcmd = check_nextcmd(rest); if (!ends_excmd(*rest) || eap->skip) rest = NULL; - else if (ga_grow(&(curbuf->b_syn_patterns), pat_count) != FAIL + else if (ga_grow(&(curwin->w_s->b_syn_patterns), pat_count) != FAIL && (syn_id = syn_check_group(arg, (int)(group_name_end - arg))) != 0) { @@ -4941,43 +5082,46 @@ syn_cmd_region(eap, syncing) /* * Store the start/skip/end in the syn_items list */ - idx = curbuf->b_syn_patterns.ga_len; + idx = curwin->w_s->b_syn_patterns.ga_len; for (item = ITEM_START; item <= ITEM_END; ++item) { for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp->pp_next) { - SYN_ITEMS(curbuf)[idx] = *(ppp->pp_synp); - SYN_ITEMS(curbuf)[idx].sp_syncing = syncing; - SYN_ITEMS(curbuf)[idx].sp_type = + SYN_ITEMS(curwin->w_s)[idx] = *(ppp->pp_synp); + SYN_ITEMS(curwin->w_s)[idx].sp_syncing = syncing; + SYN_ITEMS(curwin->w_s)[idx].sp_type = (item == ITEM_START) ? SPTYPE_START : (item == ITEM_SKIP) ? SPTYPE_SKIP : SPTYPE_END; - SYN_ITEMS(curbuf)[idx].sp_flags |= syn_opt_arg.flags; - SYN_ITEMS(curbuf)[idx].sp_syn.id = syn_id; - SYN_ITEMS(curbuf)[idx].sp_syn.inc_tag = current_syn_inc_tag; - SYN_ITEMS(curbuf)[idx].sp_syn_match_id = + SYN_ITEMS(curwin->w_s)[idx].sp_flags |= syn_opt_arg.flags; + SYN_ITEMS(curwin->w_s)[idx].sp_syn.id = syn_id; + SYN_ITEMS(curwin->w_s)[idx].sp_syn.inc_tag = current_syn_inc_tag; + SYN_ITEMS(curwin->w_s)[idx].sp_syn_match_id = ppp->pp_matchgroup_id; +#ifdef FEAT_CONCEAL + SYN_ITEMS(curwin->w_s)[idx].sp_char = conceal_char; +#endif if (item == ITEM_START) { - SYN_ITEMS(curbuf)[idx].sp_cont_list = + SYN_ITEMS(curwin->w_s)[idx].sp_cont_list = syn_opt_arg.cont_list; - SYN_ITEMS(curbuf)[idx].sp_syn.cont_in_list = + SYN_ITEMS(curwin->w_s)[idx].sp_syn.cont_in_list = syn_opt_arg.cont_in_list; if (syn_opt_arg.cont_in_list != NULL) - curbuf->b_syn_containedin = TRUE; - SYN_ITEMS(curbuf)[idx].sp_next_list = + curwin->w_s->b_syn_containedin = TRUE; + SYN_ITEMS(curwin->w_s)[idx].sp_next_list = syn_opt_arg.next_list; } - ++curbuf->b_syn_patterns.ga_len; + ++curwin->w_s->b_syn_patterns.ga_len; ++idx; #ifdef FEAT_FOLDING if (syn_opt_arg.flags & HL_FOLD) - ++curbuf->b_syn_folditems; + ++curwin->w_s->b_syn_folditems; #endif } } redraw_curbuf_later(SOME_VALID); - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ success = TRUE; /* don't free the progs and patterns now */ } } @@ -5169,9 +5313,9 @@ syn_scl_name2id(name) name_u = vim_strsave_up(name); if (name_u == NULL) return 0; - for (i = curbuf->b_syn_clusters.ga_len; --i >= 0; ) - if (SYN_CLSTR(curbuf)[i].scl_name_u != NULL - && STRCMP(name_u, SYN_CLSTR(curbuf)[i].scl_name_u) == 0) + for (i = curwin->w_s->b_syn_clusters.ga_len; --i >= 0; ) + if (SYN_CLSTR(curwin->w_s)[i].scl_name_u != NULL + && STRCMP(name_u, SYN_CLSTR(curwin->w_s)[i].scl_name_u) == 0) break; vim_free(name_u); return (i < 0 ? 0 : i + SYNID_CLUSTER); @@ -5237,32 +5381,32 @@ syn_add_cluster(name) /* * First call for this growarray: init growing array. */ - if (curbuf->b_syn_clusters.ga_data == NULL) + if (curwin->w_s->b_syn_clusters.ga_data == NULL) { - curbuf->b_syn_clusters.ga_itemsize = sizeof(syn_cluster_T); - curbuf->b_syn_clusters.ga_growsize = 10; + curwin->w_s->b_syn_clusters.ga_itemsize = sizeof(syn_cluster_T); + curwin->w_s->b_syn_clusters.ga_growsize = 10; } /* * Make room for at least one other cluster entry. */ - if (ga_grow(&curbuf->b_syn_clusters, 1) == FAIL) + if (ga_grow(&curwin->w_s->b_syn_clusters, 1) == FAIL) { vim_free(name); return 0; } - len = curbuf->b_syn_clusters.ga_len; + len = curwin->w_s->b_syn_clusters.ga_len; - vim_memset(&(SYN_CLSTR(curbuf)[len]), 0, sizeof(syn_cluster_T)); - SYN_CLSTR(curbuf)[len].scl_name = name; - SYN_CLSTR(curbuf)[len].scl_name_u = vim_strsave_up(name); - SYN_CLSTR(curbuf)[len].scl_list = NULL; - ++curbuf->b_syn_clusters.ga_len; + vim_memset(&(SYN_CLSTR(curwin->w_s)[len]), 0, sizeof(syn_cluster_T)); + SYN_CLSTR(curwin->w_s)[len].scl_name = name; + SYN_CLSTR(curwin->w_s)[len].scl_name_u = vim_strsave_up(name); + SYN_CLSTR(curwin->w_s)[len].scl_list = NULL; + ++curwin->w_s->b_syn_clusters.ga_len; if (STRICMP(name, "Spell") == 0) - curbuf->b_spell_cluster_id = len + SYNID_CLUSTER; + curwin->w_s->b_spell_cluster_id = len + SYNID_CLUSTER; if (STRICMP(name, "NoSpell") == 0) - curbuf->b_nospell_cluster_id = len + SYNID_CLUSTER; + curwin->w_s->b_nospell_cluster_id = len + SYNID_CLUSTER; return len + SYNID_CLUSTER; } @@ -5325,7 +5469,7 @@ syn_cmd_cluster(eap, syncing) EMSG2(_(e_invarg2), rest); break; } - syn_combine_list(&SYN_CLSTR(curbuf)[scl_id].scl_list, + syn_combine_list(&SYN_CLSTR(curwin->w_s)[scl_id].scl_list, &clstr_list, list_op); got_clstr = TRUE; } @@ -5333,7 +5477,7 @@ syn_cmd_cluster(eap, syncing) if (got_clstr) { redraw_curbuf_later(SOME_VALID); - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ } } @@ -5349,8 +5493,8 @@ syn_cmd_cluster(eap, syncing) static void init_syn_patterns() { - curbuf->b_syn_patterns.ga_itemsize = sizeof(synpat_T); - curbuf->b_syn_patterns.ga_growsize = 10; + curwin->w_s->b_syn_patterns.ga_itemsize = sizeof(synpat_T); + curwin->w_s->b_syn_patterns.ga_growsize = 10; } /* @@ -5390,7 +5534,7 @@ get_syn_pattern(arg, ci) if (ci->sp_prog == NULL) return NULL; - ci->sp_ic = curbuf->b_syn_ic; + ci->sp_ic = curwin->w_s->b_syn_ic; /* * Check for a match, highlight or region offset. @@ -5488,17 +5632,17 @@ syn_cmd_sync(eap, syncing) if (STRCMP(key, "CCOMMENT") == 0) { if (!eap->skip) - curbuf->b_syn_sync_flags |= SF_CCOMMENT; + curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT; if (!ends_excmd(*next_arg)) { arg_end = skiptowhite(next_arg); if (!eap->skip) - curbuf->b_syn_sync_id = syn_check_group(next_arg, + curwin->w_s->b_syn_sync_id = syn_check_group(next_arg, (int)(arg_end - next_arg)); next_arg = skipwhite(arg_end); } else if (!eap->skip) - curbuf->b_syn_sync_id = syn_name2id((char_u *)"Comment"); + curwin->w_s->b_syn_sync_id = syn_name2id((char_u *)"Comment"); } else if ( STRNCMP(key, "LINES", 5) == 0 || STRNCMP(key, "MINLINES", 8) == 0 @@ -5520,24 +5664,24 @@ syn_cmd_sync(eap, syncing) if (!eap->skip) { if (key[4] == 'B') - curbuf->b_syn_sync_linebreaks = n; + curwin->w_s->b_syn_sync_linebreaks = n; else if (key[1] == 'A') - curbuf->b_syn_sync_maxlines = n; + curwin->w_s->b_syn_sync_maxlines = n; else - curbuf->b_syn_sync_minlines = n; + curwin->w_s->b_syn_sync_minlines = n; } } else if (STRCMP(key, "FROMSTART") == 0) { if (!eap->skip) { - curbuf->b_syn_sync_minlines = MAXLNUM; - curbuf->b_syn_sync_maxlines = 0; + curwin->w_s->b_syn_sync_minlines = MAXLNUM; + curwin->w_s->b_syn_sync_maxlines = 0; } } else if (STRCMP(key, "LINECONT") == 0) { - if (curbuf->b_syn_linecont_pat != NULL) + if (curwin->w_s->b_syn_linecont_pat != NULL) { EMSG(_("E403: syntax sync: line continuations pattern specified twice")); finished = TRUE; @@ -5553,25 +5697,25 @@ syn_cmd_sync(eap, syncing) if (!eap->skip) { /* store the pattern and compiled regexp program */ - if ((curbuf->b_syn_linecont_pat = vim_strnsave(next_arg + 1, + if ((curwin->w_s->b_syn_linecont_pat = vim_strnsave(next_arg + 1, (int)(arg_end - next_arg - 1))) == NULL) { finished = TRUE; break; } - curbuf->b_syn_linecont_ic = curbuf->b_syn_ic; + curwin->w_s->b_syn_linecont_ic = curwin->w_s->b_syn_ic; /* Make 'cpoptions' empty, to avoid the 'l' flag */ cpo_save = p_cpo; p_cpo = (char_u *)""; - curbuf->b_syn_linecont_prog = - vim_regcomp(curbuf->b_syn_linecont_pat, RE_MAGIC); + curwin->w_s->b_syn_linecont_prog = + vim_regcomp(curwin->w_s->b_syn_linecont_pat, RE_MAGIC); p_cpo = cpo_save; - if (curbuf->b_syn_linecont_prog == NULL) + if (curwin->w_s->b_syn_linecont_prog == NULL) { - vim_free(curbuf->b_syn_linecont_pat); - curbuf->b_syn_linecont_pat = NULL; + vim_free(curwin->w_s->b_syn_linecont_pat); + curwin->w_s->b_syn_linecont_pat = NULL; finished = TRUE; break; } @@ -5601,7 +5745,7 @@ syn_cmd_sync(eap, syncing) { eap->nextcmd = check_nextcmd(arg_start); redraw_curbuf_later(SOME_VALID); - syn_stack_free_all(curbuf); /* Need to recompute all syntax. */ + syn_stack_free_all(curwin->w_s); /* Need to recompute all syntax. */ } } @@ -5862,8 +6006,8 @@ in_id_list(cur_si, list, ssp, contained) --cur_si; /* cur_si->si_idx is -1 for keywords, these never contain anything. */ if (cur_si->si_idx >= 0 && in_id_list(NULL, ssp->cont_in_list, - &(SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_syn), - SYN_ITEMS(syn_buf)[cur_si->si_idx].sp_flags & HL_CONTAINED)) + &(SYN_ITEMS(syn_block)[cur_si->si_idx].sp_syn), + SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags & HL_CONTAINED)) return TRUE; } @@ -5918,7 +6062,7 @@ in_id_list(cur_si, list, ssp, contained) return retval; if (item >= SYNID_CLUSTER) { - scl_list = SYN_CLSTR(syn_buf)[item - SYNID_CLUSTER].scl_list; + scl_list = SYN_CLSTR(syn_block)[item - SYNID_CLUSTER].scl_list; /* restrict recursiveness to 30 to avoid an endless loop for a * cluster that includes itself (indirectly) */ if (scl_list != NULL && depth < 30) @@ -5946,6 +6090,7 @@ static struct subcommand subcommands[] = {"case", syn_cmd_case}, {"clear", syn_cmd_clear}, {"cluster", syn_cmd_cluster}, + {"conceal", syn_cmd_conceal}, {"enable", syn_cmd_enable}, {"include", syn_cmd_include}, {"keyword", syn_cmd_keyword}, @@ -6006,14 +6151,34 @@ ex_syntax(eap) } } + void +ex_ownsyntax(eap) + exarg_T *eap; +{ + if (curwin->w_s == &curwin->w_buffer->b_s) + { + curwin->w_s = (synblock_T *)alloc(sizeof(synblock_T)); + memset(curwin->w_s, 0, sizeof(synblock_T)); +#ifdef FEAT_SPELL + curwin->w_p_spell = FALSE; /* No spell checking */ + clear_string_option(&curwin->w_s->b_p_spc); + clear_string_option(&curwin->w_s->b_p_spf); + vim_free(curwin->w_s->b_cap_prog); + curwin->w_s->b_cap_prog = NULL; + clear_string_option(&curwin->w_s->b_p_spl); +#endif + } + apply_autocmds(EVENT_SYNTAX, eap->arg, curbuf->b_fname, TRUE, curbuf); +} + int -syntax_present(buf) - buf_T *buf; +syntax_present(win) + win_T *win; { - return (buf->b_syn_patterns.ga_len != 0 - || buf->b_syn_clusters.ga_len != 0 - || buf->b_keywtab.ht_used > 0 - || buf->b_keywtab_ic.ht_used > 0); + return (win->w_s->b_syn_patterns.ga_len != 0 + || win->w_s->b_syn_clusters.ga_len != 0 + || win->w_s->b_keywtab.ht_used > 0 + || win->w_s->b_keywtab_ic.ht_used > 0); } #if defined(FEAT_CMDL_COMPL) || defined(PROTO) @@ -6124,11 +6289,22 @@ syn_get_id(wp, lnum, col, trans, spellp, keep_state) || col < current_col) syntax_start(wp, lnum); - (void)get_syntax_attr(col, spellp, keep_state); + (void)get_syntax_attr(col, NULL, spellp, keep_state); return (trans ? current_trans_id : current_id); } +#if defined(FEAT_CONCEAL) || defined(PROTO) +/* + * Return conceal substitution character + */ + int +syn_get_sub_char() +{ + return current_sub_char; +} +#endif + #if defined(FEAT_EVAL) || defined(PROTO) /* * Return the syntax ID at position "i" in the current stack. @@ -6164,7 +6340,7 @@ syn_get_foldlevel(wp, lnum) int i; /* Return quickly when there are no fold items at all. */ - if (wp->w_buffer->b_syn_folditems != 0) + if (wp->w_s->b_syn_folditems != 0) { syntax_start(wp, lnum); @@ -6316,6 +6492,10 @@ static char *(highlight_init_light[]) = CENT("CursorLine term=underline cterm=underline", "CursorLine term=underline cterm=underline guibg=Grey90"), #endif +#ifdef FEAT_CONCEAL + CENT("Conceal ctermbg=DarkGrey ctermfg=LightGrey", + "Conceal ctermbg=DarkGrey ctermfg=LightGrey guibg=DarkGrey guifg=LightGrey"), +#endif #ifdef FEAT_AUTOCMD CENT("MatchParen term=reverse ctermbg=Cyan", "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"), @@ -6400,6 +6580,10 @@ static char *(highlight_init_dark[]) = CENT("MatchParen term=reverse ctermbg=DarkCyan", "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"), #endif +#ifdef FEAT_CONCEAL + CENT("Conceal ctermbg=DarkGrey ctermfg=LightGrey", + "Conceal ctermbg=DarkGrey ctermfg=LightGrey guibg=DarkGrey guifg=LightGrey"), +#endif #ifdef FEAT_GUI "Normal gui=NONE", #endif |