text: // This is an open source non-commercial project. Dear PVS-Studio, please check
  // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
  
  /*
   * syntax.c: code for syntax highlighting
   */
  
  #include <assert.h>
  #include <ctype.h>
  #include <inttypes.h>
  #include <stdbool.h>
  #include <stdlib.h>
  #include <string.h>
  
  #include "nvim/api/private/helpers.h"
  #include "nvim/ascii.h"
  #include "nvim/buffer.h"
  #include "nvim/charset.h"
  #include "nvim/cursor_shape.h"
  #include "nvim/eval.h"
  #include "nvim/ex_cmds2.h"
  #include "nvim/ex_docmd.h"
  #include "nvim/fileio.h"
  #include "nvim/fold.h"
  #include "nvim/garray.h"
  #include "nvim/hashtab.h"
  #include "nvim/highlight.h"
  #include "nvim/highlight_group.h"
  #include "nvim/indent_c.h"
  #include "nvim/keymap.h"
  #include "nvim/lua/executor.h"
  #include "nvim/macros.h"
  #include "nvim/mbyte.h"
  #include "nvim/memline.h"
  #include "nvim/memory.h"
  #include "nvim/message.h"
  #include "nvim/option.h"
  #include "nvim/os/input.h"
  #include "nvim/os/os.h"
  #include "nvim/os/time.h"
  #include "nvim/os_unix.h"
  #include "nvim/path.h"
  #include "nvim/regexp.h"
  #include "nvim/screen.h"
  #include "nvim/sign.h"
  #include "nvim/strings.h"
  #include "nvim/syntax.h"
  #include "nvim/syntax_defs.h"
  #include "nvim/terminal.h"
  #include "nvim/ui.h"
  #include "nvim/vim.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 char e_illegal_arg[] = N_("E390: Illegal argument: %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 syn_pattern {
    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_u *sp_pattern;                   // regexp to match, pattern
    regprog_T *sp_prog;                   // regexp to match, program
    syn_time_T sp_time;
  } synpat_T;
  
  
  typedef struct syn_cluster_S {
    char_u *scl_name;         // syntax cluster name
    char_u *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 state_item {
    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
    long 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_u *pattern;
  } time_entry_T;
  
  struct name_list {
    int flag;
    char *name;
  };
  
  #ifdef INCLUDE_GENERATED_DECLARATIONS
  # include "syntax.c.generated.h"
  #endif
  
  static char *(spo_name_tab[SPO_COUNT]) =
  { "ms=", "me=", "hs=", "he=", "rs=", "re=", "lc=" };
  
  // The sp_off_flags are computed like this:
  // offset from the start of the matched text: (1 << SPO_XX_OFF)
  // offset from the end   of the matched text: (1 << (SPO_XX_OFF + SPO_COUNT))
  // When both are present, only one is used.
  
  #define SPTYPE_MATCH    1       // match keyword with this group ID
  #define SPTYPE_START    2       // match a regexp, start of item
  #define SPTYPE_END      3       // match a regexp, end of item
  #define SPTYPE_SKIP     4       // match a regexp, skip within item
  
  
  #define SYN_ITEMS(buf)  ((synpat_T *)((buf)->b_syn_patterns.ga_data))
  
  #define NONE_IDX        (-2)    // value of sp_sync_idx for "NONE"
  
  /*
   * Flags for b_syn_sync_flags:
   */
  #define SF_CCOMMENT     0x01    // sync on a C-style comment
  #define SF_MATCH        0x02    // sync by matching a pattern
  
  #define SYN_STATE_P(ssp)    ((bufstate_T *)((ssp)->ga_data))
  
  #define MAXKEYWLEN      80          // maximum length of a keyword
  
  /*
   * The attributes of the syntax item that has been recognized.
   */
  static int current_attr = 0;        // attr of current syntax word
  static int current_id = 0;          // ID of current char for syn_get_id()
  static int current_trans_id = 0;    // idem, transparency removed
  static int current_flags = 0;
  static int current_seqnr = 0;
  static int current_sub_char = 0;
  
  /*
   * Methods of combining two clusters
   */
  #define CLUSTER_REPLACE     1   // replace first list with second
  #define CLUSTER_ADD         2   // add second list to first
  #define CLUSTER_SUBTRACT    3   // subtract second list from first
  
  #define SYN_CLSTR(buf)  ((syn_cluster_T *)((buf)->b_syn_clusters.ga_data))
  
  /*
   * Syntax group IDs have different types:
   *     0 - 19999  normal syntax groups
   * 20000 - 20999  ALLBUT indicator (current_syn_inc_tag added)
   * 21000 - 21999  TOP indicator (current_syn_inc_tag added)
   * 22000 - 22999  CONTAINED indicator (current_syn_inc_tag added)
   * 23000 - 32767  cluster IDs (subtract SYNID_CLUSTER for the cluster ID)
   */
  #define SYNID_ALLBUT    MAX_HL_ID   // syntax group ID for contains=ALLBUT
  #define SYNID_TOP       21000       // syntax group ID for contains=TOP
  #define SYNID_CONTAINED 22000       // syntax group ID for contains=CONTAINED
  #define SYNID_CLUSTER   23000       // first syntax group ID for clusters
  
  #define MAX_SYN_INC_TAG 999         // maximum before the above overflow
  #define MAX_CLUSTER_ID  (32767 - SYNID_CLUSTER)
  
  /*
   * Annoying Hack(TM):  ":syn include" needs this pointer to pass to
   * expand_filename().  Most of the other syntax commands don't need it, so
   * instead of passing it to them, we stow it here.
   */
  static char_u **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_u *)&dumkey)))
  #define HI2KE(hi)      HIKEY2KE((hi)->hi_key)
  
  // -V:HI2KE:782
  
  /*
   * 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 long 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 *p;
    synstate_T *last_valid = NULL;
    synstate_T *last_min_valid = NULL;
    synstate_T *sp, *prev = NULL;
    linenr_T parsed_lnum;
    linenr_T first_stored;
    int dist;
    static int 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) {
      (void)syn_finish_line(false);
      if (!current_state_stored) {
        ++current_lnum;
        (void)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 (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();
      (void)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)) {
          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)
  {
    buf_T *curbuf_save;
    win_T *curwin_save;
    pos_T cursor_save;
    int idx;
    linenr_T lnum;
    linenr_T end_lnum;
    linenr_T break_lnum;
    bool had_sync_point;
    stateitem_T *cur_si;
    synpat_T *spp;
    char_u *line;
    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;
    colnr_T prev_current_col;
  
    /*
     * 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().
      curwin_save = curwin;
      curwin = wp;
      curbuf_save = curbuf;
      curbuf = syn_buf;
  
      /*
       * Skip lines that end in a backslash.
       */
      for (; start_lnum > 1; --start_lnum) {
        line = ml_get(start_lnum - 1);
        if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') {
          break;
        }
      }
      current_lnum = start_lnum;
  
      // set cursor to start of search
      cursor_save = wp->w_cursor;
      wp->w_cursor.lnum = start_lnum;
      wp->w_cursor.col = 0;
  
      /*
       * If the line is inside a comment, need to find the syntax item that
       * defines the comment.
       * Restrict the search for the end of a comment to b_syn_sync_maxlines.
       */
      if (find_start_comment((int)syn_block->b_syn_sync_maxlines) != NULL) {
        for (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;
    }
    /*
     * 2. Search backwards for given sync patterns.
     */
    else if (syn_block->b_syn_sync_flags & SF_MATCH) {
      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;
      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();
          for (;;) {
            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.
              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;
            (void)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_u *chartab)
  {
    if (syn_block->b_syn_isk != empty_option) {
      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_u *chartab)
  {
    if (syn_win->w_s->b_syn_isk != empty_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) {
      regmmatch_T regmatch;
      // chartab array for syn iskeyword
      char_u 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, (colnr_T)0,
                          IF_SYN_TIME(&syn_block->b_syn_linecont_time));
      syn_block->b_syn_linecont_prog = regmatch.regprog;
  
      restore_chartab(buf_chartab);
      return r;
    }
    return FALSE;
  }
  
  /*
   * 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)
  {
    synstate_T *p;
  
    if (block->b_sst_array != NULL) {
      for (p = block->b_sst_first; p != NULL; p = p->sst_next) {
        clear_syn_state(p);
      }
      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)
  {
    long len;
    synstate_T *to, *from;
    synstate_T *sstp;
  
    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);
      sstp = xcalloc(len, sizeof(synstate_T));
  
      to = sstp - 1;
      if (syn_block->b_sst_array != NULL) {
        // Move the states from the old array to the new one.
        for (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 *p, *prev, *np;
    linenr_T n;
  
    prev = NULL;
    for (p = block->b_sst_first; p != NULL;) {
      if (p->sst_lnum + block->b_syn_sync_linebreaks > buf->b_mod_top) {
        n = p->sst_lnum + buf->b_mod_xlines;
        if (n <= buf->b_mod_bot) {
          // this state is inside the changed area, remove it
          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 *p, *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 (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 (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 *p, *prev;
  
    prev = NULL;
    for (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) {
        (void)syn_stack_cleanup();
        // "sp" may have been moved to the freelist now
        sp = syn_stack_find_entry(current_lnum);
      }
      // Still no free items?  Must be a strange problem...
      if (syn_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)
  {
    int i;
    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 (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;
    reg_extmatch_T *six, *bsx;
  
    // 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.
      bsx = bp[i].bs_extmatch;
      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;
      }
    }
    if (i < 0) {
      return true;
    }
  
    return 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(linenr_T lnum)
  {
    synstate_T *sp;
  
    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)
         */
        (void)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;
        (void)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) {
      (void)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;                // was: char_u *endp;
    lpos_T hl_startpos;           // was: int hl_startcol;
    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, *sip = NULL;
    int startcol;
    int endcol;
    long 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_u buf_chartab[32];  // chartab array for syn iskeyword
    char_u *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) {
        (void)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_u *cur_pos = line + current_col;
          if (vim_iswordp_buf(cur_pos, syn_buf)
              && (current_col == 0
                  || !vim_iswordp_buf(cur_pos - 1 - utf_head_off(line, cur_pos - 1),
                                      syn_buf))) {
            syn_id = check_keyword_id(line, (int)current_col, &endcol, &flags,
                                      &next_list, cur_si, &cchar);
            if (syn_id != 0) {
              push_current_state(KEYWORD_IDX);
              {
                cur_si = &CUR_STATE(current_state.ga_len - 1);
                cur_si->si_m_startcol = current_col;
                cur_si->si_h_startpos.lnum = current_lnum;
                cur_si->si_h_startpos.col = 0;            // starts right away
                cur_si->si_m_endpos.lnum = current_lnum;
                cur_si->si_m_endpos.col = endcol;
                cur_si->si_h_endpos.lnum = current_lnum;
                cur_si->si_h_endpos.col = endcol;
                cur_si->si_ends = TRUE;
                cur_si->si_end_idx = 0;
                cur_si->si_flags = flags;
                cur_si->si_seqnr = next_seqnr++;
                cur_si->si_cchar = cchar;
                if (current_state.ga_len > 1) {
                  cur_si->si_flags |=
                    CUR_STATE(current_state.ga_len - 2).si_flags
                    & HL_CONCEAL;
                }
                cur_si->si_id = syn_id;
                cur_si->si_trans_id = syn_id;
                if (flags & HL_TRANSP) {
                  if (current_state.ga_len < 2) {
                    cur_si->si_attr = 0;
                    cur_si->si_trans_id = 0;
                  } else {
                    cur_si->si_attr = CUR_STATE(current_state.ga_len - 2).si_attr;
                    cur_si->si_trans_id = CUR_STATE(current_state.ga_len - 2).si_trans_id;
                  }
                } else {
                  cur_si->si_attr = syn_id2attr(syn_id);
                }
                cur_si->si_cont_list = NULL;
                cur_si->si_next_list = next_list;
                check_keepend();
              }
            }
          }
        }
  
        /*
         * 3. Check for patterns (only if no keyword found).
         */
        if (syn_id == 0 && syn_block->b_syn_patterns.ga_len) {
          /*
           * If we didn't check for a match yet, or we are past it, check
           * for any match with a pattern.
           */
          if (next_match_idx < 0 || next_match_col < (int)current_col) {
            /*
             * Check all relevant patterns for a match at this
             * position.  This is complicated, because matching with a
             * pattern takes quite a bit of time, thus we want to
             * avoid doing it when it's not needed.
             */
            next_match_idx = 0;                   // no match in this line yet
            next_match_col = MAXCOL;
            for (int idx = syn_block->b_syn_patterns.ga_len; --idx >= 0;) {
              synpat_T *const spp = &(SYN_ITEMS(syn_block)[idx]);
              if (spp->sp_syncing == syncing
                  && (displaying || !(spp->sp_flags & HL_DISPLAY))
                  && (spp->sp_type == SPTYPE_MATCH
                      || spp->sp_type == SPTYPE_START)
                  && (current_next_list != NULL
                             ? in_id_list(NULL, current_next_list,
                                          &spp->sp_syn, 0)
                             : (cur_si == NULL
                                ? !(spp->sp_flags & HL_CONTAINED)
                                : in_id_list(cur_si,
                                             cur_si->si_cont_list, &spp->sp_syn,
                                             spp->sp_flags & HL_CONTAINED)))) {
                // If we already tried matching in this line, and
                // there isn't a match before next_match_col, skip
                // this item.
                if (spp->sp_line_id == current_line_id
                    && spp->sp_startcol >= next_match_col) {
                  continue;
                }
                spp->sp_line_id = current_line_id;
  
                colnr_T lc_col = current_col - spp->sp_offsets[SPO_LC_OFF];
                if (lc_col < 0) {
                  lc_col = 0;
                }
  
                regmatch.rmm_ic = spp->sp_ic;
                regmatch.regprog = spp->sp_prog;
                int r = syn_regexec(&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
                  }
                }
                /*
                 * For a "match" the size must be > 0 after the
                 * end offset needs has been added.  Except when
                 * syncing.
                 */
                else if (spp->sp_type == SPTYPE_MATCH) {
                  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 = 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 = 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 = 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);
    for (;;) {
      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;
        } else {
          // 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;
        sip->si_h_startpos = CUR_STATE(idx - 1).si_h_startpos;
        sip->si_h_endpos = CUR_STATE(idx - 1).si_h_endpos;
        if (sip->si_cont_list == NULL) {
          sip->si_flags |= HL_TRANS_CONT;
          sip->si_cont_list = CUR_STATE(idx - 1).si_cont_list;
        }
      }
    }
  }
  
  /*
   * Check the current stack for patterns with "keepend" flag.
   * Propagate the match-end to contained items, until a "skipend" item is found.
   */
  static void check_keepend(void)
  {
    int i;
    lpos_T maxpos;
    lpos_T maxpos_h;
    stateitem_T *sip;
  
    /*
     * This check can consume a lot of time; only do it from the level where
     * there really is a keepend.
     */
    if (keepend_level < 0) {
      return;
    }
  
    /*
     * Find the last index of an "extend" item.  "keepend" items before that
     * won't do anything.  If there is no "extend" item "i" will be
     * "keepend_level" and all "keepend" items will work normally.
     */
    for (i = current_state.ga_len - 1; i > keepend_level; --i) {
      if (CUR_STATE(i).si_flags & HL_EXTEND) {
        break;
      }
    }
  
    maxpos.lnum = 0;
    maxpos.col = 0;
    maxpos_h.lnum = 0;
    maxpos_h.col = 0;
    for (; i < current_state.ga_len; ++i) {
      sip = &CUR_STATE(i);
      if (maxpos.lnum != 0) {
        limit_pos_zero(&sip->si_m_endpos, &maxpos);
        limit_pos_zero(&sip->si_h_endpos, &maxpos_h);
        limit_pos_zero(&sip->si_eoe_pos, &maxpos);
        sip->si_ends = TRUE;
      }
      if (sip->si_ends && (sip->si_flags & HL_KEEPEND)) {
        if (maxpos.lnum == 0
            || maxpos.lnum > sip->si_m_endpos.lnum
            || (maxpos.lnum == sip->si_m_endpos.lnum
                && maxpos.col > sip->si_m_endpos.col)) {
          maxpos = sip->si_m_endpos;
        }
        if (maxpos_h.lnum == 0
            || maxpos_h.lnum > sip->si_h_endpos.lnum
            || (maxpos_h.lnum == sip->si_h_endpos.lnum
                && maxpos_h.col > sip->si_h_endpos.col)) {
          maxpos_h = sip->si_h_endpos;
        }
      }
    }
  }
  
  /// Update an entry in the current_state stack for a start-skip-end pattern.
  /// This finds the end of the current item, if it's in the current line.
  ///
  /// @param startcol  where to start searching for the end
  /// @param force     when true overrule a previous end
  ///
  /// @return          the flags for the matched END.
  static void update_si_end(stateitem_T *sip, int startcol, bool force)
  {
    lpos_T hl_endpos;
    lpos_T end_endpos;
  
    // return quickly for a keyword
    if (sip->si_idx < 0) {
      return;
    }
  
    // Don't update when it's already done.  Can be a match of an end pattern
    // that started in a previous line.  Watch out: can also be a "keepend"
    // from a containing item.
    if (!force && sip->si_m_endpos.lnum >= current_lnum) {
      return;
    }
  
    /*
     * We need to find the end of the region.  It may continue in the next
     * line.
     */
    int end_idx = 0;
    lpos_T startpos = {
      .lnum = current_lnum,
      .col = startcol,
    };
    lpos_T endpos = { 0 };
    find_endpos(sip->si_idx, &startpos, &endpos, &hl_endpos,
                &(sip->si_flags), &end_endpos, &end_idx, sip->si_extmatch);
  
    if (endpos.lnum == 0) {
      // No end pattern matched.
      if (SYN_ITEMS(syn_block)[sip->si_idx].sp_flags & HL_ONELINE) {
        // a "oneline" never continues in the next line
        sip->si_ends = TRUE;
        sip->si_m_endpos.lnum = current_lnum;
        sip->si_m_endpos.col = (colnr_T)STRLEN(syn_getcurline());
      } else {
        // continues in the next line
        sip->si_ends = FALSE;
        sip->si_m_endpos.lnum = 0;
      }
      sip->si_h_endpos = sip->si_m_endpos;
    } else {
      // match within this line
      sip->si_m_endpos = endpos;
      sip->si_h_endpos = hl_endpos;
      sip->si_eoe_pos = end_endpos;
      sip->si_ends = TRUE;
      sip->si_end_idx = end_idx;
    }
  }
  
  /*
   * Add a new state to the current state stack.
   * It is cleared and the index set to "idx".
   */
  static void push_current_state(int idx)
  {
    stateitem_T *p = GA_APPEND_VIA_PTR(stateitem_T, &current_state);
    memset(p, 0, sizeof(*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,
                          long *flagsp, lpos_T *end_endpos, int *end_idx, reg_extmatch_T *start_ext)
  {
    colnr_T matchcol;
    synpat_T *spp, *spp_skip;
    int start_idx;
    int best_idx;
    regmmatch_T regmatch;
    regmmatch_T best_regmatch;        // startpos/endpos of best match
    lpos_T pos;
    char_u *line;
    bool had_match = false;
    char_u 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.
     */
    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.
     */
    for (;;) {
      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);
  
    matchcol = startpos->col;     // start looking for a match at sstart
    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);
  
    for (;;) {
      /*
       * 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;
        int 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;
          }
  
          line = ml_get_buf(syn_buf, startpos->lnum, false);
          int line_len = (int)STRLEN(line);
  
          // take care of an empty match or negative offset
          if (pos.col <= matchcol) {
            matchcol++;
          } else if (pos.col <= regmatch.endpos[0].col) {
            matchcol = pos.col;
          } else {
            // Be careful not to jump over the NUL at the end-of-line
            for (matchcol = regmatch.endpos[0].col;
                 matchcol < line_len && matchcol < pos.col;
                 matchcol++) {
            }
          }
  
          // if the skip pattern includes end-of-line, break here
          if (matchcol >= line_len) {
            break;
          }
  
          continue;  // start with first end pattern again
        }
      }
  
      /*
       * Match from start pattern to end pattern.
       * Correct for match and highlight offset of end pattern.
       */
      spp = &(SYN_ITEMS(syn_block)[best_idx]);
      syn_add_end_off(m_endpos, &best_regmatch, spp, SPO_ME_OFF, 1);
      // can't end before the start
      if (m_endpos->lnum == startpos->lnum && m_endpos->col < startpos->col) {
        m_endpos->col = startpos->col;
      }
  
      syn_add_end_off(end_endpos, &best_regmatch, spp, SPO_HE_OFF, 1);
      // can't end before the start
      if (end_endpos->lnum == startpos->lnum
          && end_endpos->col < startpos->col) {
        end_endpos->col = startpos->col;
      }
      // can't end after the match
      limit_pos(end_endpos, m_endpos);
  
      /*
       * If the end group is highlighted differently, adjust the pointers.
       */
      if (spp->sp_syn_match_id != spp->sp_syn.id && spp->sp_syn_match_id != 0) {
        *end_idx = best_idx;
        if (spp->sp_off_flags & (1 << (SPO_RE_OFF + SPO_COUNT))) {
          hl_endpos->lnum = best_regmatch.endpos[0].lnum;
          hl_endpos->col = best_regmatch.endpos[0].col;
        } else {
          hl_endpos->lnum = best_regmatch.startpos[0].lnum;
          hl_endpos->col = best_regmatch.startpos[0].col;
        }
        hl_endpos->col += spp->sp_offsets[SPO_RE_OFF];
  
        // can't end before the start
        if (hl_endpos->lnum == startpos->lnum
            && hl_endpos->col < startpos->col) {
          hl_endpos->col = startpos->col;
        }
        limit_pos(hl_endpos, m_endpos);
  
        // now the match ends where the highlighting ends, it is turned
        // into the matchgroup for the end
        *m_endpos = *hl_endpos;
      } else {
        *end_idx = 0;
        *hl_endpos = *end_endpos;
      }
  
      *flagsp = spp->sp_flags;
  
      had_match = true;
      break;
    }
  
    // no match for an END pattern in this line
    if (!had_match) {
      m_endpos->lnum = 0;
    }
  
    restore_chartab(buf_chartab);
  
    // Remove external matches.
    unref_extmatch(re_extmatch_in);
    re_extmatch_in = NULL;
  }
  
  /*
   * Limit "pos" not to be after "limit".
   */
  static void limit_pos(lpos_T *pos, lpos_T *limit)
  {
    if (pos->lnum > limit->lnum) {
      *pos = *limit;
    } else if (pos->lnum == limit->lnum && pos->col > limit->col) {
      pos->col = limit->col;
    }
  }
  
  /*
   * Limit "pos" not to be after "limit", unless pos->lnum is zero.
   */
  static void limit_pos_zero(lpos_T *pos, lpos_T *limit)
  {
    if (pos->lnum == 0) {
      *pos = *limit;
    } else {
      limit_pos(pos, limit);
    }
  }
  
  /// Add offset to matched text for end of match or highlight.
  ///
  /// @param result    returned position
  /// @param regmatch  start/end of match
  /// @param spp       matched pattern
  /// @param idx       index of offset
  /// @param extra     extra chars for offset to start
  static void syn_add_end_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *spp, int idx,
                              int extra)
  {
    int col;
    int off;
    char_u *base;
    char_u *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, false);
      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_u *base;
    char_u *p;
  
    if (spp->sp_off_flags & (1 << (idx + SPO_COUNT))) {
      result->lnum = regmatch->endpos[0].lnum;
      col = regmatch->endpos[0].col;
      off = spp->sp_offsets[idx] + extra;
    } else {
      result->lnum = regmatch->startpos[0].lnum;
      col = regmatch->startpos[0].col;
      off = spp->sp_offsets[idx];
    }
    if (result->lnum > syn_buf->b_ml.ml_line_count) {
      // a "\n" at the end of the pattern may take us below the last line
      result->lnum = syn_buf->b_ml.ml_line_count;
      col = (int)STRLEN(ml_get_buf(syn_buf, result->lnum, false));
    }
    if (off != 0) {
      base = ml_get_buf(syn_buf, result->lnum, false);
      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_u *syn_getcurline(void)
  {
    return ml_get_buf(syn_buf, current_lnum, false);
  }
  
  /*
   * Call vim_regexec() to find a match with "rmp" in "syn_buf".
   * Returns TRUE when there is a match.
   */
  static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T *st)
  {
    int r;
    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 = syn_buf->b_p_smc;
    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"));
    }
  
    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_u *const line, const int startcol, int *const endcolp,
                              long *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_u *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_u keyword[MAXKEYWLEN + 1];         // assume max. keyword len is 80
    STRLCPY(keyword, kwp, kwlen + 1);
  
    keyentry_T *kp = NULL;
  
    // matching case
    if (syn_block->b_keywtab.ht_used != 0) {
      kp = match_keyword(keyword, &syn_block->b_keywtab, cur_si);
    }
  
    // ignoring case
    if (kp == NULL && syn_block->b_keywtab_ic.ht_used != 0) {
      str_foldcase(kwp, kwlen, keyword, MAXKEYWLEN + 1);
      kp = match_keyword(keyword, &syn_block->b_keywtab_ic, cur_si);
    }
  
    if (kp != NULL) {
      *endcolp = startcol + kwlen;
      *flagsp = kp->flags;
      *next_listp = kp->next_list;
      *ccharp = kp->k_char;
      return kp->k_syn.id;
    }
  
    return 0;
  }
  
  /// Find keywords that match.  There can be several with different
  /// attributes.
  /// When current_next_list is non-zero accept only that group, otherwise:
  ///  Accept a not-contained keyword at toplevel.
  ///  Accept a keyword at other levels only if it is in the contains list.
  static keyentry_T *match_keyword(char_u *keyword, hashtab_T *ht, stateitem_T *cur_si)
  {
    hashitem_T *hi = hash_find(ht, keyword);
    if (!HASHITEM_EMPTY(hi)) {
      for (keyentry_T *kp = HI2KE(hi); kp != NULL; kp = kp->ke_next) {
        if (current_next_list != 0
            ? in_id_list(NULL, current_next_list, &kp->k_syn, 0)
            : (cur_si == NULL
              ? !(kp->flags & HL_CONTAINED)
              : in_id_list(cur_si, cur_si->si_cont_list,
                           &kp->k_syn, kp->flags & HL_CONTAINED))) {
          return kp;
        }
      }
    }
    return NULL;
  }
  
  /*
   * Handle ":syntax conceal" command.
   */
  static void syn_cmd_conceal(exarg_T *eap, int syncing)
  {
    char_u *arg = eap->arg;
    char_u *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");
      } else {
        msg("syntax conceal off");
      }
    } 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_u *arg = eap->arg;
    char_u *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");
      } else {
        msg("syntax case match");
      }
    } 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_u *arg = eap->arg;
    char_u *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");   break;
      case SYNFLD_MINIMUM:
        msg("syntax foldlevel minimum"); 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_u *arg = eap->arg;
    char_u *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");
      } else if (curwin->w_s->b_syn_spell == SYNSPL_NOTOP) {
        msg("syntax spell notoplevel");
      } else {
        msg("syntax spell default");
      }
    } 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, NOT_VALID);
  }
  
  /// Handle ":syntax iskeyword" command.
  static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
  {
    char_u *arg = eap->arg;
    char_u save_chartab[32];
    char_u *save_isk;
  
    if (eap->skip) {
      return;
    }
  
    arg = skipwhite(arg);
    if (*arg == NUL) {
      msg_puts("\n");
      if (curwin->w_s->b_syn_isk != empty_option) {
        msg_puts("syntax iskeyword ");
        msg_outtrans(curwin->w_s->b_syn_isk);
      } else {
        msg_outtrans((char_u *)_("syntax iskeyword not set"));
      }
    } 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 = vim_strsave(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, 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) * (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_u *arg = eap->arg;
    char_u *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;
          } else {
            // 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, (int)(arg_end - arg));
          if (id == 0) {
            semsg(_(e_nogroup), arg);
            break;
          } else {
            syn_clear_one(id, syncing);
          }
        }
        arg = skipwhite(arg_end);
      }
    }
    redraw_curbuf_later(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 = (char_u *)"";
      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_u *arg = eap->arg;
    char_u *arg_end;
  
    eap->nextcmd = find_nextcmd(arg);
    if (eap->skip) {
      return;
    }
  
    if (!syntax_present(curwin)) {
      msg(_(msg_no_items));
      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, (int)(arg_end - arg));
          if (id == 0) {
            semsg(_(e_nogroup), arg);
          } else {
            syn_list_one(id, syncing, true);
          }
        }
        arg = skipwhite(arg_end);
      }
    }
    eap->nextcmd = check_nextcmd(arg);
  }
  
  static void syn_lines_msg(void)
  {
    if (curwin->w_s->b_syn_sync_maxlines > 0
        || curwin->w_s->b_syn_sync_minlines > 0) {
      msg_puts("; ");
      if (curwin->w_s->b_syn_sync_minlines == MAXLNUM) {
        msg_puts(_("from the first line"));
      } else {
        if (curwin->w_s->b_syn_sync_minlines > 0) {
          msg_puts(_("minimal "));
          msg_outnum(curwin->w_s->b_syn_sync_minlines);
          if (curwin->w_s->b_syn_sync_maxlines) {
            msg_puts(", ");
          }
        }
        if (curwin->w_s->b_syn_sync_maxlines > 0) {
          msg_puts(_("maximal "));
          msg_outnum(curwin->w_s->b_syn_sync_maxlines);
        }
        msg_puts(_(" lines before top line"));
      }
    }
  }
  
  static void syn_match_msg(void)
  {
    if (curwin->w_s->b_syn_sync_linebreaks > 0) {
      msg_puts(_("; match "));
      msg_outnum(curwin->w_s->b_syn_sync_linebreaks);
      msg_puts(_(" line breaks"));
    }
  }
  
  static int last_matchgroup;
  
  
  /// List one syntax item, for ":syntax" or "syntax list syntax_name".
  ///
  /// @param syncing    when true: list syncing items
  /// @param link_only  when true; list link-only too
  static void syn_list_one(const int id, const bool syncing, const bool link_only)
  {
    bool did_header = false;
    static struct name_list namelist1[] =
    {
      { HL_DISPLAY, "display" },
      { HL_CONTAINED, "contained" },
      { HL_ONELINE, "oneline" },
      { HL_KEEPEND, "keepend" },
      { HL_EXTEND, "extend" },
      { HL_EXCLUDENL, "excludenl" },
      { HL_TRANSP, "transparent" },
      { HL_FOLD, "fold" },
      { HL_CONCEAL, "conceal" },
      { HL_CONCEALENDS, "concealends" },
      { 0, NULL }
    };
    static struct name_list namelist2[] =
    {
      { HL_SKIPWHITE, "skipwhite" },
      { HL_SKIPNL, "skipnl" },
      { HL_SKIPEMPTY, "skipempty" },
      { 0, NULL }
    };
  
    const int attr = HL_ATTR(HLF_D);      // highlight like directories
  
    // list the keywords for "id"
    if (!syncing) {
      did_header = syn_list_keywords(id, &curwin->w_s->b_keywtab, false, attr);
      did_header = syn_list_keywords(id, &curwin->w_s->b_keywtab_ic,
                                     did_header, attr);
    }
  
    // list the patterns for "id"
    for (int idx = 0;
         idx < curwin->w_s->b_syn_patterns.ga_len && !got_int;
         idx++) {
      const synpat_T *const spp = &(SYN_ITEMS(curwin->w_s)[idx]);
      if (spp->sp_syn.id != id || spp->sp_syncing != syncing) {
        continue;
      }
  
      (void)syn_list_header(did_header, 0, id, true);
      did_header = true;
      last_matchgroup = 0;
      if (spp->sp_type == SPTYPE_MATCH) {
        put_pattern("match", ' ', spp, attr);
        msg_putchar(' ');
      } else if (spp->sp_type == SPTYPE_START) {
        while (SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_START) {
          put_pattern("start", '=', &SYN_ITEMS(curwin->w_s)[idx++], attr);
        }
        if (SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_SKIP) {
          put_pattern("skip", '=', &SYN_ITEMS(curwin->w_s)[idx++], attr);
        }
        while (idx < curwin->w_s->b_syn_patterns.ga_len
               && SYN_ITEMS(curwin->w_s)[idx].sp_type == SPTYPE_END) {
          put_pattern("end", '=', &SYN_ITEMS(curwin->w_s)[idx++], attr);
        }
        --idx;
        msg_putchar(' ');
      }
      syn_list_flags(namelist1, spp->sp_flags, attr);
  
      if (spp->sp_cont_list != NULL) {
        put_id_list("contains", spp->sp_cont_list, attr);
      }
  
      if (spp->sp_syn.cont_in_list != NULL) {
        put_id_list("containedin", spp->sp_syn.cont_in_list, attr);
      }
  
      if (spp->sp_next_list != NULL) {
        put_id_list("nextgroup", spp->sp_next_list, attr);
        syn_list_flags(namelist2, spp->sp_flags, attr);
      }
      if (spp->sp_flags & (HL_SYNC_HERE|HL_SYNC_THERE)) {
        if (spp->sp_flags & HL_SYNC_HERE) {
          msg_puts_attr("grouphere", attr);
        } else {
          msg_puts_attr("groupthere", attr);
        }
        msg_putchar(' ');
        if (spp->sp_sync_idx >= 0) {
          msg_outtrans(highlight_group_name(SYN_ITEMS(curwin->w_s)
                                            [spp->sp_sync_idx].sp_syn.id - 1));
        } 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) {
      (void)syn_list_header(did_header, 0, id, true);
      msg_puts_attr("links to", attr);
      msg_putchar(' ');
      msg_outtrans(highlight_group_name(highlight_link_id(id - 1) - 1));
    }
  }
  
  static void syn_list_flags(struct name_list *nlist, int flags, int attr)
  {
    int i;
  
    for (i = 0; nlist[i].flag != 0; ++i) {
      if (flags & nlist[i].flag) {
        msg_puts_attr(nlist[i].name, attr);
        msg_putchar(' ');
      }
    }
  }
  
  /*
   * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
   */
  static void syn_list_cluster(int id)
  {
    int endcol = 15;
  
    // slight hack:  roughly duplicate the guts of syn_list_header()
    msg_putchar('\n');
    msg_outtrans(SYN_CLSTR(curwin->w_s)[id].scl_name);
  
    if (msg_col >= endcol) {      // output at least one space
      endcol = msg_col + 1;
    }
    if (Columns <= endcol) {      // avoid hang for tiny window
      endcol = Columns - 1;
    }
  
    msg_advance(endcol);
    if (SYN_CLSTR(curwin->w_s)[id].scl_list != NULL) {
      put_id_list("cluster", SYN_CLSTR(curwin->w_s)[id].scl_list, HL_ATTR(HLF_D));
    } else {
      msg_puts_attr("cluster", HL_ATTR(HLF_D));
      msg_puts("=NONE");
    }
  }
  
  static void put_id_list(const char *const name, const int16_t *const list, const int attr)
  {
    msg_puts_attr(name, attr);
    msg_putchar('=');
    for (const int16_t *p = list; *p; p++) {
      if (*p >= SYNID_ALLBUT && *p < SYNID_TOP) {
        if (p[1]) {
          msg_puts("ALLBUT");
        } else {
          msg_puts("ALL");
        }
      } else if (*p >= SYNID_TOP && *p < SYNID_CONTAINED) {
        msg_puts("TOP");
      } else if (*p >= SYNID_CONTAINED && *p < SYNID_CLUSTER) {
        msg_puts("CONTAINED");
      } else if (*p >= SYNID_CLUSTER) {
        int scl_id = *p - SYNID_CLUSTER;
  
        msg_putchar('@');
        msg_outtrans(SYN_CLSTR(curwin->w_s)[scl_id].scl_name);
      } else {
        msg_outtrans(highlight_group_name(*p - 1));
      }
      if (p[1]) {
        msg_putchar(',');
      }
    }
    msg_putchar(' ');
  }
  
  static void put_pattern(const char *const s, const int c, const synpat_T *const spp, const int attr)
  {
    static const char *const sepchars = "/+=-#@\"|'^&";
    int i;
  
    // May have to write "matchgroup=group"
    if (last_matchgroup != spp->sp_syn_match_id) {
      last_matchgroup = spp->sp_syn_match_id;
      msg_puts_attr("matchgroup", attr);
      msg_putchar('=');
      if (last_matchgroup == 0) {
        msg_outtrans((char_u *)"NONE");
      } else {
        msg_outtrans(highlight_group_name(last_matchgroup - 1));
      }
      msg_putchar(' ');
    }
  
    // Output the name of the pattern and an '=' or ' '.
    msg_puts_attr(s, attr);
    msg_putchar(c);
  
    // output the pattern, in between a char that is not in the pattern
    for (i = 0; vim_strchr(spp->sp_pattern, 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);
    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 long n = spp->sp_offsets[i];
      if (i != SPO_LC_OFF) {
        if (spp->sp_off_flags & mask) {
          msg_putchar('s');
        } else {
          msg_putchar('e');
        }
        if (n > 0) {
          msg_putchar('+');
        }
      }
      if (n || i == SPO_LC_OFF) {
        msg_outnum(n);
      }
      first = false;
    }
    msg_putchar(' ');
  }
  
  /// List or clear the keywords for one syntax group.
  ///
  /// @param did_header  header has already been printed
  ///
  /// @return            true if the header has been printed.
  static bool syn_list_keywords(const int id, const hashtab_T *const ht, bool did_header,
                                const int attr)
  {
    int prev_contained = 0;
    const int16_t *prev_next_list = NULL;
    const int16_t *prev_cont_in_list = NULL;
    int prev_skipnl = 0;
    int prev_skipwhite = 0;
    int prev_skipempty = 0;
  
    // Unfortunately, this list of keywords is not sorted on alphabet but on
    // hash value...
    size_t todo = ht->ht_used;
    for (const hashitem_T *hi = ht->ht_array; todo > 0 && !got_int; hi++) {
      if (HASHITEM_EMPTY(hi)) {
        continue;
      }
      todo--;
      for (keyentry_T *kp = HI2KE(hi); kp != NULL && !got_int; kp = kp->ke_next) {
        if (kp->k_syn.id == id) {
          int outlen = 0;
          bool force_newline = false;
          if (prev_contained != (kp->flags & HL_CONTAINED)
              || prev_skipnl != (kp->flags & HL_SKIPNL)
              || prev_skipwhite != (kp->flags & HL_SKIPWHITE)
              || prev_skipempty != (kp->flags & HL_SKIPEMPTY)
              || prev_cont_in_list != kp->k_syn.cont_in_list
              || prev_next_list != kp->next_list) {
            force_newline = true;
          } else {
            outlen = (int)STRLEN(kp->keyword);
          }
          // output "contained" and "nextgroup" on each line
          if (syn_list_header(did_header, outlen, id, force_newline)) {
            prev_contained = 0;
            prev_next_list = NULL;
            prev_cont_in_list = NULL;
            prev_skipnl = 0;
            prev_skipwhite = 0;
            prev_skipempty = 0;
          }
          did_header = true;
          if (prev_contained != (kp->flags & HL_CONTAINED)) {
            msg_puts_attr("contained", attr);
            msg_putchar(' ');
            prev_contained = (kp->flags & HL_CONTAINED);
          }
          if (kp->k_syn.cont_in_list != prev_cont_in_list) {
            put_id_list("containedin", kp->k_syn.cont_in_list, attr);
            msg_putchar(' ');
            prev_cont_in_list = kp->k_syn.cont_in_list;
          }
          if (kp->next_list != prev_next_list) {
            put_id_list("nextgroup", kp->next_list, attr);
            msg_putchar(' ');
            prev_next_list = kp->next_list;
            if (kp->flags & HL_SKIPNL) {
              msg_puts_attr("skipnl", attr);
              msg_putchar(' ');
              prev_skipnl = (kp->flags & HL_SKIPNL);
            }
            if (kp->flags & HL_SKIPWHITE) {
              msg_puts_attr("skipwhite", attr);
              msg_putchar(' ');
              prev_skipwhite = (kp->flags & HL_SKIPWHITE);
            }
            if (kp->flags & HL_SKIPEMPTY) {
              msg_puts_attr("skipempty", attr);
              msg_putchar(' ');
              prev_skipempty = (kp->flags & HL_SKIPEMPTY);
            }
          }
          msg_outtrans(kp->keyword);
        }
      }
    }
  
    return did_header;
  }
  
  static void syn_clear_keyword(int id, hashtab_T *ht)
  {
    hashitem_T *hi;
    keyentry_T *kp;
    keyentry_T *kp_prev;
    keyentry_T *kp_next;
    int todo;
  
    hash_lock(ht);
    todo = (int)ht->ht_used;
    for (hi = ht->ht_array; todo > 0; ++hi) {
      if (HASHITEM_EMPTY(hi)) {
        continue;
      }
      --todo;
      kp_prev = NULL;
      for (kp = HI2KE(hi); kp != NULL;) {
        if (kp->k_syn.id == id) {
          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)
  {
    hashitem_T *hi;
    int todo;
    keyentry_T *kp;
    keyentry_T *kp_next;
  
    todo = (int)ht->ht_used;
    for (hi = ht->ht_array; todo > 0; ++hi) {
      if (!HASHITEM_EMPTY(hi)) {
        --todo;
        for (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_u *const name, const int id, const int flags,
                          int16_t *const cont_in_list, int16_t *const next_list,
                          const int conceal_char)
  {
    char_u name_folded[MAXKEYWLEN + 1];
    const char_u *const name_ic = (curwin->w_s->b_syn_ic)
        ? str_foldcase(name, (int)STRLEN(name), name_folded, sizeof(name_folded))
        : name;
  
    keyentry_T *const kp = xmalloc(sizeof(keyentry_T) + STRLEN(name_ic));
    STRCPY(kp->keyword, name_ic);
    kp->k_syn.id = id;
    kp->k_syn.inc_tag = current_syn_inc_tag;
    kp->flags = flags;
    kp->k_char = conceal_char;
    kp->k_syn.cont_in_list = copy_id_list(cont_in_list);
    if (cont_in_list != NULL) {
      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, (const char *)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_u *get_group_name(char_u *arg, char_u **name_end)
  {
    char_u *rest;
  
    *name_end = skiptowhite(arg);
    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_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
  {
    char_u *gname_start, *gname;
    int syn_id;
    int len = 0;
    char *p;
    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;
    }
  
    for (;;) {
      /*
       * 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;) {
        p = flagtab[fidx].name;
        int i;
        for (i = 0, len = 0; p[i] != NUL; i += 2, ++len) {
          if (arg[len] != (char_u)p[i] && arg[len] != (char_u)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(_("E395: 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_strict(*conceal_char)) {
          emsg(_("E844: 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;
          }
          gname_start = arg;
          arg = skiptowhite(arg);
          if (gname_start == arg) {
            return NULL;
          }
          gname = vim_strnsave(gname_start, arg - gname_start);
          if (STRCMP(gname, "NONE") == 0) {
            *opt->sync_idx = NONE_IDX;
          } else {
            syn_id = syn_name2id((char *)gname);
            int i;
            for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0;) {
              if (SYN_ITEMS(curwin->w_s)[i].sp_syn.id == syn_id
                  && SYN_ITEMS(curwin->w_s)[i].sp_type == SPTYPE_START) {
                *opt->sync_idx = i;
                break;
              }
            }
            if (i < 0) {
              semsg(_("E394: Didn't find region item for %s"), gname);
              xfree(gname);
              return NULL;
            }
          }
  
          xfree(gname);
          arg = skipwhite(arg);
        } else if (flagtab[fidx].flags == HL_FOLD
                   && foldmethodIsSyntax(curwin)) {
          // Need to update folds later.
          foldUpdateAll(curwin);
        }
      }
    }
  
    return arg;
  }
  
  /*
   * Adjustments to syntax item when declared in a ":syn include"'d file.
   * Set the contained flag, and if the item is not already contained, add it
   * to the specified top-level group, if any.
   */
  static void syn_incl_toplevel(int id, int *flagsp)
  {
    if ((*flagsp & HL_CONTAINED) || curwin->w_s->b_syn_topgrp == 0) {
      return;
    }
    *flagsp |= HL_CONTAINED;
    if (curwin->w_s->b_syn_topgrp >= SYNID_CLUSTER) {
      // We have to alloc this, because syn_combine_list() will free it.
      int16_t *grp_list = xmalloc(2 * sizeof(*grp_list));
      int tlg_id = curwin->w_s->b_syn_topgrp - SYNID_CLUSTER;
  
      grp_list[0] = 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_u *arg = eap->arg;
    int sgl_id = 1;
    char_u *group_name_end;
    char_u *rest;
    char *errormsg = NULL;
    int prev_toplvl_grp;
    int prev_syn_inc_tag;
    bool source = false;
  
    eap->nextcmd = find_nextcmd(arg);
    if (eap->skip) {
      return;
    }
  
    if (arg[0] == '@') {
      ++arg;
      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;
    }
    prev_syn_inc_tag = current_syn_inc_tag;
    current_syn_inc_tag = ++running_syn_inc_tag;
    prev_toplvl_grp = curwin->w_s->b_syn_topgrp;
    curwin->w_s->b_syn_topgrp = sgl_id;
    if (source
        ? do_source((char *)eap->arg, false, DOSO_NONE) == FAIL
        : source_runtime((char *)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_u *arg = eap->arg;
    char_u *group_name_end;
    int syn_id;
    char_u *rest;
    char_u *keyword_copy = NULL;
    char_u *p;
    char_u *kw;
    syn_opt_arg_T syn_opt_arg;
    int cnt;
    int conceal_char = NUL;
  
    rest = get_group_name(arg, &group_name_end);
  
    if (rest != NULL) {
      if (eap->skip) {
        syn_id = -1;
      } else {
        syn_id = syn_check_group((char *)arg, (int)(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.
        cnt = 0;
        p = keyword_copy;
        for (; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest)) {
          rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
          if (rest == NULL || ends_excmd(*rest)) {
            break;
          }
          // Copy the keyword, removing backslashes, and add a NUL.
          while (*rest != NUL && !ascii_iswhite(*rest)) {
            if (*rest == '\\' && rest[1] != NUL) {
              rest++;
            }
            *p++ = *rest++;
          }
          *p++ = NUL;
          cnt++;
        }
  
        if (!eap->skip) {
          // Adjust flags for use of ":syn include".
          syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
  
          // 2: Add an entry for each keyword.
          for (kw = keyword_copy; --cnt >= 0; kw += STRLEN(kw) + 1) {
            for (p = vim_strchr(kw, '[');;) {
              if (p != NULL) {
                *p = NUL;
              }
              add_keyword(kw, syn_id, syn_opt_arg.flags,
                          syn_opt_arg.cont_in_list,
                          syn_opt_arg.next_list, conceal_char);
              if (p == NULL) {
                break;
              }
              if (p[1] == NUL) {
                semsg(_("E789: Missing ']': %s"), kw);
                goto error;
              }
              if (p[1] == ']') {
                if (p[2] != NUL) {
                  semsg(_("E890: trailing char after ']': %s]%s"),
                        kw, &p[2]);
                  goto error;
                }
                kw = p + 1;
                break;   // skip over the "]"
              }
              const int l = utfc_ptr2len(p + 1);
  
              memmove(p, p + 1, 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(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_u *arg = eap->arg;
    char_u *group_name_end;
    char_u *rest;
    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
    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();
    memset(&item, 0, sizeof(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((char *)arg, (int)(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 = 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(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_u *arg = eap->arg;
    char_u *group_name_end;
    char_u *rest;                    // next arg, NULL on error
    char_u *key_end;
    char_u *key = NULL;
    char_u *p;
    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, 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) {
        p = skiptowhite(rest);
        if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip) {
          matchgroup_id = 0;
        } else {
          matchgroup_id = syn_check_group((char *)rest, (int)(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((char *)arg, (int)(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 = syn_id;
              SYN_ITEMS(curwin->w_s)[idx].sp_syn.inc_tag =
                current_syn_inc_tag;
              SYN_ITEMS(curwin->w_s)[idx].sp_syn_match_id =
                ppp->pp_matchgroup_id;
              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(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((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_u *name)
  {
    // Avoid using stricmp() too much, it's slow on some systems
    char_u *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_u *linep, int len)
  {
    char_u *name = vim_strnsave(linep, 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_u *pp, int len)
  {
    int id;
    char_u *name;
  
    name = vim_strnsave(pp, len);
  
    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_u *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);
    memset(scp, 0, sizeof(*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_u *arg = eap->arg;
    char_u *group_name_end;
    char_u *rest;
    bool got_clstr = false;
    int opt_len;
    int list_op;
  
    eap->nextcmd = find_nextcmd(arg);
    if (eap->skip) {
      return;
    }
  
    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;
  
      for (;;) {
        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(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.
   * Returns a pointer to the next argument, or NULL in case of an error.
   */
  static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
  {
    char_u *end;
    int *p;
    int idx;
    char_u *cpo_save;
  
    // need at least three chars
    if (arg == NULL || arg[0] == NUL || arg[1] == NUL || arg[2] == NUL) {
      return NULL;
    }
  
    end = skip_regexp(arg + 1, *arg, TRUE, NULL);
    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 = vim_strnsave(arg + 1, end - arg - 1);
  
    // Make 'cpoptions' empty, to avoid the 'l' flag
    cpo_save = p_cpo;
    p_cpo = (char_u *)"";
    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) {
        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 |= (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_u *arg_start = eap->arg;
    char_u *arg_end;
    char_u *key = NULL;
    char_u *next_arg;
    int illegal = FALSE;
    int finished = FALSE;
    long n;
    char_u *cpo_save;
  
    if (ends_excmd(*arg_start)) {
      syn_cmd_list(eap, TRUE);
      return;
    }
  
    while (!ends_excmd(*arg_start)) {
      arg_end = skiptowhite(arg_start);
      next_arg = skipwhite(arg_end);
      xfree(key);
      key = vim_strnsave_up(arg_start, 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 = syn_check_group((char *)next_arg, (int)(arg_end - next_arg));
          }
          next_arg = skipwhite(arg_end);
        } else if (!eap->skip) {
          curwin->w_s->b_syn_sync_id = 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;
        }
        n = getdigits_long(&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, NULL);
        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 =
            vim_strnsave(next_arg + 1, 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
          cpo_save = p_cpo;
          p_cpo = (char_u *)"";
          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(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_u **const arg, const int keylen, int16_t **const list, const bool skip)
  {
    char_u *p = NULL;
    char_u *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_u *const name = xmalloc(end - p + 3);   // leave room for "^$"
        STRLCPY(name + 1, p, end - p + 1);
        if (STRCMP(name + 1, "ALLBUT") == 0
            || STRCMP(name + 1, "ALL") == 0
            || STRCMP(name + 1, "TOP") == 0
            || STRCMP(name + 1, "CONTAINED") == 0) {
          if (TOUPPER_ASC(**arg) != 'C') {
            semsg(_("E407: %s not allowed here"), name + 1);
            failed = true;
            xfree(name);
            break;
          }
          if (count != 0) {
            semsg(_("E408: %s must be first in contains list"),
                  name + 1);
            failed = true;
            xfree(name);
            break;
          }
          if (name[1] == 'A') {
            id = SYNID_ALLBUT + current_syn_inc_tag;
          } else if (name[1] == 'T') {
            if (curwin->w_s->b_syn_topgrp >= SYNID_CLUSTER) {
              id = curwin->w_s->b_syn_topgrp;
            } else {
              id = SYNID_TOP + current_syn_inc_tag;
            }
          } else {
            id = SYNID_CONTAINED + current_syn_inc_tag;
          }
        } else if (name[1] == '@') {
          if (skip) {
            id = -1;
          } else {
            id = syn_check_cluster(name + 2, (int)(end - p - 1));
          }
        } else {
          /*
           * Handle full group name.
           */
          if (vim_strpbrk(name + 1, (char_u *)"\\.*^$~[") == NULL) {
            id = syn_check_group((char *)(name + 1), (int)(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), (colnr_T)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] = i + 1;  // -V522
                  }
                }
                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] = 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((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 = (count + 1) * sizeof(int16_t);
    int16_t *const retval = xmalloc(len);
    memmove(retval, list, len);
  
    return retval;
  }
  
  /// Check if syntax group "ssp" is in the ID list "list" of "cur_si".
  /// "cur_si" can be NULL if not checking the "containedin" list.
  /// Used to check if a syntax item is in the "contains" or "nextgroup" list of
  /// the current item.
  /// This function is called very often, keep it fast!!
  ///
  /// @param cur_si     current item or NULL
  /// @param list       id list
  /// @param ssp        group id and ":syn include" tag of group
  /// @param contained  group id is contained
  static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, int contained)
  {
    int retval;
    int16_t *scl_list;
    int16_t item;
    int16_t id = ssp->id;
    static int depth = 0;
    int r;
  
    // If ssp has a "containedin" list and "cur_si" is in it, return TRUE.
    if (cur_si != NULL && ssp->cont_in_list != NULL
        && !(cur_si->si_flags & HL_MATCH)) {
      // Ignore transparent items without a contains argument.  Double check
      // that we don't go back past the first one.
      while ((cur_si->si_flags & HL_TRANS_CONT)
             && cur_si > (stateitem_T *)(current_state.ga_data)) {
        --cur_si;
      }
      // cur_si->si_idx is -1 for keywords, these never contain anything.
      if (cur_si->si_idx >= 0 && in_id_list(NULL, ssp->cont_in_list,
                                            &(SYN_ITEMS(syn_block)[cur_si->si_idx].sp_syn),
                                            SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags &
                                            HL_CONTAINED)) {
        return TRUE;
      }
    }
  
    if (list == NULL) {
      return FALSE;
    }
  
    /*
     * If list is ID_LIST_ALL, we are in a transparent item that isn't
     * inside anything.  Only allow not-contained groups.
     */
    if (list == ID_LIST_ALL) {
      return !contained;
    }
  
    /*
     * If the first item is "ALLBUT", return TRUE if "id" is NOT in the
     * contains list.  We also require that "id" is at the same ":syn include"
     * level as the list.
     */
    item = *list;
    if (item >= SYNID_ALLBUT && item < SYNID_CLUSTER) {
      if (item < SYNID_TOP) {
        // ALL or ALLBUT: accept all groups in the same file
        if (item - SYNID_ALLBUT != ssp->inc_tag) {
          return FALSE;
        }
      } else if (item < SYNID_CONTAINED) {
        // TOP: accept all not-contained groups in the same file
        if (item - SYNID_TOP != ssp->inc_tag || contained) {
          return FALSE;
        }
      } else {
        // CONTAINED: accept all contained groups in the same file
        if (item - SYNID_CONTAINED != ssp->inc_tag || !contained) {
          return FALSE;
        }
      }
      item = *++list;
      retval = FALSE;
    } else {
      retval = TRUE;
    }
  
    /*
     * Return "retval" if id is in the contains list.
     */
    while (item != 0) {
      if (item == id) {
        return retval;
      }
      if (item >= SYNID_CLUSTER) {
        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;
          r = in_id_list(NULL, scl_list, ssp, contained);
          --depth;
          if (r) {
            return retval;
          }
        }
      }
      item = *++list;
    }
    return !retval;
  }
  
  struct subcommand {
    char *name;                                // subcommand name
    void (*func)(exarg_T *, int);              // function to call
  };
  
  static struct subcommand subcommands[] =
  {
    { "case",      syn_cmd_case },
    { "clear",     syn_cmd_clear },
    { "cluster",   syn_cmd_cluster },
    { "conceal",   syn_cmd_conceal },
    { "enable",    syn_cmd_on },
    { "foldlevel", syn_cmd_foldlevel },
    { "include",   syn_cmd_include },
    { "iskeyword", syn_cmd_iskeyword },
    { "keyword",   syn_cmd_keyword },
    { "list",      syn_cmd_list },
    { "manual",    syn_cmd_manual },
    { "match",     syn_cmd_match },
    { "on",        syn_cmd_on },
    { "off",       syn_cmd_off },
    { "region",    syn_cmd_region },
    { "reset",     syn_cmd_reset },
    { "spell",     syn_cmd_spell },
    { "sync",      syn_cmd_sync },
    { "",          syn_cmd_list },
    { NULL, NULL }
  };
  
  /*
   * ":syntax".
   * This searches the subcommands[] table for the subcommand name, and calls a
   * syntax_subcommand() function to do the rest.
   */
  void ex_syntax(exarg_T *eap)
  {
    char_u *arg = eap->arg;
    char_u *subcmd_end;
  
    syn_cmdlinep = eap->cmdlinep;
  
    // isolate subcommand name
    for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); subcmd_end++) {
    }
    char_u *const subcmd_name = vim_strnsave(arg, subcmd_end - arg);
    if (eap->skip) {  // skip error messages for all subcommands
      emsg_skip++;
    }
    for (int i = 0;; i++) {
      if (subcommands[i].name == NULL) {
        semsg(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
        break;
      }
      if (STRCMP(subcmd_name, (char_u *)subcommands[i].name) == 0) {
        eap->arg = skipwhite(subcmd_end);
        (subcommands[i].func)(eap, FALSE);
        break;
      }
    }
    xfree(subcmd_name);
    if (eap->skip) {
      --emsg_skip;
    }
  }
  
  void ex_ownsyntax(exarg_T *eap)
  {
    char_u *old_value;
    char_u *new_value;
  
    if (curwin->w_s == &curwin->w_buffer->b_s) {
      curwin->w_s = xmalloc(sizeof(synblock_T));
      memset(curwin->w_s, 0, sizeof(synblock_T));
      hash_init(&curwin->w_s->b_keywtab);
      hash_init(&curwin->w_s->b_keywtab_ic);
      // TODO: Keep the spell checking as it was. NOLINT(readability/todo)
      curwin->w_p_spell = false;  // No spell checking
      // make sure option values are "empty_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.
    old_value = get_var_value("b:current_syntax");
    if (old_value != NULL) {
      old_value = vim_strsave(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.
    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
  } 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_u *)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_u *)arg;
    include_link = 0;
    include_default = 0;
  
    // (part of) subcommand already typed
    if (*arg != NUL) {
      const char *p = (const char *)skiptowhite((const char_u *)arg);
      if (*p != NUL) {  // Past first word.
        xp->xp_pattern = skipwhite((const char_u *)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, "keyword", p - arg) == 0
                   || STRNICMP(arg, "region", p - arg) == 0
                   || STRNICMP(arg, "match", p - arg) == 0
                   || STRNICMP(arg, "list", 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_u *get_syntax_name(expand_T *xp, int idx)
  {
    switch (expand_what) {
    case EXP_SUBCMD:
      return (char_u *)subcommands[idx].name;
    case EXP_CASE: {
      static char *case_args[] = { "match", "ignore", NULL };
      return (char_u *)case_args[idx];
    }
    case EXP_SPELL: {
      static char *spell_args[] =
      { "toplevel", "notoplevel", "default", NULL };
      return (char_u *)spell_args[idx];
    }
    case EXP_SYNC: {
      static char *sync_args[] =
      { "ccomment", "clear", "fromstart",
        "linebreaks=", "linecont", "lines=", "match",
        "maxlines=", "minlines=", "region", NULL };
      return (char_u *)sync_args[idx];
    }
    }
    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, long 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 buffer, need to restart parsing.
    if (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;
    }
  
    (void)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;
    int syntax_flags;
  
    (void)syn_get_id(wp, lnum, col, false, NULL, false);
    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, long 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) {
          (void)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 = 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));
      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_u *get_syntime_arg(expand_T *xp, int idx)
  {
    switch (idx) {
    case 0:
      return (char_u *)"on";
    case 1:
      return (char_u *)"off";
    case 2:
      return (char_u *)"clear";
    case 3:
      return (char_u *)"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));
      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));
      msg_puts(" ");
  
      msg_advance(69);
      int len;
      if (Columns < 80) {
        len = 20;       // will wrap anyway
      } else {
        len = Columns - 70;
      }
      if (len > (int)STRLEN(p->pattern)) {
        len = (int)STRLEN(p->pattern);
      }
      msg_outtrans_len(p->pattern, len);
      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");
    }
  }
  