]> git.saurik.com Git - bison.git/blobdiff - src/reader.c
When reducing initial empty rules, Bison parser read an initial
[bison.git] / src / reader.c
index 822b9fe48d8aef46994b73bf73ba1090a8ecdb6a..0adee6fc8c5c301632364e0485ea05186f43e7f6 100644 (file)
@@ -1,5 +1,6 @@
-/* Input parser for bison
-   Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002
+/* Input parser for Bison
+
+   Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002, 2003
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-
 #include "system.h"
-#include "quotearg.h"
-#include "quote.h"
-#include "getargs.h"
+
+#include <quotearg.h>
+
+#include "complain.h"
+#include "conflicts.h"
 #include "files.h"
-#include "symtab.h"
-#include "options.h"
+#include "getargs.h"
 #include "gram.h"
-#include "complain.h"
+#include "muscle_tab.h"
 #include "output.h"
 #include "reader.h"
-#include "conflicts.h"
-#include "muscle_tab.h"
+#include "symlist.h"
+#include "symtab.h"
 
-int lineno;
 static symbol_list *grammar = NULL;
-static int start_flag = 0;
-
-/* Nonzero if %union has been seen.  */
-int typed = 0;
-
-static symbol_list *
-symbol_list_new (symbol_t *sym)
-{
-  symbol_list *res = XMALLOC (symbol_list, 1);
-  res->next = NULL;
-  res->sym = sym;
-  res->line = lineno;
-  res->action = NULL;
-  res->action_line = 0;
-  res->ruleprec = NULL;
-  return res;
-}
+static bool start_flag = false;
+merger_list *merge_functions;
 
+/* Has %union been seen?  */
+bool typed = false;
 \f
-/*--------------------------------------------------------------.
-| Get the data type (alternative in the union) of the value for |
-| symbol N in rule RULE.                                        |
-`--------------------------------------------------------------*/
-
-char *
-get_type_name (int n, symbol_list *rule)
-{
-  int i;
-  symbol_list *rp;
-
-  if (n < 0)
-    {
-      complain (_("invalid $ value"));
-      return NULL;
-    }
-
-  rp = rule;
-  i = 0;
-
-  while (i < n)
-    {
-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-       {
-         complain (_("invalid $ value"));
-         return NULL;
-       }
-      ++i;
-    }
-
-  return rp->sym->type_name;
-}
-
-
 /*-----------------------.
 | Set the start symbol.  |
 `-----------------------*/
 
 void
-grammar_start_symbol_set (symbol_t *s)
+grammar_start_symbol_set (symbol *sym, location loc)
 {
   if (start_flag)
-    complain (_("multiple %s declarations"), "%start");
+    complain_at (loc, _("multiple %s declarations"), "%start");
   else
     {
-      start_flag = 1;
-      startsymbol = s;
+      start_flag = true;
+      startsymbol = sym;
+      startsymbol_location = loc;
     }
 }
 
@@ -113,67 +66,76 @@ grammar_start_symbol_set (symbol_t *s)
 `----------------------------------------------------------------*/
 
 void
-prologue_augment (const char *prologue, int location)
+prologue_augment (const char *prologue, location loc)
 {
   struct obstack *oout =
     !typed ? &pre_prologue_obstack : &post_prologue_obstack;
 
-  if (!no_lines_flag)
-    {
-      obstack_fgrow2 (oout, muscle_find ("linef"),
-                     location, quotearg_style (c_quoting_style,
-                                               muscle_find ("filename")));
-    }
+  obstack_fgrow1 (oout, "]b4_syncline([[%d]], [[", loc.start.line);
+  MUSCLE_OBSTACK_SGROW (oout,
+                       quotearg_style (c_quoting_style, loc.start.file));
+  obstack_sgrow (oout, "]])[\n");
   obstack_sgrow (oout, prologue);
 }
 
+\f
 
+/*-------------------------------------------------------------------.
+| Return the merger index for a merging function named NAME, whose   |
+| arguments have type TYPE.  Records the function, if new, in        |
+| MERGER_LIST.                                                      |
+`-------------------------------------------------------------------*/
 
