2007-02-07 Paolo Bonzini <bonzini@gnu.org>

[bison.git] / src / symtab.c

diff --git a/src/symtab.c b/src/symtab.c
index ef59c6eef70e1d7a95e40979970fca38ba47f2a5..8910f09c4ee0e4744f848b1aad4ec655c24e5dfe 100644 (file)
--- a/src/symtab.c
+++ b/src/symtab.c
@@ -1,6 +1,6 @@
 /* Symbol table manager for Bison.
 
 /* Symbol table manager for Bison.
 

-   Copyright (C) 1984, 1989, 2000, 2001, 2002, 2004, 2005, 2006 Free
+   Copyright (C) 1984, 1989, 2000, 2001, 2002, 2004, 2005, 2006, 2007 Free

    Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -41,6 +41,15 @@ symbol *accept = NULL;
 symbol *startsymbol = NULL;
 location startsymbol_location;
 
 symbol *startsymbol = NULL;
 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;
+

 /*---------------------------------.
 | Create a new symbol, named TAG.  |
 `---------------------------------*/
 /*---------------------------------.
 | Create a new symbol, named TAG.  |
 `---------------------------------*/


@@ -55,8 +64,8 @@ symbol_new (uniqstr tag, location loc)
   res->location = loc;
 
   res->type_name = NULL;
   res->location = loc;
 
   res->type_name = NULL;

-  res->destructor = NULL;
-  res->printer = NULL;
+  code_props_none_init (&res->destructor);
+  code_props_none_init (&res->printer);

 
   res->number = NUMBER_UNDEFINED;
   res->prec = 0;
 
   res->number = NUMBER_UNDEFINED;
   res->prec = 0;


@@ -74,6 +83,23 @@ symbol_new (uniqstr tag, location loc)
   return res;
 }
 
   return res;
 }
 

