neovim

syntax.c (182289B)

---

// 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/errors.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_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;

#include "syntax.c.generated.h"

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(&current_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(&current_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(&current_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(&current_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 *l = ml_get(start_lnum - 1);
     if (*l == NUL || *(l + ml_get_len(start_lnum - 1) - 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(&current_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(&regmatch, 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(&current_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(&current_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(&current_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(&current_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(&current_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)))) {
             // 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(&regmatch, 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, &regmatch,
                               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, &regmatch,
                               spp, SPO_HS_OFF, -1);

             // Compute the region start.
             // Default is to use the end of the match.
             syn_add_end_off(&eos_pos, &regmatch,
                             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, &regmatch, spp,
                               SPO_HE_OFF, 0);
               syn_add_end_off(&endpos, &regmatch, 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(&current_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(&current_state)) {
       break;
     }

     if (had_extend && keepend_level >= 0) {
       syn_update_ends(false);
       if (GA_EMPTY(&current_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 = syn_getcurline_len();
   } 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, &current_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(&current_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;
 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(&regmatch, 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(&regmatch, 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, &regmatch, 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;
       }

       int line_len = ml_get_buf_len(syn_buf, startpos->lnum);

       // 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 = ml_get_buf_len(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);
}

/// Get length of current line in syntax buffer.
static colnr_T syn_getcurline_len(void)
{
 return ml_get_buf_len(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
 xmemcpyz(keyword, kwp, (size_t)kwlen);

 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))) {
       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, false);
   } else {
     msg_outtrans(_("syntax iskeyword not set"), 0, false);
   }
 } 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;
 }

 msg_ext_set_kind("list_cmd");
 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 keyvalue_T namelist1[] = {
   KEYVALUE_ENTRY(HL_DISPLAY, "display"),
   KEYVALUE_ENTRY(HL_CONTAINED, "contained"),
   KEYVALUE_ENTRY(HL_ONELINE, "oneline"),
   KEYVALUE_ENTRY(HL_KEEPEND, "keepend"),
   KEYVALUE_ENTRY(HL_EXTEND, "extend"),
   KEYVALUE_ENTRY(HL_EXCLUDENL, "excludenl"),
   KEYVALUE_ENTRY(HL_TRANSP, "transparent"),
   KEYVALUE_ENTRY(HL_FOLD, "fold"),
   KEYVALUE_ENTRY(HL_CONCEAL, "conceal"),
   KEYVALUE_ENTRY(HL_CONCEALENDS, "concealends"),
 };
 static keyvalue_T namelist2[] = {
   KEYVALUE_ENTRY(HL_SKIPWHITE, "skipwhite"),
   KEYVALUE_ENTRY(HL_SKIPNL, "skipnl"),
   KEYVALUE_ENTRY(HL_SKIPEMPTY, "skipempty"),
 };

 const int hl_id = HLF_D;      // highlight like directories

 // list the keywords for "id"
 if (!syncing) {
   did_header = syn_list_keywords(id, &curwin->w_s->b_keywtab, false, hl_id);
   did_header = syn_list_keywords(id, &curwin->w_s->b_keywtab_ic, did_header, hl_id);
 }

 // 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, hl_id);
     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++], hl_id);
     }
     if (SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_SKIP) {
       put_pattern("skip", '=', &SYN_ITEMS(curwin->w_s)[idx++], hl_id);
     }
     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++], hl_id);
     }
     idx--;
     msg_putchar(' ');
   }
   syn_list_flags(namelist1, ARRAY_SIZE(namelist1), spp->sp_flags, hl_id);

   if (spp->sp_cont_list != NULL) {
     put_id_list("contains", spp->sp_cont_list, hl_id);
   }

   if (spp->sp_syn.cont_in_list != NULL) {
     put_id_list("containedin", spp->sp_syn.cont_in_list, hl_id);
   }

   if (spp->sp_next_list != NULL) {
     put_id_list("nextgroup", spp->sp_next_list, hl_id);
     syn_list_flags(namelist2, ARRAY_SIZE(namelist2), spp->sp_flags, hl_id);
   }
   if (spp->sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE)) {
     if (spp->sp_flags & HL_SYNC_HERE) {
       msg_puts_hl("grouphere", hl_id, false);
     } else {
       msg_puts_hl("groupthere", hl_id, false);
     }
     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, false);
     } 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_hl("links to", hl_id, false);
   msg_putchar(' ');
   msg_outtrans(highlight_group_name(highlight_link_id(id - 1) - 1), 0, false);
 }
}