+static int
+get_merge_function (uniqstr name, uniqstr type, location loc)
+{
+  merger_list *syms;
+  merger_list head;
+  int n;
 
-/*----------------------.
-| Handle the epilogue.  |
-`----------------------*/
+  if (! glr_parser)
+    return 0;
 
-void
-epilogue_set (const char *epilogue, int location)
-{
-  struct obstack el_obstack;
-  obstack_init (&el_obstack);
+  if (type == NULL)
+    type = uniqstr_new ("");
 
-  if (!no_lines_flag)
+  head.next = merge_functions;
+  for (syms = &head, n = 1; syms->next != NULL; syms = syms->next, n += 1)
+    if (UNIQSTR_EQ (name, syms->next->name))
+      break;
+  if (syms->next == NULL)
     {
-      obstack_fgrow2 (&el_obstack, muscle_find ("linef"),
-                     location, quotearg_style (c_quoting_style,
-                                               muscle_find ("filename")));
+      MALLOC (syms->next, 1);
+      syms->next->name = uniqstr_new (name);
+      syms->next->type = uniqstr_new (type);
+      syms->next->next = NULL;
+      merge_functions = head.next;
     }
-  obstack_sgrow (&el_obstack, epilogue);
-  obstack_1grow (&el_obstack, 0);
-  muscle_insert ("epilogue", obstack_finish (&el_obstack));
+  else if (!UNIQSTR_EQ (type, syms->next->type))
+    warn_at (loc, _("result type clash on merge function %s: <%s> != <%s>"),
+            name, type, syms->next->type);
+  return n;
 }
 
+/*--------------------------------------.
+| Free all merge-function definitions. |
+`--------------------------------------*/
 
-\f
-
-/*-------------------------------------------------------------------.
-| Generate a dummy symbol, a nonterminal, whose name cannot conflict |
-| with the user's names.                                             |
-`-------------------------------------------------------------------*/
-
-static symbol_t *
-gensym (void)
+void
+free_merger_functions (void)
 {
-  /* Incremented for each generated symbol */
-  static int gensym_count = 0;
-  static char buf[256];
-
-  symbol_t *sym;
-
-  sprintf (buf, "@%d", ++gensym_count);
-  sym = getsym (buf);
-  sym->class = nterm_sym;
-  sym->number = nvars++;
-  return sym;
+  merger_list *L0;
+  if (! glr_parser)
+    return;
+  L0 = merge_functions;
+  while (L0 != NULL)
+    {
+      merger_list *L1 = L0->next;
+      free (L0);
+      L0 = L1;
+    }
 }
+
 \f
 /*-------------------------------------------------------------------.
 | Parse the input grammar into a one symbol_list structure.  Each    |
@@ -196,11 +158,11 @@ gensym (void)
 /* The (currently) last symbol of GRAMMAR. */
 symbol_list *grammar_end = NULL;
 
-/* Append S to the GRAMMAR. */
+/* Append SYM to the grammar.  */
 void
-grammar_symbol_append (symbol_t *s)
+grammar_symbol_append (symbol *sym, location loc)
 {
-  symbol_list *p = symbol_list_new (s);
+  symbol_list *p = symbol_list_new (sym, loc);
 
   if (grammar_end)
     grammar_end->next = p;
@@ -210,29 +172,33 @@ grammar_symbol_append (symbol_t *s)
   grammar_end = p;
 }
 
-/* The rule currently being defined, and the previous rule.  Point to
-   the first symbol of each list: their lhs.  */
+/* The rule currently being defined, and the previous rule.
+   CURRENT_RULE points to the first LHS of the current rule, while
+   PREVIOUS_RULE_END points to the *end* of the previous rule (NULL).  */
 symbol_list *current_rule = NULL;
-symbol_list *previous_rule = NULL;
+symbol_list *previous_rule_end = NULL;
 
 
-/* Create a new rule for LHS in to the GRAMMAR. */
+/*----------------------------------------------.
+| Create a new rule for LHS in to the GRAMMAR.  |
+`----------------------------------------------*/
 
 void
-grammar_rule_begin (symbol_t *lhs)
+grammar_rule_begin (symbol *lhs, location loc)
 {
   if (!start_flag)
     {
       startsymbol = lhs;
-      start_flag = 1;
+      startsymbol_location = loc;
+      start_flag = true;
     }
 
   /* Start a new rule and record its lhs.  */
   ++nrules;
   ++nritems;
 
-  previous_rule = grammar_end;
-  grammar_symbol_append (lhs);
+  previous_rule_end = grammar_end;
+  grammar_symbol_append (lhs, loc);
   current_rule = grammar_end;
 
   /* Mark the rule's lhs as a nonterminal if not already so.  */
@@ -244,7 +210,7 @@ grammar_rule_begin (symbol_t *lhs)
       ++nvars;
     }
   else if (lhs->class == token_sym)
-    complain (_("rule given for %s, which is a token"), lhs->tag);
+    complain_at (loc, _("rule given for %s, which is a token"), lhs->tag);
 }
 
 /* Check that the last rule (CURRENT_RULE) is properly defined.  For
@@ -253,48 +219,56 @@ grammar_rule_begin (symbol_t *lhs)
 static void
 grammar_current_rule_check (void)
 {
-  symbol_t *lhs = current_rule->sym;
-  symbol_t *first_rhs = current_rule->next->sym;
+  symbol *lhs = current_rule->sym;
+  char const *lhs_type = lhs->type_name;
+  symbol *first_rhs = current_rule->next->sym;
 
   /* If there is an action, then there is nothing we can do: the user
-     is allowed to shoot in her foot.  */
+     is allowed to shoot herself in the foot.  */
   if (current_rule->action)
     return;
 
