* src/parse-gram.y (declaration): Have %parse-param and %lex-param

[bison.git] / tests / calc.at

diff --git a/tests/calc.at b/tests/calc.at
index 149abb2f644c524cd0b0defbc01deeedd0b6febb..c3873e57c55c10ee687231a310eb4b685e875ddf 100644 (file)
--- a/tests/calc.at
+++ b/tests/calc.at
@@ -26,8 +26,8 @@
 # ------------------------- #
 
 
 # ------------------------- #
 
 

-# _AT_DATA_CALC_Y($1, $2, $3, [CPP-DIRECTIVES])
-# ---------------------------------------------
+# _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
+# -----------------------------------------------

 # Produce `calc.y'.  Don't call this macro directly, because it contains
 # some occurrences of `$1' etc. which will be interpreted by m4.  So
 # you should call it with $1, $2, and $3 as arguments, which is what
 # Produce `calc.y'.  Don't call this macro directly, because it contains
 # some occurrences of `$1' etc. which will be interpreted by m4.  So
 # you should call it with $1, $2, and $3 as arguments, which is what


@@ -35,30 +35,27 @@
 m4_define([_AT_DATA_CALC_Y],
 [m4_if([$1$2$3], $[1]$[2]$[3], [],
        [m4_fatal([$0: Invalid arguments: $@])])dnl
 m4_define([_AT_DATA_CALC_Y],
 [m4_if([$1$2$3], $[1]$[2]$[3], [],
        [m4_fatal([$0: Invalid arguments: $@])])dnl

-AT_DATA([calc.y],
+AT_DATA_GRAMMAR([calc.y],

 [[/* Infix notation calculator--calc */
 [[/* Infix notation calculator--calc */

-
+]$4[

 %{
 %{

-#include <config.h>
-/* We don't need perfect functions for these tests. */
-#undef malloc
-#undef memcmp
-#undef realloc

 #include <stdio.h>
 
 #if STDC_HEADERS
 # include <stdlib.h>
 # include <string.h>
 #include <stdio.h>
 
 #if STDC_HEADERS
 # include <stdlib.h>
 # include <string.h>

-#else
-char *strcat(char *dest, const char *src);

 #endif
 #include <ctype.h>
 #endif
 #include <ctype.h>

+#include <assert.h>

 
 extern void perror (const char *s);
 
 /* Exercise pre-prologue dependency to %union.  */
 typedef int value_t;
 
 
 extern void perror (const char *s);
 
 /* Exercise pre-prologue dependency to %union.  */
 typedef int value_t;
 

+value_t global_result = 0;
+int global_count = 0;
+

 %}
 
 /* Exercise %union. */
 %}
 
 /* Exercise %union. */


@@ -76,16 +73,14 @@ typedef int value_t;
 #  define VAL     (yylval)
 #endif
 
 #  define VAL     (yylval)
 #endif
 

+#define YYLLOC_FORMAL   ]AT_LOCATION_IF([, YYLTYPE *yylloc])[
+#define YYLLOC_ARG      ]AT_LOCATION_IF([, yylloc])[
+#define USE_YYLLOC      ]AT_LOCATION_IF([(void) yylloc;])[
+

 #if YYPURE
 #if YYPURE

-#  if YYLSP_NEEDED
-#    define LEX_FORMALS     YYSTYPE *yylval, YYLTYPE *yylloc
-#    define LEX_ARGS        yylval, yylloc
-#    define USE_LEX_ARGS    (void) yylval; (void) yylloc;
-#  else
-#    define LEX_FORMALS     YYSTYPE *yylval
-#    define LEX_ARGS        yylval
-#    define USE_LEX_ARGS    (void) yylval
-#  endif
+#  define LEX_FORMALS     YYSTYPE *yylval YYLLOC_FORMAL
+#  define LEX_ARGS        yylval          YYLLOC_ARG
+#  define USE_LEX_ARGS    (void) yylval;  USE_YYLLOC

 #  define LEX_PRE_FORMALS   LEX_FORMALS,
 #  define LEX_PRE_ARGS      LEX_ARGS,
 #else
 #  define LEX_PRE_FORMALS   LEX_FORMALS,
 #  define LEX_PRE_ARGS      LEX_ARGS,
 #else


@@ -97,7 +92,13 @@ typedef int value_t;
 #endif
 
 static int power (int base, int exponent);
 #endif
 
 static int power (int base, int exponent);

-static void yyerror (const char *s);
+/* yyerror receives the location if:
+   - %location & %pure & %glr
+   - %location & %pure & %yacc & %parse-param. */
+static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
+                     ]AT_PARAM_IF([value_t *result, int *count, ])[
+                     const char *s
+                     );

 static int yylex (LEX_FORMALS);
 static int yygetc (LEX_FORMALS);
 static void yyungetc (LEX_PRE_FORMALS int c);
 static int yylex (LEX_FORMALS);
 static int yygetc (LEX_FORMALS);
 static void yyungetc (LEX_PRE_FORMALS int c);


@@ -114,27 +115,25 @@ static void yyungetc (LEX_PRE_FORMALS int c);
 %left NEG     /* negation--unary minus */
 %right '^'    /* exponentiation        */
 
 %left NEG     /* negation--unary minus */
 %right '^'    /* exponentiation        */
 

-]$4[
-

 /* Grammar follows */
 %%
 input:
   line
 /* Grammar follows */
 %%
 input:
   line

-| input line
+| input line         { ]AT_PARAM_IF([++*count; ++global_count;])[ }

 ;
 
 line:
   '\n'
 ;
 
 line:
   '\n'

-| exp '\n'
+| exp '\n'           { ]AT_PARAM_IF([*result = global_result = $1;])[ }

 ;
 
 exp:
   NUM                { $$ = $1;             }
 | exp '=' exp
   {
 ;
 
 exp:
   NUM                { $$ = $1;             }
 | exp '=' exp
   {

-     if ($1 != $3)
-       fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
-     $$ = $1 == $3;
+    if ($1 != $3)
+      fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
+    $$ = $1;

   }
 | exp '+' exp        { $$ = $1 + $3;        }
 | exp '-' exp        { $$ = $1 - $3;        }
   }
 | exp '+' exp        { $$ = $1 + $3;        }
 | exp '-' exp        { $$ = $1 - $3;        }


@@ -150,26 +149,30 @@ exp:
 FILE *yyin;
 
 static void
 FILE *yyin;
 
 static void

-yyerror (const char *s)
+yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
+         ]AT_PARAM_IF([value_t *result, int *count, ])[
+         const char *s
+         )

 {
 {

-#if YYLSP_NEEDED
+]AT_PARAM_IF([(void) result; (void) count; ])[
+]AT_YYERROR_SEES_LOC_IF([

   fprintf (stderr, "%d.%d-%d.%d: ",
           LOC.first_line, LOC.first_column,
           LOC.last_line, LOC.last_column);
   fprintf (stderr, "%d.%d-%d.%d: ",
           LOC.first_line, LOC.first_column,
           LOC.last_line, LOC.last_column);

-#endif
+])[

   fprintf (stderr, "%s\n", s);
 }
 
 
   fprintf (stderr, "%s\n", s);
 }
 
 

-#if YYLSP_NEEDED
+]AT_LOCATION_IF([

 static YYLTYPE last_yylloc;
 static YYLTYPE last_yylloc;

-#endif
+])[

 static int
 yygetc (LEX_FORMALS)
 {
   int res = getc (yyin);
   USE_LEX_ARGS;
 static int
 yygetc (LEX_FORMALS)
 {
   int res = getc (yyin);
   USE_LEX_ARGS;

-#if YYLSP_NEEDED
+]AT_LOCATION_IF([

   last_yylloc = LOC;
   if (res == '\n')
     {
   last_yylloc = LOC;
   if (res == '\n')
     {


@@ -178,7 +181,7 @@ yygetc (LEX_FORMALS)
     }
   else
     LOC.last_column++;
     }
   else
     LOC.last_column++;

-#endif
+])[

   return res;
 }
 
   return res;
 }
 


@@ -187,10 +190,10 @@ static void
 yyungetc (LEX_PRE_FORMALS int c)
 {
   USE_LEX_ARGS;
 yyungetc (LEX_PRE_FORMALS int c)
 {
   USE_LEX_ARGS;

-#if YYLSP_NEEDED
+]AT_LOCATION_IF([

   /* Wrong when C == `\n'. */
   LOC = last_yylloc;
   /* Wrong when C == `\n'. */
   LOC = last_yylloc;

-#endif
+])[

   ungetc (c, yyin);
 }
 
   ungetc (c, yyin);
 }
 


@@ -236,24 +239,24 @@ yylex (LEX_FORMALS)
   if (init)
     {
       init = 0;
   if (init)
     {
       init = 0;

-#if YYLSP_NEEDED
+]AT_LOCATION_IF([

       LOC.last_column = 1;
       LOC.last_line = 1;
       LOC.last_column = 1;
       LOC.last_line = 1;

-#endif
+])[

     }
 
     }
 

-#if YYLSP_NEEDED
+]AT_LOCATION_IF([

   LOC.first_column = LOC.last_column;
   LOC.first_line = LOC.last_line;
   LOC.first_column = LOC.last_column;
   LOC.first_line = LOC.last_line;

-#endif
+])[

 
   /* Skip white space.  */
   while ((c = yygetc (LEX_ARGS)) == ' ' || c == '\t')
     {
 
   /* Skip white space.  */
   while ((c = yygetc (LEX_ARGS)) == ' ' || c == '\t')
     {

-#if YYLSP_NEEDED
+]AT_LOCATION_IF([

       LOC.first_column = LOC.last_column;
       LOC.first_line = LOC.last_line;
       LOC.first_column = LOC.last_column;
       LOC.first_line = LOC.last_line;

-#endif
+])[

     }
 
   /* process numbers   */
     }
 
   /* process numbers   */


@@ -286,6 +289,9 @@ power (int base, int exponent)
 int
 main (int argc, const char **argv)
 {
 int
 main (int argc, const char **argv)
 {

+  value_t result = 0;
+  int count = 0;
+  int status = 0;

   yyin = NULL;
 
   if (argc == 2)
   yyin = NULL;
 
   if (argc == 2)


@@ -302,8 +308,10 @@ main (int argc, const char **argv)
 #if YYDEBUG
   yydebug = 1;
 #endif
 #if YYDEBUG
   yydebug = 1;
 #endif

-  yyparse ();
-  return 0;
+  status = yyparse (]AT_PARAM_IF([&result, &count])[);
+  assert (global_result == result);
+  assert (global_count  == count);
+  return status;

 }
 ]])
 ])# _AT_DATA_CALC_Y
 }
 ]])
 ])# _AT_DATA_CALC_Y


