tests/calc.at

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