tests/calc.at

   1 # Checking the output filenames.                         -*- Autotest -*-
   2 # Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2, or (at your option)
   7 # any later version.
   8
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  17 # 02111-1307, USA.
  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 %{
  42 #include <stdio.h>
  43
  44 #if STDC_HEADERS
  45 # include <stdlib.h>
  46 # include <string.h>
  47 #endif
  48 #include <ctype.h>
  49
  50 extern void perror (const char *s);
  51
  52 /* Exercise pre-prologue dependency to %union.  */
  53 typedef int value;
  54
  55 static value global_result = 0;
  56 static int global_count = 0;
  57
  58 ]AT_LALR1_CC_IF([typedef yy::Location YYLTYPE;])[
  59 %}
  60
  61 /* Exercise %union. */
  62 %union
  63 {
  64   value ival;
  65 };
  66
  67 %{
  68 static int power (int base, int exponent);
  69 ]AT_LALR1_CC_IF([], [
  70 /* yyerror receives the location if:
  71    - %location & %pure & %glr
  72    - %location & %pure & %yacc & %parse-param. */
  73 static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])
  74                      AT_PARAM_IF([value *result, int *count, ])
  75                      const char *s
  76                      );])[
  77 static int yylex (]AT_LEX_FORMALS[);
  78 static int yygetc (]AT_LEX_FORMALS[);
  79 static void yyungetc (]AT_LEX_PRE_FORMALS[ int c);
  80 %}
  81
  82 /* Bison Declarations */
  83 %token CALC_EOF 0 "end of input"
  84 %token <ival> NUM "number"
  85 %type  <ival> exp
  86
  87 %nonassoc '=' /* comparison            */
  88 %left '-' '+'
  89 %left '*' '/'
  90 %left NEG     /* negation--unary minus */
  91 %right '^'    /* exponentiation        */
  92
  93 /* Grammar follows */
  94 %%
  95 input:
  96   line
  97 | input line         { ]AT_PARAM_IF([++*count; ++global_count;])[ }
  98 ;
  99
 100 line:
 101   '\n'
 102 | exp '\n'           { ]AT_PARAM_IF([*result = global_result = $1;])[ }
 103 ;
 104
 105 exp:
 106   NUM                { $$ = $1;             }
 107 | exp '=' exp
 108   {
 109     if ($1 != $3)
 110       fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
 111     $$ = $1;
 112   }
 113 | exp '+' exp        { $$ = $1 + $3;        }
 114 | exp '-' exp        { $$ = $1 - $3;        }
 115 | exp '*' exp        { $$ = $1 * $3;        }
 116 | exp '/' exp        { $$ = $1 / $3;        }
 117 | '-' exp  %prec NEG { $$ = -$2;            }
 118 | exp '^' exp        { $$ = power ($1, $3); }
 119 | '(' exp ')'        { $$ = $2;             }
 120 | '(' error ')'      { $$ = 1111;           }
 121 | '!'                { YYERROR;             }
 122 ;
 123 %%
 124 /* The input. */
 125 static FILE *yyin;
 126
 127 ]AT_LALR1_CC_IF(
 128 [/* Currently, print_ is required in C++. */
 129 void
 130 yy::Parser::print_ ()
 131 {
 132 AT_LOCATION_IF([
 133   std::cerr << location;])
 134 }
 135
 136 /* A C++ error reporting function. */
 137 void
 138 yy::Parser::error_ ()
 139 {
 140   std::cerr << AT_LOCATION_IF([location << ": " << ])message << std::endl;
 141 }
 142
 143 int
 144 yyparse (void)
 145 {
 146   yy::Parser parser = yy::Parser (!!YYDEBUG[]AT_LOCATION_IF([,
 147                                   yy::Location::Location ()]));
 148   return parser.parse ();
 149 }
 150 ],
 151 [static void
 152 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])
 153          AT_PARAM_IF([value *result, int *count, ])
 154          const char *s)
 155 {
 156 AT_PARAM_IF([(void) result; (void) count;])
 157 AT_YYERROR_SEES_LOC_IF([
 158   fprintf (stderr, "%d.%d",
 159            AT_LOC.first_line, AT_LOC.first_column);
 160   if (AT_LOC.first_line != AT_LOC.last_line)
 161     fprintf (stderr, "-%d.%d",
 162              AT_LOC.last_line,  AT_LOC.last_column - 1);
 163   else if (AT_LOC.first_column != AT_LOC.last_column - 1)
 164     fprintf (stderr, "-%d",
 165              AT_LOC.last_column - 1);
 166   fprintf (stderr, ": ");])
 167   fprintf (stderr, "%s\n", s);
 168 }])[
 169
 170
 171 ]AT_LOCATION_IF([
 172 static YYLTYPE last_yylloc;
 173 ])[
 174 static int
 175 yygetc (]AT_LEX_FORMALS[)
 176 {
 177   int res = getc (yyin);
 178   ]AT_USE_LEX_ARGS[;
 179 ]AT_LOCATION_IF([
 180   last_yylloc = AT_LOC;
 181   if (res == '\n')
 182     {
 183 AT_LALR1_CC_IF(
 184 [     AT_LOC.end.line++;
 185       AT_LOC.end.column = 0;],
 186 [     AT_LOC.last_line++;
 187       AT_LOC.last_column = 0;])
 188     }
 189   else
 190 AT_LALR1_CC_IF(
 191 [    AT_LOC.end.column++;],
 192 [    AT_LOC.last_column++;])
 193 ])[
 194   return res;
 195 }
 196
 197
 198 static void
 199 yyungetc (]AT_LEX_PRE_FORMALS[ int c)
 200 {
 201   ]AT_USE_LEX_ARGS[;
 202 ]AT_LOCATION_IF([
 203   /* Wrong when C == `\n'. */
 204   AT_LOC = last_yylloc;
 205 ])[
 206   ungetc (c, yyin);
 207 }
 208
 209 static int
 210 read_signed_integer (]AT_LEX_FORMALS[)
 211 {
 212   int c = yygetc (]AT_LEX_ARGS[);
 213   int sign = 1;
 214   int n = 0;
 215
 216   ]AT_USE_LEX_ARGS[;
 217   if (c == '-')
 218     {
 219       c = yygetc (]AT_LEX_ARGS[);
 220       sign = -1;
 221     }
 222
 223   while (isdigit (c))
 224     {
 225       n = 10 * n + (c - '0');
 226       c = yygetc (]AT_LEX_ARGS[);
 227     }
 228
 229   yyungetc (]AT_LEX_PRE_ARGS[ c);
 230
 231   return sign * n;
 232 }
 233
 234
 235
 236 /*---------------------------------------------------------------.
 237 | Lexical analyzer returns an integer on the stack and the token |
 238 | NUM, or the ASCII character read if not a number.  Skips all   |
 239 | blanks and tabs, returns 0 for EOF.                            |
 240 `---------------------------------------------------------------*/
 241
 242 static int
 243 yylex (]AT_LEX_FORMALS[)
 244 {
 245   static int init = 1;
 246   int c;
 247
 248   if (init)
 249     {
 250       init = 0;
 251 ]AT_LALR1_CC_IF([],
 252 [AT_LOCATION_IF([
 253       AT_LOC.last_column = 0;
 254       AT_LOC.last_line = 1;
 255 ])])[
 256     }
 257
 258 ]AT_LOCATION_IF([AT_LALR1_CC_IF(
 259 [ AT_LOC.begin = AT_LOC.end;],
 260 [ AT_LOC.first_column = AT_LOC.last_column;
 261   AT_LOC.first_line   = AT_LOC.last_line;
 262 ])])[
 263
 264   /* Skip white space.  */
 265   while ((c = yygetc (]AT_LEX_ARGS[)) == ' ' || c == '\t')
 266     {
 267 ]AT_LOCATION_IF([AT_LALR1_CC_IF(
 268 [     AT_LOC.begin = AT_LOC.end;],
 269 [     AT_LOC.first_column = AT_LOC.last_column;
 270       AT_LOC.first_line   = AT_LOC.last_line;
 271 ])])[
 272     }
 273
 274   /* process numbers   */
 275   if (c == '.' || isdigit (c))
 276     {
 277       yyungetc (]AT_LEX_PRE_ARGS[ c);
 278       ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
 279       return NUM;
 280     }
 281
 282   /* Return end-of-file.  */
 283   if (c == EOF)
 284     return CALC_EOF;
 285
 286   /* Return single chars. */
 287   return c;
 288 }
 289
 290 static int
 291 power (int base, int exponent)
 292 {
 293   int res = 1;
 294   if (exponent < 0)
 295     exit (1);
 296   for (/* Niente */; exponent; --exponent)
 297     res *= base;
 298   return res;
 299 }
 300
 301
 302 int
 303 main (int argc, const char **argv)
 304 {
 305   value result = 0;
 306   int count = 0;
 307   int status;
 308
 309   if (argc == 2)
 310     yyin = fopen (argv[1], "r");
 311   else
 312     yyin = stdin;
 313
 314   if (!yyin)
 315     {
 316       perror (argv[1]);
 317       exit (1);
 318     }
 319
 320 ]AT_LALR1_CC_IF([], [m4_bmatch([$4], [%debug],
 321 [  yydebug = 1;])])[
 322   status = yyparse (]AT_PARAM_IF([&result, &count])[);
 323   if (global_result != result)
 324     abort ();
 325   if (global_count != count)
 326     abort ();
 327   return status;
 328 }
 329 ]])
 330 ])# _AT_DATA_CALC_Y
 331
 332
 333 # AT_DATA_CALC_Y([BISON-OPTIONS])
 334 # -------------------------------
 335 # Produce `calc.y'.
 336 m4_define([AT_DATA_CALC_Y],
 337 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
 338 ])
 339
 340
 341
 342 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0])
 343 # ------------------------------------------------------------
 344 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
 345 #
 346 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
 347 # NUM-STDERR-LINES is the number of expected lines on stderr.
 348 #
 349 # We don't count GLR's traces yet, since its traces are somewhat
 350 # different from LALR's.
 351 m4_define([_AT_CHECK_CALC],
 352 [AT_DATA([[input]],
 353 [[$2
 354 ]])
 355 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
 356 m4_bmatch([$1],
 357   [%debug.*%glr\|%glr.*%debug],
 358      [],
 359   [%debug],
 360      [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
 361 ])])
 362 ])
 363
 364
 365 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
 366 #                      [NUM-DEBUG-LINES],
 367 #                      [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
 368 # ---------------------------------------------------------
 369 # Run `calc' on INPUT, and expect a `syntax error' message.
 370 #
 371 # If INPUT starts with a slash, it is used as absolute input file name,
 372 # otherwise as contents.
 373 #
 374 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
 375 # is correctly output on stderr.
 376 #
 377 # If BISON-OPTIONS contains `%error-verbose', then make sure the
 378 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
 379 # on STDERR.
 380 #
 381 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 382 # is the number of expected lines on stderr.
 383 m4_define([_AT_CHECK_CALC_ERROR],
 384 [m4_bmatch([$3], [^/],
 385            [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
 386            [AT_DATA([[input]],
 387 [[$3
 388 ]])
 389 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
 390 m4_bmatch([$1],
 391   [%debug.*%glr\|%glr.*%debug],
 392      [],
 393   [%debug],
 394      [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4
 395 ])])
 396
 397 # Normalize the observed and expected error messages, depending upon the
 398 # options.
 399 # 1. Remove the traces from observed.
 400 sed '/^Starting/d
 401 /^Entering/d
 402 /^Stack/d
 403 /^Reading/d
 404 /^Reducing/d
 405 /^Shifting/d
 406 /^state/d
 407 /^Error:/d
 408 /^Next/d
 409 /^Discarding/d
 410 /^yydestructor:/d' stderr >at-stderr
 411 mv at-stderr stderr
 412 # 2. Create the reference error message.
 413 AT_DATA([[expout]],
 414 [$5
 415 ])
 416 # 3. If locations are not used, remove them.
 417 AT_YYERROR_SEES_LOC_IF([],
 418 [[sed 's/^[-0-9.]*: //' expout >at-expout
 419 mv at-expout expout]])
 420 # 4. If error-verbose is not used, strip the`, unexpected....' part.
 421 m4_bmatch([$1], [%error-verbose], [],
 422 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
 423 mv at-expout expout]])
 424 # 5. Check
 425 AT_CHECK([cat stderr], 0, [expout])
 426 ])
 427
 428
 429 # AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS])
 430 # -----------------------------------------
 431 # This macro works around the impossibility to define macros
 432 # inside macros, because issuing `[$1]' is not possible in M4 :(.
 433 # This sucks hard, GNU M4 should really provide M5 like $$1.
 434 m4_define([AT_CHECK_PUSHDEFS],
 435 [m4_if([$1$2], $[1]$[2], [],
 436        [m4_fatal([$0: Invalid arguments: $@])])dnl
 437 m4_pushdef([AT_LALR1_CC_IF],
 438 [m4_bmatch([$3], ["lalr1.cc"], [$1], [$2])])
 439 m4_pushdef([AT_GLR_IF],
 440 [m4_bmatch([$3], [%glr-parser], [$1], [$2])])
 441 # Using yacc.c?
 442 m4_pushdef([AT_YACC_IF],
 443 [m4_bmatch([$3], [%glr-parser\|%skeleton], [$2], [$1])])
 444 m4_pushdef([AT_PARAM_IF],
 445 [m4_bmatch([$3], [%parse-param], [$1], [$2])])
 446 m4_pushdef([AT_LOCATION_IF],
 447 [m4_bmatch([$3], [%locations], [$1], [$2])])
 448 m4_pushdef([AT_PURE_IF],
 449 [m4_bmatch([$3], [%pure-parser], [$1], [$2])])
 450 m4_pushdef([AT_PURE_AND_LOC_IF],
 451 [m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations],
 452            [$1], [$2])])
 453 m4_pushdef([AT_GLR_OR_PARAM_IF],
 454 [m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
 455
 456 # yyerror receives the location if %location & %pure & (%glr or %parse-param).
 457 m4_pushdef([AT_YYERROR_ARG_LOC_IF],
 458 [AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
 459                     [$2])])
 460 # yyerror always sees the locations (when activated), except if
 461 # yacc & pure & !param.
 462 m4_pushdef([AT_YYERROR_SEES_LOC_IF],
 463 [AT_LOCATION_IF([AT_YACC_IF([AT_PURE_IF([AT_PARAM_IF([$1], [$2])],
 464                                         [$1])],
 465                             [$1])],
 466                 [$2])])
 467
 468 # The interface is pure: either because %pure-parser, or because we
 469 # are using the C++ parsers.
 470 m4_pushdef([AT_PURE_LEX_IF],
 471 [AT_PURE_IF([$1],
 472             [AT_LALR1_CC_IF([$1], [$2])])])
 473
 474 AT_PURE_LEX_IF(
 475 [m4_pushdef([AT_LOC], [(*yylloc)])
 476  m4_pushdef([AT_VAL], [(*yylval)])
 477  m4_pushdef([AT_LEX_FORMALS],
 478             [YYSTYPE *yylval[]AT_LOCATION_IF([, YYLTYPE *yylloc])])
 479  m4_pushdef([AT_LEX_ARGS],
 480             [yylval[]AT_LOCATION_IF([, yylloc])])
 481  m4_pushdef([AT_USE_LEX_ARGS],
 482             [(void) yylval;AT_LOCATION_IF([(void) yylloc])])
 483  m4_pushdef([AT_LEX_PRE_FORMALS],
 484             [AT_LEX_FORMALS, ])
 485  m4_pushdef([AT_LEX_PRE_ARGS],
 486             [AT_LEX_ARGS, ])
 487 ],
 488 [m4_pushdef([AT_LOC], [(yylloc)])
 489  m4_pushdef([AT_VAL], [(yylval)])
 490  m4_pushdef([AT_LEX_FORMALS],     [void])
 491  m4_pushdef([AT_LEX_ARGS],        [])
 492  m4_pushdef([AT_USE_LEX_ARGS],    [])
 493  m4_pushdef([AT_LEX_PRE_FORMALS], [])
 494  m4_pushdef([AT_LEX_PRE_ARGS],    [])
 495 ])
 496 ])# AT_CALC_PUSHDEFS
 497
 498
 499 # AT_CALC_POPDEFS
 500 # ---------------
 501 m4_define([AT_CHECK_POPDEFS],
 502 [m4_popdef([AT_LEX_PRE_ARGS])
 503 m4_popdef([AT_LEX_PRE_FORMALS])
 504 m4_popdef([AT_USE_LEX_ARGS])
 505 m4_popdef([AT_LEX_ARGS])
 506 m4_popdef([AT_LEX_FORMALS])
 507 m4_popdef([AT_VAL])
 508 m4_popdef([AT_LOC])
 509 m4_popdef([AT_PURE_LEX_IF])
 510 m4_popdef([AT_YYERROR_SEES_LOC_IF])
 511 m4_popdef([AT_YYERROR_ARG_LOC_IF])
 512 m4_popdef([AT_GLR_OR_PARAM_IF])
 513 m4_popdef([AT_PURE_AND_LOC_IF])
 514 m4_popdef([AT_LOCATION_IF])
 515 m4_popdef([AT_PARAM_IF])
 516 m4_popdef([AT_YACC_IF])
 517 m4_popdef([AT_GLR_IF])
 518 m4_popdef([AT_LALR1_CC_IF])
 519 ])
 520
 521
 522
 523 # AT_CHECK_CALC([BISON-OPTIONS])
 524 # ------------------------------
 525 # Start a testing chunk which compiles `calc' grammar with
 526 # BISON-OPTIONS, and performs several tests over the parser.
 527 m4_define([AT_CHECK_CALC],
 528 [# We use integers to avoid dependencies upon the precision of doubles.
 529 AT_SETUP([Calculator $1])
 530
 531 AT_CHECK_PUSHDEFS($[1], $[2], [$1])
 532
 533 AT_DATA_CALC_Y([$1])
 534
 535 # Specify the output files to avoid problems on different file systems.
 536 AT_CHECK([bison -o calc.c calc.y],
 537          [0], [], [])
 538
 539 AT_LALR1_CC_IF(
 540 [AT_CHECK([$CXX --version || exit 77], 0, ignore, ignore)
 541 AT_COMPILE_CXX([calc])],
 542 [AT_COMPILE([calc])])
 543
 544 # Test the priorities.
 545 _AT_CHECK_CALC([$1],
 546 [1 + 2 * 3 = 7
 547 1 + 2 * -3 = -5
 548
 549 -1^2 = -1
 550 (-1)^2 = 1
 551
 552 ---1 = -1
 553
 554 1 - 2 - 3 = -4
 555 1 - (2 - 3) = 2
 556
 557 2^2^3 = 256
 558 (2^2)^3 = 64],
 559                [486])
 560
 561 # Some syntax errors.
 562 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [11],
 563                      [1.2: syntax error, unexpected "number"])
 564 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [15],
 565                      [1.2: syntax error, unexpected '/', expecting "number" or '-' or '(' or '!'])
 566 _AT_CHECK_CALC_ERROR([$1], [1], [error], [4],
 567                      [1.0: syntax error, unexpected $undefined])
 568 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [22],
 569                      [1.6: syntax error, unexpected '='])
 570 _AT_CHECK_CALC_ERROR([$1], [1],
 571                      [
 572 +1],
 573                      [14],
 574                      [2.0: syntax error, unexpected '+'])
 575 # Exercise error messages with EOF: work on an empty file.
 576 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
 577                      [1.0: syntax error, unexpected "end of input"])
 578
 579 # Exercise the error token: without it, we die at the first error,
 580 # hence be sure to
 581 #
 582 # - have several errors which exercise different shift/discardings
 583 #   - (): nothing to pop, nothing to discard
 584 #   - (1 + 1 + 1 +): a lot to pop, nothing to discard
 585 #   - (* * *): nothing to pop, a lot to discard
 586 #   - (1 + 2 * *): some to pop and discard
 587 #
 588 # - test the action associated to `error'
 589 #
 590 # - check the lookahead that triggers an error is not discarded
 591 #   when we enter error recovery.  Below, the lookahead causing the
 592 #   first error is ")", which is needed to recover from the error and
 593 #   produce the "0" that triggers the "0 != 1" error.
 594 #
 595 _AT_CHECK_CALC_ERROR([$1], [0],
 596                      [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
 597                      [156],
 598 [1.1: syntax error, unexpected ')', expecting "number" or '-' or '(' or '!'
 599 1.17: syntax error, unexpected ')', expecting "number" or '-' or '(' or '!'
 600 1.22: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
 601 1.40: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
 602 calc: error: 4444 != 1])
 603
 604 # The same, but this time exercising explicitly triggered syntax errors.
 605 # POSIX says the lookahead causing the error should not be discarded.
 606 _AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [64],
 607 [1.9: syntax error, unexpected "number"
 608 calc: error: 2222 != 1])
 609 AT_CHECK_POPDEFS
 610
 611 AT_CLEANUP
 612 ])# AT_CHECK_CALC
 613
 614
 615
 616
 617 # ------------------------ #
 618 # Simple LALR Calculator.  #
 619 # ------------------------ #
 620
 621 AT_BANNER([[Simple LALR Calculator.]])
 622
 623 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
 624 # -----------------------------------
 625 # Start a testing chunk which compiles `calc' grammar with
 626 # BISON-OPTIONS, and performs several tests over the parser.
 627 m4_define([AT_CHECK_CALC_LALR],
 628 [AT_CHECK_CALC($@)])
 629
 630 AT_CHECK_CALC_LALR()
 631
 632 AT_CHECK_CALC_LALR([%defines])
 633 AT_CHECK_CALC_LALR([%locations])
 634 AT_CHECK_CALC_LALR([%name-prefix="calc"])
 635 AT_CHECK_CALC_LALR([%verbose])
 636 AT_CHECK_CALC_LALR([%yacc])
 637 AT_CHECK_CALC_LALR([%error-verbose])
 638
 639 AT_CHECK_CALC_LALR([%error-verbose %locations])
 640
 641 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 642
 643 AT_CHECK_CALC_LALR([%debug])
 644 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 645
 646 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 647
 648 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param {int *count}])
 649
 650
 651 # ----------------------- #
 652 # Simple GLR Calculator.  #
 653 # ----------------------- #
 654
 655 AT_BANNER([[Simple GLR Calculator.]])
 656
 657 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
 658 # ----------------------------------
 659 # Start a testing chunk which compiles `calc' grammar with
 660 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
 661 m4_define([AT_CHECK_CALC_GLR],
 662 [AT_CHECK_CALC([%glr-parser] $@)])
 663
 664
 665 AT_CHECK_CALC_GLR()
 666
 667 AT_CHECK_CALC_GLR([%defines])
 668 AT_CHECK_CALC_GLR([%locations])
 669 AT_CHECK_CALC_GLR([%name-prefix="calc"])
 670 AT_CHECK_CALC_GLR([%verbose])
 671 AT_CHECK_CALC_GLR([%yacc])
 672 AT_CHECK_CALC_GLR([%error-verbose])
 673
 674 AT_CHECK_CALC_GLR([%error-verbose %locations])
 675
 676 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 677
 678 AT_CHECK_CALC_GLR([%debug])
 679 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 680
 681 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 682
 683 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param {int *count}])
 684
 685
 686 # ----------------------------- #
 687 # Simple LALR1 C++ Calculator.  #
 688 # ----------------------------- #
 689
 690 AT_BANNER([[Simple LALR1 C++ Calculator.]])
 691
 692 # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
 693 # ---------------------------------------
 694 # Start a testing chunk which compiles `calc' grammar with
 695 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
 696 m4_define([AT_CHECK_CALC_LALR1_CC],
 697 [AT_CHECK_CALC([%skeleton "lalr1.cc"] $@)])
 698
 699 # AT_CHECK_CALC_LALR1_CC()
 700
 701 AT_CHECK_CALC_LALR1_CC([%defines %locations])
 702
 703 AT_CHECK_CALC_LALR1_CC([%defines])
 704 # AT_CHECK_CALC_LALR1_CC([%locations])
 705 # AT_CHECK_CALC_LALR1_CC([%name-prefix="calc"])
 706 # AT_CHECK_CALC_LALR1_CC([%verbose])
 707 # AT_CHECK_CALC_LALR1_CC([%yacc])
 708 # AT_CHECK_CALC_LALR1_CC([%error-verbose])
 709
 710 # AT_CHECK_CALC_LALR1_CC([%error-verbose %locations])
 711
 712 AT_CHECK_CALC_LALR1_CC([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 713
 714 # AT_CHECK_CALC_LALR1_CC([%debug])
 715 AT_CHECK_CALC_LALR1_CC([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 716
 717 AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 718
 719 # AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param {int *count}])