X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/566e87bb15a98ed499e79b45f6c834ad0ffdc3b7..41ff7ec97691:/src/parse.y diff --git a/src/parse.y b/src/parse.y index 263129c..f507d5b 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; } %} @@ -173,34 +202,34 @@ yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err) %token T_COMMA "," %token T_ELLIPSIS "..." -%token T_TYPEDEF "typedef" -%token T_EXTERN "extern" -%token T_STATIC "static" -%token T_AUTO "auto" -%token T_REGISTER "register" - -%token T_INLINE "inline" - -%token T_RESTRICT "restrict" -%token T_VOLATILE "volatile" -%token T_CONST "const" - -%token T_VOID "void" -%token T_CHAR "char" -%token T_SHORT "short" -%token T_INT "int" -%token T_LONG "long" -%token T_FLOAT "float" -%token T_DOUBLE "double" -%token T_SIGNED "signed" -%token T_UNSIGNED "unsigned" -%token T_BOOL "_Bool" -%token T_COMPLEX "_Complex" -%token T_IMAGINARY "_Imaginary" - -%token T_STRUCT "struct" -%token T_UNION "union" -%token T_ENUM "enum" +%token T_TYPEDEF "typedef" +%token T_EXTERN "extern" +%token T_STATIC "static" +%token T_AUTO "auto" +%token T_REGISTER "register" + +%token T_INLINE "inline" + +%token T_RESTRICT "restrict" +%token T_VOLATILE "volatile" +%token T_CONST "const" + +%token T_VOID "void" +%token T_CHAR "char" +%token T_SHORT "short" +%token T_INT "int" +%token T_LONG "long" +%token T_FLOAT "float" +%token T_DOUBLE "double" +%token T_SIGNED "signed" +%token T_UNSIGNED "unsigned" +%token T_BOOL "_Bool" +%token T_COMPLEX "_Complex" +%token T_IMAGINARY "_Imaginary" + +%token T_STRUCT "struct" +%token T_UNION "union" +%token T_ENUM "enum" /* * English keywords. @@ -217,23 +246,25 @@ 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 typespec_simple qualifier_simple +%type declspec_simple qualifier_simple +%type typespec_simple typespec_tagged %type declspec_notype declspec_noid typespec_noid typespec %type qualifier qualifiers %type declspecs declspecs_noid %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 @@ -253,11 +284,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; @@ -285,29 +330,31 @@ declarator_wrap: declarator { ALLOC_STRUCT($$, struct cdecl, .declarators = $1); } -declspec_simple: T_AUTO { $$ = CDECL_STOR_AUTO; } - | T_TYPEDEF { $$ = CDECL_STOR_TYPEDEF; } - | T_EXTERN { $$ = CDECL_STOR_EXTERN; } - | T_STATIC { $$ = CDECL_STOR_STATIC; } - | T_REGISTER { $$ = CDECL_STOR_REGISTER; } - | T_INLINE { $$ = CDECL_FUNC_INLINE; } - -typespec_simple: T_VOID { $$ = CDECL_TYPE_VOID; } - | T_CHAR { $$ = CDECL_TYPE_CHAR; } - | T_SHORT { $$ = CDECL_TYPE_SHORT; } - | T_INT { $$ = CDECL_TYPE_INT; } - | T_LONG { $$ = CDECL_TYPE_LONG; } - | T_FLOAT { $$ = CDECL_TYPE_FLOAT; } - | T_DOUBLE { $$ = CDECL_TYPE_DOUBLE; } - | T_SIGNED { $$ = CDECL_TYPE_SIGNED; } - | T_UNSIGNED { $$ = CDECL_TYPE_UNSIGNED; } - | T_BOOL { $$ = CDECL_TYPE_BOOL; } - | T_COMPLEX { $$ = CDECL_TYPE_COMPLEX; } - | T_IMAGINARY { $$ = CDECL_TYPE_IMAGINARY; } - -qualifier_simple: T_CONST { $$ = CDECL_QUAL_CONST; } - | T_RESTRICT { $$ = CDECL_QUAL_RESTRICT; } - | T_VOLATILE { $$ = CDECL_QUAL_VOLATILE; } +declspec_simple: T_AUTO + | T_TYPEDEF + | T_EXTERN + | T_STATIC + | T_REGISTER + | T_INLINE + +typespec_simple: T_VOID + | T_CHAR + | T_SHORT + | T_INT + | T_LONG + | T_FLOAT + | T_DOUBLE + | T_SIGNED + | T_UNSIGNED + | T_BOOL + | T_COMPLEX + | T_IMAGINARY + +typespec_tagged: T_STRUCT | T_UNION | T_ENUM | { $$ = CDECL_TYPE_IDENT; } + +qualifier_simple: T_CONST + | T_RESTRICT + | T_VOLATILE declspec_notype: qualifier | declspec_simple { ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1); @@ -321,35 +368,20 @@ qualifier: qualifier_simple { ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1); } -typespec: typespec_noid | T_STRUCT T_IDENT { - ALLOC_STRUCT($$, struct cdecl_declspec, - .type = CDECL_TYPE_STRUCT, - .ident = $2); -} | T_UNION T_IDENT { - ALLOC_STRUCT($$, struct cdecl_declspec, - .type = CDECL_TYPE_UNION, - .ident = $2); -} | T_ENUM T_IDENT { +typespec: typespec_noid | typespec_tagged T_IDENT { ALLOC_STRUCT($$, struct cdecl_declspec, - .type = CDECL_TYPE_ENUM, + .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); @@ -357,9 +389,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 { @@ -368,26 +397,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 { @@ -436,13 +456,7 @@ 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; } @@ -466,27 +480,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: { @@ -513,25 +516,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, @@ -560,35 +554,28 @@ english_parameter: english_declaration | typedef_name_qual null_decl { .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; } %% @@ -605,3 +592,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); +}