tests/calc.at

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