From d441a347916cd54c621a8560d334ce91ebdc6db9 Mon Sep 17 00:00:00 2001
From: Akim Demaille <akim.demaille@gmail.com>
Date: Mon, 3 Aug 2020 19:02:15 +0200
Subject: [PATCH] multistart: also give access to yynerrs

This is something that has always bothered me: with pure parsers (and
they all should be) the user does not have an (easy) access to yynerrs
at the end of the parse.  In the case of error recovery, that's the
only direct means to know if there were errors.  The usual approach
being having the user maintain a counter incremented each time yyerror
is called.

So here, also capture yynerrs in the return value of the start-symbol
parsing functions.

* data/skeletons/yacc.c (yy_parse_impl_t): New.
(yy_parse_impl): Use it.
(b4_accept): Fill it.
* examples/c/lexcalc/parse.y, examples/c/lexcalc/scan.l: No longer
pass nerrs as lex- and parse-param, just use the resulting yynerrs.
bistromathic and reccalc both demonstrate %param.
---
 data/skeletons/yacc.c           | 26 ++++++++++++++++++--------
 examples/c/lexcalc/lexcalc.test |  9 ++++++---
 examples/c/lexcalc/parse.y      | 24 +++++++++++++-----------
 examples/c/lexcalc/scan.l       |  4 ++--
 4 files changed, 39 insertions(+), 24 deletions(-)

diff --git a/data/skeletons/yacc.c b/data/skeletons/yacc.c
index c8c89555..62f9f93c 100644
--- a/data/skeletons/yacc.c
+++ b/data/skeletons/yacc.c
@@ -123,7 +123,7 @@ m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])])
 # before, using the slot of SYMBOL-NUM.
 m4_define([b4_accept],
 [m4_ifval([$1],
-          [b4_symbol_value((*yyvalue), [$1]) = b4_rhs_value(2, 1, [$1]); ])YYACCEPT])
+          [b4_symbol_value(yyimpl->yyvalue, [$1]) = b4_rhs_value(2, 1, [$1]); ]) YYACCEPT])
 
 
 # b4_lhs_value(SYMBOL-NUM, [TYPE])
@@ -176,6 +176,7 @@ typedef struct
 {]b4_symbol_if([$1], [has_type], [[
   ]_b4_symbol($1, type)[ yyvalue;]])[
   int yystatus;
+  int yynerrs;
 } ]b4_prefix[parse_]_b4_symbol($1, id)[_t;
 
 // Parse one ]_b4_symbol($1, tag)[.
@@ -200,10 +201,11 @@ m4_define([_b4_define_sub_yyparse],
 yyparse_]_b4_symbol($1, id)[ (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[)
 {
   ]b4_prefix[parse_]_b4_symbol($1, id)[_t yyres;
-  YYSTYPE yyvalue;
-  yyres.yystatus = yy_parse_impl (]b4_symbol($2, id)[, &yyvalue]m4_ifset([b4_parse_param],
+  yy_parse_impl_t yyimpl;
+  yyres.yystatus = yy_parse_impl (]b4_symbol($2, id)[, &yyimpl]m4_ifset([b4_parse_param],
                            [[, ]b4_args(b4_parse_param)])[);]b4_symbol_if([$1], [has_type], [[
-  yyres.yyvalue = yyvalue.]b4_symbol($1, slot)[;]])[
+  yyres.yyvalue = yyimpl.yyvalue.]b4_symbol($1, slot)[;]])[
+  yyres.yynerrs = yyimpl.yynerrs;
   return yyres;
 }
 ]])
