tests/calc.at

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