X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/41ff7ec97691736525bb3da095afd5ca9a8ef003..00514ec7f1070550a52651971bb6a5e36efbe4f0:/src/parse.y

diff --git a/src/parse.y b/src/parse.y
index f507d5b..14d593e 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -41,17 +41,67 @@
 	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_STRUCT(ptr, type, ...) do { \
-	ALLOC(ptr, sizeof (type)); \
-	*(ptr) = (type) { __VA_ARGS__ }; \
+#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_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)
 
 /*
@@ -59,7 +109,13 @@
  * 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 {
@@ -76,10 +132,10 @@ const char *cdecl__token_name(unsigned token);
 	uintmax_t uintval;
 	unsigned spectype;
 	_Bool boolval;
-	char *strval;
 	struct cdecl_declspec *declspec;
 	struct cdecl_declarator *declarator;
 	struct cdecl *decl;
+	struct parse_item *item;
 }
 
 %{
@@ -91,7 +147,6 @@ static void free_declspec(struct cdecl_declspec *x)
 	struct cdecl_declspec *p;
 	while (x) {
 		p = x->next;
-		free(x->ident);
 		free(x);
 		x = p;
 	}
@@ -106,16 +161,13 @@ static void free_declarator(struct cdecl_declarator *x)
 
 		switch (x->type) {
 		case CDECL_DECL_NULL:
-			break;
+			x = NULL;
 		case CDECL_DECL_IDENT:
-			free(x->u.ident);
+		case CDECL_DECL_ARRAY:
 			break;
 		case CDECL_DECL_POINTER:
 			free_declspec(x->u.pointer.qualifiers);
 			break;
-		case CDECL_DECL_ARRAY:
-			free(x->u.array.vla);
-			break;
 		case CDECL_DECL_FUNCTION:
 			free_decl(x->u.function.parameters);
 			break;
@@ -167,31 +219,36 @@ static void join_specs(struct cdecl_declspec *a, struct cdecl_declspec *b)
  * Alter an abstract declarator (type name) to declare an identifier instead,
  * used by the English parser rules to reduce "identifier as type" sequences.
  */
-static struct cdecl *insert_identifier(struct cdecl *decl, char *ident)
+static struct cdecl *insert_identifier(struct cdecl *decl, struct parse_item *ident)
 {
-	struct cdecl_declarator *d = decl->declarators;
+	struct cdecl_declarator *d, **p = &decl->declarators;
 
-	while (d->child)
-		d = d->child;
-
-	d->type = CDECL_DECL_IDENT;
-	d->u.ident = ident;
+	while ((d = *p)->child)
+		p = &d->child;
 
+	*p = &ident->u.declarator;
 	return decl;
 }
+
+static struct cdecl_declarator *nulldecl(void)
+{
+	static const struct cdecl_declarator nulldecl = {0};
+	return (void *)&nulldecl;
+}
+#define NULLDECL (nulldecl())
+
 %}
 
-%destructor { free($$); }            <strval>
+%destructor { free($$); }            <item>
 %destructor { free_declspec($$); }   <declspec>
 %destructor { free_declarator($$); } <declarator>
 %destructor { free_decl($$); }       <decl>
 
 /* Magic tokens */
 %token T_LEX_ERROR
-%token T_ENGLISH
 
-%token <strval> T_IDENT "identifier"
-%token <uintval> T_UINT "integer constant"
+%token <item>    T_IDENT "identifier"
+%token <uintval> T_UINT  "integer constant"
 
 %token T_SEMICOLON ";"
 %token T_ASTERISK  "*"
@@ -245,7 +302,7 @@ static struct cdecl *insert_identifier(struct cdecl *decl, char *ident)
 %token T_AS        "as"
 %token T_VLA       "variable-length"
 
-%type <strval>     vla_ident
+%type <item>       vla_ident
 %type <uintval>    array_length
 %type <boolval>    varargs
 %type <spectype>   declspec_simple qualifier_simple
@@ -255,33 +312,25 @@ static struct cdecl *insert_identifier(struct cdecl *decl, char *ident)
 %type <declspec>   declspecs declspecs_noid
 %type <declarator> direct_declarator declarator pointer array parens postfix
 %type <declarator> direct_declarator_ish declarator_ish parameter_type_list
-%type <decl>       declaration declarators declarator_wrap
-%type <decl>       parameter
+%type <decl>       cdecl declaration declarators declarator_wrap parameter
 
-%type <strval>     english_vla
+%type <item>       english_vla
 %type <declspec>   storage_func_specs post_specs
 %type <declspec>   type_qual_spec type_qual_specs typedef_name_qual
 %type <declarator> english_declarator english_array english_function
 %type <declarator> english_parameter_list null_decl
-%type <decl>       english english_declaration
-%type <decl>       english_parameter
+%type <decl>       english english_declaration english_parameter
 
-/*
- * Harmless shift/reduce conflicts in english_parameter.  See comments below
- * for more details.
- */
-%expect 2
+/* Precedence declaration to avoid conflict in english_parameter; see below. */
+%right T_TYPE
+%right T_IDENT
 
 %%
 
-input: T_ENGLISH english {
-	*out = $2;
-} | declaration {
-	*out = $1;
-};
+input: cdecl { *out = $1; }
+cdecl: english | declaration
 
 semi: | T_SEMICOLON
