From: Victor Santet Date: Fri, 22 Jun 2012 12:11:05 +0000 (+0200) Subject: maint: factor the handling of %printer and %destructor X-Git-Tag: v2.7.90~425 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/71da68b3662b7169c58f8c5d4c0e89bc3caa31c4 maint: factor the handling of %printer and %destructor There is too much code duplication between %printer and %destructor. We used to have two functions for each action: the first one for destructors, the second one for printers. Factor using a 'code_props_type', and an array of code_props instead of two members. * src/symlist.h, src/symlist.c (symbol_list_destructor_set) (symbol_list_printer_set): Fuse into... (symbol_list_code_props_set): this. * src/symtab.h, src/symtab.c (default_tagged_destructor) (default_tagged_printer): Fuse into... (default_tagged_code_props): this. (default_tagless_destructor, default_tagless_printer) (default_tagless_code_props): Likewise. (code_props_type_string): new. (symbol_destructor_set, symbol_destructor_get, semantic_type_destructor_set) (default_tagged_destructor_set, default_tagless_destructor_set) (symbol_printer_set, symbol_printer_get, semantic_type_printer_set) (default_tagged_printer_set, default_tagless_printer_set): Replace by... (symbol_code_props_set, symbol_code_props_get, semantic_type_code_props_set) (default_tagged_code_props_set, default_tagless_code_props_set): these. * src/parse-gram.y (grammar_declaration): Adjust. * src/output.c (CODE_PROP, grammar_declaration): Ditto. * src/reader.c (symbol_should_be_used): Ditto. --- diff --git a/src/output.c b/src/output.c index 58615057..c967fa7a 100644 --- a/src/output.c +++ b/src/output.c @@ -438,7 +438,7 @@ prepare_symbol_definitions (void) #define CODE_PROP(PropName) \ do { \ - code_props const *p = symbol_ ## PropName ## _get (sym); \ + code_props const *p = symbol_code_props_get (sym, PropName); \ SET_KEY("has_" #PropName); \ MUSCLE_INSERT_INT (key, !!p->code); \ \ diff --git a/src/parse-gram.c b/src/parse-gram.c index ec41fd2b..0f247ff0 100644 --- a/src/parse-gram.c +++ b/src/parse-gram.c @@ -2307,7 +2307,7 @@ yyreduce: { symbol_list *list; for (list = (yyvsp[0].list); list; list = list->next) - symbol_list_destructor_set (list, (yyvsp[-1].code), (yylsp[-1])); + symbol_list_code_props_set (list, destructor, (yylsp[-1]), (yyvsp[-1].code)); symbol_list_free ((yyvsp[0].list)); } /* Line 1735 of yacc.c */ @@ -2320,7 +2320,7 @@ yyreduce: { symbol_list *list; for (list = (yyvsp[0].list); list; list = list->next) - symbol_list_printer_set (list, (yyvsp[-1].code), (yylsp[-1])); + symbol_list_code_props_set (list, printer, (yylsp[-1]), (yyvsp[-1].code)); symbol_list_free ((yyvsp[0].list)); } /* Line 1735 of yacc.c */ diff --git a/src/parse-gram.y b/src/parse-gram.y index 8e385196..c932ba54 100644 --- a/src/parse-gram.y +++ b/src/parse-gram.y @@ -390,14 +390,14 @@ grammar_declaration: { symbol_list *list; for (list = $3; list; list = list->next) - symbol_list_destructor_set (list, $2, @2); + symbol_list_code_props_set (list, destructor, @2, $2); symbol_list_free ($3); } | "%printer" "{...}" generic_symlist { symbol_list *list; for (list = $3; list; list = list->next) - symbol_list_printer_set (list, $2, @2); + symbol_list_code_props_set (list, printer, @2, $2); symbol_list_free ($3); } | "%default-prec" diff --git a/src/reader.c b/src/reader.c index 9bb9d7b6..c456cbff 100644 --- a/src/reader.c +++ b/src/reader.c @@ -257,7 +257,7 @@ grammar_current_rule_begin (symbol *lhs, location loc, static bool symbol_should_be_used (symbol_list const *s, bool *midrule_warning) { - if (symbol_destructor_get (s->content.sym)->code) + if (symbol_code_props_get (s->content.sym, destructor)->code) return true; if ((s->midrule && s->midrule->action_props.is_value_used) || (s->midrule_parent_rule diff --git a/src/symlist.c b/src/symlist.c index abb58674..abea6ce7 100644 --- a/src/symlist.c +++ b/src/symlist.c @@ -223,53 +223,29 @@ symbol_list_null (symbol_list *node) } void -symbol_list_destructor_set (symbol_list *node, char const *code, location loc) +symbol_list_code_props_set (symbol_list *node, code_props_type kind, + location loc, char const *code) { - code_props destructor; - code_props_symbol_action_init (&destructor, code, loc); - code_props_translate_code (&destructor); + code_props cprops; + code_props_symbol_action_init (&cprops, code, loc); + code_props_translate_code (&cprops); switch (node->content_type) { case SYMLIST_SYMBOL: - symbol_destructor_set (node->content.sym, &destructor); + symbol_code_props_set (node->content.sym, kind, &cprops); if (node->content.sym->status == undeclared) node->content.sym->status = used; break; case SYMLIST_TYPE: - semantic_type_destructor_set ( - semantic_type_get (node->content.type_name), &destructor); + semantic_type_code_props_set + (semantic_type_get (node->content.type_name), + kind, &cprops); break; case SYMLIST_DEFAULT_TAGGED: - default_tagged_destructor_set (&destructor); + default_tagged_code_props_set (kind, &cprops); break; case SYMLIST_DEFAULT_TAGLESS: - default_tagless_destructor_set (&destructor); - break; - } -} - -void -symbol_list_printer_set (symbol_list *node, char const *code, location loc) -{ - code_props printer; - code_props_symbol_action_init (&printer, code, loc); - code_props_translate_code (&printer); - switch (node->content_type) - { - case SYMLIST_SYMBOL: - symbol_printer_set (node->content.sym, &printer); - if (node->content.sym->status == undeclared) - node->content.sym->status = used; - break; - case SYMLIST_TYPE: - semantic_type_printer_set ( - semantic_type_get (node->content.type_name), &printer); - break; - case SYMLIST_DEFAULT_TAGGED: - default_tagged_printer_set (&printer); - break; - case SYMLIST_DEFAULT_TAGLESS: - default_tagless_printer_set (&printer); + default_tagless_code_props_set (kind, &cprops); break; } } diff --git a/src/symlist.h b/src/symlist.h index 43936b29..0bd4f3b0 100644 --- a/src/symlist.h +++ b/src/symlist.h @@ -118,12 +118,9 @@ uniqstr symbol_list_n_type_name_get (symbol_list *l, location loc, int n); /* Check whether the node is a border element of a rule. */ bool symbol_list_null (symbol_list *node); -/** Set the \c \%destructor for \c node as \c code at \c loc. */ -void symbol_list_destructor_set (symbol_list *node, char const *code, - location loc); - -/** Set the \c \%printer for \c node as \c code at \c loc. */ -void symbol_list_printer_set (symbol_list *node, char const *code, - location loc); +/** Set the \c \%destructor or \c \%printer for \c node as \c code at + \c loc. */ +void symbol_list_code_props_set (symbol_list *node, code_props_type kind, + location loc, char const *code); #endif /* !SYMLIST_H_ */ diff --git a/src/symtab.c b/src/symtab.c index f4f35290..b30ccaf1 100644 --- a/src/symtab.c +++ b/src/symtab.c @@ -49,10 +49,16 @@ location startsymbol_location; | Default %destructor's and %printer's. | `---------------------------------------*/ -static code_props default_tagged_destructor = CODE_PROPS_NONE_INIT; -static code_props default_tagless_destructor = CODE_PROPS_NONE_INIT; -static code_props default_tagged_printer = CODE_PROPS_NONE_INIT; -static code_props default_tagless_printer = CODE_PROPS_NONE_INIT; +static code_props default_tagged_code_props[CODE_PROPS_SIZE] = + { + CODE_PROPS_NONE_INIT, + CODE_PROPS_NONE_INIT, + }; +static code_props default_tagless_code_props[CODE_PROPS_SIZE] = + { + CODE_PROPS_NONE_INIT, + CODE_PROPS_NONE_INIT, + }; /*---------------------------------. | Create a new symbol, named TAG. | @@ -75,8 +81,8 @@ symbol_new (uniqstr tag, location loc) res->location = loc; res->type_name = NULL; - code_props_none_init (&res->destructor); - code_props_none_init (&res->printer); + for (int i = 0; i < CODE_PROPS_SIZE; ++i) + code_props_none_init (&res->props[i]); res->number = NUMBER_UNDEFINED; res->prec = 0; @@ -94,6 +100,23 @@ symbol_new (uniqstr tag, location loc) return res; } +/*-------------------------------------------------------. +| Name of the code_props type: %destructor or %printer. | +`-------------------------------------------------------*/ + +static char const * +code_props_type_string (code_props_type kind) +{ + switch (kind) + { + case destructor: + return "%destructor"; + case printer: + return "%printer"; + } + assert (0); +} + /*----------------------------------------. | Create a new semantic type, named TAG. | `----------------------------------------*/ @@ -105,8 +128,8 @@ semantic_type_new (uniqstr tag) uniqstr_assert (tag); res->tag = tag; - code_props_none_init (&res->destructor); - code_props_none_init (&res->printer); + for (int i = 0; i < CODE_PROPS_SIZE; ++i) + code_props_none_init (&res->props[i]); return res; } @@ -120,9 +143,9 @@ semantic_type_new (uniqstr tag) if (s->Attr) \ fprintf (f, " %s { %s }", #Attr, s->Attr) -#define SYMBOL_CODE_PRINT(Attr) \ - if (s->Attr.code) \ - fprintf (f, " %s { %s }", #Attr, s->Attr.code) +#define SYMBOL_CODE_PRINT(Attr) \ + if (s->props[Attr].code) \ + fprintf (f, " %s { %s }", #Attr, s->props[Attr].code) void symbol_print (symbol *s, FILE *f) @@ -217,115 +240,65 @@ symbol_type_set (symbol *sym, uniqstr type_name, location loc) } } -/*-----------------------------------------. -| Set the DESTRUCTOR associated with SYM. | -`-----------------------------------------*/ - -void -symbol_destructor_set (symbol *sym, code_props const *destructor) -{ - if (sym->destructor.code) - symbol_redeclaration (sym, "%destructor", sym->destructor.location, - destructor->location); - sym->destructor = *destructor; -} - -/*------------------------------------------. -| Set the DESTRUCTOR associated with TYPE. | -`------------------------------------------*/ - -void -semantic_type_destructor_set (semantic_type *type, - code_props const *destructor) -{ - if (type->destructor.code) - semantic_type_redeclaration (type, "%destructor", - type->destructor.location, - destructor->location); - type->destructor = *destructor; -} - -/*---------------------------------------. -| Get the computed %destructor for SYM. | -`---------------------------------------*/ - -code_props const * -symbol_destructor_get (symbol const *sym) -{ - /* Per-symbol %destructor. */ - if (sym->destructor.code) - return &sym->destructor; - - /* Per-type %destructor. */ - if (sym->type_name) - { - code_props const *destructor = - &semantic_type_get (sym->type_name)->destructor; - if (destructor->code) - return destructor; - } - - /* Apply default %destructor's only to user-defined symbols. */ - if (sym->tag[0] == '$' || sym == errtoken) - return &code_props_none; - - if (sym->type_name) - return &default_tagged_destructor; - return &default_tagless_destructor; -} - -/*--------------------------------------. -| Set the PRINTER associated with SYM. | -`--------------------------------------*/ +/*--------------------------------------------------------. +| Set the DESTRUCTOR or PRINTER associated with the SYM. | +`--------------------------------------------------------*/ void -symbol_printer_set (symbol *sym, code_props const *printer) +symbol_code_props_set (symbol *sym, code_props_type kind, + code_props const *code) { - if (sym->printer.code) - symbol_redeclaration (sym, "%printer", - sym->printer.location, printer->location); - sym->printer = *printer; + if (sym->props[kind].code) + symbol_redeclaration (sym, code_props_type_string (kind), + sym->props[kind].location, + code->location); + sym->props[kind] = *code; } -/*---------------------------------------. -| Set the PRINTER associated with TYPE. | -`---------------------------------------*/ +/*-----------------------------------------------------. +| Set the DESTRUCTOR or PRINTER associated with TYPE. | +`-----------------------------------------------------*/ void -semantic_type_printer_set (semantic_type *type, code_props const *printer) +semantic_type_code_props_set (semantic_type *type, + code_props_type kind, + code_props const *code) { - if (type->printer.code) - semantic_type_redeclaration (type, "%printer", - type->printer.location, printer->location); - type->printer = *printer; + if (type->props[kind].code) + semantic_type_redeclaration (type, code_props_type_string (kind), + type->props[kind].location, + code->location); + type->props[kind] = *code; } -/*------------------------------------. -| Get the computed %printer for SYM. | -`------------------------------------*/ +/*---------------------------------------------------. +| Get the computed %destructor or %printer for SYM. | +`---------------------------------------------------*/ code_props const * -symbol_printer_get (symbol const *sym) +symbol_code_props_get (symbol const *sym, + code_props_type kind) { - /* Per-symbol %printer. */ - if (sym->printer.code) - return &sym->printer; + /* Per-symbol code props. */ + if (sym->props[kind].code) + return &sym->props[kind]; - /* Per-type %printer. */ + /* Per-type code props. */ if (sym->type_name) { - code_props const *printer = &semantic_type_get (sym->type_name)->printer; - if (printer->code) - return printer; + code_props const *code = + &semantic_type_get (sym->type_name)->props[kind]; + if (code->code) + return code; } - /* Apply the default %printer only to user-defined symbols. */ + /* Apply default code props's only to user-defined symbols. */ if (sym->tag[0] == '$' || sym == errtoken) return &code_props_none; if (sym->type_name) - return &default_tagged_printer; - return &default_tagless_printer; + return &default_tagged_code_props[kind]; + return &default_tagless_code_props[kind]; } /*-----------------------------------------------------------------. @@ -504,21 +477,11 @@ symbol_check_alias_consistency (symbol *this) } - if (str->destructor.code || sym->destructor.code) - { - if (str->destructor.code) - symbol_destructor_set (sym, &str->destructor); - else - symbol_destructor_set (str, &sym->destructor); - } - - if (str->printer.code || sym->printer.code) - { - if (str->printer.code) - symbol_printer_set (sym, &str->printer); - else - symbol_printer_set (str, &sym->printer); - } + for (int i = 0; i < CODE_PROPS_SIZE; ++i) + if (str->props[i].code) + symbol_code_props_set (sym, i, &str->props[i]); + else if (sym->props[i].code) + symbol_code_props_set (str, i, &sym->props[i]); if (sym->prec || str->prec) { @@ -974,53 +937,30 @@ symbols_pack (void) `--------------------------------------------------*/ void -default_tagged_destructor_set (code_props const *destructor) -{ - if (default_tagged_destructor.code) - { - complain_at (destructor->location, - _("redeclaration for default tagged %%destructor")); - complain_at (default_tagged_destructor.location, - _("previous declaration")); - } - default_tagged_destructor = *destructor; -} - -void -default_tagless_destructor_set (code_props const *destructor) +default_tagged_code_props_set (code_props_type kind, code_props const *code) { - if (default_tagless_destructor.code) + if (default_tagged_code_props[kind].code) { - complain_at (destructor->location, - _("redeclaration for default tagless %%destructor")); - complain_at (default_tagless_destructor.location, + complain_at (code->location, + _("redeclaration for default tagged %s"), + code_props_type_string (kind)); + complain_at (default_tagged_code_props[kind].location, _("previous declaration")); } - default_tagless_destructor = *destructor; + default_tagged_code_props[kind] = *code; } void -default_tagged_printer_set (code_props const *printer) +default_tagless_code_props_set (code_props_type kind, code_props const *code) { - if (default_tagged_printer.code) + if (default_tagless_code_props[kind].code) { - complain_at (printer->location, - _("redeclaration for default tagged %%printer")); - complain_at (default_tagged_printer.location, + complain_at (code->location, + _("redeclaration for default tagless %s"), + code_props_type_string (kind)); + complain_at (default_tagless_code_props[kind].location, _("previous declaration")); } - default_tagged_printer = *printer; + default_tagless_code_props[kind] = *code; } -void -default_tagless_printer_set (code_props const *printer) -{ - if (default_tagless_printer.code) - { - complain_at (printer->location, - _("redeclaration for default tagless %%printer")); - complain_at (default_tagless_printer.location, - _("previous declaration")); - } - default_tagless_printer = *printer; -} diff --git a/src/symtab.h b/src/symtab.h index 480d6ca3..0ef4db29 100644 --- a/src/symtab.h +++ b/src/symtab.h @@ -74,6 +74,15 @@ typedef enum declared, } status; +typedef enum code_props_type code_props_type; +enum code_props_type + { + destructor = 0, + printer = 1, + }; + +enum { CODE_PROPS_SIZE = 2 }; + /* When extending this structure, be sure to complete symbol_check_alias_consistency. */ struct symbol @@ -88,19 +97,14 @@ struct symbol /** Its \c \%type's location. */ location type_location; - /** Any \c \%destructor declared specifically for this symbol. - - Access this field only through symbol's interface functions. For - example, if symbol::destructor = NULL, a default \c \%destructor - or a per-type \c \%destructor might be appropriate, and - \c symbol_destructor_get will compute the correct one. */ - code_props destructor; - - /** Any \c \%printer declared specifically for this symbol. + /** Any \c \%destructor (resp. \%printer) declared specificially for this + symbol. - Access this field only through symbol's interface functions. - \sa symbol::destructor */ - code_props printer; + Access this field only through symbol's interface functions. For + Example, if symbol::destructor = NULL (resp. symbol::printer + = NULL), a default \c \%destructor (resp. \%printer) or a per-type + \c symbol_destructor_printer_get will compute the corect one. */ + code_props props[CODE_PROPS_SIZE]; symbol_number number; location prec_location; @@ -167,19 +171,15 @@ void symbol_make_alias (symbol *sym, symbol *str, location loc); Do nothing if passed 0 as \c type_name. */ void symbol_type_set (symbol *sym, uniqstr type_name, location loc); -/** Set the \c destructor associated with \c sym. */ -void symbol_destructor_set (symbol *sym, code_props const *destructor); +/** Set the \c \%destructor or \c \%printer associated with \c sym. */ +void symbol_code_props_set (symbol *sym, code_props_type kind, + code_props const *destructor); -/** Get the computed \c \%destructor for \c sym, which was initialized with - \c code_props_none_init if there's no \c \%destructor. */ -code_props const *symbol_destructor_get (symbol const *sym); - -/** Set the \c printer associated with \c sym. */ -void symbol_printer_set (symbol *sym, code_props const *printer); - -/** Get the computed \c \%printer for \c sym, which was initialized with - \c code_props_none_init if there's no \c \%printer. */ -code_props const *symbol_printer_get (symbol const *sym); +/** Get the computed \c \%destructor or \c %printer for \c sym, which was +initialized with \c code_props_none_init if there's no \c \%destructor or +\c %printer. */ +code_props const *symbol_code_props_get (symbol const *sym, + code_props_type kind); /* Set the \c precedence associated with \c sym. @@ -229,10 +229,10 @@ typedef struct { /** The key, name of the semantic type. */ uniqstr tag; - /** Any \c %destructor declared for this semantic type. */ - code_props destructor; - /** Any \c %printer declared for this semantic type. */ - code_props printer; + /** Any \c %destructor and %printer declared for this + semantic type. */ + code_props props[CODE_PROPS_SIZE]; + } semantic_type; /** Fetch (or create) the semantic type associated to KEY. */ @@ -241,13 +241,10 @@ semantic_type *semantic_type_from_uniqstr (const uniqstr key); /** Fetch (or create) the semantic type associated to KEY. */ semantic_type *semantic_type_get (const char *key); -/** Set the \c destructor associated with \c type. */ -void semantic_type_destructor_set (semantic_type *type, - code_props const *destructor); - -/** Set the \c printer associated with \c type. */ -void semantic_type_printer_set (semantic_type *type, - code_props const *printer); +/** Set the \c destructor or \c printer associated with \c type. */ +void semantic_type_code_props_set (semantic_type *type, + code_props_type kind, + code_props const *code); /*----------------------------------. | Symbol and semantic type tables. | @@ -275,14 +272,11 @@ void symbols_pack (void); | Default %destructor's and %printer's. | `---------------------------------------*/ -/** Set the default \c \%destructor for tagged values. */ -void default_tagged_destructor_set (code_props const *destructor); -/** Set the default \c \%destructor for tagless values. */ -void default_tagless_destructor_set (code_props const *destructor); - -/** Set the default \c \%printer for tagged values. */ -void default_tagged_printer_set (code_props const *printer); -/** Set the default \c \%printer for tagless values. */ -void default_tagless_printer_set (code_props const *printer); +/** Set the default \c \%destructor or \c \%printer for tagged values. */ +void default_tagged_code_props_set (code_props_type kind, + code_props const *code); +/** Set the default \c \%destructor or \c \%printer for tagless values. */ +void default_tagless_code_props_set (code_props_type kind, + code_props const *destructor); #endif /* !SYMTAB_H_ */