tests/calc.at

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