]> git.saurik.com Git - bison.git/blobdiff - src/reader.c
* src/symtab.c (symbol_user_token_number_set): Don't complain when
[bison.git] / src / reader.c
index 6106037c790e7cf5c2d244ee12ec738d1bb9ae5a..f2bc42e724db4bf926575c3939a92651d3c0a59d 100644 (file)
@@ -51,11 +51,6 @@ typedef struct symbol_list
 int lineno;
 static symbol_list *grammar = NULL;
 static int start_flag = 0;
 int lineno;
 static symbol_list *grammar = NULL;
 static int start_flag = 0;
-static symbol_t *startval = NULL;
-
-/* Nonzero if components of semantic values are used, implying
-   they must be unions.  */
-static int value_components_used;
 
 /* Nonzero if %union has been seen.  */
 static int typed = 0;
 
 /* Nonzero if %union has been seen.  */
 static int typed = 0;
@@ -63,11 +58,6 @@ static int typed = 0;
 /* Incremented for each %left, %right or %nonassoc seen */
 static int lastprec = 0;
 
 /* Incremented for each %left, %right or %nonassoc seen */
 static int lastprec = 0;
 
-symbol_t *errtoken = NULL;
-symbol_t *undeftoken = NULL;
-symbol_t *eoftoken = NULL;
-symbol_t *axiom = NULL;
-
 static symbol_list *
 symbol_list_new (symbol_t *sym)
 {
 static symbol_list *
 symbol_list_new (symbol_t *sym)
 {
@@ -81,169 +71,6 @@ symbol_list_new (symbol_t *sym)
   return res;
 }
 
   return res;
 }
 
-/*------------------------.
-| Operations on symbols.  |
-`------------------------*/
-
-
-/*-----------------------------------------------------------.
-| If THIS is not defined, report an error, and consider it a |
-| nonterminal.                                               |
-`-----------------------------------------------------------*/
-
-static bool
-symbol_check_defined (symbol_t *this)
-{
-  if (this->class == unknown_sym)
-    {
-      complain
-       (_("symbol %s is used, but is not defined as a token and has no rules"),
-        this->tag);
-      this->class = nterm_sym;
-      this->number = nvars++;
-    }
-
-  return TRUE;
-}
-
-
-/*-------------------------------------------------------------------.
-| Assign a symbol number, and write the definition of the token name |
-| into FDEFINES.  Put in SYMBOLS.                                    |
-`-------------------------------------------------------------------*/
-
-static bool
-symbol_make_alias (symbol_t *symbol, char *typename)
-{
-  if (symval->alias)
-    warn (_("symbol `%s' used more than once as a literal string"),
-         symval->tag);
-  else if (symbol->alias)
-    warn (_("symbol `%s' given more than one literal string"),
-         symbol->tag);
-  else
-    {
-      symval->class = token_sym;
-      symval->type_name = typename;
-      symval->user_token_number = symbol->user_token_number;
-      symbol->user_token_number = USER_NUMBER_ALIAS;
-      symval->alias = symbol;
-      symbol->alias = symval;
-      /* symbol and symval combined are only one symbol */
-      nsyms--;
-      ntokens--;
-      assert (ntokens == symbol->number || ntokens == symval->number);
-      symbol->number = symval->number =
-       (symval->number < symbol->number) ? symval->number : symbol->number;
-    }
-
-  return TRUE;
-}
-
-/*---------------------------------------------------------.
-| Check that THIS, and its alias, have same precedence and |
-| associativity.                                           |
-`---------------------------------------------------------*/
-
-static bool
-symbol_check_alias_consistence (symbol_t *this)
-{
-  /* Check only those who _are_ the aliases. */
-  if (this->alias && this->user_token_number == USER_NUMBER_ALIAS)
-    {
-      if (this->prec != this->alias->prec)
-       {
-         if (this->prec != 0 && this->alias->prec != 0)
-           complain (_("conflicting precedences for %s and %s"),
-                     this->tag, this->alias->tag);
-         if (this->prec != 0)
-           this->alias->prec = this->prec;
-         else
-           this->prec = this->alias->prec;
-       }
-
-      if (this->assoc != this->alias->assoc)
-       {
-         if (this->assoc != 0 && this->alias->assoc != 0)
-           complain (_("conflicting assoc values for %s and %s"),
-                     this->tag, this->alias->tag);
-         if (this->assoc != 0)
-           this->alias->assoc = this->assoc;
-         else
-           this->assoc = this->alias->assoc;
-       }
-    }
-  return TRUE;
-}
-
-
-/*-------------------------------------------------------------------.
-| Assign a symbol number, and write the definition of the token name |
-| into FDEFINES.  Put in SYMBOLS.                                    |
-`-------------------------------------------------------------------*/
-
-static bool
-symbol_pack (symbol_t *this)
-{
-  if (this->class == nterm_sym)
-    {
-      this->number += ntokens;
-    }
-  else if (this->alias)
-    {
-      /* 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 == NUMBER_UNDEFINED)
-       {
-         if (this == eoftoken || this->alias == eoftoken)
-           this->number = this->alias->number = 0;
-         else
-           {
-             assert (this->alias->number != NUMBER_UNDEFINED);
-             this->number = this->alias->number;
-           }
-       }
-      /* Do not do processing below for USER_NUMBER_ALIASs.  */
-      if (this->user_token_number == USER_NUMBER_ALIAS)
-       return TRUE;
-    }
-  else /* this->class == token_sym */
-    {
-      assert (this->number != NUMBER_UNDEFINED);
-    }
-
-  symbols[this->number] = this;
-  return TRUE;
-}
-
-
-
-
-/*--------------------------------------------------.
-| Put THIS in TOKEN_TRANSLATIONS if it is a token.  |
-`--------------------------------------------------*/
-
-static bool
-symbol_translation (symbol_t *this)
-{
-  /* Non-terminal? */
-  if (this->class == token_sym
-      && this->user_token_number != USER_NUMBER_ALIAS)
-    {
-      /* A token which translation has already been set? */
-      if (token_translations[this->user_token_number] != undeftoken->number)
-       complain (_("tokens %s and %s both assigned number %d"),
-                 symbols[token_translations[this->user_token_number]]->tag,
-                 this->tag, this->user_token_number);
-
-      token_translations[this->user_token_number] = this->number;
-    }
-
-  return TRUE;
-}
-\f
-
 /*===================\
 | Low level lexing.  |
 \===================*/
 /*===================\
 | Low level lexing.  |
 \===================*/
