X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/5383a8b913e74ebe5faa39ef3e570afb95779141..21bc2db0ec83b235caec38d42f4d0812f473d766:/src/parse.y diff --git a/src/parse.y b/src/parse.y index 0156bb3..ba9bf22 100644 --- a/src/parse.y +++ b/src/parse.y @@ -53,6 +53,13 @@ ALLOC(ptr, sizeof (type)); \ *(ptr) = (type) { __VA_ARGS__ }; \ } while (0) + +/* + * With the postprocessing performed by fix-yytname.awk, all the symbol + * 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) %} %code requires { @@ -69,10 +76,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; } %{ @@ -84,7 +91,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; } @@ -99,16 +105,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; @@ -160,31 +163,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; - - while (d->child) - d = d->child; + struct cdecl_declarator *d, **p = &decl->declarators; - 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($$); } +%destructor { free($$); } %destructor { free_declspec($$); } %destructor { free_declarator($$); } %destructor { free_decl($$); } /* Magic tokens */ %token T_LEX_ERROR -%token T_ENGLISH -%token T_IDENT "identifier" -%token T_UINT "integer constant" +%token T_IDENT "identifier" +%token T_UINT "integer constant" %token T_SEMICOLON ";" %token T_ASTERISK "*" @@ -238,7 +246,8 @@ static struct cdecl *insert_identifier(struct cdecl *decl, char *ident) %token T_AS "as" %token T_VLA "variable-length" -%type vla_ident +%type vla_ident +%type array_length %type varargs %type declspec_simple qualifier_simple %type typespec_simple typespec_tagged @@ -248,26 +257,24 @@ static struct cdecl *insert_identifier(struct cdecl *decl, char *ident) %type direct_declarator declarator pointer array parens postfix %type direct_declarator_ish declarator_ish parameter_type_list %type declaration declarators declarator_wrap -%type parameter parameters +%type parameter -%type english_vla +%type english_vla %type storage_func_specs post_specs %type type_qual_spec type_qual_specs typedef_name_qual %type english_declarator english_array english_function %type english_parameter_list null_decl -%type english_parameter english_parameters %type english english_declaration +%type 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; +input: english { + *out = $1; } | declaration { *out = $1; }; @@ -342,7 +349,7 @@ typespec_simple: T_VOID | T_COMPLEX | T_IMAGINARY -typespec_tagged: T_STRUCT | T_UNION | T_ENUM +typespec_tagged: T_STRUCT | T_UNION | T_ENUM | { $$ = CDECL_TYPE_IDENT; } qualifier_simple: T_CONST | T_RESTRICT @@ -361,36 +368,30 @@ qualifier: qualifier_simple { } typespec: typespec_noid | typespec_tagged T_IDENT { - ALLOC_STRUCT($$, struct cdecl_declspec, - .type = $1, - .ident = $2); -} | T_IDENT { - ALLOC_STRUCT($$, struct cdecl_declspec, - .type = CDECL_TYPE_IDENT, - .ident = $1); + /* 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 ""); - strcpy($$, ""); + if (!($$ = cdecl__alloc_item(1))) + YYERROR; + *$$->s = 0; } -array: T_LBRACKET T_UINT T_RBRACKET { - if ($2 == 0) - FAIL(_("array length must be positive")); - +array: T_LBRACKET array_length T_RBRACKET { ALLOC_STRUCT($$, struct cdecl_declarator, .type = CDECL_DECL_ARRAY, .u.array.length = $2); } | T_LBRACKET vla_ident T_RBRACKET { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_ARRAY, - .u.array.vla = $2); -} | T_LBRACKET T_RBRACKET { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_ARRAY); + $$ = &$2->u.declarator; + $$->type = CDECL_DECL_ARRAY; + $$->u.array.vla = $$->u.ident; + $$->u.array.length = 0; } parameter: declspecs declarator { @@ -399,26 +400,17 @@ parameter: declspecs declarator { .declarators = $2); } -parameters: parameter | parameters T_COMMA parameter { - $$ = $3; - $$->next = $1; -} - varargs: { $$ = false; } | T_COMMA T_ELLIPSIS { $$ = true; } -parameter_type_list: parameters varargs { - struct cdecl *p, *c, *n; - - /* Parameters were accumulated in reverse order. */ - for (p = NULL, c = $1; c; p = c, c = n) { - n = c->next; - c->next = p; - } - +parameter_type_list: parameter varargs { ALLOC_STRUCT($$, struct cdecl_declarator, .type = CDECL_DECL_FUNCTION, - .u.function.parameters = p, + .u.function.parameters = $1, .u.function.variadic = $2); +} | parameter T_COMMA parameter_type_list { + $$ = $3; + $1->next = $$->u.function.parameters; + $$->u.function.parameters = $1; } parens: T_LPAREN parameter_type_list T_RPAREN { @@ -447,20 +439,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; @@ -472,7 +460,12 @@ english: T_DECLARE T_IDENT T_AS english_declaration { $$ = $2; } -storage_func_specs: { $$ = NULL; } | declspec_simple storage_func_specs { +/* + * 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_STRUCT($$, struct cdecl_declspec, .type = $1, .next = $2); @@ -504,8 +497,7 @@ english_declaration: storage_func_specs english_declarator post_specs { } 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, @@ -527,47 +519,43 @@ english_function: T_FUNCTION T_RETURNING { $$ = $3; } -english_parameter_list: english_parameters varargs { - struct cdecl *p, *c, *n; - - /* Parameters were accumulated in reverse order. */ - for (p = NULL, c = $1; c; p = c, c = n) { - n = c->next; - c->next = p; - } - +english_parameter_list: english_parameter varargs { ALLOC_STRUCT($$, struct cdecl_declarator, .type = CDECL_DECL_FUNCTION, - .u.function.parameters = p, + .u.function.parameters = $1, .u.function.variadic = $2); -} - -english_parameters: english_parameters T_COMMA english_parameter { +} | english_parameter T_COMMA english_parameter_list { $$ = $3; - $$->next = $1; -} | english_parameter + $1->next = $$->u.function.parameters; + $$->u.function.parameters = $1; +} 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, @@ -578,25 +566,26 @@ english_parameter: english_declaration | typedef_name_qual null_decl { } english_array: T_VLA T_ARRAY english_vla T_OF { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_ARRAY, - .u.array.vla = $3); -} | T_ARRAY T_UINT T_OF { - if ($2 == 0) - FAIL(_("array length must be positive")); - + $$ = &$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); -} | T_ARRAY T_OF { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_ARRAY, - .u.array.length = 0); +} + +array_length: { $$ = 0; } +array_length: T_UINT { + if (!($$ = $1)) + FAIL(_("array length must be positive")); } english_vla: T_IDENT | { - ALLOC($$, sizeof ""); - strcpy($$, ""); + if (!($$ = cdecl__alloc_item(1))) + YYERROR; + *$$->s = 0; } %%