-  /* If $$ is being set in default way, report if any type mismatch.
-     */
+  /* Don't worry about the default action if $$ is untyped, since $$'s
+     value can't be used.  */
+  if (! lhs_type)
+    return;
+
+  /* If $$ is being set in default way, report if any type mismatch.  */
   if (first_rhs)
     {
-      const char *lhs_type = lhs->type_name       ? lhs->type_name       : "";
       const char *rhs_type = first_rhs->type_name ? first_rhs->type_name : "";
-      if (strcmp (lhs_type, rhs_type))
-       complain (_("type clash (`%s' `%s') on default action"),
-                 lhs_type, rhs_type);
+      if (!UNIQSTR_EQ (lhs_type, rhs_type))
+       warn_at (current_rule->location,
+                _("type clash on default action: <%s> != <%s>"),
+                lhs_type, rhs_type);
     }
   /* Warn if there is no default for $$ but we need one.  */
   else
-    {
-      if (lhs->type_name)
-       complain (_("empty rule for typed nonterminal, and no action"));
-    }
+    warn_at (current_rule->location,
+            _("empty rule for typed nonterminal, and no action"));
 }
 
 
-/* End the currently being grown rule. */
+/*-------------------------------------.
+| End the currently being grown rule.  |
+`-------------------------------------*/
 
 void
-grammar_rule_end (void)
+grammar_rule_end (location loc)
 {
   /* Put an empty link in the list to mark the end of this rule  */
-  grammar_symbol_append (NULL);
+  grammar_symbol_append (NULL, grammar_end->location);
+  current_rule->location = loc;
   grammar_current_rule_check ();
 }
 
 
-/* The previous action turns out the be a mid-rule action.  Attach it
-   to the current rule, i.e., create a dummy symbol, attach it this
-   mid-rule action, and append this dummy nonterminal to the current
-   rule.  */
+/*-------------------------------------------------------------------.
+| The previous action turns out the be a mid-rule action.  Attach it |
+| to the current rule, i.e., create a dummy symbol, attach it this   |
+| mid-rule action, and append this dummy nonterminal to the current  |
+| rule.                                                              |
+`-------------------------------------------------------------------*/
 
 void
 grammar_midrule_action (void)
@@ -303,70 +277,98 @@ grammar_midrule_action (void)
      give the new rule this number by inserting the new rule before
      it.  */
 
-  /* Make a dummy nonterminal, a gensym.  */
-  symbol_t *sdummy = gensym ();
-  symbol_list *midrule_action = symbol_list_new (sdummy);
+  /* Make a DUMMY nonterminal, whose location is that of the midrule
+     action.  Create the MIDRULE.  */
+  location dummy_location = current_rule->action_location;
+  symbol *dummy = dummy_symbol_get (dummy_location);
+  symbol_list *midrule = symbol_list_new (dummy, dummy_location);
 
   /* Make a new rule, whose body is empty, before the current one, so
      that the action just read can belong to it.  */
   ++nrules;
   ++nritems;
-  /* Attach its lineno to that of the host rule.  */
-  midrule_action->line = current_rule->line;
-  /* Move the action from the host rule to this one.  */
-  midrule_action->action = current_rule->action;
-  midrule_action->action_line = current_rule->action_line;
+  /* Attach its location and actions to that of the DUMMY.  */
+  midrule->location = dummy_location;
+  midrule->action = current_rule->action;
+  midrule->action_location = dummy_location;
   current_rule->action = NULL;
 
-  if (previous_rule)
-    previous_rule->next = midrule_action;
+  if (previous_rule_end)
+    previous_rule_end->next = midrule;
   else
-    grammar = midrule_action;
+    grammar = midrule;
 