@@ -313,8 +321,7 @@ main (int argc, const char **argv)
 # -------------------------------
 # Produce `calc.y'.
 m4_define([AT_DATA_CALC_Y],
 # -------------------------------
 # Produce `calc.y'.
 m4_define([AT_DATA_CALC_Y],

-[_AT_DATA_CALC_Y($[1], $[2], $[3],
-                 [m4_bpatsubst([$1], [--[^ ]*])])
+[_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])

 ])
 
 
 ])
 
 


@@ -342,15 +349,16 @@ m4_bmatch([$1],
 ])
 
 
 ])
 
 

-# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, INPUT, [NUM-DEBUG-LINES],
-#                      [ERROR-LOCATION], [IF-YYERROR-VERBOSE])
-# ------------------------------------------------------------
+# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
+#                      [NUM-DEBUG-LINES],
+#                      [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
+# ---------------------------------------------------------

 # Run `calc' on INPUT, and expect a `parse error' message.
 #
 # If INPUT starts with a slash, it is used as absolute input file name,
 # otherwise as contents.
 #
 # Run `calc' on INPUT, and expect a `parse error' message.
 #
 # If INPUT starts with a slash, it is used as absolute input file name,
 # otherwise as contents.
 #

-# If BISON-OPTIONS contains `--location', then make sure the ERROR-LOCATION
+# If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION

 # is correctly output on stderr.
 #
 # If BISON-OPTIONS contains `%error-verbose', then make sure the
 # is correctly output on stderr.
 #
 # If BISON-OPTIONS contains `%error-verbose', then make sure the