@@ -1595,9 +1597,16 @@ yypush_parse (yypstate *yyps]b4_pure_if([[,
 `----------*/
 
 ]m4_ifdef([b4_start_symbols],
-[[
+[[// Extract data from the parser.
+typedef struct
+{
+  YYSTYPE yyvalue;
+  int yynerrs;
+} yy_parse_impl_t;
+
+// Run a full parse, using YYCHAR as switching token.
 static int
-yy_parse_impl (int yychar, YYSTYPE *yyvalue]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[);
+yy_parse_impl (int yychar, yy_parse_impl_t *yyimpl]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[);
 
 ]m4_map([_b4_define_sub_yyparse], m4_defn([b4_start_symbols]))[
 
@@ -1609,7 +1618,7 @@ yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[)
 }
 
 static int
-yy_parse_impl (int yychar, YYSTYPE *yyvalue]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[)]],
+yy_parse_impl (int yychar, yy_parse_impl_t *yyimpl]m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])[)]],
 [[int
 yyparse (]m4_ifset([b4_parse_param], [b4_formals(b4_parse_param)], [void])[)]])])[
 {]b4_pure_if([b4_declare_scanner_communication_variables
@@ -2172,7 +2181,8 @@ yypushreturn:]], [[
     YYSTACK_FREE (yyes);]])])[
 ]b4_parse_error_bmatch([detailed\|verbose],
 [[  if (yymsg != yymsgbuf)
-    YYSTACK_FREE (yymsg);]])[
+    YYSTACK_FREE (yymsg);]])[]m4_ifdef([b4_start_symbols], [[
+  yyimpl->yynerrs = yynerrs;]])[
   return yyresult;
 }
 ]b4_push_if([b4_parse_state_variable_macros([b4_macro_undef])])[
diff --git a/examples/c/lexcalc/lexcalc.test b/examples/c/lexcalc/lexcalc.test
index 794676de..0eb4ebee 100644
--- a/examples/c/lexcalc/lexcalc.test
+++ b/examples/c/lexcalc/lexcalc.test
@@ -38,12 +38,14 @@ run -noerr 0 9 -p
 cat >input <<EOF
 (1+2) *
 EOF
-run 1 'err: 1.8-2.0: syntax error, unexpected end of line, expecting ( or number'
+run 1 'err: 1.8-2.0: syntax error, unexpected end of line, expecting ( or number
+err: errors: 1'
 
 cat >input <<EOF
 1 / (2 - 2)
 EOF
-run 1 'err: 1.1-11: error: division by zero'
+run 1 'err: 1.1-11: error: division by zero
+err: errors: 1'
 
 
 # Multistart: parse "expression" instead of "input".
@@ -57,4 +59,5 @@ cat >input <<EOF
 2
 EOF
 run 1 'expression: failure
-err: 2.1: syntax error, unexpected number, expecting end of file' -e
+err: 2.1: syntax error, unexpected number, expecting end of file
+err: errors: 1' -e
diff --git a/examples/c/lexcalc/parse.y b/examples/c/lexcalc/parse.y
index 59708115..1da92a3e 100644
--- a/examples/c/lexcalc/parse.y
+++ b/examples/c/lexcalc/parse.y
@@ -25,10 +25,10 @@
 {
   // Tell Flex the expected prototype of yylex.
 #define YY_DECL                                 \
-  yytoken_kind_t yylex (YYSTYPE* yylval, YYLTYPE *yylloc, int *nerrs)
+  yytoken_kind_t yylex (YYSTYPE* yylval, YYLTYPE *yylloc)
   YY_DECL;
 
-  void yyerror (YYLTYPE *loc, int *nerrs, const char *msg);
+  void yyerror (YYLTYPE *loc, const char *msg);
 }
 
 // Emitted on top of the implementation file.
@@ -62,9 +62,6 @@
 // Enable debug traces (see yydebug in main).
 %define parse.trace
 
-// Error count, exchanged between main, yyparse and yylex.
-%param {int *nerrs}
-
 %token
   PLUS   "+"
   MINUS  "-"
@@ -109,7 +106,7 @@ exp:
   {
     if ($3 == 0)
       {
-        yyerror (&@$, nerrs, "error: division by zero");
+        yyerror (&@$, "error: division by zero");
         YYERROR;
       }
     else
@@ -121,19 +118,19 @@ exp:
 %%
 // Epilogue (C code).
 
-void yyerror (YYLTYPE *loc, int *nerrs, const char *msg)
+void yyerror (YYLTYPE *loc, const char *msg)
 {
   YY_LOCATION_PRINT (stderr, *loc);
   fprintf (stderr, ": %s\n", msg);
-  ++*nerrs;
 }
 
 int main (int argc, const char *argv[])
 {
-  int nerrs = 0;
   // Possibly enable parser runtime debugging.
   yydebug = !!getenv ("YYDEBUG");
   int parse_expression_p = 0;
+  int nerrs = 0;
+
   // Enable parse traces on option -p.
   for (int i = 0; i < argc; ++i)
     if (1 < argc && strcmp (argv[1], "-p") == 0)
@@ -143,14 +140,19 @@ int main (int argc, const char *argv[])
 
   if (parse_expression_p)
     {
-      yyparse_expression_t res = yyparse_expression (&nerrs);
+      yyparse_expression_t res = yyparse_expression ();
+      nerrs = res.yynerrs;
       if (res.yystatus == 0)
         printf ("expression: %d\n", res.yyvalue);
       else
         printf ("expression: failure\n");
     }
   else
-    yyparse_input (&nerrs);
+    nerrs = yyparse_input ().yynerrs;
+
+  if (nerrs)
+    fprintf (stderr, "errors: %d\n", nerrs);
+
   // Exit on failure if there were errors.
   return !!nerrs;
 }
diff --git a/examples/c/lexcalc/scan.l b/examples/c/lexcalc/scan.l
index 3d71a381..baf0798d 100644
--- a/examples/c/lexcalc/scan.l
+++ b/examples/c/lexcalc/scan.l
@@ -61,7 +61,7 @@
   errno = 0;
   long n = strtol (yytext, NULL, 10);
   if (! (INT_MIN <= n && n <= INT_MAX && errno != ERANGE))
-    yyerror (yylloc, nerrs, "integer is out of range");
+    yyerror (yylloc, "integer is out of range");
   yylval->TOK_NUM = (int) n;
   return TOK_NUM;
 }
@@ -71,7 +71,7 @@
  /* Ignore white spaces. */
 [ \t]+   LOCATION_STEP (); continue;
 
-.        yyerror (yylloc, nerrs, "syntax error, invalid character"); continue;
+.        yyerror (yylloc, "syntax error, invalid character"); continue;
 
 <<EOF>>  return TOK_YYEOF;
 %%