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 {
 163 ]AT_LOCATION_TYPE_IF([
 164 # include <iostream>
 165   struct Point
 166   {
 167     int l;
 168     int c;
 169   };
 170
 171   struct Span
 172   {
 173     Point begin;
 174     Point end;
 175   };
 176 ])[
 177   /* Exercise pre-prologue dependency to %union.  */
 178   typedef int semantic_value;
 179 }
 180
 181 /* Exercise %union. */
 182 %union
 183 {
 184   semantic_value ival;
 185 };
 186
 187 %code provides
 188 {
 189 #include <stdio.h>
 190 /* The input.  */
 191 extern FILE *input;]AT_SKEL_CC_IF([[
 192 #ifndef YYLTYPE
 193 # define YYLTYPE ]AT_NAME_PREFIX[::parser::location_type
 194 #endif
 195 ]AT_LOCATION_TYPE_IF([[
 196   #define first_line   begin.l
 197   #define first_column begin.c
 198   #define last_line    end.l
 199   #define last_column  end.c
 200 ]], [[
 201   #define first_line   begin.line
 202   #define first_column begin.column
 203   #define last_line    end.line
 204   #define last_column  end.column
 205 ]])])[
 206 }
 207
 208 %code
 209 {
 210 #include <stdlib.h>
 211 #include <string.h>
 212 #if HAVE_UNISTD_H
 213 # include <unistd.h>
 214 #else
 215 # undef alarm
 216 # define alarm(seconds) /* empty */
 217 #endif
 218 #define USE(Var)
 219
 220 FILE *input;
 221 static semantic_value global_result = 0;
 222 static int global_count = 0;
 223 static int power (int base, int exponent);
 224 ]AT_SKEL_CC_IF(,
 225 [/* yyerror receives the location if:
 226    - %location & %pure & %glr
 227    - %location & %pure & %yacc & %parse-param. */
 228 static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
 229                      AT_PARAM_IF([semantic_value *result, int *count, ])
 230                      const char *s
 231                      );])[
 232 int yylex (]AT_LEX_FORMALS[);
 233 }
 234
 235 ]AT_SKEL_CC_IF([AT_LOCATION_IF([AT_LOCATION_TYPE_IF([], [
 236 /* The lalr1.cc skeleton, for backward compatibility, defines
 237    a constructor for position that initializes the filename.  The
 238    glr.cc skeleton does not (and in fact cannot: location/position
 239    are stored in a union, from which objects with constructors are
 240    excluded in C++). */
 241 %initial-action {
 242   @$.initialize (0);
 243 }
 244 ])])])[
 245
 246 /* Bison Declarations */
 247 %token CALC_EOF 0 "end of input"
 248 %token <ival> NUM "number"
 249 %type  <ival> exp
 250
 251 %nonassoc '='   /* comparison          */
 252 %left '-' '+'
 253 %left '*' '/'
 254 %precedence NEG /* negation--unary minus */
 255 %right '^'      /* exponentiation        */
 256
 257 /* Grammar follows */
 258 %%
 259 input:
 260   line
 261 | input line         { ]AT_PARAM_IF([++*count; ++global_count;])[ }
 262 ;
 263
 264 line:
 265   '\n'
 266 | exp '\n'           { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
 267 ;
 268
 269 exp:
 270   NUM                { $$ = $1;             }
 271 | exp '=' exp
 272   {
 273     if ($1 != $3)
 274       fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
 275     $$ = $1;
 276   }
 277 | exp '+' exp        { $$ = $1 + $3;        }
 278 | exp '-' exp        { $$ = $1 - $3;        }
 279 | exp '*' exp        { $$ = $1 * $3;        }
 280 | exp '/' exp        { $$ = $1 / $3;        }
 281 | '-' exp  %prec NEG { $$ = -$2;            }
 282 | exp '^' exp        { $$ = power ($1, $3); }
 283 | '(' exp ')'        { $$ = $2;             }
 284 | '(' error ')'      { $$ = 1111; yyerrok;  }
 285 | '!'                { $$ = 0; YYERROR;     }
 286 | '-' error          { $$ = 0; YYERROR;     }
 287 ;
 288 %%
 289
 290 ]AT_SKEL_CC_IF(
 291 [AT_LOCATION_TYPE_IF([[
 292   std::ostream&
 293   operator<< (std::ostream& o, const Span& s)
 294   {
 295     o << s.begin.l << '.' << s.begin.c;
 296     if (s.begin.l != s.end.l)
 297       o << '-' << s.end.l << '.' << s.end.c - 1;
 298     else if (s.begin.c != s.end.c - 1)
 299       o << '-' << s.end.c - 1;
 300     return o;
 301   }
 302 ]])
 303
 304 /* A C++ error reporting function.  */
 305 void
 306 AT_NAME_PREFIX::parser::error (AT_LOCATION_IF([const location_type& l, ])const std::string& m)
 307 {
 308   std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
 309 }
 310
 311 /* A C++ yyparse that simulates the C signature.  */
 312 int
 313 yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
 314 {
 315   AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
 316 #if YYDEBUG
 317   parser.set_debug_level (1);
 318 #endif
 319   return parser.parse ();
 320 }
 321 ],
 322 [/* A C error reporting function.  */
 323 static void
 324 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
 325          AT_PARAM_IF([semantic_value *result, int *count, ])
 326          const char *s)
 327 {
 328 AT_PARAM_IF([(void) result; (void) count;])
 329 AT_YYERROR_SEES_LOC_IF([
 330   fprintf (stderr, "%d.%d",
 331            AT_LOC.first_line, AT_LOC.first_column);
 332   if (AT_LOC.first_line != AT_LOC.last_line)
 333     fprintf (stderr, "-%d.%d",
 334              AT_LOC.last_line,  AT_LOC.last_column - 1);
 335   else if (AT_LOC.first_column != AT_LOC.last_column - 1)
 336     fprintf (stderr, "-%d",
 337              AT_LOC.last_column - 1);
 338   fprintf (stderr, ": ");])
 339   fprintf (stderr, "%s\n", s);
 340 }])[
 341
 342 ]AT_DEFINES_IF(, [AT_CALC_LEX])[
 343
 344 static int
 345 power (int base, int exponent)
 346 {
 347   int res = 1;
 348   if (exponent < 0)
 349     exit (3);
 350   for (/* Niente */; exponent; --exponent)
 351     res *= base;
 352   return res;
 353 }
 354
 355
 356 /* A C main function.  */
 357 int
 358 main (int argc, const char **argv)
 359 {
 360   semantic_value result = 0;
 361   int count = 0;
 362   int status;
 363
 364   /* This used to be alarm (10), but that isn't enough time for
 365      a July 1995 vintage DEC Alphastation 200 4/100 system,
 366      according to Nelson H. F. Beebe.  100 seconds is enough.  */
 367   alarm (100);
 368
 369   if (argc == 2)
 370     input = fopen (argv[1], "r");
 371   else
 372     input = stdin;
 373
 374   if (!input)
 375     {
 376       perror (argv[1]);
 377       return 3;
 378     }
 379
 380 ]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
 381 [  yydebug = 1;])])[
 382   status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
 383   if (fclose (input))
 384     perror ("fclose");
 385   if (global_result != result)
 386     abort ();
 387   if (global_count != count)
 388     abort ();
 389   return status;
 390 }
 391 ]])
 392 AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
 393 [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
 394
 395 ]AT_CALC_LEX])])
 396 m4_popdef([AT_CALC_LEX])
 397 ])# _AT_DATA_CALC_Y
 398
 399
 400 # AT_DATA_CALC_Y([BISON-OPTIONS])
 401 # -------------------------------
 402 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
 403 # `calc-lex.cc'.
 404 m4_define([AT_DATA_CALC_Y],
 405 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
 406 ])
 407
 408
 409
 410 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
 411 # --------------------------------------------------------
 412 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
 413 #
 414 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
 415 #
 416 # NUM-STDERR-LINES is the number of expected lines on stderr.
 417 # Currently this is ignored, though, since the output format is fluctuating.
 418 #
 419 # We don't count GLR's traces yet, since its traces are somewhat
 420 # different from LALR's.
 421 m4_define([_AT_CHECK_CALC],
 422 [AT_DATA([[input]],
 423 [[$2
 424 ]])
 425 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
 426 ])
 427
 428
 429 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
 430 #                      [NUM-STDERR-LINES],
 431 #                      [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
 432 # ---------------------------------------------------------
 433 # Run `calc' on INPUT, and expect a `syntax error' message.
 434 #
 435 # If INPUT starts with a slash, it is used as absolute input file name,
 436 # otherwise as contents.
 437 #
 438 # NUM-STDERR-LINES is the number of expected lines on stderr.
 439 # Currently this is ignored, though, since the output format is fluctuating.
 440 #
 441 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
 442 # is correctly output on stderr.
 443 #
 444 # If BISON-OPTIONS contains `%define parse.error verbose', then make sure the
 445 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
 446 # on STDERR.
 447 #
 448 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 449 # is the number of expected lines on stderr.
 450 m4_define([_AT_CHECK_CALC_ERROR],
 451 [m4_bmatch([$3], [^/],
 452            [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
 453            [AT_DATA([[input]],
 454 [[$3
 455 ]])
 456 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
 457
 458 # Normalize the observed and expected error messages, depending upon the
 459 # options.
 460 # 1. Remove the traces from observed.
 461 sed '/^Starting/d
 462 /^Entering/d
 463 /^Stack/d
 464 /^Reading/d
 465 /^Reducing/d
 466 /^Return/d
 467 /^Shifting/d
 468 /^state/d
 469 /^Cleanup:/d
 470 /^Error:/d
 471 /^Next/d
 472 /^Now/d
 473 /^Discarding/d
 474 / \$[[0-9$]]* = /d
 475 /^yydestructor:/d' stderr >at-stderr
 476 mv at-stderr stderr
 477 # 2. Create the reference error message.
 478 AT_DATA([[expout]],
 479 [$5
 480 ])
 481 # 3. If locations are not used, remove them.
 482 AT_YYERROR_SEES_LOC_IF([],
 483 [[sed 's/^[-0-9.]*: //' expout >at-expout
 484 mv at-expout expout]])
 485 # 4. If error-verbose is not used, strip the`, unexpected....' part.
 486 m4_bmatch([$1], [%define parse.error verbose], [],
 487 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
 488 mv at-expout expout]])
 489 # 5. Check
 490 AT_CHECK([cat stderr], 0, [expout])
 491 ])
 492
 493
 494 # AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
 495 # --------------------------------------------------
 496 # Start a testing chunk which compiles `calc' grammar with
 497 # BISON-OPTIONS, and performs several tests over the parser.
 498 # However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
 499 m4_define([AT_CHECK_CALC],
 500 [# We use integers to avoid dependencies upon the precision of doubles.
 501 AT_SETUP([Calculator $1])
 502
 503 m4_ifval([$2], [AT_CHECK([exit 77])])
 504
 505 AT_BISON_OPTION_PUSHDEFS([$1])
 506
 507 AT_DATA_CALC_Y([$1])
 508 AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
 509
 510 # Test the priorities.
 511 _AT_CHECK_CALC([$1],
 512 [1 + 2 * 3 = 7
 513 1 + 2 * -3 = -5
 514
 515 -1^2 = -1
 516 (-1)^2 = 1
 517
 518 ---1 = -1
 519
 520 1 - 2 - 3 = -4
 521 1 - (2 - 3) = 2
 522
 523 2^2^3 = 256
 524 (2^2)^3 = 64],
 525                [842])
 526
 527 # Some syntax errors.
 528 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
 529                      [1.3: syntax error, unexpected number])
 530 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
 531                      [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
 532 _AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
 533                      [1.1: syntax error, unexpected $undefined])
 534 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
 535                      [1.7: syntax error, unexpected '='])
 536 _AT_CHECK_CALC_ERROR([$1], [1],
 537                      [
 538 +1],
 539                      [20],
 540                      [2.1: syntax error, unexpected '+'])
 541 # Exercise error messages with EOF: work on an empty file.
 542 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
 543                      [1.1: syntax error, unexpected end of input])
 544
 545 # Exercise the error token: without it, we die at the first error,
 546 # hence be sure to
 547 #
 548 # - have several errors which exercise different shift/discardings
 549 #   - (): nothing to pop, nothing to discard
 550 #   - (1 + 1 + 1 +): a lot to pop, nothing to discard
 551 #   - (* * *): nothing to pop, a lot to discard
 552 #   - (1 + 2 * *): some to pop and discard
 553 #
 554 # - test the action associated to `error'
 555 #
 556 # - check the lookahead that triggers an error is not discarded
 557 #   when we enter error recovery.  Below, the lookahead causing the
 558 #   first error is ")", which is needed to recover from the error and
 559 #   produce the "0" that triggers the "0 != 1" error.
 560 #
 561 _AT_CHECK_CALC_ERROR([$1], [0],
 562                      [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
 563                      [250],
 564 [1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
 565 1.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
 566 1.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 567 1.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 568 calc: error: 4444 != 1])
 569
 570 # The same, but this time exercising explicitly triggered syntax errors.
 571 # POSIX says the lookahead causing the error should not be discarded.
 572 _AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
 573 [1.10: syntax error, unexpected number
 574 calc: error: 2222 != 1])
 575 _AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
 576 [1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 577 1.12: syntax error, unexpected number
 578 calc: error: 2222 != 1])
 579
 580 # Check that yyerrok works properly: second error is not reported,
 581 # third and fourth are.  Parse status is succesfull.
 582 _AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
 583 [1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 584 1.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
 585 1.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
 586
 587 AT_BISON_OPTION_POPDEFS
 588
 589 AT_CLEANUP
 590 ])# AT_CHECK_CALC
 591
 592
 593
 594
 595 # ------------------------ #
 596 # Simple LALR Calculator.  #
 597 # ------------------------ #
 598
 599 AT_BANNER([[Simple LALR(1) Calculator.]])
 600
 601 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
 602 # -----------------------------------
 603 # Start a testing chunk which compiles `calc' grammar with
 604 # BISON-OPTIONS, and performs several tests over the parser.
 605 m4_define([AT_CHECK_CALC_LALR],
 606 [AT_CHECK_CALC($@)])
 607
 608 AT_CHECK_CALC_LALR()
 609
 610 AT_CHECK_CALC_LALR([%defines])
 611 AT_CHECK_CALC_LALR([%locations])
 612
 613 AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
 614 AT_CHECK_CALC_LALR([%verbose])
 615 AT_CHECK_CALC_LALR([%yacc])
 616 AT_CHECK_CALC_LALR([%define parse.error verbose])
 617
 618 AT_CHECK_CALC_LALR([%define api.pure %locations])
 619 AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
 620 AT_CHECK_CALC_LALR([%define parse.error verbose %locations])
 621
 622 AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
 623 AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
 624
 625 AT_CHECK_CALC_LALR([%debug])
 626 AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 627
 628 AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 629 AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 630
 631 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}])
 632
 633
 634 # ----------------------- #
 635 # Simple GLR Calculator.  #
 636 # ----------------------- #
 637
 638 AT_BANNER([[Simple GLR Calculator.]])
 639
 640 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
 641 # ----------------------------------
 642 # Start a testing chunk which compiles `calc' grammar with
 643 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
 644 m4_define([AT_CHECK_CALC_GLR],
 645 [AT_CHECK_CALC([%glr-parser] $@)])
 646
 647
 648 AT_CHECK_CALC_GLR()
 649
 650 AT_CHECK_CALC_GLR([%defines])
 651 AT_CHECK_CALC_GLR([%locations])
 652 AT_CHECK_CALC_GLR([%name-prefix "calc"])
 653 AT_CHECK_CALC_GLR([%verbose])
 654 AT_CHECK_CALC_GLR([%yacc])
 655 AT_CHECK_CALC_GLR([%define parse.error verbose])
 656
 657 AT_CHECK_CALC_GLR([%define api.pure %locations])
 658 AT_CHECK_CALC_GLR([%define parse.error verbose %locations])
 659
 660 AT_CHECK_CALC_GLR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
 661
 662 AT_CHECK_CALC_GLR([%debug])
 663 AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 664 AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
 665
 666 AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
 667
 668 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}])
 669
 670
 671 # ----------------------------- #
 672 # Simple LALR1 C++ Calculator.  #
 673 # ----------------------------- #
 674
 675 AT_BANNER([[Simple LALR(1) C++ Calculator.]])
 676
 677 # First let's try using %skeleton
 678 AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
 679
 680 # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
 681 # ---------------------------------------
 682 # Start a testing chunk which compiles `calc' grammar with
 683 # the C++ skeleton, and performs several tests over the parser.
 684 m4_define([AT_CHECK_CALC_LALR1_CC],
 685 [AT_CHECK_CALC([%language "C++" %defines] $@)])
 686
 687 AT_CHECK_CALC_LALR1_CC([])
 688 AT_CHECK_CALC_LALR1_CC([%locations])
 689 AT_CHECK_CALC_LALR1_CC([%locations %define location_type Span])
 690 AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
 691
 692 AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
 693
 694 AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
 695 AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
 696
 697 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}])
 698
 699
 700
 701 # --------------------------- #
 702 # Simple GLR C++ Calculator.  #
 703 # --------------------------- #
 704
 705 AT_BANNER([[Simple GLR C++ Calculator.]])
 706
 707 # Again, we try also using %skeleton.
 708 AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
 709
 710 # AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
 711 # -------------------------------------
 712 # Start a testing chunk which compiles `calc' grammar with
 713 # the GLR C++ skeleton, and performs several tests over the parser.
 714 m4_define([AT_CHECK_CALC_GLR_CC],
 715 [AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
 716
 717 AT_CHECK_CALC_GLR_CC([])
 718 AT_CHECK_CALC_GLR_CC([%define parse.error verbose %name-prefix "calc" %verbose %yacc])
 719
 720 AT_CHECK_CALC_GLR_CC([%debug])
 721 AT_CHECK_CALC_GLR_CC([%define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
 722
 723 AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
 724 AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
 725
 726 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}])