+/*----------------------------------------.
+| Create a new semantic type, named TAG.  |
+`----------------------------------------*/
+
+static semantic_type *
+semantic_type_new (uniqstr tag)
+{
+  semantic_type *res = xmalloc (sizeof *res);
+
+  uniqstr_assert (tag);
+  res->tag = tag;
+  code_props_none_init (&res->destructor);
+  code_props_none_init (&res->printer);
+
+  return res;
+}
+

 
 /*-----------------.
 | Print a symbol.  |
 
 /*-----------------.
 | Print a symbol.  |


@@ -83,6 +109,10 @@ symbol_new (uniqstr tag, location loc)
   if (s->Attr)                                         \
     fprintf (f, " %s { %s }", #Attr, s->Attr)
 
   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)
+

 void
 symbol_print (symbol *s, FILE *f)
 {
 void
 symbol_print (symbol *s, FILE *f)
 {


@@ -90,14 +120,15 @@ symbol_print (symbol *s, FILE *f)
     {
       fprintf (f, "\"%s\"", s->tag);
       SYMBOL_ATTR_PRINT (type_name);
     {
       fprintf (f, "\"%s\"", s->tag);
       SYMBOL_ATTR_PRINT (type_name);

-      SYMBOL_ATTR_PRINT (destructor);
-      SYMBOL_ATTR_PRINT (printer);
+      SYMBOL_CODE_PRINT (destructor);
+      SYMBOL_CODE_PRINT (printer);

     }
   else
     fprintf (f, "<NULL>");
 }
 
 #undef SYMBOL_ATTR_PRINT
     }
   else
     fprintf (f, "<NULL>");
 }
 
 #undef SYMBOL_ATTR_PRINT

+#undef SYMBOL_CODE_PRINT

 
 /*------------------------------------------------------------------.
 | Complain that S's WHAT is redeclared at SECOND, and was first set |
 
 /*------------------------------------------------------------------.
 | Complain that S's WHAT is redeclared at SECOND, and was first set |


@@ -105,10 +136,19 @@ symbol_print (symbol *s, FILE *f)
 `------------------------------------------------------------------*/
 
 static void
 `------------------------------------------------------------------*/
 
 static void

-redeclaration (symbol* s, const char *what, location first, location second)
+symbol_redeclaration (symbol *s, const char *what, location first,
+                      location second)

 {
   complain_at (second, _("%s redeclaration for %s"), what, s->tag);
 {
   complain_at (second, _("%s redeclaration for %s"), what, s->tag);

-  complain_at (first, _("first declaration"));
+  complain_at (first, _("previous declaration"));
+}
+
+static void
+semantic_type_redeclaration (semantic_type *s, const char *what, location first,
+                             location second)
+{
+  complain_at (second, _("%s redeclaration for <%s>"), what, s->tag);
+  complain_at (first, _("previous declaration"));

 }
 
 
 }
 
 


@@ -123,7 +163,7 @@ symbol_type_set (symbol *sym, uniqstr type_name, location loc)
   if (type_name)
     {
       if (sym->type_name)
   if (type_name)
     {
       if (sym->type_name)

-       redeclaration (sym, "%type", sym->type_location, loc);
+       symbol_redeclaration (sym, "%type", sym->type_location, loc);

       uniqstr_assert (type_name);
       sym->type_name = type_name;
       sym->type_location = loc;
       uniqstr_assert (type_name);
       sym->type_name = type_name;
       sym->type_location = loc;


@@ -131,39 +171,116 @@ symbol_type_set (symbol *sym, uniqstr type_name, location loc)
 }
 
 
 }
 
 

-/*------------------------------------------------------------------.
-| Set the DESTRUCTOR associated with SYM.  Do nothing if passed 0.  |
-`------------------------------------------------------------------*/
+/*-----------------------------------------.
+| 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
 
 void

-symbol_destructor_set (symbol *sym, const char *destructor, location loc)
+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)

 {
 {

-  if (destructor)
+  /* Per-symbol %destructor.  */
+  if (sym->destructor.code)
+    return &sym->destructor;
+
+  /* Per-type %destructor.  */
+  if (sym->type_name)

     {
     {

-      if (sym->destructor)
-       redeclaration (sym, "%destructor", sym->destructor_location, loc);
-      sym->destructor = destructor;
-      sym->destructor_location = loc;
+      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 PRINTER associated with SYM.  Do nothing if passed 0.  |
-`---------------------------------------------------------------*/
+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
 
 void

-symbol_printer_set (symbol *sym, const char *printer, location loc)
+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)

 {
 {

-  if (printer)
+  /* Per-symbol %printer.  */
+  if (sym->printer.code)
+    return &sym->printer;
+
+  /* Per-type %printer.  */
+  if (sym->type_name)

     {
     {

-      if (sym->printer)
-       redeclaration (sym, "%printer", sym->destructor_location, loc);
-      sym->printer = printer;
-      sym->printer_location = loc;
+      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;
+}

 
 /*-----------------------------------------------------------------.
 | Set the PRECEDENCE associated with SYM.  Does nothing if invoked |
 
 /*-----------------------------------------------------------------.
 | Set the PRECEDENCE associated with SYM.  Does nothing if invoked |


@@ -176,7 +293,8 @@ symbol_precedence_set (symbol *sym, int prec, assoc a, location loc)
   if (a != undef_assoc)
     {
       if (sym->prec != 0)
   if (a != undef_assoc)
     {
       if (sym->prec != 0)

-       redeclaration (sym, assoc_to_string (a), sym->prec_location, loc);
+       symbol_redeclaration (sym, assoc_to_string (a), sym->prec_location,
+                              loc);

       sym->prec = prec;
       sym->assoc = a;
       sym->prec_location = loc;
       sym->prec = prec;
       sym->assoc = a;
       sym->prec_location = loc;


@@ -223,13 +341,19 @@ symbol_class_set (symbol *sym, symbol_class class, location loc, bool declaring)
 void
 symbol_user_token_number_set (symbol *sym, int user_token_number, location loc)
 {
 void
 symbol_user_token_number_set (symbol *sym, int user_token_number, location loc)
 {

-  assert (sym->class == token_sym);
+  int *user_token_numberp;

 
 

-  if (sym->user_token_number != USER_NUMBER_UNDEFINED
-      && sym->user_token_number != user_token_number)
+  aver (sym->class == token_sym);
+
+  if (sym->user_token_number != USER_NUMBER_ALIAS)
+    user_token_numberp = &sym->user_token_number;
+  else
+    user_token_numberp = &sym->alias->user_token_number;
+  if (*user_token_numberp != USER_NUMBER_UNDEFINED
+      && *user_token_numberp != user_token_number)

     complain_at (loc, _("redefining user token number of %s"), sym->tag);
 
     complain_at (loc, _("redefining user token number of %s"), sym->tag);
 

-  sym->user_token_number = user_token_number;
+  *user_token_numberp = user_token_number;

   /* User defined $end token? */
   if (user_token_number == 0)
     {
   /* User defined $end token? */
   if (user_token_number == 0)
     {


@@ -291,12 +415,7 @@ symbol_make_alias (symbol *sym, symbol *symval, location loc)
       sym->user_token_number = USER_NUMBER_ALIAS;
       symval->alias = sym;
       sym->alias = symval;
       sym->user_token_number = USER_NUMBER_ALIAS;
       symval->alias = sym;
       sym->alias = symval;

-      /* sym and symval combined are only one symbol.  */
-      nsyms--;
-      ntokens--;
-      assert (ntokens == sym->number || ntokens == symval->number);
-      sym->number = symval->number =
-       (symval->number < sym->number) ? symval->number : sym->number;
+      symval->number = sym->number;

       symbol_type_set (symval, sym->type_name, loc);
     }
 }
       symbol_type_set (symval, sym->type_name, loc);
     }
 }


@@ -326,22 +445,20 @@ symbol_check_alias_consistency (symbol *this)
     }
 
 
     }
 
 

-  if (orig->destructor || alias->destructor)
+  if (orig->destructor.code || alias->destructor.code)

     {
     {

-      if (orig->destructor)
-       symbol_destructor_set (alias, orig->destructor,
-                              orig->destructor_location);
+      if (orig->destructor.code)
+       symbol_destructor_set (alias, &orig->destructor);

       else
       else

-       symbol_destructor_set (orig, alias->destructor,
-                              alias->destructor_location);
+       symbol_destructor_set (orig, &alias->destructor);

     }
 
     }
 

-  if (orig->printer || alias->printer)
+  if (orig->printer.code || alias->printer.code)

     {
     {

-      if (orig->printer)
-       symbol_printer_set (alias, orig->printer, orig->printer_location);
+      if (orig->printer.code)
+       symbol_printer_set (alias, &orig->printer);

       else
       else

-       symbol_printer_set (orig, alias->printer, alias->printer_location);
+       symbol_printer_set (orig, &alias->printer);

     }
 
   if (alias->prec || orig->prec)
     }
 
   if (alias->prec || orig->prec)


@@ -387,7 +504,7 @@ symbol_pack (symbol *this)
            this->number = this->alias->number = 0;
          else
            {
            this->number = this->alias->number = 0;
          else
            {

-             assert (this->alias->number != NUMBER_UNDEFINED);
+             aver (this->alias->number != NUMBER_UNDEFINED);

              this->number = this->alias->number;
            }
        }
              this->number = this->alias->number;
            }
        }


@@ -396,7 +513,7 @@ symbol_pack (symbol *this)
        return true;
     }
   else /* this->class == token_sym */
        return true;
     }
   else /* this->class == token_sym */

-    assert (this->number != NUMBER_UNDEFINED);
+    aver (this->number != NUMBER_UNDEFINED);

 
   symbols[this->number] = this;
   return true;
 
   symbols[this->number] = this;
   return true;


@@ -442,14 +559,15 @@ symbol_translation_processor (void *this, void *null ATTRIBUTE_UNUSED)
 }
 
 
 }
 
 

-/*----------------------.
-| A symbol hash table.  |
-`----------------------*/
+/*---------------------------------------.
+| Symbol and semantic type hash tables.  |
+`---------------------------------------*/

 
 

-/* Initial capacity of symbols hash table.  */
+/* Initial capacity of symbol and semantic type hash table.  */

 #define HT_INITIAL_CAPACITY 257
 
 static struct hash_table *symbol_table = NULL;
 #define HT_INITIAL_CAPACITY 257
 
 static struct hash_table *symbol_table = NULL;

+static struct hash_table *semantic_type_table = NULL;

 
 static inline bool
 hash_compare_symbol (const symbol *m1, const symbol *m2)
 
 static inline bool
 hash_compare_symbol (const symbol *m1, const symbol *m2)


@@ -458,12 +576,25 @@ hash_compare_symbol (const symbol *m1, const symbol *m2)
   return UNIQSTR_EQ (m1->tag, m2->tag);
 }
 
   return UNIQSTR_EQ (m1->tag, m2->tag);
 }
 

