* src/symtab.h (SALIAS, SUNDEF): Rename as...

[bison.git] / src / reader.c

diff --git a/src/reader.c b/src/reader.c
index f76f5c8487a0fbe25636831d0689bf9f3305aed9..75957010632f83d9c95c4132521535c48eaec0a3 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -45,9 +45,6 @@ typedef struct symbol_list
   const char *action;
   int action_line;
 
   const char *action;
   int action_line;
 

-  /* The guard is attached to the LHS of a rule. */
-  const char *guard;
-  int guard_line;

   symbol_t *ruleprec;
 } symbol_list;
 
   symbol_t *ruleprec;
 } symbol_list;
 


@@ -80,8 +77,6 @@ symbol_list_new (symbol_t *sym)
   res->line = lineno;
   res->action = NULL;
   res->action_line = 0;
   res->line = lineno;
   res->action = NULL;
   res->action_line = 0;

-  res->guard = NULL;
-  res->guard_line = 0;

   res->ruleprec = NULL;
   return res;
 }
   res->ruleprec = NULL;
   return res;
 }


@@ -131,7 +126,7 @@ symbol_make_alias (symbol_t *symbol, char *typename)
       symval->class = token_sym;
       symval->type_name = typename;
       symval->user_token_number = symbol->user_token_number;
       symval->class = token_sym;
       symval->type_name = typename;
       symval->user_token_number = symbol->user_token_number;

-      symbol->user_token_number = SALIAS;
+      symbol->user_token_number = USER_NUMBER_ALIAS;

       symval->alias = symbol;
       symbol->alias = symval;
       /* symbol and symval combined are only one symbol */
       symval->alias = symbol;
       symbol->alias = symval;
       /* symbol and symval combined are only one symbol */


