Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-20 01:33:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

maint: factor the handling of %printer and %destructor

Browse Source 
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.
This commit is contained in:
Victor Santet
2012-06-22 14:11:05 +02:00
committed by Akim Demaille
parent dfe292c695
commit 71da68b366
8 changed files with 149 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/output.c
View File

@@ -438,7 +438,7 @@ prepare_symbol_definitions (void)
#define CODE_PROP(PropName) \ #define CODE_PROP(PropName) \
do { \ do { \
code_props const *p = symbol_ ## PropName ## _get (sym); \ code_props const *p = symbol_code_props_get (sym, PropName); \
SET_KEY("has_" #PropName); \ SET_KEY("has_" #PropName); \
MUSCLE_INSERT_INT (key, !!p->code); \ MUSCLE_INSERT_INT (key, !!p->code); \
\ \

4
src/parse-gram.c
View File

@@ -2307,7 +2307,7 @@ yyreduce:
{ {
symbol_list *list; symbol_list *list;
for (list = (yyvsp[0].list); list; list = list->next) 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)); symbol_list_free ((yyvsp[0].list));
} }
/* Line 1735 of yacc.c */ /* Line 1735 of yacc.c */
@@ -2320,7 +2320,7 @@ yyreduce:
{ {
symbol_list *list; symbol_list *list;
for (list = (yyvsp[0].list); list; list = list->next) 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)); symbol_list_free ((yyvsp[0].list));
} }
/* Line 1735 of yacc.c */ /* Line 1735 of yacc.c */

4
src/parse-gram.y
View File

@@ -390,14 +390,14 @@ grammar_declaration:
{ {
symbol_list *list; symbol_list *list;
for (list = $3; list; list = list->next) 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); symbol_list_free ($3);
} }
| "%printer" "{...}" generic_symlist | "%printer" "{...}" generic_symlist
{ {
symbol_list *list; symbol_list *list;
for (list = $3; list; list = list->next) 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); symbol_list_free ($3);
} }
| "%default-prec" | "%default-prec"

2
src/reader.c
View File

@@ -257,7 +257,7 @@ grammar_current_rule_begin (symbol *lhs, location loc,
static bool static bool
symbol_should_be_used (symbol_list const *s, bool *midrule_warning) 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; return true;
if ((s->midrule && s->midrule->action_props.is_value_used) if ((s->midrule && s->midrule->action_props.is_value_used)
|| (s->midrule_parent_rule || (s->midrule_parent_rule

46
src/symlist.c
View File

@@ -223,53 +223,29 @@ symbol_list_null (symbol_list *node)
} }
void 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 cprops;
code_props_symbol_action_init (&destructor, code, loc); code_props_symbol_action_init (&cprops, code, loc);
code_props_translate_code (&destructor); code_props_translate_code (&cprops);
switch (node->content_type) switch (node->content_type)
{ {
case SYMLIST_SYMBOL: 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) if (node->content.sym->status == undeclared)
node->content.sym->status = used; node->content.sym->status = used;
break; break;
case SYMLIST_TYPE: case SYMLIST_TYPE:
semantic_type_destructor_set ( semantic_type_code_props_set
semantic_type_get (node->content.type_name), &destructor); (semantic_type_get (node->content.type_name),
kind, &cprops);
break; break;
case SYMLIST_DEFAULT_TAGGED: case SYMLIST_DEFAULT_TAGGED:
default_tagged_destructor_set (&destructor); default_tagged_code_props_set (kind, &cprops);
break; break;
case SYMLIST_DEFAULT_TAGLESS: case SYMLIST_DEFAULT_TAGLESS:
default_tagless_destructor_set (&destructor); default_tagless_code_props_set (kind, &cprops);
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);
break; break;
} }
} }

11
src/symlist.h
View File

@@ -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. */ /* Check whether the node is a border element of a rule. */
bool symbol_list_null (symbol_list *node); bool symbol_list_null (symbol_list *node);
/** Set the \c \%destructor for \c node as \c code at \c loc. */ /** Set the \c \%destructor or \c \%printer for \c node as \c code at
void symbol_list_destructor_set (symbol_list *node, char const *code, \c loc. */
location loc); void symbol_list_code_props_set (symbol_list *node, code_props_type kind,
location loc, char const *code);
/** 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);
#endif /* !SYMLIST_H_ */ #endif /* !SYMLIST_H_ */

