viml/parser/expressions: Add support for string parsing

8 files changed, 1938 insertions, 13 deletions

diff --git a/src/nvim/mbyte.h b/src/nvim/mbyte.h
index bf6ccb13a5..fce600d0a9 100644
--- a/src/nvim/mbyte.h
+++ b/src/nvim/mbyte.h
@@ -73,6 +73,8 @@ typedef struct {
 
 extern const uint8_t utf8len_tab_zero[256];
 
+extern const uint8_t utf8len_tab[256];
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "mbyte.h.generated.h"
 #endif
diff --git a/src/nvim/viml/parser/expressions.c b/src/nvim/viml/parser/expressions.c
index 0613cc66d5..3f30fe2a0e 100644
--- a/src/nvim/viml/parser/expressions.c
+++ b/src/nvim/viml/parser/expressions.c
@@ -915,8 +915,6 @@ static inline void viml_pexpr_debug_print_token(
 //
 // NVimIdentifierKey -> Identifier
 //
-// NVimFigureBrace -> NVimInternalError
-//
 // NVimUnaryPlus -> NVimUnaryOperator
 // NVimBinaryPlus -> NVimBinaryOperator
 // NVimConcat -> NVimBinaryOperator
@@ -929,6 +927,18 @@ static inline void viml_pexpr_debug_print_token(
 // NVimNestingParenthesis -> NVimParenthesis
 // NVimCallingParenthesis -> NVimParenthesis
 //
+// NVimString -> String
+// NVimStringSpecial -> SpecialChar
+// NVimSingleQuote -> NVimString
+// NVimSingleQuotedBody -> NVimString
+// NVimSingleQuotedQuote -> NVimStringSpecial
+// NVimDoubleQuote -> NVimString
+// NVimDoubleQuotedBody -> NVimString
+// NVimDoubleQuotedEscape -> NVimStringSpecial
+// NVimDoubleQuotedUnknownEscape -> NVimInvalid
+//
+// " Note: NVimDoubleQuotedUnknownEscape is not actually invalid
+//
 // NVimInvalidComma -> NVimInvalidDelimiter
 // NVimInvalidSpacing -> NVimInvalid
 // NVimInvalidTernary -> NVimInvalidOperator
@@ -952,6 +962,19 @@ static inline void viml_pexpr_debug_print_token(
 // NVimInvalidList -> NVimInvalidDelimiter
 // NVimInvalidSubscript -> NVimInvalidDelimiter
 // NVimInvalidSubscriptColon -> NVimInvalidSubscript
+// NVimInvalidString -> NVimInvalidValue
+// NVimInvalidStringSpecial -> NVimInvalidString
+// NVimInvalidSingleQuote -> NVimInvalidString
+// NVimInvalidSingleQuotedBody -> NVimInvalidString
+// NVimInvalidSingleQuotedQuote -> NVimInvalidStringSpecial
+// NVimInvalidDoubleQuote -> NVimInvalidString
+// NVimInvalidDoubleQuotedBody -> NVimInvalidString
+// NVimInvalidDoubleQuotedEscape -> NVimInvalidStringSpecial
+// NVimInvalidDoubleQuotedUnknownEscape -> NVimInvalid
+//
+// NVimFigureBrace -> NVimInternalError
+// NVimInvalidSingleQuotedUnknownEscape -> NVimInternalError
+// NVimSingleQuotedUnknownEscape -> NVimInternalError
 
 /// Allocate a new node and set some of the values
 ///
@@ -1402,6 +1425,318 @@ static inline void east_set_error(const ParserState *const pstate,
       } \
     } while (0)
 
+/// Structure used to define “string shifts” necessary to map string
+/// highlighting to actual strings.
+typedef struct {
+  size_t start;  ///< Where special character starts in original string.
+  size_t orig_len;  ///< Length of orininal string (e.g. 4 for "\x80").
+  size_t act_len;  ///< Length of resulting character(s) (e.g. 1 for "\x80").
+  bool escape_not_known;  ///< True if escape sequence in original is not known.
+} StringShift;
+
+/// Parse and highlight single- or double-quoted string
+///
+/// Function is supposed to detect and highlight regular expressions (but does
+/// not do now).
+///
+/// @param[out]  pstate  Parser state which also contains a place where
+///                      highlighting is saved.
+/// @param[out]  node  Node where string parsing results are saved.
+/// @param[in]  token  Token to highlight.
+/// @param[in]  ast_stack  Parser AST stack, used to detect whether current
+///                        string is a regex.
+/// @param[in]  is_invalid  Whether currently processed token is not valid.
+static void parse_quoted_string(ParserState *const pstate,
+                                ExprASTNode *const node,
+                                const LexExprToken token,
+                                const ExprASTStack ast_stack,
+                                const bool is_invalid)
+  FUNC_ATTR_NONNULL_ALL
+{
+  const ParserLine pline = pstate->reader.lines.items[token.start.line];
+  const char *const s = pline.data + token.start.col;
+  const char *const e = s + token.len - token.data.str.closed;
+  const char *p = s + 1;
+  const bool is_double = (token.type == kExprLexDoubleQuotedString);
+  size_t size = token.len - token.data.str.closed - 1;
+  kvec_withinit_t(StringShift, 16) shifts;
+  kvi_init(shifts);
+  if (!is_double) {
+    viml_parser_highlight(pstate, token.start, 1, HL(SingleQuotedString));
+    while (p < e) {
+      const char *const chunk_e = memchr(p, '\'', (size_t)(e - p));
+      if (chunk_e == NULL) {
+        break;
+      }
+      size--;
+      p = chunk_e + 2;
+      if (pstate->colors) {
+        kvi_push(shifts, ((StringShift) {
+            .start = token.start.col + (size_t)(chunk_e - s),
+            .orig_len = 2,
+            .act_len = 1,
+            .escape_not_known = false,
+        }));
+      }
+    }
+    node->data.str.size = size;
+    if (size == 0) {
+      node->data.str.value = NULL;
+    } else {
+      char *v_p;
+      v_p = node->data.str.value = xmalloc(size);
+      p = s + 1;
+      while (p < e) {
+        const char *const chunk_e = memchr(p, '\'', (size_t)(e - p));
+        if (chunk_e == NULL) {
+          memcpy(v_p, p, (size_t)(e - p));
+          break;
+        }
+        memcpy(v_p, p, (size_t)(chunk_e - p));
+        v_p += (size_t)(chunk_e - p) + 1;
+        v_p[-1] = '\'';
+        p = chunk_e + 2;
+      }
+    }
+  } else {
+    viml_parser_highlight(pstate, token.start, 1, HL(DoubleQuotedString));
+    for (p = s + 1; p < e; p++) {
+      if (*p == '\\' && p + 1 < e) {
+        p++;
+        if (p + 1 == e) {
+          size--;
+          break;
+        }
+        switch (*p) {
+          // A "\<x>" form occupies at least 4 characters, and produces up to
+          // 6 characters: reserve space for 2 extra, but do not compute actual
+          // length just now, it would be costy.
+          case '<': {
+            size += 2;
+            break;
+          }
+          // Hexadecimal, always single byte, but at least three bytes each.
+          case 'x': case 'X': {
+            size--;
+            if (ascii_isxdigit(p[1])) {
+              size--;
+              if (p + 2 < e && ascii_isxdigit(p[2])) {
+                size--;
+              }
+            }
+            break;
+          }
+          // Unicode
+          //
+          // \uF takes 1 byte which is 2 bytes less then escape sequence.
+          // \uFF: 2 bytes, 2 bytes less.
+          // \uFFF: 3 bytes, 2 bytes less.
+          // \uFFFF: 3 bytes, 3 bytes less.
+          // \UFFFFF: 4 bytes, 3 bytes less.
+          // \UFFFFFF: 5 bytes, 3 bytes less.
+          // \UFFFFFFF: 6 bytes, 3 bytes less.
+          // \U7FFFFFFF: 6 bytes, 4 bytes less.
+          case 'u': case 'U': {
+            const char *const esc_start = p;
+            size_t n = (*p == 'u' ? 4 : 8);
+            int nr = 0;
+            p++;
+            while (n-- && ascii_isxdigit(p[1])) {
+              p++;
+              nr = (nr << 4) + hex2nr(*p);
+            }
+            // Escape length: (esc_start - 1) points to "\\", esc_start to "u"
+            // or "U", p to the byte after last byte. So escape sequence
+            // occupies p - (esc_start - 1), but it stands for a utf_char2len
+            // bytes.
+            size -= (size_t)((p - (esc_start - 1)) - utf_char2len(nr));
+            p--;
+            break;
+          }
+          // Octal, always single byte, but at least two bytes each.
+          case '0': case '1': case '2': case '3': case '4': case '5': case '6':
+          case '7': {
+            size--;
+            p++;
+            if (*p >= '0' && *p <= '7') {
+              size--;
+              p++;
+              if (*p >= '0' && *p <= '7') {
+                size--;
+                p++;
+              }
+            }
+            break;
+          }
+          default: {
+            size--;
+            break;
+          }
+        }
+      }
+    }
+    if (size == 0) {
+      node->data.str.value = NULL;
+      node->data.str.size = 0;
+    } else {
+      char *v_p;
+      v_p = node->data.str.value = xmalloc(size);
+      p = s + 1;
+      while (p < e) {
+        const char *const chunk_e = memchr(p, '\\', (size_t)(e - p));
+        if (chunk_e == NULL) {
+          memcpy(v_p, p, (size_t)(e - p));
+          v_p += e - p;
+          break;
+        }
+        memcpy(v_p, p, (size_t)(chunk_e - p));
+        v_p += (size_t)(chunk_e - p);
+        p = chunk_e + 1;
+        if (p == e) {
+          *v_p++ = '\\';
+          break;
+        }
+        bool is_unknown = false;
+        const char *const v_p_start = v_p;
+        switch (*p) {
+#define SINGLE_CHAR_ESC(ch, real_ch) \
+          case ch: { \
+            *v_p++ = real_ch; \
+            p++; \
+            break; \
+          }
+          SINGLE_CHAR_ESC('b', BS)
+          SINGLE_CHAR_ESC('e', ESC)
+          SINGLE_CHAR_ESC('f', FF)
+          SINGLE_CHAR_ESC('n', NL)
+          SINGLE_CHAR_ESC('r', CAR)
+          SINGLE_CHAR_ESC('t', TAB)
+          SINGLE_CHAR_ESC('"', '"')
+          SINGLE_CHAR_ESC('\\', '\\')
+#undef SINGLE_CHAR_ESC
+
+          // Hexadecimal or unicode.
+          case 'X': case 'x': case 'u': case 'U': {
+            if (ascii_isxdigit(p[1])) {
+              size_t n;
+              int nr;
+              bool is_hex = (*p == 'x' || *p == 'X');
+
+              if (is_hex) {
+                n = 2;
+              } else if (*p == 'u') {
+                n = 4;
+              } else {
+                n = 8;
+              }
+              nr = 0;
+              while (n-- && ascii_isxdigit(p[1])) {
+                p++;
+                nr = (nr << 4) + hex2nr(*p);
+              }
+              p++;
+              if (is_hex) {
+                *v_p++ = (char)nr;
+              } else {
+                v_p += utf_char2bytes(nr, (char_u *)v_p);
+              }
+            } else {
+              is_unknown = true;
+              *v_p++ = *p;
+              p++;
+            }
+            break;
+          }
+          // Octal: "\1", "\12", "\123".
+          case '0': case '1': case '2': case '3': case '4': case '5': case '6':
+          case '7': {
+            uint8_t ch = (uint8_t)(*p++ - '0');
+            if (*p >= '0' && *p <= '7') {
+              ch = (uint8_t)((ch << 3) + *p++ - '0');
+              if (*p >= '0' && *p <= '7') {
+                ch = (uint8_t)((ch << 3) + *p++ - '0');
+              }
+            }
+            *v_p++ = (char)ch;
+            break;
+          }
+          // Special key, e.g.: "\<C-W>"
+          case '<': {
+            const size_t special_len = (
+                trans_special((const char_u **)&p, (size_t)(e - p),
+                              (char_u *)v_p, true, true));
+            if (special_len != 0) {
+              v_p += special_len;
+            } else {
+              is_unknown = true;
+              mb_copy_char((const char_u **)&p, (char_u **)&v_p);
+            }
+            break;
+          }
+          default: {
+            is_unknown = true;
+            mb_copy_char((const char_u **)&p, (char_u **)&v_p);
+            break;
+          }
+        }
+        if (pstate->colors) {
+          kvi_push(shifts, ((StringShift) {
+              .start = token.start.col + (size_t)(chunk_e - s),
+              .orig_len = (size_t)(p - chunk_e),
+              .act_len = (size_t)(v_p - (char *)v_p_start),
+              .escape_not_known = is_unknown,
+          }));
+        }
+      }
+      node->data.str.size = (size_t)(v_p - node->data.str.value);
+    }
+  }
+  if (pstate->colors) {
+    // TODO(ZyX-I): use ast_stack to determine and highlight regular expressions
+    // TODO(ZyX-I): use ast_stack to determine and highlight printf format str
+    // TODO(ZyX-I): use ast_stack to determine and highlight expression strings
+    size_t next_col = 1;
+    const char *const body_str = (is_double
+                                  ? HL(DoubleQuotedBody)
+                                  : HL(SingleQuotedBody));
+    const char *const esc_str = (is_double
+                                 ? HL(DoubleQuotedEscape)
+                                 : HL(SingleQuotedQuote));
+    const char *const ukn_esc_str = (is_double
+                                     ? HL(DoubleQuotedUnknownEscape)
+                                     : HL(SingleQuotedUnknownEscape));
+    for (size_t i = 0; i < kv_size(shifts); i++) {
+      const StringShift cur_shift = kv_A(shifts, i);
+      if (cur_shift.start > next_col) {
+        viml_parser_highlight(pstate, shifted_pos(token.start, next_col),
+                              cur_shift.start - next_col,
+                              body_str);
+      }
+      viml_parser_highlight(pstate, shifted_pos(token.start, cur_shift.start),
+                            cur_shift.orig_len,
+                            (cur_shift.escape_not_known
+                             ? ukn_esc_str
+                             : esc_str));
+      next_col = cur_shift.start + cur_shift.orig_len;
+    }
+    if (next_col < token.len - token.data.str.closed) {
+      viml_parser_highlight(pstate, shifted_pos(token.start, next_col),
+                            token.len - token.data.str.closed - next_col,
+                            body_str);
+    }
+  }
+  if (token.data.str.closed) {
+    if (is_double) {
+      viml_parser_highlight(pstate, shifted_pos(token.start, token.len - 1),
+                            1, HL(DoubleQuotedString));
+    } else {
+      viml_parser_highlight(pstate, shifted_pos(token.start, token.len - 1),
+                            1, HL(SingleQuotedString));
+    }
+  }
+  kvi_destroy(shifts);
+}
+
 /// Parse one VimL expression
 ///
 /// @param  pstate  Parser state.
@@ -1714,12 +2049,7 @@ viml_pexpr_parse_invalid_comma:
           } else if (eastnode_lvl >= kEOpLvlComma) {
             can_be_ternary = false;
           } else {
-viml_pexpr_parse_invalid_colon:
-            ERROR_FROM_TOKEN_AND_MSG(
-                cur_token,
-                _("E15: Colon outside of dictionary or ternary operator: "
-                  "%.*s"));
-            break;
+            goto viml_pexpr_parse_invalid_colon;
           }
           if (i == kv_size(ast_stack) - 1) {
             goto viml_pexpr_parse_invalid_colon;
@@ -1741,6 +2071,12 @@ viml_pexpr_parse_invalid_colon:
           ADD_OP_NODE(cur_node);
           HL_CUR_TOKEN(SubscriptColon);
         } else {
+          goto viml_pexpr_parse_valid_colon;
+viml_pexpr_parse_invalid_colon:
+          ERROR_FROM_TOKEN_AND_MSG(
+              cur_token,
+              _("E15: Colon outside of dictionary or ternary operator: %.*s"));
+viml_pexpr_parse_valid_colon:
           ADD_VALUE_IF_MISSING(_(EXP_VAL_COLON));
           NEW_NODE_WITH_CUR_POS(cur_node, kExprNodeColon);
           if (is_ternary) {
@@ -2201,6 +2537,30 @@ viml_pexpr_parse_no_paren_closing_error: {}
         kvi_push(ast_stack, &ter_val_node->children);
         break;
       }
+      case kExprLexDoubleQuotedString:
+      case kExprLexSingleQuotedString: {
+        const bool is_double = (tok_type == kExprLexDoubleQuotedString);
+        if (!cur_token.data.str.closed) {
+          // It is weird, but Vim has two identical errors messages with
+          // different error numbers: "E114: Missing quote" and
+          // "E115: Missing quote".
+          ERROR_FROM_TOKEN_AND_MSG(
+              cur_token, (is_double
+                          ? _("E114: Missing double quote: %.*s")
+                          : _("E115: Missing single quote: %.*s")));
+        }
+        if (want_node == kENodeOperator) {
+          OP_MISSING;
+        }
+        NEW_NODE_WITH_CUR_POS(
+            cur_node, (is_double
+                       ? kExprNodeDoubleQuotedString
+                       : kExprNodeSingleQuotedString));
+        *top_node_p = cur_node;
+        parse_quoted_string(pstate, cur_node, cur_token, ast_stack, is_invalid);
+        want_node = kENodeOperator;
+        break;
+      }
     }
 viml_pexpr_parse_cycle_end:
     prev_token = cur_token;
diff --git a/src/nvim/viml/parser/expressions.h b/src/nvim/viml/parser/expressions.h
index 0d496c87ba..a09cdde4c0 100644
--- a/src/nvim/viml/parser/expressions.h
+++ b/src/nvim/viml/parser/expressions.h
@@ -195,6 +195,8 @@ typedef enum {
   kExprNodeConcatOrSubscript = 'S',
   kExprNodeInteger = '0',  ///< Integral number.
   kExprNodeFloat = '1',  ///< Floating-point number.
+  kExprNodeSingleQuotedString = '\'',
+  kExprNodeDoubleQuotedString = '"',
 } ExprASTNodeType;
 
 typedef struct expr_ast_node ExprASTNode;
@@ -249,6 +251,11 @@ struct expr_ast_node {
     struct {
       float_T value;
     } flt;  ///< For kExprNodeFloat.
+    struct {
+      char *value;
+      size_t size;
+    } str;  ///< For kExprNodeSingleQuotedString and
+            ///< kExprNodeDoubleQuotedString.
   } data;
 };
 
diff --git a/test/helpers.lua b/test/helpers.lua
index d5356416af..e7d8c185ba 100644
--- a/test/helpers.lua
+++ b/test/helpers.lua
@@ -330,9 +330,10 @@ format_luav = function(v, indent)
   end
   local ret = ''
   if type(v) == 'string' then
-    ret = '\'' .. tostring(v):gsub('[\'\\]', '\\%0'):gsub('[%z\1-\31]', function(match)
-      return SUBTBL[match:byte()]
-    end) .. '\''
+    ret = tostring(v):gsub('[\'\\]', '\\%0'):gsub('[%z\1-\31]', function(match)
+      return SUBTBL[match:byte() + 1]
+    end)
+    ret = '\'' .. ret .. '\''
   elseif type(v) == 'table' then
     local processed_keys = {}
     ret = '{' .. linesep
diff --git a/test/symbolic/klee/nvim/keymap.c b/test/symbolic/klee/nvim/keymap.c
new file mode 100644
index 0000000000..c59d8d4d6e
--- /dev/null
+++ b/test/symbolic/klee/nvim/keymap.c
@@ -0,0 +1,540 @@
+#include <stdbool.h>
+
+#include "nvim/types.h"
+#include "nvim/keymap.h"
+#include "nvim/eval/typval.h"
+
+#define MOD_KEYS_ENTRY_SIZE 5
+
+static char_u modifier_keys_table[] =
+{
+  MOD_MASK_SHIFT, '&', '9',                   '@', '1',
+  MOD_MASK_SHIFT, '&', '0',                   '@', '2',
+  MOD_MASK_SHIFT, '*', '1',                   '@', '4',
+  MOD_MASK_SHIFT, '*', '2',                   '@', '5',
+  MOD_MASK_SHIFT, '*', '3',                   '@', '6',
+  MOD_MASK_SHIFT, '*', '4',                   'k', 'D',
+  MOD_MASK_SHIFT, '*', '5',                   'k', 'L',
+  MOD_MASK_SHIFT, '*', '7',                   '@', '7',
+  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_END,    '@', '7',
+  MOD_MASK_SHIFT, '*', '9',                   '@', '9',
+  MOD_MASK_SHIFT, '*', '0',                   '@', '0',
+  MOD_MASK_SHIFT, '#', '1',                   '%', '1',
+  MOD_MASK_SHIFT, '#', '2',                   'k', 'h',
+  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_HOME,   'k', 'h',
+  MOD_MASK_SHIFT, '#', '3',                   'k', 'I',
+  MOD_MASK_SHIFT, '#', '4',                   'k', 'l',
+  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_LEFT,   'k', 'l',
+  MOD_MASK_SHIFT, '%', 'a',                   '%', '3',
+  MOD_MASK_SHIFT, '%', 'b',                   '%', '4',
+  MOD_MASK_SHIFT, '%', 'c',                   '%', '5',
+  MOD_MASK_SHIFT, '%', 'd',                   '%', '7',
+  MOD_MASK_SHIFT, '%', 'e',                   '%', '8',
+  MOD_MASK_SHIFT, '%', 'f',                   '%', '9',
+  MOD_MASK_SHIFT, '%', 'g',                   '%', '0',
+  MOD_MASK_SHIFT, '%', 'h',                   '&', '3',
+  MOD_MASK_SHIFT, '%', 'i',                   'k', 'r',
+  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_RIGHT,  'k', 'r',
+  MOD_MASK_SHIFT, '%', 'j',                   '&', '5',
+  MOD_MASK_SHIFT, '!', '1',                   '&', '6',
+  MOD_MASK_SHIFT, '!', '2',                   '&', '7',
+  MOD_MASK_SHIFT, '!', '3',                   '&', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP,     'k', 'u',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN,   'k', 'd',
+
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1,    KS_EXTRA, (int)KE_XF1,
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2,    KS_EXTRA, (int)KE_XF2,
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3,    KS_EXTRA, (int)KE_XF3,
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4,    KS_EXTRA, (int)KE_XF4,
+
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1,     'k', '1',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2,     'k', '2',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3,     'k', '3',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4,     'k', '4',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5,     'k', '5',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6,     'k', '6',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7,     'k', '7',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8,     'k', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9,     'k', '9',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10,    'k', ';',
+
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11,    'F', '1',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12,    'F', '2',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13,    'F', '3',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14,    'F', '4',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15,    'F', '5',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16,    'F', '6',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17,    'F', '7',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18,    'F', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19,    'F', '9',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20,    'F', 'A',
+
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21,    'F', 'B',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22,    'F', 'C',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23,    'F', 'D',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24,    'F', 'E',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25,    'F', 'F',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26,    'F', 'G',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27,    'F', 'H',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28,    'F', 'I',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29,    'F', 'J',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30,    'F', 'K',
+
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31,    'F', 'L',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32,    'F', 'M',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33,    'F', 'N',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34,    'F', 'O',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35,    'F', 'P',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36,    'F', 'Q',
+  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37,    'F', 'R',
+
+  MOD_MASK_SHIFT, 'k', 'B',                   KS_EXTRA, (int)KE_TAB,
+
+  NUL
+};
+
+int simplify_key(const int key, int *modifiers)
+{
+  if (*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) {
+    // TAB is a special case.
+    if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) {
+      *modifiers &= ~MOD_MASK_SHIFT;
+      return K_S_TAB;
+    }
+    const int key0 = KEY2TERMCAP0(key);
+    const int key1 = KEY2TERMCAP1(key);
+    for (int i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) {
+      if (key0 == modifier_keys_table[i + 3]
+          && key1 == modifier_keys_table[i + 4]
+          && (*modifiers & modifier_keys_table[i])) {
+        *modifiers &= ~modifier_keys_table[i];
+        return TERMCAP2KEY(modifier_keys_table[i + 1],
+                           modifier_keys_table[i + 2]);
+      }
+    }
+  }
+  return key;
+}
+
+int handle_x_keys(const int key)
+  FUNC_ATTR_CONST FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  switch (key) {
+    case K_XUP:     return K_UP;
+    case K_XDOWN:   return K_DOWN;
+    case K_XLEFT:   return K_LEFT;
+    case K_XRIGHT:  return K_RIGHT;
+    case K_XHOME:   return K_HOME;
+    case K_ZHOME:   return K_HOME;
+    case K_XEND:    return K_END;
+    case K_ZEND:    return K_END;
+    case K_XF1:     return K_F1;
+    case K_XF2:     return K_F2;
+    case K_XF3:     return K_F3;
+    case K_XF4:     return K_F4;
+    case K_S_XF1:   return K_S_F1;
+    case K_S_XF2:   return K_S_F2;
+    case K_S_XF3:   return K_S_F3;
+    case K_S_XF4:   return K_S_F4;
+  }
+  return key;
+}
+
+static const struct key_name_entry {
+  int key;  ///< Special key code or ASCII value.
+  const char *name;  ///< Name of the key
+} key_names_table[] = {
+  {' ',               "Space"},
+  {TAB,               "Tab"},
+  {K_TAB,             "Tab"},
+  {NL,                "NL"},
+  {NL,                "NewLine"},     // Alternative name
+  {NL,                "LineFeed"},    // Alternative name
+  {NL,                "LF"},          // Alternative name
+  {CAR,               "CR"},
+  {CAR,               "Return"},      // Alternative name
+  {CAR,               "Enter"},       // Alternative name
+  {K_BS,              "BS"},
+  {K_BS,              "BackSpace"},   // Alternative name
+  {ESC,               "Esc"},
+  {CSI,               "CSI"},
+  {K_CSI,             "xCSI"},
+  {'|',               "Bar"},
+  {'\\',              "Bslash"},
+  {K_DEL,             "Del"},
+  {K_DEL,             "Delete"},      // Alternative name
+  {K_KDEL,            "kDel"},
+  {K_UP,              "Up"},
+  {K_DOWN,            "Down"},
+  {K_LEFT,            "Left"},
+  {K_RIGHT,           "Right"},
+  {K_XUP,             "xUp"},
+  {K_XDOWN,           "xDown"},
+  {K_XLEFT,           "xLeft"},
+  {K_XRIGHT,          "xRight"},
+
+  {K_F1,              "F1"},
+  {K_F2,              "F2"},
+  {K_F3,              "F3"},
+  {K_F4,              "F4"},
+  {K_F5,              "F5"},
+  {K_F6,              "F6"},
+  {K_F7,              "F7"},
+  {K_F8,              "F8"},
+  {K_F9,              "F9"},
+  {K_F10,             "F10"},
+
+  {K_F11,             "F11"},
+  {K_F12,             "F12"},
+  {K_F13,             "F13"},
+  {K_F14,             "F14"},
+  {K_F15,             "F15"},
+  {K_F16,             "F16"},
+  {K_F17,             "F17"},
+  {K_F18,             "F18"},
+  {K_F19,             "F19"},
+  {K_F20,             "F20"},
+
+  {K_F21,             "F21"},
+  {K_F22,             "F22"},
+  {K_F23,             "F23"},
+  {K_F24,             "F24"},
+  {K_F25,             "F25"},
+  {K_F26,             "F26"},
+  {K_F27,             "F27"},
+  {K_F28,             "F28"},
+  {K_F29,             "F29"},
+  {K_F30,             "F30"},
+
+  {K_F31,             "F31"},
+  {K_F32,             "F32"},
+  {K_F33,             "F33"},
+  {K_F34,             "F34"},
+  {K_F35,             "F35"},
+  {K_F36,             "F36"},
+  {K_F37,             "F37"},
+
+  {K_XF1,             "xF1"},
+  {K_XF2,             "xF2"},
+  {K_XF3,             "xF3"},
+  {K_XF4,             "xF4"},
+
+  {K_HELP,            "Help"},
+  {K_UNDO,            "Undo"},
+  {K_INS,             "Insert"},
+  {K_INS,             "Ins"},         // Alternative name
+  {K_KINS,            "kInsert"},
+  {K_HOME,            "Home"},
+  {K_KHOME,           "kHome"},
+  {K_XHOME,           "xHome"},
+  {K_ZHOME,           "zHome"},
+  {K_END,             "End"},
+  {K_KEND,            "kEnd"},
+  {K_XEND,            "xEnd"},
+  {K_ZEND,            "zEnd"},
+  {K_PAGEUP,          "PageUp"},
+  {K_PAGEDOWN,        "PageDown"},
+  {K_KPAGEUP,         "kPageUp"},
+  {K_KPAGEDOWN,       "kPageDown"},
+
+  {K_KPLUS,           "kPlus"},
+  {K_KMINUS,          "kMinus"},
+  {K_KDIVIDE,         "kDivide"},
+  {K_KMULTIPLY,       "kMultiply"},
+  {K_KENTER,          "kEnter"},
+  {K_KPOINT,          "kPoint"},
+
+  {K_K0,              "k0"},
+  {K_K1,              "k1"},
+  {K_K2,              "k2"},
+  {K_K3,              "k3"},
+  {K_K4,              "k4"},
+  {K_K5,              "k5"},
+  {K_K6,              "k6"},
+  {K_K7,              "k7"},
+  {K_K8,              "k8"},
+  {K_K9,              "k9"},
+
+  {'<',               "lt"},
+
+  {K_MOUSE,           "Mouse"},
+  {K_LEFTMOUSE,       "LeftMouse"},
+  {K_LEFTMOUSE_NM,    "LeftMouseNM"},
+  {K_LEFTDRAG,        "LeftDrag"},
+  {K_LEFTRELEASE,     "LeftRelease"},
+  {K_LEFTRELEASE_NM,  "LeftReleaseNM"},
+  {K_MIDDLEMOUSE,     "MiddleMouse"},
+  {K_MIDDLEDRAG,      "MiddleDrag"},
+  {K_MIDDLERELEASE,   "MiddleRelease"},
+  {K_RIGHTMOUSE,      "RightMouse"},
+  {K_RIGHTDRAG,       "RightDrag"},
+  {K_RIGHTRELEASE,    "RightRelease"},
+  {K_MOUSEDOWN,       "ScrollWheelUp"},
+  {K_MOUSEUP,         "ScrollWheelDown"},
+  {K_MOUSELEFT,       "ScrollWheelRight"},
+  {K_MOUSERIGHT,      "ScrollWheelLeft"},
+  {K_MOUSEDOWN,       "MouseDown"},  // OBSOLETE: Use ScrollWheelXXX instead
+  {K_MOUSEUP,         "MouseUp"},    // Same
+  {K_X1MOUSE,         "X1Mouse"},
+  {K_X1DRAG,          "X1Drag"},
+  {K_X1RELEASE,       "X1Release"},
+  {K_X2MOUSE,         "X2Mouse"},
+  {K_X2DRAG,          "X2Drag"},
+  {K_X2RELEASE,       "X2Release"},
+  {K_DROP,            "Drop"},
+  {K_ZERO,            "Nul"},
+  {K_SNR,             "SNR"},
+  {K_PLUG,            "Plug"},
+  {K_PASTE,           "Paste"},
+  {K_FOCUSGAINED,     "FocusGained"},
+  {K_FOCUSLOST,       "FocusLost"},
+  {0,                 NULL}
+};
+
+int get_special_key_code(const char_u *name)
+{
+  for (int i = 0; key_names_table[i].name != NULL; i++) {
+    const char *const table_name = key_names_table[i].name;
+    int j;
+    for (j = 0; vim_isIDc(name[j]) && table_name[j] != NUL; j++) {
+      if (TOLOWER_ASC(table_name[j]) != TOLOWER_ASC(name[j])) {
+        break;
+      }
+    }
+    if (!vim_isIDc(name[j]) && table_name[j] == NUL) {
+      return key_names_table[i].key;
+    }
+  }
+
+  return 0;
+}
+
+
+static const struct modmasktable {
+  short mod_mask;  ///< Bit-mask for particular key modifier.
+  short mod_flag;  ///< Bit(s) for particular key modifier.
+  char_u name;  ///< Single letter name of modifier.
+} mod_mask_table[] = {
+  {MOD_MASK_ALT,              MOD_MASK_ALT,           (char_u)'M'},
+  {MOD_MASK_META,             MOD_MASK_META,          (char_u)'T'},
+  {MOD_MASK_CTRL,             MOD_MASK_CTRL,          (char_u)'C'},
+  {MOD_MASK_SHIFT,            MOD_MASK_SHIFT,         (char_u)'S'},
+  {MOD_MASK_MULTI_CLICK,      MOD_MASK_2CLICK,        (char_u)'2'},
+  {MOD_MASK_MULTI_CLICK,      MOD_MASK_3CLICK,        (char_u)'3'},
+  {MOD_MASK_MULTI_CLICK,      MOD_MASK_4CLICK,        (char_u)'4'},
+  {MOD_MASK_CMD,              MOD_MASK_CMD,           (char_u)'D'},
+  // 'A' must be the last one
+  {MOD_MASK_ALT,              MOD_MASK_ALT,           (char_u)'A'},
+  {0, 0, NUL}
+};
+
+int name_to_mod_mask(int c)
+{
+  c = TOUPPER_ASC(c);
+  for (size_t i = 0; mod_mask_table[i].mod_mask != 0; i++) {
+    if (c == mod_mask_table[i].name) {
+      return mod_mask_table[i].mod_flag;
+    }
+  }
+  return 0;
+}
+
+static int extract_modifiers(int key, int *modp)
+{
+  int modifiers = *modp;
+
+  if (!(modifiers & MOD_MASK_CMD)) {  // Command-key is special
+    if ((modifiers & MOD_MASK_SHIFT) && ASCII_ISALPHA(key)) {
+      key = TOUPPER_ASC(key);
+      modifiers &= ~MOD_MASK_SHIFT;
+    }
+  }
+  if ((modifiers & MOD_MASK_CTRL)
+      && ((key >= '?' && key <= '_') || ASCII_ISALPHA(key))) {
+    key = Ctrl_chr(key);
+    modifiers &= ~MOD_MASK_CTRL;
+    if (key == 0) {  // <C-@> is <Nul>
+      key = K_ZERO;
+    }
+  }
+
+  *modp = modifiers;
+  return key;
+}
+
+int find_special_key(const char_u **srcp, const size_t src_len, int *const modp,
+                     const bool keycode, const bool keep_x_key,
+                     const bool in_string)
+{
+  const char_u *last_dash;
+  const char_u *end_of_name;
+  const char_u *src;
+  const char_u *bp;
+  const char_u *const end = *srcp + src_len - 1;
+  int modifiers;
+  int bit;
+  int key;
+  uvarnumber_T n;
+  int l;
+
+  if (src_len == 0) {
+    return 0;
+  }
+
+  src = *srcp;
+  if (src[0] != '<') {
+    return 0;
+  }
+
+  // Find end of modifier list
+  last_dash = src;
+  for (bp = src + 1; bp <= end && (*bp == '-' || vim_isIDc(*bp)); bp++) {
+    if (*bp == '-') {
+      last_dash = bp;
+      if (bp + 1 <= end) {
+        l = utfc_ptr2len_len(bp + 1, (int)(end - bp) + 1);
+        // Anything accepted, like <C-?>.
+        // <C-"> or <M-"> are not special in strings as " is
+        // the string delimiter. With a backslash it works: <M-\">
+        if (end - bp > l && !(in_string && bp[1] == '"') && bp[2] == '>') {
+          bp += l;
+        } else if (end - bp > 2 && in_string && bp[1] == '\\'
+                   && bp[2] == '"' && bp[3] == '>') {
+          bp += 2;
+        }
+      }
+    }
+    if (end - bp > 3 && bp[0] == 't' && bp[1] == '_') {
+      bp += 3;  // skip t_xx, xx may be '-' or '>'
+    } else if (end - bp > 4 && STRNICMP(bp, "char-", 5) == 0) {
+      vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0);
+      bp += l + 5;
+      break;
+    }
+  }
+
+  if (bp <= end && *bp == '>') {  // found matching '>'
+    end_of_name = bp + 1;
+
+    /* Which modifiers are given? */
+    modifiers = 0x0;
+    for (bp = src + 1; bp < last_dash; bp++) {
+      if (*bp != '-') {
+        bit = name_to_mod_mask(*bp);
+        if (bit == 0x0) {
+          break;                // Illegal modifier name
+        }
+        modifiers |= bit;
+      }
+    }
+
+    // Legal modifier name.
+    if (bp >= last_dash) {
+      if (STRNICMP(last_dash + 1, "char-", 5) == 0
+          && ascii_isdigit(last_dash[6])) {
+        // <Char-123> or <Char-033> or <Char-0x33>
+        vim_str2nr(last_dash + 6, NULL, NULL, STR2NR_ALL, NULL, &n, 0);
+        key = (int)n;
+      } else {
+        int off = 1;
+
+        // Modifier with single letter, or special key name.
+        if (in_string && last_dash[1] == '\\' && last_dash[2] == '"') {
+          off = 2;
+        }
+        l = mb_ptr2len(last_dash + 1);
+        if (modifiers != 0 && last_dash[l + 1] == '>') {
+          key = PTR2CHAR(last_dash + off);
+        } else {
+          key = get_special_key_code(last_dash + off);
+          if (!keep_x_key) {
+            key = handle_x_keys(key);
+          }
+        }
+      }
+
+      // get_special_key_code() may return NUL for invalid
+      // special key name.
+      if (key != NUL) {
+        // Only use a modifier when there is no special key code that
+        // includes the modifier.
+        key = simplify_key(key, &modifiers);
+
+        if (!keycode) {
+          // don't want keycode, use single byte code
+          if (key == K_BS) {
+            key = BS;
+          } else if (key == K_DEL || key == K_KDEL) {
+            key = DEL;
+          }
+        }
+
+        // Normal Key with modifier:
+        // Try to make a single byte code (except for Alt/Meta modifiers).
+        if (!IS_SPECIAL(key)) {
+          key = extract_modifiers(key, &modifiers);
+        }
+
+        *modp = modifiers;
+        *srcp = end_of_name;
+        return key;
+      }
+    }
+  }
+  return 0;
+}
+
+char_u *add_char2buf(int c, char_u *s)
+{
+  char_u temp[MB_MAXBYTES + 1];
+  const int len = utf_char2bytes(c, temp);
+  for (int i = 0; i < len; ++i) {
+    c = temp[i];
+    // Need to escape K_SPECIAL and CSI like in the typeahead buffer.
+    if (c == K_SPECIAL) {
+      *s++ = K_SPECIAL;
+      *s++ = KS_SPECIAL;
+      *s++ = KE_FILLER;
+    } else {
+      *s++ = c;
+    }
+  }
+  return s;
+}
+
+unsigned int trans_special(const char_u **srcp, const size_t src_len,
+                           char_u *const dst, const bool keycode,
+                           const bool in_string)
+{
+  int modifiers = 0;
+  int key;
+  unsigned int dlen = 0;
+
+  key = find_special_key(srcp, src_len, &modifiers, keycode, false, in_string);
+  if (key == 0) {
+    return 0;
+  }
+
+  // Put the appropriate modifier in a string.
+  if (modifiers != 0) {
+    dst[dlen++] = K_SPECIAL;
+    dst[dlen++] = KS_MODIFIER;
+    dst[dlen++] = (char_u)modifiers;
+  }
+
+  if (IS_SPECIAL(key)) {
+    dst[dlen++] = K_SPECIAL;
+    dst[dlen++] = (char_u)KEY2TERMCAP0(key);
+    dst[dlen++] = KEY2TERMCAP1(key);
+  } else if (has_mbyte && !keycode) {
+    dlen += (unsigned int)(*mb_char2bytes)(key, dst + dlen);
+  } else if (keycode) {
+    char_u *after = add_char2buf(key, dst + dlen);
+    assert(after >= dst && (uintmax_t)(after - dst) <= UINT_MAX);
+    dlen = (unsigned int)(after - dst);
+  } else {
+    dst[dlen++] = (char_u)key;
+  }
+
+  return dlen;
+}
diff --git a/test/symbolic/klee/nvim/mbyte.c b/test/symbolic/klee/nvim/mbyte.c
index 394d17b700..bfc191b1b7 100644
--- a/test/symbolic/klee/nvim/mbyte.c
+++ b/test/symbolic/klee/nvim/mbyte.c
@@ -1,9 +1,89 @@
 #include <stddef.h>