static void syn_list_flags(keyvalue_T *nlist, size_t nr_entries, int flags, int hl_id)
{
 for (size_t i = 0; i < nr_entries; i++) {
   if (flags & nlist[i].key) {
     msg_puts_hl(nlist[i].value, hl_id, false);
     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, false);

 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, HLF_D);
 } else {
   msg_puts_hl("cluster", HLF_D, false);
   msg_puts("=NONE");
 }
}

static void put_id_list(const char *const name, const int16_t *const list, const int hl_id)
{
 msg_puts_hl(name, hl_id, false);
 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, false);
   } else {
     msg_outtrans(highlight_group_name(*p - 1), 0, false);
   }
   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 hl_id)
{
 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_hl("matchgroup", hl_id, false);
   msg_putchar('=');
   if (last_matchgroup == 0) {
     msg_outtrans("NONE", 0, false);
   } else {
     msg_outtrans(highlight_group_name(last_matchgroup - 1), 0, false);
   }
   msg_putchar(' ');
 }

 // Output the name of the pattern and an '=' or ' '.
 msg_puts_hl(s, hl_id, false);
 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, false);
 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 hl_id)
{
 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_hl("contained", hl_id, false);
         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, hl_id);
         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, hl_id);
         msg_putchar(' ');
         prev_next_list = kp->next_list;
         if (kp->flags & HL_SKIPNL) {
           msg_puts_hl("skipnl", hl_id, false);
           msg_putchar(' ');
           prev_skipnl = (kp->flags & HL_SKIPNL);
         }
         if (kp->flags & HL_SKIPWHITE) {
           msg_puts_hl("skipwhite", hl_id, false);
           msg_putchar(' ');
           prev_skipwhite = (kp->flags & HL_SKIPWHITE);
         }
         if (kp->flags & HL_SKIPEMPTY) {
           msg_puts_hl("skipempty", hl_id, false);
           msg_putchar(' ');
           prev_skipempty = (kp->flags & HL_SKIPEMPTY);
         }
       }
       msg_outtrans(kp->keyword, 0, false);
     }
   }
 }

 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, size_t namelen, 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 *name_ic;
 size_t name_iclen;
 if (curwin->w_s->b_syn_ic) {
   name_ic = str_foldcase(name, (int)namelen, name_folded, MAXKEYWLEN + 1);
   name_iclen = strlen(name_ic);
 } else {
   name_ic = name;
   name_iclen = namelen;
 }

 keyentry_T *const kp = xmalloc(offsetof(keyentry_T, keyword) + name_iclen + 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 | HL_INCLUDED_TOPLEVEL;
 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.
       size_t kwlen = 0;
       for (char *kw = keyword_copy; --cnt >= 0; kw += kwlen + 1) {
         for (p = vim_strchr(kw, '[');;) {
           if (p == NULL) {
             kwlen = strlen(kw);
           } else {
             *p = NUL;
             kwlen = (size_t)(p - kw);
           }
           add_keyword(kw, kwlen, 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;
             kwlen = 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 "^$"
     xmemcpyz(name + 1, p, (size_t)(end - p));
     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;
       } else if (name[1] == 'T') {
         id = SYNID_TOP;
       } else {
         id = SYNID_CONTAINED;
       }
       id += 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(&regmatch, 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 flags      group flags
static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, int flags)
{
 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)) {
     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 !(flags & HL_CONTAINED);
 }

 // Is this top-level (i.e. not 'contained') in the file it was declared in?
 // For included files, this is different from HL_CONTAINED, which is set
 // unconditionally.
 bool toplevel = !(flags & HL_CONTAINED) || (flags & HL_INCLUDED_TOPLEVEL);

 // 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 || !toplevel) {
       return false;
     }
   } else {
     // CONTAINED: accept all contained groups in the same file
     if (item - SYNID_CONTAINED != ssp->inc_tag || toplevel) {
       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, flags);
       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 },
};

/// ":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++;
 }
 size_t i;
 for (i = 0; i < ARRAY_SIZE(subcommands); i++) {
   if (strcmp(subcmd_name, subcommands[i].name) == 0) {
     eap->arg = skipwhite(subcmd_end);
     (subcommands[i].func)(eap, false);
     break;
   }
 }

 if (i == ARRAY_SIZE(subcommands)) {
   semsg(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
 }

 xfree(subcmd_name);
 if (eap->skip) {
   emsg_skip--;
 }
}

/// @deprecated
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:
   if (idx < 0 || idx >= (int)ARRAY_SIZE(subcommands)) {
     return NULL;
   }
   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, false);
   msg_puts(" ");

   msg_advance(69);
   int len;
   if (Columns < 80) {
     len = 20;       // will wrap anyway
   } else {
     len = Columns - 70;
   }
   int patlen = (int)strlen(p->pattern);
   len = MIN(len, patlen);
   msg_outtrans_len(p->pattern, len, 0, false);
   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");
 }
}