Merge remote-tracking branch 'origin/maint'

[bison.git] / tests / calc.at

diff --git a/tests/calc.at b/tests/calc.at
index 5a19a8e590ed822bd0e65f239bb932e120ed4919..55b9154468ec56b63424a9df66d840100b8132fc 100644 (file)
--- a/tests/calc.at
+++ b/tests/calc.at
@@ -1,6 +1,6 @@
 # Simple calculator.                         -*- Autotest -*-
 
 # Simple calculator.                         -*- Autotest -*-
 

-# Copyright (C) 2000-2010 Free Software Foundation, Inc.
+# Copyright (C) 2000-2012 Free Software Foundation, Inc.

 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by


@@ -33,21 +33,90 @@
 # 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.
 # 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.

+#
+# When %defines is not passed, generate a single self-contained file.
+# Otherwise, generate three: calc.y with the parser, calc-lex.c with
+# the scanner, and calc-main.c with "main()".  This is in order to
+# stress the use of the generated parser header.  To avoid code
+# duplication, AT_CALC_LEX and AT_CALC_MAIN contain the body of these
+# two later files.

 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

+
+m4_pushdef([AT_CALC_MAIN],
+[#include <assert.h>
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#else
+# undef alarm
+# define alarm(seconds) /* empty */
+#endif
+
+AT_SKEL_CC_IF([[
+/* A C++ ]AT_NAME_PREFIX[parse that simulates the C signature.  */
+int
+]AT_NAME_PREFIX[parse (]AT_PARAM_IF([semantic_value *result, int *count]))[
+{
+  ]AT_NAME_PREFIX[::parser parser]AT_PARAM_IF([ (result, count)])[;
+#if YYDEBUG
+  parser.set_debug_level (1);
+#endif
+  return parser.parse ();
+}
+]])[
+
+semantic_value global_result = 0;
+int global_count = 0;
+
+/* A C main function.  */
+int
+main (int argc, const char **argv)
+{
+  semantic_value result = 0;
+  int count = 0;
+  int status;
+
+  /* This used to be alarm (10), but that isn't enough time for
+     a July 1995 vintage DEC Alphastation 200 4/100 system,
+     according to Nelson H. F. Beebe.  100 seconds is enough.  */
+  alarm (100);
+
+  if (argc == 2)
+    input = fopen (argv[1], "r");
+  else
+    input = stdin;
+
+  if (!input)
+    {
+      perror (argv[1]);
+      return 3;
+    }
+
+]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
+[  ]AT_NAME_PREFIX[debug = 1;])])[
+  status = ]AT_NAME_PREFIX[parse (]AT_PARAM_IF([[&result, &count]])[);
+  if (fclose (input))
+    perror ("fclose");
+  assert (global_result == result);
+  assert (global_count == count);
+  return status;
+}
+]])
+
+

 m4_pushdef([AT_CALC_LEX],
 [[#include <ctype.h>
 
 m4_pushdef([AT_CALC_LEX],
 [[#include <ctype.h>
 

-int ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[);
-static int get_char (]AT_LEX_FORMALS[);
-static void unget_char (]AT_LEX_PRE_FORMALS[ int c);
+]AT_YYLEX_DECLARE_EXTERN[
+static int get_char (]AT_YYLEX_FORMALS[);
+static void unget_char (]AT_YYLEX_PRE_FORMALS[ int c);

 
 ]AT_LOCATION_IF([
 static YYLTYPE last_yylloc;
 ])[
 static int
 
 ]AT_LOCATION_IF([
 static YYLTYPE last_yylloc;
 ])[
 static int

-get_char (]AT_LEX_FORMALS[)
+get_char (]AT_YYLEX_FORMALS[)

 {
   int res = getc (input);
   ]AT_USE_LEX_ARGS[;
 {
   int res = getc (input);
   ]AT_USE_LEX_ARGS[;


@@ -55,17 +124,17 @@ get_char (]AT_LEX_FORMALS[)
   last_yylloc = AT_LOC;
   if (res == '\n')
     {
   last_yylloc = AT_LOC;
   if (res == '\n')
     {

-      AT_LOC.last_line++;
-      AT_LOC.last_column = 1;
+      AT_LOC_LAST_LINE++;
+      AT_LOC_LAST_COLUMN = 1;

     }
   else
     }
   else

-    AT_LOC.last_column++;
+    AT_LOC_LAST_COLUMN++;

 ])[
   return res;
 }
 
 static void
 ])[
   return res;
 }
 
 static void

-unget_char (]AT_LEX_PRE_FORMALS[ int c)
+unget_char (]AT_YYLEX_PRE_FORMALS[ int c)

 {
   ]AT_USE_LEX_ARGS[;
 ]AT_LOCATION_IF([
 {
   ]AT_USE_LEX_ARGS[;
 ]AT_LOCATION_IF([


@@ -76,26 +145,26 @@ unget_char (]AT_LEX_PRE_FORMALS[ int c)
 }
 
 static int
 }
 
 static int

-read_signed_integer (]AT_LEX_FORMALS[)
+read_signed_integer (]AT_YYLEX_FORMALS[)

 {
 {

-  int c = get_char (]AT_LEX_ARGS[);
+  int c = get_char (]AT_YYLEX_ARGS[);

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

-      c = get_char (]AT_LEX_ARGS[);
+      c = get_char (]AT_YYLEX_ARGS[);

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

-      c = get_char (]AT_LEX_ARGS[);
+      c = get_char (]AT_YYLEX_ARGS[);

     }
 
     }
 

-  unget_char (]AT_LEX_PRE_ARGS[ c);
+  unget_char (]AT_YYLEX_PRE_ARGS[ c);

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


@@ -107,8 +176,7 @@ read_signed_integer (]AT_LEX_FORMALS[)
 | blanks and tabs, returns 0 for EOF.                            |
 `---------------------------------------------------------------*/
 
 | blanks and tabs, returns 0 for EOF.                            |
 `---------------------------------------------------------------*/
 

-int
-]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[)
+]AT_YYLEX_PROTOTYPE[

 {
   static int init = 1;
   int c;
 {
   static int init = 1;
   int c;


@@ -117,30 +185,26 @@ int
     {
       init = 0;
 ]AT_LOCATION_IF([
     {
       init = 0;
 ]AT_LOCATION_IF([

-      AT_LOC.last_column = 1;
-      AT_LOC.last_line = 1;
+      AT_LOC_LAST_COLUMN = 1;
+      AT_LOC_LAST_LINE = 1;

 ])[
     }
 
 ])[
     }
 

-]AT_LOCATION_IF([
- AT_LOC.first_column = AT_LOC.last_column;
-  AT_LOC.first_line   = AT_LOC.last_line;
-])[
-
-  /* Skip white space.  */
-  while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t')
+  /* Skip current token, then white spaces.  */
+  do

     {
 ]AT_LOCATION_IF(
     {
 ]AT_LOCATION_IF(

-[     AT_LOC.first_column = AT_LOC.last_column;
-      AT_LOC.first_line   = AT_LOC.last_line;
+[     AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
+      AT_LOC_FIRST_LINE   = AT_LOC_LAST_LINE;

 ])[
     }
 ])[
     }

+  while ((c = get_char (]AT_YYLEX_ARGS[)) == ' ' || c == '\t');

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

-      unget_char (]AT_LEX_PRE_ARGS[ c);
-      ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
+      unget_char (]AT_YYLEX_PRE_ARGS[ c);
+      ]AT_VAL[.ival = read_signed_integer (]AT_YYLEX_ARGS[);

       return ]AT_TOKEN_PREFIX[NUM;
     }
 
       return ]AT_TOKEN_PREFIX[NUM;
     }
 


@@ -158,9 +222,38 @@ AT_DATA_GRAMMAR([calc.y],
 ]$4
 AT_SKEL_CC_IF(
 [%define global_tokens_and_yystype])[
 ]$4
 AT_SKEL_CC_IF(
 [%define global_tokens_and_yystype])[

-%code requires {
-/* Exercise pre-prologue dependency to %union.  */
-typedef int semantic_value;
+%code requires
+{
+]AT_LOCATION_TYPE_IF([[
+# include <iostream>
+  struct Point
+  {
+    int l;
+    int c;
+  };
+
+  struct Span
+  {
+    Point first;
+    Point last;
+  };
+
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+  do                                                                    \
+    if (N)                                                              \
+      {                                                                 \
+        (Current).first = YYRHSLOC (Rhs, 1).first;                      \
+        (Current).last  = YYRHSLOC (Rhs, N).last;                       \
+      }                                                                 \
+    else                                                                \
+      {                                                                 \
+        (Current).first = (Current).last = YYRHSLOC (Rhs, 0).last;      \
+      }                                                                 \
+  while (false)
+
+]])[
+  /* Exercise pre-prologue dependency to %union.  */
+  typedef int semantic_value;

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


@@ -169,62 +262,53 @@ typedef int semantic_value;
   semantic_value ival;
 };
 
   semantic_value ival;
 };
 

-%code provides {
+%code provides
+{

 #include <stdio.h>
 /* The input.  */
 #include <stdio.h>
 /* The input.  */

-extern FILE *input;]AT_SKEL_CC_IF([[
+extern FILE *input;
+extern semantic_value global_result;
+extern int global_count;]AT_SKEL_CC_IF([[

 #ifndef YYLTYPE
 #ifndef YYLTYPE

-# define YYLTYPE ]AT_NAME_PREFIX[::location
+# define YYLTYPE ]AT_NAME_PREFIX[::parser::location_type

 #endif
 #endif

-#define first_line   begin.line
-#define first_column begin.column
-#define last_line    end.line
-#define last_column  end.column]])[
+]])[

 }
 
 }
 

-%code {
-#include <stdlib.h>
+%code
+{
+#include <assert.h>

 #include <string.h>
 #include <string.h>

-#if HAVE_UNISTD_H
-# include <unistd.h>
-#else
-# undef alarm
-# define alarm(seconds) /* empty */
-#endif

 #define USE(Var)
 
 FILE *input;
 #define USE(Var)
 
 FILE *input;

-static semantic_value global_result = 0;
-static int global_count = 0;

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

+

 ]AT_SKEL_CC_IF(,
 ]AT_SKEL_CC_IF(,

-[/* yyerror receives the location if:
-   - %location & %pure & %glr
-   - %location & %pure & %yacc & %parse-param. */
-static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
+[static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])

                      AT_PARAM_IF([semantic_value *result, int *count, ])
                      const char *s
                      );])[
                      AT_PARAM_IF([semantic_value *result, int *count, ])
                      const char *s
                      );])[

-int yylex (]AT_LEX_FORMALS[);
+]AT_YYLEX_DECLARE_EXTERN[

 }
 
 }
 

-]AT_SKEL_CC_IF([AT_LOCATION_IF([
+]AT_SKEL_CC_IF([AT_LOCATION_IF([AT_LOCATION_TYPE_IF([], [

 /* The lalr1.cc skeleton, for backward compatibility, defines
    a constructor for position that initializes the filename.  The
    glr.cc skeleton does not (and in fact cannot: location/position
    are stored in a union, from which objects with constructors are
    excluded in C++). */
 %initial-action {
 /* The lalr1.cc skeleton, for backward compatibility, defines
    a constructor for position that initializes the filename.  The
    glr.cc skeleton does not (and in fact cannot: location/position
    are stored in a union, from which objects with constructors are
    excluded in C++). */
 %initial-action {

-  @$.initialize (0);
+  @$.initialize ();

 }
 }

-])])[
+])])])[

 
 /* Bison Declarations */
 %token CALC_EOF 0 "end of input"
 %token <ival> NUM "number"
 %type  <ival> exp
 
 
 /* Bison Declarations */
 %token CALC_EOF 0 "end of input"
 %token <ival> NUM "number"
 %type  <ival> exp
 

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

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


@@ -263,25 +347,32 @@ exp:
 ;
 %%
 
 ;
 %%
 

-]AT_SKEL_CC_IF(
-[/* A C++ error reporting function.  */
-void
-AT_NAME_PREFIX::parser::error (AT_LOCATION_IF([const location& l, ])const std::string& m)
+static int
+power (int base, int exponent)

 {
 {

-  std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
+  int res = 1;
+  assert (0 <= exponent);
+  for (/* Niente */; exponent; --exponent)
+    res *= base;
+  return res;

 }
 
 }
 

-int
-yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
-{
-  AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
-#if YYDEBUG
-  parser.set_debug_level (1);
-#endif
-  return parser.parse ();
-}
-],
-[static void
+]AT_SKEL_CC_IF(
+[AT_LOCATION_TYPE_IF([[
+  std::ostream&
+  operator<< (std::ostream& o, const Span& s)
+  {
+    o << s.first.l << '.' << s.first.c;
+    if (s.first.l != s.last.l)
+      o << '-' << s.last.l << '.' << s.last.c - 1;
+    else if (s.first.c != s.last.c - 1)
+      o << '-' << s.last.c - 1;
+    return o;
+  }
+]])
+AT_YYERROR_DEFINE],
+[/* A C error reporting function.  */
+static void

 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
          AT_PARAM_IF([semantic_value *result, int *count, ])
          const char *s)
 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
          AT_PARAM_IF([semantic_value *result, int *count, ])
          const char *s)


@@ -289,69 +380,32 @@ yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
 AT_PARAM_IF([(void) result; (void) count;])
 AT_YYERROR_SEES_LOC_IF([
   fprintf (stderr, "%d.%d",
 AT_PARAM_IF([(void) result; (void) count;])
 AT_YYERROR_SEES_LOC_IF([
   fprintf (stderr, "%d.%d",

-           AT_LOC.first_line, AT_LOC.first_column);
-  if (AT_LOC.first_line != AT_LOC.last_line)
+           AT_LOC_FIRST_LINE, AT_LOC_FIRST_COLUMN);
+  if (AT_LOC_FIRST_LINE != AT_LOC_LAST_LINE)

     fprintf (stderr, "-%d.%d",
     fprintf (stderr, "-%d.%d",

-            AT_LOC.last_line,  AT_LOC.last_column - 1);
-  else if (AT_LOC.first_column != AT_LOC.last_column - 1)
+             AT_LOC_LAST_LINE,  AT_LOC_LAST_COLUMN - 1);
+  else if (AT_LOC_FIRST_COLUMN != AT_LOC_LAST_COLUMN - 1)

     fprintf (stderr, "-%d",
     fprintf (stderr, "-%d",

-            AT_LOC.last_column - 1);
+             AT_LOC_LAST_COLUMN - 1);

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

-]AT_DEFINES_IF(, [AT_CALC_LEX])[
-
-static int
-power (int base, int exponent)
-{
-  int res = 1;
-  if (exponent < 0)
-    exit (3);
-  for (/* Niente */; exponent; --exponent)
-    res *= base;
-  return res;
-}
-
-
-int
-main (int argc, const char **argv)
-{
-  semantic_value result = 0;
-  int count = 0;
-  int status;
-
-  /* This used to be alarm (10), but that isn't enough time for
-     a July 1995 vintage DEC Alphastation 200 4/100 system,
-     according to Nelson H. F. Beebe.  100 seconds is enough.  */
-  alarm (100);
-
-  if (argc == 2)
-    input = fopen (argv[1], "r");
-  else
-    input = stdin;
-
-  if (!input)
-    {
-      perror (argv[1]);
-      return 3;
-    }
-
-]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
-[  yydebug = 1;])])[
-  status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
-  fclose (input);
-  if (global_result != result)
-    abort ();
-  if (global_count != count)
-    abort ();
-  return status;
-}
+]AT_DEFINES_IF([],
+[AT_CALC_LEX
+AT_CALC_MAIN])[

 ]])
 ]])

