X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/8ef7bb974c538e4802688d45296ee988a6648e02..83fa7018cb10ccff445c18f24cb69a82179fc5ed:/src/parse.y diff --git a/src/parse.y b/src/parse.y index e9df6cb..ec7ea1b 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 { @@ -76,6 +83,7 @@ const char *cdecl__token_name(unsigned token); } %{ +static void yyerror(YYLTYPE *, yyscan_t, struct cdecl **, const char *); static void free_decl(struct cdecl *); static void free_declspec(struct cdecl_declspec *x) @@ -142,13 +150,34 @@ void cdecl__free(struct cdecl *decl) free_decl(decl); } -static void -yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err) +/* + * Join two declaration specifier lists into a single list, with "a" being the + * head of the new list. + * + * The list "a" is assumed to be nonempty. + */ +static void join_specs(struct cdecl_declspec *a, struct cdecl_declspec *b) { - if (strstr(err, "T_LEX_ERROR")) - return; + while (a->next) + a = a->next; + a->next = b; +} - cdecl__err(CDECL_ENOPARSE, "%s", err); +/* + * 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) +{ + struct cdecl_declarator *d = decl->declarators; + + while (d->child) + d = d->child; + + d->type = CDECL_DECL_IDENT; + d->u.ident = ident; + + return decl; } %} @@ -159,7 +188,6 @@ yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err) /* Magic tokens */ %token T_LEX_ERROR -%token T_ENGLISH %token T_IDENT "identifier" %token T_UINT "integer constant" @@ -217,6 +245,7 @@ yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err) %token T_VLA "variable-length" %type vla_ident +%type array_length %type varargs %type declspec_simple qualifier_simple %type typespec_simple typespec_tagged @@ -226,26 +255,24 @@ yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err) %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 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; }; @@ -254,11 +281,25 @@ semi: | T_SEMICOLON declaration: declspecs declarators semi { $$ = $2; - - for (struct cdecl *i = $$; i; i = i->next) - i->specifiers = $1; + $$->specifiers = $1; }; +/* + * We support parsing declarations using arbitrary identifiers as type + * specifiers (a la C typedef). To avoid confusion with identifiers that + * may also be used as declarators, note the following: + * + * (a) Every valid C declaration must have at least one type specifier, and + * (b) Valid declarations with typedef names have exactly one type specifier. + * + * So the rule applied when parsing specifiers is: an identifier is a type + * specifier only if we have not yet seen any type specifiers whatsoever + * (within one declaration specifier list). + * + * Treating identifiers as type specifiers by default can lead to strange and + * unexpected parses; libcdecl applies a simplification step to the resulting + * parse tree afterwards. + */ declspecs: declspec_notype declspecs { $$ = $1; $$->next = $2; @@ -306,7 +347,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 @@ -328,23 +369,16 @@ 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); } declspec_noid: declspec_notype | typespec_noid vla_ident: T_IDENT | T_ASTERISK { ALLOC($$, sizeof ""); - strcpy($$, ""); + *$$ = 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); @@ -352,9 +386,6 @@ array: T_LBRACKET T_UINT 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); } parameter: declspecs declarator { @@ -363,26 +394,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 { @@ -431,18 +453,17 @@ direct_declarator: { } english: T_DECLARE T_IDENT T_AS english_declaration { - $$ = $4; - for (struct cdecl_declarator *d = $$->declarators; d; d = d->child) { - if (d->type == CDECL_DECL_NULL) { - d->type = CDECL_DECL_IDENT; - d->u.ident = $2; - } - } + $$ = insert_identifier($4, $2); } | T_TYPE 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); @@ -461,27 +482,16 @@ type_qual_specs: { $$ = NULL; } | type_qual_spec type_qual_specs { * together three different specifiers lists. */ post_specs: qualifiers typespec type_qual_specs { + $2->next = $3; + join_specs($2, $1); $$ = $2; - $$->next = $1; - for (struct cdecl_declspec *s = $$; s; s = s->next) { - if (!s->next) { - s->next = $3; - break; - } - } } english_declaration: storage_func_specs english_declarator post_specs { + join_specs($3, $1); ALLOC_STRUCT($$, struct cdecl, .specifiers = $3, .declarators = $2); - - for (struct cdecl_declspec *s = $$->specifiers; s; s = s->next) { - if (!s->next) { - s->next = $1; - break; - } - } } english_declarator: { @@ -508,25 +518,16 @@ 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, @@ -541,49 +542,46 @@ null_decl: { } /* - * 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). * - * The typedef name conflict is the only issue, so treating it as a special - * case makes the shift harmless. + * - 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 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); } | T_IDENT T_AS english_declaration { - $$ = $3; - for (struct cdecl_declarator *d = $$->declarators; d; d = d->child) { - if (d->type == CDECL_DECL_NULL) { - d->type = CDECL_DECL_IDENT; - d->u.ident = $1; - } - } + $$ = 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); -} | T_ARRAY T_UINT T_OF { - if ($2 == 0) - FAIL(_("array length must be positive")); - +} | 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($$, ""); + *$$ = 0; } %% @@ -600,3 +598,12 @@ const char *cdecl__token_name(unsigned token) { return yytname[YYTRANSLATE(token)]; } + +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); +}