tests/calc.at

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