tests/calc.at

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