* src/output.c (output_table_data): Change the prototype to use

[bison.git] / src / conflicts.c

diff --git a/src/conflicts.c b/src/conflicts.c
index a9ea208ad4114a04739d0857949be9d1bc834b1a..bb2daecb292631f85406ee87585c5bd9237a374a 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -40,10 +40,11 @@ static unsigned *lookaheadset = NULL;
 static inline void
 log_resolution (int state, int LAno, int token, char *resolution)
 {
 static inline void
 log_resolution (int state, int LAno, int token, char *resolution)
 {

-  obstack_fgrow4 (&output_obstack,
-                 _("\
+  if (verbose_flag)
+    obstack_fgrow4 (&output_obstack,
+                   _("\

 Conflict in state %d between rule %d and token %s resolved as %s.\n"),
 Conflict in state %d between rule %d and token %s resolved as %s.\n"),

-                 state, LAruleno[LAno], tags[token], resolution);
+                   state, LAruleno[LAno], tags[token], resolution);

 }
 
 
 }
 
 


@@ -56,15 +57,29 @@ Conflict in state %d between rule %d and token %s resolved as %s.\n"),
 static void
 flush_shift (int state, int token)
 {
 static void
 flush_shift (int state, int token)
 {

-  shifts *shiftp = state_table[state].shifts;
+  shifts *shiftp = state_table[state]->shifts;

   int i;
 
   int i;
 

+  RESETBIT (lookaheadset, token);

   for (i = 0; i < shiftp->nshifts; i++)
     if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token)
       SHIFT_DISABLE (shiftp, i);
 }
 
 
   for (i = 0; i < shiftp->nshifts; i++)
     if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token)
       SHIFT_DISABLE (shiftp, i);
 }
 
 

