Merge remote-tracking branch 'upstream/master' into floattitlefloattitle

1 files changed, 688 insertions, 1023 deletions

diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 2a3ec56451..575d475b87 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -1,9 +1,7 @@
 // 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
- */
+// syntax.c: code for syntax highlighting
 
 #include <assert.h>
 #include <ctype.h>
@@ -93,22 +91,20 @@ typedef struct syn_pattern {
   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
+  char *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
+  char *scl_name_u;         // uppercase of scl_name
   int16_t *scl_list;        // IDs in this syntax cluster
 } syn_cluster_T;
 
-/*
- * For the current state we need to remember more than just the idx.
- * When si_m_endpos.lnum is 0, the items other than si_idx are unknown.
- * (The end positions have the column number of the next char)
- */
+// 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
@@ -133,10 +129,8 @@ typedef struct state_item {
                                         // pattern
 } stateitem_T;
 
-/*
- * Struct to reduce the number of arguments to get_syn_options(), it's used
- * very often.
- */
+// 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"
@@ -184,9 +178,7 @@ static char *(spo_name_tab[SPO_COUNT]) =
 
 #define NONE_IDX        (-2)    // value of sp_sync_idx for "NONE"
 
-/*
- * Flags for b_syn_sync_flags:
- */
+// 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
 
@@ -194,9 +186,7 @@ static char *(spo_name_tab[SPO_COUNT]) =
 
 #define MAXKEYWLEN      80          // maximum length of a keyword
 
-/*
- * The attributes of the syntax item that has been recognized.
- */
+// 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
@@ -204,23 +194,19 @@ static int current_flags = 0;
 static int current_seqnr = 0;
 static int current_sub_char = 0;
 
-/*
- * Methods of combining two clusters
- */
+// 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)
- */
+// 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
@@ -234,21 +220,17 @@ static int current_sub_char = 0;
 // instead of passing it to them, we stow it here.
 static char **syn_cmdlinep;
 
-/*
- * Another Annoying Hack(TM):  To prevent rules from other ":syn include"'d
- * files from leaking into ALLBUT lists, we assign a unique ID to the
- * rules in each ":syn include"'d file.
- */
+// 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.
- */
+// 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)))
@@ -256,11 +238,9 @@ static keyentry_T dumkey;
 
 // -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.
- */
+// 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");
@@ -272,13 +252,11 @@ static char msg_no_items[] = N_("No Syntax items defined for this buffer");
 
 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)
- */
+// 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
@@ -290,17 +268,13 @@ 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.
- */
+// 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.
- */
+// 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
@@ -328,13 +302,11 @@ 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.
- */
+// 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;
@@ -348,11 +320,9 @@ void syntax_start(win_T *wp, linenr_T lnum)
 
   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.
-   */
+  // 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)) {
@@ -363,18 +333,14 @@ void syntax_start(win_T *wp, linenr_T lnum)
   changedtick = buf_get_changedtick(syn_buf);
   syn_win = wp;
 
-  /*
-   * Allocate syntax stack when needed.
-   */
+  // 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 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) {
@@ -384,11 +350,9 @@ void syntax_start(win_T *wp, linenr_T 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 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();
     }
@@ -396,10 +360,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
     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.
-   */
+  // 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) {
@@ -418,10 +380,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
     }
   }
 
-  /*
-   * If "lnum" is before or far beyond a line with a saved state, need to
-   * re-synchronize.
-   */
+  // 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) {
@@ -436,10 +396,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
     first_stored = current_lnum;
   }
 
-  /*
-   * Advance from the sync point or saved state until the current line.
-   * Save some entries for syncing with later on.
-   */
+  // 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 {
@@ -506,10 +464,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
   syn_start_line();
 }
 
-/*
- * We cannot simply discard growarrays full of state_items or buf_states; we
- * have to manually release their extmatch pointers first.
- */
+// 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) {
@@ -522,24 +478,20 @@ static void clear_syn_state(synstate_T *p)
   }
 }
 
-/*
- * Cleanup the current_state stack.
- */
+// 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".
- */
+// 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;
@@ -560,19 +512,15 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
   lpos_T found_m_endpos;
   colnr_T prev_current_col;
 
-  /*
-   * Clear any current state that might be hanging around.
-   */
+  // 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.
-   */
+  // 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 {
@@ -595,9 +543,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
   }
   current_lnum = start_lnum;
 
-  /*
-   * 1. Search backwards for the end of a C-style comment.
-   */
+  // 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().
@@ -606,11 +552,9 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     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);
+    // Skip lines that end in a backslash.
+    for (; start_lnum > 1; start_lnum--) {
+      line = (char_u *)ml_get(start_lnum - 1);
       if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') {
         break;
       }
@@ -622,11 +566,9 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     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 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
@@ -644,11 +586,8 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     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) {
+  } else if (syn_block->b_syn_sync_flags & SF_MATCH) {
+    // 2. Search backwards for given sync patterns.
     if (syn_block->b_syn_sync_maxlines != 0
         && start_lnum > syn_block->b_syn_sync_maxlines) {
       break_lnum = start_lnum - syn_block->b_syn_sync_maxlines;
@@ -675,19 +614,15 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
         break;
       }
 
-      /*
-       * Check if the previous line has the line-continuation pattern.
-       */
+      // 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
-       */
+      // Start with nothing on the state stack
       validate_current_state();
 
-      for (current_lnum = lnum; current_lnum < end_lnum; ++current_lnum) {
+      for (current_lnum = lnum; current_lnum < end_lnum; current_lnum++) {
         syn_start_line();
         for (;;) {
           had_sync_point = syn_finish_line(true);
@@ -712,10 +647,8 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
             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).
-             */
+            // 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;
@@ -743,27 +676,21 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
         }
       }
 
-      /*
-       * If a sync point was encountered, break here.
-       */
+      // 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.
-         */
+        // 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.
-         */
+        // 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);
@@ -797,7 +724,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
   validate_current_state();
 }
 
-static void save_chartab(char_u *chartab)
+static void save_chartab(char *chartab)
 {
   if (syn_block->b_syn_isk != empty_option) {
     memmove(chartab, syn_buf->b_chartab, (size_t)32);
@@ -805,23 +732,21 @@ static void save_chartab(char_u *chartab)
   }
 }
 
-static void restore_chartab(char_u *chartab)
+static void restore_chartab(char *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".
- */
+/// 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);
+    save_chartab((char *)buf_chartab);
 
     regmatch.rmm_ic = syn_block->b_syn_linecont_ic;
     regmatch.regprog = syn_block->b_syn_linecont_prog;
@@ -829,24 +754,20 @@ static int syn_match_linecont(linenr_T lnum)
                         IF_SYN_TIME(&syn_block->b_syn_linecont_time));
     syn_block->b_syn_linecont_prog = regmatch.regprog;
 
-    restore_chartab(buf_chartab);
+    restore_chartab((char *)buf_chartab);
     return r;
   }
-  return FALSE;
+  return false;
 }
 
-/*
- * Prepare the current state for the start of a line.
- */
+// 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".
-   */
+  // 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();
@@ -878,23 +799,21 @@ static void syn_update_ends(bool startofline)
         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;
+        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.
-   */
+  // 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) {
+    for (; i > keepend_level; i--) {
       if (CUR_STATE(i).si_flags & HL_EXTEND) {
         break;
       }
@@ -925,37 +844,35 @@ static void syn_update_ends(bool startofline)
 /////////////////////////////////////////
 // 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.
- */
+// 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)
 {
@@ -970,10 +887,8 @@ static void syn_stack_free_block(synblock_T *block)
     block->b_sst_len = 0;
   }
 }
-/*
- * Free b_sst_array[] for buffer "buf".
- * Used when syntax items changed to force resyncing everywhere.
- */
+// 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);
@@ -986,12 +901,10 @@ void syn_stack_free_all(synblock_T *block)
   }
 }
 
-/*
- * 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.
- */
+// 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)
 {
   synstate_T *to, *from;
@@ -1058,12 +971,10 @@ static void syn_stack_alloc(void)
   }
 }
 
-/*
- * 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.
- */
+// 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);
@@ -1139,11 +1050,9 @@ static bool syn_stack_cleanup(void)
     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).
-   */
+  // 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;
@@ -1160,10 +1069,8 @@ static bool syn_stack_cleanup(void)
     }
   }
 
-  /*
-   * Go through the list to make the entries for the oldest tick at an
-   * interval of several lines.
-   */
+  // 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) {
@@ -1177,22 +1084,18 @@ static bool syn_stack_cleanup(void)
   return retval;
 }
 
-/*
- * Free the allocated memory for a syn_state item.
- * Move the entry into the free list.
- */
+// 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;
+  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".
- */
+// 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;
@@ -1209,10 +1112,8 @@ static synstate_T *syn_stack_find_entry(linenr_T lnum)
   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!