240
src/symtab.c
View File

@@ -49,10 +49,16 @@ location startsymbol_location;
| Default %destructor's and %printer's. | | Default %destructor's and %printer's. |
`---------------------------------------*/ `---------------------------------------*/
static code_props default_tagged_destructor = CODE_PROPS_NONE_INIT; static code_props default_tagged_code_props[CODE_PROPS_SIZE] =
static code_props default_tagless_destructor = CODE_PROPS_NONE_INIT; {
static code_props default_tagged_printer = CODE_PROPS_NONE_INIT; CODE_PROPS_NONE_INIT,
static code_props default_tagless_printer = 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. | | Create a new symbol, named TAG. |
@@ -75,8 +81,8 @@ symbol_new (uniqstr tag, location loc)
res->location = loc; res->location = loc;
res->type_name = NULL; res->type_name = NULL;
code_props_none_init (&res->destructor); for (int i = 0; i < CODE_PROPS_SIZE; ++i)
code_props_none_init (&res->printer); code_props_none_init (&res->props[i]);
res->number = NUMBER_UNDEFINED; res->number = NUMBER_UNDEFINED;
res->prec = 0; res->prec = 0;
@@ -94,6 +100,23 @@ symbol_new (uniqstr tag, location loc)
return res; 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. | | Create a new semantic type, named TAG. |
`----------------------------------------*/ `----------------------------------------*/
@@ -105,8 +128,8 @@ semantic_type_new (uniqstr tag)
uniqstr_assert (tag); uniqstr_assert (tag);
res->tag = tag; res->tag = tag;
code_props_none_init (&res->destructor); for (int i = 0; i < CODE_PROPS_SIZE; ++i)
code_props_none_init (&res->printer); code_props_none_init (&res->props[i]);
return res; return res;
} }
@@ -120,9 +143,9 @@ semantic_type_new (uniqstr tag)
if (s->Attr) \ if (s->Attr) \
fprintf (f, " %s { %s }", #Attr, s->Attr) fprintf (f, " %s { %s }", #Attr, s->Attr)
#define SYMBOL_CODE_PRINT(Attr) \ #define SYMBOL_CODE_PRINT(Attr) \
if (s->Attr.code) \ if (s->props[Attr].code) \
fprintf (f, " %s { %s }", #Attr, s->Attr.code) fprintf (f, " %s { %s }", #Attr, s->props[Attr].code)
void void
symbol_print (symbol *s, FILE *f) 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. | | Set the DESTRUCTOR or PRINTER associated with the SYM. |
`-----------------------------------------*/ `--------------------------------------------------------*/
void void
symbol_destructor_set (symbol *sym, code_props const *destructor) symbol_code_props_set (symbol *sym, code_props_type kind,
code_props const *code)
{ {
if (sym->destructor.code) if (sym->props[kind].code)
symbol_redeclaration (sym, "%destructor", sym->destructor.location, symbol_redeclaration (sym, code_props_type_string (kind),
destructor->location); sym->props[kind].location,
sym->destructor = *destructor; code->location);
sym->props[kind] = *code;
} }
/*------------------------------------------. /*-----------------------------------------------------.
| Set the DESTRUCTOR associated with TYPE. | | Set the DESTRUCTOR or PRINTER associated with TYPE. |
`------------------------------------------*/ `-----------------------------------------------------*/
void void
semantic_type_destructor_set (semantic_type *type, semantic_type_code_props_set (semantic_type *type,
code_props const *destructor) code_props_type kind,
code_props const *code)
{ {
if (type->destructor.code) if (type->props[kind].code)
semantic_type_redeclaration (type, "%destructor", semantic_type_redeclaration (type, code_props_type_string (kind),
type->destructor.location, type->props[kind].location,
destructor->location); code->location);
type->destructor = *destructor; type->props[kind] = *code;
} }
/*---------------------------------------. /*---------------------------------------------------.
| Get the computed %destructor for SYM. | | Get the computed %destructor or %printer for SYM. |
`---------------------------------------*/ `---------------------------------------------------*/
code_props const * code_props const *
symbol_destructor_get (symbol const *sym) symbol_code_props_get (symbol const *sym,
code_props_type kind)
{ {
/* Per-symbol %destructor. */ /* Per-symbol code props. */
if (sym->destructor.code) if (sym->props[kind].code)
return &sym->destructor; return &sym->props[kind];
/* Per-type %destructor. */ /* Per-type code props. */
if (sym->type_name) if (sym->type_name)
{ {
code_props const *destructor = code_props const *code =
&semantic_type_get (sym->type_name)->destructor; &semantic_type_get (sym->type_name)->props[kind];
if (destructor->code) if (code->code)
return destructor; return code;
} }
/* Apply default %destructor's only to user-defined symbols. */ /* Apply default code props's only to user-defined symbols. */
if (sym->tag[0] == '$' || sym == errtoken) if (sym->tag[0] == '$' || sym == errtoken)
return &code_props_none; return &code_props_none;
if (sym->type_name) if (sym->type_name)
return &default_tagged_destructor; return &default_tagged_code_props[kind];
return &default_tagless_destructor; return &default_tagless_code_props[kind];
}
/*--------------------------------------.
| Set the PRINTER associated with SYM. |
`--------------------------------------*/
void
symbol_printer_set (symbol *sym, code_props const *printer)
{
if (sym->printer.code)
symbol_redeclaration (sym, "%printer",
sym->printer.location, printer->location);
sym->printer = *printer;
}
/*---------------------------------------.
| Set the PRINTER associated with TYPE. |
`---------------------------------------*/
void
semantic_type_printer_set (semantic_type *type, code_props const *printer)
{
if (type->printer.code)
semantic_type_redeclaration (type, "%printer",
type->printer.location, printer->location);
type->printer = *printer;
}
/*------------------------------------.
| Get the computed %printer for SYM. |
`------------------------------------*/
code_props const *
symbol_printer_get (symbol const *sym)
{
/* Per-symbol %printer. */
if (sym->printer.code)
return &sym->printer;
/* Per-type %printer. */
if (sym->type_name)
{
code_props const *printer = &semantic_type_get (sym->type_name)->printer;
if (printer->code)
return printer;
}
/* Apply the default %printer 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;
} }
/*-----------------------------------------------------------------. /*-----------------------------------------------------------------.
@@ -504,21 +477,11 @@ symbol_check_alias_consistency (symbol *this)
} }
if (str->destructor.code || sym->destructor.code) for (int i = 0; i < CODE_PROPS_SIZE; ++i)
{ if (str->props[i].code)
if (str->destructor.code) symbol_code_props_set (sym, i, &str->props[i]);
symbol_destructor_set (sym, &str->destructor); else if (sym->props[i].code)
else symbol_code_props_set (str, i, &sym->props[i]);
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);
}
if (sym->prec || str->prec) if (sym->prec || str->prec)
{ {
@@ -974,53 +937,30 @@ symbols_pack (void)
`--------------------------------------------------*/ `--------------------------------------------------*/
void void
default_tagged_destructor_set (code_props const *destructor) default_tagged_code_props_set (code_props_type kind, code_props const *code)
{ {
if (default_tagged_destructor.code) if (default_tagged_code_props[kind].code)
{ {
complain_at (destructor->location, complain_at (code->location,
_("redeclaration for default tagged %%destructor")); _("redeclaration for default tagged %s"),
complain_at (default_tagged_destructor.location, code_props_type_string (kind));
complain_at (default_tagged_code_props[kind].location,
_("previous declaration")); _("previous declaration"));
} }
default_tagged_destructor = *destructor; default_tagged_code_props[kind] = *code;
} }
void void
default_tagless_destructor_set (code_props const *destructor) default_tagless_code_props_set (code_props_type kind, code_props const *code)
{ {
if (default_tagless_destructor.code) if (default_tagless_code_props[kind].code)
{ {
complain_at (destructor->location, complain_at (code->location,
_("redeclaration for default tagless %%destructor")); _("redeclaration for default tagless %s"),
complain_at (default_tagless_destructor.location, code_props_type_string (kind));
complain_at (default_tagless_code_props[kind].location,
_("previous declaration")); _("previous declaration"));
} }
default_tagless_destructor = *destructor; default_tagless_code_props[kind] = *code;
} }
void
default_tagged_printer_set (code_props const *printer)
{
if (default_tagged_printer.code)
{
complain_at (printer->location,
_("redeclaration for default tagged %%printer"));
complain_at (default_tagged_printer.location,
_("previous declaration"));
}
default_tagged_printer = *printer;
}
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;
}

82
src/symtab.h
View File

@@ -74,6 +74,15 @@ typedef enum
declared, declared,
} status; } 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 /* When extending this structure, be sure to complete
symbol_check_alias_consistency. */ symbol_check_alias_consistency. */
struct symbol struct symbol
@@ -88,19 +97,14 @@ struct symbol
/** Its \c \%type's location. */ /** Its \c \%type's location. */
location type_location; location type_location;
/** Any \c \%destructor declared specifically for this symbol. /** Any \c \%destructor (resp. \%printer) declared specificially for this
symbol.
Access this field only through <tt>symbol</tt>'s interface functions. For Access this field only through <tt>symbol</tt>'s interface functions. For
example, if <tt>symbol::destructor = NULL</tt>, a default \c \%destructor Example, if <tt>symbol::destructor = NULL</tt> (resp. <tt>symbol::printer
or a per-type \c \%destructor might be appropriate, and = NULL</tt>), a default \c \%destructor (resp. \%printer) or a per-type
\c symbol_destructor_get will compute the correct one. */ \c symbol_destructor_printer_get will compute the corect one. */
code_props destructor; code_props props[CODE_PROPS_SIZE];
/** Any \c \%printer declared specifically for this symbol.
Access this field only through <tt>symbol</tt>'s interface functions.
\sa symbol::destructor */
code_props printer;
symbol_number number; symbol_number number;
location prec_location; 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. */ Do nothing if passed 0 as \c type_name. */
void symbol_type_set (symbol *sym, uniqstr type_name, location loc); void symbol_type_set (symbol *sym, uniqstr type_name, location loc);
/** Set the \c destructor associated with \c sym. */ /** Set the \c \%destructor or \c \%printer associated with \c sym. */
void symbol_destructor_set (symbol *sym, code_props const *destructor); 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 /** Get the computed \c \%destructor or \c %printer for \c sym, which was
\c code_props_none_init if there's no \c \%destructor. */ initialized with \c code_props_none_init if there's no \c \%destructor or
code_props const *symbol_destructor_get (symbol const *sym); \c %printer. */
code_props const *symbol_code_props_get (symbol const *sym,
/** Set the \c printer associated with \c sym. */ code_props_type kind);
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);
/* Set the \c precedence associated with \c sym. /* Set the \c precedence associated with \c sym.
@@ -229,10 +229,10 @@ typedef struct {
/** The key, name of the semantic type. */ /** The key, name of the semantic type. */
uniqstr tag; uniqstr tag;
/** Any \c %destructor declared for this semantic type. */ /** Any \c %destructor and %printer declared for this
code_props destructor; semantic type. */
/** Any \c %printer declared for this semantic type. */ code_props props[CODE_PROPS_SIZE];
code_props printer;
} semantic_type; } semantic_type;
/** Fetch (or create) the semantic type associated to KEY. */ /** 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. */ /** Fetch (or create) the semantic type associated to KEY. */
semantic_type *semantic_type_get (const char *key); semantic_type *semantic_type_get (const char *key);
/** Set the \c destructor associated with \c type. */ /** Set the \c destructor or \c printer associated with \c type. */
void semantic_type_destructor_set (semantic_type *type, void semantic_type_code_props_set (semantic_type *type,
code_props const *destructor); code_props_type kind,
code_props const *code);
/** Set the \c printer associated with \c type. */
void semantic_type_printer_set (semantic_type *type,
code_props const *printer);
/*----------------------------------. /*----------------------------------.
| Symbol and semantic type tables. | | Symbol and semantic type tables. |
@@ -275,14 +272,11 @@ void symbols_pack (void);
| Default %destructor's and %printer's. | | Default %destructor's and %printer's. |
`---------------------------------------*/ `---------------------------------------*/
/** Set the default \c \%destructor for tagged values. */ /** Set the default \c \%destructor or \c \%printer for tagged values. */
void default_tagged_destructor_set (code_props const *destructor); void default_tagged_code_props_set (code_props_type kind,
/** Set the default \c \%destructor for tagless values. */ code_props const *code);
void default_tagless_destructor_set (code_props const *destructor); /** Set the default \c \%destructor or \c \%printer for tagless values. */
void default_tagless_code_props_set (code_props_type kind,
/** Set the default \c \%printer for tagged values. */ code_props const *destructor);
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);
#endif /* !SYMTAB_H_ */ #endif /* !SYMTAB_H_ */