yysyntax_error: more preparation for readability of next patch.

There are no behavioral changes here.
* data/glr.c (yyreportSyntaxError): Reorganize.
* data/lalr1.cc (yy::parser::yysyntax_error_): Reorganize.
* tests/conflicts.at (parse.error=verbose and consistent errors):
Reorganize.

diff --git a/ChangeLog b/ChangeLog
index 76163f208abf2848ee8d91d6752be673fcbebfe1..019c238469e2ad810aee9ac6d111c08191d46130 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2010-11-07  Joel E. Denny  <jdenny@clemson.edu>
+
+       yysyntax_error: more preparation for readability of next patch.
+       There are no behavioral changes here.
+       * data/glr.c (yyreportSyntaxError): Reorganize.
+       * data/lalr1.cc (yy::parser::yysyntax_error_): Reorganize.
+       * tests/conflicts.at (parse.error=verbose and consistent errors):
+       Reorganize.
+

 2010-11-07  Joel E. Denny  <jdenny@clemson.edu>
 
        yysyntax_error: prepare for readability of next patches.
 2010-11-07  Joel E. Denny  <jdenny@clemson.edu>
 
        yysyntax_error: prepare for readability of next patches.

diff --git a/data/glr.c b/data/glr.c
index f6c51c35acbe3112013b64942b32a84645b01927..93ed51283396cccb48cb64b55b989ad6e807c715 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -2076,9 +2076,11 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
 /*ARGSUSED*/ static void
 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {
 /*ARGSUSED*/ static void
 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
 {

-  if (yystackp->yyerrState == 0)
-    {
-#if YYERROR_VERBOSE
+  if (yystackp->yyerrState != 0)
+    return;
+#if ! YYERROR_VERBOSE
+  yyerror (]b4_lyyerror_args[YY_("syntax error"));
+#else

       int yyn;
       yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
 if (YYPACT_NINF < yyn && yyn <= YYLAST)
       int yyn;
       yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
 if (YYPACT_NINF < yyn && yyn <= YYLAST)


@@ -2175,11 +2177,10 @@ if (YYPACT_NINF < yyn && yyn <= YYLAST)
     }
   }
 else
     }
   }
 else

-#endif /* YYERROR_VERBOSE */

   yyerror (]b4_lyyerror_args[YY_("syntax error"));
   yyerror (]b4_lyyerror_args[YY_("syntax error"));

+#endif /* YYERROR_VERBOSE */

   yynerrs += 1;
 }
   yynerrs += 1;
 }

-}

 
 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
    yylval, and yylloc are the syntactic category, semantic value, and location
 
 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
    yylval, and yylloc are the syntactic category, semantic value, and location