-
 declaration: declspecs declarators semi {
 	$$ = $2;
 	$$->specifiers = $1;
@@ -327,7 +376,7 @@ declarators: declarator_wrap | declarator_wrap T_COMMA declarators {
 }
 
 declarator_wrap: declarator {
-	ALLOC_STRUCT($$, struct cdecl, .declarators = $1);
+	ALLOC_DECL($$, NULL, $1);
 }
 
 declspec_simple: T_AUTO
@@ -356,54 +405,43 @@ qualifier_simple: T_CONST
 	| 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 {
-	ALLOC_STRUCT($$, struct cdecl_declspec,
-		.type  = $1,
-		.ident = $2);
+	/* Compiler should be able to elide this assignment. */
+	$2->u.declspec.ident = $2->u.declarator.u.ident;
+
+	$$ = &$2->u.declspec;
+	$$->type = $1;
 }
 
 declspec_noid: declspec_notype | typespec_noid
 
 vla_ident: T_IDENT | T_ASTERISK {
-	ALLOC($$, sizeof "");
-	*$$ = 0;
+	if (!($$ = cdecl__alloc_item(1)))
+		YYERROR;
+	*$$->s = 0;
 }
 
 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 {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_ARRAY,
-		.u.array.vla = $2);
+	$$ = &$2->u.declarator;
+	$$->type = CDECL_DECL_ARRAY;
+	$$->u.array.vla = $$->u.ident;
+	$$->u.array.length = 0;
 }
 
 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;
@@ -413,22 +451,16 @@ parameter_type_list: parameter varargs {
 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
@@ -436,20 +468,16 @@ declarator_ish: direct_declarator_ish | pointer
 postfix: array | parens
 
 direct_declarator_ish: {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_NULL);
+	$$ = NULLDECL;
 } | direct_declarator_ish postfix {
 	$$ = $2;
 	$$->child = $1;
 }
 
 direct_declarator: {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_NULL);
+	$$ = NULLDECL;
 } | T_IDENT {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_IDENT,
-		.u.ident = $1);
+	$$ = &$1->u.declarator;
 } | direct_declarator postfix {
 	$$ = $2;
 	$$->child = $1;
@@ -461,10 +489,14 @@ english: T_DECLARE T_IDENT T_AS english_declaration {
 	$$ = $2;
 }
 
-storage_func_specs: { $$ = NULL; } | declspec_simple storage_func_specs {
-	ALLOC_STRUCT($$, struct cdecl_declspec,
-		.type = $1,
-		.next = $2);
+/*
+ * We use a precedence declaration to prefer shifting an identifier
+ * 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;
 }
 
 type_qual_spec: typespec_noid | qualifier
@@ -487,19 +519,13 @@ post_specs: qualifiers typespec type_qual_specs {
 
 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: {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_NULL);
+	$$ = 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;
@@ -509,18 +535,13 @@ english_declarator: {
 }
 
 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;
@@ -528,43 +549,45 @@ english_parameter_list: english_parameter varargs {
 }
 
 typedef_name_qual: T_IDENT qualifiers {
-	ALLOC_STRUCT($$, struct cdecl_declspec,
-		.type = CDECL_TYPE_IDENT,
-		.ident = $1,
-		.next = $2);
+	/* Compiler should be able to elide this assignment. */
+	$1->u.declspec.ident = $1->u.declarator.u.ident;
+
+	$$ = &$1->u.declspec;
+	$$->type = CDECL_TYPE_IDENT;
+	$$->next = $2;
 }
 
 null_decl: {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_NULL);
+	$$ = NULLDECL;
 }
 
 /*
- * There is a small shift/reduce conflict here.  An unadorned identifier
- * as the first thing in the parameter might be a typedef name deep in the
- * first english_declaration (thus empty storage_func_specs and empty
- * english_declarator need to be reduced) or it might be the identifier
- * before the "as" (thus the identifier should be shifted).
+ * There is a shift/reduce conflict here when an identifier appears as the
+ * first token.  The conflict is between shifting T_IDENT, or reducing the
+ * empty production for storage_func_specs (cf. english_declaration).
+ *
+ *   - In either case, if we reduce, we won't match T_IDENT T_AS since the
+ *     stack now has the extra storage_func_specs nonterminal symbol.
+ *   - And if we shift, we won't match english_declaration since it is
+ *     too late to add storage_func_specs to the stack.
  *
- * The typedef name conflict is the only issue, so treating it as a special
- * case makes the shift harmless.
+ * The only valid input affected by the conflict is a simple type names,
+ * possibly followed by qualifiers.  So the conflict is adequately resolved
+ * 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);
 }
 
 english_array: T_VLA T_ARRAY english_vla T_OF {
-	ALLOC_STRUCT($$, struct cdecl_declarator,
-		.type = CDECL_DECL_ARRAY,
-		.u.array.vla = $3);
+	$$ = &$3->u.declarator;
+	$$->type = CDECL_DECL_ARRAY;
+	$$->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; }
@@ -574,8 +597,9 @@ array_length: T_UINT {
 }
 
 english_vla: T_IDENT | {
-	ALLOC($$, sizeof "");
-	*$$ = 0;
+	if (!($$ = cdecl__alloc_item(1)))
+		YYERROR;
+	*$$->s = 0;
 }
 
 %%