* src/reader.c (copy_dollar): New function.

[bison.git] / tests / calc.m4

diff --git a/tests/calc.m4 b/tests/calc.m4
index c365924ff921ff1c1eff9f506bfa971d2f499de8..a875620606e9f1b048165e5fa9bf6bc177952239 100644 (file)
--- a/tests/calc.m4
+++ b/tests/calc.m4
@@ -17,30 +17,36 @@ EOF
 # ------------------------- #
 
 
 # ------------------------- #
 
 

-# _AT_DATA_CALC_Y($1, $2, $3)
-# ---------------------------
+# _AT_DATA_CALC_Y($1, $2, $3, [CPP-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
 # AT_DATA_CALC_Y does.
 AT_DEFINE([_AT_DATA_CALC_Y],
 # 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
 # AT_DATA_CALC_Y does.
 AT_DEFINE([_AT_DATA_CALC_Y],

-[AT_DATA([calc.y],
+[ifelse([$1$2$3],
+        $[1]$[2]$[3], [],
+        [errprint([$0: Invalid arguments: $@
+])m4exit(1)])dnl
+AT_DATA([calc.y],

 [[/* Infix notation calculator--calc */
 
 %{
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 [[/* Infix notation calculator--calc */
 
 %{
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>

-#define YYSTYPE int
+]$4[

 
 static int power (int base, int exponent);
 
 static int power (int base, int exponent);

-static int read_signed_integer (FILE *stream);

 static void yyerror (const char *s);
 static void yyerror (const char *s);

+static int yylex (void);

 extern void perror (const char *s);
 %}
 
 /* BISON Declarations */
 %token NUM
 extern void perror (const char *s);
 %}
 
 /* BISON Declarations */
 %token NUM

+
+%nonassoc '=' /* comparison           */

 %left '-' '+'
 %left '*' '/'
 %left NEG     /* negation--unary minus */
 %left '-' '+'
 %left '*' '/'
 %left NEG     /* negation--unary minus */


@@ -48,22 +54,31 @@ extern void perror (const char *s);
 
 /* Grammar follows */
 %%
 
 /* Grammar follows */
 %%

-input:    /* empty string */
-        | input line
+input:
+  /* empty string */
+| input line

 ;
 
 ;
 

-line:     '\n'
-        | exp '\n'  { printf ("%d", $1);     }
+line:
+  '\n'
+| exp '\n'

 ;
 
 ;
 

-exp:      NUM                { $$ = $1;             }
-        | exp '+' exp        { $$ = $1 + $3;        }
-        | exp '-' exp        { $$ = $1 - $3;        }
-        | exp '*' exp        { $$ = $1 * $3;        }
-        | exp '/' exp        { $$ = $1 / $3;        }
-        | '-' exp  %prec NEG { $$ = -$2;            }
-        | exp '^' exp        { $$ = power ($1, $3); }
-        | '(' exp ')'        { $$ = $2;             }
+exp:
+  NUM                { $$ = $1;             }
+| exp '=' exp
+  {
+     if ($1 != $3)
+       printf ("calc: error: %d != %d\n", $1, $3);
+     $$ = $1 == $3;
+  }
+| exp '+' exp        { $$ = $1 + $3;        }
+| exp '-' exp        { $$ = $1 - $3;        }
+| exp '*' exp        { $$ = $1 * $3;        }
+| exp '/' exp        { $$ = $1 / $3;        }
+| '-' exp  %prec NEG { $$ = -$2;            }
+| exp '^' exp        { $$ = power ($1, $3); }
+| '(' exp ')'        { $$ = $2;             }

 ;
 %%
 /* The input. */
 ;
 %%
 /* The input. */


@@ -72,57 +87,104 @@ FILE *yyin;
 static void
 yyerror (const char *s)
 {
 static void
 yyerror (const char *s)
 {

+#ifdef YYLSP_NEEDED
+  fprintf (stderr, "%d.%d:%d.%d: ",
+          yylloc.first_line, yylloc.first_column,
+          yylloc.last_line, yylloc.last_column);
+#endif

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

-read_signed_integer (FILE *stream)
+yygetc ()
+{
+  int res = getc (yyin);
+#ifdef YYLSP_NEEDED
+  if (res == '\n')
+    {
+      yylloc.last_line++;
+      yylloc.last_column = 0;
+    }
+  else
+    yylloc.last_column++;
+#endif
+  return res;
+}
+
+
+static void
+yyungetc (int c)
+{
+#ifdef YYLSP_NEEDED
+  /* Wrong when C == `\n'. */
+  yylloc.last_column--;
+#endif
+  ungetc (c, yyin);
+}
+
+static int
+read_signed_integer (void)

 {
 {

-  int c = getc (stream);
+  int c = yygetc ();

   int sign = 1;
   int n = 0;
 
   if (c == '-')
     {
   int sign = 1;
   int n = 0;
 
   if (c == '-')
     {

-      c = getc (stream);
+      c = yygetc ();

       sign = -1;
     }
 
   while (isdigit (c))
     {
       n = 10 * n + (c - '0');
       sign = -1;
     }
 
   while (isdigit (c))
     {
       n = 10 * n + (c - '0');

-      c = getc (stream);
+      c = yygetc ();

     }
 
     }
 

-  ungetc (c, stream);
+  yyungetc (c);

 
   return sign * n;
 }
 
 
   return sign * n;
 }
 

+
+

 /*---------------------------------------------------------------.
 | Lexical analyzer returns an integer on the stack and the token |
 | NUM, or the ASCII character read if not a number.  Skips all   |
 | blanks and tabs, returns 0 for EOF.                            |
 `---------------------------------------------------------------*/
 
 /*---------------------------------------------------------------.
 | Lexical analyzer returns an integer on the stack and the token |
 | NUM, or the ASCII character read if not a number.  Skips all   |
 | blanks and tabs, returns 0 for EOF.                            |
 `---------------------------------------------------------------*/
 

-int
-yylex ()
+static int
+yylex (void)

 {
   int c;
 
 {
   int c;
 

+#ifdef YYLSP_NEEDED
+  yylloc.first_column = yylloc.last_column;
+  yylloc.first_line = yylloc.last_line;
+#endif
+

   /* Skip white space.  */
   /* Skip white space.  */

-  while ((c = getc (yyin)) == ' ' || c == '\t')
-    ;
+  while ((c = yygetc ()) == ' ' || c == '\t')
+    {
+#ifdef YYLSP_NEEDED
+      yylloc.first_column = yylloc.last_column;
+      yylloc.first_line = yylloc.last_line;
+#endif
+    }
+

   /* process numbers   */
   if (c == '.' || isdigit (c))
     {
   /* process numbers   */
   if (c == '.' || isdigit (c))
     {

-      ungetc (c, yyin);
-      yylval = read_signed_integer (yyin);
+      yyungetc (c);
+      yylval = read_signed_integer ();

       return NUM;
     }
       return NUM;
     }

+

   /* Return end-of-file.  */
   if (c == EOF)
     return 0;
   /* Return end-of-file.  */
   if (c == EOF)
     return 0;

+

   /* Return single chars. */
   return c;
 }
   /* Return single chars. */
   return c;
 }


@@ -144,7 +206,7 @@ main (int argn, const char **argv)
   if (argn == 2)
     yyin = fopen (argv[1], "r");
   else
   if (argn == 2)
     yyin = fopen (argv[1], "r");
   else

-     yyin = stdin;
+    yyin = stdin;

 
   if (!stdin)
     {
 
   if (!stdin)
     {


@@ -154,6 +216,10 @@ main (int argn, const char **argv)
 
 #if YYDEBUG
   yydebug = 1;
 
 #if YYDEBUG
   yydebug = 1;

+#endif
+#ifdef YYLSP_NEEDED
+  yylloc.last_column = 0;
+  yylloc.last_line = 1;

 #endif
   yyparse ();
   return 0;
 #endif
   yyparse ();
   return 0;


@@ -162,68 +228,122 @@ main (int argn, const char **argv)
 ])# _AT_DATA_CALC_Y
 
 
 ])# _AT_DATA_CALC_Y
 
 

-# AT_DATA_CALC_Y
-# --------------
+# AT_DATA_CALC_Y([BISON-OPTIONS])
+# -------------------------------

 # Produce `calc.y'.
 AT_DEFINE([AT_DATA_CALC_Y],
 # Produce `calc.y'.
 AT_DEFINE([AT_DATA_CALC_Y],

-[_AT_DATA_CALC_Y($[1], $[2], $[3])])
+[_AT_DATA_CALC_Y($[1], $[2], $[3],
+                 [ifelse(regexp([$1], [--yyerror-verbose]),
+                         [-1], [],
+                         [[#define YYERROR_VERBOSE]])])])

 
 
 
 

-# _AT_CHECK_CALC(INPUT, OUTPUT, [STDERR])
-# ---------------------------------------
-# Run `calc' on INPUT, and expect OUTPUT and STDERR.
-AT_DEFINE([_AT_CHECK_CALC],
-[AT_CHECK([echo "$1" | calc], 0, [$2], [$3])])
-

 
 

-# AT_CHECK_CALC(TITLE, [BISON-OPTIONS], [PARSER-EXPECTED-STDERR])
-# ---------------------------------------------------------------
-# Start a testing chunk named TITLE which compiles `calc' grammar with
+# _AT_CHECK_CALC(BISON-OPTIONS, INPUT)
+# ------------------------------------
+# Run `calc' on INPUT and expect no STDOUT nor STDERR.
+# If `--debug' is passed to bison, discard all the debugging traces
+# preserving only the `parse errors'.  Note that since there should be
+# none, the `grep' will fail with exit status 1.
+AT_DEFINE([_AT_CHECK_CALC],
+[ifelse(regexp([$1], [--debug]),
+  [-1],
+     [AT_CHECK([echo "$2" | calc],
+               [0], [], [])],
+     [AT_CHECK([echo "$2" | calc 2>&1 >/dev/null | grep 'parse error' >&2],
+               [1], [], [])])])
+
+
+# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, INPUT,
+#                      [ERROR-LOCATION], [IF-YYERROR-VERBOSE])
+# ------------------------------------------------------------
+# Run `calc' on INPUT, and expect STDERR.
+AT_DEFINE([_AT_CHECK_CALC_ERROR],
+[AT_CHECK([echo "$2" | calc 2>&1 >/dev/null | grep 'parse error' >&2], 0,
+          [],
+[ifelse(regexp([$1], [--location]),
+        [-1], [], [$3: ])[]dnl
+parse error[]dnl
+ifelse(regexp([$1], [--yyerror-verbose]),
+       [-1], [], [$4])[]dnl
+
+])])
+
+
+# AT_CHECK_CALC([BISON-OPTIONS], [PARSER-EXPECTED-STDERR])
+# --------------------------------------------------------
+# Start a testing chunk which compiles `calc' grammar with

 # BISON-OPTIONS, and performs several tests over the parser.
 AT_DEFINE([AT_CHECK_CALC],
 [# We use integers to avoid dependencies upon the precision of doubles.
 # BISON-OPTIONS, and performs several tests over the parser.
 AT_DEFINE([AT_CHECK_CALC],
 [# We use integers to avoid dependencies upon the precision of doubles.

-AT_SETUP([$1])
+AT_SETUP([Calculator $1])

 
 

-AT_DATA_CALC_Y
+AT_DATA_CALC_Y([$1])

 
 # Specify the output files to avoid problems on different file systems.
 
 # Specify the output files to avoid problems on different file systems.

-AT_CHECK([bison calc.y -o calc.c $2], 0, [], [])
+AT_CHECK([bison calc.y -o calc.c patsubst([$1], [--yyerror-verbose])],
+         [0], [], [])

 AT_CHECK([$CC $CFLAGS calc.c -o calc], 0, [], [])
 
 # Test the priorities.
 AT_CHECK([$CC $CFLAGS calc.c -o calc], 0, [], [])
 
 # Test the priorities.

-_AT_CHECK_CALC([1 + 2 * 3],   [7], [$3])
-_AT_CHECK_CALC([1 + 2 * -3], [-5], [$3])
-
-_AT_CHECK_CALC([-1^2],  [-1], [$3])
-_AT_CHECK_CALC([(-1)^2], [1], [$3])
-
-_AT_CHECK_CALC([---1], [-1], [$3])
-
-_AT_CHECK_CALC([1 - 2 - 3],  [-4], [$3])
-_AT_CHECK_CALC([1 - (2 - 3)], [2], [$3])
-
-_AT_CHECK_CALC([2^2^3],  [256], [$3])
-_AT_CHECK_CALC([(2^2)^3], [64], [$3])
-
-AT_CLEANUP(calc calc.c)
+_AT_CHECK_CALC([$1],
+[1 + 2 * 3 = 7
+1 + 2 * -3 = -5
+
+-1^2 = -1
+(-1)^2 = 1
+
+---1 = -1
+
+1 - 2 - 3 = -4
+1 - (2 - 3) = 2
+
+2^2^3 = 256
+(2^2)^3 = 64], [$2])
+
+# Some parse errors.
+_AT_CHECK_CALC_ERROR([$1], [+1],
+                     [1.0:1.1],
+                     [, unexpected `'+''])
+_AT_CHECK_CALC_ERROR([$1], [1//2],
+                     [1.2:1.3],
+                     [, unexpected `'/'', expecting `NUM' or `'-'' or `'(''])
+_AT_CHECK_CALC_ERROR([$1], [error],
+                     [1.0:1.1],
+                     [, unexpected `$undefined.'])
+_AT_CHECK_CALC_ERROR([$1], [1 = 2 = 3],
+                     [1.6:1.7],
+                     [, unexpected `'=''])
+_AT_CHECK_CALC_ERROR([$1],
+                     [
++1],
+                     [2.0:2.1],
+                     [, unexpected `'+''])
+
+AT_CLEANUP(calc calc.c calc.h calc.output)

 ])# AT_CHECK_CALC
 
 
 ])# AT_CHECK_CALC
 
 

-# -------------- #
-# Actual tests.  #
-# -------------- #

 
 
 
 

-AT_CHECK_CALC([Simple calculator])
+# ------------------ #
+# Test the parsers.  #
+# ------------------ #
+
+AT_CHECK_CALC()
+# This one is very suspicious.  The test fails, but it might be normal.
+AT_CHECK_CALC([--raw])

 
 

-AT_CHECK_CALC([Simple Yacc compatible calculator],
-              [--yacc])
+AT_CHECK_CALC([--defines])
+AT_CHECK_CALC([--locations])
+AT_CHECK_CALC([--name-prefix=calc])
+AT_CHECK_CALC([--verbose])
+AT_CHECK_CALC([--yacc])
+AT_CHECK_CALC([--yyerror-verbose])

 
 

-AT_CHECK_CALC([Simple calculator whose tokens are numbered from 3],
-              [--raw])
+AT_CHECK_CALC([--locations --yyerror-verbose])

 
 

-AT_CHECK_CALC([Simple debugging calculator],
-              [--debug], ignore)
+AT_CHECK_CALC([--defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose])

 
 

-AT_CHECK_CALC([Simple Yacc compatible debugging calculator],
-              [--debug --yacc], ignore)
+AT_CHECK_CALC([--debug])
+AT_CHECK_CALC([--debug --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose])