tests/calc.at

   1 # Simple calculator.                         -*- Autotest -*-
   2
   3 # Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free
   4 # Software Foundation, Inc.
   5
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 ## ---------------------------------------------------- ##
  20 ## Compile the grammar described in the documentation.  ##
  21 ## ---------------------------------------------------- ##
  22
  23
  24 # ------------------------- #
  25 # Helping Autotest macros.  #
  26 # ------------------------- #
  27
  28
  29 # _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
  30 # -----------------------------------------------
  31 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
  32 # `calc-lex.cc'.
  33 #
  34 # Don't call this macro directly, because it contains some occurrences
  35 # of `$1' etc. which will be interpreted by m4.  So you should call it
  36 # with $1, $2, and $3 as arguments, which is what AT_DATA_CALC_Y does.
  37 m4_define([_AT_DATA_CALC_Y],
  38 [m4_if([$1$2$3], $[1]$[2]$[3], [],
  39        [m4_fatal([$0: Invalid arguments: $@])])dnl
  40 m4_pushdef([AT_CALC_LEX],
  41 [[#include <ctype.h>
  42
  43 int ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[);
  44 static int get_char (]AT_LEX_FORMALS[);
  45 static void unget_char (]AT_LEX_PRE_FORMALS[ int c);
  46
  47 ]AT_LOCATION_IF([
  48 static YYLTYPE last_yylloc;
  49 ])[
  50 static int
  51 get_char (]AT_LEX_FORMALS[)
  52 {
  53   int res = getc (input);
  54   ]AT_USE_LEX_ARGS[;
  55 ]AT_LOCATION_IF([
  56   last_yylloc = AT_LOC;
  57   if (res == '\n')
  58     {
  59       AT_LOC.last_line++;
  60       AT_LOC.last_column = 1;
  61     }
  62   else
  63     AT_LOC.last_column++;
  64 ])[
  65   return res;
  66 }
  67
  68 static void
  69 unget_char (]AT_LEX_PRE_FORMALS[ int c)
  70 {
  71   ]AT_USE_LEX_ARGS[;
  72 ]AT_LOCATION_IF([
  73   /* Wrong when C == `\n'. */
  74   AT_LOC = last_yylloc;
  75 ])[
  76   ungetc (c, input);
  77 }
  78
  79 static int
  80 read_signed_integer (]AT_LEX_FORMALS[)
  81 {
  82   int c = get_char (]AT_LEX_ARGS[);
  83   int sign = 1;
  84   int n = 0;
  85
  86   ]AT_USE_LEX_ARGS[;
  87   if (c == '-')
  88     {
  89       c = get_char (]AT_LEX_ARGS[);
  90       sign = -1;
  91     }
  92
  93   while (isdigit (c))
  94     {
  95       n = 10 * n + (c - '0');
  96       c = get_char (]AT_LEX_ARGS[);
  97     }
  98
  99   unget_char (]AT_LEX_PRE_ARGS[ c);
 100
 101   return sign * n;
 102 }
 103
 104
 105 /*---------------------------------------------------------------.
 106 | Lexical analyzer returns an integer on the stack and the token |
 107 | NUM, or the ASCII character read if not a number.  Skips all   |
 108 | blanks and tabs, returns 0 for EOF.                            |
 109 `---------------------------------------------------------------*/
 110
 111 int
 112 ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[)
 113 {
 114   static int init = 1;
 115   int c;
 116
 117   if (init)
 118     {
 119       init = 0;
 120 ]AT_LOCATION_IF([
 121       AT_LOC.last_column = 1;
 122       AT_LOC.last_line = 1;
 123 ])[
 124     }
 125
 126 ]AT_LOCATION_IF([
 127  AT_LOC.first_column = AT_LOC.last_column;
 128   AT_LOC.first_line   = AT_LOC.last_line;
 129 ])[
 130
 131   /* Skip white space.  */
 132   while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t')
 133     {
 134 ]AT_LOCATION_IF(
 135 [     AT_LOC.first_column = AT_LOC.last_column;
 136       AT_LOC.first_line   = AT_LOC.last_line;
 137 ])[
 138     }
 139
 140   /* process numbers   */
 141   if (c == '.' || isdigit (c))
 142     {
 143       unget_char (]AT_LEX_PRE_ARGS[ c);
 144       ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
 145       return ]AT_TOKEN_PREFIX[NUM;
 146     }
 147
 148   /* Return end-of-file.  */
 149   if (c == EOF)
 150     return ]AT_TOKEN_PREFIX[CALC_EOF;
 151
 152   /* Return single chars. */
 153   return c;
 154 }
 155 ]])
 156
 157 AT_DATA_GRAMMAR([calc.y],
 158 [[/* Infix notation calculator--calc */
 159 ]$4
 160 AT_SKEL_CC_IF(
 161 [%define global_tokens_and_yystype])[
 162 %code requires {
 163 /* Exercise pre-prologue dependency to %union.  */
 164 typedef int semantic_value;
 165 }
 166
 167 /* Exercise %union. */
 168 %union
 169 {
 170   semantic_value ival;
 171 };
 172
 173 %code provides {
 174 #include <stdio.h>
 175 /* The input.  */
 176 extern FILE *input;]AT_SKEL_CC_IF([[
 177 #ifndef YYLTYPE
 178 # define YYLTYPE ]AT_NAME_PREFIX[::location
 179 #endif
 180 #define first_line   begin.line
 181 #define first_column begin.column
 182 #define last_line    end.line
 183 #define last_column  end.column]])[
 184 }
 185
 186 %code {
 187 #include <stdlib.h>
 188 #include <string.h>
 189 #if HAVE_UNISTD_H
 190 # include <unistd.h>
 191 #else
 192 # undef alarm
 193 # define alarm(seconds) /* empty */
 194 #endif
 195 #define USE(Var)
 196
 197 FILE *input;
 198 static semantic_value global_result = 0;
 199 static int global_count = 0;
 200 static int power (int base, int exponent);
 201 ]AT_SKEL_CC_IF(,
 202 [/* yyerror receives the location if:
 203    - %location & %pure & %glr
 204    - %location & %pure & %yacc & %parse-param. */
 205 static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
 206                      AT_PARAM_IF([semantic_value *result, int *count, ])
 207                      const char *s
 208                      );])[
 209 int yylex (]AT_LEX_FORMALS[);
 210 }
 211
 212 ]AT_SKEL_CC_IF([AT_LOCATION_IF([
 213 /* The lalr1.cc skeleton, for backward compatibility, defines
 214    a constructor for position that initializes the filename.  The
 215    glr.cc skeleton does not (and in fact cannot: location/position
 216    are stored in a union, from which objects with constructors are
 217    excluded in C++). */
 218 %initial-action {
 219   @$.initialize (0);
 220 }
 221 ])])[
 222
 223 /* Bison Declarations */
 224 %token CALC_EOF 0 "end of input"
 225 %token <ival> NUM "number"
 226 %type  <ival> exp
 227
 228 %nonassoc '='   /* comparison          */
 229 %left '-' '+'
 230 %left '*' '/'
 231 %precedence NEG /* negation--unary minus */
 232 %right '^'      /* exponentiation        */
 233
 234 /* Grammar follows */
 235 %%
 236 input:
 237   line
 238 | input line         { ]AT_PARAM_IF([++*count; ++global_count;])[ }
 239 ;
 240
 241 line:
 242   '\n'
 243 | exp '\n'           { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
 244 ;
 245
 246 exp:
 247   NUM                { $$ = $1;             }
 248 | exp '=' exp
 249   {
 250     if ($1 != $3)
 251       fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
 252     $$ = $1;
 253   }
 254 | exp '+' exp        { $$ = $1 + $3;        }
 255 | exp '-' exp        { $$ = $1 - $3;        }
 256 | exp '*' exp        { $$ = $1 * $3;        }
 257 | exp '/' exp        { $$ = $1 / $3;        }
 258 | '-' exp  %prec NEG { $$ = -$2;            }
 259 | exp '^' exp        { $$ = power ($1, $3); }
 260 | '(' exp ')'        { $$ = $2;             }
 261 | '(' error ')'      { $$ = 1111; yyerrok;  }
 262 | '!'                { $$ = 0; YYERROR;     }
 263 | '-' error          { $$ = 0; YYERROR;     }
 264 ;
 265 %%
 266
 267 ]AT_SKEL_CC_IF(
 268 [/* A C++ error reporting function.  */
 269 void
 270 AT_NAME_PREFIX::parser::error (AT_LOCATION_IF([const location& l, ])const std::string& m)
 271 {
 272   std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
 273 }
 274
 275 int
 276 yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
 277 {
 278   AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
 279 #if YYDEBUG
 280   parser.set_debug_level (1);
 281 #endif
 282   return parser.parse ();
 283 }
 284 ],
 285 [static void
 286 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
 287          AT_PARAM_IF([semantic_value *result, int *count, ])
 288          const char *s)
 289 {
 290 AT_PARAM_IF([(void) result; (void) count;])
 291 AT_YYERROR_SEES_LOC_IF([
 292   fprintf (stderr, "%d.%d",
 293            AT_LOC.first_line, AT_LOC.first_column);
 294   if (AT_LOC.first_line != AT_LOC.last_line)
 295     fprintf (stderr, "-%d.%d",
 296              AT_LOC.last_line,  AT_LOC.last_column - 1);
 297   else if (AT_LOC.first_column != AT_LOC.last_column - 1)
 298     fprintf (stderr, "-%d",
 299              AT_LOC.last_column - 1);
 300   fprintf (stderr, ": ");])
 301   fprintf (stderr, "%s\n", s);
 302 }])[
 303
 304 ]AT_DEFINES_IF(, [AT_CALC_LEX])[
 305
 306 static int
 307 power (int base, int exponent)
 308 {
 309   int res = 1;
 310   if (exponent < 0)
 311     exit (3);
 312   for (/* Niente */; exponent; --exponent)
 313     res *= base;
 314   return res;
 315 }
 316
 317
 318 int
 319 main (int argc, const char **argv)
 320 {
 321   semantic_value result = 0;
 322   int count = 0;
 323   int status;
 324
 325   /* This used to be alarm (10), but that isn't enough time for
 326      a July 1995 vintage DEC Alphastation 200 4/100 system,
 327      according to Nelson H. F. Beebe.  100 seconds is enough.  */
 328   alarm (100);
 329
 330   if (argc == 2)
 331     input = fopen (argv[1], "r");
 332   else
 333     input = stdin;
 334
 335   if (!input)
 336     {
 337       perror (argv[1]);
 338       return 3;
 339     }
 340
 341 ]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
 342 [  yydebug = 1;])])[
 343   status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
 344   fclose (input);
 345   if (global_result != result)
 346     abort ();
 347   if (global_count != count)
 348     abort ();
 349   return status;
 350 }
 351 ]])
 352 AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
 353 [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
 354
 355 ]AT_CALC_LEX])])
 356 m4_popdef([AT_CALC_LEX])
 357 ])# _AT_DATA_CALC_Y
 358
 359
 360 # AT_DATA_CALC_Y([BISON-OPTIONS])
 361 # -------------------------------
 362 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
 363 # `calc-lex.cc'.
 364 m4_define([AT_DATA_CALC_Y],
 365 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
 366 ])
 367
 368
 369
 370 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
 371 # --------------------------------------------------------
 372 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
 373 #
 374 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
 375 #
 376 # NUM-STDERR-LINES is the number of expected lines on stderr.
 377 # Currently this is ignored, though, since the output format is fluctuating.
 378 #
 379 # We don't count GLR's traces yet, since its traces are somewhat
 380 # different from LALR's.
 381 m4_define([_AT_CHECK_CALC],
 382 [AT_DATA([[input]],
 383 [[$2
 384 ]])
 385 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
 386 ])
 387
 388
 389 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
 390 #                      [NUM-STDERR-LINES],
 391 #                      [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
 392 # ---------------------------------------------------------
 393 # Run `calc' on INPUT, and expect a `syntax error' message.
 394 #
 395 # If INPUT starts with a slash, it is used as absolute input file name,
 396 # otherwise as contents.
 397 #
 398 # NUM-STDERR-LINES is the number of expected lines on stderr.
 399 # Currently this is ignored, though, since the output format is fluctuating.
 400 #
 401 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
 402 # is correctly output on stderr.
 403 #
 404 # If BISON-OPTIONS contains `%error-verbose', then make sure the
 405 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
 406 # on STDERR.
 407 #
 408 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 409 # is the number of expected lines on stderr.
 410 m4_define([_AT_CHECK_CALC_ERROR],
 411 [m4_bmatch([$3], [^/],
 412            [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
 413            [AT_DATA([[input]],
 414 [[$3
 415 ]])
 416 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
 417
 418 # Normalize the observed and expected error messages, depending upon the
 419 # options.
 420 # 1. Remove the traces from observed.
 421 sed '/^Starting/d
 422 /^Entering/d
 423 /^Stack/d
 424 /^Reading/d
 425 /^Reducing/d
 426 /^Return/d
 427 /^Shifting/d
 428 /^state/d
 429 /^Cleanup:/d
 430 /^Error:/d
 431 /^Next/d
 432 /^Now/d
 433 /^Discarding/d
 434 / \$[[0-9$]]* = /d
 435 /^yydestructor:/d' stderr >at-stderr
 436 mv at-stderr stderr
 437 # 2. Create the reference error message.
 438 AT_DATA([[expout]],
 439 [$5
 440 ])
 441 # 3. If locations are not used, remove them.
 442 AT_YYERROR_SEES_LOC_IF([],
 443 [[sed 's/^[-0-9.]*: //' expout >at-expout
 444 mv at-expout expout]])
 445 # 4. If error-verbose is not used, strip the`, unexpected....' part.
 446 m4_bmatch([$1], [%error-verbose], [],
 447 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
 448 mv at-expout expout]])
 449 # 5. Check
 450 AT_CHECK([cat stderr], 0, [expout])
 451 ])
 452
 453
 454 # AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
 455 # --------------------------------------------------
 456 # Start a testing chunk which compiles `calc' grammar with
 457 # BISON-OPTIONS, and performs several tests over the parser.
 458 # However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
 459 m4_define([AT_CHECK_CALC],
 460 [# We use integers to avoid dependencies upon the precision of doubles.
 461 AT_SETUP([Calculator $1])
 462
 463 m4_ifval([$2], [AT_CHECK([exit 77])])
 464
 465 AT_BISON_OPTION_PUSHDEFS([$1])
 466
 467 AT_DATA_CALC_Y([$1])
 468 AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
 469
 470 # Test the priorities.
 471 _AT_CHECK_CALC([$1],
 472 [1 + 2 * 3 = 7
 473 1 + 2 * -3 = -5
 474
 475 -1^2 = -1
 476 (-1)^2 = 1
 477
 478 ---1 = -1
 479
 480 1 - 2 - 3 = -4
 481 1 - (2 - 3) = 2
 482
 483 2^2^3 = 256
 484 (2^2)^3 = 64],
 485                [842])
 486
 487 # Some syntax errors.
 488 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
 489                      [1.3: syntax error, unexpected number])
 490 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
 491                      [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
 492 _AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
 493                      [1.1: syntax error, unexpected $undefined])
 494 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
 495                      [1.7: syntax error, unexpected '='])
 496 _AT_CHECK_CALC_ERROR([$1], [1],
 497                      [
 498 +1],
 499                      [20],
 500                      [2.1: syntax error, unexpected '+'])
 501 # Exercise error messages with EOF: work on an empty file.
 502 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
 503                      [1.1: syntax error, unexpected end of input])
 504
 505 # Exercise the error token: without it, we die at the first error,
 506 # hence be sure to
 507 #
 508 # - have several errors which exercise different shift/discardings
 509 #   - (): nothing to pop, nothing to discard
 510 #   - (1 + 1 + 1 +): a lot to pop, nothing to discard
 511 #   - (* * *): nothing to pop, a lot to discard
 512 #   - (1 + 2 * *): some to pop and discard
 513 #
 514 # - test the action associated to `error'
 515 #
 516 # - check the lookahead that triggers an error is not discarded
 517 #   when we enter error recovery.  Below, the lookahead causing the
 518 #   first error is ")", which is needed to recover from the error and
 519 #   produce the "0" that triggers the "0 != 1" error.
 520 #
 521 _AT_CHECK_CALC_ERROR([$1], [0],
 522                      [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
 523                      [250],
 524 [1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
 525 1.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
 526 1.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 527 1.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 528 calc: error: 4444 != 1])
 529
 530 # The same, but this time exercising explicitly triggered syntax errors.
 531 # POSIX says the lookahead causing the error should not be discarded.
 532 _AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
 533 [1.10: syntax error, unexpected number
 534 calc: error: 2222 != 1])
 535 _AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
 536 [1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 537 1.12: syntax error, unexpected number
 538 calc: error: 2222 != 1])
 539
 540 # Check that yyerrok works properly: second error is not reported,
 541 # third and fourth are.  Parse status is succesfull.
 542 _AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
 543 [1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 544 1.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 545 1.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
 546
 547 AT_BISON_OPTION_POPDEFS
 548
 549 AT_CLEANUP
 550 ])# AT_CHECK_CALC
 551
 552
 553
 554
 555 # ------------------------ #
 556 # Simple LALR Calculator.  #
 557 # ------------------------ #
 558
 559 AT_BANNER([[Simple LALR(1) Calculator.]])
 560
 561 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
 562 # -----------------------------------
 563 # Start a testing chunk which compiles `calc' grammar with
 564 # BISON-OPTIONS, and performs several tests over the parser.
 565 m4_define([AT_CHECK_CALC_LALR],
 566 [AT_CHECK_CALC($@)])
 567
 568 AT_CHECK_CALC_LALR()
 569
 570 AT_CHECK_CALC_LALR([%defines])
 571 AT_CHECK_CALC_LALR([%locations])
 572 AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
 573 AT_CHECK_CALC_LALR([%verbose])
 574 AT_CHECK_CALC_LALR([%yacc])
 575 AT_CHECK_CALC_LALR([%error-verbose])
 576
 577 AT_CHECK_CALC_LALR([%define api.pure %locations])
 578 AT_CHECK_CALC_LALR([%define api.push_pull "both" %define api.pure %locations])
 579 AT_CHECK_CALC_LALR([%error-verbose %locations])
 580
 581 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
 582 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix "calc" %define token.prefix "TOK_" %verbose %yacc])
 583
 584 AT_CHECK_CALC_LALR([%debug])
 585 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 586
 587 AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 588 AT_CHECK_CALC_LALR([%define api.push_pull "both" %define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 589
 590 AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 591
 592
 593 # ----------------------- #
 594 # Simple GLR Calculator.  #
 595 # ----------------------- #
 596
 597 AT_BANNER([[Simple GLR Calculator.]])
 598
 599 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
 600 # ----------------------------------
 601 # Start a testing chunk which compiles `calc' grammar with
 602 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
 603 m4_define([AT_CHECK_CALC_GLR],
 604 [AT_CHECK_CALC([%glr-parser] $@)])
 605
 606
 607 AT_CHECK_CALC_GLR()
 608
 609 AT_CHECK_CALC_GLR([%defines])
 610 AT_CHECK_CALC_GLR([%locations])
 611 AT_CHECK_CALC_GLR([%name-prefix "calc"])
 612 AT_CHECK_CALC_GLR([%verbose])
 613 AT_CHECK_CALC_GLR([%yacc])
 614 AT_CHECK_CALC_GLR([%error-verbose])
 615
 616 AT_CHECK_CALC_GLR([%define api.pure %locations])
 617 AT_CHECK_CALC_GLR([%error-verbose %locations])
 618
 619 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
 620
 621 AT_CHECK_CALC_GLR([%debug])
 622 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 623 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix "calc" %define token.prefix "TOK_" %verbose %yacc])
 624
 625 AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 626
 627 AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 628
 629
 630 # ----------------------------- #
 631 # Simple LALR1 C++ Calculator.  #
 632 # ----------------------------- #
 633
 634 AT_BANNER([[Simple LALR(1) C++ Calculator.]])
 635
 636 # First let's try using %skeleton
 637 AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
 638
 639 # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
 640 # ---------------------------------------
 641 # Start a testing chunk which compiles `calc' grammar with
 642 # the C++ skeleton, and performs several tests over the parser.
 643 m4_define([AT_CHECK_CALC_LALR1_CC],
 644 [AT_CHECK_CALC([%language "C++" %defines] $@)])
 645
 646 AT_CHECK_CALC_LALR1_CC([])
 647 AT_CHECK_CALC_LALR1_CC([%locations])
 648 AT_CHECK_CALC_LALR1_CC([%locations %error-verbose %name-prefix "calc" %verbose %yacc])
 649
 650 AT_CHECK_CALC_LALR1_CC([%locations %error-verbose %debug %name-prefix "calc" %verbose %yacc])
 651
 652 AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
 653 AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %error-verbose %debug %name-prefix "calc" %define token.prefix "TOK_" %verbose %yacc])
 654
 655 AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
 656
 657
 658
 659 # --------------------------- #
 660 # Simple GLR C++ Calculator.  #
 661 # --------------------------- #
 662
 663 AT_BANNER([[Simple GLR C++ Calculator.]])
 664
 665 # Again, we try also using %skeleton.
 666 AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
 667
 668 # AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
 669 # -------------------------------------
 670 # Start a testing chunk which compiles `calc' grammar with
 671 # the GLR C++ skeleton, and performs several tests over the parser.
 672 m4_define([AT_CHECK_CALC_GLR_CC],
 673 [AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
 674
 675 AT_CHECK_CALC_GLR_CC([])
 676 AT_CHECK_CALC_GLR_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
 677
 678 AT_CHECK_CALC_GLR_CC([%debug])
 679 AT_CHECK_CALC_GLR_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
 680
 681 AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
 682 AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %define token.prefix "TOK_" %verbose %yacc])
 683
 684 AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])