@@ -154,7 +149,7 @@ static bool
 symbol_check_alias_consistence (symbol_t *this)
 {
   /* Check only those who _are_ the aliases. */
 symbol_check_alias_consistence (symbol_t *this)
 {
   /* Check only those who _are_ the aliases. */

-  if (this->alias && this->user_token_number == SALIAS)
+  if (this->alias && this->user_token_number == USER_NUMBER_ALIAS)

     {
       if (this->prec != this->alias->prec)
        {
     {
       if (this->prec != this->alias->prec)
        {


@@ -199,23 +194,23 @@ symbol_pack (symbol_t *this)
       /* This symbol and its alias are a single token defn.
         Allocate a tokno, and assign to both check agreement of
         prec and assoc fields and make both the same */
       /* This symbol and its alias are a single token defn.
         Allocate a tokno, and assign to both check agreement of
         prec and assoc fields and make both the same */

-      if (this->number == -1)
+      if (this->number == NUMBER_UNDEFINED)

        {
          if (this == eoftoken || this->alias == eoftoken)
            this->number = this->alias->number = 0;
          else
            {
        {
          if (this == eoftoken || this->alias == eoftoken)
            this->number = this->alias->number = 0;
          else
            {

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

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

-      /* Do not do processing below for SALIASs.  */
-      if (this->user_token_number == SALIAS)
+      /* Do not do processing below for USER_NUMBER_ALIASs.  */
+      if (this->user_token_number == USER_NUMBER_ALIAS)

        return TRUE;
     }
   else /* this->class == token_sym */
     {
        return TRUE;
     }
   else /* this->class == token_sym */
     {

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

     }
 
   symbols[this->number] = this;
     }
 
   symbols[this->number] = this;


@@ -234,7 +229,7 @@ symbol_translation (symbol_t *this)
 {
   /* Non-terminal? */
   if (this->class == token_sym
 {
   /* Non-terminal? */
   if (this->class == token_sym

-      && this->user_token_number != SALIAS)
+      && this->user_token_number != USER_NUMBER_ALIAS)

     {
       /* A token which translation has already been set? */
       if (token_translations[this->user_token_number] != undeftoken->number)
     {
       /* A token which translation has already been set? */
       if (token_translations[this->user_token_number] != undeftoken->number)


@@ -332,6 +327,28 @@ get_type_name (int n, symbol_list *rule)
   return rp->sym->type_name;
 }
 \f
   return rp->sym->type_name;
 }
 \f

+/*------------------------------------------------------------------.
+| Copy the character C to OOUT, and insert quadigraphs when needed. |
+`------------------------------------------------------------------*/
+
+static inline void
+copy_character (struct obstack *oout, int c)
+{
+  switch (c)
+    {
+    case '[':
+      obstack_sgrow (oout, "@<:@");
+      break;
+
+    case ']':
+      obstack_sgrow (oout, "@:>@");
+      break;
+
+    default:
+      obstack_1grow (oout, c);
+    }
+}
+

 /*------------------------------------------------------------.
 | Dump the string from FIN to OOUT if non null.  MATCH is the |
 | delimiter of the string (either ' or ").                    |
 /*------------------------------------------------------------.
 | Dump the string from FIN to OOUT if non null.  MATCH is the |
 | delimiter of the string (either ' or ").                    |


@@ -359,14 +376,14 @@ copy_string2 (FILE *fin, struct obstack *oout, int match, int store)
          continue;
        }
 
          continue;
        }
 

-      obstack_1grow (oout, c);
+      copy_character (oout, c);

 
       if (c == '\\')
        {
          c = getc (fin);
          if (c == EOF)
            fatal (_("unterminated string at end of file"));
 
       if (c == '\\')
        {
          c = getc (fin);
          if (c == EOF)
            fatal (_("unterminated string at end of file"));

-         obstack_1grow (oout, c);
+         copy_character (oout, c);

 
          if (c == '\n')
            ++lineno;
 
          if (c == '\n')
            ++lineno;


@@ -463,30 +480,29 @@ copy_comment (FILE *fin, struct obstack *oout)
        fatal (_("unterminated comment"));
       else
        {
        fatal (_("unterminated comment"));
       else
        {

-         obstack_1grow (oout, c);
+         copy_character (oout, c);

          c = getc (fin);
        }
     }
 }
 
 
          c = getc (fin);
        }
     }
 }
 
 

-/*-----------------------------------------------------------------.
-| FIN is pointing to a location (i.e., a `@').  Output to OOUT a   |
-| reference to this location. STACK_OFFSET is the number of values |
-| in the current rule so far, which says where to find `$0' with   |
-| respect to the top of the stack.                                 |
-`-----------------------------------------------------------------*/
+/*-------------------------------------------------------------------.
+| FIN is pointing to a location (i.e., a `@').  Output to OOUT a     |
+| reference to this location. RULE_LENGTH is the number of values in |
+| the current rule so far, which says where to find `$0' with        |
+| respect to the top of the stack.                                   |
+`-------------------------------------------------------------------*/

 
 static inline void
 
 static inline void

-copy_at (FILE *fin, struct obstack *oout, int stack_offset)
+copy_at (FILE *fin, struct obstack *oout, int rule_length)

 {
 {

-  int c;
+  int c = getc (fin);
+  locations_flag = 1;

 
 

-  c = getc (fin);

   if (c == '$')
     {
   if (c == '$')
     {

-      obstack_sgrow (oout, "yyloc");
-      locations_flag = 1;
+      obstack_sgrow (oout, "]b4_lhs_location[");

     }
   else if (isdigit (c) || c == '-')
     {
     }
   else if (isdigit (c) || c == '-')
     {


@@ -494,16 +510,11 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
 
       ungetc (c, fin);
       n = read_signed_integer (fin);
 
       ungetc (c, fin);
       n = read_signed_integer (fin);

-      if (n > stack_offset)
+      if (n > rule_length)

        complain (_("invalid value: %s%d"), "@", n);
       else
        complain (_("invalid value: %s%d"), "@", n);
       else

-       {
-         /* Offset is always 0 if parser has already popped the stack
-            pointer.  */
-         obstack_fgrow1 (oout, "yylsp[%d]",
-                         n - (semantic_parser ? 0 : stack_offset));
-         locations_flag = 1;
-       }
+       obstack_fgrow2 (oout, "]b4_rhs_location([%d], [%d])[",
+                       rule_length, n);

     }
   else
     {
     }
   else
     {


@@ -514,19 +525,19 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
 }
 
 
 }
 
 

-/*-------------------------------------------------------------------.
-| FIN is pointing to a wannabee semantic value (i.e., a `$').        |
-|                                                                    |
-| Possible inputs: $[<TYPENAME>]($|integer)                          |
-|                                                                    |
-| Output to OOUT a reference to this semantic value. STACK_OFFSET is |
-| the number of values in the current rule so far, which says where  |
-| to find `$0' with respect to the top of the stack.                 |
-`-------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| FIN is pointing to a wannabee semantic value (i.e., a `$').       |
+|                                                                   |
+| Possible inputs: $[<TYPENAME>]($|integer)                         |
+|                                                                   |
+| Output to OOUT a reference to this semantic value. RULE_LENGTH is |
+| the number of values in the current rule so far, which says where |
+| to find `$0' with respect to the top of the stack.                |
+`------------------------------------------------------------------*/

 
 static inline void
 copy_dollar (FILE *fin, struct obstack *oout,
 
 static inline void
 copy_dollar (FILE *fin, struct obstack *oout,

-            symbol_list *rule, int stack_offset)
+            symbol_list *rule, int rule_length)

 {
   int c = getc (fin);
   const char *type_name = NULL;
 {
   int c = getc (fin);
   const char *type_name = NULL;


@@ -542,15 +553,15 @@ copy_dollar (FILE *fin, struct obstack *oout,
 
   if (c == '$')
     {
 
   if (c == '$')
     {

-      obstack_sgrow (oout, "yyval");
-

       if (!type_name)
        type_name = get_type_name (0, rule);
       if (!type_name)
        type_name = get_type_name (0, rule);

-      if (type_name)
-       obstack_fgrow1 (oout, ".%s", type_name);

       if (!type_name && typed)
        complain (_("$$ of `%s' has no declared type"),
                  rule->sym->tag);
       if (!type_name && typed)
        complain (_("$$ of `%s' has no declared type"),
                  rule->sym->tag);

+      if (!type_name)
+       type_name = "";
+      obstack_fgrow1 (oout,
+                     "]b4_lhs_value([%s])[", type_name);

     }
   else if (isdigit (c) || c == '-')
     {
     }
   else if (isdigit (c) || c == '-')
     {


@@ -558,23 +569,19 @@ copy_dollar (FILE *fin, struct obstack *oout,
       ungetc (c, fin);
       n = read_signed_integer (fin);
 
       ungetc (c, fin);
       n = read_signed_integer (fin);
 

-      if (n > stack_offset)
+      if (n > rule_length)

        complain (_("invalid value: %s%d"), "$", n);
       else
        {
          if (!type_name && n > 0)
            type_name = get_type_name (n, rule);
        complain (_("invalid value: %s%d"), "$", n);
       else
        {
          if (!type_name && n > 0)
            type_name = get_type_name (n, rule);

-
-         /* Offset is always 0 if parser has already popped the stack
-            pointer.  */
-         obstack_fgrow1 (oout, "yyvsp[%d]",
-                         n - (semantic_parser ? 0 : stack_offset));
-
-         if (type_name)
-           obstack_fgrow1 (oout, ".%s", type_name);

          if (!type_name && typed)
            complain (_("$%d of `%s' has no declared type"),
                      n, rule->sym->tag);
          if (!type_name && typed)
            complain (_("$%d of `%s' has no declared type"),
                      n, rule->sym->tag);

+         if (!type_name)
+           type_name = "";
+         obstack_fgrow3 (oout, "]b4_rhs_value([%d], [%d], [%s])[",
+                         rule_length, n, type_name);

        }
     }
   else
        }
     }
   else


@@ -591,7 +598,7 @@ copy_dollar (FILE *fin, struct obstack *oout,
 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void

-copy_definition (void)
+copy_definition (struct obstack *oout)

 {
   int c;
   /* -1 while reading a character if prev char was %. */
 {
   int c;
   /* -1 while reading a character if prev char was %. */


@@ -599,7 +606,7 @@ copy_definition (void)
 
   if (!no_lines_flag)
     {
 
   if (!no_lines_flag)
     {

-      obstack_fgrow2 (&attrs_obstack, muscle_find ("linef"),
+      obstack_fgrow2 (oout, muscle_find ("linef"),

                      lineno, quotearg_style (c_quoting_style,
                                              muscle_find ("filename")));
     }
                      lineno, quotearg_style (c_quoting_style,
                                              muscle_find ("filename")));
     }


@@ -613,7 +620,7 @@ copy_definition (void)
       switch (c)
        {
        case '\n':
       switch (c)
        {
        case '\n':

-         obstack_1grow (&attrs_obstack, c);
+         obstack_1grow (oout, c);

          ++lineno;
          break;
 
          ++lineno;
          break;
 


@@ -623,18 +630,18 @@ copy_definition (void)
 
        case '\'':
        case '"':
 
        case '\'':
        case '"':

-         copy_string (finput, &attrs_obstack, c);
+         copy_string (finput, oout, c);

          break;
 
        case '/':
          break;
 
        case '/':

-         copy_comment (finput, &attrs_obstack);
+         copy_comment (finput, oout);

          break;
 
        case EOF:
          fatal ("%s", _("unterminated `%{' definition"));
 
        default:
          break;
 
        case EOF:
          fatal ("%s", _("unterminated `%{' definition"));
 
        default:

-         obstack_1grow (&attrs_obstack, c);
+         copy_character (oout, c);

        }
 
       c = getc (finput);
        }
 
       c = getc (finput);


@@ -643,7 +650,7 @@ copy_definition (void)
        {
          if (c == '}')
            return;
        {
          if (c == '}')
            return;

-         obstack_1grow (&attrs_obstack, '%');
+         obstack_1grow (oout, '%');

        }
       after_percent = 0;
     }
        }
       after_percent = 0;
     }


@@ -705,7 +712,7 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
          symbol->class = what_is;
          if (what_is == nterm_sym && oldclass != nterm_sym)
            symbol->number = nvars++;
          symbol->class = what_is;
          if (what_is == nterm_sym && oldclass != nterm_sym)
            symbol->number = nvars++;

-         if (what_is == token_sym && symbol->number == -1)
+         if (what_is == token_sym && symbol->number == NUMBER_UNDEFINED)

            symbol->number = ntokens++;
 
          if (typename)
            symbol->number = ntokens++;
 
          if (typename)


@@ -857,7 +864,7 @@ parse_assoc_decl (associativity assoc)
          symval->assoc = assoc;
          if (symval->class == nterm_sym)
            complain (_("symbol %s redefined"), symval->tag);
          symval->assoc = assoc;
          if (symval->class == nterm_sym)
            complain (_("symbol %s redefined"), symval->tag);

-         if (symval->number == -1)
+         if (symval->number == NUMBER_UNDEFINED)

            {
              symval->number = ntokens++;
              symval->class = token_sym;
            {
              symval->number = ntokens++;
              symval->class = token_sym;


@@ -991,10 +998,10 @@ parse_expect_decl (void)
 |                                                                    |
 | Two symbols are entered in the table, one for the token symbol and |
 | one for the literal.  Both are given the <type>, if any, from the  |
 |                                                                    |
 | Two symbols are entered in the table, one for the token symbol and |
 | one for the literal.  Both are given the <type>, if any, from the  |

-| declaration.  The ->user_token_number of the first is SALIAS and   |
-| the ->user_token_number of the second is set to the number, if     |
-| any, from the declaration.  The two symbols are linked via         |
-| pointers in their ->alias fields.                                  |
+| declaration.  The ->user_token_number of the first is              |
+| USER_NUMBER_ALIAS and the ->user_token_number of the second is set |
+| to the number, if any, from the declaration.  The two symbols are  |
+| linked via pointers in their ->alias fields.                       |

 |                                                                    |
 | During OUTPUT_DEFINES_TABLE, the symbol is reported thereafter,    |
 | only the literal string is retained it is the literal string that  |
 |                                                                    |
 | During OUTPUT_DEFINES_TABLE, the symbol is reported thereafter,    |
 | only the literal string is retained it is the literal string that  |


@@ -1007,7 +1014,7 @@ parse_thong_decl (void)
   token_t token;
   symbol_t *symbol;
   char *typename = 0;
   token_t token;
   symbol_t *symbol;
   char *typename = 0;

-  int usrtoknum = SUNDEF;
+  int usrtoknum = USER_NUMBER_UNDEFINED;

 
   token = lex ();              /* fetch typename or first token */
   if (token == tok_typename)
 
   token = lex ();              /* fetch typename or first token */
   if (token == tok_typename)


@@ -1028,7 +1035,7 @@ parse_thong_decl (void)
     }
   symval->class = token_sym;
   symval->type_name = typename;
     }
   symval->class = token_sym;
   symval->type_name = typename;

-  symval->user_token_number = SALIAS;
+  symval->user_token_number = USER_NUMBER_ALIAS;

   symbol = symval;
 
   token = lex ();              /* get number or literal string */
   symbol = symval;
 
   token = lex ();              /* get number or literal string */


@@ -1154,7 +1161,7 @@ parse_skel_decl (void)
 /*----------------------------------------------------------------.
 | Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
 | any `%' declarations, and copy the contents of any `%{ ... %}'  |
 /*----------------------------------------------------------------.
 | Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
 | any `%' declarations, and copy the contents of any `%{ ... %}'  |

-| groups to ATTRS_OBSTACK.                                        |
+| groups to PRE_PROLOGUE_OBSTACK or POST_PROLOGUE_OBSTACK.        |

 `----------------------------------------------------------------*/
 
 static void
 `----------------------------------------------------------------*/
 
 static void


@@ -1174,7 +1181,10 @@ read_declarations (void)
              return;
 
            case tok_percent_left_curly:
              return;
 
            case tok_percent_left_curly:

-             copy_definition ();
+              if (!typed)
+               copy_definition (&pre_prologue_obstack);
+             else
+               copy_definition (&post_prologue_obstack);

              break;
 
            case tok_token:
              break;
 
            case tok_token:


@@ -1252,26 +1262,26 @@ read_declarations (void)
     }
 }
 \f
     }
 }
 \f

-/*-------------------------------------------------------------------.
-| Assuming that a `{' has just been seen, copy everything up to the  |
-| matching `}' into the actions file.  STACK_OFFSET is the number of |
-| values in the current rule so far, which says where to find `$0'   |
-| with respect to the top of the stack.                              |
-|                                                                    |
-| This routine is used both for actions and guards.  Only            |
-| ACTION_OBSTACK is used, but this is fine, since we use only        |
-| pointers to relevant portions inside this obstack.                 |
-`-------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Assuming that a `{' has just been seen, copy everything up to the |
+| matching `}' into ACTION_OBSTACK.                                 |
+|                                                                   |
+| RULE_LENGTH is the number of values in the current rule so far,   |
+| which says where to find `$0' with respect to the top of the      |
+| stack.  It is not the same as the rule->length in the case of mid |
+| rule actions.                                                     |
+|                                                                   |
+| This routine is used for actions.                                 |
+`------------------------------------------------------------------*/

 
 static void
 
 static void

-parse_braces (symbol_list *rule, int stack_offset)
+parse_action (symbol_list *rule, int rule_length)

 {
 {

-  int c;
-  int count;
-
-  count = 1;
+  int count = 1;
+  rule->action_line = lineno;

   while (count > 0)
     {
   while (count > 0)
     {

+      int c;

       while ((c = getc (finput)) != '}')
        switch (c)
          {
       while ((c = getc (finput)) != '}')
        switch (c)
          {


@@ -1295,13 +1305,11 @@ parse_braces (symbol_list *rule, int stack_offset)
            break;
 
          case '$':
            break;
 
          case '$':

-           copy_dollar (finput, &action_obstack,
-                        rule, stack_offset);
+           copy_dollar (finput, &action_obstack, rule, rule_length);

            break;
 
          case '@':
            break;
 
          case '@':

-           copy_at (finput, &action_obstack,
-                    stack_offset);
+           copy_at (finput, &action_obstack, rule_length);

            break;
 
          case EOF:
            break;
 
          case EOF:


@@ -1317,29 +1325,9 @@ parse_braces (symbol_list *rule, int stack_offset)
     }
 
   obstack_1grow (&action_obstack, '\0');
     }
 
   obstack_1grow (&action_obstack, '\0');

-}
-
-
-static void
-parse_action (symbol_list *rule, int stack_offset)
-{
-  rule->action_line = lineno;
-  parse_braces (rule, stack_offset);

   rule->action = obstack_finish (&action_obstack);
 }
 
   rule->action = obstack_finish (&action_obstack);
 }
 

-
-static void
-parse_guard (symbol_list *rule, int stack_offset)
-{
-  token_t t = lex ();
-  if (t != tok_left_curly)
-    complain (_("invalid %s declaration"), "%guard");
-  rule->guard_line = lineno;
-  parse_braces (rule, stack_offset);
-  rule->guard = obstack_finish (&action_obstack);
-}
-

 \f
 
 /*-------------------------------------------------------------------.
 \f
 
 /*-------------------------------------------------------------------.


@@ -1371,8 +1359,8 @@ gensym (void)
 | null pointer instead of a symbol to terminate the rule.  The next  |
 | symbol is the lhs of the following rule.                           |
 |                                                                    |
 | null pointer instead of a symbol to terminate the rule.  The next  |
 | symbol is the lhs of the following rule.                           |
 |                                                                    |

-| All guards and actions are copied out to the appropriate files,    |
-| labelled by the rule number they apply to.                         |
+| All actions are copied out, labelled by the rule number they apply |
+| to.                                                                |

 |                                                                    |
 | Bison used to allow some %directives in the rules sections, but    |
 | this is no longer consider appropriate: (i) the documented grammar |
 |                                                                    |
 | Bison used to allow some %directives in the rules sections, but    |
 | this is no longer consider appropriate: (i) the documented grammar |


@@ -1569,15 +1557,6 @@ readgram (void)
            t = lex ();
          }
 
            t = lex ();
          }
 

-       if (t == tok_guard)
-         {
-           if (!semantic_parser)
-             complain (_("%%guard present but %%semantic_parser not specified"));
-
-           parse_guard (crule, rulelength);
-           t = lex ();
-         }
-

        if (t == tok_left_curly)
          {
            /* This case never occurs -wjh */
        if (t == tok_left_curly)
          {
            /* This case never occurs -wjh */


@@ -1663,7 +1642,7 @@ read_additionnal_code (void)
     }
 
   while ((c = getc (finput)) != EOF)
     }
 
   while ((c = getc (finput)) != EOF)

-    obstack_1grow (&el_obstack, c);
+    copy_character (&el_obstack, c);

 
   obstack_1grow (&el_obstack, 0);
   muscle_insert ("epilogue", obstack_finish (&el_obstack));
 
   obstack_1grow (&el_obstack, 0);
   muscle_insert ("epilogue", obstack_finish (&el_obstack));


@@ -1678,15 +1657,38 @@ read_additionnal_code (void)
 static void
 token_translations_init (void)
 {
 static void
 token_translations_init (void)
 {

-  int last_user_token_number = 256;
+  int num_256_available_p = TRUE;

   int i;
 
   int i;
 

-  /* Set the user numbers. */
+  /* Find the highest user token number, and whether 256, the POSIX
+     preferred user token number for the error token, is used.  */
+  max_user_token_number = 0;
+  for (i = 0; i < ntokens; ++i)
+    {
+      symbol_t *this = symbols[i];
+      if (this->user_token_number != USER_NUMBER_UNDEFINED)
+       {
+         if (this->user_token_number > max_user_token_number)
+           max_user_token_number = this->user_token_number;
+         if (this->user_token_number == 256)
+           num_256_available_p = FALSE;
+       }
+    }
+
+  /* If 256 is not used, assign it to error, to follow POSIX.  */
+  if (num_256_available_p
+      && errtoken->user_token_number == USER_NUMBER_UNDEFINED)
+    errtoken->user_token_number = 256;
+
+  /* Set the missing user numbers. */
+  if (max_user_token_number < 256)
+    max_user_token_number = 256;
+

   for (i = 0; i < ntokens; ++i)
     {
       symbol_t *this = symbols[i];
   for (i = 0; i < ntokens; ++i)
     {
       symbol_t *this = symbols[i];

-      if (this->user_token_number == SUNDEF)
-       this->user_token_number = ++last_user_token_number;
+      if (this->user_token_number == USER_NUMBER_UNDEFINED)
+       this->user_token_number = ++max_user_token_number;

       if (this->user_token_number > max_user_token_number)
        max_user_token_number = this->user_token_number;
     }
       if (this->user_token_number > max_user_token_number)
        max_user_token_number = this->user_token_number;
     }


@@ -1698,7 +1700,6 @@ token_translations_init (void)
      inputs.  */
   for (i = 0; i < max_user_token_number + 1; i++)
     token_translations[i] = undeftoken->number;
      inputs.  */
   for (i = 0; i < max_user_token_number + 1; i++)
     token_translations[i] = undeftoken->number;

-

   symbols_do (symbol_translation, NULL);
 }
 
   symbols_do (symbol_translation, NULL);
 }
 


@@ -1757,13 +1758,13 @@ packgram (void)
       rules[ruleno].useful = TRUE;
       rules[ruleno].action = p->action;
       rules[ruleno].action_line = p->action_line;
       rules[ruleno].useful = TRUE;
       rules[ruleno].action = p->action;
       rules[ruleno].action_line = p->action_line;

-      rules[ruleno].guard = p->guard;
-      rules[ruleno].guard_line = p->guard_line;

 
       p = p->next;
       while (p && p->sym)
        {
 
       p = p->next;
       while (p && p->sym)
        {

-         ritem[itemno++] = p->sym->number;
+         /* item_number_t = token_number_t.
+            But the former needs to contain more: negative rule numbers. */
+         ritem[itemno++] = token_number_as_item_number (p->sym->number);

          /* A rule gets by default the precedence and associativity
             of the last token in it.  */
          if (p->sym->class == token_sym)
          /* A rule gets by default the precedence and associativity
             of the last token in it.  */
          if (p->sym->class == token_sym)


@@ -1793,13 +1794,12 @@ packgram (void)
     ritem_print (stderr);
 }
 \f
     ritem_print (stderr);
 }
 \f

-/*-------------------------------------------------------------------.
-| Read in the grammar specification and record it in the format      |
-| described in gram.h.  All guards are copied into the GUARD_OBSTACK |
-| and all actions into ACTION_OBSTACK, in each case forming the body |
-| of a C function (YYGUARD or YYACTION) which contains a switch      |
-| statement to decide which guard or action to execute.              |
-`-------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Read in the grammar specification and record it in the format     |
+| described in gram.h.  All actions are copied into ACTION_OBSTACK, |
+| in each case forming the body of a C function (YYACTION) which    |
+| contains a switch statement to decide which action to execute.    |
+`------------------------------------------------------------------*/

 
 void
 reader (void)
 
 void
 reader (void)


@@ -1822,7 +1822,6 @@ reader (void)
   errtoken = getsym ("error");
   errtoken->class = token_sym;
   errtoken->number = ntokens++;
   errtoken = getsym ("error");
   errtoken->class = token_sym;
   errtoken->number = ntokens++;

-  errtoken->user_token_number = 256;   /* Value specified by POSIX.  */

 
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */
 
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */


@@ -1832,8 +1831,9 @@ reader (void)
 
   /* Initialize the obstacks. */
   obstack_init (&action_obstack);
 
   /* Initialize the obstacks. */
   obstack_init (&action_obstack);

-  obstack_init (&attrs_obstack);

   obstack_init (&output_obstack);
   obstack_init (&output_obstack);

+  obstack_init (&pre_prologue_obstack);
+  obstack_init (&post_prologue_obstack);

 
   finput = xfopen (infile, "r");
 
 
   finput = xfopen (infile, "r");
 


@@ -1853,7 +1853,7 @@ reader (void)
     }
 
   /* Read in the grammar, build grammar in list form.  Write out
     }
 
   /* Read in the grammar, build grammar in list form.  Write out

-     guards and actions.  */
+     actions.  */

   readgram ();
   /* Some C code is given at the end of the grammar file. */
   read_additionnal_code ();
   readgram ();
   /* Some C code is given at the end of the grammar file. */
   read_additionnal_code ();