- */
+// 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;
@@ -1221,11 +1122,9 @@ static synstate_T *store_current_state(void)
   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) {
+  // 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
@@ -1256,9 +1155,7 @@ static synstate_T *store_current_state(void)
       sp = NULL;
     }
   } else if (sp == NULL || sp->sst_lnum != current_lnum) {
-    /*
-     * Add a new entry
-     */
+    // Add a new entry
     // If no free items, cleanup the array first.
     if (syn_block->b_sst_freecount == 0) {
       (void)syn_stack_cleanup();
@@ -1273,7 +1170,7 @@ static synstate_T *store_current_state(void)
       // list, after *sp
       p = syn_block->b_sst_firstfree;
       syn_block->b_sst_firstfree = p->sst_next;
-      --syn_block->b_sst_freecount;
+      syn_block->b_sst_freecount--;
       if (sp == NULL) {
         // Insert in front of the list
         p->sst_next = syn_block->b_sst_first;
@@ -1302,7 +1199,7 @@ static synstate_T *store_current_state(void)
     } else {
       bp = sp->sst_union.sst_stack;
     }
-    for (i = 0; i < sp->sst_stacksize; ++i) {
+    for (i = 0; i < sp->sst_stacksize; i++) {
       bp[i].bs_idx = CUR_STATE(i).si_idx;
       bp[i].bs_flags = (int)CUR_STATE(i).si_flags;
       bp[i].bs_seqnr = CUR_STATE(i).si_seqnr;
@@ -1318,9 +1215,7 @@ static synstate_T *store_current_state(void)
   return sp;
 }
 
-/*
- * Copy a state stack from "from" in b_sst_array[] to current_state;
- */
+// Copy a state stack from "from" in b_sst_array[] to current_state;
 static void load_current_state(synstate_T *from)
 {
   int i;
@@ -1336,7 +1231,7 @@ static void load_current_state(synstate_T *from)
     } else {
       bp = from->sst_union.sst_stack;
     }
-    for (i = 0; i < from->sst_stacksize; ++i) {
+    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;
@@ -1345,7 +1240,7 @@ static void load_current_state(synstate_T *from)
       if (keepend_level < 0 && (CUR_STATE(i).si_flags & HL_KEEPEND)) {
         keepend_level = i;
       }
-      CUR_STATE(i).si_ends = FALSE;
+      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 =
@@ -1424,16 +1319,14 @@ static bool syn_stack_equal(synstate_T *sp)
   return i < 0 ? true : false;
 }
 
-/*
- * We stop parsing syntax above line "lnum".  If the stored state at or below
- * this line depended on a change before it, it now depends on the line below
- * the last parsed line.
- * The window looks like this:
- *          line which changed
- *          displayed line
- *          displayed line
- * lnum ->  line below window
- */
+// 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;
@@ -1448,9 +1341,8 @@ void syntax_end_parsing(linenr_T lnum)
   }
 }
 
-/*
- * End of handling of the state stack.
- ****************************************/
+// End of handling of the state stack.
+// **************************************
 
 static void invalidate_current_state(void)
 {
@@ -1475,33 +1367,25 @@ 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.
-   */
+  // 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)
-       */
+      // 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.
-       */
+      // 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.
-       */
+      // Store the current state in b_sst_array[] for later use.
       current_lnum++;
       (void)store_current_state();
     }
@@ -1551,7 +1435,7 @@ static bool syn_finish_line(const bool syncing)
 /// "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
+/// 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"
@@ -1589,9 +1473,7 @@ int get_syntax_attr(const colnr_T col, bool *const can_spell, const bool keep_st
     validate_current_state();
   }
 
-  /*
-   * Skip from the current column to "col", get the attributes for "col".
-   */
+  // 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);
@@ -1636,15 +1518,11 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   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();
+  // No character, no attributes!  Past end of line?
+  // Do try matching with an empty line (could be the start of a region).
+  line = (char_u *)syn_getcurline();
   if (line[current_col] == NUL && current_col != 0) {
-    /*
-     * If we found a match after the last column, use it.
-     */
+    // 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();
@@ -1661,11 +1539,9 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
     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.
-   */
+  // 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;
@@ -1681,25 +1557,21 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   ga_init(&zero_width_next_ga, (int)sizeof(int), 10);
 
   // use syntax iskeyword option
-  save_chartab(buf_chartab);
+  save_chartab((char *)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.
-   */
+  // 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!).
-     */
+    // 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 {
@@ -1708,18 +1580,17 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
 
     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.
-       */
+      // 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();
+        line = (char_u *)syn_getcurline();
         const char_u *cur_pos = line + current_col;
-        if (vim_iswordp_buf(cur_pos, syn_buf)
+        if (vim_iswordp_buf((char *)cur_pos, syn_buf)
             && (current_col == 0
-                || !vim_iswordp_buf(cur_pos - 1 - utf_head_off(line, cur_pos - 1),
+                || !vim_iswordp_buf((char *)cur_pos - 1 -
+                                    utf_head_off((char *)line, (char *)cur_pos - 1),
                                     syn_buf))) {
-          syn_id = check_keyword_id(line, (int)current_col, &endcol, &flags,
+          syn_id = check_keyword_id((char *)line, (int)current_col, &endcol, &flags,
                                     &next_list, cur_si, &cchar);
           if (syn_id != 0) {
             push_current_state(KEYWORD_IDX);
@@ -1732,7 +1603,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               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_ends = true;
               cur_si->si_end_idx = 0;
               cur_si->si_flags = flags;
               cur_si->si_seqnr = next_seqnr++;
@@ -1763,21 +1634,15 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
         }
       }
 
-      /*
-       * 3. Check for patterns (only if no keyword found).
-       */
+      // 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 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.
-           */
+          // 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;) {
@@ -1819,9 +1684,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
                 continue;
               }
 
-              /*
-               * Compute the first column of the match.
-               */
+              // Compute the first column of the match.
               syn_add_start_off(&pos, &regmatch,
                                 spp, SPO_MS_OFF, -1);
               if (pos.lnum > current_lnum) {
@@ -1836,19 +1699,15 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               // 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 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 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;
@@ -1866,10 +1725,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               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.
-               */
+              // 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;
@@ -1880,12 +1737,10 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               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.
-               */
+              // 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;
@@ -1896,23 +1751,18 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
                 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) {
+              } else if (spp->sp_type == SPTYPE_MATCH) {
+                // For a "match" the size must be > 0 after the
+                // end offset needs has been added.  Except when
+                // syncing.
                 syn_add_end_off(&hl_endpos, &regmatch, spp,
                                 SPO_HE_OFF, 0);
                 syn_add_end_off(&endpos, &regmatch, spp,
                                 SPO_ME_OFF, 0);
                 if (endpos.lnum == current_lnum
                     && (int)endpos.col + syncing < startcol) {
-                  /*
-                   * If an empty string is matched, may need
-                   * to try matching again at next column.
-                   */
+                  // If 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;
                   }
@@ -1920,9 +1770,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
                 }
               }
 
-              /*
-               * keep the best match so far in next_match_*
-               */
+              // keep the best match so far in next_match_*
+
               // Highlighting must start after startpos and end
               // before endpos.
               if (hl_startpos.lnum == current_lnum
@@ -1947,9 +1796,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
           }
         }
 
-        /*
-         * If we found a match at the current column, use it.
-         */
+        // 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;
 
@@ -1977,17 +1824,13 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
       }
     }
 
-    /*
-     * Handle searching for nextgroup match.
-     */
+    // 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 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();
+        line = (char_u *)syn_getcurline();
         if (((current_next_flags & HL_SKIPWHITE)
              && ascii_iswhite(line[current_col]))
             || ((current_next_flags & HL_SKIPEMPTY)
@@ -1996,14 +1839,12 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
         }
       }
 
-      /*
-       * 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).
-       */
+      // 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) {
@@ -2012,19 +1853,17 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
     }
   } while (found_match);
 
-  restore_chartab(buf_chartab);
+  restore_chartab((char *)buf_chartab);
 
-  /*
-   * Use attributes from the current state, if within its highlighting.
-   * If not, use attributes from the current-but-one state, etc.
-   */
+  // 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) {
+    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
@@ -2046,10 +1885,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
     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.
-       */
+      // 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.
@@ -2085,14 +1922,12 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
       }
     }
 
-    /*
-     * 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.
-     */
+    // 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)
@@ -2112,7 +1947,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
 
   // nextgroup ends at end of line, unless "skipnl" or "skipempty" present
   if (current_next_list != NULL
-      && (line = syn_getcurline())[current_col] != NUL
+      && (line = (char_u *)syn_getcurline())[current_col] != NUL
       && line[current_col + 1] == NUL
       && !(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))) {
     current_next_list = NULL;
@@ -2152,9 +1987,7 @@ static bool did_match_already(int idx, garray_T *gap)
   return false;
 }
 
-/*
- * Push the next match onto the stack.
- */
+// Push the next match onto the stack.
 static stateitem_T *push_next_match(void)
 {
   stateitem_T *cur_si;
@@ -2163,15 +1996,11 @@ static stateitem_T *push_next_match(void)
 
   spp = &(SYN_ITEMS(syn_block)[next_match_idx]);
 
-  /*
-   * Push the item in current_state stack;
-   */
+  // 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.
-     */
+    // 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;
@@ -2192,7 +2021,7 @@ static stateitem_T *push_next_match(void)
     } 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_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;
@@ -2204,10 +2033,8 @@ static stateitem_T *push_next_match(void)
     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 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);
@@ -2216,7 +2043,7 @@ static stateitem_T *push_next_match(void)
       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_ends = true;
       cur_si->si_end_idx = 0;
       cur_si->si_flags = HL_MATCH;
       cur_si->si_seqnr = next_seqnr++;
@@ -2235,9 +2062,7 @@ static stateitem_T *push_next_match(void)
   return cur_si;
 }
 
-/*
- * Check for end of current state (and the states before it).
- */
+// Check for end of current state (and the states before it).
 static void check_state_ends(void)
 {
   stateitem_T *cur_si;
@@ -2249,12 +2074,10 @@ static void check_state_ends(void)
         && (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 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
@@ -2331,10 +2154,8 @@ static void check_state_ends(void)
   }
 }
 
-/*
- * 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.
- */
+// 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);
@@ -2359,11 +2180,9 @@ static void update_si_attr(int idx)
     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.
-   */
+  // 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;
@@ -2382,10 +2201,8 @@ static void update_si_attr(int idx)
   }
 }
 
-/*
- * Check the current stack for patterns with "keepend" flag.
- * Propagate the match-end to contained items, until a "skipend" item is found.
- */
+// 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;
@@ -2393,20 +2210,16 @@ static void check_keepend(void)
   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.
-   */
+  // 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) {
+  // 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;
     }
@@ -2416,13 +2229,13 @@ static void check_keepend(void)
   maxpos.col = 0;
   maxpos_h.lnum = 0;
   maxpos_h.col = 0;
-  for (; i < current_state.ga_len; ++i) {
+  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;
+      sip->si_ends = true;
     }
     if (sip->si_ends && (sip->si_flags & HL_KEEPEND)) {
       if (maxpos.lnum == 0
@@ -2465,10 +2278,8 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
     return;
   }
 
-  /*
-   * We need to find the end of the region.  It may continue in the next
-   * line.
-   */
+  // 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,
@@ -2482,12 +2293,12 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
     // 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_ends = true;
       sip->si_m_endpos.lnum = current_lnum;
-      sip->si_m_endpos.col = (colnr_T)STRLEN(syn_getcurline());
+      sip->si_m_endpos.col = (colnr_T)strlen(syn_getcurline());
     } else {
       // continues in the next line
-      sip->si_ends = FALSE;
+      sip->si_ends = false;
       sip->si_m_endpos.lnum = 0;
     }
     sip->si_h_endpos = sip->si_m_endpos;
@@ -2496,15 +2307,13 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
     sip->si_m_endpos = endpos;
     sip->si_h_endpos = hl_endpos;
     sip->si_eoe_pos = end_endpos;
-    sip->si_ends = TRUE;
+    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".
- */
+// 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);
@@ -2512,14 +2321,12 @@ static void push_current_state(int idx)
   p->si_idx = idx;
 }
 
-/*
- * Remove a state from the current_state stack.
- */
+// 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;
+    current_state.ga_len--;
   }
   // after the end of a pattern, try matching a keyword or pattern
   next_match_idx = -1;
@@ -2565,20 +2372,16 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     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.
-   */
+  // 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.
-   */
+  // 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) {
@@ -2587,9 +2390,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     idx++;
   }
 
-  /*
-   *    Lookup the SKIP pattern (if present)
-   */
+  //    Lookup the SKIP pattern (if present)
   if (spp->sp_type == SPTYPE_SKIP) {
     spp_skip = spp;
     idx++;
@@ -2606,14 +2407,12 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
   best_regmatch.startpos[0].col = 0;            // avoid compiler warning
 
   // use syntax iskeyword option
-  save_chartab(buf_chartab);
+  save_chartab((char *)buf_chartab);
 
   for (;;) {
-    /*
-     * Find end pattern that matches first after "matchcol".
-     */
+    // Find end pattern that matches first after "matchcol".
     best_idx = -1;
-    for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; ++idx) {
+    for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; idx++) {
       int lc_col = matchcol;
 
       spp = &(SYN_ITEMS(syn_block)[idx]);
@@ -2640,18 +2439,14 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
       }
     }
 
-    /*
-     * If all end patterns have been tried, and there is no match, the
-     * item continues until end-of-line.
-     */
+    // 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 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];
 
@@ -2673,7 +2468,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
           break;
         }
 
-        line = ml_get_buf(syn_buf, startpos->lnum, false);
+        line = (char_u *)ml_get_buf(syn_buf, startpos->lnum, false);
         int line_len = (int)STRLEN(line);
 
         // take care of an empty match or negative offset
@@ -2697,10 +2492,8 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
       }
     }
 
-    /*
-     * Match from start pattern to end pattern.
-     * Correct for match and highlight offset of end pattern.
-     */
+    // 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
@@ -2717,9 +2510,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     // can't end after the match
     limit_pos(end_endpos, m_endpos);
 
-    /*
-     * If the end group is highlighted differently, adjust the pointers.
-     */
+    // 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))) {
@@ -2757,16 +2548,14 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     m_endpos->lnum = 0;
   }
 
-  restore_chartab(buf_chartab);
+  restore_chartab((char *)buf_chartab);
 
   // Remove external matches.
   unref_extmatch(re_extmatch_in);
   re_extmatch_in = NULL;
 }
 
-/*
- * Limit "pos" not to be after "limit".
- */
+// Limit "pos" not to be after "limit".
 static void limit_pos(lpos_T *pos, lpos_T *limit)
 {
   if (pos->lnum > limit->lnum) {
@@ -2776,9 +2565,7 @@ static void limit_pos(lpos_T *pos, lpos_T *limit)
   }
 }
 
-/*
- * Limit "pos" not to be after "limit", unless pos->lnum is zero.
- */
+// 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) {
@@ -2817,7 +2604,7 @@ static void syn_add_end_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *spp
   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);
+    base = (char_u *)ml_get_buf(syn_buf, result->lnum, false);
     p = base + col;
     if (off > 0) {
       while (off-- > 0 && *p != NUL) {
@@ -2859,10 +2646,10 @@ static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *s
   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));
