tests/calc.at

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