@@ -360,17 +368,17 @@ m4_bmatch([$1],
 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 # is the number of expected lines on stderr.
 m4_define([_AT_CHECK_CALC_ERROR],
 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 # is the number of expected lines on stderr.
 m4_define([_AT_CHECK_CALC_ERROR],

-[m4_bmatch([$2], [^/],
-           [AT_PARSER_CHECK([./calc $2], 0, [], [stderr])],
+[m4_bmatch([$3], [^/],
+           [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],

            [AT_DATA([[input]],
            [AT_DATA([[input]],

-[[$2
+[[$3

 ]])
 ]])

-AT_PARSER_CHECK([./calc input], 0, [], [stderr])])
+AT_PARSER_CHECK([./calc input], $2, [], [stderr])])

 m4_bmatch([$1],
   [%debug.*%glr\|%glr.*%debug],
      [],
   [%debug],
 m4_bmatch([$1],
   [%debug.*%glr\|%glr.*%debug],
      [],
   [%debug],

-     [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
+     [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4

 ])])
 
 # Normalize the observed and expected error messages, depending upon the
 ])])
 
 # Normalize the observed and expected error messages, depending upon the


@@ -390,10 +398,10 @@ sed '/^Starting/d
 mv at-stderr stderr
 # 2. Create the reference error message.
 AT_DATA([[expout]],
 mv at-stderr stderr
 # 2. Create the reference error message.
 AT_DATA([[expout]],

-[$4
+[$5

 ])
 # 3. If locations are not used, remove them.
 ])
 # 3. If locations are not used, remove them.

-m4_bmatch([$1], [%locations], [],
+AT_YYERROR_SEES_LOC_IF([],

 [[sed 's/^[-0-9.]*: //' expout >at-expout
 mv at-expout expout]])
 # 4. If error-verbose is not used, strip the`, unexpected....' part.
 [[sed 's/^[-0-9.]*: //' expout >at-expout
 mv at-expout expout]])
 # 4. If error-verbose is not used, strip the`, unexpected....' part.


@@ -405,6 +413,55 @@ AT_CHECK([cat stderr], 0, [expout])
 ])
 
 
 ])
 
 

+# AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS])
+# -----------------------------------------
+# This macro works around the impossibility to define macros
+# inside macros, because issuing `[$1]' is not possible in M4 :(.
+# This sucks hard, GNU M4 should really provide M5 like $$1.
+m4_define([AT_CHECK_PUSHDEFS],
+[m4_if([$1$2], $[1]$[2], [],
+       [m4_fatal([$0: Invalid arguments: $@])])dnl
+m4_pushdef([AT_PARAM_IF],
+[m4_bmatch([$3], [%parse-param], [$1], [$2])])
+m4_pushdef([AT_LOCATION_IF],
+[m4_bmatch([$3], [%locations], [$1], [$2])])
+m4_pushdef([AT_PURE_IF],
+[m4_bmatch([$3], [%pure-parser], [$1], [$2])])
+m4_pushdef([AT_GLR_IF],
+[m4_bmatch([$3], [%glr-parser], [$1], [$2])])
+m4_pushdef([AT_PURE_AND_LOC_IF],
+[m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations],
+           [$1], [$2])])
+m4_pushdef([AT_GLR_OR_PARAM_IF],
+[m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
+
+# yyerror receives the location if %location & %pure & (%glr or %parse-param).
+m4_pushdef([AT_YYERROR_ARG_LOC_IF],
+[AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
+                    [$2])])
+# yyerror cannot see the locations if !glr & pure & !param.
+m4_pushdef([AT_YYERROR_SEES_LOC_IF],
+[AT_LOCATION_IF([AT_GLR_IF([$1],
+                           [AT_PURE_IF([AT_PARAM_IF([$1], [$2])],
+                                       [$1])])],
+                [$2])])
+])
+
+
+# AT_CALC_POPDEFS
+# ---------------
+m4_define([AT_CHECK_POPDEFS],
+[m4_popdef([AT_YYERROR_SEES_LOC_IF])
+m4_popdef([AT_YYERROR_ARG_LOC_IF])
+m4_popdef([AT_GLR_OR_PARAM_IF])
+m4_popdef([AT_PURE_AND_LOC_IF])
+m4_popdef([AT_GLR_IF])
+m4_popdef([AT_LOCATION_IF])
+m4_popdef([AT_PARAM_IF])
+])
+
+
+

 # AT_CHECK_CALC([BISON-OPTIONS])
 # ------------------------------
 # Start a testing chunk which compiles `calc' grammar with
 # AT_CHECK_CALC([BISON-OPTIONS])
 # ------------------------------
 # Start a testing chunk which compiles `calc' grammar with


