tests/calc.at

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