%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
#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)
/*
* 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 {
%union {
uintmax_t uintval;
unsigned spectype;
- _Bool boolval;
+ bool boolval;
struct cdecl_declspec *declspec;
struct cdecl_declarator *declarator;
struct cdecl *decl;
a->next = b;
}
+/*
+ * Join three specifier lists into a single list, and returns the head of
+ * the new list.
+ *
+ * The list "b" is assumed to be a singleton list.
+ */
+static struct cdecl_declspec *join_specs3(struct cdecl_declspec *a,
+ struct cdecl_declspec *b,
+ struct cdecl_declspec *c)
+{
+ b->next = c;
+ join_specs(b, a);
+ return b;
+}
+
/*
* Alter an abstract declarator (type name) to declare an identifier instead,
* used by the English parser rules to reduce "identifier as type" sequences.
%type <spectype> typespec_simple typespec_tagged
%type <declspec> declspec_notype declspec_noid typespec_noid typespec
%type <declspec> qualifier qualifiers
-%type <declspec> declspecs declspecs_noid
+%type <declspec> declspecs declspecs_notype declspecs_noid
%type <declarator> direct_declarator declarator pointer array parens postfix
%type <declarator> direct_declarator_ish declarator_ish parameter_type_list
%type <decl> cdecl declaration declarators declarator_wrap parameter
* unexpected parses; libcdecl applies a simplification step to the resulting
* parse tree afterwards.
*/
-declspecs: declspec_notype declspecs {
- $$ = $1;
- $$->next = $2;
-} | typespec declspecs_noid {
- $$ = $1;
- $$->next = $2;
+declspecs: declspecs_notype typespec declspecs_noid {
+ $$ = join_specs3($1, $2, $3);
}
-declspecs_noid: { $$ = NULL; } | declspec_noid declspecs_noid {
- $$ = $1;
- $$->next = $2;
+declspecs_notype: { $$ = NULL; } | declspecs_notype declspec_notype {
+ $$ = $2;
+ $$->next = $1;
+}
+
+declspecs_noid: { $$ = NULL; } | declspecs_noid declspec_noid {
+ $$ = $2;
+ $$->next = $1;
}
qualifiers: { $$ = NULL; } | qualifiers qualifier {
* over reducing this empty rule; see below.
*/
storage_func_specs: %prec T_TYPE { $$ = NULL; }
-storage_func_specs: declspec_simple storage_func_specs {
- ALLOC_DECLSPEC($$, $1);
- $$->next = $2;
+storage_func_specs: storage_func_specs declspec_simple {
+ ALLOC_DECLSPEC($$, $2);
+ $$->next = $1;
}
type_qual_spec: typespec_noid | qualifier
-type_qual_specs: { $$ = NULL; } | type_qual_spec type_qual_specs {
- $$ = $1;
- $$->next = $2;
+type_qual_specs: { $$ = NULL; } | type_qual_specs type_qual_spec {
+ $$ = $2;
+ $$->next = $1;
}
/*
* together three different specifiers lists.
*/
post_specs: qualifiers typespec type_qual_specs {
- $2->next = $3;
- join_specs($2, $1);
- $$ = $2;
+ $$ = join_specs3($1, $2, $3);
}
english_declaration: storage_func_specs english_declarator post_specs {
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 | {
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);
}