Re: [PATCH 1/3] maint: code factorization for %printer & %destructor

[Akim Demaille]

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.