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_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_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_ITEM_DECLARATOR(ptr); \
+ (ptr)->child = child_; \
+ (ptr)->type = CDECL_DECL_POINTER; \
+ (ptr)->u.pointer.qualifiers = qualifiers_; \
} while (0)
-#define ALLOC_STRUCT(ptr, type, ...) do { \
- ALLOC(ptr, sizeof (type)); \
- *(ptr) = (type) { __VA_ARGS__ }; \
+#define ALLOC_DECLSPEC(ptr, type_) do { \
+ ALLOC_ITEM_DECLSPEC(ptr); \
+ (ptr)->type = type_; \
+ (ptr)->ident = NULL; \
+} while (0)
+
+#define ALLOC_DECL(ptr, specifiers_, declarators_) do { \
+ ALLOC_ITEM_DECL(ptr); \
+ (ptr)->specifiers = specifiers_; \
+ (ptr)->declarators = declarators_; \
} 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;
}
declarator_wrap: declarator {
- ALLOC_STRUCT($$, struct cdecl, .declarators = $1);
+ ALLOC_DECL($$, NULL, $1);
}
declspec_simple: T_AUTO
| T_RESTRICT
| T_VOLATILE
-declspec_notype: qualifier | declspec_simple {
- ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1);
-}
-
-typespec_noid: typespec_simple {
- ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1);
-}
-
-qualifier: qualifier_simple {
- ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1);
-}
+declspec_notype: qualifier | declspec_simple { ALLOC_DECLSPEC($$, $1); }
+typespec_noid: typespec_simple { ALLOC_DECLSPEC($$, $1); }
+qualifier: qualifier_simple { ALLOC_DECLSPEC($$, $1); }
typespec: typespec_noid | typespec_tagged T_IDENT {
/* Compiler should be able to elide this assignment. */
}
array: T_LBRACKET array_length T_RBRACKET {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_ARRAY,
- .u.array.length = $2);
+ ALLOC_ARRAY($$, $2);
} | T_LBRACKET vla_ident T_RBRACKET {
$$ = &$2->u.declarator;
$$->type = CDECL_DECL_ARRAY;
}
parameter: declspecs declarator {
- ALLOC_STRUCT($$, struct cdecl,
- .specifiers = $1,
- .declarators = $2);
+ ALLOC_DECL($$, $1, $2);
}
varargs: { $$ = false; } | T_COMMA T_ELLIPSIS { $$ = true; }
parameter_type_list: parameter varargs {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_FUNCTION,
- .u.function.parameters = $1,
- .u.function.variadic = $2);
+ ALLOC_FUNCTION($$, $1, $2);
} | parameter T_COMMA parameter_type_list {
$$ = $3;
$1->next = $$->u.function.parameters;
parens: T_LPAREN parameter_type_list T_RPAREN {
$$ = $2;
} | T_LPAREN declarator_ish T_RPAREN {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_FUNCTION);
- ALLOC_STRUCT($$->u.function.parameters, struct cdecl,
- .declarators = $2);
+ struct cdecl *fake_params;
+
+ ALLOC_DECL(fake_params, NULL, $2);
+ ALLOC_FUNCTION($$, fake_params, false);
}
pointer: T_ASTERISK qualifiers direct_declarator {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_POINTER,
- .u.pointer.qualifiers = $2,
- .child = $3);
+ ALLOC_POINTER($$, $2, $3);
} | T_ASTERISK qualifiers pointer {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_POINTER,
- .u.pointer.qualifiers = $2,
- .child = $3);
+ ALLOC_POINTER($$, $2, $3);
}
declarator: direct_declarator | pointer
*/
storage_func_specs: %prec T_TYPE { $$ = NULL; }
storage_func_specs: declspec_simple storage_func_specs {
- ALLOC_STRUCT($$, struct cdecl_declspec,
- .type = $1,
- .next = $2);
+ ALLOC_DECLSPEC($$, $1);
+ $$->next = $2;
}
type_qual_spec: typespec_noid | qualifier
english_declaration: storage_func_specs english_declarator post_specs {
join_specs($3, $1);
- ALLOC_STRUCT($$, struct cdecl,
- .specifiers = $3,
- .declarators = $2);
+ ALLOC_DECL($$, $3, $2);
}
english_declarator: {
$$ = NULLDECL;
} | english_declarator qualifiers T_POINTER T_TO {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_POINTER,
- .child = $1,
- .u.pointer.qualifiers = $2);
+ ALLOC_POINTER($$, $2, $1);
} | english_declarator english_array {
$$ = $2;
$$->child = $1;
}
english_function: T_FUNCTION T_RETURNING {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_FUNCTION,
- .u.function.parameters = NULL);
+ ALLOC_FUNCTION($$, NULL, false);
} | T_FUNCTION T_LPAREN english_parameter_list T_RPAREN T_RETURNING {
$$ = $3;
}
english_parameter_list: english_parameter varargs {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_FUNCTION,
- .u.function.parameters = $1,
- .u.function.variadic = $2);
+ ALLOC_FUNCTION($$, $1, $2);
} | english_parameter T_COMMA english_parameter_list {
$$ = $3;
$1->next = $$->u.function.parameters;
* by shifting, so long as we have a special-case reduction to handle this.
*/
english_parameter: english_declaration | typedef_name_qual null_decl {
- ALLOC_STRUCT($$, struct cdecl,
- .specifiers = $1,
- .declarators = $2);
+ ALLOC_DECL($$, $1, $2);
} | T_IDENT T_AS english_declaration {
$$ = insert_identifier($3, $1);
}
$$->u.array.vla = $$->u.ident;
$$->u.array.length = 0;
} | T_ARRAY array_length T_OF {
- ALLOC_STRUCT($$, struct cdecl_declarator,
- .type = CDECL_DECL_ARRAY,
- .u.array.length = $2);
+ ALLOC_ARRAY($$, $2);
}
array_length: { $$ = 0; }