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 586150577c7b0081f91deff37562a0ea13554263..c967fa7a477b9985eac70ae4ed158e2334c60c0d 100644 (file)
--- 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 ec41fd2b1650fc4274412f4cc3f7d86c1ce276d3..0f247ff05a8cd009b66f164dde643bbb6d94c074 100644 (file)
--- 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 8e3851965abc03b688d3e3eb9c340be955250c43..c932ba548272474cc6e0f567e78060cc172360b8 100644 (file)
--- 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 9bb9d7b6a6ce4a35e5c1d895c8c541e3e34d3fde..c456cbff17c130ad57e0c8e72210035d9a5d3f1c 100644 (file)
--- 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 abb58674f1c80a5b935cbcdbd316463df83e4fff..abea6ce75e24e3db119d783627edb3b0464c86b1 100644 (file)
--- 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 43936b294147d2b851c701dbcd4eb558dadbb1bc..0bd4f3b09f5b62cfe164e7e6e1b0491e34a1bfa3 100644 (file)
--- 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 f4f35290837bd4f16fe02f1c133174503a0c9827..b30ccaf1eb577df2f149f4b00c9c14a2d1f26401 100644 (file)
--- 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 480d6ca3d7bafa3b1b2ee1bcf2324e74428e0c45..0ef4db29d17e87400af3c274b118b123c2993af3 100644 (file)
--- 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 <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.
+  /** Any \c \%destructor (resp. \%printer) declared specificially 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[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_ */