mirror of
https://github.com/neovim/neovim.git
synced 2026-01-31 01:22:25 +10:00
1813661a61
Remove `export` pramgas from defs headers as it causes IWYU to believe that the definitions from the defs headers comes from main header, which is not what we really want.
5665 lines
178 KiB
C
5665 lines
178 KiB
C
// syntax.c: code for syntax highlighting
|
|
|
|
#include <assert.h>
|
|
#include <inttypes.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "nvim/ascii_defs.h"
|
|
#include "nvim/autocmd.h"
|
|
#include "nvim/autocmd_defs.h"
|
|
#include "nvim/buffer.h"
|
|
#include "nvim/buffer_defs.h"
|
|
#include "nvim/charset.h"
|
|
#include "nvim/cmdexpand_defs.h"
|
|
#include "nvim/drawscreen.h"
|
|
#include "nvim/eval.h"
|
|
#include "nvim/eval/typval_defs.h"
|
|
#include "nvim/eval/vars.h"
|
|
#include "nvim/ex_cmds_defs.h"
|
|
#include "nvim/ex_docmd.h"
|
|
#include "nvim/fold.h"
|
|
#include "nvim/garray.h"
|
|
#include "nvim/garray_defs.h"
|
|
#include "nvim/gettext_defs.h"
|
|
#include "nvim/globals.h"
|
|
#include "nvim/hashtab.h"
|
|
#include "nvim/hashtab_defs.h"
|
|
#include "nvim/highlight.h"
|
|
#include "nvim/highlight_defs.h"
|
|
#include "nvim/highlight_group.h"
|
|
#include "nvim/indent_c.h"
|
|
#include "nvim/macros_defs.h"
|
|
#include "nvim/mbyte.h"
|
|
#include "nvim/memline.h"
|
|
#include "nvim/memory.h"
|
|
#include "nvim/message.h"
|
|
#include "nvim/option_vars.h"
|
|
#include "nvim/optionstr.h"
|
|
#include "nvim/os/input.h"
|
|
#include "nvim/path.h"
|
|
#include "nvim/pos_defs.h"
|
|
#include "nvim/profile.h"
|
|
#include "nvim/regexp.h"
|
|
#include "nvim/regexp_defs.h"
|
|
#include "nvim/runtime.h"
|
|
#include "nvim/strings.h"
|
|
#include "nvim/syntax.h"
|
|
#include "nvim/types_defs.h"
|
|
#include "nvim/vim_defs.h"
|
|
|
|
static bool did_syntax_onoff = false;
|
|
|
|
// different types of offsets that are possible
|
|
#define SPO_MS_OFF 0 // match start offset
|
|
#define SPO_ME_OFF 1 // match end offset
|
|
#define SPO_HS_OFF 2 // highl. start offset
|
|
#define SPO_HE_OFF 3 // highl. end offset
|
|
#define SPO_RS_OFF 4 // region start offset
|
|
#define SPO_RE_OFF 5 // region end offset
|
|
#define SPO_LC_OFF 6 // leading context offset
|
|
#define SPO_COUNT 7
|
|
|
|
static const char e_illegal_arg[] = N_("E390: Illegal argument: %s");
|
|
static const char e_contains_argument_not_accepted_here[]
|
|
= N_("E395: Contains argument not accepted here");
|
|
static const char e_invalid_cchar_value[]
|
|
= N_("E844: Invalid cchar value");
|
|
static const char e_trailing_char_after_rsb_str_str[]
|
|
= N_("E890: Trailing char after ']': %s]%s");
|
|
|
|
// The patterns that are being searched for are stored in a syn_pattern.
|
|
// A match item consists of one pattern.
|
|
// A start/end item consists of n start patterns and m end patterns.
|
|
// A start/skip/end item consists of n start patterns, one skip pattern and m
|
|
// end patterns.
|
|
// For the latter two, the patterns are always consecutive: start-skip-end.
|
|
//
|
|
// A character offset can be given for the matched text (_m_start and _m_end)
|
|
// and for the actually highlighted text (_h_start and _h_end).
|
|
//
|
|
// Note that ordering of members is optimized to reduce padding.
|
|
typedef struct {
|
|
char sp_type; // see SPTYPE_ defines below
|
|
bool sp_syncing; // this item used for syncing
|
|
int16_t sp_syn_match_id; // highlight group ID of pattern
|
|
int16_t sp_off_flags; // see below
|
|
int sp_offsets[SPO_COUNT]; // offsets
|
|
int sp_flags; // see HL_ defines below
|
|
int sp_cchar; // conceal substitute character
|
|
int sp_ic; // ignore-case flag for sp_prog
|
|
int sp_sync_idx; // sync item index (syncing only)
|
|
int sp_line_id; // ID of last line where tried
|
|
int sp_startcol; // next match in sp_line_id line
|
|
int16_t *sp_cont_list; // cont. group IDs, if non-zero
|
|
int16_t *sp_next_list; // next group IDs, if non-zero
|
|
struct sp_syn sp_syn; // struct passed to in_id_list()
|
|
char *sp_pattern; // regexp to match, pattern
|
|
regprog_T *sp_prog; // regexp to match, program
|
|
syn_time_T sp_time;
|
|
} synpat_T;
|
|
|
|
typedef struct {
|
|
char *scl_name; // syntax cluster name
|
|
char *scl_name_u; // uppercase of scl_name
|
|
int16_t *scl_list; // IDs in this syntax cluster
|
|
} syn_cluster_T;
|
|
|
|
// For the current state we need to remember more than just the idx.
|
|
// When si_m_endpos.lnum is 0, the items other than si_idx are unknown.
|
|
// (The end positions have the column number of the next char)
|
|
typedef struct {
|
|
int si_idx; // index of syntax pattern or
|
|
// KEYWORD_IDX
|
|
int si_id; // highlight group ID for keywords
|
|
int si_trans_id; // idem, transparency removed
|
|
int si_m_lnum; // lnum of the match
|
|
int si_m_startcol; // starting column of the match
|
|
lpos_T si_m_endpos; // just after end posn of the match
|
|
lpos_T si_h_startpos; // start position of the highlighting
|
|
lpos_T si_h_endpos; // end position of the highlighting
|
|
lpos_T si_eoe_pos; // end position of end pattern
|
|
int si_end_idx; // group ID for end pattern or zero
|
|
int si_ends; // if match ends before si_m_endpos
|
|
int si_attr; // attributes in this state
|
|
int si_flags; // HL_HAS_EOL flag in this state, and
|
|
// HL_SKIP* for si_next_list
|
|
int si_seqnr; // sequence number
|
|
int si_cchar; // substitution character for conceal
|
|
int16_t *si_cont_list; // list of contained groups
|
|
int16_t *si_next_list; // nextgroup IDs after this item ends
|
|
reg_extmatch_T *si_extmatch; // \z(...\) matches from start
|
|
// pattern
|
|
} stateitem_T;
|
|
|
|
// Struct to reduce the number of arguments to get_syn_options(), it's used
|
|
// very often.
|
|
typedef struct {
|
|
int flags; // flags for contained and transparent
|
|
bool keyword; // true for ":syn keyword"
|
|
int *sync_idx; // syntax item for "grouphere" argument, NULL
|
|
// if not allowed
|
|
bool has_cont_list; // true if "cont_list" can be used
|
|
int16_t *cont_list; // group IDs for "contains" argument
|
|
int16_t *cont_in_list; // group IDs for "containedin" argument
|
|
int16_t *next_list; // group IDs for "nextgroup" argument
|
|
} syn_opt_arg_T;
|
|
|
|
typedef struct {
|
|
proftime_T total;
|
|
int count;
|
|
int match;
|
|
proftime_T slowest;
|
|
proftime_T average;
|
|
int id;
|
|
char *pattern;
|
|
} time_entry_T;
|
|
|
|
struct name_list {
|
|
int flag;
|
|
char *name;
|
|
};
|
|
|
|
#ifdef INCLUDE_GENERATED_DECLARATIONS
|
|
# include "syntax.c.generated.h"
|
|
#endif
|
|
|
|
static char *(spo_name_tab[SPO_COUNT]) =
|
|
{ "ms=", "me=", "hs=", "he=", "rs=", "re=", "lc=" };
|
|
|
|
// The sp_off_flags are computed like this:
|
|
// offset from the start of the matched text: (1 << SPO_XX_OFF)
|
|
// offset from the end of the matched text: (1 << (SPO_XX_OFF + SPO_COUNT))
|
|
// When both are present, only one is used.
|
|
|
|
#define SPTYPE_MATCH 1 // match keyword with this group ID
|
|
#define SPTYPE_START 2 // match a regexp, start of item
|
|
#define SPTYPE_END 3 // match a regexp, end of item
|
|
#define SPTYPE_SKIP 4 // match a regexp, skip within item
|
|
|
|
#define SYN_ITEMS(buf) ((synpat_T *)((buf)->b_syn_patterns.ga_data))
|
|
|
|
#define NONE_IDX (-2) // value of sp_sync_idx for "NONE"
|
|
|
|
// Flags for b_syn_sync_flags:
|
|
#define SF_CCOMMENT 0x01 // sync on a C-style comment
|
|
#define SF_MATCH 0x02 // sync by matching a pattern
|
|
|
|
#define SYN_STATE_P(ssp) ((bufstate_T *)((ssp)->ga_data))
|
|
|
|
#define MAXKEYWLEN 80 // maximum length of a keyword
|
|
|
|
// The attributes of the syntax item that has been recognized.
|
|
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
|
|
static int current_flags = 0;
|
|
static int current_seqnr = 0;
|
|
static int current_sub_char = 0;
|
|
|
|
// Methods of combining two clusters
|
|
#define CLUSTER_REPLACE 1 // replace first list with second
|
|
#define CLUSTER_ADD 2 // add second list to first
|
|
#define CLUSTER_SUBTRACT 3 // subtract second list from first
|
|
|
|
#define SYN_CLSTR(buf) ((syn_cluster_T *)((buf)->b_syn_clusters.ga_data))
|
|
|
|
// Syntax group IDs have different types:
|
|
// 0 - 19999 normal syntax groups
|
|
// 20000 - 20999 ALLBUT indicator (current_syn_inc_tag added)
|
|
// 21000 - 21999 TOP indicator (current_syn_inc_tag added)
|
|
// 22000 - 22999 CONTAINED indicator (current_syn_inc_tag added)
|
|
// 23000 - 32767 cluster IDs (subtract SYNID_CLUSTER for the cluster ID)
|
|
#define SYNID_ALLBUT MAX_HL_ID // syntax group ID for contains=ALLBUT
|
|
#define SYNID_TOP 21000 // syntax group ID for contains=TOP
|
|
#define SYNID_CONTAINED 22000 // syntax group ID for contains=CONTAINED
|
|
#define SYNID_CLUSTER 23000 // first syntax group ID for clusters
|
|
|
|
#define MAX_SYN_INC_TAG 999 // maximum before the above overflow
|
|
#define MAX_CLUSTER_ID (32767 - SYNID_CLUSTER)
|
|
|
|
// Annoying Hack(TM): ":syn include" needs this pointer to pass to
|
|
// expand_filename(). Most of the other syntax commands don't need it, so
|
|
// instead of passing it to them, we stow it here.
|
|
static char **syn_cmdlinep;
|
|
|
|
// Another Annoying Hack(TM): To prevent rules from other ":syn include"'d
|
|
// files from leaking into ALLBUT lists, we assign a unique ID to the
|
|
// rules in each ":syn include"'d file.
|
|
static int current_syn_inc_tag = 0;
|
|
static int running_syn_inc_tag = 0;
|
|
|
|
// In a hashtable item "hi_key" points to "keyword" in a keyentry.
|
|
// This avoids adding a pointer to the hashtable item.
|
|
// KE2HIKEY() converts a var pointer to a hashitem key pointer.
|
|
// HIKEY2KE() converts a hashitem key pointer to a var pointer.
|
|
// HI2KE() converts a hashitem pointer to a var pointer.
|
|
static keyentry_T dumkey;
|
|
#define KE2HIKEY(kp) ((kp)->keyword)
|
|
#define HIKEY2KE(p) ((keyentry_T *)((p) - (dumkey.keyword - (char *)&dumkey)))
|
|
#define HI2KE(hi) HIKEY2KE((hi)->hi_key)
|
|
|
|
// To reduce the time spent in keepend(), remember at which level in the state
|
|
// stack the first item with "keepend" is present. When "-1", there is no
|
|
// "keepend" on the stack.
|
|
static int keepend_level = -1;
|
|
|
|
static char msg_no_items[] = N_("No Syntax items defined for this buffer");
|
|
|
|
// value of si_idx for keywords
|
|
#define KEYWORD_IDX (-1)
|
|
// valid of si_cont_list for containing all but contained groups
|
|
#define ID_LIST_ALL ((int16_t *)-1)
|
|
|
|
static int next_seqnr = 1; // value to use for si_seqnr
|
|
|
|
// The next possible match in the current line for any pattern is remembered,
|
|
// to avoid having to try for a match in each column.
|
|
// If next_match_idx == -1, not tried (in this line) yet.
|
|
// If next_match_col == MAXCOL, no match found in this line.
|
|
// (All end positions have the column of the char after the end)
|
|
static int next_match_col; // column for start of next match
|
|
static lpos_T next_match_m_endpos; // position for end of next match
|
|
static lpos_T next_match_h_startpos; // pos. for highl. start of next match
|
|
static lpos_T next_match_h_endpos; // pos. for highl. end of next match
|
|
static int next_match_idx; // index of matched item
|
|
static int next_match_flags; // flags for next match
|
|
static lpos_T next_match_eos_pos; // end of start pattn (start region)
|
|
static lpos_T next_match_eoe_pos; // pos. for end of end pattern
|
|
static int next_match_end_idx; // ID of group for end pattn or zero
|
|
static reg_extmatch_T *next_match_extmatch = NULL;
|
|
|
|
// A state stack is an array of integers or stateitem_T, stored in a
|
|
// garray_T. A state stack is invalid if its itemsize entry is zero.
|
|
#define INVALID_STATE(ssp) ((ssp)->ga_itemsize == 0)
|
|
#define VALID_STATE(ssp) ((ssp)->ga_itemsize != 0)
|
|
|
|
// The current state (within the line) of the recognition engine.
|
|
// When current_state.ga_itemsize is 0 the current state is invalid.
|
|
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 proftime_T *syn_tm; // timeout limit
|
|
static linenr_T current_lnum = 0; // lnum of current state
|
|
static colnr_T current_col = 0; // column of current state
|
|
static bool current_state_stored = false; // true if stored current state
|
|
// after setting current_finished
|
|
static bool current_finished = false; // current line has been finished
|
|
static garray_T current_state // current stack of state_items
|
|
= GA_EMPTY_INIT_VALUE;
|
|
static int16_t *current_next_list = NULL; // when non-zero, nextgroup list
|
|
static int current_next_flags = 0; // flags for current_next_list
|
|
static int current_line_id = 0; // unique number for current line
|
|
|
|
#define CUR_STATE(idx) ((stateitem_T *)(current_state.ga_data))[idx]
|
|
|
|
static bool syn_time_on = false;
|
|
#define IF_SYN_TIME(p) (p)
|
|
|
|
// Set the timeout used for syntax highlighting.
|
|
// Use NULL to reset, no timeout.
|
|
void syn_set_timeout(proftime_T *tm)
|
|
{
|
|
syn_tm = tm;
|
|
}
|
|
|
|
// Start the syntax recognition for a line. This function is normally called
|
|
// from the screen updating, once for each displayed line.
|
|
// The buffer is remembered in syn_buf, because get_syntax_attr() doesn't get
|
|
// it. Careful: curbuf and curwin are likely to point to another buffer and
|
|
// window.
|
|
void syntax_start(win_T *wp, linenr_T lnum)
|
|
{
|
|
synstate_T *last_valid = NULL;
|
|
synstate_T *last_min_valid = NULL;
|
|
synstate_T *sp;
|
|
synstate_T *prev = NULL;
|
|
linenr_T first_stored;
|
|
int dist;
|
|
static varnumber_T changedtick = 0; // remember the last change ID
|
|
|
|
current_sub_char = NUL;
|
|
|
|
// After switching buffers, invalidate current_state.
|
|
// Also do this when a change was made, the current state may be invalid
|
|
// then.
|
|
if (syn_block != wp->w_s
|
|
|| syn_buf != wp->w_buffer
|
|
|| changedtick != buf_get_changedtick(syn_buf)) {
|
|
invalidate_current_state();
|
|
syn_buf = wp->w_buffer;
|
|
syn_block = wp->w_s;
|
|
}
|
|
changedtick = buf_get_changedtick(syn_buf);
|
|
syn_win = wp;
|
|
|
|
// Allocate syntax stack when needed.
|
|
syn_stack_alloc();
|
|
if (syn_block->b_sst_array == NULL) {
|
|
return; // out of memory
|
|
}
|
|
syn_block->b_sst_lasttick = display_tick;
|
|
|
|
// If the state of the end of the previous line is useful, store it.
|
|
if (VALID_STATE(¤t_state)
|
|
&& current_lnum < lnum
|
|
&& current_lnum < syn_buf->b_ml.ml_line_count) {
|
|
syn_finish_line(false);
|
|
if (!current_state_stored) {
|
|
current_lnum++;
|
|
store_current_state();
|
|
}
|
|
|
|
// If the current_lnum is now the same as "lnum", keep the current
|
|
// state (this happens very often!). Otherwise invalidate
|
|
// current_state and figure it out below.
|
|
if (current_lnum != lnum) {
|
|
invalidate_current_state();
|
|
}
|
|
} else {
|
|
invalidate_current_state();
|
|
}
|
|
|
|
// 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_block->b_sst_array != NULL) {
|
|
// Find last valid saved state before start_lnum.
|
|
for (synstate_T *p = syn_block->b_sst_first; p != NULL; p = p->sst_next) {
|
|
if (p->sst_lnum > lnum) {
|
|
break;
|
|
}
|
|
if (p->sst_change_lnum == 0) {
|
|
last_valid = p;
|
|
if (p->sst_lnum >= lnum - syn_block->b_syn_sync_minlines) {
|
|
last_min_valid = p;
|
|
}
|
|
}
|
|
}
|
|
if (last_min_valid != NULL) {
|
|
load_current_state(last_min_valid);
|
|
}
|
|
}
|
|
|
|
// If "lnum" is before or far beyond a line with a saved state, need to
|
|
// re-synchronize.
|
|
if (INVALID_STATE(¤t_state)) {
|
|
syn_sync(wp, lnum, last_valid);
|
|
if (current_lnum == 1) {
|
|
// First line is always valid, no matter "minlines".
|
|
first_stored = 1;
|
|
} else {
|
|
// Need to parse "minlines" lines before state can be considered
|
|
// valid to store.
|
|
first_stored = current_lnum + syn_block->b_syn_sync_minlines;
|
|
}
|
|
} else {
|
|
first_stored = current_lnum;
|
|
}
|
|
|
|
// Advance from the sync point or saved state until the current line.
|
|
// Save some entries for syncing with later on.
|
|
if (syn_block->b_sst_len <= Rows) {
|
|
dist = 999999;
|
|
} else {
|
|
dist = syn_buf->b_ml.ml_line_count / (syn_block->b_sst_len - Rows) + 1;
|
|
}
|
|
while (current_lnum < lnum) {
|
|
syn_start_line();
|
|
syn_finish_line(false);
|
|
current_lnum++;
|
|
|
|
// If we parsed at least "minlines" lines or started at a valid
|
|
// state, the current state is considered valid.
|
|
if (current_lnum >= first_stored) {
|
|
// Check if the saved state entry is for the current line and is
|
|
// equal to the current state. If so, then validate all saved
|
|
// states that depended on a change before the parsed line.
|
|
if (prev == NULL) {
|
|
prev = syn_stack_find_entry(current_lnum - 1);
|
|
}
|
|
if (prev == NULL) {
|
|
sp = syn_block->b_sst_first;
|
|
} else {
|
|
sp = prev;
|
|
}
|
|
while (sp != NULL && sp->sst_lnum < current_lnum) {
|
|
sp = sp->sst_next;
|
|
}
|
|
if (sp != NULL
|
|
&& sp->sst_lnum == current_lnum
|
|
&& syn_stack_equal(sp)) {
|
|
linenr_T parsed_lnum = current_lnum;
|
|
prev = sp;
|
|
while (sp != NULL && sp->sst_change_lnum <= parsed_lnum) {
|
|
if (sp->sst_lnum <= lnum) {
|
|
// valid state before desired line, use this one
|
|
prev = sp;
|
|
} else if (sp->sst_change_lnum == 0) {
|
|
// past saved states depending on change, break here.
|
|
break;
|
|
}
|
|
sp->sst_change_lnum = 0;
|
|
sp = sp->sst_next;
|
|
}
|
|
load_current_state(prev);
|
|
} else if (prev == NULL
|
|
// Store the state at this line when it's the first one, the line
|
|
// where we start parsing, or some distance from the previously
|
|
// saved state. But only when parsed at least 'minlines'.
|
|
|| current_lnum == lnum
|
|
|| current_lnum >= prev->sst_lnum + dist) {
|
|
prev = store_current_state();
|
|
}
|
|
}
|
|
|
|
// This can take a long time: break when CTRL-C pressed. The current
|
|
// state will be wrong then.
|
|
line_breakcheck();
|
|
if (got_int) {
|
|
current_lnum = lnum;
|
|
break;
|
|
}
|
|
}
|
|
|
|
syn_start_line();
|
|
}
|
|
|
|
// We cannot simply discard growarrays full of state_items or buf_states; we
|
|
// have to manually release their extmatch pointers first.
|
|
static void clear_syn_state(synstate_T *p)
|
|
{
|
|
if (p->sst_stacksize > SST_FIX_STATES) {
|
|
#define UNREF_BUFSTATE_EXTMATCH(bs) unref_extmatch((bs)->bs_extmatch)
|
|
GA_DEEP_CLEAR(&(p->sst_union.sst_ga), bufstate_T, UNREF_BUFSTATE_EXTMATCH);
|
|
} else {
|
|
for (int i = 0; i < p->sst_stacksize; i++) {
|
|
unref_extmatch(p->sst_union.sst_stack[i].bs_extmatch);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Cleanup the current_state stack.
|
|
static void clear_current_state(void)
|
|
{
|
|
#define UNREF_STATEITEM_EXTMATCH(si) unref_extmatch((si)->si_extmatch)
|
|
GA_DEEP_CLEAR(¤t_state, stateitem_T, UNREF_STATEITEM_EXTMATCH);
|
|
}
|
|
|
|
// Try to find a synchronisation point for line "lnum".
|
|
//
|
|
// This sets current_lnum and the current state. One of three methods is
|
|
// used:
|
|
// 1. Search backwards for the end of a C-comment.
|
|
// 2. Search backwards for given sync patterns.
|
|
// 3. Simply start on a given number of lines above "lnum".
|
|
static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
|
|
{
|
|
pos_T cursor_save;
|
|
linenr_T lnum;
|
|
linenr_T break_lnum;
|
|
stateitem_T *cur_si;
|
|
synpat_T *spp;
|
|
int found_flags = 0;
|
|
int found_match_idx = 0;
|
|
linenr_T found_current_lnum = 0;
|
|
int found_current_col = 0;
|
|
lpos_T found_m_endpos;
|
|
|
|
// Clear any current state that might be hanging around.
|
|
invalidate_current_state();
|
|
|
|
// Start at least "minlines" back. Default starting point for parsing is
|
|
// there.
|
|
// Start further back, to avoid that scrolling backwards will result in
|
|
// resyncing for every line. Now it resyncs only one out of N lines,
|
|
// where N is minlines * 1.5, or minlines * 2 if minlines is small.
|
|
// Watch out for overflow when minlines is MAXLNUM.
|
|
if (syn_block->b_syn_sync_minlines > start_lnum) {
|
|
start_lnum = 1;
|
|
} else {
|
|
if (syn_block->b_syn_sync_minlines == 1) {
|
|
lnum = 1;
|
|
} else if (syn_block->b_syn_sync_minlines < 10) {
|
|
lnum = syn_block->b_syn_sync_minlines * 2;
|
|
} else {
|
|
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 {
|
|
start_lnum -= lnum;
|
|
}
|
|
}
|
|
current_lnum = start_lnum;
|
|
|
|
// 1. Search backwards for the end of a C-style comment.
|
|
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().
|
|
win_T *curwin_save = curwin;
|
|
curwin = wp;
|
|
buf_T *curbuf_save = curbuf;
|
|
curbuf = syn_buf;
|
|
|
|
// Skip lines that end in a backslash.
|
|
for (; start_lnum > 1; start_lnum--) {
|
|
char *line = ml_get(start_lnum - 1);
|
|
if (*line == NUL || *(line + strlen(line) - 1) != '\\') {
|
|
break;
|
|
}
|
|
}
|
|
current_lnum = start_lnum;
|
|
|
|
// set cursor to start of search
|
|
cursor_save = wp->w_cursor;
|
|
wp->w_cursor.lnum = start_lnum;
|
|
wp->w_cursor.col = 0;
|
|
|
|
// If the line is inside a comment, need to find the syntax item that
|
|
// defines the comment.
|
|
// Restrict the search for the end of a comment to b_syn_sync_maxlines.
|
|
if (find_start_comment((int)syn_block->b_syn_sync_maxlines) != NULL) {
|
|
for (int 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();
|
|
push_current_state(idx);
|
|
update_si_attr(current_state.ga_len - 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// restore cursor and buffer
|
|
wp->w_cursor = cursor_save;
|
|
curwin = curwin_save;
|
|
curbuf = curbuf_save;
|
|
} else if (syn_block->b_syn_sync_flags & SF_MATCH) {
|
|
// 2. Search backwards for given sync patterns.
|
|
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;
|
|
}
|
|
|
|
found_m_endpos.lnum = 0;
|
|
found_m_endpos.col = 0;
|
|
linenr_T end_lnum = start_lnum;
|
|
lnum = start_lnum;
|
|
while (--lnum > break_lnum) {
|
|
// This can take a long time: break when CTRL-C pressed.
|
|
line_breakcheck();
|
|
if (got_int) {
|
|
invalidate_current_state();
|
|
current_lnum = start_lnum;
|
|
break;
|
|
}
|
|
|
|
// Check if we have run into a valid saved state stack now.
|
|
if (last_valid != NULL && lnum == last_valid->sst_lnum) {
|
|
load_current_state(last_valid);
|
|
break;
|
|
}
|
|
|
|
// Check if the previous line has the line-continuation pattern.
|
|
if (lnum > 1 && syn_match_linecont(lnum - 1)) {
|
|
continue;
|
|
}
|
|
|
|
// Start with nothing on the state stack
|
|
validate_current_state();
|
|
|
|
for (current_lnum = lnum; current_lnum < end_lnum; current_lnum++) {
|
|
syn_start_line();
|
|
while (true) {
|
|
bool had_sync_point = syn_finish_line(true);
|
|
// When a sync point has been found, remember where, and
|
|
// continue to look for another one, further on in the line.
|
|
if (had_sync_point && current_state.ga_len) {
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
if (cur_si->si_m_endpos.lnum > start_lnum) {
|
|
// ignore match that goes to after where started
|
|
current_lnum = end_lnum;
|
|
break;
|
|
}
|
|
if (cur_si->si_idx < 0) {
|
|
// Cannot happen?
|
|
found_flags = 0;
|
|
found_match_idx = KEYWORD_IDX;
|
|
} else {
|
|
spp = &(SYN_ITEMS(syn_block)[cur_si->si_idx]);
|
|
found_flags = spp->sp_flags;
|
|
found_match_idx = spp->sp_sync_idx;
|
|
}
|
|
found_current_lnum = current_lnum;
|
|
found_current_col = current_col;
|
|
found_m_endpos = cur_si->si_m_endpos;
|
|
// Continue after the match (be aware of a zero-length
|
|
// match).
|
|
if (found_m_endpos.lnum > current_lnum) {
|
|
current_lnum = found_m_endpos.lnum;
|
|
current_col = found_m_endpos.col;
|
|
if (current_lnum >= end_lnum) {
|
|
break;
|
|
}
|
|
} else if (found_m_endpos.col > current_col) {
|
|
current_col = found_m_endpos.col;
|
|
} else {
|
|
current_col++;
|
|
}
|
|
|
|
// syn_current_attr() will have skipped the check for
|
|
// an item that ends here, need to do that now. Be
|
|
// careful not to go past the NUL.
|
|
colnr_T prev_current_col = current_col;
|
|
if (syn_getcurline()[current_col] != NUL) {
|
|
current_col++;
|
|
}
|
|
check_state_ends();
|
|
current_col = prev_current_col;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If a sync point was encountered, break here.
|
|
if (found_flags) {
|
|
// Put the item that was specified by the sync point on the
|
|
// state stack. If there was no item specified, make the
|
|
// state stack empty.
|
|
clear_current_state();
|
|
if (found_match_idx >= 0) {
|
|
push_current_state(found_match_idx);
|
|
update_si_attr(current_state.ga_len - 1);
|
|
}
|
|
|
|
// When using "grouphere", continue from the sync point
|
|
// match, until the end of the line. Parsing starts at
|
|
// the next line.
|
|
// For "groupthere" the parsing starts at start_lnum.
|
|
if (found_flags & HL_SYNC_HERE) {
|
|
if (!GA_EMPTY(¤t_state)) {
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
cur_si->si_h_startpos.lnum = found_current_lnum;
|
|
cur_si->si_h_startpos.col = found_current_col;
|
|
update_si_end(cur_si, (int)current_col, true);
|
|
check_keepend();
|
|
}
|
|
current_col = found_m_endpos.col;
|
|
current_lnum = found_m_endpos.lnum;
|
|
syn_finish_line(false);
|
|
current_lnum++;
|
|
} else {
|
|
current_lnum = start_lnum;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
end_lnum = lnum;
|
|
invalidate_current_state();
|
|
}
|
|
|
|
// Ran into start of the file or exceeded maximum number of lines
|
|
if (lnum <= break_lnum) {
|
|
invalidate_current_state();
|
|
current_lnum = break_lnum + 1;
|
|
}
|
|
}
|
|
|
|
validate_current_state();
|
|
}
|
|
|
|
static void save_chartab(char *chartab)
|
|
{
|
|
if (syn_block->b_syn_isk == empty_string_option) {
|
|
return;
|
|
}
|
|
|
|
memmove(chartab, syn_buf->b_chartab, (size_t)32);
|
|
memmove(syn_buf->b_chartab, syn_win->w_s->b_syn_chartab, (size_t)32);
|
|
}
|
|
|
|
static void restore_chartab(char *chartab)
|
|
{
|
|
if (syn_win->w_s->b_syn_isk != empty_string_option) {
|
|
memmove(syn_buf->b_chartab, chartab, (size_t)32);
|
|
}
|
|
}
|
|
|
|
/// Return true if the line-continuation pattern matches in line "lnum".
|
|
static int syn_match_linecont(linenr_T lnum)
|
|
{
|
|
if (syn_block->b_syn_linecont_prog == NULL) {
|
|
return false;
|
|
}
|
|
|
|
regmmatch_T regmatch;
|
|
// chartab array for syn iskeyword
|
|
char buf_chartab[32];
|
|
save_chartab(buf_chartab);
|
|
|
|
regmatch.rmm_ic = syn_block->b_syn_linecont_ic;
|
|
regmatch.regprog = syn_block->b_syn_linecont_prog;
|
|
int r = syn_regexec(®match, lnum, 0,
|
|
IF_SYN_TIME(&syn_block->b_syn_linecont_time));
|
|
syn_block->b_syn_linecont_prog = regmatch.regprog;
|
|
|
|
restore_chartab(buf_chartab);
|
|
return r;
|
|
}
|
|
|
|
// Prepare the current state for the start of a line.
|
|
static void syn_start_line(void)
|
|
{
|
|
current_finished = false;
|
|
current_col = 0;
|
|
|
|
// Need to update the end of a start/skip/end that continues from the
|
|
// previous line and regions that have "keepend".
|
|
if (!GA_EMPTY(¤t_state)) {
|
|
syn_update_ends(true);
|
|
check_state_ends();
|
|
}
|
|
|
|
next_match_idx = -1;
|
|
current_line_id++;
|
|
next_seqnr = 1;
|
|
}
|
|
|
|
/// Check for items in the stack that need their end updated.
|
|
///
|
|
/// @param startofline if true the last item is always updated.
|
|
/// if false the item with "keepend" is forcefully updated.
|
|
static void syn_update_ends(bool startofline)
|
|
{
|
|
stateitem_T *cur_si;
|
|
|
|
if (startofline) {
|
|
// Check for a match carried over from a previous line with a
|
|
// contained region. The match ends as soon as the region ends.
|
|
for (int i = 0; i < current_state.ga_len; i++) {
|
|
cur_si = &CUR_STATE(i);
|
|
if (cur_si->si_idx >= 0
|
|
&& (SYN_ITEMS(syn_block)[cur_si->si_idx]).sp_type
|
|
== SPTYPE_MATCH
|
|
&& cur_si->si_m_endpos.lnum < current_lnum) {
|
|
cur_si->si_flags |= HL_MATCHCONT;
|
|
cur_si->si_m_endpos.lnum = 0;
|
|
cur_si->si_m_endpos.col = 0;
|
|
cur_si->si_h_endpos = cur_si->si_m_endpos;
|
|
cur_si->si_ends = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Need to update the end of a start/skip/end that continues from the
|
|
// previous line. And regions that have "keepend", because they may
|
|
// influence contained items. If we've just removed "extend"
|
|
// (startofline == 0) then we should update ends of normal regions
|
|
// contained inside "keepend" because "extend" could have extended
|
|
// these "keepend" regions as well as contained normal regions.
|
|
// Then check for items ending in column 0.
|
|
int i = current_state.ga_len - 1;
|
|
if (keepend_level >= 0) {
|
|
for (; i > keepend_level; i--) {
|
|
if (CUR_STATE(i).si_flags & HL_EXTEND) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool seen_keepend = false;
|
|
for (; i < current_state.ga_len; i++) {
|
|
cur_si = &CUR_STATE(i);
|
|
if ((cur_si->si_flags & HL_KEEPEND)
|
|
|| (seen_keepend && !startofline)
|
|
|| (i == current_state.ga_len - 1 && startofline)) {
|
|
cur_si->si_h_startpos.col = 0; // start highl. in col 0
|
|
cur_si->si_h_startpos.lnum = current_lnum;
|
|
|
|
if (!(cur_si->si_flags & HL_MATCHCONT)) {
|
|
update_si_end(cur_si, (int)current_col, !startofline);
|
|
}
|
|
|
|
if (!startofline && (cur_si->si_flags & HL_KEEPEND)) {
|
|
seen_keepend = true;
|
|
}
|
|
}
|
|
}
|
|
check_keepend();
|
|
}
|
|
|
|
/////////////////////////////////////////
|
|
// Handling of the state stack cache.
|
|
|
|
// EXPLANATION OF THE SYNTAX STATE STACK CACHE
|
|
//
|
|
// To speed up syntax highlighting, the state stack for the start of some
|
|
// lines is cached. These entries can be used to start parsing at that point.
|
|
//
|
|
// The stack is kept in b_sst_array[] for each buffer. There is a list of
|
|
// valid entries. b_sst_first points to the first one, then follow sst_next.
|
|
// The entries are sorted on line number. The first entry is often for line 2
|
|
// (line 1 always starts with an empty stack).
|
|
// There is also a list for free entries. This construction is used to avoid
|
|
// having to allocate and free memory blocks too often.
|
|
//
|
|
// When making changes to the buffer, this is logged in b_mod_*. When calling
|
|
// update_screen() to update the display, it will call
|
|
// syn_stack_apply_changes() for each displayed buffer to adjust the cached
|
|
// entries. The entries which are inside the changed area are removed,
|
|
// because they must be recomputed. Entries below the changed have their line
|
|
// number adjusted for deleted/inserted lines, and have their sst_change_lnum
|
|
// set to indicate that a check must be made if the changed lines would change
|
|
// the cached entry.
|
|
//
|
|
// When later displaying lines, an entry is stored for each line. Displayed
|
|
// lines are likely to be displayed again, in which case the state at the
|
|
// start of the line is needed.
|
|
// For not displayed lines, an entry is stored for every so many lines. These
|
|
// entries will be used e.g., when scrolling backwards. The distance between
|
|
// entries depends on the number of lines in the buffer. For small buffers
|
|
// the distance is fixed at SST_DIST, for large buffers there is a fixed
|
|
// number of entries SST_MAX_ENTRIES, and the distance is computed.
|
|
|
|
static void syn_stack_free_block(synblock_T *block)
|
|
{
|
|
if (block->b_sst_array == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (synstate_T *p = block->b_sst_first; p != NULL; p = p->sst_next) {
|
|
clear_syn_state(p);
|
|
}
|
|
XFREE_CLEAR(block->b_sst_array);
|
|
block->b_sst_first = 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(synblock_T *block)
|
|
{
|
|
syn_stack_free_block(block);
|
|
|
|
// When using "syntax" fold method, must update all folds.
|
|
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
|
|
if (wp->w_s == block && foldmethodIsSyntax(wp)) {
|
|
foldUpdateAll(wp);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allocate the syntax state stack for syn_buf when needed.
|
|
// If the number of entries in b_sst_array[] is much too big or a bit too
|
|
// small, reallocate it.
|
|
// Also used to allocate b_sst_array[] for the first time.
|
|
static void syn_stack_alloc(void)
|
|
{
|
|
int len = syn_buf->b_ml.ml_line_count / SST_DIST + Rows * 2;
|
|
if (len < SST_MIN_ENTRIES) {
|
|
len = SST_MIN_ENTRIES;
|
|
} else if (len > SST_MAX_ENTRIES) {
|
|
len = SST_MAX_ENTRIES;
|
|
}
|
|
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;
|
|
len = (len + len / 2) / SST_DIST + Rows * 2;
|
|
if (len < SST_MIN_ENTRIES) {
|
|
len = SST_MIN_ENTRIES;
|
|
} else if (len > SST_MAX_ENTRIES) {
|
|
len = SST_MAX_ENTRIES;
|
|
}
|
|
|
|
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_block->b_sst_len - syn_block->b_sst_freecount + 2 > len
|
|
&& syn_stack_cleanup()) {}
|
|
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;
|
|
}
|
|
}
|
|
|
|
assert(len >= 0);
|
|
synstate_T *sstp = xcalloc((size_t)len, sizeof(synstate_T));
|
|
|
|
synstate_T *to = sstp - 1;
|
|
if (syn_block->b_sst_array != NULL) {
|
|
// Move the states from the old array to the new one.
|
|
for (synstate_T *from = syn_block->b_sst_first; from != NULL;
|
|
from = from->sst_next) {
|
|
to++;
|
|
*to = *from;
|
|
to->sst_next = to + 1;
|
|
}
|
|
}
|
|
if (to != sstp - 1) {
|
|
to->sst_next = NULL;
|
|
syn_block->b_sst_first = sstp;
|
|
syn_block->b_sst_freecount = len - (int)(to - sstp) - 1;
|
|
} else {
|
|
syn_block->b_sst_first = NULL;
|
|
syn_block->b_sst_freecount = len;
|
|
}
|
|
|
|
// Create the list of free entries.
|
|
syn_block->b_sst_firstfree = to + 1;
|
|
while (++to < sstp + len) {
|
|
to->sst_next = to + 1;
|
|
}
|
|
(sstp + len - 1)->sst_next = NULL;
|
|
|
|
xfree(syn_block->b_sst_array);
|
|
syn_block->b_sst_array = sstp;
|
|
syn_block->b_sst_len = len;
|
|
}
|
|
}
|
|
|
|
// Check for changes in a buffer to affect stored syntax states. Uses the
|
|
// b_mod_* fields.
|
|
// Called from update_screen(), before screen is being updated, once for each
|
|
// displayed buffer.
|
|
void syn_stack_apply_changes(buf_T *buf)
|
|
{
|
|
syn_stack_apply_changes_block(&buf->b_s, buf);
|
|
|
|
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
|
|
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(synblock_T *block, buf_T *buf)
|
|
{
|
|
synstate_T *prev = NULL;
|
|
for (synstate_T *p = block->b_sst_first; p != NULL;) {
|
|
if (p->sst_lnum + block->b_syn_sync_linebreaks > buf->b_mod_top) {
|
|
linenr_T n = p->sst_lnum + buf->b_mod_xlines;
|
|
if (n <= buf->b_mod_bot) {
|
|
// this state is inside the changed area, remove it
|
|
synstate_T *np = p->sst_next;
|
|
if (prev == NULL) {
|
|
block->b_sst_first = np;
|
|
} else {
|
|
prev->sst_next = np;
|
|
}
|
|
syn_stack_free_entry(block, p);
|
|
p = np;
|
|
continue;
|
|
}
|
|
// This state is below the changed area. Remember the line
|
|
// that needs to be parsed before this entry can be made valid
|
|
// again.
|
|
if (p->sst_change_lnum != 0 && p->sst_change_lnum > buf->b_mod_top) {
|
|
if (p->sst_change_lnum + buf->b_mod_xlines > buf->b_mod_top) {
|
|
p->sst_change_lnum += buf->b_mod_xlines;
|
|
} else {
|
|
p->sst_change_lnum = buf->b_mod_top;
|
|
}
|
|
}
|
|
if (p->sst_change_lnum == 0
|
|
|| p->sst_change_lnum < buf->b_mod_bot) {
|
|
p->sst_change_lnum = buf->b_mod_bot;
|
|
}
|
|
|
|
p->sst_lnum = n;
|
|
}
|
|
prev = p;
|
|
p = p->sst_next;
|
|
}
|
|
}
|
|
|
|
/// Reduce the number of entries in the state stack for syn_buf.
|
|
///
|
|
/// @return true if at least one entry was freed.
|
|
static bool syn_stack_cleanup(void)
|
|
{
|
|
synstate_T *prev;
|
|
disptick_T tick;
|
|
int dist;
|
|
bool retval = false;
|
|
|
|
if (syn_block->b_sst_first == NULL) {
|
|
return retval;
|
|
}
|
|
|
|
// Compute normal distance between non-displayed entries.
|
|
if (syn_block->b_sst_len <= Rows) {
|
|
dist = 999999;
|
|
} else {
|
|
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_block->b_sst_lasttick;
|
|
bool above = false;
|
|
prev = syn_block->b_sst_first;
|
|
for (synstate_T *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_block->b_sst_lasttick) {
|
|
if (!above || p->sst_tick < tick) {
|
|
tick = p->sst_tick;
|
|
}
|
|
above = true;
|
|
} else if (!above && p->sst_tick < tick) {
|
|
tick = p->sst_tick;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Go through the list to make the entries for the oldest tick at an
|
|
// interval of several lines.
|
|
prev = syn_block->b_sst_first;
|
|
for (synstate_T *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_block, p);
|
|
p = prev;
|
|
retval = true;
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
// Free the allocated memory for a syn_state item.
|
|
// Move the entry into the free list.
|
|
static void syn_stack_free_entry(synblock_T *block, synstate_T *p)
|
|
{
|
|
clear_syn_state(p);
|
|
p->sst_next = block->b_sst_firstfree;
|
|
block->b_sst_firstfree = p;
|
|
block->b_sst_freecount++;
|
|
}
|
|
|
|
// Find an entry in the list of state stacks at or before "lnum".
|
|
// Returns NULL when there is no entry or the first entry is after "lnum".
|
|
static synstate_T *syn_stack_find_entry(linenr_T lnum)
|
|
{
|
|
synstate_T *prev = NULL;
|
|
for (synstate_T *p = syn_block->b_sst_first; p != NULL; prev = p, p = p->sst_next) {
|
|
if (p->sst_lnum == lnum) {
|
|
return p;
|
|
}
|
|
if (p->sst_lnum > lnum) {
|
|
break;
|
|
}
|
|
}
|
|
return prev;
|
|
}
|
|
|
|
// Try saving the current state in b_sst_array[].
|
|
// The current state must be valid for the start of the current_lnum line!
|
|
static synstate_T *store_current_state(void)
|
|
{
|
|
int i;
|
|
synstate_T *p;
|
|
bufstate_T *bp;
|
|
stateitem_T *cur_si;
|
|
synstate_T *sp = syn_stack_find_entry(current_lnum);
|
|
|
|
// If the current state contains a start or end pattern that continues
|
|
// from the previous line, we can't use it. Don't store it then.
|
|
for (i = current_state.ga_len - 1; i >= 0; i--) {
|
|
cur_si = &CUR_STATE(i);
|
|
if (cur_si->si_h_startpos.lnum >= current_lnum
|
|
|| cur_si->si_m_endpos.lnum >= current_lnum
|
|
|| cur_si->si_h_endpos.lnum >= current_lnum
|
|
|| (cur_si->si_end_idx
|
|
&& cur_si->si_eoe_pos.lnum >= current_lnum)) {
|
|
break;
|
|
}
|
|
}
|
|
if (i >= 0) {
|
|
if (sp != NULL) {
|
|
// find "sp" in the list and remove it
|
|
if (syn_block->b_sst_first == sp) {
|
|
// it's the first entry
|
|
syn_block->b_sst_first = sp->sst_next;
|
|
} else {
|
|
// find the entry just before this one to adjust 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_block, sp);
|
|
sp = NULL;
|
|
}
|
|
} else if (sp == NULL || sp->sst_lnum != current_lnum) {
|
|
// Add a new entry
|
|
// If no free items, cleanup the array first.
|
|
if (syn_block->b_sst_freecount == 0) {
|
|
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_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_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_block->b_sst_first;
|
|
syn_block->b_sst_first = p;
|
|
} else {
|
|
// insert in list after *sp
|
|
p->sst_next = sp->sst_next;
|
|
sp->sst_next = p;
|
|
}
|
|
sp = p;
|
|
sp->sst_stacksize = 0;
|
|
sp->sst_lnum = current_lnum;
|
|
}
|
|
}
|
|
if (sp != NULL) {
|
|
// When overwriting an existing state stack, clear it first
|
|
clear_syn_state(sp);
|
|
sp->sst_stacksize = current_state.ga_len;
|
|
if (current_state.ga_len > SST_FIX_STATES) {
|
|
// Need to clear it, might be something remaining from when the
|
|
// length was less than SST_FIX_STATES.
|
|
ga_init(&sp->sst_union.sst_ga, (int)sizeof(bufstate_T), 1);
|
|
ga_grow(&sp->sst_union.sst_ga, current_state.ga_len);
|
|
sp->sst_union.sst_ga.ga_len = current_state.ga_len;
|
|
bp = SYN_STATE_P(&(sp->sst_union.sst_ga));
|
|
} else {
|
|
bp = sp->sst_union.sst_stack;
|
|
}
|
|
for (i = 0; i < sp->sst_stacksize; i++) {
|
|
bp[i].bs_idx = CUR_STATE(i).si_idx;
|
|
bp[i].bs_flags = CUR_STATE(i).si_flags;
|
|
bp[i].bs_seqnr = CUR_STATE(i).si_seqnr;
|
|
bp[i].bs_cchar = CUR_STATE(i).si_cchar;
|
|
bp[i].bs_extmatch = ref_extmatch(CUR_STATE(i).si_extmatch);
|
|
}
|
|
sp->sst_next_flags = current_next_flags;
|
|
sp->sst_next_list = current_next_list;
|
|
sp->sst_tick = display_tick;
|
|
sp->sst_change_lnum = 0;
|
|
}
|
|
current_state_stored = true;
|
|
return sp;
|
|
}
|
|
|
|
// Copy a state stack from "from" in b_sst_array[] to current_state;
|
|
static void load_current_state(synstate_T *from)
|
|
{
|
|
bufstate_T *bp;
|
|
|
|
clear_current_state();
|
|
validate_current_state();
|
|
keepend_level = -1;
|
|
if (from->sst_stacksize) {
|
|
ga_grow(¤t_state, from->sst_stacksize);
|
|
if (from->sst_stacksize > SST_FIX_STATES) {
|
|
bp = SYN_STATE_P(&(from->sst_union.sst_ga));
|
|
} else {
|
|
bp = from->sst_union.sst_stack;
|
|
}
|
|
for (int i = 0; i < from->sst_stacksize; i++) {
|
|
CUR_STATE(i).si_idx = bp[i].bs_idx;
|
|
CUR_STATE(i).si_flags = bp[i].bs_flags;
|
|
CUR_STATE(i).si_seqnr = bp[i].bs_seqnr;
|
|
CUR_STATE(i).si_cchar = bp[i].bs_cchar;
|
|
CUR_STATE(i).si_extmatch = ref_extmatch(bp[i].bs_extmatch);
|
|
if (keepend_level < 0 && (CUR_STATE(i).si_flags & HL_KEEPEND)) {
|
|
keepend_level = i;
|
|
}
|
|
CUR_STATE(i).si_ends = false;
|
|
CUR_STATE(i).si_m_lnum = 0;
|
|
if (CUR_STATE(i).si_idx >= 0) {
|
|
CUR_STATE(i).si_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);
|
|
}
|
|
current_state.ga_len = from->sst_stacksize;
|
|
}
|
|
current_next_list = from->sst_next_list;
|
|
current_next_flags = from->sst_next_flags;
|
|
current_lnum = from->sst_lnum;
|
|
}
|
|
|
|
/// Compare saved state stack "*sp" with the current state.
|
|
///
|
|
/// @return true when they are equal.
|
|
static bool syn_stack_equal(synstate_T *sp)
|
|
{
|
|
bufstate_T *bp;
|
|
|
|
// First a quick check if the stacks have the same size end nextlist.
|
|
if (sp->sst_stacksize != current_state.ga_len
|
|
|| sp->sst_next_list != current_next_list) {
|
|
return false;
|
|
}
|
|
|
|
// Need to compare all states on both stacks.
|
|
if (sp->sst_stacksize > SST_FIX_STATES) {
|
|
bp = SYN_STATE_P(&(sp->sst_union.sst_ga));
|
|
} else {
|
|
bp = sp->sst_union.sst_stack;
|
|
}
|
|
|
|
int i;
|
|
for (i = current_state.ga_len; --i >= 0;) {
|
|
// If the item has another index the state is different.
|
|
if (bp[i].bs_idx != CUR_STATE(i).si_idx) {
|
|
break;
|
|
}
|
|
if (bp[i].bs_extmatch == CUR_STATE(i).si_extmatch) {
|
|
continue;
|
|
}
|
|
// When the extmatch pointers are different, the strings in them can
|
|
// still be the same. Check if the extmatch references are equal.
|
|
reg_extmatch_T *bsx = bp[i].bs_extmatch;
|
|
reg_extmatch_T *six = CUR_STATE(i).si_extmatch;
|
|
// If one of the extmatch pointers is NULL the states are different.
|
|
if (bsx == NULL || six == NULL) {
|
|
break;
|
|
}
|
|
int j;
|
|
for (j = 0; j < NSUBEXP; j++) {
|
|
// Check each referenced match string. They must all be equal.
|
|
if (bsx->matches[j] != six->matches[j]) {
|
|
// If the pointer is different it can still be the same text.
|
|
// Compare the strings, ignore case when the start item has the
|
|
// sp_ic flag set.
|
|
if (bsx->matches[j] == NULL || six->matches[j] == NULL) {
|
|
break;
|
|
}
|
|
if (mb_strcmp_ic((SYN_ITEMS(syn_block)[CUR_STATE(i).si_idx]).sp_ic,
|
|
(const char *)bsx->matches[j],
|
|
(const char *)six->matches[j]) != 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (j != NSUBEXP) {
|
|
break;
|
|
}
|
|
}
|
|
return i < 0 ? true : false;
|
|
}
|
|
|
|
// We stop parsing syntax above line "lnum". If the stored state at or below
|
|
// this line depended on a change before it, it now depends on the line below
|
|
// the last parsed line.
|
|
// The window looks like this:
|
|
// line which changed
|
|
// displayed line
|
|
// displayed line
|
|
// lnum -> line below window
|
|
void syntax_end_parsing(win_T *wp, linenr_T lnum)
|
|
{
|
|
synstate_T *sp;
|
|
|
|
if (syn_block != wp->w_s) {
|
|
return; // not the right window
|
|
}
|
|
sp = syn_stack_find_entry(lnum);
|
|
if (sp != NULL && sp->sst_lnum < lnum) {
|
|
sp = sp->sst_next;
|
|
}
|
|
|
|
if (sp != NULL && sp->sst_change_lnum != 0) {
|
|
sp->sst_change_lnum = lnum;
|
|
}
|
|
}
|
|
|
|
// End of handling of the state stack.
|
|
// **************************************
|
|
|
|
static void invalidate_current_state(void)
|
|
{
|
|
clear_current_state();
|
|
current_state.ga_itemsize = 0; // mark current_state invalid
|
|
current_next_list = NULL;
|
|
keepend_level = -1;
|
|
}
|
|
|
|
static void validate_current_state(void)
|
|
{
|
|
current_state.ga_itemsize = sizeof(stateitem_T);
|
|
ga_set_growsize(¤t_state, 3);
|
|
}
|
|
|
|
/// This will only be called just after get_syntax_attr() for the previous
|
|
/// line, to check if the next line needs to be redrawn too.
|
|
///
|
|
/// @return true if the syntax at start of lnum changed since last time.
|
|
bool syntax_check_changed(linenr_T lnum)
|
|
{
|
|
bool retval = true;
|
|
synstate_T *sp;
|
|
|
|
// Check the state stack when:
|
|
// - lnum is just below the previously syntaxed line.
|
|
// - lnum is not before the lines with saved states.
|
|
// - lnum is not past the lines with saved states.
|
|
// - lnum is at or before the last changed line.
|
|
if (VALID_STATE(¤t_state) && lnum == current_lnum + 1) {
|
|
sp = syn_stack_find_entry(lnum);
|
|
if (sp != NULL && sp->sst_lnum == lnum) {
|
|
// finish the previous line (needed when not all of the line was
|
|
// drawn)
|
|
syn_finish_line(false);
|
|
|
|
// Compare the current state with the previously saved state of
|
|
// the line.
|
|
if (syn_stack_equal(sp)) {
|
|
retval = false;
|
|
}
|
|
|
|
// Store the current state in b_sst_array[] for later use.
|
|
current_lnum++;
|
|
store_current_state();
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Finish the current line.
|
|
/// This doesn't return any attributes, it only gets the state at the end of
|
|
/// the line. It can start anywhere in the line, as long as the current state
|
|
/// is valid.
|
|
///
|
|
/// @param syncing called for syncing
|
|
static bool syn_finish_line(const bool syncing)
|
|
{
|
|
while (!current_finished) {
|
|
syn_current_attr(syncing, false, NULL, false);
|
|
|
|
// When syncing, and found some item, need to check the item.
|
|
if (syncing && current_state.ga_len) {
|
|
// Check for match with sync item.
|
|
const stateitem_T *const cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
if (cur_si->si_idx >= 0
|
|
&& (SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags
|
|
& (HL_SYNC_HERE|HL_SYNC_THERE))) {
|
|
return true;
|
|
}
|
|
|
|
// syn_current_attr() will have skipped the check for an item
|
|
// that ends here, need to do that now. Be careful not to go
|
|
// past the NUL.
|
|
const colnr_T prev_current_col = current_col;
|
|
if (syn_getcurline()[current_col] != NUL) {
|
|
current_col++;
|
|
}
|
|
check_state_ends();
|
|
current_col = prev_current_col;
|
|
}
|
|
current_col++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Gets highlight attributes for next character.
|
|
/// Must first call syntax_start() once for the line.
|
|
/// "col" is normally 0 for the first use in a line, and increments by one each
|
|
/// time. It's allowed to skip characters and to stop before the end of the
|
|
/// line. But only a "col" after a previously used column is allowed.
|
|
/// When "can_spell" is not NULL set it to true when spell-checking should be
|
|
/// done.
|
|
///
|
|
/// @param keep_state keep state of char at "col"
|
|
///
|
|
/// @return highlight attributes for next character.
|
|
int get_syntax_attr(const colnr_T col, bool *const can_spell, const bool keep_state)
|
|
{
|
|
int attr = 0;
|
|
|
|
if (can_spell != NULL) {
|
|
// Default: Only do spelling when there is no @Spell cluster or when
|
|
// ":syn spell toplevel" was used.
|
|
*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_block->b_sst_array == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
// After 'synmaxcol' the attribute is always zero.
|
|
if (syn_buf->b_p_smc > 0 && col >= (colnr_T)syn_buf->b_p_smc) {
|
|
clear_current_state();
|
|
current_id = 0;
|
|
current_trans_id = 0;
|
|
current_flags = 0;
|
|
current_seqnr = 0;
|
|
return 0;
|
|
}
|
|
|
|
// Make sure current_state is valid
|
|
if (INVALID_STATE(¤t_state)) {
|
|
validate_current_state();
|
|
}
|
|
|
|
// Skip from the current column to "col", get the attributes for "col".
|
|
while (current_col <= col) {
|
|
attr = syn_current_attr(false, true, can_spell,
|
|
current_col == col ? keep_state : false);
|
|
current_col++;
|
|
}
|
|
|
|
return attr;
|
|
}
|
|
|
|
/// Get syntax attributes for current_lnum, current_col.
|
|
///
|
|
/// @param syncing When true: called for syncing
|
|
/// @param displaying result will be displayed
|
|
/// @param can_spell return: do spell checking
|
|
/// @param keep_state keep syntax stack afterwards
|
|
static int syn_current_attr(const bool syncing, const bool displaying, bool *const can_spell,
|
|
const bool keep_state)
|
|
{
|
|
lpos_T endpos;
|
|
lpos_T hl_startpos;
|
|
lpos_T hl_endpos;
|
|
lpos_T eos_pos; // end-of-start match (start region)
|
|
lpos_T eoe_pos; // end-of-end pattern
|
|
int end_idx; // group ID for end pattern
|
|
stateitem_T *cur_si;
|
|
stateitem_T *sip = NULL;
|
|
int startcol;
|
|
int endcol;
|
|
int flags;
|
|
int cchar;
|
|
int16_t *next_list;
|
|
bool found_match; // found usable match
|
|
static bool try_next_column = false; // must try in next col
|
|
regmmatch_T regmatch;
|
|
lpos_T pos;
|
|
reg_extmatch_T *cur_extmatch = NULL;
|
|
char buf_chartab[32]; // chartab array for syn iskeyword
|
|
char *line; // current line. NOTE: becomes invalid after
|
|
// looking for a pattern match!
|
|
|
|
// variables for zero-width matches that have a "nextgroup" argument
|
|
bool keep_next_list;
|
|
bool zero_width_next_list = false;
|
|
garray_T zero_width_next_ga;
|
|
|
|
// No character, no attributes! Past end of line?
|
|
// Do try matching with an empty line (could be the start of a region).
|
|
line = syn_getcurline();
|
|
if (line[current_col] == NUL && current_col != 0) {
|
|
// If we found a match after the last column, use it.
|
|
if (next_match_idx >= 0 && next_match_col >= (int)current_col
|
|
&& next_match_col != MAXCOL) {
|
|
push_next_match();
|
|
}
|
|
|
|
current_finished = true;
|
|
current_state_stored = false;
|
|
return 0;
|
|
}
|
|
|
|
// if the current or next character is NUL, we will finish the line now
|
|
if (line[current_col] == NUL || line[current_col + 1] == NUL) {
|
|
current_finished = true;
|
|
current_state_stored = false;
|
|
}
|
|
|
|
// When in the previous column there was a match but it could not be used
|
|
// (empty match or already matched in this column) need to try again in
|
|
// the next column.
|
|
if (try_next_column) {
|
|
next_match_idx = -1;
|
|
try_next_column = false;
|
|
}
|
|
|
|
// Only check for keywords when not syncing and there are some.
|
|
const bool do_keywords = !syncing
|
|
&& (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.
|
|
ga_init(&zero_width_next_ga, (int)sizeof(int), 10);
|
|
|
|
// use syntax iskeyword option
|
|
save_chartab(buf_chartab);
|
|
|
|
// Repeat matching keywords and patterns, to find contained items at the
|
|
// same column. This stops when there are no extra matches at the current
|
|
// column.
|
|
do {
|
|
found_match = false;
|
|
keep_next_list = false;
|
|
int syn_id = 0;
|
|
|
|
// 1. Check for a current state.
|
|
// Only when there is no current state, or if the current state may
|
|
// contain other things, we need to check for keywords and patterns.
|
|
// Always need to check for contained items if some item has the
|
|
// "containedin" argument (takes extra time!).
|
|
if (current_state.ga_len) {
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
} else {
|
|
cur_si = NULL;
|
|
}
|
|
|
|
if (syn_block->b_syn_containedin || cur_si == NULL
|
|
|| cur_si->si_cont_list != NULL) {
|
|
// 2. Check for keywords, if on a keyword char after a non-keyword
|
|
// char. Don't do this when syncing.
|
|
if (do_keywords) {
|
|
line = syn_getcurline();
|
|
const char *cur_pos = line + current_col;
|
|
if (vim_iswordp_buf(cur_pos, syn_buf)
|
|
&& (current_col == 0
|
|
|| !vim_iswordp_buf(cur_pos - 1 -
|
|
utf_head_off(line, cur_pos - 1),
|
|
syn_buf))) {
|
|
syn_id = check_keyword_id(line, (int)current_col, &endcol, &flags,
|
|
&next_list, cur_si, &cchar);
|
|
if (syn_id != 0) {
|
|
push_current_state(KEYWORD_IDX);
|
|
{
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
cur_si->si_m_startcol = current_col;
|
|
cur_si->si_h_startpos.lnum = current_lnum;
|
|
cur_si->si_h_startpos.col = 0; // starts right away
|
|
cur_si->si_m_endpos.lnum = current_lnum;
|
|
cur_si->si_m_endpos.col = endcol;
|
|
cur_si->si_h_endpos.lnum = current_lnum;
|
|
cur_si->si_h_endpos.col = endcol;
|
|
cur_si->si_ends = true;
|
|
cur_si->si_end_idx = 0;
|
|
cur_si->si_flags = flags;
|
|
cur_si->si_seqnr = next_seqnr++;
|
|
cur_si->si_cchar = cchar;
|
|
if (current_state.ga_len > 1) {
|
|
cur_si->si_flags |=
|
|
CUR_STATE(current_state.ga_len - 2).si_flags
|
|
& HL_CONCEAL;
|
|
}
|
|
cur_si->si_id = syn_id;
|
|
cur_si->si_trans_id = syn_id;
|
|
if (flags & HL_TRANSP) {
|
|
if (current_state.ga_len < 2) {
|
|
cur_si->si_attr = 0;
|
|
cur_si->si_trans_id = 0;
|
|
} else {
|
|
cur_si->si_attr = CUR_STATE(current_state.ga_len - 2).si_attr;
|
|
cur_si->si_trans_id = CUR_STATE(current_state.ga_len - 2).si_trans_id;
|
|
}
|
|
} else {
|
|
cur_si->si_attr = syn_id2attr(syn_id);
|
|
}
|
|
cur_si->si_cont_list = NULL;
|
|
cur_si->si_next_list = next_list;
|
|
check_keepend();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Check for patterns (only if no keyword found).
|
|
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
|
|
// for any match with a pattern.
|
|
if (next_match_idx < 0 || next_match_col < (int)current_col) {
|
|
// Check all relevant patterns for a match at this
|
|
// position. This is complicated, because matching with a
|
|
// pattern takes quite a bit of time, thus we want to
|
|
// avoid doing it when it's not needed.
|
|
next_match_idx = 0; // no match in this line yet
|
|
next_match_col = MAXCOL;
|
|
for (int idx = syn_block->b_syn_patterns.ga_len; --idx >= 0;) {
|
|
synpat_T *const spp = &(SYN_ITEMS(syn_block)[idx]);
|
|
if (spp->sp_syncing == syncing
|
|
&& (displaying || !(spp->sp_flags & HL_DISPLAY))
|
|
&& (spp->sp_type == SPTYPE_MATCH
|
|
|| spp->sp_type == SPTYPE_START)
|
|
&& (current_next_list != NULL
|
|
? in_id_list(NULL, current_next_list, &spp->sp_syn, 0)
|
|
: (cur_si == NULL
|
|
? !(spp->sp_flags & HL_CONTAINED)
|
|
: in_id_list(cur_si,
|
|
cur_si->si_cont_list, &spp->sp_syn,
|
|
spp->sp_flags & HL_CONTAINED)))) {
|
|
// If we already tried matching in this line, and
|
|
// there isn't a match before next_match_col, skip
|
|
// this item.
|
|
if (spp->sp_line_id == current_line_id
|
|
&& spp->sp_startcol >= next_match_col) {
|
|
continue;
|
|
}
|
|
spp->sp_line_id = current_line_id;
|
|
|
|
colnr_T lc_col = current_col - spp->sp_offsets[SPO_LC_OFF];
|
|
if (lc_col < 0) {
|
|
lc_col = 0;
|
|
}
|
|
|
|
regmatch.rmm_ic = spp->sp_ic;
|
|
regmatch.regprog = spp->sp_prog;
|
|
int r = syn_regexec(®match, current_lnum, lc_col,
|
|
IF_SYN_TIME(&spp->sp_time));
|
|
spp->sp_prog = regmatch.regprog;
|
|
if (!r) {
|
|
// no match in this line, try another one
|
|
spp->sp_startcol = MAXCOL;
|
|
continue;
|
|
}
|
|
|
|
// Compute the first column of the match.
|
|
syn_add_start_off(&pos, ®match,
|
|
spp, SPO_MS_OFF, -1);
|
|
if (pos.lnum > current_lnum) {
|
|
// must have used end of match in a next line,
|
|
// we can't handle that
|
|
spp->sp_startcol = MAXCOL;
|
|
continue;
|
|
}
|
|
startcol = pos.col;
|
|
|
|
// remember the next column where this pattern
|
|
// matches in the current line
|
|
spp->sp_startcol = startcol;
|
|
|
|
// If a previously found match starts at a lower
|
|
// column number, don't use this one.
|
|
if (startcol >= next_match_col) {
|
|
continue;
|
|
}
|
|
|
|
// If we matched this pattern at this position
|
|
// before, skip it. Must retry in the next
|
|
// column, because it may match from there.
|
|
if (did_match_already(idx, &zero_width_next_ga)) {
|
|
try_next_column = true;
|
|
continue;
|
|
}
|
|
|
|
endpos.lnum = regmatch.endpos[0].lnum;
|
|
endpos.col = regmatch.endpos[0].col;
|
|
|
|
// Compute the highlight start.
|
|
syn_add_start_off(&hl_startpos, ®match,
|
|
spp, SPO_HS_OFF, -1);
|
|
|
|
// Compute the region start.
|
|
// Default is to use the end of the match.
|
|
syn_add_end_off(&eos_pos, ®match,
|
|
spp, SPO_RS_OFF, 0);
|
|
|
|
// Grab the external submatches before they get
|
|
// overwritten. Reference count doesn't change.
|
|
unref_extmatch(cur_extmatch);
|
|
cur_extmatch = re_extmatch_out;
|
|
re_extmatch_out = NULL;
|
|
|
|
flags = 0;
|
|
eoe_pos.lnum = 0; // avoid warning
|
|
eoe_pos.col = 0;
|
|
end_idx = 0;
|
|
hl_endpos.lnum = 0;
|
|
|
|
// For a "oneline" the end must be found in the
|
|
// same line too. Search for it after the end of
|
|
// the match with the start pattern. Set the
|
|
// resulting end positions at the same time.
|
|
if (spp->sp_type == SPTYPE_START
|
|
&& (spp->sp_flags & HL_ONELINE)) {
|
|
lpos_T startpos;
|
|
|
|
startpos = endpos;
|
|
find_endpos(idx, &startpos, &endpos, &hl_endpos,
|
|
&flags, &eoe_pos, &end_idx, cur_extmatch);
|
|
if (endpos.lnum == 0) {
|
|
continue; // not found
|
|
}
|
|
} else if (spp->sp_type == SPTYPE_MATCH) {
|
|
// For a "match" the size must be > 0 after the
|
|
// end offset needs has been added. Except when
|
|
// syncing.
|
|
syn_add_end_off(&hl_endpos, ®match, spp,
|
|
SPO_HE_OFF, 0);
|
|
syn_add_end_off(&endpos, ®match, spp,
|
|
SPO_ME_OFF, 0);
|
|
if (endpos.lnum == current_lnum
|
|
&& (int)endpos.col + syncing < startcol) {
|
|
// If an empty string is matched, may need
|
|
// to try matching again at next column.
|
|
if (regmatch.startpos[0].col == regmatch.endpos[0].col) {
|
|
try_next_column = true;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// keep the best match so far in next_match_*
|
|
|
|
// Highlighting must start after startpos and end
|
|
// before endpos.
|
|
if (hl_startpos.lnum == current_lnum
|
|
&& (int)hl_startpos.col < startcol) {
|
|
hl_startpos.col = startcol;
|
|
}
|
|
limit_pos_zero(&hl_endpos, &endpos);
|
|
|
|
next_match_idx = idx;
|
|
next_match_col = startcol;
|
|
next_match_m_endpos = endpos;
|
|
next_match_h_endpos = hl_endpos;
|
|
next_match_h_startpos = hl_startpos;
|
|
next_match_flags = flags;
|
|
next_match_eos_pos = eos_pos;
|
|
next_match_eoe_pos = eoe_pos;
|
|
next_match_end_idx = end_idx;
|
|
unref_extmatch(next_match_extmatch);
|
|
next_match_extmatch = cur_extmatch;
|
|
cur_extmatch = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we found a match at the current column, use it.
|
|
if (next_match_idx >= 0 && next_match_col == (int)current_col) {
|
|
synpat_T *lspp;
|
|
|
|
// When a zero-width item matched which has a nextgroup,
|
|
// don't push the item but set nextgroup.
|
|
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) {
|
|
current_next_list = lspp->sp_next_list;
|
|
current_next_flags = lspp->sp_flags;
|
|
keep_next_list = true;
|
|
zero_width_next_list = true;
|
|
|
|
// Add the index to a list, so that we can check
|
|
// later that we don't match it again (and cause an
|
|
// endless loop).
|
|
GA_APPEND(int, &zero_width_next_ga, next_match_idx);
|
|
next_match_idx = -1;
|
|
} else {
|
|
cur_si = push_next_match();
|
|
}
|
|
found_match = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle searching for nextgroup match.
|
|
if (current_next_list != NULL && !keep_next_list) {
|
|
// If a nextgroup was not found, continue looking for one if:
|
|
// - this is an empty line and the "skipempty" option was given
|
|
// - we are on white space and the "skipwhite" option was given
|
|
if (!found_match) {
|
|
line = syn_getcurline();
|
|
if (((current_next_flags & HL_SKIPWHITE)
|
|
&& ascii_iswhite(line[current_col]))
|
|
|| ((current_next_flags & HL_SKIPEMPTY)
|
|
&& *line == NUL)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If a nextgroup was found: Use it, and continue looking for
|
|
// contained matches.
|
|
// If a nextgroup was not found: Continue looking for a normal
|
|
// match.
|
|
// When did set current_next_list for a zero-width item and no
|
|
// match was found don't loop (would get stuck).
|
|
current_next_list = NULL;
|
|
next_match_idx = -1;
|
|
if (!zero_width_next_list) {
|
|
found_match = true;
|
|
}
|
|
}
|
|
} while (found_match);
|
|
|
|
restore_chartab(buf_chartab);
|
|
|
|
// Use attributes from the current state, if within its highlighting.
|
|
// If not, use attributes from the current-but-one state, etc.
|
|
current_attr = 0;
|
|
current_id = 0;
|
|
current_trans_id = 0;
|
|
current_flags = 0;
|
|
current_seqnr = 0;
|
|
if (cur_si != NULL) {
|
|
for (int idx = current_state.ga_len - 1; idx >= 0; idx--) {
|
|
sip = &CUR_STATE(idx);
|
|
if ((current_lnum > sip->si_h_startpos.lnum
|
|
|| (current_lnum == sip->si_h_startpos.lnum
|
|
&& current_col >= sip->si_h_startpos.col))
|
|
&& (sip->si_h_endpos.lnum == 0
|
|
|| current_lnum < sip->si_h_endpos.lnum
|
|
|| (current_lnum == sip->si_h_endpos.lnum
|
|
&& current_col < sip->si_h_endpos.col))) {
|
|
current_attr = sip->si_attr;
|
|
current_id = sip->si_id;
|
|
current_trans_id = sip->si_trans_id;
|
|
current_flags = sip->si_flags;
|
|
current_seqnr = sip->si_seqnr;
|
|
current_sub_char = sip->si_cchar;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (can_spell != NULL) {
|
|
struct sp_syn sps;
|
|
|
|
// set "can_spell" to true if spell checking is supposed to be
|
|
// done in the current item.
|
|
if (syn_block->b_spell_cluster_id == 0) {
|
|
// There is no @Spell cluster: Do spelling for items without
|
|
// @NoSpell cluster.
|
|
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 = (int16_t)syn_block->b_nospell_cluster_id;
|
|
sps.cont_in_list = NULL;
|
|
*can_spell = !in_id_list(sip, sip->si_cont_list, &sps, 0);
|
|
}
|
|
} else {
|
|
// The @Spell cluster is defined: Do spelling in items with
|
|
// the @Spell cluster. But not when @NoSpell is also there.
|
|
// At the toplevel only spell check when ":syn spell toplevel"
|
|
// was used.
|
|
if (current_trans_id == 0) {
|
|
*can_spell = (syn_block->b_syn_spell == SYNSPL_TOP);
|
|
} else {
|
|
sps.inc_tag = 0;
|
|
sps.id = (int16_t)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_block->b_nospell_cluster_id != 0) {
|
|
sps.id = (int16_t)syn_block->b_nospell_cluster_id;
|
|
if (in_id_list(sip, sip->si_cont_list, &sps, 0)) {
|
|
*can_spell = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for end of current state (and the states before it) at the
|
|
// next column. Don't do this for syncing, because we would miss a
|
|
// single character match.
|
|
// First check if the current state ends at the current column. It
|
|
// may be for an empty match and a containing item might end in the
|
|
// current column.
|
|
if (!syncing && !keep_state) {
|
|
check_state_ends();
|
|
if (!GA_EMPTY(¤t_state)
|
|
&& syn_getcurline()[current_col] != NUL) {
|
|
current_col++;
|
|
check_state_ends();
|
|
current_col--;
|
|
}
|
|
}
|
|
} 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_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
|
|
&& (line = syn_getcurline())[current_col] != NUL
|
|
&& line[current_col + 1] == NUL
|
|
&& !(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))) {
|
|
current_next_list = NULL;
|
|
}
|
|
|
|
if (!GA_EMPTY(&zero_width_next_ga)) {
|
|
ga_clear(&zero_width_next_ga);
|
|
}
|
|
|
|
// No longer need external matches. But keep next_match_extmatch.
|
|
unref_extmatch(re_extmatch_out);
|
|
re_extmatch_out = NULL;
|
|
unref_extmatch(cur_extmatch);
|
|
|
|
return current_attr;
|
|
}
|
|
|
|
/// @return true if we already matched pattern "idx" at the current column.
|
|
static bool did_match_already(int idx, garray_T *gap)
|
|
{
|
|
for (int i = current_state.ga_len; --i >= 0;) {
|
|
if (CUR_STATE(i).si_m_startcol == (int)current_col
|
|
&& CUR_STATE(i).si_m_lnum == (int)current_lnum
|
|
&& CUR_STATE(i).si_idx == idx) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Zero-width matches with a nextgroup argument are not put on the syntax
|
|
// stack, and can only be matched once anyway.
|
|
for (int i = gap->ga_len; --i >= 0;) {
|
|
if (((int *)(gap->ga_data))[i] == idx) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Push the next match onto the stack.
|
|
static stateitem_T *push_next_match(void)
|
|
{
|
|
stateitem_T *cur_si;
|
|
synpat_T *spp;
|
|
int save_flags;
|
|
|
|
spp = &(SYN_ITEMS(syn_block)[next_match_idx]);
|
|
|
|
// Push the item in current_state stack;
|
|
push_current_state(next_match_idx);
|
|
{
|
|
// If it's a start-skip-end type that crosses lines, figure out how
|
|
// much it continues in this line. Otherwise just fill in the length.
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
cur_si->si_h_startpos = next_match_h_startpos;
|
|
cur_si->si_m_startcol = current_col;
|
|
cur_si->si_m_lnum = current_lnum;
|
|
cur_si->si_flags = spp->sp_flags;
|
|
cur_si->si_seqnr = next_seqnr++;
|
|
cur_si->si_cchar = spp->sp_cchar;
|
|
if (current_state.ga_len > 1) {
|
|
cur_si->si_flags |=
|
|
CUR_STATE(current_state.ga_len - 2).si_flags & HL_CONCEAL;
|
|
}
|
|
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)) {
|
|
// Try to find the end pattern in the current line
|
|
update_si_end(cur_si, (int)(next_match_m_endpos.col), true);
|
|
check_keepend();
|
|
} else {
|
|
cur_si->si_m_endpos = next_match_m_endpos;
|
|
cur_si->si_h_endpos = next_match_h_endpos;
|
|
cur_si->si_ends = true;
|
|
cur_si->si_flags |= next_match_flags;
|
|
cur_si->si_eoe_pos = next_match_eoe_pos;
|
|
cur_si->si_end_idx = next_match_end_idx;
|
|
}
|
|
if (keepend_level < 0 && (cur_si->si_flags & HL_KEEPEND)) {
|
|
keepend_level = current_state.ga_len - 1;
|
|
}
|
|
check_keepend();
|
|
update_si_attr(current_state.ga_len - 1);
|
|
|
|
save_flags = cur_si->si_flags & (HL_CONCEAL | HL_CONCEALENDS);
|
|
// If the start pattern has another highlight group, push another item
|
|
// on the stack for the start pattern.
|
|
if (spp->sp_type == SPTYPE_START && spp->sp_syn_match_id != 0) {
|
|
push_current_state(next_match_idx);
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
cur_si->si_h_startpos = next_match_h_startpos;
|
|
cur_si->si_m_startcol = current_col;
|
|
cur_si->si_m_lnum = current_lnum;
|
|
cur_si->si_m_endpos = next_match_eos_pos;
|
|
cur_si->si_h_endpos = next_match_eos_pos;
|
|
cur_si->si_ends = true;
|
|
cur_si->si_end_idx = 0;
|
|
cur_si->si_flags = HL_MATCH;
|
|
cur_si->si_seqnr = next_seqnr++;
|
|
cur_si->si_flags |= save_flags;
|
|
if (cur_si->si_flags & HL_CONCEALENDS) {
|
|
cur_si->si_flags |= HL_CONCEAL;
|
|
}
|
|
cur_si->si_next_list = NULL;
|
|
check_keepend();
|
|
update_si_attr(current_state.ga_len - 1);
|
|
}
|
|
}
|
|
|
|
next_match_idx = -1; // try other match next time
|
|
|
|
return cur_si;
|
|
}
|
|
|
|
// Check for end of current state (and the states before it).
|
|
static void check_state_ends(void)
|
|
{
|
|
stateitem_T *cur_si;
|
|
int had_extend;
|
|
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
while (true) {
|
|
if (cur_si->si_ends
|
|
&& (cur_si->si_m_endpos.lnum < current_lnum
|
|
|| (cur_si->si_m_endpos.lnum == current_lnum
|
|
&& cur_si->si_m_endpos.col <= current_col))) {
|
|
// If there is an end pattern group ID, highlight the end pattern
|
|
// now. No need to pop the current item from the stack.
|
|
// Only do this if the end pattern continues beyond the current
|
|
// position.
|
|
if (cur_si->si_end_idx
|
|
&& (cur_si->si_eoe_pos.lnum > current_lnum
|
|
|| (cur_si->si_eoe_pos.lnum == current_lnum
|
|
&& cur_si->si_eoe_pos.col > current_col))) {
|
|
cur_si->si_idx = cur_si->si_end_idx;
|
|
cur_si->si_end_idx = 0;
|
|
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;
|
|
cur_si->si_seqnr = next_seqnr++;
|
|
if (cur_si->si_flags & HL_CONCEALENDS) {
|
|
cur_si->si_flags |= HL_CONCEAL;
|
|
}
|
|
update_si_attr(current_state.ga_len - 1);
|
|
|
|
// nextgroup= should not match in the end pattern
|
|
current_next_list = NULL;
|
|
|
|
// what matches next may be different now, clear it
|
|
next_match_idx = 0;
|
|
next_match_col = MAXCOL;
|
|
break;
|
|
}
|
|
|
|
// handle next_list, unless at end of line and no "skipnl" or
|
|
// "skipempty"
|
|
current_next_list = cur_si->si_next_list;
|
|
current_next_flags = cur_si->si_flags;
|
|
if (!(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))
|
|
&& syn_getcurline()[current_col] == NUL) {
|
|
current_next_list = NULL;
|
|
}
|
|
|
|
// When the ended item has "extend", another item with
|
|
// "keepend" now needs to check for its end.
|
|
had_extend = (cur_si->si_flags & HL_EXTEND);
|
|
|
|
pop_current_state();
|
|
|
|
if (GA_EMPTY(¤t_state)) {
|
|
break;
|
|
}
|
|
|
|
if (had_extend && keepend_level >= 0) {
|
|
syn_update_ends(false);
|
|
if (GA_EMPTY(¤t_state)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
cur_si = &CUR_STATE(current_state.ga_len - 1);
|
|
|
|
// Only for a region the search for the end continues after
|
|
// the end of the contained item. If the contained match
|
|
// included the end-of-line, break here, the region continues.
|
|
// Don't do this when:
|
|
// - "keepend" is used for the contained item
|
|
// - not at the end of the line (could be end="x$"me=e-1).
|
|
// - "excludenl" is used (HL_HAS_EOL won't be set)
|
|
if (cur_si->si_idx >= 0
|
|
&& SYN_ITEMS(syn_block)[cur_si->si_idx].sp_type == SPTYPE_START
|
|
&& !(cur_si->si_flags & (HL_MATCH | HL_KEEPEND))) {
|
|
update_si_end(cur_si, (int)current_col, true);
|
|
check_keepend();
|
|
if ((current_next_flags & HL_HAS_EOL)
|
|
&& keepend_level < 0
|
|
&& syn_getcurline()[current_col] == NUL) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update an entry in the current_state stack for a match or region. This
|
|
// fills in si_attr, si_next_list and si_cont_list.
|
|
static void update_si_attr(int idx)
|
|
{
|
|
stateitem_T *sip = &CUR_STATE(idx);
|
|
synpat_T *spp;
|
|
|
|
// This should not happen...
|
|
if (sip->si_idx < 0) {
|
|
return;
|
|
}
|
|
|
|
spp = &(SYN_ITEMS(syn_block)[sip->si_idx]);
|
|
if (sip->si_flags & HL_MATCH) {
|
|
sip->si_id = spp->sp_syn_match_id;
|
|
} else {
|
|
sip->si_id = spp->sp_syn.id;
|
|
}
|
|
sip->si_attr = syn_id2attr(sip->si_id);
|
|
sip->si_trans_id = sip->si_id;
|
|
if (sip->si_flags & HL_MATCH) {
|
|
sip->si_cont_list = NULL;
|
|
} else {
|
|
sip->si_cont_list = spp->sp_cont_list;
|
|
}
|
|
|
|
// For transparent items, take attr from outer item.
|
|
// Also take cont_list, if there is none.
|
|
// Don't do this for the matchgroup of a start or end pattern.
|
|
if ((spp->sp_flags & HL_TRANSP) && !(sip->si_flags & HL_MATCH)) {
|
|
if (idx == 0) {
|
|
sip->si_attr = 0;
|
|
sip->si_trans_id = 0;
|
|
if (sip->si_cont_list == NULL) {
|
|
sip->si_cont_list = ID_LIST_ALL;
|
|
}
|
|
} else {
|
|
sip->si_attr = CUR_STATE(idx - 1).si_attr;
|
|
sip->si_trans_id = CUR_STATE(idx - 1).si_trans_id;
|
|
if (sip->si_cont_list == NULL) {
|
|
sip->si_flags |= HL_TRANS_CONT;
|
|
sip->si_cont_list = CUR_STATE(idx - 1).si_cont_list;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check the current stack for patterns with "keepend" flag.
|
|
// Propagate the match-end to contained items, until a "skipend" item is found.
|
|
static void check_keepend(void)
|
|
{
|
|
int i;
|
|
lpos_T maxpos;
|
|
lpos_T maxpos_h;
|
|
stateitem_T *sip;
|
|
|
|
// This check can consume a lot of time; only do it from the level where
|
|
// there really is a keepend.
|
|
if (keepend_level < 0) {
|
|
return;
|
|
}
|
|
|
|
// Find the last index of an "extend" item. "keepend" items before that
|
|
// won't do anything. If there is no "extend" item "i" will be
|
|
// "keepend_level" and all "keepend" items will work normally.
|
|
for (i = current_state.ga_len - 1; i > keepend_level; i--) {
|
|
if (CUR_STATE(i).si_flags & HL_EXTEND) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
maxpos.lnum = 0;
|
|
maxpos.col = 0;
|
|
maxpos_h.lnum = 0;
|
|
maxpos_h.col = 0;
|
|
for (; i < current_state.ga_len; i++) {
|
|
sip = &CUR_STATE(i);
|
|
if (maxpos.lnum != 0) {
|
|
limit_pos_zero(&sip->si_m_endpos, &maxpos);
|
|
limit_pos_zero(&sip->si_h_endpos, &maxpos_h);
|
|
limit_pos_zero(&sip->si_eoe_pos, &maxpos);
|
|
sip->si_ends = true;
|
|
}
|
|
if (sip->si_ends && (sip->si_flags & HL_KEEPEND)) {
|
|
if (maxpos.lnum == 0
|
|
|| maxpos.lnum > sip->si_m_endpos.lnum
|
|
|| (maxpos.lnum == sip->si_m_endpos.lnum
|
|
&& maxpos.col > sip->si_m_endpos.col)) {
|
|
maxpos = sip->si_m_endpos;
|
|
}
|
|
if (maxpos_h.lnum == 0
|
|
|| maxpos_h.lnum > sip->si_h_endpos.lnum
|
|
|| (maxpos_h.lnum == sip->si_h_endpos.lnum
|
|
&& maxpos_h.col > sip->si_h_endpos.col)) {
|
|
maxpos_h = sip->si_h_endpos;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Update an entry in the current_state stack for a start-skip-end pattern.
|
|
/// This finds the end of the current item, if it's in the current line.
|
|
///
|
|
/// @param startcol where to start searching for the end
|
|
/// @param force when true overrule a previous end
|
|
///
|
|
/// @return the flags for the matched END.
|
|
static void update_si_end(stateitem_T *sip, int startcol, bool force)
|
|
{
|
|
lpos_T hl_endpos;
|
|
lpos_T end_endpos;
|
|
|
|
// return quickly for a keyword
|
|
if (sip->si_idx < 0) {
|
|
return;
|
|
}
|
|
|
|
// Don't update when it's already done. Can be a match of an end pattern
|
|
// that started in a previous line. Watch out: can also be a "keepend"
|
|
// from a containing item.
|
|
if (!force && sip->si_m_endpos.lnum >= current_lnum) {
|
|
return;
|
|
}
|
|
|
|
// We need to find the end of the region. It may continue in the next
|
|
// line.
|
|
int end_idx = 0;
|
|
lpos_T startpos = {
|
|
.lnum = current_lnum,
|
|
.col = startcol,
|
|
};
|
|
lpos_T endpos = { 0 };
|
|
find_endpos(sip->si_idx, &startpos, &endpos, &hl_endpos,
|
|
&(sip->si_flags), &end_endpos, &end_idx, sip->si_extmatch);
|
|
|
|
if (endpos.lnum == 0) {
|
|
// No end pattern matched.
|
|
if (SYN_ITEMS(syn_block)[sip->si_idx].sp_flags & HL_ONELINE) {
|
|
// a "oneline" never continues in the next line
|
|
sip->si_ends = true;
|
|
sip->si_m_endpos.lnum = current_lnum;
|
|
sip->si_m_endpos.col = (colnr_T)strlen(syn_getcurline());
|
|
} else {
|
|
// continues in the next line
|
|
sip->si_ends = false;
|
|
sip->si_m_endpos.lnum = 0;
|
|
}
|
|
sip->si_h_endpos = sip->si_m_endpos;
|
|
} else {
|
|
// match within this line
|
|
sip->si_m_endpos = endpos;
|
|
sip->si_h_endpos = hl_endpos;
|
|
sip->si_eoe_pos = end_endpos;
|
|
sip->si_ends = true;
|
|
sip->si_end_idx = end_idx;
|
|
}
|
|
}
|
|
|
|
// Add a new state to the current state stack.
|
|
// It is cleared and the index set to "idx".
|
|
static void push_current_state(int idx)
|
|
{
|
|
stateitem_T *p = GA_APPEND_VIA_PTR(stateitem_T, ¤t_state);
|
|
CLEAR_POINTER(p);
|
|
p->si_idx = idx;
|
|
}
|
|
|
|
// Remove a state from the current_state stack.
|
|
static void pop_current_state(void)
|
|
{
|
|
if (!GA_EMPTY(¤t_state)) {
|
|
unref_extmatch(CUR_STATE(current_state.ga_len - 1).si_extmatch);
|
|
current_state.ga_len--;
|
|
}
|
|
// after the end of a pattern, try matching a keyword or pattern
|
|
next_match_idx = -1;
|
|
|
|
// if first state with "keepend" is popped, reset keepend_level
|
|
if (keepend_level >= current_state.ga_len) {
|
|
keepend_level = -1;
|
|
}
|
|
}
|
|
|
|
/// Find the end of a start/skip/end syntax region after "startpos".
|
|
/// Only checks one line.
|
|
/// Also handles a match item that continued from a previous line.
|
|
/// If not found, the syntax item continues in the next line. m_endpos->lnum
|
|
/// will be 0.
|
|
/// If found, the end of the region and the end of the highlighting is
|
|
/// computed.
|
|
///
|
|
/// @param idx index of the pattern
|
|
/// @param startpos where to start looking for an END match
|
|
/// @param m_endpos return: end of match
|
|
/// @param hl_endpos return: end of highlighting
|
|
/// @param flagsp return: flags of matching END
|
|
/// @param end_endpos return: end of end pattern match
|
|
/// @param end_idx return: group ID for end pat. match, or 0
|
|
/// @param start_ext submatches from the start pattern
|
|
static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_endpos, int *flagsp,
|
|
lpos_T *end_endpos, int *end_idx, reg_extmatch_T *start_ext)
|
|
{
|
|
synpat_T *spp_skip;
|
|
int best_idx;
|
|
regmmatch_T regmatch;
|
|
regmmatch_T best_regmatch; // startpos/endpos of best match
|
|
lpos_T pos;
|
|
char *line;
|
|
bool had_match = false;
|
|
char buf_chartab[32]; // chartab array for syn option iskeyword
|
|
|
|
// just in case we are invoked for a keyword
|
|
if (idx < 0) {
|
|
return;
|
|
}
|
|
|
|
// Check for being called with a START pattern.
|
|
// Can happen with a match that continues to the next line, because it
|
|
// contained a region.
|
|
synpat_T *spp = &(SYN_ITEMS(syn_block)[idx]);
|
|
if (spp->sp_type != SPTYPE_START) {
|
|
*hl_endpos = *startpos;
|
|
return;
|
|
}
|
|
|
|
// Find the SKIP or first END pattern after the last START pattern.
|
|
while (true) {
|
|
spp = &(SYN_ITEMS(syn_block)[idx]);
|
|
if (spp->sp_type != SPTYPE_START) {
|
|
break;
|
|
}
|
|
idx++;
|
|
}
|
|
|
|
// Lookup the SKIP pattern (if present)
|
|
if (spp->sp_type == SPTYPE_SKIP) {
|
|
spp_skip = spp;
|
|
idx++;
|
|
} else {
|
|
spp_skip = NULL;
|
|
}
|
|
|
|
// Setup external matches for syn_regexec().
|
|
unref_extmatch(re_extmatch_in);
|
|
re_extmatch_in = ref_extmatch(start_ext);
|
|
|
|
colnr_T matchcol = startpos->col; // start looking for a match at sstart
|
|
int start_idx = idx; // remember the first END pattern.
|
|
best_regmatch.startpos[0].col = 0; // avoid compiler warning
|
|
|
|
// use syntax iskeyword option
|
|
save_chartab(buf_chartab);
|
|
|
|
while (true) {
|
|
// Find end pattern that matches first after "matchcol".
|
|
best_idx = -1;
|
|
for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; idx++) {
|
|
int lc_col = matchcol;
|
|
|
|
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];
|
|
if (lc_col < 0) {
|
|
lc_col = 0;
|
|
}
|
|
|
|
regmatch.rmm_ic = spp->sp_ic;
|
|
regmatch.regprog = spp->sp_prog;
|
|
bool r = syn_regexec(®match, startpos->lnum, lc_col,
|
|
IF_SYN_TIME(&spp->sp_time));
|
|
spp->sp_prog = regmatch.regprog;
|
|
if (r) {
|
|
if (best_idx == -1 || regmatch.startpos[0].col
|
|
< best_regmatch.startpos[0].col) {
|
|
best_idx = idx;
|
|
best_regmatch.startpos[0] = regmatch.startpos[0];
|
|
best_regmatch.endpos[0] = regmatch.endpos[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
// If all end patterns have been tried, and there is no match, the
|
|
// item continues until end-of-line.
|
|
if (best_idx == -1) {
|
|
break;
|
|
}
|
|
|
|
// If the skip pattern matches before the end pattern,
|
|
// continue searching after the skip pattern.
|
|
if (spp_skip != NULL) {
|
|
int lc_col = matchcol - spp_skip->sp_offsets[SPO_LC_OFF];
|
|
|
|
if (lc_col < 0) {
|
|
lc_col = 0;
|
|
}
|
|
regmatch.rmm_ic = spp_skip->sp_ic;
|
|
regmatch.regprog = spp_skip->sp_prog;
|
|
int r = syn_regexec(®match, startpos->lnum, lc_col,
|
|
IF_SYN_TIME(&spp_skip->sp_time));
|
|
spp_skip->sp_prog = regmatch.regprog;
|
|
if (r && regmatch.startpos[0].col <= best_regmatch.startpos[0].col) {
|
|
// Add offset to skip pattern match
|
|
syn_add_end_off(&pos, ®match, spp_skip, SPO_ME_OFF, 1);
|
|
|
|
// If the skip pattern goes on to the next line, there is no
|
|
// match with an end pattern in this line.
|
|
if (pos.lnum > startpos->lnum) {
|
|
break;
|
|
}
|
|
|
|
line = ml_get_buf(syn_buf, startpos->lnum);
|
|
int line_len = (int)strlen(line);
|
|
|
|
// take care of an empty match or negative offset
|
|
if (pos.col <= matchcol) {
|
|
matchcol++;
|
|
} else if (pos.col <= regmatch.endpos[0].col) {
|
|
matchcol = pos.col;
|
|
} else {
|
|
// Be careful not to jump over the NUL at the end-of-line
|
|
for (matchcol = regmatch.endpos[0].col;
|
|
matchcol < line_len && matchcol < pos.col;
|
|
matchcol++) {}
|
|
}
|
|
|
|
// if the skip pattern includes end-of-line, break here
|
|
if (matchcol >= line_len) {
|
|
break;
|
|
}
|
|
|
|
continue; // start with first end pattern again
|
|
}
|
|
}
|
|
|
|
// Match from start pattern to end pattern.
|
|
// Correct for match and highlight offset of end pattern.
|
|
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) {
|
|
m_endpos->col = startpos->col;
|
|
}
|
|
|
|
syn_add_end_off(end_endpos, &best_regmatch, spp, SPO_HE_OFF, 1);
|
|
// can't end before the start
|
|
if (end_endpos->lnum == startpos->lnum
|
|
&& end_endpos->col < startpos->col) {
|
|
end_endpos->col = startpos->col;
|
|
}
|
|
// can't end after the match
|
|
limit_pos(end_endpos, m_endpos);
|
|
|
|
// If the end group is highlighted differently, adjust the pointers.
|
|
if (spp->sp_syn_match_id != spp->sp_syn.id && spp->sp_syn_match_id != 0) {
|
|
*end_idx = best_idx;
|
|
if (spp->sp_off_flags & (1 << (SPO_RE_OFF + SPO_COUNT))) {
|
|
hl_endpos->lnum = best_regmatch.endpos[0].lnum;
|
|
hl_endpos->col = best_regmatch.endpos[0].col;
|
|
} else {
|
|
hl_endpos->lnum = best_regmatch.startpos[0].lnum;
|
|
hl_endpos->col = best_regmatch.startpos[0].col;
|
|
}
|
|
hl_endpos->col += spp->sp_offsets[SPO_RE_OFF];
|
|
|
|
// can't end before the start
|
|
if (hl_endpos->lnum == startpos->lnum
|
|
&& hl_endpos->col < startpos->col) {
|
|
hl_endpos->col = startpos->col;
|
|
}
|
|
limit_pos(hl_endpos, m_endpos);
|
|
|
|
// now the match ends where the highlighting ends, it is turned
|
|
// into the matchgroup for the end
|
|
*m_endpos = *hl_endpos;
|
|
} else {
|
|
*end_idx = 0;
|
|
*hl_endpos = *end_endpos;
|
|
}
|
|
|
|
*flagsp = spp->sp_flags;
|
|
|
|
had_match = true;
|
|
break;
|
|
}
|
|
|
|
// no match for an END pattern in this line
|
|
if (!had_match) {
|
|
m_endpos->lnum = 0;
|
|
}
|
|
|
|
restore_chartab(buf_chartab);
|
|
|
|
// Remove external matches.
|
|
unref_extmatch(re_extmatch_in);
|
|
re_extmatch_in = NULL;
|
|
}
|
|
|
|
// Limit "pos" not to be after "limit".
|
|
static void limit_pos(lpos_T *pos, lpos_T *limit)
|
|
{
|
|
if (pos->lnum > limit->lnum) {
|
|
*pos = *limit;
|
|
} else if (pos->lnum == limit->lnum && pos->col > limit->col) {
|
|
pos->col = limit->col;
|
|
}
|
|
}
|
|
|
|
// Limit "pos" not to be after "limit", unless pos->lnum is zero.
|
|
static void limit_pos_zero(lpos_T *pos, lpos_T *limit)
|
|
{
|
|
if (pos->lnum == 0) {
|
|
*pos = *limit;
|
|
} else {
|
|
limit_pos(pos, limit);
|
|
}
|
|
}
|
|
|
|
/// Add offset to matched text for end of match or highlight.
|
|
///
|
|
/// @param result returned position
|
|
/// @param regmatch start/end of match
|
|
/// @param spp matched pattern
|
|
/// @param idx index of offset
|
|
/// @param extra extra chars for offset to start
|
|
static void syn_add_end_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *spp, int idx,
|
|
int extra)
|
|
{
|
|
int col;
|
|
int off;
|
|
char *base;
|
|
char *p;
|
|
|
|
if (spp->sp_off_flags & (1 << idx)) {
|
|
result->lnum = regmatch->startpos[0].lnum;
|
|
col = regmatch->startpos[0].col;
|
|
off = spp->sp_offsets[idx] + extra;
|
|
} else {
|
|
result->lnum = regmatch->endpos[0].lnum;
|
|
col = regmatch->endpos[0].col;
|
|
off = spp->sp_offsets[idx];
|
|
}
|
|
// Don't go past the end of the line. Matters for "rs=e+2" when there
|
|
// is a matchgroup. Watch out for match with last NL in the buffer.
|
|
if (result->lnum > syn_buf->b_ml.ml_line_count) {
|
|
col = 0;
|
|
} else if (off != 0) {
|
|
base = ml_get_buf(syn_buf, result->lnum);
|
|
p = base + col;
|
|
if (off > 0) {
|
|
while (off-- > 0 && *p != NUL) {
|
|
MB_PTR_ADV(p);
|
|
}
|
|
} else {
|
|
while (off++ < 0 && base < p) {
|
|
MB_PTR_BACK(base, p);
|
|
}
|
|
}
|
|
col = (int)(p - base);
|
|
}
|
|
result->col = col;
|
|
}
|
|
|
|
/// Add offset to matched text for start of match or highlight.
|
|
/// Avoid resulting column to become negative.
|
|
///
|
|
/// @param result returned position
|
|
/// @param regmatch start/end of match
|
|
/// @param extra extra chars for offset to end
|
|
static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *spp, int idx,
|
|
int extra)
|
|
{
|
|
int col;
|
|
int off;
|
|
char *base;
|
|
char *p;
|
|
|
|
if (spp->sp_off_flags & (1 << (idx + SPO_COUNT))) {
|
|
result->lnum = regmatch->endpos[0].lnum;
|
|
col = regmatch->endpos[0].col;
|
|
off = spp->sp_offsets[idx] + extra;
|
|
} else {
|
|
result->lnum = regmatch->startpos[0].lnum;
|
|
col = regmatch->startpos[0].col;
|
|
off = spp->sp_offsets[idx];
|
|
}
|
|
if (result->lnum > syn_buf->b_ml.ml_line_count) {
|
|
// a "\n" at the end of the pattern may take us below the last line
|
|
result->lnum = syn_buf->b_ml.ml_line_count;
|
|
col = (int)strlen(ml_get_buf(syn_buf, result->lnum));
|
|
}
|
|
if (off != 0) {
|
|
base = ml_get_buf(syn_buf, result->lnum);
|
|
p = base + col;
|
|
if (off > 0) {
|
|
while (off-- && *p != NUL) {
|
|
MB_PTR_ADV(p);
|
|
}
|
|
} else {
|
|
while (off++ && base < p) {
|
|
MB_PTR_BACK(base, p);
|
|
}
|
|
}
|
|
col = (int)(p - base);
|
|
}
|
|
result->col = col;
|
|
}
|
|
|
|
/// Get current line in syntax buffer.
|
|
static char *syn_getcurline(void)
|
|
{
|
|
return ml_get_buf(syn_buf, current_lnum);
|
|
}
|
|
|
|
// Call vim_regexec() to find a match with "rmp" in "syn_buf".
|
|
// Returns true when there is a match.
|
|
static bool syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T *st)
|
|
{
|
|
int timed_out = 0;
|
|
proftime_T pt;
|
|
const bool l_syn_time_on = syn_time_on;
|
|
|
|
if (l_syn_time_on) {
|
|
pt = profile_start();
|
|
}
|
|
|
|
if (rmp->regprog == NULL) {
|
|
// This can happen if a previous call to vim_regexec_multi() tried to
|
|
// use the NFA engine, which resulted in NFA_TOO_EXPENSIVE, and
|
|
// compiling the pattern with the other engine fails.
|
|
return false;
|
|
}
|
|
|
|
rmp->rmm_maxcol = (colnr_T)syn_buf->b_p_smc;
|
|
int r = vim_regexec_multi(rmp, syn_win, syn_buf, lnum, col, syn_tm, &timed_out);
|
|
|
|
if (l_syn_time_on) {
|
|
pt = profile_end(pt);
|
|
st->total = profile_add(st->total, pt);
|
|
if (profile_cmp(pt, st->slowest) < 0) {
|
|
st->slowest = pt;
|
|
}
|
|
st->count++;
|
|
if (r > 0) {
|
|
st->match++;
|
|
}
|
|
}
|
|
if (timed_out && !syn_win->w_s->b_syn_slow) {
|
|
syn_win->w_s->b_syn_slow = true;
|
|
msg(_("'redrawtime' exceeded, syntax highlighting disabled"), 0);
|
|
}
|
|
|
|
if (r > 0) {
|
|
rmp->startpos[0].lnum += lnum;
|
|
rmp->endpos[0].lnum += lnum;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Check one position in a line for a matching keyword.
|
|
/// The caller must check if a keyword can start at startcol.
|
|
/// Return its ID if found, 0 otherwise.
|
|
///
|
|
/// @param startcol position in line to check for keyword
|
|
/// @param endcolp return: character after found keyword
|
|
/// @param flagsp return: flags of matching keyword
|
|
/// @param next_listp return: next_list of matching keyword
|
|
/// @param cur_si item at the top of the stack
|
|
/// @param ccharp conceal substitution char
|
|
static int check_keyword_id(char *const line, const int startcol, int *const endcolp,
|
|
int *const flagsp, int16_t **const next_listp,
|
|
stateitem_T *const cur_si, int *const ccharp)
|
|
{
|
|
// Find first character after the keyword. First character was already
|
|
// checked.
|
|
char *const kwp = line + startcol;
|
|
int kwlen = 0;
|
|
do {
|
|
kwlen += utfc_ptr2len(kwp + kwlen);
|
|
} while (vim_iswordp_buf(kwp + kwlen, syn_buf));
|
|
|
|
if (kwlen > MAXKEYWLEN) {
|
|
return 0;
|
|
}
|
|
|
|
// Must make a copy of the keyword, so we can add a NUL and make it
|
|
// lowercase.
|
|
char keyword[MAXKEYWLEN + 1]; // assume max. keyword len is 80
|
|
xstrlcpy(keyword, kwp, (size_t)kwlen + 1);
|
|
|
|
keyentry_T *kp = NULL;
|
|
|
|
// matching case
|
|
if (syn_block->b_keywtab.ht_used != 0) {
|
|
kp = match_keyword(keyword, &syn_block->b_keywtab, cur_si);
|
|
}
|
|
|
|
// ignoring case
|
|
if (kp == NULL && syn_block->b_keywtab_ic.ht_used != 0) {
|
|
str_foldcase(kwp, kwlen, keyword, MAXKEYWLEN + 1);
|
|
kp = match_keyword(keyword, &syn_block->b_keywtab_ic, cur_si);
|
|
}
|
|
|
|
if (kp != NULL) {
|
|
*endcolp = startcol + kwlen;
|
|
*flagsp = kp->flags;
|
|
*next_listp = kp->next_list;
|
|
*ccharp = kp->k_char;
|
|
return kp->k_syn.id;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// Find keywords that match. There can be several with different
|
|
/// attributes.
|
|
/// When current_next_list is non-zero accept only that group, otherwise:
|
|
/// Accept a not-contained keyword at toplevel.
|
|
/// Accept a keyword at other levels only if it is in the contains list.
|
|
static keyentry_T *match_keyword(char *keyword, hashtab_T *ht, stateitem_T *cur_si)
|
|
{
|
|
hashitem_T *hi = hash_find(ht, keyword);
|
|
if (!HASHITEM_EMPTY(hi)) {
|
|
for (keyentry_T *kp = HI2KE(hi); kp != NULL; kp = kp->ke_next) {
|
|
if (current_next_list != 0
|
|
? in_id_list(NULL, current_next_list, &kp->k_syn, 0)
|
|
: (cur_si == NULL
|
|
? !(kp->flags & HL_CONTAINED)
|
|
: in_id_list(cur_si, cur_si->si_cont_list,
|
|
&kp->k_syn, kp->flags & HL_CONTAINED))) {
|
|
return kp;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Handle ":syntax conceal" command.
|
|
static void syn_cmd_conceal(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *next;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
next = skiptowhite(arg);
|
|
if (*arg == NUL) {
|
|
if (curwin->w_s->b_syn_conceal) {
|
|
msg("syntax conceal on", 0);
|
|
} else {
|
|
msg("syntax conceal off", 0);
|
|
}
|
|
} else 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 {
|
|
semsg(_(e_illegal_arg), arg);
|
|
}
|
|
}
|
|
|
|
/// Handle ":syntax case" command.
|
|
static void syn_cmd_case(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *next;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
next = skiptowhite(arg);
|
|
if (*arg == NUL) {
|
|
if (curwin->w_s->b_syn_ic) {
|
|
msg("syntax case ignore", 0);
|
|
} else {
|
|
msg("syntax case match", 0);
|
|
}
|
|
} else if (STRNICMP(arg, "match", 5) == 0 && next - arg == 5) {
|
|
curwin->w_s->b_syn_ic = false;
|
|
} else if (STRNICMP(arg, "ignore", 6) == 0 && next - arg == 6) {
|
|
curwin->w_s->b_syn_ic = true;
|
|
} else {
|
|
semsg(_(e_illegal_arg), arg);
|
|
}
|
|
}
|
|
|
|
/// Handle ":syntax foldlevel" command.
|
|
static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *arg_end;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
if (*arg == NUL) {
|
|
switch (curwin->w_s->b_syn_foldlevel) {
|
|
case SYNFLD_START:
|
|
msg("syntax foldlevel start", 0); break;
|
|
case SYNFLD_MINIMUM:
|
|
msg("syntax foldlevel minimum", 0); break;
|
|
default:
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
arg_end = skiptowhite(arg);
|
|
if (STRNICMP(arg, "start", 5) == 0 && arg_end - arg == 5) {
|
|
curwin->w_s->b_syn_foldlevel = SYNFLD_START;
|
|
} else if (STRNICMP(arg, "minimum", 7) == 0 && arg_end - arg == 7) {
|
|
curwin->w_s->b_syn_foldlevel = SYNFLD_MINIMUM;
|
|
} else {
|
|
semsg(_(e_illegal_arg), arg);
|
|
return;
|
|
}
|
|
|
|
arg = skipwhite(arg_end);
|
|
if (*arg != NUL) {
|
|
semsg(_(e_illegal_arg), arg);
|
|
}
|
|
}
|
|
|
|
/// Handle ":syntax spell" command.
|
|
static void syn_cmd_spell(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *next;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
next = skiptowhite(arg);
|
|
if (*arg == NUL) {
|
|
if (curwin->w_s->b_syn_spell == SYNSPL_TOP) {
|
|
msg("syntax spell toplevel", 0);
|
|
} else if (curwin->w_s->b_syn_spell == SYNSPL_NOTOP) {
|
|
msg("syntax spell notoplevel", 0);
|
|
} else {
|
|
msg("syntax spell default", 0);
|
|
}
|
|
} else if (STRNICMP(arg, "toplevel", 8) == 0 && next - arg == 8) {
|
|
curwin->w_s->b_syn_spell = SYNSPL_TOP;
|
|
} else if (STRNICMP(arg, "notoplevel", 10) == 0 && next - arg == 10) {
|
|
curwin->w_s->b_syn_spell = SYNSPL_NOTOP;
|
|
} else if (STRNICMP(arg, "default", 7) == 0 && next - arg == 7) {
|
|
curwin->w_s->b_syn_spell = SYNSPL_DEFAULT;
|
|
} else {
|
|
semsg(_(e_illegal_arg), arg);
|
|
return;
|
|
}
|
|
|
|
// assume spell checking changed, force a redraw
|
|
redraw_later(curwin, UPD_NOT_VALID);
|
|
}
|
|
|
|
/// Handle ":syntax iskeyword" command.
|
|
static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char save_chartab[32];
|
|
char *save_isk;
|
|
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
arg = skipwhite(arg);
|
|
if (*arg == NUL) {
|
|
msg_puts("\n");
|
|
if (curwin->w_s->b_syn_isk != empty_string_option) {
|
|
msg_puts("syntax iskeyword ");
|
|
msg_outtrans(curwin->w_s->b_syn_isk, 0);
|
|
} else {
|
|
msg_outtrans(_("syntax iskeyword not set"), 0);
|
|
}
|
|
} else {
|
|
if (STRNICMP(arg, "clear", 5) == 0) {
|
|
memmove(curwin->w_s->b_syn_chartab, curbuf->b_chartab, (size_t)32);
|
|
clear_string_option(&curwin->w_s->b_syn_isk);
|
|
} else {
|
|
memmove(save_chartab, curbuf->b_chartab, (size_t)32);
|
|
save_isk = curbuf->b_p_isk;
|
|
curbuf->b_p_isk = xstrdup(arg);
|
|
|
|
buf_init_chartab(curbuf, false);
|
|
memmove(curwin->w_s->b_syn_chartab, curbuf->b_chartab, (size_t)32);
|
|
memmove(curbuf->b_chartab, save_chartab, (size_t)32);
|
|
clear_string_option(&curwin->w_s->b_syn_isk);
|
|
curwin->w_s->b_syn_isk = curbuf->b_p_isk;
|
|
curbuf->b_p_isk = save_isk;
|
|
}
|
|
}
|
|
redraw_later(curwin, UPD_NOT_VALID);
|
|
}
|
|
|
|
// Clear all syntax info for one buffer.
|
|
void syntax_clear(synblock_T *block)
|
|
{
|
|
block->b_syn_error = false; // clear previous error
|
|
block->b_syn_slow = false; // clear previous timeout
|
|
block->b_syn_ic = false; // Use case, by default
|
|
block->b_syn_foldlevel = SYNFLD_START;
|
|
block->b_syn_spell = SYNSPL_DEFAULT; // default spell checking
|
|
block->b_syn_containedin = false;
|
|
block->b_syn_conceal = false;
|
|
|
|
// free the keywords
|
|
clear_keywtab(&block->b_keywtab);
|
|
clear_keywtab(&block->b_keywtab_ic);
|
|
|
|
// free the syntax patterns
|
|
for (int 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 (int 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_regfree(block->b_syn_linecont_prog);
|
|
block->b_syn_linecont_prog = NULL;
|
|
XFREE_CLEAR(block->b_syn_linecont_pat);
|
|
block->b_syn_folditems = 0;
|
|
clear_string_option(&block->b_syn_isk);
|
|
|
|
// free the stored states
|
|
syn_stack_free_all(block);
|
|
invalidate_current_state();
|
|
|
|
// Reset the counter for ":syn include"
|
|
running_syn_inc_tag = 0;
|
|
}
|
|
|
|
// Get rid of ownsyntax for window "wp".
|
|
void reset_synblock(win_T *wp)
|
|
{
|
|
if (wp->w_s != &wp->w_buffer->b_s) {
|
|
syntax_clear(wp->w_s);
|
|
xfree(wp->w_s);
|
|
wp->w_s = &wp->w_buffer->b_s;
|
|
}
|
|
}
|
|
|
|
// Clear syncing info for one buffer.
|
|
static void syntax_sync_clear(void)
|
|
{
|
|
// free the syntax patterns
|
|
for (int 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);
|
|
}
|
|
}
|
|
|
|
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_regfree(curwin->w_s->b_syn_linecont_prog);
|
|
curwin->w_s->b_syn_linecont_prog = NULL;
|
|
XFREE_CLEAR(curwin->w_s->b_syn_linecont_pat);
|
|
clear_string_option(&curwin->w_s->b_syn_isk);
|
|
|
|
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(synblock_T *block, int idx)
|
|
{
|
|
synpat_T *spp;
|
|
|
|
spp = &(SYN_ITEMS(block)[idx]);
|
|
if (spp->sp_flags & HL_FOLD) {
|
|
block->b_syn_folditems--;
|
|
}
|
|
syn_clear_pattern(block, idx);
|
|
memmove(spp, spp + 1, sizeof(synpat_T) * (size_t)(block->b_syn_patterns.ga_len - idx - 1));
|
|
block->b_syn_patterns.ga_len--;
|
|
}
|
|
|
|
// Clear and free one syntax pattern. When clearing all, must be called from
|
|
// last to first!
|
|
static void syn_clear_pattern(synblock_T *block, int i)
|
|
{
|
|
xfree(SYN_ITEMS(block)[i].sp_pattern);
|
|
vim_regfree(SYN_ITEMS(block)[i].sp_prog);
|
|
// Only free sp_cont_list and sp_next_list of first start pattern
|
|
if (i == 0 || SYN_ITEMS(block)[i - 1].sp_type != SPTYPE_START) {
|
|
xfree(SYN_ITEMS(block)[i].sp_cont_list);
|
|
xfree(SYN_ITEMS(block)[i].sp_next_list);
|
|
xfree(SYN_ITEMS(block)[i].sp_syn.cont_in_list);
|
|
}
|
|
}
|
|
|
|
// Clear and free one syntax cluster.
|
|
static void syn_clear_cluster(synblock_T *block, int i)
|
|
{
|
|
xfree(SYN_CLSTR(block)[i].scl_name);
|
|
xfree(SYN_CLSTR(block)[i].scl_name_u);
|
|
xfree(SYN_CLSTR(block)[i].scl_list);
|
|
}
|
|
|
|
/// Handle ":syntax clear" command.
|
|
static void syn_cmd_clear(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *arg_end;
|
|
int id;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
// We have to disable this within ":syn include @group filename",
|
|
// because otherwise @group would get deleted.
|
|
// Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
|
|
// clear".
|
|
if (curwin->w_s->b_syn_topgrp != 0) {
|
|
return;
|
|
}
|
|
|
|
if (ends_excmd(*arg)) {
|
|
// No argument: Clear all syntax items.
|
|
if (syncing) {
|
|
syntax_sync_clear();
|
|
} else {
|
|
syntax_clear(curwin->w_s);
|
|
if (curwin->w_s == &curwin->w_buffer->b_s) {
|
|
do_unlet(S_LEN("b:current_syntax"), true);
|
|
}
|
|
do_unlet(S_LEN("w:current_syntax"), true);
|
|
}
|
|
} else {
|
|
// Clear the group IDs that are in the argument.
|
|
while (!ends_excmd(*arg)) {
|
|
arg_end = skiptowhite(arg);
|
|
if (*arg == '@') {
|
|
id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
|
|
if (id == 0) {
|
|
semsg(_("E391: No such syntax cluster: %s"), arg);
|
|
break;
|
|
}
|
|
// We can't physically delete a cluster without changing
|
|
// the IDs of other clusters, so we do the next best thing
|
|
// and make it empty.
|
|
int scl_id = id - SYNID_CLUSTER;
|
|
|
|
XFREE_CLEAR(SYN_CLSTR(curwin->w_s)[scl_id].scl_list);
|
|
} else {
|
|
id = syn_name2id_len(arg, (size_t)(arg_end - arg));
|
|
if (id == 0) {
|
|
semsg(_(e_nogroup), arg);
|
|
break;
|
|
}
|
|
syn_clear_one(id, syncing);
|
|
}
|
|
arg = skipwhite(arg_end);
|
|
}
|
|
}
|
|
redraw_curbuf_later(UPD_SOME_VALID);
|
|
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
|
|
}
|
|
|
|
// Clear one syntax group for the current buffer.
|
|
static void syn_clear_one(const int id, const bool syncing)
|
|
{
|
|
synpat_T *spp;
|
|
|
|
// Clear keywords only when not ":syn sync clear group-name"
|
|
if (!syncing) {
|
|
syn_clear_keyword(id, &curwin->w_s->b_keywtab);
|
|
syn_clear_keyword(id, &curwin->w_s->b_keywtab_ic);
|
|
}
|
|
|
|
// clear the patterns for "id"
|
|
for (int idx = curwin->w_s->b_syn_patterns.ga_len; --idx >= 0;) {
|
|
spp = &(SYN_ITEMS(curwin->w_s)[idx]);
|
|
if (spp->sp_syn.id != id || spp->sp_syncing != syncing) {
|
|
continue;
|
|
}
|
|
syn_remove_pattern(curwin->w_s, idx);
|
|
}
|
|
}
|
|
|
|
// Handle ":syntax on" command.
|
|
static void syn_cmd_on(exarg_T *eap, int syncing)
|
|
{
|
|
syn_cmd_onoff(eap, "syntax");
|
|
}
|
|
|
|
// Handle ":syntax reset" command.
|
|
// It actually resets highlighting, not syntax.
|
|
static void syn_cmd_reset(exarg_T *eap, int syncing)
|
|
{
|
|
eap->nextcmd = check_nextcmd(eap->arg);
|
|
if (!eap->skip) {
|
|
init_highlight(true, true);
|
|
}
|
|
}
|
|
|
|
// Handle ":syntax manual" command.
|
|
static void syn_cmd_manual(exarg_T *eap, int syncing)
|
|
{
|
|
syn_cmd_onoff(eap, "manual");
|
|
}
|
|
|
|
// Handle ":syntax off" command.
|
|
static void syn_cmd_off(exarg_T *eap, int syncing)
|
|
{
|
|
syn_cmd_onoff(eap, "nosyntax");
|
|
}
|
|
|
|
static void syn_cmd_onoff(exarg_T *eap, char *name)
|
|
FUNC_ATTR_NONNULL_ALL
|
|
{
|
|
eap->nextcmd = check_nextcmd(eap->arg);
|
|
if (!eap->skip) {
|
|
did_syntax_onoff = true;
|
|
char buf[100];
|
|
memcpy(buf, "so ", 4);
|
|
vim_snprintf(buf + 3, sizeof(buf) - 3, SYNTAX_FNAME, name);
|
|
do_cmdline_cmd(buf);
|
|
}
|
|
}
|
|
|
|
void syn_maybe_enable(void)
|
|
{
|
|
if (!did_syntax_onoff) {
|
|
exarg_T ea;
|
|
ea.arg = "";
|
|
ea.skip = false;
|
|
syn_cmd_on(&ea, false);
|
|
}
|
|
}
|
|
|
|
/// Handle ":syntax [list]" command: list current syntax words.
|
|
///
|
|
/// @param syncing when true: list syncing items
|
|
static void syn_cmd_list(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *arg_end;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
if (!syntax_present(curwin)) {
|
|
msg(_(msg_no_items), 0);
|
|
return;
|
|
}
|
|
|
|
if (syncing) {
|
|
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 (!(curwin->w_s->b_syn_sync_flags & SF_MATCH)) {
|
|
if (curwin->w_s->b_syn_sync_minlines == 0) {
|
|
msg_puts(_("no syncing"));
|
|
} else {
|
|
if (curwin->w_s->b_syn_sync_minlines == MAXLNUM) {
|
|
msg_puts(_("syncing starts at the first line"));
|
|
} else {
|
|
msg_puts(_("syncing starts "));
|
|
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 (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();
|
|
syn_match_msg();
|
|
}
|
|
} else {
|
|
msg_puts_title(_("\n--- Syntax items ---"));
|
|
}
|
|
if (ends_excmd(*arg)) {
|
|
// No argument: List all group IDs and all syntax clusters.
|
|
for (int id = 1; id <= highlight_num_groups() && !got_int; id++) {
|
|
syn_list_one(id, syncing, false);
|
|
}
|
|
for (int id = 0; id < curwin->w_s->b_syn_clusters.ga_len && !got_int; id++) {
|
|
syn_list_cluster(id);
|
|
}
|
|
} else {
|
|
// List the group IDs and syntax clusters that are in the argument.
|
|
while (!ends_excmd(*arg) && !got_int) {
|
|
arg_end = skiptowhite(arg);
|
|
if (*arg == '@') {
|
|
int id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
|
|
if (id == 0) {
|
|
semsg(_("E392: No such syntax cluster: %s"), arg);
|
|
} else {
|
|
syn_list_cluster(id - SYNID_CLUSTER);
|
|
}
|
|
} else {
|
|
int id = syn_name2id_len(arg, (size_t)(arg_end - arg));
|
|
if (id == 0) {
|
|
semsg(_(e_nogroup), arg);
|
|
} else {
|
|
syn_list_one(id, syncing, true);
|
|
}
|
|
}
|
|
arg = skipwhite(arg_end);
|
|
}
|
|
}
|
|
eap->nextcmd = check_nextcmd(arg);
|
|
}
|
|
|
|
static void syn_lines_msg(void)
|
|
{
|
|
if (curwin->w_s->b_syn_sync_maxlines > 0
|
|
|| curwin->w_s->b_syn_sync_minlines > 0) {
|
|
msg_puts("; ");
|
|
if (curwin->w_s->b_syn_sync_minlines == MAXLNUM) {
|
|
msg_puts(_("from the first line"));
|
|
} else {
|
|
if (curwin->w_s->b_syn_sync_minlines > 0) {
|
|
msg_puts(_("minimal "));
|
|
msg_outnum(curwin->w_s->b_syn_sync_minlines);
|
|
if (curwin->w_s->b_syn_sync_maxlines) {
|
|
msg_puts(", ");
|
|
}
|
|
}
|
|
if (curwin->w_s->b_syn_sync_maxlines > 0) {
|
|
msg_puts(_("maximal "));
|
|
msg_outnum(curwin->w_s->b_syn_sync_maxlines);
|
|
}
|
|
msg_puts(_(" lines before top line"));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void syn_match_msg(void)
|
|
{
|
|
if (curwin->w_s->b_syn_sync_linebreaks > 0) {
|
|
msg_puts(_("; match "));
|
|
msg_outnum(curwin->w_s->b_syn_sync_linebreaks);
|
|
msg_puts(_(" line breaks"));
|
|
}
|
|
}
|
|
|
|
static int last_matchgroup;
|
|
|
|
/// List one syntax item, for ":syntax" or "syntax list syntax_name".
|
|
///
|
|
/// @param syncing when true: list syncing items
|
|
/// @param link_only when true; list link-only too
|
|
static void syn_list_one(const int id, const bool syncing, const bool link_only)
|
|
{
|
|
bool did_header = false;
|
|
static struct name_list namelist1[] = {
|
|
{ HL_DISPLAY, "display" },
|
|
{ HL_CONTAINED, "contained" },
|
|
{ HL_ONELINE, "oneline" },
|
|
{ HL_KEEPEND, "keepend" },
|
|
{ HL_EXTEND, "extend" },
|
|
{ HL_EXCLUDENL, "excludenl" },
|
|
{ HL_TRANSP, "transparent" },
|
|
{ HL_FOLD, "fold" },
|
|
{ HL_CONCEAL, "conceal" },
|
|
{ HL_CONCEALENDS, "concealends" },
|
|
{ 0, NULL }
|
|
};
|
|
static struct name_list namelist2[] = {
|
|
{ HL_SKIPWHITE, "skipwhite" },
|
|
{ HL_SKIPNL, "skipnl" },
|
|
{ HL_SKIPEMPTY, "skipempty" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
const int attr = HL_ATTR(HLF_D); // highlight like directories
|
|
|
|
// list the keywords for "id"
|
|
if (!syncing) {
|
|
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 (int idx = 0;
|
|
idx < curwin->w_s->b_syn_patterns.ga_len && !got_int;
|
|
idx++) {
|
|
const synpat_T *const spp = &(SYN_ITEMS(curwin->w_s)[idx]);
|
|
if (spp->sp_syn.id != id || spp->sp_syncing != syncing) {
|
|
continue;
|
|
}
|
|
|
|
syn_list_header(did_header, 0, id, true);
|
|
did_header = true;
|
|
last_matchgroup = 0;
|
|
if (spp->sp_type == SPTYPE_MATCH) {
|
|
put_pattern("match", ' ', spp, attr);
|
|
msg_putchar(' ');
|
|
} else if (spp->sp_type == SPTYPE_START) {
|
|
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(' ');
|
|
}
|
|
syn_list_flags(namelist1, spp->sp_flags, attr);
|
|
|
|
if (spp->sp_cont_list != NULL) {
|
|
put_id_list("contains", spp->sp_cont_list, attr);
|
|
}
|
|
|
|
if (spp->sp_syn.cont_in_list != NULL) {
|
|
put_id_list("containedin", spp->sp_syn.cont_in_list, attr);
|
|
}
|
|
|
|
if (spp->sp_next_list != NULL) {
|
|
put_id_list("nextgroup", spp->sp_next_list, attr);
|
|
syn_list_flags(namelist2, spp->sp_flags, attr);
|
|
}
|
|
if (spp->sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE)) {
|
|
if (spp->sp_flags & HL_SYNC_HERE) {
|
|
msg_puts_attr("grouphere", attr);
|
|
} else {
|
|
msg_puts_attr("groupthere", attr);
|
|
}
|
|
msg_putchar(' ');
|
|
if (spp->sp_sync_idx >= 0) {
|
|
msg_outtrans(highlight_group_name(SYN_ITEMS(curwin->w_s)
|
|
[spp->sp_sync_idx].sp_syn.id - 1), 0);
|
|
} else {
|
|
msg_puts("NONE");
|
|
}
|
|
msg_putchar(' ');
|
|
}
|
|
}
|
|
|
|
// list the link, if there is one
|
|
if (highlight_link_id(id - 1) && (did_header || link_only) && !got_int) {
|
|
syn_list_header(did_header, 0, id, true);
|
|
msg_puts_attr("links to", attr);
|
|
msg_putchar(' ');
|
|
msg_outtrans(highlight_group_name(highlight_link_id(id - 1) - 1), 0);
|
|
}
|
|
}
|
|
|
|
static void syn_list_flags(struct name_list *nlist, int flags, int attr)
|
|
{
|
|
for (int i = 0; nlist[i].flag != 0; i++) {
|
|
if (flags & nlist[i].flag) {
|
|
msg_puts_attr(nlist[i].name, attr);
|
|
msg_putchar(' ');
|
|
}
|
|
}
|
|
}
|
|
|
|
// List one syntax cluster, for ":syntax" or "syntax list syntax_name".
|
|
static void syn_list_cluster(int id)
|
|
{
|
|
int endcol = 15;
|
|
|
|
// slight hack: roughly duplicate the guts of syn_list_header()
|
|
msg_putchar('\n');
|
|
msg_outtrans(SYN_CLSTR(curwin->w_s)[id].scl_name, 0);
|
|
|
|
if (msg_col >= endcol) { // output at least one space
|
|
endcol = msg_col + 1;
|
|
}
|
|
if (Columns <= endcol) { // avoid hang for tiny window
|
|
endcol = Columns - 1;
|
|
}
|
|
|
|
msg_advance(endcol);
|
|
if (SYN_CLSTR(curwin->w_s)[id].scl_list != NULL) {
|
|
put_id_list("cluster", SYN_CLSTR(curwin->w_s)[id].scl_list, HL_ATTR(HLF_D));
|
|
} else {
|
|
msg_puts_attr("cluster", HL_ATTR(HLF_D));
|
|
msg_puts("=NONE");
|
|
}
|
|
}
|
|
|
|
static void put_id_list(const char *const name, const int16_t *const list, const int attr)
|
|
{
|
|
msg_puts_attr(name, attr);
|
|
msg_putchar('=');
|
|
for (const int16_t *p = list; *p; p++) {
|
|
if (*p >= SYNID_ALLBUT && *p < SYNID_TOP) {
|
|
if (p[1]) {
|
|
msg_puts("ALLBUT");
|
|
} else {
|
|
msg_puts("ALL");
|
|
}
|
|
} else if (*p >= SYNID_TOP && *p < SYNID_CONTAINED) {
|
|
msg_puts("TOP");
|
|
} else if (*p >= SYNID_CONTAINED && *p < SYNID_CLUSTER) {
|
|
msg_puts("CONTAINED");
|
|
} else if (*p >= SYNID_CLUSTER) {
|
|
int scl_id = *p - SYNID_CLUSTER;
|
|
|
|
msg_putchar('@');
|
|
msg_outtrans(SYN_CLSTR(curwin->w_s)[scl_id].scl_name, 0);
|
|
} else {
|
|
msg_outtrans(highlight_group_name(*p - 1), 0);
|
|
}
|
|
if (p[1]) {
|
|
msg_putchar(',');
|
|
}
|
|
}
|
|
msg_putchar(' ');
|
|
}
|
|
|
|
static void put_pattern(const char *const s, const int c, const synpat_T *const spp, const int attr)
|
|
{
|
|
static const char *const sepchars = "/+=-#@\"|'^&";
|
|
int i;
|
|
|
|
// May have to write "matchgroup=group"
|
|
if (last_matchgroup != spp->sp_syn_match_id) {
|
|
last_matchgroup = spp->sp_syn_match_id;
|
|
msg_puts_attr("matchgroup", attr);
|
|
msg_putchar('=');
|
|
if (last_matchgroup == 0) {
|
|
msg_outtrans("NONE", 0);
|
|
} else {
|
|
msg_outtrans(highlight_group_name(last_matchgroup - 1), 0);
|
|
}
|
|
msg_putchar(' ');
|
|
}
|
|
|
|
// Output the name of the pattern and an '=' or ' '.
|
|
msg_puts_attr(s, attr);
|
|
msg_putchar(c);
|
|
|
|
// output the pattern, in between a char that is not in the pattern
|
|
for (i = 0; vim_strchr(spp->sp_pattern, (uint8_t)sepchars[i]) != NULL;) {
|
|
if (sepchars[++i] == NUL) {
|
|
i = 0; // no good char found, just use the first one
|
|
break;
|
|
}
|
|
}
|
|
msg_putchar(sepchars[i]);
|
|
msg_outtrans(spp->sp_pattern, 0);
|
|
msg_putchar(sepchars[i]);
|
|
|
|
// output any pattern options
|
|
bool first = true;
|
|
for (i = 0; i < SPO_COUNT; i++) {
|
|
const int mask = (1 << i);
|
|
if (!(spp->sp_off_flags & (mask + (mask << SPO_COUNT)))) {
|
|
continue;
|
|
}
|
|
if (!first) {
|
|
msg_putchar(','); // Separate with commas.
|
|
}
|
|
msg_puts(spo_name_tab[i]);
|
|
const int n = spp->sp_offsets[i];
|
|
if (i != SPO_LC_OFF) {
|
|
if (spp->sp_off_flags & mask) {
|
|
msg_putchar('s');
|
|
} else {
|
|
msg_putchar('e');
|
|
}
|
|
if (n > 0) {
|
|
msg_putchar('+');
|
|
}
|
|
}
|
|
if (n || i == SPO_LC_OFF) {
|
|
msg_outnum(n);
|
|
}
|
|
first = false;
|
|
}
|
|
msg_putchar(' ');
|
|
}
|
|
|
|
/// List or clear the keywords for one syntax group.
|
|
///
|
|
/// @param did_header header has already been printed
|
|
///
|
|
/// @return true if the header has been printed.
|
|
static bool syn_list_keywords(const int id, const hashtab_T *const ht, bool did_header,
|
|
const int attr)
|
|
{
|
|
int prev_contained = 0;
|
|
const int16_t *prev_next_list = NULL;
|
|
const int16_t *prev_cont_in_list = NULL;
|
|
int prev_skipnl = 0;
|
|
int prev_skipwhite = 0;
|
|
int prev_skipempty = 0;
|
|
|
|
// Unfortunately, this list of keywords is not sorted on alphabet but on
|
|
// hash value...
|
|
size_t todo = ht->ht_used;
|
|
for (const hashitem_T *hi = ht->ht_array; todo > 0 && !got_int; hi++) {
|
|
if (HASHITEM_EMPTY(hi)) {
|
|
continue;
|
|
}
|
|
todo--;
|
|
for (keyentry_T *kp = HI2KE(hi); kp != NULL && !got_int; kp = kp->ke_next) {
|
|
if (kp->k_syn.id == id) {
|
|
int outlen = 0;
|
|
bool force_newline = false;
|
|
if (prev_contained != (kp->flags & HL_CONTAINED)
|
|
|| prev_skipnl != (kp->flags & HL_SKIPNL)
|
|
|| prev_skipwhite != (kp->flags & HL_SKIPWHITE)
|
|
|| prev_skipempty != (kp->flags & HL_SKIPEMPTY)
|
|
|| prev_cont_in_list != kp->k_syn.cont_in_list
|
|
|| prev_next_list != kp->next_list) {
|
|
force_newline = true;
|
|
} else {
|
|
outlen = (int)strlen(kp->keyword);
|
|
}
|
|
// output "contained" and "nextgroup" on each line
|
|
if (syn_list_header(did_header, outlen, id, force_newline)) {
|
|
prev_contained = 0;
|
|
prev_next_list = NULL;
|
|
prev_cont_in_list = NULL;
|
|
prev_skipnl = 0;
|
|
prev_skipwhite = 0;
|
|
prev_skipempty = 0;
|
|
}
|
|
did_header = true;
|
|
if (prev_contained != (kp->flags & HL_CONTAINED)) {
|
|
msg_puts_attr("contained", attr);
|
|
msg_putchar(' ');
|
|
prev_contained = (kp->flags & HL_CONTAINED);
|
|
}
|
|
if (kp->k_syn.cont_in_list != prev_cont_in_list) {
|
|
put_id_list("containedin", kp->k_syn.cont_in_list, attr);
|
|
msg_putchar(' ');
|
|
prev_cont_in_list = kp->k_syn.cont_in_list;
|
|
}
|
|
if (kp->next_list != prev_next_list) {
|
|
put_id_list("nextgroup", kp->next_list, attr);
|
|
msg_putchar(' ');
|
|
prev_next_list = kp->next_list;
|
|
if (kp->flags & HL_SKIPNL) {
|
|
msg_puts_attr("skipnl", attr);
|
|
msg_putchar(' ');
|
|
prev_skipnl = (kp->flags & HL_SKIPNL);
|
|
}
|
|
if (kp->flags & HL_SKIPWHITE) {
|
|
msg_puts_attr("skipwhite", attr);
|
|
msg_putchar(' ');
|
|
prev_skipwhite = (kp->flags & HL_SKIPWHITE);
|
|
}
|
|
if (kp->flags & HL_SKIPEMPTY) {
|
|
msg_puts_attr("skipempty", attr);
|
|
msg_putchar(' ');
|
|
prev_skipempty = (kp->flags & HL_SKIPEMPTY);
|
|
}
|
|
}
|
|
msg_outtrans(kp->keyword, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
return did_header;
|
|
}
|
|
|
|
static void syn_clear_keyword(int id, hashtab_T *ht)
|
|
{
|
|
hash_lock(ht);
|
|
int todo = (int)ht->ht_used;
|
|
for (hashitem_T *hi = ht->ht_array; todo > 0; hi++) {
|
|
if (HASHITEM_EMPTY(hi)) {
|
|
continue;
|
|
}
|
|
todo--;
|
|
keyentry_T *kp_prev = NULL;
|
|
for (keyentry_T *kp = HI2KE(hi); kp != NULL;) {
|
|
if (kp->k_syn.id == id) {
|
|
keyentry_T *kp_next = kp->ke_next;
|
|
if (kp_prev == NULL) {
|
|
if (kp_next == NULL) {
|
|
hash_remove(ht, hi);
|
|
} else {
|
|
hi->hi_key = KE2HIKEY(kp_next);
|
|
}
|
|
} else {
|
|
kp_prev->ke_next = kp_next;
|
|
}
|
|
xfree(kp->next_list);
|
|
xfree(kp->k_syn.cont_in_list);
|
|
xfree(kp);
|
|
kp = kp_next;
|
|
} else {
|
|
kp_prev = kp;
|
|
kp = kp->ke_next;
|
|
}
|
|
}
|
|
}
|
|
hash_unlock(ht);
|
|
}
|
|
|
|
// Clear a whole keyword table.
|
|
static void clear_keywtab(hashtab_T *ht)
|
|
{
|
|
keyentry_T *kp_next;
|
|
|
|
int todo = (int)ht->ht_used;
|
|
for (hashitem_T *hi = ht->ht_array; todo > 0; hi++) {
|
|
if (!HASHITEM_EMPTY(hi)) {
|
|
todo--;
|
|
for (keyentry_T *kp = HI2KE(hi); kp != NULL; kp = kp_next) {
|
|
kp_next = kp->ke_next;
|
|
xfree(kp->next_list);
|
|
xfree(kp->k_syn.cont_in_list);
|
|
xfree(kp);
|
|
}
|
|
}
|
|
}
|
|
hash_clear(ht);
|
|
hash_init(ht);
|
|
}
|
|
|
|
/// Add a keyword to the list of keywords.
|
|
///
|
|
/// @param name name of keyword
|
|
/// @param id group ID for this keyword
|
|
/// @param flags flags for this keyword
|
|
/// @param cont_in_list containedin for this keyword
|
|
/// @param next_list nextgroup for this keyword
|
|
static void add_keyword(char *const name, const int id, const int flags,
|
|
int16_t *const cont_in_list, int16_t *const next_list,
|
|
const int conceal_char)
|
|
{
|
|
char name_folded[MAXKEYWLEN + 1];
|
|
const char *const name_ic = (curwin->w_s->b_syn_ic)
|
|
? str_foldcase(name, (int)strlen(name), name_folded,
|
|
sizeof(name_folded))
|
|
: name;
|
|
|
|
keyentry_T *const kp = xmalloc(offsetof(keyentry_T, keyword) + strlen(name_ic) + 1);
|
|
STRCPY(kp->keyword, name_ic);
|
|
kp->k_syn.id = (int16_t)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) {
|
|
curwin->w_s->b_syn_containedin = true;
|
|
}
|
|
kp->next_list = copy_id_list(next_list);
|
|
|
|
const hash_T hash = hash_hash(kp->keyword);
|
|
hashtab_T *const ht = (curwin->w_s->b_syn_ic)
|
|
? &curwin->w_s->b_keywtab_ic
|
|
: &curwin->w_s->b_keywtab;
|
|
hashitem_T *const hi = hash_lookup(ht, kp->keyword,
|
|
strlen(kp->keyword), hash);
|
|
|
|
// even though it looks like only the kp->keyword member is
|
|
// being used here, vim uses some pointer trickery to get the original
|
|
// struct again later by using knowledge of the offset of the keyword
|
|
// field in the struct. See the definition of the HI2KE macro.
|
|
if (HASHITEM_EMPTY(hi)) {
|
|
// new keyword, add to hashtable
|
|
kp->ke_next = NULL;
|
|
hash_add_item(ht, hi, kp->keyword, hash);
|
|
} else {
|
|
// keyword already exists, prepend to list
|
|
kp->ke_next = HI2KE(hi);
|
|
hi->hi_key = KE2HIKEY(kp);
|
|
}
|
|
}
|
|
|
|
/// Get the start and end of the group name argument.
|
|
///
|
|
/// @param arg start of the argument
|
|
/// @param name_end pointer to end of the name
|
|
///
|
|
/// @return a pointer to the first argument.
|
|
/// Return NULL if the end of the command was found instead of further args.
|
|
static char *get_group_name(char *arg, char **name_end)
|
|
{
|
|
*name_end = skiptowhite(arg);
|
|
char *rest = skipwhite(*name_end);
|
|
|
|
// Check if there are enough arguments. The first argument may be a
|
|
// pattern, where '|' is allowed, so only check for NUL.
|
|
if (ends_excmd(*arg) || *rest == NUL) {
|
|
return NULL;
|
|
}
|
|
return rest;
|
|
}
|
|
|
|
/// Check for syntax command option arguments.
|
|
/// This can be called at any place in the list of arguments, and just picks
|
|
/// out the arguments that are known. Can be called several times in a row to
|
|
/// collect all options in between other arguments.
|
|
///
|
|
/// @param arg next argument to be checked
|
|
/// @param opt various things
|
|
/// @param skip true if skipping over command
|
|
///
|
|
/// @return a pointer to the next argument (which isn't an option).
|
|
/// Return NULL for any error;
|
|
static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
|
|
{
|
|
int len = 0;
|
|
int fidx;
|
|
static const struct flag {
|
|
char *name;
|
|
int argtype;
|
|
int flags;
|
|
} flagtab[] = { { "cCoOnNtTaAiInNeEdD", 0, HL_CONTAINED },
|
|
{ "oOnNeElLiInNeE", 0, HL_ONELINE },
|
|
{ "kKeEeEpPeEnNdD", 0, HL_KEEPEND },
|
|
{ "eExXtTeEnNdD", 0, HL_EXTEND },
|
|
{ "eExXcClLuUdDeEnNlL", 0, HL_EXCLUDENL },
|
|
{ "tTrRaAnNsSpPaArReEnNtT", 0, HL_TRANSP },
|
|
{ "sSkKiIpPnNlL", 0, HL_SKIPNL },
|
|
{ "sSkKiIpPwWhHiItTeE", 0, HL_SKIPWHITE },
|
|
{ "sSkKiIpPeEmMpPtTyY", 0, HL_SKIPEMPTY },
|
|
{ "gGrRoOuUpPhHeErReE", 0, HL_SYNC_HERE },
|
|
{ "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 }, };
|
|
static const char *const first_letters = "cCoOkKeEtTsSgGdDfFnN";
|
|
|
|
if (arg == NULL) { // already detected error
|
|
return NULL;
|
|
}
|
|
|
|
if (curwin->w_s->b_syn_conceal) {
|
|
opt->flags |= HL_CONCEAL;
|
|
}
|
|
|
|
while (true) {
|
|
// This is used very often when a large number of keywords is defined.
|
|
// Need to skip quickly when no option name is found.
|
|
// Also avoid tolower(), it's slow.
|
|
if (strchr(first_letters, *arg) == NULL) {
|
|
break;
|
|
}
|
|
|
|
for (fidx = ARRAY_SIZE(flagtab); --fidx >= 0;) {
|
|
char *p = flagtab[fidx].name;
|
|
int i;
|
|
for (i = 0, len = 0; p[i] != NUL; i += 2, len++) {
|
|
if (arg[len] != p[i] && arg[len] != p[i + 1]) {
|
|
break;
|
|
}
|
|
}
|
|
if (p[i] == NUL && (ascii_iswhite(arg[len])
|
|
|| (flagtab[fidx].argtype > 0
|
|
? arg[len] == '='
|
|
: ends_excmd(arg[len])))) {
|
|
if (opt->keyword
|
|
&& (flagtab[fidx].flags == HL_DISPLAY
|
|
|| flagtab[fidx].flags == HL_FOLD
|
|
|| flagtab[fidx].flags == HL_EXTEND)) {
|
|
// treat "display", "fold" and "extend" as a keyword
|
|
fidx = -1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (fidx < 0) { // no match found
|
|
break;
|
|
}
|
|
|
|
if (flagtab[fidx].argtype == 1) {
|
|
if (!opt->has_cont_list) {
|
|
emsg(_(e_contains_argument_not_accepted_here));
|
|
return NULL;
|
|
}
|
|
if (get_id_list(&arg, 8, &opt->cont_list, skip) == FAIL) {
|
|
return NULL;
|
|
}
|
|
} else if (flagtab[fidx].argtype == 2) {
|
|
if (get_id_list(&arg, 11, &opt->cont_in_list, skip) == FAIL) {
|
|
return NULL;
|
|
}
|
|
} else if (flagtab[fidx].argtype == 3) {
|
|
if (get_id_list(&arg, 9, &opt->next_list, skip) == FAIL) {
|
|
return NULL;
|
|
}
|
|
} else if (flagtab[fidx].argtype == 11 && arg[5] == '=') {
|
|
// cchar=?
|
|
*conceal_char = utf_ptr2char(arg + 6);
|
|
arg += utfc_ptr2len(arg + 6) - 1;
|
|
if (!vim_isprintc(*conceal_char)) {
|
|
emsg(_(e_invalid_cchar_value));
|
|
return NULL;
|
|
}
|
|
arg = skipwhite(arg + 7);
|
|
} else {
|
|
opt->flags |= flagtab[fidx].flags;
|
|
arg = skipwhite(arg + len);
|
|
|
|
if (flagtab[fidx].flags == HL_SYNC_HERE
|
|
|| flagtab[fidx].flags == HL_SYNC_THERE) {
|
|
if (opt->sync_idx == NULL) {
|
|
emsg(_("E393: group[t]here not accepted here"));
|
|
return NULL;
|
|
}
|
|
char *gname_start = arg;
|
|
arg = skiptowhite(arg);
|
|
if (gname_start == arg) {
|
|
return NULL;
|
|
}
|
|
char *gname = xstrnsave(gname_start, (size_t)(arg - gname_start));
|
|
if (strcmp(gname, "NONE") == 0) {
|
|
*opt->sync_idx = NONE_IDX;
|
|
} else {
|
|
int syn_id = syn_name2id(gname);
|
|
int i;
|
|
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;
|
|
}
|
|
}
|
|
if (i < 0) {
|
|
semsg(_("E394: Didn't find region item for %s"), gname);
|
|
xfree(gname);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
xfree(gname);
|
|
arg = skipwhite(arg);
|
|
} else if (flagtab[fidx].flags == HL_FOLD
|
|
&& foldmethodIsSyntax(curwin)) {
|
|
// Need to update folds later.
|
|
foldUpdateAll(curwin);
|
|
}
|
|
}
|
|
}
|
|
|
|
return arg;
|
|
}
|
|
|
|
// Adjustments to syntax item when declared in a ":syn include"'d file.
|
|
// Set the contained flag, and if the item is not already contained, add it
|
|
// to the specified top-level group, if any.
|
|
static void syn_incl_toplevel(int id, int *flagsp)
|
|
{
|
|
if ((*flagsp & HL_CONTAINED) || curwin->w_s->b_syn_topgrp == 0) {
|
|
return;
|
|
}
|
|
*flagsp |= HL_CONTAINED;
|
|
if (curwin->w_s->b_syn_topgrp >= SYNID_CLUSTER) {
|
|
// We have to alloc this, because syn_combine_list() will free it.
|
|
int16_t *grp_list = xmalloc(2 * sizeof(*grp_list));
|
|
int tlg_id = curwin->w_s->b_syn_topgrp - SYNID_CLUSTER;
|
|
|
|
grp_list[0] = (int16_t)id;
|
|
grp_list[1] = 0;
|
|
syn_combine_list(&SYN_CLSTR(curwin->w_s)[tlg_id].scl_list, &grp_list,
|
|
CLUSTER_ADD);
|
|
}
|
|
}
|
|
|
|
// Handle ":syntax include [@{group-name}] filename" command.
|
|
static void syn_cmd_include(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
int sgl_id = 1;
|
|
char *group_name_end;
|
|
const char *errormsg = NULL;
|
|
bool source = false;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
if (arg[0] == '@') {
|
|
arg++;
|
|
char *rest = get_group_name(arg, &group_name_end);
|
|
if (rest == NULL) {
|
|
emsg(_("E397: Filename required"));
|
|
return;
|
|
}
|
|
sgl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
|
|
if (sgl_id == 0) {
|
|
return;
|
|
}
|
|
// separate_nextcmd() and expand_filename() depend on this
|
|
eap->arg = rest;
|
|
}
|
|
|
|
// Everything that's left, up to the next command, should be the
|
|
// filename to include.
|
|
eap->argt |= (EX_XFILE | EX_NOSPC);
|
|
separate_nextcmd(eap);
|
|
if (*eap->arg == '<' || *eap->arg == '$' || path_is_absolute(eap->arg)) {
|
|
// For an absolute path, "$VIM/..." or "<sfile>.." we ":source" the
|
|
// file. Need to expand the file name first. In other cases
|
|
// ":runtime!" is used.
|
|
source = true;
|
|
if (expand_filename(eap, syn_cmdlinep, &errormsg) == FAIL) {
|
|
if (errormsg != NULL) {
|
|
emsg(errormsg);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Save and restore the existing top-level grouplist id and ":syn
|
|
// include" tag around the actual inclusion.
|
|
if (running_syn_inc_tag >= MAX_SYN_INC_TAG) {
|
|
emsg(_("E847: Too many syntax includes"));
|
|
return;
|
|
}
|
|
int prev_syn_inc_tag = current_syn_inc_tag;
|
|
current_syn_inc_tag = ++running_syn_inc_tag;
|
|
int 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, NULL) == FAIL
|
|
: source_runtime(eap->arg, DIP_ALL) == FAIL) {
|
|
semsg(_(e_notopen), eap->arg);
|
|
}
|
|
curwin->w_s->b_syn_topgrp = prev_toplvl_grp;
|
|
current_syn_inc_tag = prev_syn_inc_tag;
|
|
}
|
|
|
|
// Handle ":syntax keyword {group-name} [{option}] keyword .." command.
|
|
static void syn_cmd_keyword(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *group_name_end;
|
|
int syn_id;
|
|
char *keyword_copy = NULL;
|
|
syn_opt_arg_T syn_opt_arg;
|
|
int conceal_char = NUL;
|
|
|
|
char *rest = get_group_name(arg, &group_name_end);
|
|
|
|
if (rest != NULL) {
|
|
if (eap->skip) {
|
|
syn_id = -1;
|
|
} else {
|
|
syn_id = syn_check_group(arg, (size_t)(group_name_end - arg));
|
|
}
|
|
if (syn_id != 0) {
|
|
// Allocate a buffer, for removing backslashes in the keyword.
|
|
keyword_copy = xmalloc(strlen(rest) + 1);
|
|
}
|
|
if (keyword_copy != NULL) {
|
|
syn_opt_arg.flags = 0;
|
|
syn_opt_arg.keyword = true;
|
|
syn_opt_arg.sync_idx = NULL;
|
|
syn_opt_arg.has_cont_list = false;
|
|
syn_opt_arg.cont_in_list = NULL;
|
|
syn_opt_arg.next_list = NULL;
|
|
|
|
// The options given apply to ALL keywords, so all options must be
|
|
// found before keywords can be created.
|
|
// 1: collect the options and copy the keywords to keyword_copy.
|
|
int cnt = 0;
|
|
char *p = keyword_copy;
|
|
for (; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest)) {
|
|
rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
|
|
if (rest == NULL || ends_excmd(*rest)) {
|
|
break;
|
|
}
|
|
// Copy the keyword, removing backslashes, and add a NUL.
|
|
while (*rest != NUL && !ascii_iswhite(*rest)) {
|
|
if (*rest == '\\' && rest[1] != NUL) {
|
|
rest++;
|
|
}
|
|
*p++ = *rest++;
|
|
}
|
|
*p++ = NUL;
|
|
cnt++;
|
|
}
|
|
|
|
if (!eap->skip) {
|
|
// Adjust flags for use of ":syn include".
|
|
syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
|
|
|
|
// 2: Add an entry for each keyword.
|
|
for (char *kw = keyword_copy; --cnt >= 0; kw += strlen(kw) + 1) {
|
|
for (p = vim_strchr(kw, '[');;) {
|
|
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, conceal_char);
|
|
if (p == NULL) {
|
|
break;
|
|
}
|
|
if (p[1] == NUL) {
|
|
semsg(_("E789: Missing ']': %s"), kw);
|
|
goto error;
|
|
}
|
|
if (p[1] == ']') {
|
|
if (p[2] != NUL) {
|
|
semsg(_(e_trailing_char_after_rsb_str_str), kw, &p[2]);
|
|
goto error;
|
|
}
|
|
kw = p + 1;
|
|
break; // skip over the "]"
|
|
}
|
|
const int l = utfc_ptr2len(p + 1);
|
|
|
|
memmove(p, p + 1, (size_t)l);
|
|
p += l;
|
|
}
|
|
}
|
|
}
|
|
|
|
error:
|
|
xfree(keyword_copy);
|
|
xfree(syn_opt_arg.cont_in_list);
|
|
xfree(syn_opt_arg.next_list);
|
|
}
|
|
}
|
|
|
|
if (rest != NULL) {
|
|
eap->nextcmd = check_nextcmd(rest);
|
|
} else {
|
|
semsg(_(e_invarg2), arg);
|
|
}
|
|
|
|
redraw_curbuf_later(UPD_SOME_VALID);
|
|
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
|
|
}
|
|
|
|
/// Handle ":syntax match {name} [{options}] {pattern} [{options}]".
|
|
///
|
|
/// Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
|
|
///
|
|
/// @param syncing true for ":syntax sync match .. "
|
|
static void syn_cmd_match(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *group_name_end;
|
|
synpat_T item; // the item found in the line
|
|
int syn_id;
|
|
syn_opt_arg_T syn_opt_arg;
|
|
int sync_idx = 0;
|
|
int conceal_char = NUL;
|
|
|
|
// Isolate the group name, check for validity
|
|
char *rest = get_group_name(arg, &group_name_end);
|
|
|
|
// Get options before the pattern
|
|
syn_opt_arg.flags = 0;
|
|
syn_opt_arg.keyword = false;
|
|
syn_opt_arg.sync_idx = syncing ? &sync_idx : NULL;
|
|
syn_opt_arg.has_cont_list = true;
|
|
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, &conceal_char, eap->skip);
|
|
|
|
// get the pattern.
|
|
init_syn_patterns();
|
|
CLEAR_FIELD(item);
|
|
rest = get_syn_pattern(rest, &item);
|
|
if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
|
|
syn_opt_arg.flags |= HL_HAS_EOL;
|
|
}
|
|
|
|
// Get options after the pattern
|
|
rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
|
|
|
|
if (rest != NULL) { // all arguments are valid
|
|
// Check for trailing command and illegal trailing arguments.
|
|
eap->nextcmd = check_nextcmd(rest);
|
|
if (!ends_excmd(*rest) || eap->skip) {
|
|
rest = NULL;
|
|
} else {
|
|
if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
|
|
syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
|
|
// Store the pattern in the syn_items list
|
|
synpat_T *spp = GA_APPEND_VIA_PTR(synpat_T,
|
|
&curwin->w_s->b_syn_patterns);
|
|
*spp = item;
|
|
spp->sp_syncing = syncing;
|
|
spp->sp_type = SPTYPE_MATCH;
|
|
spp->sp_syn.id = (int16_t)syn_id;
|
|
spp->sp_syn.inc_tag = current_syn_inc_tag;
|
|
spp->sp_flags = syn_opt_arg.flags;
|
|
spp->sp_sync_idx = sync_idx;
|
|
spp->sp_cont_list = syn_opt_arg.cont_list;
|
|
spp->sp_syn.cont_in_list = syn_opt_arg.cont_in_list;
|
|
spp->sp_cchar = conceal_char;
|
|
if (syn_opt_arg.cont_in_list != NULL) {
|
|
curwin->w_s->b_syn_containedin = true;
|
|
}
|
|
spp->sp_next_list = syn_opt_arg.next_list;
|
|
|
|
// remember that we found a match for syncing on
|
|
if (syn_opt_arg.flags & (HL_SYNC_HERE|HL_SYNC_THERE)) {
|
|
curwin->w_s->b_syn_sync_flags |= SF_MATCH;
|
|
}
|
|
if (syn_opt_arg.flags & HL_FOLD) {
|
|
curwin->w_s->b_syn_folditems++;
|
|
}
|
|
|
|
redraw_curbuf_later(UPD_SOME_VALID);
|
|
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
|
|
return; // don't free the progs and patterns now
|
|
}
|
|
}
|
|
}
|
|
|
|
// Something failed, free the allocated memory.
|
|
vim_regfree(item.sp_prog);
|
|
xfree(item.sp_pattern);
|
|
xfree(syn_opt_arg.cont_list);
|
|
xfree(syn_opt_arg.cont_in_list);
|
|
xfree(syn_opt_arg.next_list);
|
|
|
|
if (rest == NULL) {
|
|
semsg(_(e_invarg2), arg);
|
|
}
|
|
}
|
|
|
|
/// Handle ":syntax region {group-name} [matchgroup={group-name}]
|
|
/// start {start} .. [skip {skip}] end {end} .. [{options}]".
|
|
///
|
|
/// @param syncing true for ":syntax sync region .."
|
|
static void syn_cmd_region(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *group_name_end;
|
|
char *rest; // next arg, NULL on error
|
|
char *key_end;
|
|
char *key = NULL;
|
|
int item;
|
|
#define ITEM_START 0
|
|
#define ITEM_SKIP 1
|
|
#define ITEM_END 2
|
|
#define ITEM_MATCHGROUP 3
|
|
struct pat_ptr {
|
|
synpat_T *pp_synp; // pointer to syn_pattern
|
|
int pp_matchgroup_id; // matchgroup ID
|
|
struct pat_ptr *pp_next; // pointer to next pat_ptr
|
|
} *(pat_ptrs[3]);
|
|
// patterns found in the line
|
|
struct pat_ptr *ppp;
|
|
struct pat_ptr *ppp_next;
|
|
int pat_count = 0; // nr of syn_patterns found
|
|
int syn_id;
|
|
int matchgroup_id = 0;
|
|
bool not_enough = false; // not enough arguments
|
|
bool illegal = false; // illegal arguments
|
|
bool success = false;
|
|
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);
|
|
|
|
pat_ptrs[0] = NULL;
|
|
pat_ptrs[1] = NULL;
|
|
pat_ptrs[2] = NULL;
|
|
|
|
init_syn_patterns();
|
|
|
|
syn_opt_arg.flags = 0;
|
|
syn_opt_arg.keyword = false;
|
|
syn_opt_arg.sync_idx = NULL;
|
|
syn_opt_arg.has_cont_list = true;
|
|
syn_opt_arg.cont_list = NULL;
|
|
syn_opt_arg.cont_in_list = NULL;
|
|
syn_opt_arg.next_list = NULL;
|
|
|
|
// get the options, patterns and matchgroup.
|
|
while (rest != NULL && !ends_excmd(*rest)) {
|
|
// Check for option arguments
|
|
rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
|
|
if (rest == NULL || ends_excmd(*rest)) {
|
|
break;
|
|
}
|
|
|
|
// must be a pattern or matchgroup then
|
|
key_end = rest;
|
|
while (*key_end && !ascii_iswhite(*key_end) && *key_end != '=') {
|
|
key_end++;
|
|
}
|
|
xfree(key);
|
|
key = vim_strnsave_up(rest, (size_t)(key_end - rest));
|
|
if (strcmp(key, "MATCHGROUP") == 0) {
|
|
item = ITEM_MATCHGROUP;
|
|
} else if (strcmp(key, "START") == 0) {
|
|
item = ITEM_START;
|
|
} else if (strcmp(key, "END") == 0) {
|
|
item = ITEM_END;
|
|
} else if (strcmp(key, "SKIP") == 0) {
|
|
if (pat_ptrs[ITEM_SKIP] != NULL) { // One skip pattern allowed.
|
|
illegal = true;
|
|
break;
|
|
}
|
|
item = ITEM_SKIP;
|
|
} else {
|
|
break;
|
|
}
|
|
rest = skipwhite(key_end);
|
|
if (*rest != '=') {
|
|
rest = NULL;
|
|
semsg(_("E398: Missing '=': %s"), arg);
|
|
break;
|
|
}
|
|
rest = skipwhite(rest + 1);
|
|
if (*rest == NUL) {
|
|
not_enough = true;
|
|
break;
|
|
}
|
|
|
|
if (item == ITEM_MATCHGROUP) {
|
|
char *p = skiptowhite(rest);
|
|
if ((p - rest == 4 && strncmp(rest, "NONE", 4) == 0) || eap->skip) {
|
|
matchgroup_id = 0;
|
|
} else {
|
|
matchgroup_id = syn_check_group(rest, (size_t)(p - rest));
|
|
if (matchgroup_id == 0) {
|
|
illegal = true;
|
|
break;
|
|
}
|
|
}
|
|
rest = skipwhite(p);
|
|
} else {
|
|
// Allocate room for a syn_pattern, and link it in the list of
|
|
// syn_patterns for this item, at the start (because the list is
|
|
// used from end to start).
|
|
ppp = xmalloc(sizeof(struct pat_ptr));
|
|
ppp->pp_next = pat_ptrs[item];
|
|
pat_ptrs[item] = ppp;
|
|
ppp->pp_synp = xcalloc(1, sizeof(synpat_T));
|
|
|
|
// Get the syntax pattern and the following offset(s).
|
|
|
|
// Enable the appropriate \z specials.
|
|
if (item == ITEM_START) {
|
|
reg_do_extmatch = REX_SET;
|
|
} else {
|
|
assert(item == ITEM_SKIP || item == ITEM_END);
|
|
reg_do_extmatch = REX_USE;
|
|
}
|
|
rest = get_syn_pattern(rest, ppp->pp_synp);
|
|
reg_do_extmatch = 0;
|
|
if (item == ITEM_END && vim_regcomp_had_eol()
|
|
&& !(syn_opt_arg.flags & HL_EXCLUDENL)) {
|
|
ppp->pp_synp->sp_flags |= HL_HAS_EOL;
|
|
}
|
|
ppp->pp_matchgroup_id = matchgroup_id;
|
|
pat_count++;
|
|
}
|
|
}
|
|
xfree(key);
|
|
if (illegal || not_enough) {
|
|
rest = NULL;
|
|
}
|
|
|
|
// Must have a "start" and "end" pattern.
|
|
if (rest != NULL && (pat_ptrs[ITEM_START] == NULL
|
|
|| pat_ptrs[ITEM_END] == NULL)) {
|
|
not_enough = true;
|
|
rest = NULL;
|
|
}
|
|
|
|
if (rest != NULL) {
|
|
// Check for trailing garbage or command.
|
|
// If OK, add the item.
|
|
eap->nextcmd = check_nextcmd(rest);
|
|
if (!ends_excmd(*rest) || eap->skip) {
|
|
rest = NULL;
|
|
} else {
|
|
ga_grow(&(curwin->w_s->b_syn_patterns), pat_count);
|
|
if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
|
|
syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
|
|
// Store the start/skip/end in the syn_items list
|
|
int 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(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(curwin->w_s)[idx].sp_flags |= syn_opt_arg.flags;
|
|
SYN_ITEMS(curwin->w_s)[idx].sp_syn.id = (int16_t)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 = (int16_t)ppp->pp_matchgroup_id;
|
|
SYN_ITEMS(curwin->w_s)[idx].sp_cchar = conceal_char;
|
|
if (item == ITEM_START) {
|
|
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;
|
|
if (syn_opt_arg.cont_in_list != NULL) {
|
|
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++;
|
|
idx++;
|
|
if (syn_opt_arg.flags & HL_FOLD) {
|
|
curwin->w_s->b_syn_folditems++;
|
|
}
|
|
}
|
|
}
|
|
|
|
redraw_curbuf_later(UPD_SOME_VALID);
|
|
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
|
|
success = true; // don't free the progs and patterns now
|
|
}
|
|
}
|
|
}
|
|
|
|
// Free the allocated memory.
|
|
for (item = ITEM_START; item <= ITEM_END; item++) {
|
|
for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp_next) {
|
|
if (!success && ppp->pp_synp != NULL) {
|
|
vim_regfree(ppp->pp_synp->sp_prog);
|
|
xfree(ppp->pp_synp->sp_pattern);
|
|
}
|
|
xfree(ppp->pp_synp);
|
|
ppp_next = ppp->pp_next;
|
|
xfree(ppp);
|
|
}
|
|
}
|
|
|
|
if (!success) {
|
|
xfree(syn_opt_arg.cont_list);
|
|
xfree(syn_opt_arg.cont_in_list);
|
|
xfree(syn_opt_arg.next_list);
|
|
if (not_enough) {
|
|
semsg(_("E399: Not enough arguments: syntax region %s"), arg);
|
|
} else if (illegal || rest == NULL) {
|
|
semsg(_(e_invarg2), arg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// A simple syntax group ID comparison function suitable for use in qsort()
|
|
static int syn_compare_stub(const void *const v1, const void *const v2)
|
|
{
|
|
const int16_t *const s1 = v1;
|
|
const int16_t *const s2 = v2;
|
|
|
|
return *s1 > *s2 ? 1 : *s1 < *s2 ? -1 : 0;
|
|
}
|
|
|
|
// Combines lists of syntax clusters.
|
|
// *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
|
|
static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, const int list_op)
|
|
{
|
|
size_t count1 = 0;
|
|
size_t count2 = 0;
|
|
const int16_t *g1;
|
|
const int16_t *g2;
|
|
int16_t *clstr = NULL;
|
|
|
|
// Handle degenerate cases.
|
|
if (*clstr2 == NULL) {
|
|
return;
|
|
}
|
|
if (*clstr1 == NULL || list_op == CLUSTER_REPLACE) {
|
|
if (list_op == CLUSTER_REPLACE) {
|
|
xfree(*clstr1);
|
|
}
|
|
if (list_op == CLUSTER_REPLACE || list_op == CLUSTER_ADD) {
|
|
*clstr1 = *clstr2;
|
|
} else {
|
|
xfree(*clstr2);
|
|
}
|
|
return;
|
|
}
|
|
|
|
for (g1 = *clstr1; *g1; g1++) {
|
|
count1++;
|
|
}
|
|
for (g2 = *clstr2; *g2; g2++) {
|
|
count2++;
|
|
}
|
|
|
|
// For speed purposes, sort both lists.
|
|
qsort(*clstr1, count1, sizeof(**clstr1), syn_compare_stub);
|
|
qsort(*clstr2, count2, sizeof(**clstr2), syn_compare_stub);
|
|
|
|
// We proceed in two passes; in round 1, we count the elements to place
|
|
// in the new list, and in round 2, we allocate and populate the new
|
|
// list. For speed, we use a mergesort-like method, adding the smaller
|
|
// of the current elements in each list to the new list.
|
|
for (int round = 1; round <= 2; round++) {
|
|
g1 = *clstr1;
|
|
g2 = *clstr2;
|
|
int count = 0;
|
|
|
|
// First, loop through the lists until one of them is empty.
|
|
while (*g1 && *g2) {
|
|
// We always want to add from the first list.
|
|
if (*g1 < *g2) {
|
|
if (round == 2) {
|
|
clstr[count] = *g1;
|
|
}
|
|
count++;
|
|
g1++;
|
|
continue;
|
|
}
|
|
// We only want to add from the second list if we're adding the
|
|
// lists.
|
|
if (list_op == CLUSTER_ADD) {
|
|
if (round == 2) {
|
|
clstr[count] = *g2;
|
|
}
|
|
count++;
|
|
}
|
|
if (*g1 == *g2) {
|
|
g1++;
|
|
}
|
|
g2++;
|
|
}
|
|
|
|
// Now add the leftovers from whichever list didn't get finished
|
|
// first. As before, we only want to add from the second list if
|
|
// we're adding the lists.
|
|
for (; *g1; g1++, count++) {
|
|
if (round == 2) {
|
|
clstr[count] = *g1;
|
|
}
|
|
}
|
|
if (list_op == CLUSTER_ADD) {
|
|
for (; *g2; g2++, count++) {
|
|
if (round == 2) {
|
|
clstr[count] = *g2;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (round == 1) {
|
|
// If the group ended up empty, we don't need to allocate any
|
|
// space for it.
|
|
if (count == 0) {
|
|
clstr = NULL;
|
|
break;
|
|
}
|
|
clstr = xmalloc(((size_t)count + 1) * sizeof(*clstr));
|
|
clstr[count] = 0;
|
|
}
|
|
}
|
|
|
|
// Finally, put the new list in place.
|
|
xfree(*clstr1);
|
|
xfree(*clstr2);
|
|
*clstr1 = clstr;
|
|
}
|
|
|
|
/// Lookup a syntax cluster name and return its ID.
|
|
/// If it is not found, 0 is returned.
|
|
static int syn_scl_name2id(char *name)
|
|
{
|
|
// Avoid using stricmp() too much, it's slow on some systems
|
|
char *name_u = vim_strsave_up(name);
|
|
int i;
|
|
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;
|
|
}
|
|
}
|
|
xfree(name_u);
|
|
return i < 0 ? 0 : i + SYNID_CLUSTER;
|
|
}
|
|
|
|
/// Like syn_scl_name2id(), but take a pointer + length argument.
|
|
static int syn_scl_namen2id(char *linep, int len)
|
|
{
|
|
char *name = xstrnsave(linep, (size_t)len);
|
|
int id = syn_scl_name2id(name);
|
|
xfree(name);
|
|
|
|
return id;
|
|
}
|
|
|
|
/// Find syntax cluster name in the table and return its ID.
|
|
/// The argument is a pointer to the name and the length of the name.
|
|
/// If it doesn't exist yet, a new entry is created.
|
|
///
|
|
/// @return 0 for failure.
|
|
static int syn_check_cluster(char *pp, int len)
|
|
{
|
|
char *name = xstrnsave(pp, (size_t)len);
|
|
int id = syn_scl_name2id(name);
|
|
if (id == 0) { // doesn't exist yet
|
|
id = syn_add_cluster(name);
|
|
} else {
|
|
xfree(name);
|
|
}
|
|
return id;
|
|
}
|
|
|
|
/// Add new syntax cluster and return its ID.
|
|
/// "name" must be an allocated string, it will be consumed.
|
|
///
|
|
/// @return 0 for failure.
|
|
static int syn_add_cluster(char *name)
|
|
{
|
|
// First call for this growarray: init growing array.
|
|
if (curwin->w_s->b_syn_clusters.ga_data == NULL) {
|
|
curwin->w_s->b_syn_clusters.ga_itemsize = sizeof(syn_cluster_T);
|
|
ga_set_growsize(&curwin->w_s->b_syn_clusters, 10);
|
|
}
|
|
|
|
int len = curwin->w_s->b_syn_clusters.ga_len;
|
|
if (len >= MAX_CLUSTER_ID) {
|
|
emsg(_("E848: Too many syntax clusters"));
|
|
xfree(name);
|
|
return 0;
|
|
}
|
|
|
|
syn_cluster_T *scp = GA_APPEND_VIA_PTR(syn_cluster_T,
|
|
&curwin->w_s->b_syn_clusters);
|
|
CLEAR_POINTER(scp);
|
|
scp->scl_name = name;
|
|
scp->scl_name_u = vim_strsave_up(name);
|
|
scp->scl_list = NULL;
|
|
|
|
if (STRICMP(name, "Spell") == 0) {
|
|
curwin->w_s->b_spell_cluster_id = len + SYNID_CLUSTER;
|
|
}
|
|
if (STRICMP(name, "NoSpell") == 0) {
|
|
curwin->w_s->b_nospell_cluster_id = len + SYNID_CLUSTER;
|
|
}
|
|
|
|
return len + SYNID_CLUSTER;
|
|
}
|
|
|
|
// Handle ":syntax cluster {cluster-name} [contains={groupname},..]
|
|
// [add={groupname},..] [remove={groupname},..]".
|
|
static void syn_cmd_cluster(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *group_name_end;
|
|
bool got_clstr = false;
|
|
int opt_len;
|
|
int list_op;
|
|
|
|
eap->nextcmd = find_nextcmd(arg);
|
|
if (eap->skip) {
|
|
return;
|
|
}
|
|
|
|
char *rest = get_group_name(arg, &group_name_end);
|
|
|
|
if (rest != NULL) {
|
|
int scl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
|
|
if (scl_id == 0) {
|
|
return;
|
|
}
|
|
scl_id -= SYNID_CLUSTER;
|
|
|
|
while (true) {
|
|
if (STRNICMP(rest, "add", 3) == 0
|
|
&& (ascii_iswhite(rest[3]) || rest[3] == '=')) {
|
|
opt_len = 3;
|
|
list_op = CLUSTER_ADD;
|
|
} else if (STRNICMP(rest, "remove", 6) == 0
|
|
&& (ascii_iswhite(rest[6]) || rest[6] == '=')) {
|
|
opt_len = 6;
|
|
list_op = CLUSTER_SUBTRACT;
|
|
} else if (STRNICMP(rest, "contains", 8) == 0
|
|
&& (ascii_iswhite(rest[8]) || rest[8] == '=')) {
|
|
opt_len = 8;
|
|
list_op = CLUSTER_REPLACE;
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
int16_t *clstr_list = NULL;
|
|
if (get_id_list(&rest, opt_len, &clstr_list, eap->skip) == FAIL) {
|
|
semsg(_(e_invarg2), rest);
|
|
break;
|
|
}
|
|
if (scl_id >= 0) {
|
|
syn_combine_list(&SYN_CLSTR(curwin->w_s)[scl_id].scl_list,
|
|
&clstr_list, list_op);
|
|
} else {
|
|
xfree(clstr_list);
|
|
}
|
|
got_clstr = true;
|
|
}
|
|
|
|
if (got_clstr) {
|
|
redraw_curbuf_later(UPD_SOME_VALID);
|
|
syn_stack_free_all(curwin->w_s); // Need to recompute all.
|
|
}
|
|
}
|
|
|
|
if (!got_clstr) {
|
|
emsg(_("E400: No cluster specified"));
|
|
}
|
|
if (rest == NULL || !ends_excmd(*rest)) {
|
|
semsg(_(e_invarg2), arg);
|
|
}
|
|
}
|
|
|
|
// On first call for current buffer: Init growing array.
|
|
static void init_syn_patterns(void)
|
|
{
|
|
curwin->w_s->b_syn_patterns.ga_itemsize = sizeof(synpat_T);
|
|
ga_set_growsize(&curwin->w_s->b_syn_patterns, 10);
|
|
}
|
|
|
|
/// Get one pattern for a ":syntax match" or ":syntax region" command.
|
|
/// Stores the pattern and program in a synpat_T.
|
|
///
|
|
/// @return a pointer to the next argument, or NULL in case of an error.
|
|
static char *get_syn_pattern(char *arg, synpat_T *ci)
|
|
{
|
|
int idx;
|
|
|
|
// need at least three chars
|
|
if (arg == NULL || arg[0] == NUL || arg[1] == NUL || arg[2] == NUL) {
|
|
return NULL;
|
|
}
|
|
|
|
char *end = skip_regexp(arg + 1, *arg, true);
|
|
if (*end != *arg) { // end delimiter not found
|
|
semsg(_("E401: Pattern delimiter not found: %s"), arg);
|
|
return NULL;
|
|
}
|
|
// store the pattern and compiled regexp program
|
|
ci->sp_pattern = xstrnsave(arg + 1, (size_t)(end - arg) - 1);
|
|
|
|
// Make 'cpoptions' empty, to avoid the 'l' flag
|
|
char *cpo_save = p_cpo;
|
|
p_cpo = empty_string_option;
|
|
ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC);
|
|
p_cpo = cpo_save;
|
|
|
|
if (ci->sp_prog == NULL) {
|
|
return NULL;
|
|
}
|
|
ci->sp_ic = curwin->w_s->b_syn_ic;
|
|
syn_clear_time(&ci->sp_time);
|
|
|
|
// Check for a match, highlight or region offset.
|
|
end++;
|
|
do {
|
|
for (idx = SPO_COUNT; --idx >= 0;) {
|
|
if (strncmp(end, spo_name_tab[idx], 3) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (idx >= 0) {
|
|
int *p = &(ci->sp_offsets[idx]);
|
|
if (idx != SPO_LC_OFF) {
|
|
switch (end[3]) {
|
|
case 's':
|
|
break;
|
|
case 'b':
|
|
break;
|
|
case 'e':
|
|
idx += SPO_COUNT; break;
|
|
default:
|
|
idx = -1; break;
|
|
}
|
|
}
|
|
if (idx >= 0) {
|
|
ci->sp_off_flags |= (int16_t)(1 << idx);
|
|
if (idx == SPO_LC_OFF) { // lc=99
|
|
end += 3;
|
|
*p = getdigits_int(&end, true, 0);
|
|
|
|
// "lc=" offset automatically sets "ms=" offset
|
|
if (!(ci->sp_off_flags & (1 << SPO_MS_OFF))) {
|
|
ci->sp_off_flags |= (1 << SPO_MS_OFF);
|
|
ci->sp_offsets[SPO_MS_OFF] = *p;
|
|
}
|
|
} else { // yy=x+99
|
|
end += 4;
|
|
if (*end == '+') {
|
|
end++;
|
|
*p = getdigits_int(&end, true, 0); // positive offset
|
|
} else if (*end == '-') {
|
|
end++;
|
|
*p = -getdigits_int(&end, true, 0); // negative offset
|
|
}
|
|
}
|
|
if (*end != ',') {
|
|
break;
|
|
}
|
|
end++;
|
|
}
|
|
}
|
|
} while (idx >= 0);
|
|
|
|
if (!ends_excmd(*end) && !ascii_iswhite(*end)) {
|
|
semsg(_("E402: Garbage after pattern: %s"), arg);
|
|
return NULL;
|
|
}
|
|
return skipwhite(end);
|
|
}
|
|
|
|
/// Handle ":syntax sync .." command.
|
|
static void syn_cmd_sync(exarg_T *eap, int syncing)
|
|
{
|
|
char *arg_start = eap->arg;
|
|
char *key = NULL;
|
|
bool illegal = false;
|
|
bool finished = false;
|
|
|
|
if (ends_excmd(*arg_start)) {
|
|
syn_cmd_list(eap, true);
|
|
return;
|
|
}
|
|
|
|
while (!ends_excmd(*arg_start)) {
|
|
char *arg_end = skiptowhite(arg_start);
|
|
char *next_arg = skipwhite(arg_end);
|
|
xfree(key);
|
|
key = vim_strnsave_up(arg_start, (size_t)(arg_end - arg_start));
|
|
if (strcmp(key, "CCOMMENT") == 0) {
|
|
if (!eap->skip) {
|
|
curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
|
|
}
|
|
if (!ends_excmd(*next_arg)) {
|
|
arg_end = skiptowhite(next_arg);
|
|
if (!eap->skip) {
|
|
curwin->w_s->b_syn_sync_id =
|
|
(int16_t)syn_check_group(next_arg, (size_t)(arg_end - next_arg));
|
|
}
|
|
next_arg = skipwhite(arg_end);
|
|
} else if (!eap->skip) {
|
|
curwin->w_s->b_syn_sync_id = (int16_t)syn_name2id("Comment");
|
|
}
|
|
} else if (strncmp(key, "LINES", 5) == 0
|
|
|| strncmp(key, "MINLINES", 8) == 0
|
|
|| strncmp(key, "MAXLINES", 8) == 0
|
|
|| strncmp(key, "LINEBREAKS", 10) == 0) {
|
|
if (key[4] == 'S') {
|
|
arg_end = key + 6;
|
|
} else if (key[0] == 'L') {
|
|
arg_end = key + 11;
|
|
} else {
|
|
arg_end = key + 9;
|
|
}
|
|
if (arg_end[-1] != '=' || !ascii_isdigit(*arg_end)) {
|
|
illegal = true;
|
|
break;
|
|
}
|
|
linenr_T n = getdigits_int32(&arg_end, false, 0);
|
|
if (!eap->skip) {
|
|
if (key[4] == 'B') {
|
|
curwin->w_s->b_syn_sync_linebreaks = n;
|
|
} else if (key[1] == 'A') {
|
|
curwin->w_s->b_syn_sync_maxlines = n;
|
|
} else {
|
|
curwin->w_s->b_syn_sync_minlines = n;
|
|
}
|
|
}
|
|
} else if (strcmp(key, "FROMSTART") == 0) {
|
|
if (!eap->skip) {
|
|
curwin->w_s->b_syn_sync_minlines = MAXLNUM;
|
|
curwin->w_s->b_syn_sync_maxlines = 0;
|
|
}
|
|
} else if (strcmp(key, "LINECONT") == 0) {
|
|
if (*next_arg == NUL) { // missing pattern
|
|
illegal = true;
|
|
break;
|
|
}
|
|
if (curwin->w_s->b_syn_linecont_pat != NULL) {
|
|
emsg(_("E403: syntax sync: line continuations pattern specified twice"));
|
|
finished = true;
|
|
break;
|
|
}
|
|
arg_end = skip_regexp(next_arg + 1, *next_arg, true);
|
|
if (*arg_end != *next_arg) { // end delimiter not found
|
|
illegal = true;
|
|
break;
|
|
}
|
|
|
|
if (!eap->skip) {
|
|
// store the pattern and compiled regexp program
|
|
curwin->w_s->b_syn_linecont_pat =
|
|
xstrnsave(next_arg + 1, (size_t)(arg_end - next_arg) - 1);
|
|
curwin->w_s->b_syn_linecont_ic = curwin->w_s->b_syn_ic;
|
|
|
|
// Make 'cpoptions' empty, to avoid the 'l' flag
|
|
char *cpo_save = p_cpo;
|
|
p_cpo = empty_string_option;
|
|
curwin->w_s->b_syn_linecont_prog =
|
|
vim_regcomp(curwin->w_s->b_syn_linecont_pat, RE_MAGIC);
|
|
p_cpo = cpo_save;
|
|
syn_clear_time(&curwin->w_s->b_syn_linecont_time);
|
|
|
|
if (curwin->w_s->b_syn_linecont_prog == NULL) {
|
|
XFREE_CLEAR(curwin->w_s->b_syn_linecont_pat);
|
|
finished = true;
|
|
break;
|
|
}
|
|
}
|
|
next_arg = skipwhite(arg_end + 1);
|
|
} else {
|
|
eap->arg = next_arg;
|
|
if (strcmp(key, "MATCH") == 0) {
|
|
syn_cmd_match(eap, true);
|
|
} else if (strcmp(key, "REGION") == 0) {
|
|
syn_cmd_region(eap, true);
|
|
} else if (strcmp(key, "CLEAR") == 0) {
|
|
syn_cmd_clear(eap, true);
|
|
} else {
|
|
illegal = true;
|
|
}
|
|
finished = true;
|
|
break;
|
|
}
|
|
arg_start = next_arg;
|
|
}
|
|
xfree(key);
|
|
if (illegal) {
|
|
semsg(_("E404: Illegal arguments: %s"), arg_start);
|
|
} else if (!finished) {
|
|
eap->nextcmd = check_nextcmd(arg_start);
|
|
redraw_curbuf_later(UPD_SOME_VALID);
|
|
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
|
|
}
|
|
}
|
|
|
|
/// Convert a line of highlight group names into a list of group ID numbers.
|
|
/// "arg" should point to the "contains" or "nextgroup" keyword.
|
|
/// "arg" is advanced to after the last group name.
|
|
/// Careful: the argument is modified (NULs added).
|
|
///
|
|
/// @param keylen length of keyword
|
|
/// @param list where to store the resulting list, if not NULL, the list is silently skipped!
|
|
///
|
|
/// @return FAIL for some error, OK for success.
|
|
static int get_id_list(char **const arg, const int keylen, int16_t **const list, const bool skip)
|
|
{
|
|
char *p = NULL;
|
|
char *end;
|
|
int total_count = 0;
|
|
int16_t *retval = NULL;
|
|
regmatch_T regmatch;
|
|
int id;
|
|
bool failed = false;
|
|
|
|
// We parse the list twice:
|
|
// round == 1: count the number of items, allocate the array.
|
|
// round == 2: fill the array with the items.
|
|
// In round 1 new groups may be added, causing the number of items to
|
|
// grow when a regexp is used. In that case round 1 is done once again.
|
|
for (int round = 1; round <= 2; round++) {
|
|
// skip "contains"
|
|
p = skipwhite(*arg + keylen);
|
|
if (*p != '=') {
|
|
semsg(_("E405: Missing equal sign: %s"), *arg);
|
|
break;
|
|
}
|
|
p = skipwhite(p + 1);
|
|
if (ends_excmd(*p)) {
|
|
semsg(_("E406: Empty argument: %s"), *arg);
|
|
break;
|
|
}
|
|
|
|
// parse the arguments after "contains"
|
|
int count = 0;
|
|
do {
|
|
for (end = p; *end && !ascii_iswhite(*end) && *end != ','; end++) {}
|
|
char *const name = xmalloc((size_t)(end - p) + 3); // leave room for "^$"
|
|
xstrlcpy(name + 1, p, (size_t)(end - p) + 1);
|
|
if (strcmp(name + 1, "ALLBUT") == 0
|
|
|| strcmp(name + 1, "ALL") == 0
|
|
|| strcmp(name + 1, "TOP") == 0
|
|
|| strcmp(name + 1, "CONTAINED") == 0) {
|
|
if (TOUPPER_ASC(**arg) != 'C') {
|
|
semsg(_("E407: %s not allowed here"), name + 1);
|
|
failed = true;
|
|
xfree(name);
|
|
break;
|
|
}
|
|
if (count != 0) {
|
|
semsg(_("E408: %s must be first in contains list"),
|
|
name + 1);
|
|
failed = true;
|
|
xfree(name);
|
|
break;
|
|
}
|
|
if (name[1] == 'A') {
|
|
id = SYNID_ALLBUT + current_syn_inc_tag;
|
|
} else if (name[1] == 'T') {
|
|
if (curwin->w_s->b_syn_topgrp >= SYNID_CLUSTER) {
|
|
id = curwin->w_s->b_syn_topgrp;
|
|
} else {
|
|
id = SYNID_TOP + current_syn_inc_tag;
|
|
}
|
|
} else {
|
|
id = SYNID_CONTAINED + current_syn_inc_tag;
|
|
}
|
|
} else if (name[1] == '@') {
|
|
if (skip) {
|
|
id = -1;
|
|
} else {
|
|
id = syn_check_cluster(name + 2, (int)(end - p - 1));
|
|
}
|
|
} else {
|
|
// Handle full group name.
|
|
if (strpbrk(name + 1, "\\.*^$~[") == NULL) {
|
|
id = syn_check_group((name + 1), (size_t)(end - p));
|
|
} else {
|
|
// Handle match of regexp with group names.
|
|
*name = '^';
|
|
STRCAT(name, "$");
|
|
regmatch.regprog = vim_regcomp(name, RE_MAGIC);
|
|
if (regmatch.regprog == NULL) {
|
|
failed = true;
|
|
xfree(name);
|
|
break;
|
|
}
|
|
|
|
regmatch.rm_ic = true;
|
|
id = 0;
|
|
for (int i = highlight_num_groups(); --i >= 0;) {
|
|
if (vim_regexec(®match, highlight_group_name(i), 0)) {
|
|
if (round == 2) {
|
|
// Got more items than expected; can happen
|
|
// when adding items that match:
|
|
// "contains=a.*b,axb".
|
|
// Go back to first round.
|
|
if (count >= total_count) {
|
|
xfree(retval);
|
|
round = 1;
|
|
} else {
|
|
retval[count] = (int16_t)(i + 1);
|
|
}
|
|
}
|
|
count++;
|
|
id = -1; // Remember that we found one.
|
|
}
|
|
}
|
|
vim_regfree(regmatch.regprog);
|
|
}
|
|
}
|
|
xfree(name);
|
|
if (id == 0) {
|
|
semsg(_("E409: Unknown group name: %s"), p);
|
|
failed = true;
|
|
break;
|
|
}
|
|
if (id > 0) {
|
|
if (round == 2) {
|
|
// Got more items than expected, go back to first round.
|
|
if (count >= total_count) {
|
|
xfree(retval);
|
|
round = 1;
|
|
} else {
|
|
retval[count] = (int16_t)id;
|
|
}
|
|
}
|
|
count++;
|
|
}
|
|
p = skipwhite(end);
|
|
if (*p != ',') {
|
|
break;
|
|
}
|
|
p = skipwhite(p + 1); // skip comma in between arguments
|
|
} while (!ends_excmd(*p));
|
|
if (failed) {
|
|
break;
|
|
}
|
|
if (round == 1) {
|
|
retval = xmalloc(((size_t)count + 1) * sizeof(*retval));
|
|
retval[count] = 0; // zero means end of the list
|
|
total_count = count;
|
|
}
|
|
}
|
|
|
|
*arg = p;
|
|
if (failed || retval == NULL) {
|
|
xfree(retval);
|
|
return FAIL;
|
|
}
|
|
|
|
if (*list == NULL) {
|
|
*list = retval;
|
|
} else {
|
|
xfree(retval); // list already found, don't overwrite it
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
// Make a copy of an ID list.
|
|
static int16_t *copy_id_list(const int16_t *const list)
|
|
{
|
|
if (list == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
int count;
|
|
for (count = 0; list[count]; count++) {}
|
|
const size_t len = ((size_t)count + 1) * sizeof(int16_t);
|
|
int16_t *const retval = xmalloc(len);
|
|
memmove(retval, list, len);
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Check if syntax group "ssp" is in the ID list "list" of "cur_si".
|
|
/// "cur_si" can be NULL if not checking the "containedin" list.
|
|
/// Used to check if a syntax item is in the "contains" or "nextgroup" list of
|
|
/// the current item.
|
|
/// This function is called very often, keep it fast!!
|
|
///
|
|
/// @param cur_si current item or NULL
|
|
/// @param list id list
|
|
/// @param ssp group id and ":syn include" tag of group
|
|
/// @param contained group id is contained
|
|
static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, int contained)
|
|
{
|
|
int retval;
|
|
int16_t id = ssp->id;
|
|
static int depth = 0;
|
|
|
|
// If ssp has a "containedin" list and "cur_si" is in it, return true.
|
|
if (cur_si != NULL && ssp->cont_in_list != NULL
|
|
&& !(cur_si->si_flags & HL_MATCH)) {
|
|
// Ignore transparent items without a contains argument. Double check
|
|
// that we don't go back past the first one.
|
|
while ((cur_si->si_flags & HL_TRANS_CONT)
|
|
&& cur_si > (stateitem_T *)(current_state.ga_data)) {
|
|
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_block)[cur_si->si_idx].sp_syn),
|
|
SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags &
|
|
HL_CONTAINED)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (list == NULL) {
|
|
return false;
|
|
}
|
|
|
|
// If list is ID_LIST_ALL, we are in a transparent item that isn't
|
|
// inside anything. Only allow not-contained groups.
|
|
if (list == ID_LIST_ALL) {
|
|
return !contained;
|
|
}
|
|
|
|
// If the first item is "ALLBUT", return true if "id" is NOT in the
|
|
// contains list. We also require that "id" is at the same ":syn include"
|
|
// level as the list.
|
|
int16_t item = *list;
|
|
if (item >= SYNID_ALLBUT && item < SYNID_CLUSTER) {
|
|
if (item < SYNID_TOP) {
|
|
// ALL or ALLBUT: accept all groups in the same file
|
|
if (item - SYNID_ALLBUT != ssp->inc_tag) {
|
|
return false;
|
|
}
|
|
} else if (item < SYNID_CONTAINED) {
|
|
// TOP: accept all not-contained groups in the same file
|
|
if (item - SYNID_TOP != ssp->inc_tag || contained) {
|
|
return false;
|
|
}
|
|
} else {
|
|
// CONTAINED: accept all contained groups in the same file
|
|
if (item - SYNID_CONTAINED != ssp->inc_tag || !contained) {
|
|
return false;
|
|
}
|
|
}
|
|
item = *++list;
|
|
retval = false;
|
|
} else {
|
|
retval = true;
|
|
}
|
|
|
|
// Return "retval" if id is in the contains list.
|
|
while (item != 0) {
|
|
if (item == id) {
|
|
return retval;
|
|
}
|
|
if (item >= SYNID_CLUSTER) {
|
|
int16_t *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) {
|
|
depth++;
|
|
int r = in_id_list(NULL, scl_list, ssp, contained);
|
|
depth--;
|
|
if (r) {
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
item = *++list;
|
|
}
|
|
return !retval;
|
|
}
|
|
|
|
struct subcommand {
|
|
char *name; // subcommand name
|
|
void (*func)(exarg_T *, int); // function to call
|
|
};
|
|
|
|
static struct subcommand subcommands[] = {
|
|
{ "case", syn_cmd_case },
|
|
{ "clear", syn_cmd_clear },
|
|
{ "cluster", syn_cmd_cluster },
|
|
{ "conceal", syn_cmd_conceal },
|
|
{ "enable", syn_cmd_on },
|
|
{ "foldlevel", syn_cmd_foldlevel },
|
|
{ "include", syn_cmd_include },
|
|
{ "iskeyword", syn_cmd_iskeyword },
|
|
{ "keyword", syn_cmd_keyword },
|
|
{ "list", syn_cmd_list },
|
|
{ "manual", syn_cmd_manual },
|
|
{ "match", syn_cmd_match },
|
|
{ "on", syn_cmd_on },
|
|
{ "off", syn_cmd_off },
|
|
{ "region", syn_cmd_region },
|
|
{ "reset", syn_cmd_reset },
|
|
{ "spell", syn_cmd_spell },
|
|
{ "sync", syn_cmd_sync },
|
|
{ "", syn_cmd_list },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
/// ":syntax".
|
|
/// This searches the subcommands[] table for the subcommand name, and calls a
|
|
/// syntax_subcommand() function to do the rest.
|
|
void ex_syntax(exarg_T *eap)
|
|
{
|
|
char *arg = eap->arg;
|
|
char *subcmd_end;
|
|
|
|
syn_cmdlinep = eap->cmdlinep;
|
|
|
|
// isolate subcommand name
|
|
for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); subcmd_end++) {}
|
|
char *const subcmd_name = xstrnsave(arg, (size_t)(subcmd_end - arg));
|
|
if (eap->skip) { // skip error messages for all subcommands
|
|
emsg_skip++;
|
|
}
|
|
for (int i = 0;; i++) {
|
|
if (subcommands[i].name == NULL) {
|
|
semsg(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
|
|
break;
|
|
}
|
|
if (strcmp(subcmd_name, subcommands[i].name) == 0) {
|
|
eap->arg = skipwhite(subcmd_end);
|
|
(subcommands[i].func)(eap, false);
|
|
break;
|
|
}
|
|
}
|
|
xfree(subcmd_name);
|
|
if (eap->skip) {
|
|
emsg_skip--;
|
|
}
|
|
}
|
|
|
|
void ex_ownsyntax(exarg_T *eap)
|
|
{
|
|
if (curwin->w_s == &curwin->w_buffer->b_s) {
|
|
curwin->w_s = xcalloc(1, sizeof(synblock_T));
|
|
hash_init(&curwin->w_s->b_keywtab);
|
|
hash_init(&curwin->w_s->b_keywtab_ic);
|
|
// TODO(vim): Keep the spell checking as it was.
|
|
curwin->w_p_spell = false; // No spell checking
|
|
// make sure option values are "empty_string_option" instead of NULL
|
|
clear_string_option(&curwin->w_s->b_p_spc);
|
|
clear_string_option(&curwin->w_s->b_p_spf);
|
|
clear_string_option(&curwin->w_s->b_p_spl);
|
|
clear_string_option(&curwin->w_s->b_p_spo);
|
|
clear_string_option(&curwin->w_s->b_syn_isk);
|
|
}
|
|
|
|
// Save value of b:current_syntax.
|
|
char *old_value = get_var_value("b:current_syntax");
|
|
if (old_value != NULL) {
|
|
old_value = xstrdup(old_value);
|
|
}
|
|
|
|
// Apply the "syntax" autocommand event, this finds and loads the syntax file.
|
|
apply_autocmds(EVENT_SYNTAX, eap->arg, curbuf->b_fname, true, curbuf);
|
|
|
|
// Move value of b:current_syntax to w:current_syntax.
|
|
char *new_value = get_var_value("b:current_syntax");
|
|
if (new_value != NULL) {
|
|
set_internal_string_var("w:current_syntax", new_value);
|
|
}
|
|
|
|
// Restore value of b:current_syntax.
|
|
if (old_value == NULL) {
|
|
do_unlet(S_LEN("b:current_syntax"), true);
|
|
} else {
|
|
set_internal_string_var("b:current_syntax", old_value);
|
|
xfree(old_value);
|
|
}
|
|
}
|
|
|
|
bool syntax_present(win_T *win)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static enum {
|
|
EXP_SUBCMD, // expand ":syn" sub-commands
|
|
EXP_CASE, // expand ":syn case" arguments
|
|
EXP_SPELL, // expand ":syn spell" arguments
|
|
EXP_SYNC, // expand ":syn sync" arguments
|
|
EXP_CLUSTER, // expand ":syn list @cluster" arguments
|
|
} expand_what;
|
|
|
|
// Reset include_link, include_default, include_none to 0.
|
|
// Called when we are done expanding.
|
|
void reset_expand_highlight(void)
|
|
{
|
|
include_link = include_default = include_none = 0;
|
|
}
|
|
|
|
// Handle command line completion for :match and :echohl command: Add "None"
|
|
// as highlight group.
|
|
void set_context_in_echohl_cmd(expand_T *xp, const char *arg)
|
|
{
|
|
xp->xp_context = EXPAND_HIGHLIGHT;
|
|
xp->xp_pattern = (char *)arg;
|
|
include_none = 1;
|
|
}
|
|
|
|
// Handle command line completion for :syntax command.
|
|
void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
|
|
{
|
|
// Default: expand subcommands.
|
|
xp->xp_context = EXPAND_SYNTAX;
|
|
expand_what = EXP_SUBCMD;
|
|
xp->xp_pattern = (char *)arg;
|
|
include_link = 0;
|
|
include_default = 0;
|
|
|
|
if (*arg == NUL) {
|
|
return;
|
|
}
|
|
|
|
// (part of) subcommand already typed
|
|
const char *p = skiptowhite(arg);
|
|
if (*p == NUL) {
|
|
return;
|
|
}
|
|
|
|
// past first world
|
|
xp->xp_pattern = skipwhite(p);
|
|
if (*skiptowhite(xp->xp_pattern) != NUL) {
|
|
xp->xp_context = EXPAND_NOTHING;
|
|
} else if (STRNICMP(arg, "case", p - arg) == 0) {
|
|
expand_what = EXP_CASE;
|
|
} else if (STRNICMP(arg, "spell", p - arg) == 0) {
|
|
expand_what = EXP_SPELL;
|
|
} else if (STRNICMP(arg, "sync", p - arg) == 0) {
|
|
expand_what = EXP_SYNC;
|
|
} else if (STRNICMP(arg, "list", p - arg) == 0) {
|
|
p = skipwhite(p);
|
|
if (*p == '@') {
|
|
expand_what = EXP_CLUSTER;
|
|
} else {
|
|
xp->xp_context = EXPAND_HIGHLIGHT;
|
|
}
|
|
} else if (STRNICMP(arg, "keyword", p - arg) == 0
|
|
|| STRNICMP(arg, "region", p - arg) == 0
|
|
|| STRNICMP(arg, "match", p - arg) == 0) {
|
|
xp->xp_context = EXPAND_HIGHLIGHT;
|
|
} else {
|
|
xp->xp_context = EXPAND_NOTHING;
|
|
}
|
|
}
|
|
|
|
// Function given to ExpandGeneric() to obtain the list syntax names for
|
|
// expansion.
|
|
char *get_syntax_name(expand_T *xp, int idx)
|
|
{
|
|
switch (expand_what) {
|
|
case EXP_SUBCMD:
|
|
return subcommands[idx].name;
|
|
case EXP_CASE: {
|
|
static char *case_args[] = { "match", "ignore", NULL };
|
|
return case_args[idx];
|
|
}
|
|
case EXP_SPELL: {
|
|
static char *spell_args[] =
|
|
{ "toplevel", "notoplevel", "default", NULL };
|
|
return spell_args[idx];
|
|
}
|
|
case EXP_SYNC: {
|
|
static char *sync_args[] =
|
|
{ "ccomment", "clear", "fromstart",
|
|
"linebreaks=", "linecont", "lines=", "match",
|
|
"maxlines=", "minlines=", "region", NULL };
|
|
return sync_args[idx];
|
|
}
|
|
case EXP_CLUSTER:
|
|
if (idx < curwin->w_s->b_syn_clusters.ga_len) {
|
|
vim_snprintf(xp->xp_buf, EXPAND_BUF_LEN, "@%s",
|
|
SYN_CLSTR(curwin->w_s)[idx].scl_name);
|
|
return xp->xp_buf;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/// Function called for expression evaluation: get syntax ID at file position.
|
|
///
|
|
/// @param trans remove transparency
|
|
/// @param spellp return: can do spell checking
|
|
/// @param keep_state keep state of char at "col"
|
|
int syn_get_id(win_T *wp, linenr_T lnum, colnr_T col, int trans, bool *spellp, int keep_state)
|
|
{
|
|
// When the position is not after the current position and in the same
|
|
// line of the same window with the same buffer, need to restart parsing.
|
|
if (wp != syn_win || wp->w_buffer != syn_buf || lnum != current_lnum || col < current_col) {
|
|
syntax_start(wp, lnum);
|
|
} else if (col > current_col) {
|
|
// next_match may not be correct when moving around, e.g. with the
|
|
// "skip" expression in searchpair()
|
|
next_match_idx = -1;
|
|
}
|
|
|
|
get_syntax_attr(col, spellp, keep_state);
|
|
|
|
return trans ? current_trans_id : current_id;
|
|
}
|
|
|
|
// Get extra information about the syntax item. Must be called right after
|
|
// get_syntax_attr().
|
|
// Stores the current item sequence nr in "*seqnrp".
|
|
// Returns the current flags.
|
|
int get_syntax_info(int *seqnrp)
|
|
{
|
|
*seqnrp = current_seqnr;
|
|
return current_flags;
|
|
}
|
|
|
|
/// Get the sequence number of the concealed file position.
|
|
///
|
|
/// @return seqnr if the file position is concealed, 0 otherwise.
|
|
int syn_get_concealed_id(win_T *wp, linenr_T lnum, colnr_T col)
|
|
{
|
|
int seqnr;
|
|
|
|
syn_get_id(wp, lnum, col, false, NULL, false);
|
|
int syntax_flags = get_syntax_info(&seqnr);
|
|
|
|
if (syntax_flags & HL_CONCEAL) {
|
|
return seqnr;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Return conceal substitution character
|
|
int syn_get_sub_char(void)
|
|
{
|
|
return current_sub_char;
|
|
}
|
|
|
|
// Return the syntax ID at position "i" in the current stack.
|
|
// The caller must have called syn_get_id() before to fill the stack.
|
|
// Returns -1 when "i" is out of range.
|
|
int syn_get_stack_item(int i)
|
|
{
|
|
if (i >= current_state.ga_len) {
|
|
// Need to invalidate the state, because we didn't properly finish it
|
|
// for the last character, "keep_state" was true.
|
|
invalidate_current_state();
|
|
current_col = MAXCOL;
|
|
return -1;
|
|
}
|
|
return CUR_STATE(i).si_id;
|
|
}
|
|
|
|
static int syn_cur_foldlevel(void)
|
|
{
|
|
int level = 0;
|
|
for (int i = 0; i < current_state.ga_len; i++) {
|
|
if (CUR_STATE(i).si_flags & HL_FOLD) {
|
|
level++;
|
|
}
|
|
}
|
|
return level;
|
|
}
|
|
|
|
/// Function called to get folding level for line "lnum" in window "wp".
|
|
int syn_get_foldlevel(win_T *wp, linenr_T lnum)
|
|
{
|
|
int level = 0;
|
|
|
|
// Return quickly when there are no fold items at all.
|
|
if (wp->w_s->b_syn_folditems != 0
|
|
&& !wp->w_s->b_syn_error
|
|
&& !wp->w_s->b_syn_slow) {
|
|
syntax_start(wp, lnum);
|
|
|
|
// Start with the fold level at the start of the line.
|
|
level = syn_cur_foldlevel();
|
|
|
|
if (wp->w_s->b_syn_foldlevel == SYNFLD_MINIMUM) {
|
|
// Find the lowest fold level that is followed by a higher one.
|
|
int cur_level = level;
|
|
int low_level = cur_level;
|
|
while (!current_finished) {
|
|
syn_current_attr(false, false, NULL, false);
|
|
cur_level = syn_cur_foldlevel();
|
|
if (cur_level < low_level) {
|
|
low_level = cur_level;
|
|
} else if (cur_level > low_level) {
|
|
level = low_level;
|
|
}
|
|
current_col++;
|
|
}
|
|
}
|
|
}
|
|
if (level > wp->w_p_fdn) {
|
|
level = (int)wp->w_p_fdn;
|
|
if (level < 0) {
|
|
level = 0;
|
|
}
|
|
}
|
|
return level;
|
|
}
|
|
|
|
// ":syntime".
|
|
void ex_syntime(exarg_T *eap)
|
|
{
|
|
if (strcmp(eap->arg, "on") == 0) {
|
|
syn_time_on = true;
|
|
} else if (strcmp(eap->arg, "off") == 0) {
|
|
syn_time_on = false;
|
|
} else if (strcmp(eap->arg, "clear") == 0) {
|
|
syntime_clear();
|
|
} else if (strcmp(eap->arg, "report") == 0) {
|
|
syntime_report();
|
|
} else {
|
|
semsg(_(e_invarg2), eap->arg);
|
|
}
|
|
}
|
|
|
|
static void syn_clear_time(syn_time_T *st)
|
|
{
|
|
st->total = profile_zero();
|
|
st->slowest = profile_zero();
|
|
st->count = 0;
|
|
st->match = 0;
|
|
}
|
|
|
|
// Clear the syntax timing for the current buffer.
|
|
static void syntime_clear(void)
|
|
{
|
|
synpat_T *spp;
|
|
|
|
if (!syntax_present(curwin)) {
|
|
msg(_(msg_no_items), 0);
|
|
return;
|
|
}
|
|
for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; idx++) {
|
|
spp = &(SYN_ITEMS(curwin->w_s)[idx]);
|
|
syn_clear_time(&spp->sp_time);
|
|
}
|
|
}
|
|
|
|
// Function given to ExpandGeneric() to obtain the possible arguments of the
|
|
// ":syntime {on,off,clear,report}" command.
|
|
char *get_syntime_arg(expand_T *xp, int idx)
|
|
{
|
|
switch (idx) {
|
|
case 0:
|
|
return "on";
|
|
case 1:
|
|
return "off";
|
|
case 2:
|
|
return "clear";
|
|
case 3:
|
|
return "report";
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int syn_compare_syntime(const void *v1, const void *v2)
|
|
{
|
|
const time_entry_T *s1 = v1;
|
|
const time_entry_T *s2 = v2;
|
|
|
|
return profile_cmp(s1->total, s2->total);
|
|
}
|
|
|
|
// Clear the syntax timing for the current buffer.
|
|
static void syntime_report(void)
|
|
{
|
|
if (!syntax_present(curwin)) {
|
|
msg(_(msg_no_items), 0);
|
|
return;
|
|
}
|
|
|
|
garray_T ga;
|
|
ga_init(&ga, sizeof(time_entry_T), 50);
|
|
|
|
proftime_T total_total = profile_zero();
|
|
int total_count = 0;
|
|
time_entry_T *p;
|
|
for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; idx++) {
|
|
synpat_T *spp = &(SYN_ITEMS(curwin->w_s)[idx]);
|
|
if (spp->sp_time.count > 0) {
|
|
p = GA_APPEND_VIA_PTR(time_entry_T, &ga);
|
|
p->total = spp->sp_time.total;
|
|
total_total = profile_add(total_total, spp->sp_time.total);
|
|
p->count = spp->sp_time.count;
|
|
p->match = spp->sp_time.match;
|
|
total_count += spp->sp_time.count;
|
|
p->slowest = spp->sp_time.slowest;
|
|
proftime_T tm = profile_divide(spp->sp_time.total, spp->sp_time.count);
|
|
p->average = tm;
|
|
p->id = spp->sp_syn.id;
|
|
p->pattern = spp->sp_pattern;
|
|
}
|
|
}
|
|
|
|
// Sort on total time. Skip if there are no items to avoid passing NULL
|
|
// pointer to qsort().
|
|
if (ga.ga_len > 1) {
|
|
qsort(ga.ga_data, (size_t)ga.ga_len, sizeof(time_entry_T),
|
|
syn_compare_syntime);
|
|
}
|
|
|
|
msg_puts_title(_(" TOTAL COUNT MATCH SLOWEST AVERAGE NAME PATTERN"));
|
|
msg_puts("\n");
|
|
for (int idx = 0; idx < ga.ga_len && !got_int; idx++) {
|
|
p = ((time_entry_T *)ga.ga_data) + idx;
|
|
|
|
msg_puts(profile_msg(p->total));
|
|
msg_puts(" "); // make sure there is always a separating space
|
|
msg_advance(13);
|
|
msg_outnum(p->count);
|
|
msg_puts(" ");
|
|
msg_advance(20);
|
|
msg_outnum(p->match);
|
|
msg_puts(" ");
|
|
msg_advance(26);
|
|
msg_puts(profile_msg(p->slowest));
|
|
msg_puts(" ");
|
|
msg_advance(38);
|
|
msg_puts(profile_msg(p->average));
|
|
msg_puts(" ");
|
|
msg_advance(50);
|
|
msg_outtrans(highlight_group_name(p->id - 1), 0);
|
|
msg_puts(" ");
|
|
|
|
msg_advance(69);
|
|
int len;
|
|
if (Columns < 80) {
|
|
len = 20; // will wrap anyway
|
|
} else {
|
|
len = Columns - 70;
|
|
}
|
|
if (len > (int)strlen(p->pattern)) {
|
|
len = (int)strlen(p->pattern);
|
|
}
|
|
msg_outtrans_len(p->pattern, len, 0);
|
|
msg_puts("\n");
|
|
}
|
|
ga_clear(&ga);
|
|
if (!got_int) {
|
|
msg_puts("\n");
|
|
msg_puts(profile_msg(total_total));
|
|
msg_advance(13);
|
|
msg_outnum(total_count);
|
|
msg_puts("\n");
|
|
}
|
|
}
|