libcdecl: Move another error message into the string table.

[cdecl99.git] / src / parse.y

diff --git a/src/parse.y b/src/parse.y
index 9e547617d228e78d006014c0ccc0822822775638..6d349f79ef1bc8537280c92066a349f0429ff20f 100644 (file)
--- a/src/parse.y
+++ b/src/parse.y
@@ -1,7 +1,7 @@
 %code top {
 /*
  *  Parser for C declarations.
- *  Copyright © 2011-2012, 2021, 2023 Nick Bowler
+ *  Copyright © 2011-2012, 2021, 2023-2024 Nick Bowler
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -36,51 +36,67 @@
 #include "cdecl-internal.h"
 #include "errmsg.h"
 
-#define FAIL(msg) do { \
-       yyerror(&yylloc, NULL, NULL, msg); \
-       YYERROR; \
-} while (0)
-
-#define ALLOC(ptr, size) do { \
-       (ptr) = malloc(size); \
-       if (!(ptr)) { \
-               cdecl__errmsg(CDECL__ENOMEM); \
+/*
+ * Allocate a parse tree node via cdecl__alloc_item.
+ *
+ * - m1 specifies the item's union member to assign to ptr, which selects the
+ *   type of node to allocate.
+ *
+ * - m2 specifies the "next" or "child" member, which is initialized to a null
+ *   pointer.  The cdecl__alloc_item function sets the declarator.child member
+ *   to null; we explicitly copy this null pointer to the returned union member
+ *   to avoid type punning.  It is hoped that compilers will notice that these
+ *   pointers are at the same offset therefore the assignment can be elided.
+ *
+ * The resulting pointer can be passed directly to free, as the union is the
+ * first member of the parse_item structure.
+ *
+ * Use the wrapper macros below instead of this one.
+ */
+#define ALLOC_ITEM(ptr, m1, m2) do { \
+       struct parse_item *item; \
+       if (!(item = cdecl__alloc_item(0))) \
                YYERROR; \
-       } \
+       item->u.m1.m2 = (void *)item->u.declarator.child; \
+       (ptr) = &item->u.m1; \
 } while (0)
 
+/* Wrappers for ALLOC_ITEM to allocate various kinds of parser structures. */
+#define ALLOC_ITEM_DECLARATOR(ptr) ALLOC_ITEM(ptr, declarator, child)
+#define ALLOC_ITEM_DECLSPEC(ptr)   ALLOC_ITEM(ptr, declspec, next)
+#define ALLOC_ITEM_DECL(ptr)       ALLOC_ITEM(ptr, decl, next)
+
 #define ALLOC_FUNCTION(ptr, parameters_, variadic_) do { \
-       ALLOC(ptr, sizeof (struct cdecl_declarator)); \
+       ALLOC_ITEM_DECLARATOR(ptr); \
        (ptr)->type = CDECL_DECL_FUNCTION; \
        (ptr)->u.function.parameters = parameters_; \
        (ptr)->u.function.variadic = variadic_; \
 } while (0)
 
 #define ALLOC_ARRAY(ptr, length_) do { \
-       ALLOC(ptr, sizeof (struct cdecl_declarator)); \
+       ALLOC_ITEM_DECLARATOR(ptr); \
        (ptr)->type = CDECL_DECL_ARRAY; \
        (ptr)->u.array.vla = NULL; \
        (ptr)->u.array.length = length_; \
 } while (0)
 
 #define ALLOC_POINTER(ptr, qualifiers_, child_) do { \
-       ALLOC(ptr, sizeof (struct cdecl_declarator)); \
+       ALLOC_ITEM_DECLARATOR(ptr); \
        (ptr)->child = child_; \
        (ptr)->type = CDECL_DECL_POINTER; \
        (ptr)->u.pointer.qualifiers = qualifiers_; \
 } while (0)
 
 #define ALLOC_DECLSPEC(ptr, type_) do { \
-       ALLOC(ptr, sizeof (struct cdecl_declspec)); \
+       ALLOC_ITEM_DECLSPEC(ptr); \
        (ptr)->type = type_; \
        (ptr)->ident = NULL; \
 } while (0)
 
 #define ALLOC_DECL(ptr, specifiers_, declarators_) do { \
-       ALLOC(ptr, sizeof (struct cdecl)); \
+       ALLOC_ITEM_DECL(ptr); \
        (ptr)->specifiers = specifiers_; \
        (ptr)->declarators = declarators_; \
-       (ptr)->next = NULL; \
 } while (0)
 
 /*
@@ -88,11 +104,18 @@
  * name strings can be used directly in error messages and there is no
  * need for any string processing.
  */
-#define yytnamerr(a, b) cdecl__strlcpy(a, b, (a) ? INT_MAX : 0)
+#define yytnamerr(a, b) ( (a) ? yytnamerr_copy(a, b) \
+                              : strlen(b) )
+
+static size_t yytnamerr_copy(char *dst, const char *src)
+{
+       return cdecl__strlcpy(dst, src, strlen(src)+1);
+}
 %}
 
 %code requires {
 #include <inttypes.h>
+#include <stdbool.h>
 }
 
 %code provides {
@@ -104,7 +127,7 @@ const char *cdecl__token_name(unsigned token);
 %union {
        uintmax_t uintval;
        unsigned spectype;
-       _Bool boolval;
+       bool boolval;
        struct cdecl_declspec *declspec;
        struct cdecl_declarator *declarator;
        struct cdecl *decl;
@@ -565,8 +588,10 @@ english_array: T_VLA T_ARRAY english_vla T_OF {
 
 array_length: { $$ = 0; }
 array_length: T_UINT {
-       if (!($$ = $1))
-               FAIL(_("array length must be positive"));
+       if (!($$ = $1)) {
+               cdecl__errmsg(CDECL__EZEROARRAY);
+               YYERROR;
+       }
 }
 
 english_vla: T_IDENT | {
@@ -590,11 +615,16 @@ const char *cdecl__token_name(unsigned token)
        return yytname[YYTRANSLATE(token)];
 }
 
-static void
+/*
+ * Current versions of GCC (up to 13) want to inline this function into the
+ * parser even when optimizing for size and the results are not great, so
+ * try to prevent such inlining.
+ */
+CDECL__NOINLINE static void
 yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err)
 {
        if (strstr(err, yytname[YYTRANSLATE(T_LEX_ERROR)]))
                return;
 
-       cdecl__err(CDECL_ENOPARSE, "%s", err);
+       cdecl__err("%s", err);
 }