@@ -547,7 +374,6 @@ copy_dollar (FILE *fin, struct obstack *oout,
     {
       read_type_name (fin);
       type_name = token_buffer;
     {
       read_type_name (fin);
       type_name = token_buffer;
-      value_components_used = 1;
       c = getc (fin);
     }
 
       c = getc (fin);
     }
 
@@ -657,14 +483,12 @@ copy_definition (struct obstack *oout)
 }
 
 
 }
 
 
-/*-------------------------------------------------------------------.
-| Parse what comes after %token or %nterm.  For %token, WHAT_IS is   |
-| token_sym and WHAT_IS_NOT is nterm_sym.  For %nterm, the arguments |
-| are reversed.                                                      |
-`-------------------------------------------------------------------*/
+/*------------------------------------------.
+| Parse what comes after %token or %nterm.  |
+`------------------------------------------*/
 
 static void
 
 static void
-parse_token_decl (symbol_class what_is, symbol_class what_is_not)
+parse_token_decl (symbol_class class)
 {
   token_t token = tok_undef;
   char *typename = NULL;
 {
   token_t token = tok_undef;
   char *typename = NULL;
@@ -686,61 +510,40 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
        fatal (_("Premature EOF after %s"), token_buffer);
 
       token = lex ();
        fatal (_("Premature EOF after %s"), token_buffer);
 
       token = lex ();
-      if (token == tok_comma)
+      switch (token)
        {
        {
+       case tok_comma:
          symbol = NULL;
          symbol = NULL;
-         continue;
-       }
-      if (token == tok_typename)
-       {
+         break;
+
+       case tok_typename:
          typename = xstrdup (token_buffer);
          typename = xstrdup (token_buffer);
-         value_components_used = 1;
          symbol = NULL;
          symbol = NULL;
-       }
-      else if (token == tok_identifier && *symval->tag == '\"' && symbol)
-       {
-         symbol_make_alias (symbol, typename);
-         symbol = NULL;
-       }
-      else if (token == tok_identifier)
-       {
-         int oldclass = symval->class;
-         symbol = symval;
-
-         if (symbol->class == what_is_not)
-           complain (_("symbol %s redefined"), symbol->tag);
-         symbol->class = what_is;
-         if (what_is == nterm_sym && oldclass != nterm_sym)
-           symbol->number = nvars++;
-         if (what_is == token_sym && symbol->number == NUMBER_UNDEFINED)
-           symbol->number = ntokens++;
-
-         if (typename)
+         break;
+
+       case tok_identifier:
+         if (*symval->tag == '\"' && symbol)
            {
            {
-             if (symbol->type_name == NULL)
-               symbol->type_name = typename;
-             else if (strcmp (typename, symbol->type_name) != 0)
-               complain (_("type redeclaration for %s"), symbol->tag);
+             symbol_make_alias (symbol, symval, typename);
+             symbol = NULL;
            }
            }
-       }
-      else if (symbol && token == tok_number)
-       {
-         symbol->user_token_number = numval;
-         /* User defined EOF token? */
-         if (numval == 0)
+         else
            {
            {
-             eoftoken = symbol;
-             eoftoken->number = 0;
-             /* It is always mapped to 0, so it was already counted in
-                NTOKENS.  */
-             --ntokens;
+             symbol = symval;
+             symbol_class_set (symbol, class);
+             if (typename)
+               symbol_type_set (symbol, typename);
            }
            }
-       }
-      else
-       {
+         break;
+
+       case tok_number:
+         symbol_user_token_number_set (symbol, numval);
+         break;
+
+       default:
          complain (_("`%s' is invalid in %s"),
                    token_buffer,
          complain (_("`%s' is invalid in %s"),
                    token_buffer,
-                   (what_is == token_sym) ? "%token" : "%nterm");
+                   (class == token_sym) ? "%token" : "%nterm");
          skip_to_char ('%');
        }
     }
          skip_to_char ('%');
        }
     }
