X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/1518db926f5b2b3fc8de28b2f99ee870c42cc230..0c61f9637a469ac7a28b5a329551b03e6ad14d62:/src/parse.y diff --git a/src/parse.y b/src/parse.y index 63d5fa9..a14f909 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 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 @@ -18,20 +18,25 @@ */ } +%name-prefix "cdecl__yy" +%parse-param {void *scanner} %parse-param {struct cdecl **out} +%lex-param {yyscan_t scanner} %define api.pure %error-verbose %locations %{ +#include #include #include #include "scan.h" #include "cdecl.h" +#include "cdecl-internal.h" #define FAIL(msg) do { \ - yyerror(&yylloc, NULL, msg); \ + yyerror(&yylloc, NULL, NULL, msg); \ YYERROR; \ } while (0) @@ -52,8 +57,9 @@ } %code provides { -void yyerror(YYLTYPE *, struct cdecl **, const char *); -int yyparse(struct cdecl **out); +void cdecl__free(struct cdecl *); +void cdecl__yyerror(YYLTYPE *, void *, struct cdecl **, const char *); +int cdecl__yyparse(void *scanner, struct cdecl **out); } %union { @@ -127,7 +133,7 @@ static void free_decl(struct cdecl *x) } } -void cdecl_free(struct cdecl *decl) +void cdecl__free(struct cdecl *decl) { free_decl(decl); } @@ -138,7 +144,9 @@ void cdecl_free(struct cdecl *decl) %destructor { free_declarator($$); } %destructor { free_decl($$); } +/* Magic tokens */ %token T_LEX_ERROR +%token T_ENGLISH %token T_IDENT "identifier" %token T_UINT "integer constant" @@ -150,35 +158,50 @@ void cdecl_free(struct cdecl *decl) %token T_LBRACKET "[" %token T_RBRACKET "]" %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_STRUCT "struct" -%token T_UNION "union" -%token T_ENUM "enum" +%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" + +/* + * English keywords. + */ +%token T_TYPE "type" +%token T_DECLARE "declare" +%token T_POINTER "pointer" +%token T_FUNCTION "function" +%token T_RETURNING "returning" +%token T_ARRAY "array" +%token T_TO "to" +%token T_OF "of" +%token T_AS "as" +%token T_VLA "variable-length" %type vla_ident %type varargs @@ -191,13 +214,31 @@ void cdecl_free(struct cdecl *decl) %type declaration declarators declarator_wrap %type parameter parameters +%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 + +/* + * Harmless shift/reduce conflicts in english_parameter. See comments below + * for more details. + */ +%expect 2 + %% -input: declaration { +input: T_ENGLISH english { + *out = $2; +} | declaration { *out = $1; }; -declaration: declspecs declarators T_SEMICOLON { +semi: | T_SEMICOLON + +declaration: declspecs declarators semi { $$ = $2; for (struct cdecl *i = $$; i; i = i->next) @@ -238,17 +279,18 @@ declspec_simple: T_AUTO { $$ = CDECL_STOR_AUTO; } | 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; } +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; } @@ -380,11 +422,171 @@ direct_declarator: { $$->child = $1; } +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; + } + } +} | T_TYPE english_declaration { + $$ = $2; +} + +storage_func_specs: { $$ = NULL; } | declspec_simple storage_func_specs { + ALLOC_STRUCT($$, struct cdecl_declspec, + .type = $1, + .next = $2); +} + +type_qual_spec: typespec_noid | qualifier + +type_qual_specs: { $$ = NULL; } | type_qual_spec type_qual_specs { + $$ = $1; + $$->next = $2; +} + +/* + * The "qualifiers" nonterminal needs to be used here to avoid shift/reduce + * conflicts with pointer declarators. So we end up needing to stitch + * together three different specifiers lists. + */ +post_specs: qualifiers typespec type_qual_specs { + $$ = $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 { + 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: { + ALLOC_STRUCT($$, struct cdecl_declarator, + .type = CDECL_DECL_NULL); +} | english_declarator qualifiers T_POINTER T_TO { + ALLOC_STRUCT($$, struct cdecl_declarator, + .type = CDECL_DECL_POINTER, + .child = $1, + .u.pointer.qualifiers = $2); +} | english_declarator english_array { + $$ = $2; + $$->child = $1; +} | english_declarator english_function { + $$ = $2; + $$->child = $1; +} + +english_function: T_FUNCTION T_RETURNING { + ALLOC_STRUCT($$, struct cdecl_declarator, + .type = CDECL_DECL_FUNCTION, + .u.function.parameters = NULL); +} | T_FUNCTION T_LPAREN english_parameter_list T_RPAREN 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; + } + + ALLOC_STRUCT($$, struct cdecl_declarator, + .type = CDECL_DECL_FUNCTION, + .u.function.parameters = p, + .u.function.variadic = $2); +} + +english_parameters: english_parameters T_COMMA english_parameter { + $$ = $3; + $$->next = $1; +} | english_parameter + +typedef_name_qual: T_IDENT qualifiers { + ALLOC_STRUCT($$, struct cdecl_declspec, + .type = CDECL_TYPE_IDENT, + .ident = $1, + .next = $2); +} + +null_decl: { + ALLOC_STRUCT($$, struct cdecl_declarator, + .type = CDECL_DECL_NULL); +} + +/* + * 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). + * + * The typedef name conflict is the only issue, so treating it as a special + * case makes the shift harmless. + */ +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; + } + } +} + +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"); + + 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); +} + +english_vla: T_IDENT | { + ALLOC($$, sizeof ""); + strcpy($$, ""); +} + %% -void yyerror(YYLTYPE *loc, struct cdecl **out, const char *err) +void +yyerror(YYLTYPE *loc, yyscan_t scanner, struct cdecl **out, const char *err) { if (strstr(err, "T_LEX_ERROR")) return; - fprintf(stderr, "%s\n", err); + cdecl__set_error(&(const struct cdecl_error){ + .code = CDECL_ENOPARSE, + .str = err, + }); }