+#include <inttypes.h>
+#include <assert.h>
+#include <stdbool.h>
 
 #include "nvim/types.h"
 #include "nvim/mbyte.h"
 #include "nvim/ascii.h"
 
+const uint8_t utf8len_tab_zero[] = {
+  //1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // 0
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // 2
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // 4
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  // 6
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  // 8
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  // A
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  // C
+  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,0,0,  // E
+};
+
+const uint8_t utf8len_tab[] = {
+  // ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9 ?A ?B ?C ?D ?E ?F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 0?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 1?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 2?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 3?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 4?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 5?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 6?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 7?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 8?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // 9?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // A?
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  // B?
+  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,  // C?
+  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,  // D?
+  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  // E?
+  4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1,  // F?
+};
+
+int utf_ptr2char(const char_u *const p)
+{
+  if (p[0] < 0x80) {  // Be quick for ASCII.
+    return p[0];
+  }
+
+  const uint8_t len = utf8len_tab_zero[p[0]];
+  if (len > 1 && (p[1] & 0xc0) == 0x80) {
+    if (len == 2) {
+      return ((p[0] & 0x1f) << 6) + (p[1] & 0x3f);
+    }
+    if ((p[2] & 0xc0) == 0x80) {
+      if (len == 3) {
+        return (((p[0] & 0x0f) << 12) + ((p[1] & 0x3f) << 6)
+                + (p[2] & 0x3f));
+      }
+      if ((p[3] & 0xc0) == 0x80) {
+        if (len == 4) {
+          return (((p[0] & 0x07) << 18) + ((p[1] & 0x3f) << 12)
+                  + ((p[2] & 0x3f) << 6) + (p[3] & 0x3f));
+        }
+        if ((p[4] & 0xc0) == 0x80) {
+          if (len == 5) {
+            return (((p[0] & 0x03) << 24) + ((p[1] & 0x3f) << 18)
+                    + ((p[2] & 0x3f) << 12) + ((p[3] & 0x3f) << 6)
+                    + (p[4] & 0x3f));
+          }
+          if ((p[5] & 0xc0) == 0x80 && len == 6) {
+            return (((p[0] & 0x01) << 30) + ((p[1] & 0x3f) << 24)
+                    + ((p[2] & 0x3f) << 18) + ((p[3] & 0x3f) << 12)
+                    + ((p[4] & 0x3f) << 6) + (p[5] & 0x3f));
+          }
+        }
+      }
+    }
+  }
+  // Illegal value: just return the first byte.
+  return p[0];
+}
+
+bool utf_composinglike(const char_u *p1, const char_u *p2)
+{
+  return false;
+}
+
 char_u *string_convert(const vimconv_T *conv, char_u *data, size_t *size)
 {
   return NULL;
@@ -11,8 +91,117 @@ char_u *string_convert(const vimconv_T *conv, char_u *data, size_t *size)
 
 int utfc_ptr2len_len(const char_u *p, int size)
 {
-  if (size < 1 || *p == NUL) {
+  assert(false);
+  return 0;
+}
+
+int utf_char2len(const int c)
+{
+  if (c < 0x80) {
+    return 1;
+  } else if (c < 0x800) {
+    return 2;
+  } else if (c < 0x10000) {
+    return 3;
+  } else if (c < 0x200000) {
+    return 4;
+  } else if (c < 0x4000000) {
+    return 5;
+  } else {
+    return 6;
+  }
+}
+
+int utf_char2bytes(const int c, char_u *const buf)
+{
+  if (c < 0x80) {  // 7 bits
+    buf[0] = c;
+    return 1;
+  } else if (c < 0x800) {  // 11 bits
+    buf[0] = 0xc0 + ((unsigned)c >> 6);
+    buf[1] = 0x80 + (c & 0x3f);
+    return 2;
+  } else if (c < 0x10000) {  // 16 bits
+    buf[0] = 0xe0 + ((unsigned)c >> 12);
+    buf[1] = 0x80 + (((unsigned)c >> 6) & 0x3f);
+    buf[2] = 0x80 + (c & 0x3f);
+    return 3;
+  } else if (c < 0x200000) {  // 21 bits
+    buf[0] = 0xf0 + ((unsigned)c >> 18);
+    buf[1] = 0x80 + (((unsigned)c >> 12) & 0x3f);
+    buf[2] = 0x80 + (((unsigned)c >> 6) & 0x3f);
+    buf[3] = 0x80 + (c & 0x3f);
+    return 4;
+  } else if (c < 0x4000000) {  // 26 bits
+    buf[0] = 0xf8 + ((unsigned)c >> 24);
+    buf[1] = 0x80 + (((unsigned)c >> 18) & 0x3f);
+    buf[2] = 0x80 + (((unsigned)c >> 12) & 0x3f);
+    buf[3] = 0x80 + (((unsigned)c >> 6) & 0x3f);
+    buf[4] = 0x80 + (c & 0x3f);
+    return 5;
+  } else {  // 31 bits
+    buf[0] = 0xfc + ((unsigned)c >> 30);
+    buf[1] = 0x80 + (((unsigned)c >> 24) & 0x3f);
+    buf[2] = 0x80 + (((unsigned)c >> 18) & 0x3f);
+    buf[3] = 0x80 + (((unsigned)c >> 12) & 0x3f);
+    buf[4] = 0x80 + (((unsigned)c >> 6) & 0x3f);
+    buf[5] = 0x80 + (c & 0x3f);
+    return 6;
+  }
+}
+
+int utf_ptr2len(const char_u *const p)
+{
+  if (*p == NUL) {
+    return 0;
+  }
+  const int len = utf8len_tab[*p];
+  for (int i = 1; i < len; i++) {
+    if ((p[i] & 0xc0) != 0x80) {
+      return 1;
+    }
+  }
+  return len;
+}
+
+int utfc_ptr2len(const char_u *const p)
+{
+  uint8_t b0 = (uint8_t)(*p);
+
+  if (b0 == NUL) {
     return 0;
   }
-  return 1;
+  if (b0 < 0x80 && p[1] < 0x80) {  // be quick for ASCII
+    return 1;
+  }
+
+  // Skip over first UTF-8 char, stopping at a NUL byte.
+  int len = utf_ptr2len(p);
+
+  // Check for illegal byte.
+  if (len == 1 && b0 >= 0x80) {
+    return 1;
+  }
+
+  // Check for composing characters.  We can handle only the first six, but
+  // skip all of them (otherwise the cursor would get stuck).
+  int prevlen = 0;
+  for (;;) {
+    if (p[len] < 0x80 || !UTF_COMPOSINGLIKE(p + prevlen, p + len)) {
+      return len;
+    }
+
+    // Skip over composing char.
+    prevlen = len;
+    len += utf_ptr2len(p + len);
+  }
+}
+
+void mb_copy_char(const char_u **fp, char_u **tp)
+{
+  const size_t l = utfc_ptr2len(*fp);
+
+  memmove(*tp, *fp, (size_t)l);
+  *tp += l;
+  *fp += l;
 }
diff --git a/test/symbolic/klee/viml_expressions_parser.c b/test/symbolic/klee/viml_expressions_parser.c
index 5ad592b99f..e1cea2d990 100644
--- a/test/symbolic/klee/viml_expressions_parser.c
+++ b/test/symbolic/klee/viml_expressions_parser.c
@@ -18,6 +18,7 @@
 #include "nvim/garray.c"
 #include "nvim/gettext.c"
 #include "nvim/viml/parser/expressions.c"
+#include "nvim/keymap.c"
 
 #define INPUT_SIZE 50
 
diff --git a/test/unit/viml/expressions/parser_spec.lua b/test/unit/viml/expressions/parser_spec.lua
index 41261cf7c9..ed77a7cba4 100644
--- a/test/unit/viml/expressions/parser_spec.lua
+++ b/test/unit/viml/expressions/parser_spec.lua
@@ -142,6 +142,13 @@ local function eastnode2lua(pstate, eastnode, checked_nodes)
     typ = typ .. ('(val=%u)'):format(tonumber(eastnode.data.num.value))
   elseif typ == 'Float' then
     typ = typ .. ('(val=%e)'):format(tonumber(eastnode.data.flt.value))
+  elseif typ == 'SingleQuotedString' or typ == 'DoubleQuotedString' then
+    if eastnode.data.str.value == nil then
+      typ = typ .. '(val=NULL)'
+    else
+      local s = ffi.string(eastnode.data.str.value, eastnode.data.str.size)
+      typ = format_string('%s(val=%q)', typ, s)
+    end
   end
   ret_str = typ .. ':' .. ret_str
   local can_simplify = true
@@ -4549,4 +4556,822 @@ describe('Expressions parser', function()
       hl('InvalidSubscript', ']'),
     })
   end)