+/*-------------------------------------------------------------------.
+| Turn off the reduce recorded for the specified token for the       |
+| specified lookahead.  Used when we resolve a shift-reduce conflict |
+| in favor of the shift.                                             |
+`-------------------------------------------------------------------*/
+
+static void
+flush_reduce (int lookahead, int token)
+{
+  RESETBIT (LA (lookahead), token);
+}
+
+

 /*------------------------------------------------------------------.
 | Attempt to resolve shift-reduce conflict for one rule by means of |
 | precedence declarations.  It has already been checked that the    |
 /*------------------------------------------------------------------.
 | Attempt to resolve shift-reduce conflict for one rule by means of |
 | precedence declarations.  It has already been checked that the    |


@@ -73,82 +88,66 @@ flush_shift (int state, int token)
 `------------------------------------------------------------------*/
 
 static void
 `------------------------------------------------------------------*/
 
 static void

-resolve_sr_conflict (int state, int lookaheadnum)
+resolve_sr_conflict (int state, int lookahead)

 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */
 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */

-  int redprec = rule_table[LAruleno[lookaheadnum]].prec;
+  int redprec = rule_table[LAruleno[lookahead]].prec;

   errs *errp = ERRS_ALLOC (ntokens + 1);
   short *errtokens = errp->errs;
 
   for (i = 0; i < ntokens; i++)
   errs *errp = ERRS_ALLOC (ntokens + 1);
   short *errtokens = errp->errs;
 
   for (i = 0; i < ntokens; i++)

-    if (BITISSET (LA (lookaheadnum), i)
+    if (BITISSET (LA (lookahead), i)

        && BITISSET (lookaheadset, i)
        && sprec[i])
        && BITISSET (lookaheadset, i)
        && sprec[i])

-      /* Shift-reduce conflict occurs for token number i
-        and it has a precedence.
-        The precedence of shifting is that of token i.  */

       {
       {

+       /* Shift-reduce conflict occurs for token number i
+          and it has a precedence.
+          The precedence of shifting is that of token i.  */

        if (sprec[i] < redprec)
          {
        if (sprec[i] < redprec)
          {

-           log_resolution (state, lookaheadnum, i, _("reduce"));
-           /* flush the shift for this token */
-           RESETBIT (lookaheadset, i);
+           log_resolution (state, lookahead, i, _("reduce"));

            flush_shift (state, i);
          }
        else if (sprec[i] > redprec)
          {
            flush_shift (state, i);
          }
        else if (sprec[i] > redprec)
          {

-           log_resolution (state, lookaheadnum, i, _("shift"));
-           /* flush the reduce for this token */
-           RESETBIT (LA (lookaheadnum), i);
+           log_resolution (state, lookahead, i, _("shift"));
+           flush_reduce (lookahead, i);

          }
        else
          }
        else

-         {
-           /* Matching precedence levels.
-              For left association, keep only the reduction.
-              For right association, keep only the shift.
-              For nonassociation, keep neither.  */
+         /* Matching precedence levels.
+            For left association, keep only the reduction.
+            For right association, keep only the shift.
+            For nonassociation, keep neither.  */

 
 

-           switch (sassoc[i])
-             {
-             case right_assoc:
-               log_resolution (state, lookaheadnum, i, _("shift"));
-               break;
-
-             case left_assoc:
-               log_resolution (state, lookaheadnum, i, _("reduce"));
-               break;
-
-             case non_assoc:
-               log_resolution (state, lookaheadnum, i, _("an error"));
-               break;
-             }
-
-           if (sassoc[i] != right_assoc)
-             {
-               /* flush the shift for this token */
-               RESETBIT (lookaheadset, i);
-               flush_shift (state, i);
-             }
-           if (sassoc[i] != left_assoc)
-             {
-               /* flush the reduce for this token */
-               RESETBIT (LA (lookaheadnum), i);
-             }
-           if (sassoc[i] == non_assoc)
-             {
-               /* Record an explicit error for this token.  */
-               *errtokens++ = i;
-             }
-         }
+         switch (sassoc[i])
+           {
+           case right_assoc:
+             log_resolution (state, lookahead, i, _("shift"));
+             flush_reduce (lookahead, i);
+             break;
+
+           case left_assoc:
+             log_resolution (state, lookahead, i, _("reduce"));
+             flush_shift (state, i);
+             break;
+
+           case non_assoc:
+             log_resolution (state, lookahead, i, _("an error"));
+             flush_shift (state, i);
+             flush_reduce (lookahead, i);
+             /* Record an explicit error for this token.  */
+             *errtokens++ = i;
+             break;
+           }

       }
 
   errp->nerrs = errtokens - errp->errs;
   /* Some tokens have been explicitly made errors.  Allocate a
      permanent errs structure for this state, to record them.  */
   i = (char *) errtokens - (char *) errp;
       }
 
   errp->nerrs = errtokens - errp->errs;
   /* Some tokens have been explicitly made errors.  Allocate a
      permanent errs structure for this state, to record them.  */
   i = (char *) errtokens - (char *) errp;

-  state_table[state].errs = ERRS_ALLOC (i + 1);
-  memcpy (state_table[state].errs, errp, i);
+  state_table[state]->errs = ERRS_ALLOC (i + 1);
+  memcpy (state_table[state]->errs, errp, i);

   free (errp);
 }
 
   free (errp);
 }
 


@@ -159,13 +158,13 @@ set_conflicts (int state)
   int i, j;
   shifts *shiftp;
 
   int i, j;
   shifts *shiftp;
 

-  if (state_table[state].consistent)
+  if (state_table[state]->consistent)

     return;
 
   for (i = 0; i < tokensetsize; i++)
     lookaheadset[i] = 0;
 
     return;
 
   for (i = 0; i < tokensetsize; i++)
     lookaheadset[i] = 0;
 

-  shiftp = state_table[state].shifts;
+  shiftp = state_table[state]->shifts;

   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));


@@ -173,8 +172,8 @@ set_conflicts (int state)
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */

-  for (i = state_table[state].lookaheads;
-       i < state_table[state + 1].lookaheads;
+  for (i = state_table[state]->lookaheadsp;
+       i < state_table[state + 1]->lookaheadsp;

        ++i)
     if (rule_table[LAruleno[i]].prec)
       for (j = 0; j < tokensetsize; ++j)
        ++i)
     if (rule_table[LAruleno[i]].prec)
       for (j = 0; j < tokensetsize; ++j)


@@ -187,8 +186,8 @@ set_conflicts (int state)
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */

-  for (i = state_table[state].lookaheads;
-       i < state_table[state + 1].lookaheads;
+  for (i = state_table[state]->lookaheadsp;
+       i < state_table[state + 1]->lookaheadsp;

        ++i)
     {
       for (j = 0; j < tokensetsize; ++j)
        ++i)
     {
       for (j = 0; j < tokensetsize; ++j)


@@ -223,7 +222,7 @@ count_sr_conflicts (int state)
 {
   int i, k;
   int src_count = 0;
 {
   int i, k;
   int src_count = 0;

-  shifts *shiftp = state_table[state].shifts;
+  shifts *shiftp = state_table[state]->shifts;

 
   if (!shiftp)
     return 0;
 
   if (!shiftp)
     return 0;


@@ -238,8 +237,8 @@ count_sr_conflicts (int state)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 

-  for (i = state_table[state].lookaheads;
-       i < state_table[state + 1].lookaheads;
+  for (i = state_table[state]->lookaheadsp;
+       i < state_table[state + 1]->lookaheadsp;

        ++i)
     for (k = 0; k < tokensetsize; ++k)
       lookaheadset[k] |= LA (i)[k];
        ++i)
     for (k = 0; k < tokensetsize; ++k)
       lookaheadset[k] |= LA (i)[k];


@@ -265,8 +264,8 @@ count_rr_conflicts (int state)
   int i;
   int rrc_count = 0;
 
   int i;
   int rrc_count = 0;
 

-  int m = state_table[state].lookaheads;
-  int n = state_table[state + 1].lookaheads;
+  int m = state_table[state]->lookaheadsp;
+  int n = state_table[state + 1]->lookaheadsp;

 
   if (n - m < 2)
     return 0;
 
   if (n - m < 2)
     return 0;


@@ -414,17 +413,15 @@ void
 print_reductions (FILE *out, int state)
 {
   int i;
 print_reductions (FILE *out, int state)
 {
   int i;

-  int j;
-  int m;
-  int n;
-  shifts *shiftp;
-  errs *errp;
+  int m = state_table[state]->lookaheadsp;
+  int n = state_table[state + 1]->lookaheadsp;
+  shifts *shiftp = state_table[state]->shifts;
+  errs *errp = state_table[state]->errs;

   int nodefault = 0;
 
   for (i = 0; i < tokensetsize; i++)
     shiftset[i] = 0;
 
   int nodefault = 0;
 
   for (i = 0; i < tokensetsize; i++)
     shiftset[i] = 0;
 

-  shiftp = state_table[state].shifts;

   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       {
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       {


@@ -435,15 +432,11 @@ print_reductions (FILE *out, int state)
        SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
       }
 
        SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
       }
 

-  errp = state_table[state].errs;

   if (errp)
     for (i = 0; i < errp->nerrs; i++)
       if (errp->errs[i])
        SETBIT (shiftset, errp->errs[i]);
 
   if (errp)
     for (i = 0; i < errp->nerrs; i++)
       if (errp->errs[i])
        SETBIT (shiftset, errp->errs[i]);
 

-  m = state_table[state].lookaheads;
-  n = state_table[state + 1].lookaheads;
-

   if (n - m == 1 && !nodefault)
     {
       int k;
   if (n - m == 1 && !nodefault)
     {
       int k;


@@ -463,8 +456,6 @@ print_reductions (FILE *out, int state)
     }
   else if (n - m >= 1)
     {
     }
   else if (n - m >= 1)
     {

-      int k;
-

       int cmax = 0;
       int default_LA = -1;
       int default_rule = 0;
       int cmax = 0;
       int default_LA = -1;
       int default_rule = 0;


@@ -473,6 +464,7 @@ print_reductions (FILE *out, int state)
        for (i = m; i < n; i++)
          {
            int count = 0;
        for (i = m; i < n; i++)
          {
            int count = 0;

+           int j, k;

 
            for (k = 0; k < tokensetsize; ++k)
              lookaheadset[k] = LA (i)[k] & ~shiftset[k];
 
            for (k = 0; k < tokensetsize; ++k)
              lookaheadset[k] = LA (i)[k] & ~shiftset[k];


@@ -501,12 +493,13 @@ print_reductions (FILE *out, int state)
 
       for (i = 0; i < ntokens; i++)
        {
 
       for (i = 0; i < ntokens; i++)
        {

+         int j;

          int defaulted = 0;
          int count = BITISSET (shiftset, i);
 
          for (j = m; j < n; j++)
            {
          int defaulted = 0;
          int count = BITISSET (shiftset, i);
 
          for (j = m; j < n; j++)
            {

-             if (BITISSET (LA (m), j))
+             if (BITISSET (LA (j), i))

                {
                  if (count == 0)
                    {
                {
                  if (count == 0)
                    {