+static inline bool
+hash_compare_semantic_type (const semantic_type *m1, const semantic_type *m2)
+{
+  /* Since names are unique, we can compare the pointers themselves.  */
+  return UNIQSTR_EQ (m1->tag, m2->tag);
+}
+

 static bool
 hash_symbol_comparator (void const *m1, void const *m2)
 {
   return hash_compare_symbol (m1, m2);
 }
 
 static bool
 hash_symbol_comparator (void const *m1, void const *m2)
 {
   return hash_compare_symbol (m1, m2);
 }
 

+static bool
+hash_semantic_type_comparator (void const *m1, void const *m2)
+{
+  return hash_compare_semantic_type (m1, m2);
+}
+

 static inline size_t
 hash_symbol (const symbol *m, size_t tablesize)
 {
 static inline size_t
 hash_symbol (const symbol *m, size_t tablesize)
 {


@@ -471,12 +602,24 @@ hash_symbol (const symbol *m, size_t tablesize)
   return ((uintptr_t) m->tag) % tablesize;
 }
 
   return ((uintptr_t) m->tag) % tablesize;
 }
 

+static inline size_t
+hash_semantic_type (const semantic_type *m, size_t tablesize)
+{
+  /* Since names are unique, we can hash the pointer itself.  */
+  return ((uintptr_t) m->tag) % tablesize;
+}
+

 static size_t
 hash_symbol_hasher (void const *m, size_t tablesize)
 {
   return hash_symbol (m, tablesize);
 }
 
 static size_t
 hash_symbol_hasher (void const *m, size_t tablesize)
 {
   return hash_symbol (m, tablesize);
 }
 

