[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
RE : [PATCH 1/3] maint: code factorization for %printer & %destructor
From: |
santet_v |
Subject: |
RE : [PATCH 1/3] maint: code factorization for %printer & %destructor |
Date: |
Fri, 22 Jun 2012 09:03:26 +0000 |
>From 0e07cc0f06cc4ed151f5901f237b42e897892176 Mon Sep 17 00:00:00 2001
From: Victor Santet <address@hidden>
Date: Tue, 19 Jun 2012 14:27:13 +0200
Subject: [PATCH] maint: code factorization for %printer & %destructor
There is too much code duplication between %printer and %destructor.
Factor, using an array of code_props instead of two members.
* src/symlist.h, src/symlist.c, src/symtab.h, src/symtab.c: Factoring
functions like 'symbol_desctructor_set' and 'symbol_printer_set' into
'symbol_code_props_set' which take one supplementary argument which
indicates whether it is a destructor or a printer.
* src/parse-gram.y, src/output.c, src/reader.c: Use these new functions.
---
src/output.c | 3 +-
src/parse-gram.y | 4 +-
src/reader.c | 2 +-
src/symlist.c | 46 +++--------
src/symlist.h | 11 +--
src/symtab.c | 232 +++++++++++++++++++-----------------------------------
src/symtab.h | 95 +++++++++++-----------
7 files changed, 153 insertions(+), 240 deletions(-)
diff --git a/src/output.c b/src/output.c
index 5861505..7205309 100644
--- a/src/output.c
+++ b/src/output.c
@@ -438,7 +438,8 @@ 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.y b/src/parse-gram.y
index 8e38519..c932ba5 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 9bb9d7b..c456cbf 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 abb5867..abea6ce 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 43936b2..0bd4f3b 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 f4f3529..8b1a800 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,15 @@ symbol_new (uniqstr tag, location loc)
return res;
}
+char const *
+code_props_type_string (code_props_type kind)
+{
+ if (kind == destructor)
+ return "%destructor";
+ else /* (type == printer) */
+ return "%printer";
+}
+
/*----------------------------------------.
| Create a new semantic type, named TAG. |
`----------------------------------------*/
@@ -105,8 +120,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 +135,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 +232,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
-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)
- symbol_redeclaration (sym, "%destructor", sym->destructor.location,
- destructor->location);
- sym->destructor = *destructor;
+ 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 DESTRUCTOR associated with TYPE. |
-`------------------------------------------*/
+/*-----------------------------------------------------.
+| Set the DESTRUCTOR or PRINTER associated with TYPE. |
+`-----------------------------------------------------*/
void
-semantic_type_destructor_set (semantic_type *type,
- code_props const *destructor)
+semantic_type_code_props_set (semantic_type *type,
+ code_props_type kind,
+ code_props const *code)
{
- if (type->destructor.code)
- semantic_type_redeclaration (type, "%destructor",
- type->destructor.location,
- destructor->location);
- type->destructor = *destructor;
+ 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 %destructor for SYM. |
-`---------------------------------------*/
+/*---------------------------------------------------.
+| Get the computed %destructor or %printer for SYM. |
+`---------------------------------------------------*/
code_props const *
-symbol_destructor_get (symbol const *sym)
+symbol_code_props_get (symbol const *sym,
+ code_props_type kind)
{
- /* Per-symbol %destructor. */
- if (sym->destructor.code)
- return &sym->destructor;
+ /* Per-symbol code props. */
+ if (sym->props[kind].code)
+ return &sym->props[kind];
- /* Per-type %destructor. */
+ /* Per-type code props. */
if (sym->type_name)
{
- code_props const *destructor =
- &semantic_type_get (sym->type_name)->destructor;
- if (destructor->code)
- return destructor;
+ code_props const *code =
+ &semantic_type_get (sym->type_name)->props[kind];
+ if (code->code)
+ 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)
return &code_props_none;
if (sym->type_name)
- return &default_tagged_destructor;
- return &default_tagless_destructor;
-}
-
-/*--------------------------------------.
-| 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;
+ return &default_tagged_code_props[kind];
+ return &default_tagless_code_props[kind];
}
/*-----------------------------------------------------------------.
@@ -504,21 +469,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 +929,30 @@ symbols_pack (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,
- _("redeclaration for default tagged %%destructor"));
- complain_at (default_tagged_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_tagged_destructor = *destructor;
+ default_tagged_code_props[kind] = *code;
}
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,
- _("redeclaration for default tagless %%destructor"));
- complain_at (default_tagless_destructor.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_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;
-}
diff --git a/src/symtab.h b/src/symtab.h
index 480d6ca..c3ee790 100644
--- a/src/symtab.h
+++ b/src/symtab.h
@@ -74,6 +74,25 @@ typedef enum
declared,
} status;
+/** For symbols:
+ * needed: symbol is created, but neither declared nor used - raise an error
+ * declared: symbol is declared - ok
+ * used: symbol is used, but not declared - raise a warning
+
+ ** For semantic types:
+ * needed: type is created, but neither declared nor used - raise a warning
+ * declared: type is declared - ok
+ * used: type is used, but not declared - raise a warning */
+
+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 +107,14 @@ struct symbol
/** Its \c \%type's 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
- example, if <tt>symbol::destructor = NULL</tt>, 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.
-
- Access this field only through <tt>symbol</tt>'s interface functions.
- \sa symbol::destructor */
- code_props printer;
+ Access this field only through <tt>symbol</tt>'s interface functions. For
+ Example, if <tt>symbol::destructor = NULL</tt> (resp. <tt>symbol::printer
+ = NULL</tt>), a default \c \%destructor (resp. \%printer) or a per-type
+ \c symbol_destructor_printer_get will compute the corect one. */
+ code_props props[2];
symbol_number number;
location prec_location;
@@ -150,6 +164,9 @@ void symbol_print (symbol *s, FILE *f);
/** Is this a dummy nonterminal? */
bool symbol_is_dummy (const symbol *sym);
+/** Returns name of the code_props type: \%destructor or \%printer. */
+char const *code_props_type_string (code_props_type kind);
+
/** Return the name of the symbol that can be used as an identifier.
** Consider the alias if needed.
** Return 0 if there is none (e.g., the symbol is only defined as
@@ -167,19 +184,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 +242,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[2];
+
} semantic_type;
/** Fetch (or create) the semantic type associated to KEY. */
@@ -241,13 +254,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 +285,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_ */
--
1.7.9.5
Victor SANTET
T?l?phone Portable : +33 (0) 6 42 08 15 32
Etudiant EPITA - Infosp?
________________________________________
De : Akim Demaille address@hidden
Date d'envoi : jeudi 21 juin 2012 16:18
? : santet_v
Cc: address@hidden
Objet : Re: [PATCH 1/3] maint: code factorization for %printer & %destructor
Le 21 juin 2012 ? 15:56, Victor Santet a ?crit :
> There is too much code duplication between %printer and %destructor.
> Factor, using an array of code_props instead of two members.
>
> * src/symlist.h, src/symlist.c, src/symtab.h, src/symtab.c: Factoring
> functions like 'symbol_desctructor_set' and 'symbol_printer_set' into
> 'symbol_code_props_set' which take one supplementary argument which
> indicates whether it is a destructor or a printer.
Please, write a compliant commit message. "Factoring" is wrong,
use the imperative. Put function names in parens. Use "git log"
to have examples, and do the same.
> * src/parse-gram.y, src/output.c, src/reader.c: Use these new functions.
>
> squash! code factorization for %printer & %destructor
>
> Conflicts:
>
> src/symlist.c
This should not appear, please fix your commit message and submit
again.
> ---
> src/output.c | 3 +-
> src/parse-gram.y | 4 +-
> src/reader.c | 2 +-
> src/symlist.c | 46 +++--------
> src/symlist.h | 11 +--
> src/symtab.c | 228 +++++++++++++++++++-----------------------------------
> src/symtab.h | 95 +++++++++++++++--------
> 7 files changed, 162 insertions(+), 227 deletions(-)
>
> diff --git a/src/output.c b/src/output.c
> index 76895d6..5458cea 100644
> --- a/src/output.c
> +++ b/src/output.c
> @@ -439,7 +439,8 @@ 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); \
It looks like it would fit on a single line.
> SET_KEY("has_" #PropName); \
> MUSCLE_INSERT_INT (key, !!p->code); \
> \
> diff --git a/src/parse-gram.y b/src/parse-gram.y
> index 8e38519..c932ba5 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);
> }
This shows that you could factor these two (%printer and %destructor)
in the scanner, as a typed token, whose type would be "printer" or
"destructor". We will talk about this later.
> | "%default-prec"
> diff --git a/src/reader.c b/src/reader.c
> index 9bb9d7b..c456cbf 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 abb5867..7b244a3 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 type,
> + 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, &cprops, type);
> 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),
> + &cprops, type);
> break;
> case SYMLIST_DEFAULT_TAGGED:
> - default_tagged_destructor_set (&destructor);
> + default_tagged_code_props_set (&cprops, type);
> 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 (&cprops, type);
> break;
> }
> }
This is really nice.
> diff --git a/src/symlist.h b/src/symlist.h
> index 43936b2..f918d27 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 type,
> + location loc, char const *code);
>
> #endif /* !SYMLIST_H_ */
> diff --git a/src/symtab.c b/src/symtab.c
> index ad8820f..3c00feb 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[2] =
> + {
> + CODE_PROPS_NONE_INIT,
> + CODE_PROPS_NONE_INIT,
> + };
> +static code_props default_tagless_code_props[2] =
> + {
> + 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 < 2; ++i)
> + code_props_none_init (&res->props[i]);
There are too many "2" in your patch. Please #define a "CODE_PROPS_SIZE"
and use it (or, enum { CODE_PROPS_SIZE = 2 }; actually).
> res->number = NUMBER_UNDEFINED;
> res->prec = 0;
> @@ -94,6 +100,15 @@ symbol_new (uniqstr tag, location loc)
> return res;
> }
>
> +char *
> +code_props_type_string (code_props_type type)
> +{
> + if (type == destructor)
> + return "%destructor";
> + else /* (type == printer) */
> + return "%printer";
> +}
> +
> /*----------------------------------------.
> | Create a new semantic type, named TAG. |
> `----------------------------------------*/
> @@ -105,8 +120,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 < 2; ++i)
> + code_props_none_init (&res->props[i]);
>
> return res;
> }
> @@ -120,9 +135,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,52 +232,56 @@ 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
> -symbol_destructor_set (symbol *sym, code_props const *destructor)
> +symbol_code_props_set (symbol *sym, code_props const *code,
> + code_props_type type)
It reads backward, please pass type before code.
> {
> - if (sym->destructor.code)
> - symbol_redeclaration (sym, "%destructor", sym->destructor.location,
> - destructor->location);
> - sym->destructor = *destructor;
> + if (sym->props[type].code)
> + symbol_redeclaration (sym, code_props_type_string (type),
> + sym->props[type].location,
> + code->location);
> + sym->props[type] = *code;
> }
>
> -/*------------------------------------------.
> -| Set the DESTRUCTOR associated with TYPE. |
> -`------------------------------------------*/
> +/*-----------------------------------------------------.
> +| Set the DESTRUCTOR or PRINTER associated with TYPE. |
> +`-----------------------------------------------------*/
>
> void
> -semantic_type_destructor_set (semantic_type *type,
> - code_props const *destructor)
> +semantic_type_code_props_set (semantic_type *type,
> + code_props const *code,
> + code_props_type cp_type)
Likewise.
> {
> - if (type->destructor.code)
> - semantic_type_redeclaration (type, "%destructor",
> - type->destructor.location,
> - destructor->location);
> - type->destructor = *destructor;
> + if (type->props[cp_type].code)
> + semantic_type_redeclaration (type, code_props_type_string (cp_type),
> + type->props[cp_type].location,
> + code->location);
> + type->props[cp_type] = *code;
> }
>
> -/*---------------------------------------.
> -| Get the computed %destructor for SYM. |
> -`---------------------------------------*/
> +/*---------------------------------------------------.
> +| Get the computed %destructor or %printer for SYM. |
> +`---------------------------------------------------*/
>
> code_props const *
> -symbol_destructor_get (symbol const *sym)
> +symbol_code_props_get (symbol const *sym,
> + code_props_type type)
> {
> /* Per-symbol %destructor. */
> - if (sym->destructor.code)
> - return &sym->destructor;
> + if (sym->props[type].code)
> + return &sym->props[type];
The comment is obviously wrong. The following one too. Say "code props".
>
> /* Per-type %destructor. */
> if (sym->type_name)
> {
> - code_props const *destructor =
> - &semantic_type_get (sym->type_name)->destructor;
> - if (destructor->code)
> - return destructor;
> + code_props const *code =
> + &semantic_type_get (sym->type_name)->props[type];
> + if (code->code)
> + return code;
> }
>
> /* Apply default %destructor's only to user-defined symbols. */
And again a comment which is not updated. Please, double check.
> @@ -270,62 +289,8 @@ symbol_destructor_get (symbol const *sym)
> return &code_props_none;
>
> if (sym->type_name)
> - return &default_tagged_destructor;
> - return &default_tagless_destructor;
> -}
> -
> -/*--------------------------------------.
> -| 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;
> + return &default_tagged_code_props[type];
> + return &default_tagless_code_props[type];
> }
>
> /*-----------------------------------------------------------------.
> @@ -504,21 +469,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 < 2; ++i)
> + if (str->props[i].code)
> + symbol_code_props_set (sym, &str->props[i], i);
> + else if (sym->props[i].code)
> + symbol_code_props_set (str, &sym->props[i], i);
Better, thanks.
>
> if (sym->prec || str->prec)
> {
> @@ -971,53 +926,32 @@ symbols_pack (void)
> `--------------------------------------------------*/
>
> void
> -default_tagged_destructor_set (code_props const *destructor)
> +default_tagged_code_props_set (code_props const *code,
> + code_props_type type)
Wrong order again.
> {
> - if (default_tagged_destructor.code)
> + if (default_tagged_code_props[type].code)
> {
> - complain_at (destructor->location,
> - _("redeclaration for default tagged %%destructor"));
> - complain_at (default_tagged_destructor.location,
> + complain_at (code->location,
> + _("redeclaration for default tagged %s"),
> + code_props_type_string (type));
> + complain_at (default_tagged_code_props[type].location,
> _("previous declaration"));
> }
> - default_tagged_destructor = *destructor;
> + default_tagged_code_props[type] = *code;
> }
>
> void
> -default_tagless_destructor_set (code_props const *destructor)
> +default_tagless_code_props_set (code_props const *code,
> + code_props_type type)
Wrong order.
> {
> - if (default_tagless_destructor.code)
> + if (default_tagless_code_props[type].code)
> {
> - complain_at (destructor->location,
> - _("redeclaration for default tagless %%destructor"));
> - complain_at (default_tagless_destructor.location,
> + complain_at (code->location,
> + _("redeclaration for default tagless %s"),
> + code_props_type_string (type));
> + complain_at (default_tagless_code_props[type].location,
> _("previous declaration"));
> }
> - default_tagless_destructor = *destructor;
> + default_tagless_code_props[type] = *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;
> -}
> diff --git a/src/symtab.h b/src/symtab.h
> index 480d6ca..fa308f8 100644
> --- a/src/symtab.h
> +++ b/src/symtab.h
> @@ -74,6 +74,26 @@ typedef enum
> declared,
> } status;
>
> +/** For symbols:
> + * needed: symbol is created, but neither declared nor used - raise an error
> + * declared: symbol is declared - ok
> + * used: symbol is used, but not declared - raise a warning
> +
> + ** For semantic types:
> + * needed: type is created, but neither declared nor used - raise a warning
> + * declared: type is declared - ok
> + * used: type is used, but not declared - raise a warning
> +
> + Warnings and errors are done in symbol_check_defined() and
> + semantic_type_check_defined(). */
This comment (above) seems to be incorrectly placed. It's hard
to guess what it means.
> +
> +typedef enum code_props_type code_props_type;
> +enum code_props_type
> + {
> + destructor = 0,
> + printer = 1,
> + };
> +
> /* When extending this structure, be sure to complete
> symbol_check_alias_consistency. */
> struct symbol
> @@ -94,13 +114,21 @@ struct symbol
> example, if <tt>symbol::destructor = NULL</tt>, 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;
I hardly believe that removing the member but leaving its comment
be correct.
>
> /** 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;
Ditto.
> +
> +
> + /** Any \c \%destructor (resp. \%printer) declared specificially for this
> + symbol.
> +
> + Access this field only through <tt>symbol</tt>'s interface functions.
> For
> + Example, if <tt>symbol::destructor = NULL</tt> (resp.
> <tt>symbol::printer
> + = NULL</tt>), a default \c \%destructor (resp. \%printer) or a per-type
> + \c symbol_destructor_printer_get will compute the corect one. */
> + code_props props[2];
>
> symbol_number number;
> location prec_location;
> @@ -150,6 +178,9 @@ void symbol_print (symbol *s, FILE *f);
> /** Is this a dummy nonterminal? */
> bool symbol_is_dummy (const symbol *sym);
>
> +/** Returns name of code_props type: \%destructor or \%printer. */
"Name of the code_props...". And I'm ready to bet that this is
a char const *.
> +char *code_props_type_string (code_props_type type);
> +
> /** Return the name of the symbol that can be used as an identifier.
> ** Consider the alias if needed.
> ** Return 0 if there is none (e.g., the symbol is only defined as
> @@ -167,19 +198,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 const *destructor,
> + code_props_type type);
>
> -/** 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 type);
>
> /* Set the \c precedence associated with \c sym.
>
> @@ -229,10 +256,16 @@ 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;
> + /** Where it was defined. */
> + location location;
> +
> + /** Whether it was declared. */
> + status status;
> +
> + /** Any \c %destructor and %printer declared for this
> + semantic type. */
> + code_props props[2];
> +
> } semantic_type;
>
> /** Fetch (or create) the semantic type associated to KEY. */
> @@ -241,13 +274,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 const *destructor,
> + code_props_type cp_type);
>
> /*----------------------------------.
> | Symbol and semantic type tables. |
> @@ -275,14 +305,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 const *destructor,
> + code_props_type type);
> +/** Set the default \c \%destructor or \c \%printer for tagless values. */
> +void default_tagless_code_props_set (code_props const *destructor,
> + code_props_type type);
>
> #endif /* !SYMTAB_H_ */
> --
> 1.7.9.5
Please, submit your proposal again, as an answer to this message.