@@ -762,7 +565,7 @@ parse_start_decl (void)
   else
     {
       start_flag = 1;
   else
     {
       start_flag = 1;
-      startval = symval;
+      startsymbol = symval;
     }
 }
 
     }
 }
 
@@ -799,17 +602,12 @@ parse_type_decl (void)
 
       switch (t)
        {
 
       switch (t)
        {
-
        case tok_comma:
        case tok_semicolon:
          break;
 
        case tok_identifier:
        case tok_comma:
        case tok_semicolon:
          break;
 
        case tok_identifier:
-         if (symval->type_name == NULL)
-           symval->type_name = name;
-         else if (strcmp (name, symval->type_name) != 0)
-           complain (_("type redeclaration for %s"), symval->tag);
-
+         symbol_type_set (symval, name);
          break;
 
        default:
          break;
 
        default:
@@ -858,30 +656,16 @@ parse_assoc_decl (associativity assoc)
          break;
 
        case tok_identifier:
          break;
 
        case tok_identifier:
-         if (symval->prec != 0)
-           complain (_("redefining precedence of %s"), symval->tag);
-         symval->prec = lastprec;
-         symval->assoc = assoc;
-         if (symval->class == nterm_sym)
-           complain (_("symbol %s redefined"), symval->tag);
-         if (symval->number == NUMBER_UNDEFINED)
-           {
-             symval->number = ntokens++;
-             symval->class = token_sym;
-           }
+         symbol_class_set (symval, token_sym);
+         symbol_precedence_set (symval, lastprec, assoc);
          if (name)
          if (name)
-           {                   /* record the type, if one is specified */
-             if (symval->type_name == NULL)
-               symval->type_name = name;
-             else if (strcmp (name, symval->type_name) != 0)
-               complain (_("type redeclaration for %s"), symval->tag);
-           }
+           symbol_type_set (symval, name);
          break;
 
        case tok_number:
          if (prev == tok_identifier)
            {
          break;
 
        case tok_number:
          if (prev == tok_identifier)
            {
-             symval->user_token_number = numval;
+             symbol_user_token_number_set (symval, numval);
            }
          else
            {
            }
          else
            {
@@ -988,84 +772,6 @@ parse_expect_decl (void)
 }
 
 
 }
 
 
-/*-------------------------------------------------------------------.
-| Parse what comes after %thong.  the full syntax is                 |
-|                                                                    |
-|                %thong <type> token number literal                  |
-|                                                                    |
-| the <type> or number may be omitted.  The number specifies the     |
-| user_token_number.                                                 |
-|                                                                    |
-| 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              |
-| 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  |
-| is output to yytname                                               |
-`-------------------------------------------------------------------*/
-
-static void
-parse_thong_decl (void)
-{
-  token_t token;
-  symbol_t *symbol;
-  char *typename = 0;
-  int usrtoknum = USER_NUMBER_UNDEFINED;
-
-  token = lex ();              /* fetch typename or first token */
-  if (token == tok_typename)
-    {
-      typename = xstrdup (token_buffer);
-      value_components_used = 1;
-      token = lex ();          /* fetch first token */
-    }
-
-  /* process first token */
-
-  if (token != tok_identifier)
-    {
-      complain (_("unrecognized item %s, expected an identifier"),
-               token_buffer);
-      skip_to_char ('%');
-      return;
-    }
-  symval->class = token_sym;
-  symval->type_name = typename;
-  symval->user_token_number = USER_NUMBER_ALIAS;
-  symbol = symval;
-
-  token = lex ();              /* get number or literal string */
-
-  if (token == tok_number)
-    {
-      usrtoknum = numval;
-      token = lex ();          /* okay, did number, now get literal */
-    }
-
-  /* process literal string token */
-
-  if (token != tok_identifier || *symval->tag != '\"')
-    {
-      complain (_("expected string constant instead of %s"), token_buffer);
-      skip_to_char ('%');
-      return;
-    }
-  symval->class = token_sym;
-  symval->type_name = typename;
-  symval->user_token_number = usrtoknum;
-
-  symval->alias = symbol;
-  symbol->alias = symval;
-
-  /* symbol and symval combined are only one symbol.  */
-  nsyms--;
-}
-
-
 static void
 parse_muscle_decl (void)
 {
 static void
 parse_muscle_decl (void)
 {
@@ -1188,11 +894,11 @@ read_declarations (void)
              break;
 
            case tok_token:
              break;
 
            case tok_token:
-             parse_token_decl (token_sym, nterm_sym);
+             parse_token_decl (token_sym);
              break;
 
            case tok_nterm:
              break;
 
            case tok_nterm:
-             parse_token_decl (nterm_sym, token_sym);
+             parse_token_decl (nterm_sym);
              break;
 
            case tok_type:
              break;
 
            case tok_type:
@@ -1211,10 +917,6 @@ read_declarations (void)
              parse_expect_decl ();
              break;
 
              parse_expect_decl ();
              break;
 
-           case tok_thong:
-             parse_thong_decl ();
-             break;
-
            case tok_left:
              parse_assoc_decl (left_assoc);
              break;
            case tok_left:
              parse_assoc_decl (left_assoc);
              break;
@@ -1286,12 +988,12 @@ parse_action (symbol_list *rule, int rule_length)
        switch (c)
          {
          case '\n':
        switch (c)
          {
          case '\n':
-           obstack_1grow (&action_obstack, c);
+           copy_character (&action_obstack, c);
            ++lineno;
            break;
 
          case '{':
            ++lineno;
            break;
 
          case '{':
-           obstack_1grow (&action_obstack, c);
+           copy_character (&action_obstack, c);
            ++count;
            break;
 
            ++count;
            break;
 
@@ -1316,12 +1018,12 @@ parse_action (symbol_list *rule, int rule_length)
            fatal (_("unmatched %s"), "`{'");
 
          default:
            fatal (_("unmatched %s"), "`{'");
 
          default:
-           obstack_1grow (&action_obstack, c);
+           copy_character (&action_obstack, c);
          }
 
       /* Above loop exits when C is '}'.  */
       if (--count)
          }
 
       /* Above loop exits when C is '}'.  */
       if (--count)
-       obstack_1grow (&action_obstack, c);
+       copy_character (&action_obstack, c);
     }
 
   obstack_1grow (&action_obstack, '\0');
     }
 
   obstack_1grow (&action_obstack, '\0');
@@ -1401,7 +1103,7 @@ readgram (void)
 
            if (!start_flag)
              {
 
            if (!start_flag)
              {
-               startval = lhs;
+               startsymbol = lhs;
                start_flag = 1;
              }
 
                start_flag = 1;
              }
 
@@ -1599,7 +1301,7 @@ readgram (void)
     fatal (_("no rules in the input grammar"));
 
   /* Report any undefined symbols and consider them nonterminals.  */
     fatal (_("no rules in the input grammar"));
 
   /* Report any undefined symbols and consider them nonterminals.  */
-  symbols_do (symbol_check_defined, NULL);
+  symbols_check_defined ();
 
   /* Insert the initial rule, which line is that of the first rule
      (not that of the start symbol):
 
   /* Insert the initial rule, which line is that of the first rule
      (not that of the start symbol):
@@ -1607,14 +1309,13 @@ readgram (void)
      axiom: %start EOF.  */
   p = symbol_list_new (axiom);
   p->line = grammar->line;
      axiom: %start EOF.  */
   p = symbol_list_new (axiom);
   p->line = grammar->line;
-  p->next = symbol_list_new (startval);
+  p->next = symbol_list_new (startsymbol);
   p->next->next = symbol_list_new (eoftoken);
   p->next->next->next = symbol_list_new (NULL);
   p->next->next->next->next = grammar;
   nrules += 1;
   nritems += 3;
   grammar = p;
   p->next->next = symbol_list_new (eoftoken);
   p->next->next->next = symbol_list_new (NULL);
   p->next->next->next->next = grammar;
   nrules += 1;
   nritems += 3;
   grammar = p;
-  startval = axiom;
 
   if (nsyms > SHRT_MAX)
     fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
 
   if (nsyms > SHRT_MAX)
     fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
@@ -1649,85 +1350,6 @@ read_additionnal_code (void)
 }
 
 \f
 }
 
 \f