+    col = (int)strlen(ml_get_buf(syn_buf, result->lnum, false));
   }
   if (off != 0) {
-    base = ml_get_buf(syn_buf, result->lnum, false);
+    base = (char_u *)ml_get_buf(syn_buf, result->lnum, false);
     p = base + col;
     if (off > 0) {
       while (off-- && *p != NUL) {
@@ -2878,18 +2665,14 @@ static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *s
   result->col = col;
 }
 
-/*
- * Get current line in syntax buffer.
- */
-static char_u *syn_getcurline(void)
+/// Get current line in syntax buffer.
+static char *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.
- */
+// 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 timed_out = 0;
@@ -2916,9 +2699,9 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
     if (profile_cmp(pt, st->slowest) < 0) {
       st->slowest = pt;
     }
-    ++st->count;
+    st->count++;
     if (r > 0) {
-      ++st->match;
+      st->match++;
     }
   }
   if (timed_out && !syn_win->w_s->b_syn_slow) {
@@ -2929,9 +2712,9 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
   if (r > 0) {
     rmp->startpos[0].lnum += lnum;
     rmp->endpos[0].lnum += lnum;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 /// Check one position in a line for a matching keyword.
@@ -2944,16 +2727,16 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
 /// @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,
+static int check_keyword_id(char *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;
+  char *const kwp = line + startcol;
   int kwlen = 0;
   do {
-    kwlen += utfc_ptr2len((char *)kwp + kwlen);
+    kwlen += utfc_ptr2len(kwp + kwlen);
   } while (vim_iswordp_buf(kwp + kwlen, syn_buf));
 
   if (kwlen > MAXKEYWLEN) {
@@ -2969,13 +2752,13 @@ static int check_keyword_id(char_u *const line, const int startcol, int *const e
 
   // matching case
   if (syn_block->b_keywtab.ht_used != 0) {
-    kp = match_keyword(keyword, &syn_block->b_keywtab, cur_si);
+    kp = match_keyword((char *)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);
+    str_foldcase((char_u *)kwp, kwlen, keyword, MAXKEYWLEN + 1);
+    kp = match_keyword((char *)keyword, &syn_block->b_keywtab_ic, cur_si);
   }
 
   if (kp != NULL) {
@@ -2994,9 +2777,9 @@ static int check_keyword_id(char_u *const line, const int startcol, int *const e
 /// 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)
+static keyentry_T *match_keyword(char *keyword, hashtab_T *ht, stateitem_T *cur_si)
 {
-  hashitem_T *hi = hash_find(ht, (char *)keyword);
+  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
@@ -3012,20 +2795,18 @@ static keyentry_T *match_keyword(char_u *keyword, hashtab_T *ht, stateitem_T *cu
   return NULL;
 }
 
-/*
- * Handle ":syntax conceal" command.
- */
+// Handle ":syntax conceal" command.
 static void syn_cmd_conceal(exarg_T *eap, int syncing)
 {
   char_u *arg = (char_u *)eap->arg;
   char_u *next;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
 
-  next = skiptowhite(arg);
+  next = (char_u *)skiptowhite((char *)arg);
   if (*arg == NUL) {
     if (curwin->w_s->b_syn_conceal) {
       msg("syntax conceal on");
@@ -3041,15 +2822,13 @@ static void syn_cmd_conceal(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * Handle ":syntax case" command.
- */
+/// Handle ":syntax case" command.
 static void syn_cmd_case(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *next;
+  char *arg = eap->arg;
+  char *next;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -3076,7 +2855,7 @@ static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
   char_u *arg = (char_u *)eap->arg;
   char_u *arg_end;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3093,7 +2872,7 @@ static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
     return;
   }
 
-  arg_end = skiptowhite(arg);
+  arg_end = (char_u *)skiptowhite((char *)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) {
@@ -3109,15 +2888,13 @@ static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * Handle ":syntax spell" command.
- */
+/// Handle ":syntax spell" command.
 static void syn_cmd_spell(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *next;
+  char *arg = eap->arg;
+  char *next;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -3143,26 +2920,26 @@ static void syn_cmd_spell(exarg_T *eap, int syncing)
   }
 
   // assume spell checking changed, force a redraw
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
 }
 
 /// Handle ":syntax iskeyword" command.
 static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u save_chartab[32];
-  char_u *save_isk;
+  char *arg = eap->arg;
+  char save_chartab[32];
+  char *save_isk;
 
   if (eap->skip) {
     return;
   }
 
-  arg = (char_u *)skipwhite((char *)arg);
+  arg = skipwhite(arg);
   if (*arg == NUL) {
     msg_puts("\n");
     if (curwin->w_s->b_syn_isk != empty_option) {
       msg_puts("syntax iskeyword ");
-      msg_outtrans((char *)curwin->w_s->b_syn_isk);
+      msg_outtrans(curwin->w_s->b_syn_isk);
     } else {
       msg_outtrans(_("syntax iskeyword not set"));
     }
@@ -3173,7 +2950,7 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
     } else {
       memmove(save_chartab, curbuf->b_chartab, (size_t)32);
       save_isk = curbuf->b_p_isk;
-      curbuf->b_p_isk = vim_strsave(arg);
+      curbuf->b_p_isk = xstrdup(arg);
 
       buf_init_chartab(curbuf, false);
       memmove(curwin->w_s->b_syn_chartab, curbuf->b_chartab, (size_t)32);
@@ -3183,12 +2960,10 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
       curbuf->b_p_isk = save_isk;
     }
   }
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
 }
 
-/*
- * Clear all syntax info for one buffer.
- */
+// Clear all syntax info for one buffer.
 void syntax_clear(synblock_T *block)
 {
   block->b_syn_error = false;           // clear previous error
@@ -3236,9 +3011,7 @@ void syntax_clear(synblock_T *block)
   running_syn_inc_tag = 0;
 }
 
-/*
- * Get rid of ownsyntax for window "wp".
- */
+// Get rid of ownsyntax for window "wp".
 void reset_synblock(win_T *wp)
 {
   if (wp->w_s != &wp->w_buffer->b_s) {
@@ -3248,9 +3021,7 @@ void reset_synblock(win_T *wp)
   }
 }
 
-/*
- * Clear syncing info for one buffer.
- */
+// Clear syncing info for one buffer.
 static void syntax_sync_clear(void)
 {
   // free the syntax patterns
@@ -3273,26 +3044,22 @@ static void syntax_sync_clear(void)
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
-/*
- * Remove one pattern from the buffer's pattern list.
- */
+// 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;
+    block->b_syn_folditems--;
   }
   syn_clear_pattern(block, idx);
   memmove(spp, spp + 1, sizeof(synpat_T) * (size_t)(block->b_syn_patterns.ga_len - idx - 1));
   block->b_syn_patterns.ga_len--;
 }
 
-/*
- * Clear and free one syntax pattern.  When clearing all, must be called from
- * last to first!
- */
+// 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);
@@ -3305,9 +3072,7 @@ static void syn_clear_pattern(synblock_T *block, int i)
   }
 }
 
-/*
- * Clear and free one syntax cluster.
- */
+// Clear and free one syntax cluster.
 static void syn_clear_cluster(synblock_T *block, int i)
 {
   xfree(SYN_CLSTR(block)[i].scl_name);
@@ -3315,34 +3080,28 @@ static void syn_clear_cluster(synblock_T *block, int i)
   xfree(SYN_CLSTR(block)[i].scl_list);
 }
 
-/*
- * Handle ":syntax clear" command.
- */
+/// Handle ":syntax clear" command.
 static void syn_cmd_clear(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *arg_end;
+  char *arg = eap->arg;
+  char *arg_end;
   int id;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  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".
-   */
+  // 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.
-     */
+    // No argument: Clear all syntax items.
     if (syncing) {
       syntax_sync_clear();
     } else {
@@ -3353,9 +3112,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
       do_unlet(S_LEN("w:current_syntax"), true);
     }
   } else {
-    /*
-     * Clear the group IDs that are in the argument.
-     */
+    // Clear the group IDs that are in the argument.
     while (!ends_excmd(*arg)) {
       arg_end = skiptowhite(arg);
       if (*arg == '@') {
@@ -3372,7 +3129,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
           XFREE_CLEAR(SYN_CLSTR(curwin->w_s)[scl_id].scl_list);
         }
       } else {
-        id = syn_name2id_len((char *)arg, (size_t)(arg_end - arg));
+        id = syn_name2id_len(arg, (size_t)(arg_end - arg));
         if (id == 0) {
           semsg(_(e_nogroup), arg);
           break;
@@ -3380,16 +3137,14 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
           syn_clear_one(id, syncing);
         }
       }
-      arg = (char_u *)skipwhite((char *)arg_end);
+      arg = skipwhite(arg_end);
     }
   }
-  redraw_curbuf_later(SOME_VALID);
+  redraw_curbuf_later(UPD_SOME_VALID);
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
-/*
- * Clear one syntax group for the current buffer.
- */
+// Clear one syntax group for the current buffer.
 static void syn_clear_one(const int id, const bool syncing)
 {
   synpat_T *spp;
@@ -3410,37 +3165,29 @@ static void syn_clear_one(const int id, const bool syncing)
   }
 }
 
-/*
- * Handle ":syntax on" command.
- */
+// 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.
- */
+// Handle ":syntax reset" command.
+// It actually resets highlighting, not syntax.
 static void syn_cmd_reset(exarg_T *eap, int syncing)
 {
-  eap->nextcmd = (char *)check_nextcmd((char_u *)eap->arg);
+  eap->nextcmd = check_nextcmd(eap->arg);
   if (!eap->skip) {
     init_highlight(true, true);
   }
 }
 
-/*
- * Handle ":syntax manual" command.
- */
+// Handle ":syntax manual" command.
 static void syn_cmd_manual(exarg_T *eap, int syncing)
 {
   syn_cmd_onoff(eap, "manual");
 }
 
-/*
- * Handle ":syntax off" command.
- */
+// Handle ":syntax off" command.
 static void syn_cmd_off(exarg_T *eap, int syncing)
 {
   syn_cmd_onoff(eap, "nosyntax");
@@ -3449,7 +3196,7 @@ static void syn_cmd_off(exarg_T *eap, int syncing)
 static void syn_cmd_onoff(exarg_T *eap, char *name)
   FUNC_ATTR_NONNULL_ALL
 {
-  eap->nextcmd = (char *)check_nextcmd((char_u *)eap->arg);
+  eap->nextcmd = check_nextcmd(eap->arg);
   if (!eap->skip) {
     did_syntax_onoff = true;
     char buf[100];
@@ -3471,13 +3218,13 @@ void syn_maybe_enable(void)
 
 /// Handle ":syntax [list]" command: list current syntax words.
 ///
-/// @param syncing  when TRUE: list syncing items
+/// @param syncing  when true: list syncing items
 static void syn_cmd_list(exarg_T *eap, int syncing)
 {
   char_u *arg = (char_u *)eap->arg;
   char_u *arg_end;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3520,23 +3267,19 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
     msg_puts_title(_("\n--- Syntax items ---"));
   }
   if (ends_excmd(*arg)) {
-    /*
-     * No argument: List all group IDs and all syntax clusters.
-     */
+    // 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) {
+    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.
-     */
+    // List the group IDs and syntax clusters that are in the argument.
     while (!ends_excmd(*arg) && !got_int) {
-      arg_end = skiptowhite(arg);
+      arg_end = (char_u *)skiptowhite((char *)arg);
       if (*arg == '@') {
-        int id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
+        int id = syn_scl_namen2id((char *)arg + 1, (int)(arg_end - arg - 1));
         if (id == 0) {
           semsg(_("E392: No such syntax cluster: %s"), arg);
         } else {
@@ -3553,7 +3296,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
       arg = (char_u *)skipwhite((char *)arg_end);
     }
   }
-  eap->nextcmd = (char *)check_nextcmd(arg);
+  eap->nextcmd = check_nextcmd((char *)arg);
 }
 
 static void syn_lines_msg(void)
@@ -3702,7 +3445,7 @@ static void syn_list_flags(struct name_list *nlist, int flags, int attr)
 {
   int i;
 
-  for (i = 0; nlist[i].flag != 0; ++i) {
+  for (i = 0; nlist[i].flag != 0; i++) {
     if (flags & nlist[i].flag) {
       msg_puts_attr(nlist[i].name, attr);
       msg_putchar(' ');
@@ -3710,9 +3453,7 @@ static void syn_list_flags(struct name_list *nlist, int flags, int attr)
   }
 }
 
-/*
- * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
- */
+// List one syntax cluster, for ":syntax" or "syntax list syntax_name".
 static void syn_list_cluster(int id)
 {
   int endcol = 15;
@@ -3790,14 +3531,14 @@ static void put_pattern(const char *const s, const int c, const synpat_T *const
   msg_putchar(c);
 
   // output the pattern, in between a char that is not in the pattern
-  for (i = 0; vim_strchr((char *)spp->sp_pattern, sepchars[i]) != NULL;) {
+  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((char *)spp->sp_pattern);
+  msg_outtrans(spp->sp_pattern);
   msg_putchar(sepchars[i]);
 
   // output any pattern options
@@ -3925,7 +3666,7 @@ static void syn_clear_keyword(int id, hashtab_T *ht)
 
   hash_lock(ht);
   todo = (int)ht->ht_used;
-  for (hi = ht->ht_array; todo > 0; ++hi) {
+  for (hi = ht->ht_array; todo > 0; hi++) {
     if (HASHITEM_EMPTY(hi)) {
       continue;
     }
@@ -3956,9 +3697,7 @@ static void syn_clear_keyword(int id, hashtab_T *ht)
   hash_unlock(ht);
 }
 
-/*
- * Clear a whole keyword table.
- */
+// Clear a whole keyword table.
 static void clear_keywtab(hashtab_T *ht)
 {
   hashitem_T *hi;
@@ -3967,7 +3706,7 @@ static void clear_keywtab(hashtab_T *ht)
   keyentry_T *kp_next;
 
   todo = (int)ht->ht_used;
-  for (hi = ht->ht_array; todo > 0; ++hi) {
+  for (hi = ht->ht_array; todo > 0; hi++) {
     if (!HASHITEM_EMPTY(hi)) {
       todo--;
       for (kp = HI2KE(hi); kp != NULL; kp = kp_next) {
@@ -3989,16 +3728,17 @@ static void clear_keywtab(hashtab_T *ht)
 /// @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,
+static void add_keyword(char *const name, const int id, const int flags,
                         int16_t *const cont_in_list, int16_t *const next_list,
                         const int conceal_char)
 {
-  char_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))
+  char name_folded[MAXKEYWLEN + 1];
+  const char *const name_ic = (curwin->w_s->b_syn_ic)
+      ? (char *)str_foldcase((char_u *)name, (int)strlen(name), (char_u *)name_folded,
+                             sizeof(name_folded))
       : name;
 
-  keyentry_T *const kp = xmalloc(sizeof(keyentry_T) + STRLEN(name_ic));
+  keyentry_T *const kp = xmalloc(sizeof(keyentry_T) + strlen(name_ic));
   STRCPY(kp->keyword, name_ic);
   kp->k_syn.id = (int16_t)id;
   kp->k_syn.inc_tag = current_syn_inc_tag;
@@ -4006,7 +3746,7 @@ static void add_keyword(char_u *const name, const int id, const int 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;
+    curwin->w_s->b_syn_containedin = true;
   }
   kp->next_list = copy_id_list(next_list);
 
@@ -4039,17 +3779,13 @@ static void add_keyword(char_u *const name, const int id, const int flags,
 ///
 /// @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)
+static char *get_group_name(char *arg, char **name_end)
 {
-  char_u *rest;
-
   *name_end = skiptowhite(arg);
-  rest = (char_u *)skipwhite((char *)(*name_end));
+  char *rest = skipwhite(*name_end);
 
-  /*
-   * Check if there are enough arguments.  The first argument may be a
-   * pattern, where '|' is allowed, so only check for NUL.
-   */
+  // 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;
   }
@@ -4063,13 +3799,13 @@ static char_u *get_group_name(char_u *arg, char_u **name_end)
 ///
 /// @param arg   next argument to be checked
 /// @param opt   various things
-/// @param skip  TRUE if skipping over command
+/// @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)
+static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
 {
-  char_u *gname_start, *gname;
+  char *gname_start, *gname;
   int syn_id;
   int len = 0;
   char *p;
@@ -4108,11 +3844,9 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
   }
 
   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.
-     */
+    // 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;
     }
@@ -4120,8 +3854,8 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
     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]) {
+      for (i = 0, len = 0; p[i] != NUL; i += 2, len++) {
+        if (arg[len] != p[i] && arg[len] != p[i + 1]) {
           break;
         }
       }
@@ -4161,16 +3895,16 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
       }
     } else if (flagtab[fidx].argtype == 11 && arg[5] == '=') {
       // cchar=?
-      *conceal_char = utf_ptr2char((char *)arg + 6);
-      arg += utfc_ptr2len((char *)arg + 6) - 1;
+      *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 = (char_u *)skipwhite((char *)arg + 7);
+      arg = skipwhite(arg + 7);
     } else {
       opt->flags |= flagtab[fidx].flags;
-      arg = (char_u *)skipwhite((char *)arg + len);
+      arg = skipwhite(arg + len);
 
       if (flagtab[fidx].flags == HL_SYNC_HERE
           || flagtab[fidx].flags == HL_SYNC_THERE) {
@@ -4183,11 +3917,11 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
         if (gname_start == arg) {
           return NULL;
         }
-        gname = vim_strnsave(gname_start, (size_t)(arg - gname_start));
-        if (STRCMP(gname, "NONE") == 0) {
+        gname = xstrnsave(gname_start, (size_t)(arg - gname_start));
+        if (strcmp(gname, "NONE") == 0) {
           *opt->sync_idx = NONE_IDX;
         } else {
-          syn_id = syn_name2id((char *)gname);
+          syn_id = syn_name2id(gname);
           int i;
           for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0;) {
             if (SYN_ITEMS(curwin->w_s)[i].sp_syn.id == syn_id
@@ -4204,7 +3938,7 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
         }
 
         xfree(gname);
-        arg = (char_u *)skipwhite((char *)arg);
+        arg = skipwhite(arg);
       } else if (flagtab[fidx].flags == HL_FOLD
                  && foldmethodIsSyntax(curwin)) {
         // Need to update folds later.
@@ -4216,11 +3950,9 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
   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.
- */
+// 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) {
@@ -4239,21 +3971,19 @@ static void syn_incl_toplevel(int id, int *flagsp)
   }
 }
 
-/*
- * Handle ":syntax include [@{group-name}] filename" command.
- */
+// Handle ":syntax include [@{group-name}] filename" command.
 static void syn_cmd_include(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
+  char *arg = eap->arg;
   int sgl_id = 1;
-  char_u *group_name_end;
-  char_u *rest;
+  char *group_name_end;
+  char *rest;
   char *errormsg = NULL;
   int prev_toplvl_grp;
   int prev_syn_inc_tag;
   bool source = false;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -4270,13 +4000,11 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
       return;
     }
     // separate_nextcmd() and expand_filename() depend on this
-    eap->arg = (char *)rest;
+    eap->arg = rest;
   }
 
-  /*
-   * Everything that's left, up to the next command, should be the
-   * filename to include.
-   */
+  // 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((char_u *)eap->arg)) {
@@ -4292,10 +4020,8 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
     }
   }
 
-  /*
-   * Save and restore the existing top-level grouplist id and ":syn
-   * include" tag around the actual inclusion.
-   */
+  // 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;
@@ -4313,18 +4039,16 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
   current_syn_inc_tag = prev_syn_inc_tag;
 }
 
-/*
- * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
- */
+// Handle ":syntax keyword {group-name} [{option}] keyword .." command.
 static void syn_cmd_keyword(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
+  char *arg = eap->arg;
+  char *group_name_end;
   int syn_id;
-  char_u *rest;
-  char_u *keyword_copy = NULL;
-  char_u *p;
-  char_u *kw;
+  char *rest;
+  char *keyword_copy = NULL;
+  char *p;
+  char *kw;
   syn_opt_arg_T syn_opt_arg;
   int cnt;
   int conceal_char = NUL;
@@ -4335,11 +4059,11 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
     if (eap->skip) {
       syn_id = -1;
     } else {
-      syn_id = syn_check_group((char *)arg, (size_t)(group_name_end - arg));
+      syn_id = syn_check_group(arg, (size_t)(group_name_end - arg));
     }
     if (syn_id != 0) {
       // Allocate a buffer, for removing backslashes in the keyword.
-      keyword_copy = xmalloc(STRLEN(rest) + 1);
+      keyword_copy = xmalloc(strlen(rest) + 1);
     }
     if (keyword_copy != NULL) {
       syn_opt_arg.flags = 0;
@@ -4354,7 +4078,7 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
       // 1: collect the options and copy the keywords to keyword_copy.
       cnt = 0;
       p = keyword_copy;
-      for (; rest != NULL && !ends_excmd(*rest); rest = (char_u *)skipwhite((char *)rest)) {
+      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;
@@ -4375,8 +4099,8 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
         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 = (char_u *)vim_strchr((char *)kw, '[');;) {
+        for (kw = keyword_copy; --cnt >= 0; kw += strlen(kw) + 1) {
+          for (p = vim_strchr(kw, '[');;) {
             if (p != NULL) {
               *p = NUL;
             }
@@ -4399,7 +4123,7 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
               kw = p + 1;
               break;   // skip over the "]"
             }
-            const int l = utfc_ptr2len((char *)p + 1);
+            const int l = utfc_ptr2len(p + 1);
 
             memmove(p, p + 1, (size_t)l);
             p += l;
@@ -4415,12 +4139,12 @@ error:
   }
 
   if (rest != NULL) {
-    eap->nextcmd = (char *)check_nextcmd(rest);
+    eap->nextcmd = check_nextcmd(rest);
   } else {
     semsg(_(e_invarg2), arg);
   }
 
-  redraw_curbuf_later(SOME_VALID);
+  redraw_curbuf_later(UPD_SOME_VALID);
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
@@ -4428,12 +4152,11 @@ error:
 ///
 /// Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
 ///
-/// @param syncing  TRUE for ":syntax sync match .. "
+/// @param syncing  true for ":syntax sync match .. "
 static void syn_cmd_match(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
-  char_u *rest;
+  char *arg = eap->arg;
+  char *group_name_end;
   synpat_T item;                // the item found in the line
   int syn_id;
   syn_opt_arg_T syn_opt_arg;
@@ -4441,7 +4164,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   int conceal_char = NUL;
 
   // Isolate the group name, check for validity
-  rest = get_group_name(arg, &group_name_end);
+  char *rest = get_group_name(arg, &group_name_end);
 
   // Get options before the pattern
   syn_opt_arg.flags = 0;
@@ -4465,18 +4188,14 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   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 = (char *)check_nextcmd(rest);
+    // 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, (size_t)(group_name_end - arg))) != 0) {
+      if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
-        /*
-         * Store the pattern in the syn_items list
-         */
+        // 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;
@@ -4490,7 +4209,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
         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;
+          curwin->w_s->b_syn_containedin = true;
         }
         spp->sp_next_list = syn_opt_arg.next_list;
 
@@ -4499,19 +4218,17 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
           curwin->w_s->b_syn_sync_flags |= SF_MATCH;
         }
         if (syn_opt_arg.flags & HL_FOLD) {
-          ++curwin->w_s->b_syn_folditems;
+          curwin->w_s->b_syn_folditems++;
         }
 
-        redraw_curbuf_later(SOME_VALID);
+        redraw_curbuf_later(UPD_SOME_VALID);
         syn_stack_free_all(curwin->w_s);          // Need to recompute all syntax.
         return;           // don't free the progs and patterns now
       }
     }
   }
 
-  /*
-   * Something failed, free the allocated memory.
-   */
+  // Something failed, free the allocated memory.
   vim_regfree(item.sp_prog);
   xfree(item.sp_pattern);
   xfree(syn_opt_arg.cont_list);
@@ -4526,15 +4243,15 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
 /// Handle ":syntax region {group-name} [matchgroup={group-name}]
 ///              start {start} .. [skip {skip}] end {end} .. [{options}]".
 ///
-/// @param syncing  TRUE for ":syntax sync region .."
+/// @param syncing  true for ":syntax sync region .."
 static void syn_cmd_region(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)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;
+  char *arg = eap->arg;
+  char *group_name_end;
+  char *rest;                    // next arg, NULL on error
+  char *key_end;
+  char *key = NULL;
+  char *p;
   int item;
 #define ITEM_START          0
 #define ITEM_SKIP           1
@@ -4589,13 +4306,13 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
     }
     xfree(key);
     key = vim_strnsave_up(rest, (size_t)(key_end - rest));
-    if (STRCMP(key, "MATCHGROUP") == 0) {
+    if (strcmp(key, "MATCHGROUP") == 0) {
       item = ITEM_MATCHGROUP;
-    } else if (STRCMP(key, "START") == 0) {
+    } else if (strcmp(key, "START") == 0) {
       item = ITEM_START;
-    } else if (STRCMP(key, "END") == 0) {
+    } else if (strcmp(key, "END") == 0) {
       item = ITEM_END;
-    } else if (STRCMP(key, "SKIP") == 0) {
+    } else if (strcmp(key, "SKIP") == 0) {
       if (pat_ptrs[ITEM_SKIP] != NULL) {  // One skip pattern allowed.
         illegal = true;
         break;
@@ -4604,13 +4321,13 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
     } else {
       break;
     }
-    rest = (char_u *)skipwhite((char *)key_end);
+    rest = skipwhite(key_end);
     if (*rest != '=') {
       rest = NULL;
       semsg(_("E398: Missing '=': %s"), arg);
       break;
     }
-    rest = (char_u *)skipwhite((char *)rest + 1);
+    rest = skipwhite(rest + 1);
     if (*rest == NUL) {
       not_enough = true;
       break;
@@ -4621,19 +4338,17 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
       if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip) {
         matchgroup_id = 0;
       } else {
-        matchgroup_id = syn_check_group((char *)rest, (size_t)(p - rest));
+        matchgroup_id = syn_check_group(rest, (size_t)(p - rest));
         if (matchgroup_id == 0) {
           illegal = true;
           break;
         }
       }
-      rest = (char_u *)skipwhite((char *)p);
+      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).
-       */
+      // 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;
@@ -4671,22 +4386,18 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
   }
 
   if (rest != NULL) {
-    /*
-     * Check for trailing garbage or command.
-     * If OK, add the item.
-     */
-    eap->nextcmd = (char *)check_nextcmd(rest);
+    // 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, (size_t)(group_name_end - arg))) != 0) {
+      if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
-        /*
-         * Store the start/skip/end in the syn_items list
-         */
+        // 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 (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;
@@ -4705,7 +4416,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
               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;
+                curwin->w_s->b_syn_containedin = true;
               }
               SYN_ITEMS(curwin->w_s)[idx].sp_next_list =
                 syn_opt_arg.next_list;
@@ -4713,22 +4424,20 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
             curwin->w_s->b_syn_patterns.ga_len++;
             idx++;
             if (syn_opt_arg.flags & HL_FOLD) {
-              ++curwin->w_s->b_syn_folditems;
+              curwin->w_s->b_syn_folditems++;
             }
           }
         }
 
-        redraw_curbuf_later(SOME_VALID);
+        redraw_curbuf_later(UPD_SOME_VALID);
         syn_stack_free_all(curwin->w_s);  // Need to recompute all syntax.
         success = true;                   // don't free the progs and patterns now
       }
     }
   }
 
-  /*
-   * Free the allocated memory.
-   */
-  for (item = ITEM_START; item <= ITEM_END; ++item) {
+  // 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);
@@ -4771,9 +4480,7 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
   const int16_t *g2;
   int16_t *clstr = NULL;
 
-  /*
-   * Handle degenerate cases.
-   */
+  // Handle degenerate cases.
   if (*clstr2 == NULL) {
     return;
   }
@@ -4809,13 +4516,9 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
     g2 = *clstr2;
     int count = 0;
 
-    /*
-     * First, loop through the lists until one of them is empty.
-     */
+    // First, loop through the lists until one of them is empty.
     while (*g1 && *g2) {
-      /*
-       * We always want to add from the first list.
-       */
+      // We always want to add from the first list.
       if (*g1 < *g2) {
         if (round == 2) {
           clstr[count] = *g1;
@@ -4824,10 +4527,8 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
         g1++;
         continue;
       }
-      /*
-       * We only want to add from the second list if we're adding the
-       * lists.
-       */
+      // 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;
@@ -4840,11 +4541,9 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
       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.
-     */
+    // 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;
@@ -4859,10 +4558,8 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
     }
 
     if (round == 1) {
-      /*
-       * If the group ended up empty, we don't need to allocate any
-       * space for it.
-       */
+      // If the group ended up empty, we don't need to allocate any
+      // space for it.
       if (count == 0) {
         clstr = NULL;
         break;
@@ -4872,24 +4569,22 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
     }
   }
 
-  /*
-   * Finally, put the new list in place.
-   */
+  // 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)
+/// Lookup a syntax cluster name and return its ID.
+/// If it is not found, 0 is returned.
+static int syn_scl_name2id(char *name)
 {
   // Avoid using stricmp() too much, it's slow on some systems
-  char_u *name_u = vim_strsave_up(name);
+  char *name_u = (char *)vim_strsave_up((char_u *)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) {
+        && strcmp(name_u, SYN_CLSTR(curwin->w_s)[i].scl_name_u) == 0) {
       break;
     }
   }
@@ -4897,25 +4592,24 @@ static int syn_scl_name2id(char_u *name)
   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)
+/// Like syn_scl_name2id(), but take a pointer + length argument.
+static int syn_scl_namen2id(char *linep, int len)
 {
-  char_u *name = vim_strnsave(linep, (size_t)len);
+  char *name = xstrnsave(linep, (size_t)len);
   int id = syn_scl_name2id(name);
   xfree(name);
 
   return id;
 }
 
-// Find syntax cluster name in the table and return its ID.
-// The argument is a pointer to the name and the length of the name.
-// If it doesn't exist yet, a new entry is created.
-// Return 0 for failure.
-static int syn_check_cluster(char_u *pp, int len)
+/// Find syntax cluster name in the table and return its ID.
+/// The argument is a pointer to the name and the length of the name.
+/// If it doesn't exist yet, a new entry is created.
+///
+/// @return  0 for failure.
+static int syn_check_cluster(char *pp, int len)
 {
-  char_u *name = vim_strnsave(pp, (size_t)len);
+  char *name = xstrnsave(pp, (size_t)len);
   int id = syn_scl_name2id(name);
   if (id == 0) {                        // doesn't exist yet
     id = syn_add_cluster(name);
@@ -4925,14 +4619,13 @@ static int syn_check_cluster(char_u *pp, int len)
   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)
+/// Add new syntax cluster and return its ID.
+/// "name" must be an allocated string, it will be consumed.
+///
+/// @return  0 for failure.
+static int syn_add_cluster(char *name)
 {
-  /*
-   * First call for this growarray: init growing array.
-   */
+  // 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);
@@ -4948,8 +4641,8 @@ static int syn_add_cluster(char_u *name)
   syn_cluster_T *scp = GA_APPEND_VIA_PTR(syn_cluster_T,
                                          &curwin->w_s->b_syn_clusters);
   CLEAR_POINTER(scp);
-  scp->scl_name = name;
-  scp->scl_name_u = vim_strsave_up(name);
+  scp->scl_name = (char_u *)name;
+  scp->scl_name_u = (char *)vim_strsave_up((char_u *)name);
   scp->scl_list = NULL;
 
   if (STRICMP(name, "Spell") == 0) {
@@ -4962,20 +4655,18 @@ static int syn_add_cluster(char_u *name)
   return len + SYNID_CLUSTER;
 }
 
-/*
- * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
- *              [add={groupname},..] [remove={groupname},..]".
- */
+// Handle ":syntax cluster {cluster-name} [contains={groupname},..]
+//              [add={groupname},..] [remove={groupname},..]".
 static void syn_cmd_cluster(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
-  char_u *rest;
+  char *arg = eap->arg;
+  char *group_name_end;
+  char *rest;
   bool got_clstr = false;
   int opt_len;
   int list_op;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -5021,7 +4712,7 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
     }
 
     if (got_clstr) {
-      redraw_curbuf_later(SOME_VALID);
+      redraw_curbuf_later(UPD_SOME_VALID);
       syn_stack_free_all(curwin->w_s);          // Need to recompute all.
     }
   }
@@ -5034,21 +4725,18 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * On first call for current buffer: Init growing array.
- */
+// 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)
+/// Get one pattern for a ":syntax match" or ":syntax region" command.
+/// Stores the pattern and program in a synpat_T.
+///
+/// @return  a pointer to the next argument, or NULL in case of an error.
+static char *get_syn_pattern(char *arg, synpat_T *ci)
 {
   char *end;
   int *p;
@@ -5060,18 +4748,18 @@ static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
     return NULL;
   }
 
-  end = (char *)skip_regexp(arg + 1, *arg, true, NULL);
-  if (*end != (char)(*arg)) {                       // end delimiter not found
+  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, (size_t)(end - (char *)arg) - 1);
+  ci->sp_pattern = xstrnsave(arg + 1, (size_t)(end - arg) - 1);
 
   // Make 'cpoptions' empty, to avoid the 'l' flag
   cpo_save = p_cpo;
-  p_cpo = "";
-  ci->sp_prog = vim_regcomp((char *)ci->sp_pattern, RE_MAGIC);
+  p_cpo = empty_option;
+  ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC);
   p_cpo = cpo_save;
 
   if (ci->sp_prog == NULL) {
@@ -5080,9 +4768,7 @@ static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
   ci->sp_ic = curwin->w_s->b_syn_ic;
   syn_clear_time(&ci->sp_time);
 
-  /*
-   * Check for a match, highlight or region offset.
-   */
+  // Check for a match, highlight or region offset.
   end++;
   do {
     for (idx = SPO_COUNT; --idx >= 0;) {
@@ -5137,43 +4823,41 @@ static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
     semsg(_("E402: Garbage after pattern: %s"), arg);
     return NULL;
   }
-  return (char_u *)skipwhite(end);
+  return skipwhite(end);
 }
 
-/*
- * Handle ":syntax sync .." command.
- */
+/// Handle ":syntax sync .." command.
 static void syn_cmd_sync(exarg_T *eap, int syncing)
 {
-  char_u *arg_start = (char_u *)eap->arg;
+  char *arg_start = eap->arg;
   char *arg_end;
-  char_u *key = NULL;
-  char_u *next_arg;
+  char *key = NULL;
+  char *next_arg;
   int illegal = false;
   int finished = false;
   char *cpo_save;
 
   if (ends_excmd(*arg_start)) {
-    syn_cmd_list(eap, TRUE);
+    syn_cmd_list(eap, true);
     return;
   }
 
   while (!ends_excmd(*arg_start)) {
-    arg_end = (char *)skiptowhite(arg_start);
-    next_arg = (char_u *)skipwhite(arg_end);
+    arg_end = skiptowhite(arg_start);
+    next_arg = skipwhite(arg_end);
     xfree(key);
-    key = vim_strnsave_up(arg_start, (size_t)(arg_end - (char *)arg_start));
-    if (STRCMP(key, "CCOMMENT") == 0) {
+    key = vim_strnsave_up(arg_start, (size_t)(arg_end - arg_start));
+    if (strcmp(key, "CCOMMENT") == 0) {
       if (!eap->skip) {
         curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
       }
       if (!ends_excmd(*next_arg)) {
-        arg_end = (char *)skiptowhite(next_arg);
+        arg_end = skiptowhite(next_arg);
         if (!eap->skip) {
           curwin->w_s->b_syn_sync_id =
-            (int16_t)syn_check_group((char *)next_arg, (size_t)(arg_end - (char *)next_arg));
+            (int16_t)syn_check_group(next_arg, (size_t)(arg_end - next_arg));
         }
-        next_arg = (char_u *)skipwhite(arg_end);
+        next_arg = skipwhite(arg_end);
       } else if (!eap->skip) {
         curwin->w_s->b_syn_sync_id = (int16_t)syn_name2id("Comment");
       }
@@ -5182,14 +4866,14 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
                || STRNCMP(key, "MAXLINES", 8) == 0
                || STRNCMP(key, "LINEBREAKS", 10) == 0) {
       if (key[4] == 'S') {
-        arg_end = (char *)key + 6;
+        arg_end = key + 6;
       } else if (key[0] == 'L') {
-        arg_end = (char *)key + 11;
+        arg_end = key + 11;
       } else {
-        arg_end = (char *)key + 9;
+        arg_end = key + 9;
       }
       if (arg_end[-1] != '=' || !ascii_isdigit(*arg_end)) {
-        illegal = TRUE;
+        illegal = true;
         break;
       }
       linenr_T n = getdigits_int32(&arg_end, false, 0);
@@ -5202,23 +4886,23 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
           curwin->w_s->b_syn_sync_minlines = n;
         }
       }
-    } else if (STRCMP(key, "FROMSTART") == 0) {
+    } 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) {
+    } 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;
+        finished = true;
         break;
       }
-      arg_end = (char *)skip_regexp(next_arg + 1, *next_arg, true, NULL);
-      if (*arg_end != (char)(*next_arg)) {          // end delimiter not found
+      arg_end = skip_regexp(next_arg + 1, *next_arg, true, NULL);
+      if (*arg_end != *next_arg) {          // end delimiter not found
         illegal = true;
         break;
       }
@@ -5226,14 +4910,14 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
       if (!eap->skip) {
         // store the pattern and compiled regexp program
         curwin->w_s->b_syn_linecont_pat =
-          vim_strnsave(next_arg + 1, (size_t)(arg_end - (char *)next_arg) - 1);
+          xstrnsave(next_arg + 1, (size_t)(arg_end - next_arg) - 1);
         curwin->w_s->b_syn_linecont_ic = curwin->w_s->b_syn_ic;
 
         // Make 'cpoptions' empty, to avoid the 'l' flag
         cpo_save = p_cpo;
-        p_cpo = "";
+        p_cpo = empty_option;
         curwin->w_s->b_syn_linecont_prog =
-          vim_regcomp((char *)curwin->w_s->b_syn_linecont_pat, RE_MAGIC);
+          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);
 
@@ -5243,19 +4927,19 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
           break;
         }
       }
-      next_arg = (char_u *)skipwhite(arg_end + 1);
+      next_arg = skipwhite(arg_end + 1);
     } else {
-      eap->arg = (char *)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);
+      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;
+        illegal = true;
       }
-      finished = TRUE;
+      finished = true;
       break;
     }
     arg_start = next_arg;
@@ -5264,8 +4948,8 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
   if (illegal) {
     semsg(_("E404: Illegal arguments: %s"), arg_start);
   } else if (!finished) {
-    eap->nextcmd = (char *)check_nextcmd(arg_start);
-    redraw_curbuf_later(SOME_VALID);
+    eap->nextcmd = check_nextcmd(arg_start);
+    redraw_curbuf_later(UPD_SOME_VALID);
     syn_stack_free_all(curwin->w_s);            // Need to recompute all syntax.
   }
 }
@@ -5279,7 +4963,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
 /// @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)
+static int get_id_list(char **const arg, const int keylen, int16_t **const list, const bool skip)
 {
   char *p = NULL;
   char *end;
@@ -5296,7 +4980,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
   // 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((char *)(*arg) + keylen);
+    p = skipwhite(*arg + keylen);
     if (*p != '=') {
       semsg(_("E405: Missing equal sign: %s"), *arg);
       break;
@@ -5313,10 +4997,10 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
       for (end = p; *end && !ascii_iswhite(*end) && *end != ','; end++) {}
       char *const name = xmalloc((size_t)(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 (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;
@@ -5345,12 +5029,10 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
         if (skip) {
           id = -1;
         } else {
-          id = syn_check_cluster((char_u *)name + 2, (int)(end - p - 1));
+          id = syn_check_cluster(name + 2, (int)(end - p - 1));
         }
       } else {
-        /*
-         * Handle full group name.
-         */
+        // Handle full group name.
         if (strpbrk(name + 1, "\\.*^$~[") == NULL) {
           id = syn_check_group((name + 1), (size_t)(end - p));
         } else {
@@ -5364,7 +5046,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
             break;
           }
 
-          regmatch.rm_ic = TRUE;
+          regmatch.rm_ic = true;
           id = 0;
           for (int i = highlight_num_groups(); --i >= 0;) {
             if (vim_regexec(&regmatch, (char *)highlight_group_name(i), (colnr_T)0)) {
@@ -5421,7 +5103,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
     }
   }
 
-  *arg = (char_u *)p;
+  *arg = p;
   if (failed || retval == NULL) {
     xfree(retval);
     return FAIL;
@@ -5435,9 +5117,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
   return OK;
 }
 
-/*
- * Make a copy of an ID list.
- */
+// Make a copy of an ID list.
 static int16_t *copy_id_list(const int16_t *const list)
 {
   if (list == NULL) {
@@ -5472,7 +5152,7 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
   static int depth = 0;
   int r;
 
-  // If ssp has a "containedin" list and "cur_si" is in it, return TRUE.
+  // 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
@@ -5486,54 +5166,48 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
                                           &(SYN_ITEMS(syn_block)[cur_si->si_idx].sp_syn),
                                           SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags &
                                           HL_CONTAINED)) {
-      return TRUE;
+      return true;
     }
   }
 
   if (list == NULL) {
-    return FALSE;
+    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 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.
-   */
+  // 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;
+        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;
+        return false;
       }
     } else {
       // CONTAINED: accept all contained groups in the same file
       if (item - SYNID_CONTAINED != ssp->inc_tag || !contained) {
-        return FALSE;
+        return false;
       }
     }
     item = *++list;
-    retval = FALSE;
+    retval = false;
   } else {
-    retval = TRUE;
+    retval = true;
   }
 
-  /*
-   * Return "retval" if id is in the contains list.
-   */
+  // Return "retval" if id is in the contains list.
   while (item != 0) {
     if (item == id) {
       return retval;
@@ -5585,21 +5259,19 @@ static struct subcommand subcommands[] =
   { NULL, NULL }
 };
 
-/*
- * ":syntax".
- * This searches the subcommands[] table for the subcommand name, and calls a
- * syntax_subcommand() function to do the rest.
- */
+/// ":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 = (char_u *)eap->arg;
-  char_u *subcmd_end;
+  char *arg = eap->arg;
+  char *subcmd_end;
 
   syn_cmdlinep = eap->cmdlinep;
 
   // isolate subcommand name
   for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); subcmd_end++) {}
-  char_u *const subcmd_name = vim_strnsave(arg, (size_t)(subcmd_end - arg));
+  char *const subcmd_name = xstrnsave(arg, (size_t)(subcmd_end - arg));
   if (eap->skip) {  // skip error messages for all subcommands
     emsg_skip++;
   }
@@ -5608,8 +5280,8 @@ void ex_syntax(exarg_T *eap)
       semsg(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
       break;
     }
-    if (STRCMP(subcmd_name, (char_u *)subcommands[i].name) == 0) {
-      eap->arg = skipwhite((char *)subcmd_end);
+    if (strcmp(subcmd_name, subcommands[i].name) == 0) {
+      eap->arg = skipwhite(subcmd_end);
       (subcommands[i].func)(eap, false);
       break;
     }
@@ -5622,8 +5294,8 @@ void ex_syntax(exarg_T *eap)
 
 void ex_ownsyntax(exarg_T *eap)
 {
-  char_u *old_value;
-  char_u *new_value;
+  char *old_value;
+  char *new_value;
 
   if (curwin->w_s == &curwin->w_buffer->b_s) {
     curwin->w_s = xcalloc(1, sizeof(synblock_T));
@@ -5640,25 +5312,25 @@ void ex_ownsyntax(exarg_T *eap)
   }
 
   // Save value of b:current_syntax.
-  old_value = get_var_value("b:current_syntax");
+  old_value = (char *)get_var_value("b:current_syntax");
   if (old_value != NULL) {
-    old_value = vim_strsave(old_value);
+    old_value = xstrdup(old_value);
   }
 
   // Apply the "syntax" autocommand event, this finds and loads the syntax file.
   apply_autocmds(EVENT_SYNTAX, eap->arg, curbuf->b_fname, true, curbuf);
 
   // Move value of b:current_syntax to w:current_syntax.
-  new_value = get_var_value("b:current_syntax");
+  new_value = (char *)get_var_value("b:current_syntax");
   if (new_value != NULL) {
-    set_internal_string_var("w:current_syntax", (char *)new_value);
+    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", (char *)old_value);
+    set_internal_string_var("b:current_syntax", old_value);
     xfree(old_value);
   }
 }
@@ -5675,22 +5347,19 @@ static enum {
   EXP_SUBCMD,       // expand ":syn" sub-commands
   EXP_CASE,         // expand ":syn case" arguments
   EXP_SPELL,        // expand ":syn spell" arguments
-  EXP_SYNC,  // expand ":syn sync" arguments
+  EXP_SYNC,         // expand ":syn sync" arguments
+  EXP_CLUSTER,      // expand ":syn list @cluster" arguments
 } expand_what;
 
-/*
- * Reset include_link, include_default, include_none to 0.
- * Called when we are done expanding.
- */
+// 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.
- */
+// 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;
@@ -5698,9 +5367,7 @@ void set_context_in_echohl_cmd(expand_T *xp, const char *arg)
   include_none = 1;
 }
 
-/*
- * Handle command line completion for :syntax command.
- */
+// Handle command line completion for :syntax command.
 void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
 {
   // Default: expand subcommands.
@@ -5712,10 +5379,10 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
 
   // (part of) subcommand already typed
   if (*arg != NUL) {
-    const char *p = (const char *)skiptowhite((const char_u *)arg);
+    const char *p = (const char *)skiptowhite(arg);
     if (*p != NUL) {  // Past first word.
       xp->xp_pattern = skipwhite(p);
-      if (*skiptowhite((char_u *)xp->xp_pattern) != NUL) {
+      if (*skiptowhite(xp->xp_pattern) != NUL) {
         xp->xp_context = EXPAND_NOTHING;
       } else if (STRNICMP(arg, "case", p - arg) == 0) {
         expand_what = EXP_CASE;
@@ -5723,10 +5390,16 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
         expand_what = EXP_SPELL;
       } else if (STRNICMP(arg, "sync", p - arg) == 0) {
         expand_what = EXP_SYNC;
+      } else if (STRNICMP(arg, "list", p - arg) == 0) {
+        p = skipwhite(p);
+        if (*p == '@') {
+          expand_what = EXP_CLUSTER;
+        } else {
+          xp->xp_context = EXPAND_HIGHLIGHT;
+        }
       } else if (STRNICMP(arg, "keyword", p - arg) == 0
                  || STRNICMP(arg, "region", p - arg) == 0
-                 || STRNICMP(arg, "match", p - arg) == 0
-                 || STRNICMP(arg, "list", p - arg) == 0) {
+                 || STRNICMP(arg, "match", p - arg) == 0) {
         xp->xp_context = EXPAND_HIGHLIGHT;
       } else {
         xp->xp_context = EXPAND_NOTHING;
@@ -5735,10 +5408,8 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
   }
 }
 
-/*
- * Function given to ExpandGeneric() to obtain the list syntax names for
- * expansion.
- */
+// Function given to ExpandGeneric() to obtain the list syntax names for
+// expansion.
 char *get_syntax_name(expand_T *xp, int idx)
 {
   switch (expand_what) {
@@ -5760,6 +5431,14 @@ char *get_syntax_name(expand_T *xp, int idx)
       "maxlines=", "minlines=", "region", NULL };
     return sync_args[idx];
   }
+  case EXP_CLUSTER:
+    if (idx < curwin->w_s->b_syn_clusters.ga_len) {
+      vim_snprintf(xp->xp_buf, EXPAND_BUF_LEN, "@%s",
+                   SYN_CLSTR(curwin->w_s)[idx].scl_name);
+      return xp->xp_buf;
+    } else {
+      return NULL;
+    }
   }
   return NULL;
 }
@@ -5786,12 +5465,10 @@ int syn_get_id(win_T *wp, linenr_T lnum, colnr_T col, int trans, bool *spellp, i
   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.
- */
+// 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;
@@ -5815,24 +5492,20 @@ int syn_get_concealed_id(win_T *wp, linenr_T lnum, colnr_T col)
   return 0;
 }
 
-/*
- * Return conceal substitution character
- */
+// 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.
- */
+// 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.
+    // for the last character, "keep_state" was true.
     invalidate_current_state();
     current_col = MAXCOL;
     return -1;
@@ -5890,18 +5563,16 @@ int syn_get_foldlevel(win_T *wp, linenr_T lnum)
   return level;
 }
 
-/*
- * ":syntime".
- */
+// ":syntime".
 void ex_syntime(exarg_T *eap)
 {
-  if (STRCMP(eap->arg, "on") == 0) {
+  if (strcmp(eap->arg, "on") == 0) {
     syn_time_on = true;
-  } else if (STRCMP(eap->arg, "off") == 0) {
+  } else if (strcmp(eap->arg, "off") == 0) {
     syn_time_on = false;
-  } else if (STRCMP(eap->arg, "clear") == 0) {
+  } else if (strcmp(eap->arg, "clear") == 0) {
     syntime_clear();
-  } else if (STRCMP(eap->arg, "report") == 0) {
+  } else if (strcmp(eap->arg, "report") == 0) {
     syntime_report();
   } else {
     semsg(_(e_invarg2), eap->arg);
@@ -5916,9 +5587,7 @@ static void syn_clear_time(syn_time_T *st)
   st->match = 0;
 }
 
-/*
- * Clear the syntax timing for the current buffer.
- */
+// Clear the syntax timing for the current buffer.
 static void syntime_clear(void)
 {
   synpat_T *spp;
@@ -5927,16 +5596,14 @@ static void syntime_clear(void)
     msg(_(msg_no_items));
     return;
   }
-  for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; ++idx) {
+  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.
- */
+// Function given to ExpandGeneric() to obtain the possible arguments of the
+// ":syntime {on,off,clear,report}" command.
 char *get_syntime_arg(expand_T *xp, int idx)
 {
   switch (idx) {
@@ -5960,9 +5627,7 @@ static int syn_compare_syntime(const void *v1, const void *v2)
   return profile_cmp(s1->total, s2->total);
 }
 
-/*
- * Clear the syntax timing for the current buffer.
- */
+// Clear the syntax timing for the current buffer.
 static void syntime_report(void)
 {
   if (!syntax_present(curwin)) {
@@ -5976,7 +5641,7 @@ static void syntime_report(void)
   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) {
+  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);
@@ -5989,7 +5654,7 @@ static void syntime_report(void)
       proftime_T tm = profile_divide(spp->sp_time.total, (int)spp->sp_time.count);
       p->average = tm;
       p->id = spp->sp_syn.id;
-      p->pattern = spp->sp_pattern;
+      p->pattern = (char_u *)spp->sp_pattern;
     }
   }
 
@@ -6002,7 +5667,7 @@ static void syntime_report(void)
 
   msg_puts_title(_("  TOTAL      COUNT  MATCH   SLOWEST     AVERAGE   NAME               PATTERN"));
   msg_puts("\n");
-  for (int idx = 0; idx < ga.ga_len && !got_int; ++idx) {
+  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));
@@ -6033,7 +5698,7 @@ static void syntime_report(void)
     if (len > (int)STRLEN(p->pattern)) {
       len = (int)STRLEN(p->pattern);
     }
-    msg_outtrans_len(p->pattern, len);
+    msg_outtrans_len((char *)p->pattern, len);
     msg_puts("\n");
   }
   ga_clear(&ga);