+

 AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
 [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
 
 AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
 [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
 

-]AT_CALC_LEX])])
+]AT_CALC_LEX])
+AT_DATA_SOURCE([[calc-main.c]AT_SKEL_CC_IF([[c]])],
+[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
+
+]AT_CALC_MAIN])
+])
+m4_popdef([AT_CALC_MAIN])

 m4_popdef([AT_CALC_LEX])
 ])# _AT_DATA_CALC_Y
 
 m4_popdef([AT_CALC_LEX])
 ])# _AT_DATA_CALC_Y
 


@@ -450,21 +504,20 @@ AT_CHECK([cat stderr], 0, [expout])
 ])
 
 
 ])
 
 

-# AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
-# --------------------------------------------------
+# AT_CHECK_CALC([BISON-OPTIONS])
+# ------------------------------

 # Start a testing chunk which compiles `calc' grammar with
 # BISON-OPTIONS, and performs several tests over the parser.
 # Start a testing chunk which compiles `calc' grammar with
 # BISON-OPTIONS, and performs several tests over the parser.

-# However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.

 m4_define([AT_CHECK_CALC],
 m4_define([AT_CHECK_CALC],

-[# We use integers to avoid dependencies upon the precision of doubles.
-AT_SETUP([Calculator $1])
+[m4_ifval([$2], [m4_fatal([$0: expected a single argument])])

 
 

-m4_ifval([$2], [AT_CHECK([exit 77])])
+# We use integers to avoid dependencies upon the precision of doubles.
+AT_SETUP([Calculator $1])

 
 AT_BISON_OPTION_PUSHDEFS([$1])
 
 AT_DATA_CALC_Y([$1])
 
 AT_BISON_OPTION_PUSHDEFS([$1])
 
 AT_DATA_CALC_Y([$1])

-AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
+AT_FULL_COMPILE([calc], AT_DEFINES_IF([[lex], [main]]))

 
 # Test the priorities.
 _AT_CHECK_CALC([$1],
 
 # Test the priorities.
 _AT_CHECK_CALC([$1],


@@ -568,6 +621,7 @@ AT_CHECK_CALC_LALR()
 
 AT_CHECK_CALC_LALR([%defines])
 AT_CHECK_CALC_LALR([%locations])
 
 AT_CHECK_CALC_LALR([%defines])
 AT_CHECK_CALC_LALR([%locations])

+

 AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
 AT_CHECK_CALC_LALR([%verbose])
 AT_CHECK_CALC_LALR([%yacc])
 AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
 AT_CHECK_CALC_LALR([%verbose])
 AT_CHECK_CALC_LALR([%yacc])


@@ -644,6 +698,7 @@ m4_define([AT_CHECK_CALC_LALR1_CC],
 
 AT_CHECK_CALC_LALR1_CC([])
 AT_CHECK_CALC_LALR1_CC([%locations])
 
 AT_CHECK_CALC_LALR1_CC([])
 AT_CHECK_CALC_LALR1_CC([%locations])

+AT_CHECK_CALC_LALR1_CC([%locations %define location_type Span])

 AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
 
 AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
 AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
 
 AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])


@@ -672,6 +727,7 @@ m4_define([AT_CHECK_CALC_GLR_CC],
 [AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
 
 AT_CHECK_CALC_GLR_CC([])
 [AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
 
 AT_CHECK_CALC_GLR_CC([])

+AT_CHECK_CALC_GLR_CC([%define location_type Span])

 AT_CHECK_CALC_GLR_CC([%define parse.error verbose %name-prefix "calc" %verbose %yacc])
 
 AT_CHECK_CALC_GLR_CC([%debug])
 AT_CHECK_CALC_GLR_CC([%define parse.error verbose %name-prefix "calc" %verbose %yacc])
 
 AT_CHECK_CALC_GLR_CC([%debug])