-  /* End of the rule. */
-  previous_rule = symbol_list_new (NULL);
-  previous_rule->next = current_rule;
+  /* End the dummy's rule.  */
+  previous_rule_end = symbol_list_new (NULL, dummy_location);
+  previous_rule_end->next = current_rule;
 
-  midrule_action->next = previous_rule;
+  midrule->next = previous_rule_end;
 
-  /* Insert the dummy generated by that rule into this rule.  */
-  ++nritems;
-  grammar_symbol_append (sdummy);
+  /* Insert the dummy nonterminal replacing the midrule action into
+     the current rule.  */
+  grammar_current_rule_symbol_append (dummy, dummy_location);
 }
 
 /* Set the precedence symbol of the current rule to PRECSYM. */
 
 void
-grammar_current_rule_prec_set (symbol_t *precsym)
+grammar_current_rule_prec_set (symbol *precsym, location loc)
 {
   if (current_rule->ruleprec)
-    complain (_("two @prec's in a row"));
+    complain_at (loc, _("only one %s allowed per rule"), "%prec");
   current_rule->ruleprec = precsym;
 }
 
-/* Attach a SYMBOL to the current rule.  If needed, move the previous
+/* Attach dynamic precedence DPREC to the current rule. */
+
+void
+grammar_current_rule_dprec_set (int dprec, location loc)
+{
+  if (! glr_parser)
+    warn_at (loc, _("%s affects only GLR parsers"), "%dprec");
+  if (dprec <= 0)
+    complain_at (loc, _("%s must be followed by positive number"), "%dprec");
+  else if (current_rule->dprec != 0)
+    complain_at (loc, _("only one %s allowed per rule"), "%dprec");
+  current_rule->dprec = dprec;
+}
+
+/* Attach a merge function NAME with argument type TYPE to current
+   rule. */
+
+void
+grammar_current_rule_merge_set (uniqstr name, location loc)
+{
+  if (! glr_parser)
+    warn_at (loc, _("%s affects only GLR parsers"), "%merge");
+  if (current_rule->merger != 0)
+    complain_at (loc, _("only one %s allowed per rule"), "%merge");
+  current_rule->merger =
+    get_merge_function (name, current_rule->sym->type_name, loc);
+}
+
+/* Attach SYM to the current rule.  If needed, move the previous
    action as a mid-rule action.  */
 
 void
-grammar_current_rule_symbol_append (symbol_t *symbol)
+grammar_current_rule_symbol_append (symbol *sym, location loc)
 {
   if (current_rule->action)
     grammar_midrule_action ();
   ++nritems;
-  grammar_symbol_append (symbol);
+  grammar_symbol_append (sym, loc);
 }
 
-
 /* Attach an ACTION to the current rule.  If needed, move the previous
    action as a mid-rule action.  */
 
 void
-grammar_current_rule_action_append (const char *action, int action_line)
+grammar_current_rule_action_append (const char *action, location loc)
 {
   if (current_rule->action)
     grammar_midrule_action ();
   current_rule->action = action;
-  current_rule->action_line = action_line;
+  current_rule->action_location = loc;
 }
 
 \f
