X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/1ef30936f5fdb253b397347b91521455d0c39172..eda9528293fbc32857a5856a30ebd6585b281215:/src/parse.y diff --git a/src/parse.y b/src/parse.y index 8631f3b..14d593e 100644 --- a/src/parse.y +++ b/src/parse.y @@ -41,17 +41,67 @@ YYERROR; \ } while (0) -#define ALLOC(ptr, size) do { \ - (ptr) = malloc(size); \ - if (!(ptr)) { \ - cdecl__errmsg(CDECL__ENOMEM); \ +/* + * Allocate a parse tree node via cdecl__alloc_item. + * + * - m1 specifies the item's union member to assign to ptr, which selects the + * type of node to allocate. + * + * - m2 specifies the "next" or "child" member, which is initialized to a null + * pointer. The cdecl__alloc_item function sets the declarator.child member + * to null; we explicitly copy this null pointer to the returned union member + * to avoid type punning. It is hoped that compilers will notice that these + * pointers are at the same offset therefore the assignment can be elided. + * + * The resulting pointer can be passed directly to free, as the union is the + * first member of the parse_item structure. + * + * Use the wrapper macros below instead of this one. + */ +#define ALLOC_ITEM(ptr, m1, m2) do { \ + struct parse_item *item; \ + if (!(item = cdecl__alloc_item(0))) \ YYERROR; \ - } \ + item->u.m1.m2 = (void *)item->u.declarator.child; \ + (ptr) = &item->u.m1; \ +} while (0) + +/* Wrappers for ALLOC_ITEM to allocate various kinds of parser structures. */ +#define ALLOC_ITEM_DECLARATOR(ptr) ALLOC_ITEM(ptr, declarator, child) +#define ALLOC_ITEM_DECLSPEC(ptr) ALLOC_ITEM(ptr, declspec, next) +#define ALLOC_ITEM_DECL(ptr) ALLOC_ITEM(ptr, decl, next) + +#define ALLOC_FUNCTION(ptr, parameters_, variadic_) do { \ + ALLOC_ITEM_DECLARATOR(ptr); \ + (ptr)->type = CDECL_DECL_FUNCTION; \ + (ptr)->u.function.parameters = parameters_; \ + (ptr)->u.function.variadic = variadic_; \ +} while (0) + +#define ALLOC_ARRAY(ptr, length_) do { \ + ALLOC_ITEM_DECLARATOR(ptr); \ + (ptr)->type = CDECL_DECL_ARRAY; \ + (ptr)->u.array.vla = NULL; \ + (ptr)->u.array.length = length_; \ +} while (0) + +#define ALLOC_POINTER(ptr, qualifiers_, child_) do { \ + ALLOC_ITEM_DECLARATOR(ptr); \ + (ptr)->child = child_; \ + (ptr)->type = CDECL_DECL_POINTER; \ + (ptr)->u.pointer.qualifiers = qualifiers_; \ +} while (0) + +#define ALLOC_DECLSPEC(ptr, type_) do { \ + ALLOC_ITEM_DECLSPEC(ptr); \ + (ptr)->type = type_; \ + (ptr)->ident = NULL; \ } while (0) -#define ALLOC_STRUCT(ptr, type, ...) do { \ - ALLOC(ptr, sizeof (type)); \ - *(ptr) = (type) { __VA_ARGS__ }; \ +#define ALLOC_DECL(ptr, specifiers_, declarators_) do { \ + ALLOC_ITEM_DECL(ptr); \ + (ptr)->specifiers = specifiers_; \ + (ptr)->declarators = declarators_; \ } while (0) /* @@ -59,7 +109,13 @@ * 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) +#define yytnamerr(a, b) ( (a) ? yytnamerr_copy(a, b) \ + : strlen(b) ) + +static size_t yytnamerr_copy(char *dst, const char *src) +{ + return cdecl__strlcpy(dst, src, strlen(src)+1); +} %} %code requires { @@ -105,6 +161,7 @@ static void free_declarator(struct cdecl_declarator *x) switch (x->type) { case CDECL_DECL_NULL: + x = NULL; case CDECL_DECL_IDENT: case CDECL_DECL_ARRAY: break; @@ -168,11 +225,18 @@ static struct cdecl *insert_identifier(struct cdecl *decl, struct parse_item *id while ((d = *p)->child) p = &d->child; - free(d); - *p = d = &ident->u.declarator; + *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($$); } @@ -248,16 +312,14 @@ static struct cdecl *insert_identifier(struct cdecl *decl, struct parse_item *id %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 +%type cdecl declaration declarators declarator_wrap 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 english_declaration -%type english_parameter +%type english english_declaration english_parameter /* Precedence declaration to avoid conflict in english_parameter; see below. */ %right T_TYPE @@ -265,14 +327,10 @@ static struct cdecl *insert_identifier(struct cdecl *decl, struct parse_item *id %% -input: english { - *out = $1; -} | declaration { - *out = $1; -}; +input: cdecl { *out = $1; } +cdecl: english | declaration semi: | T_SEMICOLON - declaration: declspecs declarators semi { $$ = $2; $$->specifiers = $1; @@ -318,7 +376,7 @@ declarators: declarator_wrap | declarator_wrap T_COMMA declarators { } declarator_wrap: declarator { - ALLOC_STRUCT($$, struct cdecl, .declarators = $1); + ALLOC_DECL($$, NULL, $1); } declspec_simple: T_AUTO @@ -347,17 +405,9 @@ qualifier_simple: T_CONST | T_RESTRICT | T_VOLATILE -declspec_notype: qualifier | declspec_simple { - ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1); -} - -typespec_noid: typespec_simple { - ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1); -} - -qualifier: qualifier_simple { - ALLOC_STRUCT($$, struct cdecl_declspec, .type = $1); -} +declspec_notype: qualifier | declspec_simple { ALLOC_DECLSPEC($$, $1); } +typespec_noid: typespec_simple { ALLOC_DECLSPEC($$, $1); } +qualifier: qualifier_simple { ALLOC_DECLSPEC($$, $1); } typespec: typespec_noid | typespec_tagged T_IDENT { /* Compiler should be able to elide this assignment. */ @@ -376,9 +426,7 @@ vla_ident: T_IDENT | T_ASTERISK { } array: T_LBRACKET array_length T_RBRACKET { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_ARRAY, - .u.array.length = $2); + ALLOC_ARRAY($$, $2); } | T_LBRACKET vla_ident T_RBRACKET { $$ = &$2->u.declarator; $$->type = CDECL_DECL_ARRAY; @@ -387,18 +435,13 @@ array: T_LBRACKET array_length T_RBRACKET { } parameter: declspecs declarator { - ALLOC_STRUCT($$, struct cdecl, - .specifiers = $1, - .declarators = $2); + ALLOC_DECL($$, $1, $2); } varargs: { $$ = false; } | T_COMMA T_ELLIPSIS { $$ = true; } parameter_type_list: parameter varargs { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_FUNCTION, - .u.function.parameters = $1, - .u.function.variadic = $2); + ALLOC_FUNCTION($$, $1, $2); } | parameter T_COMMA parameter_type_list { $$ = $3; $1->next = $$->u.function.parameters; @@ -408,22 +451,16 @@ parameter_type_list: parameter varargs { parens: T_LPAREN parameter_type_list T_RPAREN { $$ = $2; } | T_LPAREN declarator_ish T_RPAREN { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_FUNCTION); - ALLOC_STRUCT($$->u.function.parameters, struct cdecl, - .declarators = $2); + struct cdecl *fake_params; + + ALLOC_DECL(fake_params, NULL, $2); + ALLOC_FUNCTION($$, fake_params, false); } pointer: T_ASTERISK qualifiers direct_declarator { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_POINTER, - .u.pointer.qualifiers = $2, - .child = $3); + ALLOC_POINTER($$, $2, $3); } | T_ASTERISK qualifiers pointer { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_POINTER, - .u.pointer.qualifiers = $2, - .child = $3); + ALLOC_POINTER($$, $2, $3); } declarator: direct_declarator | pointer @@ -431,16 +468,14 @@ 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 { $$ = &$1->u.declarator; } | direct_declarator postfix { @@ -460,9 +495,8 @@ english: T_DECLARE T_IDENT T_AS english_declaration { */ storage_func_specs: %prec T_TYPE { $$ = NULL; } storage_func_specs: declspec_simple storage_func_specs { - ALLOC_STRUCT($$, struct cdecl_declspec, - .type = $1, - .next = $2); + ALLOC_DECLSPEC($$, $1); + $$->next = $2; } type_qual_spec: typespec_noid | qualifier @@ -485,19 +519,13 @@ post_specs: qualifiers typespec type_qual_specs { english_declaration: storage_func_specs english_declarator post_specs { join_specs($3, $1); - ALLOC_STRUCT($$, struct cdecl, - .specifiers = $3, - .declarators = $2); + ALLOC_DECL($$, $3, $2); } 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, - .child = $1, - .u.pointer.qualifiers = $2); + ALLOC_POINTER($$, $2, $1); } | english_declarator english_array { $$ = $2; $$->child = $1; @@ -507,18 +535,13 @@ english_declarator: { } english_function: T_FUNCTION T_RETURNING { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_FUNCTION, - .u.function.parameters = NULL); + ALLOC_FUNCTION($$, NULL, false); } | T_FUNCTION T_LPAREN english_parameter_list T_RPAREN T_RETURNING { $$ = $3; } english_parameter_list: english_parameter varargs { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_FUNCTION, - .u.function.parameters = $1, - .u.function.variadic = $2); + ALLOC_FUNCTION($$, $1, $2); } | english_parameter T_COMMA english_parameter_list { $$ = $3; $1->next = $$->u.function.parameters; @@ -535,8 +558,7 @@ typedef_name_qual: T_IDENT qualifiers { } null_decl: { - ALLOC_STRUCT($$, struct cdecl_declarator, - .type = CDECL_DECL_NULL); + $$ = NULLDECL; } /* @@ -554,9 +576,7 @@ null_decl: { * 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); + ALLOC_DECL($$, $1, $2); } | T_IDENT T_AS english_declaration { $$ = insert_identifier($3, $1); } @@ -567,9 +587,7 @@ english_array: T_VLA T_ARRAY english_vla T_OF { $$->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); + ALLOC_ARRAY($$, $2); } array_length: { $$ = 0; }