tests/calc.at

   1 # Simple calculator.                         -*- Autotest -*-
   2 # Copyright (C) 2000, 2001, 2002, 2003, 2004  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 #include <stdlib.h>
  45 #include <string.h>
  46 #if HAVE_UNISTD_H
  47 # include <unistd.h>
  48 #else
  49 # undef alarm
  50 # define alarm(seconds) /* empty */
  51 #endif
  52 #include <ctype.h>
  53
  54 /* Exercise pre-prologue dependency to %union.  */
  55 typedef int semantic_value;
  56
  57 static semantic_value global_result = 0;
  58 static int global_count = 0;
  59 %}
  60
  61 /* Exercise %union. */
  62 %union
  63 {
  64   semantic_value ival;
  65 };
  66
  67 %{
  68 static int power (int base, int exponent);
  69 ]AT_LALR1_CC_IF([typedef yy::location YYLTYPE;],
  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([semantic_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 | '-' error          { YYERROR;             }
 123 ;
 124 %%
 125 /* The input. */
 126 static FILE *yyin;
 127
 128 ]AT_LALR1_CC_IF(
 129 [/* A C++ error reporting function. */
 130 void
 131 yy::parser::error (const location& l, const std::string& m)
 132 {
 133   (void) l;
 134   std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
 135 }
 136
 137 int
 138 yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
 139 {
 140   yy::parser parser[]AT_PARAM_IF([ (result, count)]);
 141   parser.set_debug_level (!!YYDEBUG);
 142   return parser.parse ();
 143 }
 144 ],
 145 [static void
 146 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])
 147          AT_PARAM_IF([semantic_value *result, int *count, ])
 148          const char *s)
 149 {
 150 AT_PARAM_IF([(void) result; (void) count;])
 151 AT_YYERROR_SEES_LOC_IF([
 152   fprintf (stderr, "%d.%d",
 153            AT_LOC.first_line, AT_LOC.first_column);
 154   if (AT_LOC.first_line != AT_LOC.last_line)
 155     fprintf (stderr, "-%d.%d",
 156              AT_LOC.last_line,  AT_LOC.last_column - 1);
 157   else if (AT_LOC.first_column != AT_LOC.last_column - 1)
 158     fprintf (stderr, "-%d",
 159              AT_LOC.last_column - 1);
 160   fprintf (stderr, ": ");])
 161   fprintf (stderr, "%s\n", s);
 162 }])[
 163
 164
 165 ]AT_LOCATION_IF([
 166 static YYLTYPE last_yylloc;
 167 ])[
 168 static int
 169 yygetc (]AT_LEX_FORMALS[)
 170 {
 171   int res = getc (yyin);
 172   ]AT_USE_LEX_ARGS[;
 173 ]AT_LOCATION_IF([
 174   last_yylloc = AT_LOC;
 175   if (res == '\n')
 176     {
 177 AT_LALR1_CC_IF(
 178 [     AT_LOC.end.line++;
 179       AT_LOC.end.column = 0;],
 180 [     AT_LOC.last_line++;
 181       AT_LOC.last_column = 0;])
 182     }
 183   else
 184 AT_LALR1_CC_IF(
 185 [    AT_LOC.end.column++;],
 186 [    AT_LOC.last_column++;])
 187 ])[
 188   return res;
 189 }
 190
 191
 192 static void
 193 yyungetc (]AT_LEX_PRE_FORMALS[ int c)
 194 {
 195   ]AT_USE_LEX_ARGS[;
 196 ]AT_LOCATION_IF([
 197   /* Wrong when C == `\n'. */
 198   AT_LOC = last_yylloc;
 199 ])[
 200   ungetc (c, yyin);
 201 }
 202
 203 static int
 204 read_signed_integer (]AT_LEX_FORMALS[)
 205 {
 206   int c = yygetc (]AT_LEX_ARGS[);
 207   int sign = 1;
 208   int n = 0;
 209
 210   ]AT_USE_LEX_ARGS[;
 211   if (c == '-')
 212     {
 213       c = yygetc (]AT_LEX_ARGS[);
 214       sign = -1;
 215     }
 216
 217   while (isdigit (c))
 218     {
 219       n = 10 * n + (c - '0');
 220       c = yygetc (]AT_LEX_ARGS[);
 221     }
 222
 223   yyungetc (]AT_LEX_PRE_ARGS[ c);
 224
 225   return sign * n;
 226 }
 227
 228
 229
 230 /*---------------------------------------------------------------.
 231 | Lexical analyzer returns an integer on the stack and the token |
 232 | NUM, or the ASCII character read if not a number.  Skips all   |
 233 | blanks and tabs, returns 0 for EOF.                            |
 234 `---------------------------------------------------------------*/
 235
 236 static int
 237 yylex (]AT_LEX_FORMALS[)
 238 {
 239   static int init = 1;
 240   int c;
 241
 242   if (init)
 243     {
 244       init = 0;
 245 ]AT_LALR1_CC_IF([],
 246 [AT_LOCATION_IF([
 247       AT_LOC.last_column = 0;
 248       AT_LOC.last_line = 1;
 249 ])])[
 250     }
 251
 252 ]AT_LOCATION_IF([AT_LALR1_CC_IF(
 253 [ AT_LOC.begin = AT_LOC.end;],
 254 [ AT_LOC.first_column = AT_LOC.last_column;
 255   AT_LOC.first_line   = AT_LOC.last_line;
 256 ])])[
 257
 258   /* Skip white space.  */
 259   while ((c = yygetc (]AT_LEX_ARGS[)) == ' ' || c == '\t')
 260     {
 261 ]AT_LOCATION_IF([AT_LALR1_CC_IF(
 262 [     AT_LOC.begin = AT_LOC.end;],
 263 [     AT_LOC.first_column = AT_LOC.last_column;
 264       AT_LOC.first_line   = AT_LOC.last_line;
 265 ])])[
 266     }
 267
 268   /* process numbers   */
 269   if (c == '.' || isdigit (c))
 270     {
 271       yyungetc (]AT_LEX_PRE_ARGS[ c);
 272       ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
 273       return NUM;
 274     }
 275
 276   /* Return end-of-file.  */
 277   if (c == EOF)
 278     return CALC_EOF;
 279
 280   /* Return single chars. */
 281   return c;
 282 }
 283
 284 static int
 285 power (int base, int exponent)
 286 {
 287   int res = 1;
 288   if (exponent < 0)
 289     exit (1);
 290   for (/* Niente */; exponent; --exponent)
 291     res *= base;
 292   return res;
 293 }
 294
 295
 296 int
 297 main (int argc, const char **argv)
 298 {
 299   semantic_value result = 0;
 300   int count = 0;
 301   int status;
 302
 303   alarm (10);
 304   if (argc == 2)
 305     yyin = fopen (argv[1], "r");
 306   else
 307     yyin = stdin;
 308
 309   if (!yyin)
 310     {
 311       perror (argv[1]);
 312       exit (1);
 313     }
 314
 315 ]AT_LALR1_CC_IF([], [m4_bmatch([$4], [%debug],
 316 [  yydebug = 1;])])[
 317   status = yyparse (]AT_PARAM_IF([&result, &count])[);
 318   if (global_result != result)
 319     abort ();
 320   if (global_count != count)
 321     abort ();
 322   return status;
 323 }
 324 ]])
 325 ])# _AT_DATA_CALC_Y
 326
 327
 328 # AT_DATA_CALC_Y([BISON-OPTIONS])
 329 # -------------------------------
 330 # Produce `calc.y'.
 331 m4_define([AT_DATA_CALC_Y],
 332 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
 333 ])
 334
 335
 336
 337 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0])
 338 # ------------------------------------------------------------
 339 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
 340 #
 341 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
 342 # NUM-STDERR-LINES is the number of expected lines on stderr.
 343 #
 344 # We don't count GLR's traces yet, since its traces are somewhat
 345 # different from LALR's.
 346 m4_define([_AT_CHECK_CALC],
 347 [AT_DATA([[input]],
 348 [[$2
 349 ]])
 350 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
 351 m4_bmatch([$1],
 352   [%debug.*%glr\|%glr.*%debug],
 353      [],
 354   [%debug],
 355      [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
 356 ])])
 357 ])
 358
 359
 360 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
 361 #                      [NUM-DEBUG-LINES],
 362 #                      [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
 363 # ---------------------------------------------------------
 364 # Run `calc' on INPUT, and expect a `syntax error' message.
 365 #
 366 # If INPUT starts with a slash, it is used as absolute input file name,
 367 # otherwise as contents.
 368 #
 369 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
 370 # is correctly output on stderr.
 371 #
 372 # If BISON-OPTIONS contains `%error-verbose', then make sure the
 373 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
 374 # on STDERR.
 375 #
 376 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 377 # is the number of expected lines on stderr.
 378 m4_define([_AT_CHECK_CALC_ERROR],
 379 [m4_bmatch([$3], [^/],
 380            [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
 381            [AT_DATA([[input]],
 382 [[$3
 383 ]])
 384 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
 385 m4_bmatch([$1],
 386   [%debug.*%glr\|%glr.*%debug],
 387      [],
 388   [%debug],
 389      [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4
 390 ])])
 391
 392 # Normalize the observed and expected error messages, depending upon the
 393 # options.
 394 # 1. Remove the traces from observed.
 395 sed '/^Starting/d
 396 /^Entering/d
 397 /^Stack/d
 398 /^Reading/d
 399 /^Reducing/d
 400 /^Shifting/d
 401 /^state/d
 402 /^Error:/d
 403 /^Next/d
 404 /^Discarding/d
 405 /^yydestructor:/d' stderr >at-stderr
 406 mv at-stderr stderr
 407 # 2. Create the reference error message.
 408 AT_DATA([[expout]],
 409 [$5
 410 ])
 411 # 3. If locations are not used, remove them.
 412 AT_YYERROR_SEES_LOC_IF([],
 413 [[sed 's/^[-0-9.]*: //' expout >at-expout
 414 mv at-expout expout]])
 415 # 4. If error-verbose is not used, strip the`, unexpected....' part.
 416 m4_bmatch([$1], [%error-verbose], [],
 417 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
 418 mv at-expout expout]])
 419 # 5. Check
 420 AT_CHECK([cat stderr], 0, [expout])
 421 ])
 422
 423
 424 # AT_CHECK_CALC([BISON-OPTIONS [, EXPECTED-TO-FAIL]])
 425 # ------------------------------
 426 # Start a testing chunk which compiles `calc' grammar with
 427 # BISON-OPTIONS, and performs several tests over the parser.
 428 # However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
 429 m4_define([AT_CHECK_CALC],
 430 [# We use integers to avoid dependencies upon the precision of doubles.
 431 AT_SETUP([Calculator $1])
 432
 433 m4_ifval([$2], [AT_CHECK([exit 77])])
 434
 435 AT_BISON_OPTION_PUSHDEFS([$1])
 436
 437 AT_DATA_CALC_Y([$1])
 438
 439 AT_LALR1_CC_IF(
 440   [AT_CHECK([bison -o calc.cc calc.y])
 441    AT_COMPILE_CXX([calc])],
 442   [AT_CHECK([bison -o calc.c calc.y])
 443    AT_COMPILE([calc])])
 444
 445 # Test the priorities.
 446 _AT_CHECK_CALC([$1],
 447 [1 + 2 * 3 = 7
 448 1 + 2 * -3 = -5
 449
 450 -1^2 = -1
 451 (-1)^2 = 1
 452
 453 ---1 = -1
 454
 455 1 - 2 - 3 = -4
 456 1 - (2 - 3) = 2
 457
 458 2^2^3 = 256
 459 (2^2)^3 = 64],
 460                [570])
 461
 462 # Some syntax errors.
 463 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [13],
 464                      [1.2: syntax error, unexpected "number"])
 465 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [18],
 466                      [1.2: syntax error, unexpected '/', expecting "number" or '-' or '(' or '!'])
 467 _AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
 468                      [1.0: syntax error, unexpected $undefined])
 469 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [26],
 470                      [1.6: syntax error, unexpected '='])
 471 _AT_CHECK_CALC_ERROR([$1], [1],
 472                      [
 473 +1],
 474                      [16],
 475                      [2.0: syntax error, unexpected '+'])
 476 # Exercise error messages with EOF: work on an empty file.
 477 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [5],
 478                      [1.0: syntax error, unexpected "end of input"])
 479
 480 # Exercise the error token: without it, we die at the first error,
 481 # hence be sure to
 482 #
 483 # - have several errors which exercise different shift/discardings
 484 #   - (): nothing to pop, nothing to discard
 485 #   - (1 + 1 + 1 +): a lot to pop, nothing to discard
 486 #   - (* * *): nothing to pop, a lot to discard
 487 #   - (1 + 2 * *): some to pop and discard
 488 #
 489 # - test the action associated to `error'
 490 #
 491 # - check the look-ahead that triggers an error is not discarded
 492 #   when we enter error recovery.  Below, the look-ahead causing the
 493 #   first error is ")", which is needed to recover from the error and
 494 #   produce the "0" that triggers the "0 != 1" error.
 495 #
 496 _AT_CHECK_CALC_ERROR([$1], [0],
 497                      [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
 498                      [188],
 499 [1.1: syntax error, unexpected ')', expecting "number" or '-' or '(' or '!'
 500 1.17: syntax error, unexpected ')', expecting "number" or '-' or '(' or '!'
 501 1.22: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
 502 1.40: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
 503 calc: error: 4444 != 1])
 504
 505 # The same, but this time exercising explicitly triggered syntax errors.
 506 # POSIX says the look-ahead causing the error should not be discarded.
 507 _AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [75],
 508 [1.9: syntax error, unexpected "number"
 509 calc: error: 2222 != 1])
 510 _AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [85],
 511 [1.3: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
 512 1.11: syntax error, unexpected "number"
 513 calc: error: 2222 != 1])
 514 AT_BISON_OPTION_POPDEFS
 515
 516 AT_CLEANUP
 517 ])# AT_CHECK_CALC
 518
 519
 520
 521
 522 # ------------------------ #
 523 # Simple LALR Calculator.  #
 524 # ------------------------ #
 525
 526 AT_BANNER([[Simple LALR Calculator.]])
 527
 528 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
 529 # -----------------------------------
 530 # Start a testing chunk which compiles `calc' grammar with
 531 # BISON-OPTIONS, and performs several tests over the parser.
 532 m4_define([AT_CHECK_CALC_LALR],
 533 [AT_CHECK_CALC($@)])
 534
 535 AT_CHECK_CALC_LALR()
 536
 537 AT_CHECK_CALC_LALR([%defines])
 538 AT_CHECK_CALC_LALR([%locations])
 539 AT_CHECK_CALC_LALR([%name-prefix="calc"])
 540 AT_CHECK_CALC_LALR([%verbose])
 541 AT_CHECK_CALC_LALR([%yacc])
 542 AT_CHECK_CALC_LALR([%error-verbose])
 543
 544 AT_CHECK_CALC_LALR([%pure-parser %locations])
 545 AT_CHECK_CALC_LALR([%error-verbose %locations])
 546
 547 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 548
 549 AT_CHECK_CALC_LALR([%debug])
 550 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 551
 552 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 553
 554 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}])
 555
 556
 557 # ----------------------- #
 558 # Simple GLR Calculator.  #
 559 # ----------------------- #
 560
 561 AT_BANNER([[Simple GLR Calculator.]])
 562
 563 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
 564 # ----------------------------------
 565 # Start a testing chunk which compiles `calc' grammar with
 566 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
 567 m4_define([AT_CHECK_CALC_GLR],
 568 [AT_CHECK_CALC([%glr-parser] $@)])
 569
 570
 571 AT_CHECK_CALC_GLR()
 572
 573 AT_CHECK_CALC_GLR([%defines])
 574 AT_CHECK_CALC_GLR([%locations])
 575 AT_CHECK_CALC_GLR([%name-prefix="calc"])
 576 AT_CHECK_CALC_GLR([%verbose])
 577 AT_CHECK_CALC_GLR([%yacc])
 578 AT_CHECK_CALC_GLR([%error-verbose])
 579
 580 AT_CHECK_CALC_GLR([%pure-parser %locations])
 581 AT_CHECK_CALC_GLR([%error-verbose %locations])
 582
 583 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 584
 585 AT_CHECK_CALC_GLR([%debug])
 586 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 587
 588 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 589
 590 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}])
 591
 592
 593 # ----------------------------- #
 594 # Simple LALR1 C++ Calculator.  #
 595 # ----------------------------- #
 596
 597 AT_BANNER([[Simple LALR1 C++ Calculator.]])
 598
 599 # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
 600 # ---------------------------------------
 601 # Start a testing chunk which compiles `calc' grammar with
 602 # the C++ skeleton, and performs several tests over the parser.
 603 m4_define([AT_CHECK_CALC_LALR1_CC],
 604 [AT_CHECK_CALC([%skeleton "lalr1.cc"] $@)])
 605
 606 # AT_CHECK_CALC_LALR1_CC()
 607
 608 AT_CHECK_CALC_LALR1_CC([%defines %locations])
 609
 610 AT_CHECK_CALC_LALR1_CC([%defines])
 611 # AT_CHECK_CALC_LALR1_CC([%locations])
 612 # AT_CHECK_CALC_LALR1_CC([%name-prefix="calc"])
 613 # AT_CHECK_CALC_LALR1_CC([%verbose])
 614 # AT_CHECK_CALC_LALR1_CC([%yacc])
 615 # AT_CHECK_CALC_LALR1_CC([%error-verbose])
 616
 617 # AT_CHECK_CALC_LALR1_CC([%pure-parser %locations])
 618 # AT_CHECK_CALC_LALR1_CC([%error-verbose %locations])
 619
 620 AT_CHECK_CALC_LALR1_CC([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 621
 622 # AT_CHECK_CALC_LALR1_CC([%debug])
 623 AT_CHECK_CALC_LALR1_CC([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 624
 625 AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 626
 627 AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])