@@ -413,10 +470,12 @@ m4_define([AT_CHECK_CALC],
 [# We use integers to avoid dependencies upon the precision of doubles.
 AT_SETUP([Calculator $1])
 
 [# We use integers to avoid dependencies upon the precision of doubles.
 AT_SETUP([Calculator $1])
 

+AT_CHECK_PUSHDEFS($[1], $[2], [$1])
+

 AT_DATA_CALC_Y([$1])
 
 # Specify the output files to avoid problems on different file systems.
 AT_DATA_CALC_Y([$1])
 
 # Specify the output files to avoid problems on different file systems.

-AT_CHECK([bison -o calc.c m4_bpatsubst([$1], [%[^ ]*]) calc.y],
+AT_CHECK([bison -o calc.c calc.y],

          [0], [], [])
 
 AT_COMPILE([calc])
          [0], [], [])
 
 AT_COMPILE([calc])


@@ -435,38 +494,36 @@ _AT_CHECK_CALC([$1],
 1 - (2 - 3) = 2
 
 2^2^3 = 256
 1 - (2 - 3) = 2
 
 2^2^3 = 256

-(2^2)^3 = 64], [486])
+(2^2)^3 = 64],
+               [486])

 
 # Some parse errors.
 
 # Some parse errors.

-_AT_CHECK_CALC_ERROR([$1], [0 0], [11],
+_AT_CHECK_CALC_ERROR([$1], [1], [0 0], [11],

                      [1.3-1.4: parse error, unexpected "number"])
                      [1.3-1.4: parse error, unexpected "number"])

-_AT_CHECK_CALC_ERROR([$1], [1//2], [15],
+_AT_CHECK_CALC_ERROR([$1], [1], [1//2], [15],

                      [1.3-1.4: parse error, unexpected '/', expecting "number" or '-' or '('])
                      [1.3-1.4: parse error, unexpected '/', expecting "number" or '-' or '('])

-_AT_CHECK_CALC_ERROR([$1], [error], [4],
+_AT_CHECK_CALC_ERROR([$1], [1], [error], [4],

                      [1.1-1.2: parse error, unexpected $undefined, expecting "number" or '-' or '\n' or '('])
                      [1.1-1.2: parse error, unexpected $undefined, expecting "number" or '-' or '\n' or '('])

-_AT_CHECK_CALC_ERROR([$1], [1 = 2 = 3], [22],
+_AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [22],

                      [1.7-1.8: parse error, unexpected '='])
                      [1.7-1.8: parse error, unexpected '='])

-_AT_CHECK_CALC_ERROR([$1],
+_AT_CHECK_CALC_ERROR([$1], [1],

                      [
 +1],
                      [14],
                      [2.1-2.2: parse error, unexpected '+'])
 # Exercise error messages with EOF: work on an empty file.
                      [
 +1],
                      [14],
                      [2.1-2.2: parse error, unexpected '+'])
 # Exercise error messages with EOF: work on an empty file.

-_AT_CHECK_CALC_ERROR([$1], [/dev/null], [4],
+_AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],

                      [1.1-1.2: parse error, unexpected "end of input", expecting "number" or '-' or '\n' or '('])
 
 # Exercise the error token: without it, we die at the first error,
 # hence be sure i. to have several errors, ii. to test the action
 # associated to `error'.
                      [1.1-1.2: parse error, unexpected "end of input", expecting "number" or '-' or '\n' or '('])
 
 # Exercise the error token: without it, we die at the first error,
 # hence be sure i. to have several errors, ii. to test the action
 # associated to `error'.

