xkbcomp/scanner: avoid unneeded strdup of IDENT tokens

src/scanner-utils.h

@@ -28,12 +28,22 @@ svaleq(struct sval s1, struct sval s2)
     return s1.len == s2.len && memcmp(s1.start, s2.start, s1.len) == 0;
 }
 
+static inline bool
+isvaleq(struct sval s1, struct sval s2)
+{
+    return s1.len == s2.len && istrncmp(s1.start, s2.start, s1.len) == 0;
+}
+
 static inline bool
 svaleq_prefix(struct sval s1, struct sval s2)
 {
     return s1.len <= s2.len && memcmp(s1.start, s2.start, s1.len) == 0;
 }
 
+#define SVAL(start, len) (struct sval){(start), len}
+#define SVAL_LIT(literal) SVAL(literal, sizeof(literal) - 1)
+#define SVAL_INIT(literal) { literal, sizeof(literal) - 1 }
+
 /* A line:column location in the input string (1-based). */
 struct scanner_loc {
     size_t line, column;

src/xkbcomp/parser-priv.h

@@ -7,6 +7,7 @@
 struct parser_param;
 struct scanner;
 
+#include "scanner-utils.h"
 #include "parser.h"
 
 int

src/xkbcomp/parser.y

@@ -15,7 +15,6 @@
 #include "xkbcomp/xkbcomp-priv.h"
 #include "xkbcomp/ast-build.h"
 #include "xkbcomp/parser-priv.h"
-#include "scanner-utils.h"
 #include "keysym.h"
 
 struct parser_param {
@@ -38,25 +37,33 @@ _xkbcommon_error(struct parser_param *param, const char *msg)
 }
 
 static bool
-resolve_keysym(struct parser_param *param, const char *name, xkb_keysym_t *sym_rtrn)
+resolve_keysym(struct parser_param *param, struct sval name, xkb_keysym_t *sym_rtrn)
 {
     xkb_keysym_t sym;
 
-    if (!name || istreq(name, "any") || istreq(name, "nosymbol")) {
+    if (isvaleq(name, SVAL_LIT("any")) || isvaleq(name, SVAL_LIT("nosymbol"))) {
         *sym_rtrn = XKB_KEY_NoSymbol;
         return true;
     }
 
-    if (istreq(name, "none") || istreq(name, "voidsymbol")) {
+    if (isvaleq(name, SVAL_LIT("none")) || isvaleq(name, SVAL_LIT("voidsymbol"))) {
         *sym_rtrn = XKB_KEY_VoidSymbol;
         return true;
     }
 
-    sym = xkb_keysym_from_name(name, XKB_KEYSYM_NO_FLAGS);
+    /* xkb_keysym_from_name needs a C string. */
+    char buf[XKB_KEYSYM_NAME_MAX_SIZE];
+    if (name.len >= sizeof(buf)) {
+        return false;
+    }
+    memcpy(buf, name.start, name.len);
+    buf[name.len] = '\0';
+
+    sym = xkb_keysym_from_name(buf, XKB_KEYSYM_NO_FLAGS);
     if (sym != XKB_KEY_NoSymbol) {
         *sym_rtrn = sym;
         check_deprecated_keysyms(parser_warn, param, param->ctx,
-                                 sym, name, name, "%s", "");
+                                 sym, buf, buf, "%s", "");
         return true;
     }
 
@@ -147,6 +154,7 @@ resolve_keysym(struct parser_param *param, const char *name, xkb_keysym_t *sym_r
         int64_t          num;
         enum xkb_file_type file_type;
         char            *str;
+        struct sval     sval;
         xkb_atom_t      atom;
         enum merge_mode merge;
         enum xkb_map_flags mapFlags;
@@ -174,7 +182,8 @@ resolve_keysym(struct parser_param *param, const char *name, xkb_keysym_t *sym_r
 }
 
 %type <num>     INTEGER FLOAT
-%type <str>     IDENT STRING
+%type <str>     STRING
+%type <sval>    IDENT
 %type <atom>    KEYNAME
 %type <num>     KeyCode Number Integer Float SignedNumber DoodadType
 %type <merge>   MergeMode OptMergeMode
@@ -744,12 +753,11 @@ KeySym          :       IDENT
                                 parser_warn(
                                     param,
                                     XKB_WARNING_UNRECOGNIZED_KEYSYM,
-                                    "unrecognized keysym \"%s\"",
-                                    $1
+                                    "unrecognized keysym \"%.*s\"",
+                                    $1.len, $1.start
                                 );
                                 $$ = XKB_KEY_NoSymbol;
                             }
-                            free($1);
                         }
                         /* Handle keysym that is also a keyword  */
                 |       SECTION { $$ = XKB_KEY_section; }
@@ -808,7 +816,7 @@ Integer         :       INTEGER { $$ = $1; }
 KeyCode         :       INTEGER { $$ = $1; }
                 ;
 
-Ident           :       IDENT   { $$ = xkb_atom_intern(param->ctx, $1, strlen($1)); free($1); }
+Ident           :       IDENT   { $$ = xkb_atom_intern(param->ctx, $1.start, $1.len); }
                 |       DEFAULT { $$ = xkb_atom_intern_literal(param->ctx, "default"); }
                 ;
 

src/xkbcomp/rules.c

@@ -133,13 +133,11 @@ enum rules_mlvo {
     _MLVO_NUM_ENTRIES
 };
 
-#define SVAL_LIT(literal) { literal, sizeof(literal) - 1 }
-
 static const struct sval rules_mlvo_svals[_MLVO_NUM_ENTRIES] = {
-    [MLVO_MODEL] = SVAL_LIT("model"),
-    [MLVO_LAYOUT] = SVAL_LIT("layout"),
-    [MLVO_VARIANT] = SVAL_LIT("variant"),
-    [MLVO_OPTION] = SVAL_LIT("option"),
+    [MLVO_MODEL] = SVAL_INIT("model"),
+    [MLVO_LAYOUT] = SVAL_INIT("layout"),
+    [MLVO_VARIANT] = SVAL_INIT("variant"),
+    [MLVO_OPTION] = SVAL_INIT("option"),
 };
 
 enum rules_kccgst {
@@ -152,11 +150,11 @@ enum rules_kccgst {
 };
 
 static const struct sval rules_kccgst_svals[_KCCGST_NUM_ENTRIES] = {
-    [KCCGST_KEYCODES] = SVAL_LIT("keycodes"),
-    [KCCGST_TYPES] = SVAL_LIT("types"),
-    [KCCGST_COMPAT] = SVAL_LIT("compat"),
-    [KCCGST_SYMBOLS] = SVAL_LIT("symbols"),
-    [KCCGST_GEOMETRY] = SVAL_LIT("geometry"),
+    [KCCGST_KEYCODES] = SVAL_INIT("keycodes"),
+    [KCCGST_TYPES] = SVAL_INIT("types"),
+    [KCCGST_COMPAT] = SVAL_INIT("compat"),
+    [KCCGST_SYMBOLS] = SVAL_INIT("symbols"),
+    [KCCGST_GEOMETRY] = SVAL_INIT("geometry"),
 };
 
 /* We use this to keep score whether an mlvo was matched or not; if not,

src/xkbcomp/scanner.c

@@ -7,7 +7,6 @@
 
 #include "xkbcomp-priv.h"
 #include "parser-priv.h"
-#include "scanner-utils.h"
 
 static bool
 number(struct scanner *s, int64_t *out, int *out_tok)
@@ -156,9 +155,7 @@ _xkbcommon_lex(YYSTYPE *yylval, struct scanner *s)
         tok = keyword_to_token(start, len);
         if (tok >= 0) return tok;
 
-        yylval->str = strndup(start, len);
-        if (!yylval->str)
-            return ERROR_TOK;
+        yylval->sval = SVAL(start, len);
         return IDENT;
     }