-/*------------------------------------------------------------------.
-| Set TOKEN_TRANSLATIONS.  Check that no two symbols share the same |
-| number.                                                           |
-`------------------------------------------------------------------*/
-
-static void
-token_translations_init (void)
-{
-  int num_256_available_p = TRUE;
-  int i;
-
-  /* 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];
-      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;
-    }
-
-  token_translations = XCALLOC (token_number_t, max_user_token_number + 1);
-
-  /* Initialize all entries for literal tokens to 2, the internal
-     token number for $undefined., which represents all invalid
-     inputs.  */
-  for (i = 0; i < max_user_token_number + 1; i++)
-    token_translations[i] = undeftoken->number;
-  symbols_do (symbol_translation, NULL);
-}
-
-
-/*----------------------------------------------------------------.
-| Assign symbol numbers, and write definition of token names into |
-| FDEFINES.  Set up vectors SYMBOL_TABLE, TAGS of symbols.        |
-`----------------------------------------------------------------*/
-
-static void
-packsymbols (void)
-{
-  symbols = XCALLOC (symbol_t *, nsyms);
-
-  symbols_do (symbol_check_alias_consistence, NULL);
-  symbols_do (symbol_pack, NULL);
-
-  token_translations_init ();
-
-  if (startval->class == unknown_sym)
-    fatal (_("the start symbol %s is undefined"), startval->tag);
-  else if (startval->class == token_sym)
-    fatal (_("the start symbol %s is a token"), startval->tag);
-
-  start_symbol = startval->number;
-}
-
-
 /*---------------------------------------------------------------.
 | Convert the rules into the representation using RRHS, RLHS and |
 | RITEM.                                                         |
 /*---------------------------------------------------------------.
 | Convert the rules into the representation using RRHS, RLHS and |
 | RITEM.                                                         |
@@ -1736,11 +1358,11 @@ packsymbols (void)
 static void
 packgram (void)
 {
 static void
 packgram (void)
 {
-  int itemno;
+  unsigned int itemno;
   int ruleno;
   symbol_list *p;
 
   int ruleno;
   symbol_list *p;
 
-  ritem = XCALLOC (item_number_t, nritems + 1);
+  ritem = XCALLOC (item_number_t, nritems);
   rules = XCALLOC (rule_t, nrules) - 1;
 
   itemno = 0;
   rules = XCALLOC (rule_t, nrules) - 1;
 
   itemno = 0;
@@ -1762,9 +1384,9 @@ packgram (void)
       p = p->next;
       while (p && p->sym)
        {
       p = p->next;
       while (p && p->sym)
        {
-         /* item_number_t = token_number_t.
+         /* item_number_t = symbol_number_t.
             But the former needs to contain more: negative rule numbers. */
             But the former needs to contain more: negative rule numbers. */
-         ritem[itemno++] = token_number_as_item_number (p->sym->number);
+         ritem[itemno++] = symbol_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)
@@ -1787,7 +1409,6 @@ packgram (void)
        p = p->next;
     }
 
        p = p->next;
     }
 
-  ritem[itemno] = 0;
   assert (itemno == nritems);
 
   if (trace_flag)
   assert (itemno == nritems);
 
   if (trace_flag)
@@ -1863,7 +1484,7 @@ reader (void)
 
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
 
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
-  packsymbols ();
+  symbols_pack ();
 
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
 
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();