+  itp('works with strings', function()
+    check_parsing('\'abc\'', 0, {
+      --           01234
+      ast = {
+        'SingleQuotedString(val="abc"):0:0:\'abc\'',
+      },
+    }, {
+      hl('SingleQuotedString', '\''),
+      hl('SingleQuotedBody', 'abc'),
+      hl('SingleQuotedString', '\''),
+    })
+    check_parsing('"abc"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="abc"):0:0:"abc"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedBody', 'abc'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('\'\'', 0, {
+      --           01
+      ast = {
+        'SingleQuotedString(val=NULL):0:0:\'\'',
+      },
+    }, {
+      hl('SingleQuotedString', '\''),
+      hl('SingleQuotedString', '\''),
+    })
+    check_parsing('""', 0, {
+      --           01
+      ast = {
+        'DoubleQuotedString(val=NULL):0:0:""',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"', 0, {
+      --           0
+      ast = {
+        'DoubleQuotedString(val=NULL):0:0:"',
+      },
+      err = {
+        arg = '"',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+    })
+    check_parsing('\'', 0, {
+      --           0
+      ast = {
+        'SingleQuotedString(val=NULL):0:0:\'',
+      },
+      err = {
+        arg = '\'',
+        msg = 'E115: Missing single quote: %.*s',
+      },
+    }, {
+      hl('InvalidSingleQuotedString', '\''),
+    })
+    check_parsing('"a', 0, {
+      --           01
+      ast = {
+        'DoubleQuotedString(val="a"):0:0:"a',
+      },
+      err = {
+        arg = '"a',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+      hl('InvalidDoubleQuotedBody', 'a'),
+    })
+    check_parsing('\'a', 0, {
+      --           01
+      ast = {
+        'SingleQuotedString(val="a"):0:0:\'a',
+      },
+      err = {
+        arg = '\'a',
+        msg = 'E115: Missing single quote: %.*s',
+      },
+    }, {
+      hl('InvalidSingleQuotedString', '\''),
+      hl('InvalidSingleQuotedBody', 'a'),
+    })
+    check_parsing('\'abc\'\'def\'', 0, {
+      --           0123456789
+      ast = {
+        'SingleQuotedString(val="abc\'def"):0:0:\'abc\'\'def\'',
+      },
+    }, {
+      hl('SingleQuotedString', '\''),
+      hl('SingleQuotedBody', 'abc'),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedBody', 'def'),
+      hl('SingleQuotedString', '\''),
+    })
+    check_parsing('\'abc\'\'', 0, {
+      --           012345
+      ast = {
+        'SingleQuotedString(val="abc\'"):0:0:\'abc\'\'',
+      },
+      err = {
+        arg = '\'abc\'\'',
+        msg = 'E115: Missing single quote: %.*s',
+      },
+    }, {
+      hl('InvalidSingleQuotedString', '\''),
+      hl('InvalidSingleQuotedBody', 'abc'),
+      hl('InvalidSingleQuotedQuote', '\'\''),
+    })
+    check_parsing('\'\'\'\'\'\'\'\'', 0, {
+      --           01234567
+      ast = {
+        'SingleQuotedString(val="\'\'\'"):0:0:\'\'\'\'\'\'\'\'',
+      },
+    }, {
+      hl('SingleQuotedString', '\''),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedString', '\''),
+    })
+    check_parsing('\'\'\'a\'\'\'\'bc\'', 0, {
+      --           01234567890
+      --           0         1
+      ast = {
+        'SingleQuotedString(val="\'a\'\'bc"):0:0:\'\'\'a\'\'\'\'bc\'',
+      },
+    }, {
+      hl('SingleQuotedString', '\''),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedBody', 'a'),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedQuote', '\'\''),
+      hl('SingleQuotedBody', 'bc'),
+      hl('SingleQuotedString', '\''),
+    })
+    check_parsing('"\\"\\"\\"\\""', 0, {
+      --           0123456789
+      ast = {
+        'DoubleQuotedString(val="\\"\\"\\"\\""):0:0:"\\"\\"\\"\\""',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"abc\\"def\\"ghi\\"jkl\\"mno"', 0, {
+      --           0123456789012345678901234
+      --           0         1         2
+      ast = {
+        'DoubleQuotedString(val="abc\\"def\\"ghi\\"jkl\\"mno"):0:0:"abc\\"def\\"ghi\\"jkl\\"mno"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedBody', 'abc'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedBody', 'def'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedBody', 'ghi'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedBody', 'jkl'),
+      hl('DoubleQuotedEscape', '\\"'),
+      hl('DoubleQuotedBody', 'mno'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\b\\e\\f\\r\\t\\\\"', 0, {
+      --           0123456789012345
+      --           0         1
+      ast = {
+        [[DoubleQuotedString(val="\8\27\12\13\9\\"):0:0:"\b\e\f\r\t\\"]],
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\b'),
+      hl('DoubleQuotedEscape', '\\e'),
+      hl('DoubleQuotedEscape', '\\f'),
+      hl('DoubleQuotedEscape', '\\r'),
+      hl('DoubleQuotedEscape', '\\t'),
+      hl('DoubleQuotedEscape', '\\\\'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\n\n"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="\\\n\\\n"):0:0:"\\n\n"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\n'),
+      hl('DoubleQuotedBody', '\n'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\x00"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0"):0:0:"\\x00"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\x00'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\xFF"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\255"):0:0:"\\xFF"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\xFF'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\xF"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\15"):0:0:"\\xF"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\xF'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\u00AB"', 0, {
+      --           01234567
+      ast = {
+        'DoubleQuotedString(val="«"):0:0:"\\u00AB"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\u00AB'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\U000000AB"', 0, {
+      --           01234567
+      ast = {
+        'DoubleQuotedString(val="«"):0:0:"\\U000000AB"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U000000AB'),
+      hl('DoubleQuotedString', '"'),
+    })
+    check_parsing('"\\x"', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="x"):0:0:"\\x"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\x'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\x', 0, {
+      --           012
+      ast = {
+        'DoubleQuotedString(val="x"):0:0:"\\x',
+      },
+      err = {
+        arg = '"\\x',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+      hl('InvalidDoubleQuotedUnknownEscape', '\\x'),
+    })
+
+    check_parsing('"\\xF', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="\\15"):0:0:"\\xF',
+      },
+      err = {
+        arg = '"\\xF',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+      hl('InvalidDoubleQuotedEscape', '\\xF'),
+    })
+
+    check_parsing('"\\u"', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="u"):0:0:"\\u"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\u'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\u', 0, {
+      --           012
+      ast = {
+        'DoubleQuotedString(val="u"):0:0:"\\u',
+      },
+      err = {
+        arg = '"\\u',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+      hl('InvalidDoubleQuotedUnknownEscape', '\\u'),
+    })
+
+    check_parsing('"\\U', 0, {
+      --           012
+      ast = {
+        'DoubleQuotedString(val="U"):0:0:"\\U',
+      },
+      err = {
+        arg = '"\\U',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+      hl('InvalidDoubleQuotedUnknownEscape', '\\U'),
+    })
+
+    check_parsing('"\\U"', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="U"):0:0:"\\U"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\U'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\xFX"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\15X"):0:0:"\\xFX"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\xF'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\XFX"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\15X"):0:0:"\\XFX"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\XF'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\xX"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="xX"):0:0:"\\xX"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\x'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\XX"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="XX"):0:0:"\\XX"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\X'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\uX"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="uX"):0:0:"\\uX"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\u'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\UX"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="UX"):0:0:"\\UX"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\U'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\x0X"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\x0X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\x0'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\X0X"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\X0X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\X0'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\u0X"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\u0X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\u0'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U0X"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U0X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U0'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\x00X"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\x00X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\x00'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\X00X"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\X00X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\X00'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\u00X"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\u00X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\u00'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U00X"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U00X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U00'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\u000X"', 0, {
+      --           01234567
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\u000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\u000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U000X"', 0, {
+      --           01234567
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\u0000X"', 0, {
+      --           012345678
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\u0000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\u0000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U0000X"', 0, {
+      --           012345678
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U0000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U0000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U00000X"', 0, {
+      --           0123456789
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U00000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U00000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U000000X"', 0, {
+      --           01234567890
+      --           0         1
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U000000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U000000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U0000000X"', 0, {
+      --           012345678901
+      --           0         1
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U0000000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U0000000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U00000000X"', 0, {
+      --           0123456789012
+      --           0         1
+      ast = {
+        'DoubleQuotedString(val="\\0X"):0:0:"\\U00000000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U00000000'),
+      hl('DoubleQuotedBody', 'X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\x000X"', 0, {
+      --           01234567
+      ast = {
+        'DoubleQuotedString(val="\\0000X"):0:0:"\\x000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\x00'),
+      hl('DoubleQuotedBody', '0X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\X000X"', 0, {
+      --           01234567
+      ast = {
+        'DoubleQuotedString(val="\\0000X"):0:0:"\\X000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\X00'),
+      hl('DoubleQuotedBody', '0X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\u00000X"', 0, {
+      --           0123456789
+      ast = {
+        'DoubleQuotedString(val="\\0000X"):0:0:"\\u00000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\u0000'),
+      hl('DoubleQuotedBody', '0X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\U000000000X"', 0, {
+      --           01234567890123
+      --           0         1
+      ast = {
+        'DoubleQuotedString(val="\\0000X"):0:0:"\\U000000000X"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\U00000000'),
+      hl('DoubleQuotedBody', '0X'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\0"', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="\\0"):0:0:"\\0"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\0'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\00"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="\\0"):0:0:"\\00"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\00'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\000"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0"):0:0:"\\000"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\000'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\0000"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="\\0000"):0:0:"\\0000"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\000'),
+      hl('DoubleQuotedBody', '0'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\8"', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="8"):0:0:"\\8"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\8'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\08"', 0, {
+      --           01234
+      ast = {
+        'DoubleQuotedString(val="\\0008"):0:0:"\\08"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\0'),
+      hl('DoubleQuotedBody', '8'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\008"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\0008"):0:0:"\\008"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\00'),
+      hl('DoubleQuotedBody', '8'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\0008"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="\\0008"):0:0:"\\0008"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\000'),
+      hl('DoubleQuotedBody', '8'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\777"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\255"):0:0:"\\777"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\777'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\050"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\40"):0:0:"\\050"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\050'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\<C-u>"', 0, {
+      --           012345
+      ast = {
+        'DoubleQuotedString(val="\\21"):0:0:"\\<C-u>"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedEscape', '\\<C-u>'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\<', 0, {
+      --           012
+      ast = {
+        'DoubleQuotedString(val="<"):0:0:"\\<',
+      },
+      err = {
+        arg = '"\\<',
+        msg = 'E114: Missing double quote: %.*s',
+      },
+    }, {
+      hl('InvalidDoubleQuotedString', '"'),
+      hl('InvalidDoubleQuotedUnknownEscape', '\\<'),
+    })
+
+    check_parsing('"\\<"', 0, {
+      --           0123
+      ast = {
+        'DoubleQuotedString(val="<"):0:0:"\\<"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\<'),
+      hl('DoubleQuotedString', '"'),
+    })
+
+    check_parsing('"\\<C-u"', 0, {
+      --           0123456
+      ast = {
+        'DoubleQuotedString(val="<C-u"):0:0:"\\<C-u"',
+      },
+    }, {
+      hl('DoubleQuotedString', '"'),
+      hl('DoubleQuotedUnknownEscape', '\\<'),
+      hl('DoubleQuotedBody', 'C-u'),
+      hl('DoubleQuotedString', '"'),
+    })
+  end)
 end)