diff --git a/data/lalr1.cc b/data/lalr1.cc
index d1d88d04a3480b9369302444d866b245dd398598..a3b223202de82bf5c9c14cc32736cdd5e9677e3b 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -977,8 +977,8 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
   ]b4_parser_class_name[::yysyntax_error_ (]dnl
 b4_error_verbose_if([state_type yystate, int yytoken],
                     [int, int])[)
   ]b4_parser_class_name[::yysyntax_error_ (]dnl
 b4_error_verbose_if([state_type yystate, int yytoken],
                     [int, int])[)

-  {
-    std::string yyres;]b4_error_verbose_if([[
+  {]b4_error_verbose_if([[
+    std::string yyres;

     int yyn = yypact_[yystate];
     if (yypact_ninf_ < yyn && yyn <= yylast_)
       {
     int yyn = yypact_[yystate];
     if (yypact_ninf_ < yyn && yyn <= yylast_)
       {


@@ -1038,9 +1038,9 @@ b4_error_verbose_if([state_type yystate, int yytoken],
         yyres += *yyp;
     }
   else
         yyres += *yyp;
     }
   else

-  ]])dnl
-[    yyres = YY_("syntax error");
-    return yyres;
+    yyres = YY_("syntax error");
+    return yyres;]], [[
+    return YY_("syntax error");]])[

   }
 
 
   }
 
 

diff --git a/tests/conflicts.at b/tests/conflicts.at
index ffcbb7776a65581311331831b973ab38a524f5d8..72f56963074f74899da61311c3657db8eb3e5e2d 100644 (file)
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -147,21 +147,6 @@ AT_SETUP([[parse.error=verbose and consistent errors]])
 
 m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [
 
 
 m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [
 

-AT_BISON_CHECK([$1[ -o input.c input.y]])
-AT_COMPILE([[input]])
-
-m4_pushdef([AT_EXPECTING], [m4_if($3, [ab], [[, expecting 'a' or 'b']],
-                                  $3, [a],  [[, expecting 'a']],
-                                  $3, [b],  [[, expecting 'b']])])
-
-AT_PARSER_CHECK([[./input]], [[1]], [],
-[[syntax error, unexpected ]$2[]AT_EXPECTING[
-]])
-
-m4_popdef([AT_EXPECTING])
-
-])
-

 AT_DATA_GRAMMAR([input.y],
 [[%code {
   #include <assert.h>
 AT_DATA_GRAMMAR([input.y],
 [[%code {
   #include <assert.h>


@@ -171,13 +156,53 @@ AT_DATA_GRAMMAR([input.y],
   #define USE(Var)
 }
 
   #define USE(Var)
 }
 

+]$1[
+

 %define parse.error verbose
 
 %define parse.error verbose
 

-// The point isn't to test IELR here, but state merging happens to
-// complicate the example.
-%define lr.type ielr
+%%
+
+]$2[
+
+%%
+
+int
+yylex (void)
+{
+  static char const *input = "]$3[";
+  yylval = 1;
+  return *input++;
+}
+
+void
+yyerror (char const *msg)
+{
+  fprintf (stderr, "%s\n", msg);
+}
+
+int
+main (void)
+{
+  return yyparse ();
+}
+]])
+AT_BISON_CHECK([[-o input.c input.y]])
+AT_COMPILE([[input]])
+
+m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']],
+                                  $5, [a],  [[, expecting 'a']],
+                                  $5, [b],  [[, expecting 'b']])])

 
 

-%nonassoc 'a'
+AT_PARSER_CHECK([[./input]], [[1]], [[]],
+[[syntax error, unexpected ]$4[]AT_EXPECTING[
+]])
+
+m4_popdef([AT_EXPECTING])
+
+])
+
+m4_pushdef([AT_USER_ACTION_GRAMMAR],
+[[%nonassoc 'a';

 
 // If yylval=0 here, then we know that the 'a' destructor is being
 // invoked incorrectly for the 'b' set in the semantic action below.
 
 // If yylval=0 here, then we know that the 'a' destructor is being
 // invoked incorrectly for the 'b' set in the semantic action below.


@@ -185,9 +210,7 @@ AT_DATA_GRAMMAR([input.y],
 %destructor {
   if (!$$)
     fprintf (stderr, "Wrong destructor.\n");
 %destructor {
   if (!$$)
     fprintf (stderr, "Wrong destructor.\n");

-} 'a'
-
-%%
+} 'a';

 
 // The lookahead assigned by the semantic action isn't needed before
 // either error action is encountered.  In a previous version of Bison,
 
 // The lookahead assigned by the semantic action isn't needed before
 // either error action is encountered.  In a previous version of Bison,


@@ -198,13 +221,13 @@ AT_DATA_GRAMMAR([input.y],
 // except that, due to another bug, the unexpected token is not reported
 // at all because the error action is the default action in a consistent
 // state.  That bug still needs to be fixed.
 // except that, due to another bug, the unexpected token is not reported
 // at all because the error action is the default action in a consistent
 // state.  That bug still needs to be fixed.

-start: error-reduce consistent-error 'a' { USE ($3); } ;
+start: error-reduce consistent-error 'a' { USE ($][3); } ;

 
 error-reduce:
   'a' 'a' consistent-reduction consistent-error 'a'
 
 error-reduce:
   'a' 'a' consistent-reduction consistent-error 'a'

-  { USE (($1, $2, $5)); }
+  { USE (($][1, $][2, $][5)); }

 | 'a' error
 | 'a' error

-  { USE ($1); }
+  { USE ($][1); }

 ;
 
 consistent-reduction: /*empty*/ {
 ;
 
 consistent-reduction: /*empty*/ {


@@ -214,48 +237,40 @@ consistent-reduction: /*empty*/ {
 } ;
 
 consistent-error:
 } ;
 
 consistent-error:

-  'a' { USE ($1); }
+  'a' { USE ($][1); }

 | /*empty*/ %prec 'a'
 ;
 
 // Provide another context in which all rules are useful so that this
 // test case looks a little more realistic.
 start: 'b' consistent-error 'b' ;
 | /*empty*/ %prec 'a'
 ;
 
 // Provide another context in which all rules are useful so that this
 // test case looks a little more realistic.
 start: 'b' consistent-error 'b' ;

-
-%%
-
-int
-yylex (void)
-{
-  static char const *input = "aa";
-  yylval = 1;
-  return *input++;
-}
-
-void
-yyerror (char const *msg)
-{
-  fprintf (stderr, "%s\n", msg);
-}
-
-int
-main (void)
-{
-  return yyparse ();
-}

 ]])
 ]])

+m4_pushdef([AT_USER_ACTION_INPUT], [[aa]])

 
 # See comments in grammar for why this test doesn't succeed.
 AT_XFAIL_IF([[:]])
 
 
 # See comments in grammar for why this test doesn't succeed.
 AT_XFAIL_IF([[:]])
 

-AT_CONSISTENT_ERRORS_CHECK([], [['b']], [[none]])
-AT_CONSISTENT_ERRORS_CHECK([[-Dlr.default-reductions=consistent]],
+AT_CONSISTENT_ERRORS_CHECK([[]],
+                           [AT_USER_ACTION_GRAMMAR],
+                           [AT_USER_ACTION_INPUT],
+                           [['b']], [[none]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions consistent]],
+                           [AT_USER_ACTION_GRAMMAR],
+                           [AT_USER_ACTION_INPUT],

                            [['b']], [[none]])
 
 # Canonical LR doesn't foresee the error for 'a'!
                            [['b']], [[none]])
 
 # Canonical LR doesn't foresee the error for 'a'!

-AT_CONSISTENT_ERRORS_CHECK([[-Dlr.default-reductions=accepting]],
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions accepting]],
+                           [AT_USER_ACTION_GRAMMAR],
+                           [AT_USER_ACTION_INPUT],

                            [[$end]], [[a]])
                            [[$end]], [[a]])

-AT_CONSISTENT_ERRORS_CHECK([[-Flr.type=canonical-lr]], [[$end]], [[a]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]],
+                           [AT_USER_ACTION_GRAMMAR],
+                           [AT_USER_ACTION_INPUT],
+                           [[$end]], [[a]])
+
+m4_popdef([AT_USER_ACTION_GRAMMAR])
+m4_popdef([AT_USER_ACTION_INPUT])

 
 m4_popdef([AT_CONSISTENT_ERRORS_CHECK])
 
 
 m4_popdef([AT_CONSISTENT_ERRORS_CHECK])