+static size_t
+hash_semantic_type_hasher (void const *m, size_t tablesize)
+{
+  return hash_semantic_type (m, tablesize);
+}

 
 /*-------------------------------.
 | Create the symbol hash table.  |
 
 /*-------------------------------.
 | Create the symbol hash table.  |


@@ -490,6 +633,11 @@ symbols_new (void)
                                  hash_symbol_hasher,
                                  hash_symbol_comparator,
                                  free);
                                  hash_symbol_hasher,
                                  hash_symbol_comparator,
                                  free);

+  semantic_type_table = hash_initialize (HT_INITIAL_CAPACITY,
+                                        NULL,
+                                        hash_semantic_type_hasher,
+                                        hash_semantic_type_comparator,
+                                        free);

 }
 
 
 }
 
 


@@ -499,12 +647,11 @@ symbols_new (void)
 `----------------------------------------------------------------*/
 
 symbol *
 `----------------------------------------------------------------*/
 
 symbol *

-symbol_get (const char *key, location loc)
+symbol_from_uniqstr (const uniqstr key, location loc)

 {
   symbol probe;
   symbol *entry;
 
 {
   symbol probe;
   symbol *entry;
 

-  key = uniqstr_new (key);

   probe.tag = key;
   entry = hash_lookup (symbol_table, &probe);
 
   probe.tag = key;
   entry = hash_lookup (symbol_table, &probe);
 


@@ -518,6 +665,54 @@ symbol_get (const char *key, location loc)
 }
 
 
 }
 
 

+/*-----------------------------------------------------------------------.
+| Find the semantic type named KEY, and return it.  If it does not exist |
+| yet, create it.                                                        |
+`-----------------------------------------------------------------------*/
+
+semantic_type *
+semantic_type_from_uniqstr (const uniqstr key)
+{
+  semantic_type probe;
+  semantic_type *entry;
+
+  probe.tag = key;
+  entry = hash_lookup (semantic_type_table, &probe);
+
+  if (!entry)
+    {
+      /* First insertion in the hash. */
+      entry = semantic_type_new (key);
+      hash_insert (semantic_type_table, entry);
+    }
+  return entry;
+}
+
+
+/*----------------------------------------------------------------.
+| Find the symbol named KEY, and return it.  If it does not exist |
+| yet, create it.                                                 |
+`----------------------------------------------------------------*/
+
+symbol *
+symbol_get (const char *key, location loc)
+{
+  return symbol_from_uniqstr (uniqstr_new (key), loc);
+}
+
+
+/*-----------------------------------------------------------------------.
+| Find the semantic type named KEY, and return it.  If it does not exist |
+| yet, create it.                                                        |
+`-----------------------------------------------------------------------*/
+
+semantic_type *
+semantic_type_get (const char *key)
+{
+  return semantic_type_from_uniqstr (uniqstr_new (key));
+}
+
+

 /*------------------------------------------------------------------.
 | Generate a dummy nonterminal, whose name cannot conflict with the |
 | user's names.                                                     |
 /*------------------------------------------------------------------.
 | Generate a dummy nonterminal, whose name cannot conflict with the |
 | user's names.                                                     |


@@ -532,13 +727,18 @@ dummy_symbol_get (location loc)
 
   symbol *sym;
 
 
   symbol *sym;
 

-  sprintf (buf, "@%d", ++dummy_count);
+  sprintf (buf, "$@%d", ++dummy_count);

   sym = symbol_get (buf, loc);
   sym->class = nterm_sym;
   sym->number = nvars++;
   return sym;
 }
 
   sym = symbol_get (buf, loc);
   sym->class = nterm_sym;
   sym->number = nvars++;
   return sym;
 }
 

+bool
+symbol_is_dummy (const symbol *sym)
+{
+  return sym->tag[0] == '@' || (sym->tag[0] == '$' && sym->tag[1] == '@');
+}

 
 /*-------------------.
 | Free the symbols.  |
 
 /*-------------------.
 | Free the symbols.  |


@@ -548,6 +748,7 @@ void
 symbols_free (void)
 {
   hash_free (symbol_table);
 symbols_free (void)
 {
   hash_free (symbol_table);

+  hash_free (semantic_type_table);

   free (symbols);
 }
 
   free (symbols);
 }
 


@@ -639,11 +840,35 @@ symbols_token_translations_init (void)
 void
 symbols_pack (void)
 {
 void
 symbols_pack (void)
 {

-  symbols = xcalloc (nsyms, sizeof *symbols);
-

   symbols_do (symbol_check_alias_consistency_processor, NULL);
   symbols_do (symbol_check_alias_consistency_processor, NULL);

+
+  symbols = xcalloc (nsyms, sizeof *symbols);

   symbols_do (symbol_pack_processor, NULL);
 
   symbols_do (symbol_pack_processor, NULL);
 

+  /* Aliases leave empty slots in symbols, so remove them.  */
+  {
+    int writei;
+    int readi;
+    int nsyms_old = nsyms;
+    for (writei = 0, readi = 0; readi < nsyms_old; readi += 1)
+      {
+        if (symbols[readi] == NULL)
+          {
+            nsyms -= 1;
+            ntokens -= 1;
+          }
+        else
+          {
+            symbols[writei] = symbols[readi];
+            symbols[writei]->number = writei;
+            if (symbols[writei]->alias)
+              symbols[writei]->alias->number = writei;
+            writei += 1;
+          }
+      }
+  }
+  symbols = xnrealloc (symbols, nsyms, sizeof *symbols);
+

   symbols_token_translations_init ();
 
   if (startsymbol->class == unknown_sym)
   symbols_token_translations_init ();
 
   if (startsymbol->class == unknown_sym)


@@ -655,3 +880,61 @@ symbols_pack (void)
              _("the start symbol %s is a token"),
              startsymbol->tag);
 }
              _("the start symbol %s is a token"),
              startsymbol->tag);
 }

+
+
+/*--------------------------------------------------.
+| Set default tagged/tagless %destructor/%printer.  |
+`--------------------------------------------------*/
+
+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)
+{
+  if (default_tagless_destructor.code)
+    {
+      complain_at (destructor->location,
+                   _("redeclaration for default tagless %%destructor"));
+      complain_at (default_tagless_destructor.location,
+                  _("previous declaration"));
+    }
+  default_tagless_destructor = *destructor;
+}
+
+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;
+}
+