]> git.saurik.com Git - bison.git/blobdiff - src/reader.c
* src/reader.c (grammar_midrule_action): New, Eved out from
[bison.git] / src / reader.c
index d1a6b9aa7b6d67590d8d3f0d55b161aedec86fea..949d74bb26cc657d2b3ebe09e64631c8fff05232 100644 (file)
@@ -1089,18 +1089,93 @@ 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.  */
+symbol_list *current_rule = NULL;
+symbol_list *previous_rule = NULL;
+
+
+/* Create a new rule for LHS in to the GRAMMAR. */
+
+static void
+grammar_rule_begin (symbol_t *lhs)
+{
+  if (!start_flag)
+    {
+      startsymbol = lhs;
+      start_flag = 1;
+    }
+
+  /* Start a new rule and record its lhs.  */
+  ++nrules;
+  ++nritems;
+
+  previous_rule = grammar_end;
+  grammar_symbol_append (lhs);
+  current_rule = grammar_end;
+
+  /* Mark the rule's lhs as a nonterminal if not already so.  */
+
+  if (lhs->class == unknown_sym)
+    {
+      lhs->class = nterm_sym;
+      lhs->number = nvars;
+      ++nvars;
+    }
+  else if (lhs->class == token_sym)
+    complain (_("rule given for %s, which is a token"), lhs->tag);
+}
+
+/* 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.  */
+
+static void
+grammar_midrule_action (void)
+{
+  /* Since the action was written out with this rule's number, we must
+     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 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;
+  current_rule->action = NULL;
+
+  if (previous_rule)
+    previous_rule->next = midrule_action;
+  else
+    grammar = midrule_action;
+
+  /* End of the rule. */
+  previous_rule = symbol_list_new (NULL);
+  previous_rule->next = current_rule;
+
+  midrule_action->next = previous_rule;
+
+  /* Insert the dummy generated by that rule into this rule.  */
+  ++nritems;
+  grammar_symbol_append (sdummy);
+}
+
+
 static void
 readgram (void)
 {
   token_t t;
   symbol_t *lhs = NULL;
 
-  /* Points to first symbol_list of current rule. its symbol is the
-     lhs of the rule.  */
-  symbol_list *crule = NULL;
-  /* Points to the symbol_list preceding crule.  */
-  symbol_list *crule1 = NULL;
-
   t = lex ();
 
   while (t != tok_two_percents && t != tok_eof)
@@ -1116,12 +1191,6 @@ readgram (void)
          {
            lhs = symval;
 
-           if (!start_flag)
-             {
-               startsymbol = lhs;
-               start_flag = 1;
-             }
-
            t = lex ();
            if (t != tok_colon)
              {
@@ -1129,32 +1198,13 @@ readgram (void)
                unlex (t);
              }
          }
-
        if (nrules == 0 && t == tok_bar)
          {
            complain (_("grammar starts with vertical bar"));
            lhs = symval;       /* BOGUS: use a random symval */
          }
-       /* start a new rule and record its lhs.  */
-
-       ++nrules;
-       ++nritems;
-
-       crule1 = grammar_end;
-       grammar_symbol_append (lhs);
-       crule = grammar_end;
-
-       /* mark the rule's lhs as a nonterminal if not already so.  */
-
-       if (lhs->class == unknown_sym)
-         {
-           lhs->class = nterm_sym;
-           lhs->number = nvars;
-           ++nvars;
-         }
-       else if (lhs->class == token_sym)
-         complain (_("rule given for %s, which is a token"), lhs->tag);
 
+       grammar_rule_begin (lhs);
        /* read the rhs of the rule.  */
 
        for (;;)
@@ -1163,7 +1213,7 @@ readgram (void)
            if (t == tok_prec)
              {
                t = lex ();
-               crule->ruleprec = symval;
+               current_rule->ruleprec = symval;
                t = lex ();
              }
 
@@ -1198,40 +1248,7 @@ readgram (void)
               non-terminal.  */
            if (action_flag)
              {
-               /* Since the action was written out with this rule's
-                  number, we must 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 *p = symbol_list_new (sdummy);
-
-               /* 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. */
-               p->line = crule->line;
-               /* Move the action from the host rule to this one. */
-               p->action = crule->action;
-               p->action_line = crule->action_line;
-               crule->action = NULL;
-
-               if (crule1)
-                 crule1->next = p;
-               else
-                 grammar = p;
-               /* End of the rule. */
-               crule1 = symbol_list_new (NULL);
-               crule1->next = crule;
-
-               p->next = crule1;
-
-               /* Insert the dummy generated by that rule into this
-                  rule.  */
-               ++nritems;
-               grammar_symbol_append (sdummy);
+               grammar_midrule_action ();
                action_flag = 0;
              }
 
@@ -1242,7 +1259,7 @@ readgram (void)
              }
            else                /* handle an action.  */
              {
-               parse_action (crule, rulelength);
+               parse_action (current_rule, rulelength);
                action_flag = 1;
                ++xactions;     /* JF */
              }
@@ -1256,7 +1273,7 @@ readgram (void)
          {
            complain (_("two @prec's in a row"));
            t = lex ();
-           crule->ruleprec = symval;
+           current_rule->ruleprec = symval;
            t = lex ();
          }
 
@@ -1265,7 +1282,7 @@ readgram (void)
            /* This case never occurs -wjh */
            if (action_flag)
              complain (_("two actions at end of one rule"));
-           parse_action (crule, rulelength);
+           parse_action (current_rule, rulelength);
            action_flag = 1;
            ++xactions; /* -wjh */
            t = lex ();