-_AT_CHECK_CALC_ERROR([$1], [(1 ++ 2) + (0 0) = 1], [82],
+_AT_CHECK_CALC_ERROR([$1], [0], [(1 ++ 2) + (0 0) = 1], [82],

 [1.5-1.6: parse error, unexpected '+', expecting "number" or '-' or '('
 1.15-1.16: parse error, unexpected "number"
 calc: error: 0 != 1])
 
 [1.5-1.6: parse error, unexpected '+', expecting "number" or '-' or '('
 1.15-1.16: parse error, unexpected "number"
 calc: error: 0 != 1])
 

-# Add a studid example demonstrating that Bison can further improve the
-# error message.  FIXME: Fix this ridiculous message.
-_AT_CHECK_CALC_ERROR([$1], [()], [21],
-[1.2-1.3: parse error, unexpected ')', expecting "number" or '-' or '('])
+AT_CHECK_POPDEFS

 
 AT_CLEANUP
 ])# AT_CHECK_CALC
 
 AT_CLEANUP
 ])# AT_CHECK_CALC


@@ -489,22 +546,23 @@ m4_define([AT_CHECK_CALC_LALR],
 
 AT_CHECK_CALC_LALR()
 
 
 AT_CHECK_CALC_LALR()
 

-AT_CHECK_CALC_LALR([--defines])
+AT_CHECK_CALC_LALR([%defines])

 AT_CHECK_CALC_LALR([%locations])
 AT_CHECK_CALC_LALR([%locations])

-AT_CHECK_CALC_LALR([--name-prefix=calc])
-AT_CHECK_CALC_LALR([--verbose])
-AT_CHECK_CALC_LALR([--yacc])
+AT_CHECK_CALC_LALR([%name-prefix="calc"])
+AT_CHECK_CALC_LALR([%verbose])
+AT_CHECK_CALC_LALR([%yacc])

 AT_CHECK_CALC_LALR([%error-verbose])
 
 AT_CHECK_CALC_LALR([%error-verbose %locations])
 
 AT_CHECK_CALC_LALR([%error-verbose])
 
 AT_CHECK_CALC_LALR([%error-verbose %locations])
 

-AT_CHECK_CALC_LALR([%error-verbose %locations --defines --name-prefix=calc --verbose --yacc])
+AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])

 
 AT_CHECK_CALC_LALR([%debug])
 
 AT_CHECK_CALC_LALR([%debug])

-AT_CHECK_CALC_LALR([%error-verbose %debug %locations --defines --name-prefix=calc --verbose --yacc])
+AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
+
+AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])

 
 

-# FIXME: Not ready yet.
-# AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations --defines --name-prefix=calc --verbose --yacc])
+AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value_t *result}, {result} %parse-param {int *count}, {count}])

 
 
 # ----------------------- #
 
 
 # ----------------------- #


@@ -523,18 +581,20 @@ m4_define([AT_CHECK_CALC_GLR],
 
 AT_CHECK_CALC_GLR()
 
 
 AT_CHECK_CALC_GLR()
 

-AT_CHECK_CALC_GLR([--defines])
+AT_CHECK_CALC_GLR([%defines])

 AT_CHECK_CALC_GLR([%locations])
 AT_CHECK_CALC_GLR([%locations])

-AT_CHECK_CALC_GLR([--name-prefix=calc])
-AT_CHECK_CALC_GLR([--verbose])
-AT_CHECK_CALC_GLR([--yacc])
+AT_CHECK_CALC_GLR([%name-prefix="calc"])
+AT_CHECK_CALC_GLR([%verbose])
+AT_CHECK_CALC_GLR([%yacc])

 AT_CHECK_CALC_GLR([%error-verbose])
 
 AT_CHECK_CALC_GLR([%error-verbose %locations])
 
 AT_CHECK_CALC_GLR([%error-verbose])
 
 AT_CHECK_CALC_GLR([%error-verbose %locations])
 

-AT_CHECK_CALC_GLR([%error-verbose %locations --defines --name-prefix=calc --verbose --yacc])
+AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])

 
 AT_CHECK_CALC_GLR([%debug])
 
 AT_CHECK_CALC_GLR([%debug])

-AT_CHECK_CALC_GLR([%error-verbose %debug %locations --defines --name-prefix=calc --verbose --yacc])
+AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
+
+AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])

 
 

-# AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations --defines --name-prefix=calc --verbose --yacc])
+AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value_t *result}, {result} %parse-param {int *count}, {count}])