@@ -378,33 +380,31 @@ grammar_current_rule_action_append (const char *action, int action_line)
 static void
 packgram (void)
 {
-  unsigned int itemno;
-  int ruleno;
-  symbol_list *p;
+  unsigned int itemno = 0;
+  rule_number ruleno = 0;
+  symbol_list *p = grammar;
 
-  ritem = XCALLOC (item_number_t, nritems);
-  rules = XCALLOC (rule_t, nrules) - 1;
+  CALLOC (ritem, nritems);
+  CALLOC (rules, nrules);
 
-  itemno = 0;
-  ruleno = 1;
-
-  p = grammar;
   while (p)
     {
-      symbol_t *ruleprec = p->ruleprec;
+      symbol *ruleprec = p->ruleprec;
       rules[ruleno].user_number = ruleno;
       rules[ruleno].number = ruleno;
       rules[ruleno].lhs = p->sym;
       rules[ruleno].rhs = ritem + itemno;
-      rules[ruleno].line = p->line;
-      rules[ruleno].useful = TRUE;
+      rules[ruleno].location = p->location;
+      rules[ruleno].useful = true;
       rules[ruleno].action = p->action;
-      rules[ruleno].action_line = p->action_line;
+      rules[ruleno].action_location = p->action_location;
+      rules[ruleno].dprec = p->dprec;
+      rules[ruleno].merger = p->merger;
 
       p = p->next;
       while (p && p->sym)
        {
-         /* item_number_t = symbol_number_t.
+         /* item_number = symbol_number.
             But the former needs to contain more: negative rule numbers. */
          ritem[itemno++] = symbol_number_as_item_number (p->sym->number);
          /* A rule gets by default the precedence and associativity
@@ -422,16 +422,17 @@ packgram (void)
          rules[ruleno].precsym = ruleprec;
          rules[ruleno].prec = ruleprec;
        }
-      ritem[itemno++] = -ruleno;
+      ritem[itemno++] = rule_number_as_item_number (ruleno);
       ++ruleno;
 
       if (p)
        p = p->next;
     }
 
-  assert (itemno == nritems);
+  if (itemno != nritems)
+    abort ();
 
-  if (trace_flag)
+  if (trace_flag & trace_sets)
     ritem_print (stderr);
 }
 \f
@@ -445,44 +446,41 @@ packgram (void)
 void
 reader (void)
 {
-  gram_control_t gram_control;
-  lineno = 1;
-
-  /* Initialize the muscle obstack.  */
-  obstack_init (&muscle_obstack);
-
   /* Initialize the symbol table.  */
   symbols_new ();
 
-  /* Construct the axiom symbol. */
-  axiom = getsym ("$axiom");
-  axiom->class = nterm_sym;
-  axiom->number = nvars++;
+  /* Construct the accept symbol. */
+  accept = symbol_get ("$accept", empty_location);
+  accept->class = nterm_sym;
+  accept->number = nvars++;
 
   /* Construct the error token */
-  errtoken = getsym ("error");
+  errtoken = symbol_get ("error", empty_location);
   errtoken->class = token_sym;
   errtoken->number = ntokens++;
 
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */
-  undeftoken = getsym ("$undefined.");
+  undeftoken = symbol_get ("$undefined", empty_location);
   undeftoken->class = token_sym;
   undeftoken->number = ntokens++;
 
   /* Initialize the obstacks. */
-  obstack_init (&action_obstack);
-  obstack_init (&output_obstack);
   obstack_init (&pre_prologue_obstack);
   obstack_init (&post_prologue_obstack);
 
-  finput = xfopen (infile, "r");
+  finput = xfopen (grammar_file, "r");
   gram_in = finput;
 
-  gram_debug = !!getenv ("parse");
-  gram__flex_debug = !!getenv ("scan");
+  gram__flex_debug = trace_flag & trace_scan;
+  gram_debug = trace_flag & trace_parse;
   scanner_initialize ();
-  gram_parse (&gram_control);
+  gram_parse ();
+
+  /* If something went wrong during the parsing, don't try to
+     continue.  */
+  if (complaint_issued)
+    return;
 
   /* Grammar has been read.  Do some checking */
   if (nrules == 0)
@@ -491,37 +489,34 @@ reader (void)
   /* Report any undefined symbols and consider them nonterminals.  */
   symbols_check_defined ();
 
-  /* If the user did not define her EOFTOKEN, do it now. */
-  if (!eoftoken)
+  /* If the user did not define her ENDTOKEN, do it now. */
+  if (!endtoken)
     {
-      eoftoken = getsym ("$");
-      eoftoken->class = token_sym;
-      eoftoken->number = 0;
+      endtoken = symbol_get ("$end", empty_location);
+      endtoken->class = token_sym;
+      endtoken->number = 0;
       /* Value specified by POSIX.  */
-      eoftoken->user_token_number = 0;
+      endtoken->user_token_number = 0;
     }
 
   /* Insert the initial rule, which line is that of the first rule
      (not that of the start symbol):
 
-     axiom: %start EOF.  */
+     accept: %start EOF.  */
   {
-    symbol_list *p = symbol_list_new (axiom);
-    p->line = grammar->line;
-    p->next = symbol_list_new (startsymbol);
-    p->next->next = symbol_list_new (eoftoken);
-    p->next->next->next = symbol_list_new (NULL);
+    symbol_list *p = symbol_list_new (accept, empty_location);
+    p->location = grammar->location;
+    p->next = symbol_list_new (startsymbol, empty_location);
+    p->next->next = symbol_list_new (endtoken, empty_location);
+    p->next->next->next = symbol_list_new (NULL, empty_location);
     p->next->next->next->next = grammar;
     nrules += 1;
     nritems += 3;
     grammar = p;
   }
 
-  if (nsyms > SHRT_MAX)
-    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
-          SHRT_MAX);
-
-  assert (nsyms == ntokens + nvars);
+  if (! (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars))
+    abort ();
 
   xfclose (finput);