X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/3df85155e2dbf9307dd64bd222bf74389c45a75c..b126a7b2d76bffbe16dd439b8049898442191536:/src/parse.y diff --git a/src/parse.y b/src/parse.y index 5bcd9a9..918cbd0 100644 --- a/src/parse.y +++ b/src/parse.y @@ -1,7 +1,7 @@ %code top { /* * Parser for C declarations. - * Copyright © 2011 Nick Bowler + * Copyright © 2011-2012, 2021, 2023 Nick Bowler * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -19,7 +19,7 @@ } %name-prefix "cdecl__yy" -%parse-param {yyscan_t scanner} +%parse-param {void *scanner} %parse-param {struct cdecl **out} %lex-param {yyscan_t scanner} %define api.pure @@ -32,8 +32,9 @@ #include #include "scan.h" -#include "error.h" #include "cdecl.h" +#include "cdecl-internal.h" +#include "errmsg.h" #define FAIL(msg) do { \ yyerror(&yylloc, NULL, NULL, msg); \ @@ -42,8 +43,10 @@ #define ALLOC(ptr, size) do { \ (ptr) = malloc(size); \ - if (!(ptr)) \ - FAIL("failed to allocate memory"); \ + if (!(ptr)) { \ + cdecl__errmsg(CDECL__ENOMEM); \ + YYERROR; \ + } \ } while (0) #define ALLOC_STRUCT(ptr, type, ...) do { \ @@ -57,12 +60,14 @@ } %code provides { -void cdecl__yyerror(YYLTYPE *, void *, struct cdecl **, const char *); +void cdecl__free(struct cdecl *); int cdecl__yyparse(void *scanner, struct cdecl **out); +const char *cdecl__token_name(unsigned token); } %union { uintmax_t uintval; + unsigned spectype; _Bool boolval; char *strval; struct cdecl_declspec *declspec; @@ -71,6 +76,7 @@ int cdecl__yyparse(void *scanner, struct cdecl **out); } %{ +static void yyerror(YYLTYPE *, yyscan_t, struct cdecl **, const char *); static void free_decl(struct cdecl *); static void free_declspec(struct cdecl_declspec *x) @@ -132,10 +138,40 @@ static void free_decl(struct cdecl *x) } } -void cdecl_free(struct cdecl *decl) +void cdecl__free(struct cdecl *decl) { free_decl(decl); } + +/* + * 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) +{ + while (a->next) + a = a->next; + a->next = 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) +{ + struct cdecl_declarator *d = decl->declarators; + + while (d->child) + d = d->child; + + d->type = CDECL_DECL_IDENT; + d->u.ident = ident; + + return decl; +} %} %destructor { free($$); } @@ -159,34 +195,34 @@ void cdecl_free(struct cdecl *decl) %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. @@ -203,23 +239,25 @@ void cdecl_free(struct cdecl *decl) %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 @@ -239,11 +277,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; @@ -271,29 +323,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 + +qualifier_simple: T_CONST + | T_RESTRICT + | T_VOLATILE declspec_notype: qualifier | declspec_simple { ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1); @@ -307,17 +361,9 @@ 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, @@ -332,10 +378,7 @@ vla_ident: T_IDENT | T_ASTERISK { strcpy($$, ""); } -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); @@ -343,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 { @@ -354,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 { @@ -422,13 +453,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; } @@ -452,27 +477,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: { @@ -499,25 +513,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, @@ -546,30 +551,23 @@ 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 | { @@ -578,15 +576,25 @@ english_vla: T_IDENT | { } %% -void -yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, - const char *err) + +/* + * Expose the token string table to the rest of the library, in order to + * produce strings that match parser keywords. + * + * In order for this to work properly, the Bison output must be postprocessed + * by fix-yytname.awk to remove pointless quotation marks from the keyword + * strings. + */ +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, "T_LEX_ERROR")) + if (strstr(err, yytname[YYTRANSLATE(T_LEX_ERROR)])) return; - cdecl__set_error(&(const struct cdecl_error){ - .code = CDECL_ENOPARSE, - .str = err, - }); + cdecl__err(CDECL_ENOPARSE, "%s", err); }