tests/calc.at

   1 # Checking the output filenames.                         -*- Autotest -*-
   2 # Copyright (C) 2000, 2001, 2002 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([calc.y],
  39 [[/* Infix notation calculator--calc */
  40 ]$4[
  41 %{
  42 #include <config.h>
  43 /* We don't need perfect functions for these tests. */
  44 #undef malloc
  45 #undef memcmp
  46 #undef realloc
  47 #include <stdio.h>
  48
  49 #if STDC_HEADERS
  50 # include <stdlib.h>
  51 # include <string.h>
  52 #endif
  53 #include <ctype.h>
  54 #include <assert.h>
  55
  56 extern void perror (const char *s);
  57
  58 /* Exercise pre-prologue dependency to %union.  */
  59 typedef int value_t;
  60
  61 value_t global_result = 0;
  62 int global_count = 0;
  63
  64 %}
  65
  66 /* Exercise %union. */
  67 %union
  68 {
  69   value_t ival;
  70 };
  71
  72 %{
  73 #if YYPURE
  74 #  define LOC     (*yylloc)
  75 #  define VAL     (*yylval)
  76 #else
  77 #  define LOC     (yylloc)
  78 #  define VAL     (yylval)
  79 #endif
  80
  81 #define YYLLOC_FORMAL   ]AT_LOCATION_IF([, YYLTYPE *yylloc])[
  82 #define YYLLOC_ARG      ]AT_LOCATION_IF([, yylloc])[
  83 #define USE_YYLLOC      ]AT_LOCATION_IF([(void) yylloc;])[
  84
  85 #if YYPURE
  86 #  define LEX_FORMALS     YYSTYPE *yylval YYLLOC_FORMAL
  87 #  define LEX_ARGS        yylval          YYLLOC_ARG
  88 #  define USE_LEX_ARGS    (void) yylval;  USE_YYLLOC
  89 #  define LEX_PRE_FORMALS   LEX_FORMALS,
  90 #  define LEX_PRE_ARGS      LEX_ARGS,
  91 #else
  92 #  define LEX_FORMALS       void
  93 #  define LEX_PRE_FORMALS
  94 #  define LEX_ARGS
  95 #  define LEX_PRE_ARGS
  96 #  define USE_LEX_ARGS
  97 #endif
  98
  99 static int power (int base, int exponent);
 100 /* yyerror receives the location if:
 101    - %location & %pure & %glr
 102    - %location & %pure & %yacc & %parse-param. */
 103 static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
 104                      ]AT_PARAM_IF([value_t *result, int *count, ])[
 105                      const char *s
 106                      );
 107 static int yylex (LEX_FORMALS);
 108 static int yygetc (LEX_FORMALS);
 109 static void yyungetc (LEX_PRE_FORMALS int c);
 110 %}
 111
 112 /* Bison Declarations */
 113 %token CALC_EOF 0 "end of input"
 114 %token <ival> NUM "number"
 115 %type  <ival> exp
 116
 117 %nonassoc '=' /* comparison            */
 118 %left '-' '+'
 119 %left '*' '/'
 120 %left NEG     /* negation--unary minus */
 121 %right '^'    /* exponentiation        */
 122
 123 /* Grammar follows */
 124 %%
 125 input:
 126   line
 127 | input line         { ]AT_PARAM_IF([++*count; ++global_count;])[ }
 128 ;
 129
 130 line:
 131   '\n'
 132 | exp '\n'           { ]AT_PARAM_IF([*result = global_result = $1;])[ }
 133 ;
 134
 135 exp:
 136   NUM                { $$ = $1;             }
 137 | exp '=' exp
 138   {
 139     if ($1 != $3)
 140       fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
 141     $$ = $1;
 142   }
 143 | exp '+' exp        { $$ = $1 + $3;        }
 144 | exp '-' exp        { $$ = $1 - $3;        }
 145 | exp '*' exp        { $$ = $1 * $3;        }
 146 | exp '/' exp        { $$ = $1 / $3;        }
 147 | '-' exp  %prec NEG { $$ = -$2;            }
 148 | exp '^' exp        { $$ = power ($1, $3); }
 149 | '(' exp ')'        { $$ = $2;             }
 150 | '(' error ')'      { $$ = 0;              }
 151 ;
 152 %%
 153 /* The input. */
 154 FILE *yyin;
 155
 156 static void
 157 yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
 158          ]AT_PARAM_IF([value_t *result, int *count, ])[
 159          const char *s
 160          )
 161 {
 162 ]AT_PARAM_IF([(void) result; (void) count; ])[
 163 ]AT_YYERROR_SEES_LOC_IF([
 164   fprintf (stderr, "%d.%d-%d.%d: ",
 165            LOC.first_line, LOC.first_column,
 166            LOC.last_line, LOC.last_column);
 167 ])[
 168   fprintf (stderr, "%s\n", s);
 169 }
 170
 171
 172 ]AT_LOCATION_IF([
 173 static YYLTYPE last_yylloc;
 174 ])[
 175 static int
 176 yygetc (LEX_FORMALS)
 177 {
 178   int res = getc (yyin);
 179   USE_LEX_ARGS;
 180 ]AT_LOCATION_IF([
 181   last_yylloc = LOC;
 182   if (res == '\n')
 183     {
 184       LOC.last_line++;
 185       LOC.last_column = 1;
 186     }
 187   else
 188     LOC.last_column++;
 189 ])[
 190   return res;
 191 }
 192
 193
 194 static void
 195 yyungetc (LEX_PRE_FORMALS int c)
 196 {
 197   USE_LEX_ARGS;
 198 ]AT_LOCATION_IF([
 199   /* Wrong when C == `\n'. */
 200   LOC = last_yylloc;
 201 ])[
 202   ungetc (c, yyin);
 203 }
 204
 205 static int
 206 read_signed_integer (LEX_FORMALS)
 207 {
 208   int c = yygetc (LEX_ARGS);
 209   int sign = 1;
 210   int n = 0;
 211
 212   USE_LEX_ARGS;
 213   if (c == '-')
 214     {
 215       c = yygetc (LEX_ARGS);
 216       sign = -1;
 217     }
 218
 219   while (isdigit (c))
 220     {
 221       n = 10 * n + (c - '0');
 222       c = yygetc (LEX_ARGS);
 223     }
 224
 225   yyungetc (LEX_PRE_ARGS c);
 226
 227   return sign * n;
 228 }
 229
 230
 231
 232 /*---------------------------------------------------------------.
 233 | Lexical analyzer returns an integer on the stack and the token |
 234 | NUM, or the ASCII character read if not a number.  Skips all   |
 235 | blanks and tabs, returns 0 for EOF.                            |
 236 `---------------------------------------------------------------*/
 237
 238 static int
 239 yylex (LEX_FORMALS)
 240 {
 241   static int init = 1;
 242   int c;
 243
 244   if (init)
 245     {
 246       init = 0;
 247 ]AT_LOCATION_IF([
 248       LOC.last_column = 1;
 249       LOC.last_line = 1;
 250 ])[
 251     }
 252
 253 ]AT_LOCATION_IF([
 254   LOC.first_column = LOC.last_column;
 255   LOC.first_line = LOC.last_line;
 256 ])[
 257
 258   /* Skip white space.  */
 259   while ((c = yygetc (LEX_ARGS)) == ' ' || c == '\t')
 260     {
 261 ]AT_LOCATION_IF([
 262       LOC.first_column = LOC.last_column;
 263       LOC.first_line = LOC.last_line;
 264 ])[
 265     }
 266
 267   /* process numbers   */
 268   if (c == '.' || isdigit (c))
 269     {
 270       yyungetc (LEX_PRE_ARGS c);
 271       VAL.ival = read_signed_integer (LEX_ARGS);
 272       return NUM;
 273     }
 274
 275   /* Return end-of-file.  */
 276   if (c == EOF)
 277     return CALC_EOF;
 278
 279   /* Return single chars. */
 280   return c;
 281 }
 282
 283 static int
 284 power (int base, int exponent)
 285 {
 286   int res = 1;
 287   if (exponent < 0)
 288     exit (1);
 289   for (/* Niente */; exponent; --exponent)
 290     res *= base;
 291   return res;
 292 }
 293
 294 int
 295 main (int argc, const char **argv)
 296 {
 297   value_t result = 0;
 298   int count = 0;
 299   yyin = NULL;
 300
 301   if (argc == 2)
 302     yyin = fopen (argv[1], "r");
 303   else
 304     yyin = stdin;
 305
 306   if (!yyin)
 307     {
 308       perror (argv[1]);
 309       exit (1);
 310     }
 311
 312 #if YYDEBUG
 313   yydebug = 1;
 314 #endif
 315   yyparse (]AT_PARAM_IF([&result, &count])[);
 316   assert (global_result == result);
 317   assert (global_count  == count);
 318
 319   return 0;
 320 }
 321 ]])
 322 ])# _AT_DATA_CALC_Y
 323
 324
 325 # AT_DATA_CALC_Y([BISON-OPTIONS])
 326 # -------------------------------
 327 # Produce `calc.y'.
 328 m4_define([AT_DATA_CALC_Y],
 329 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
 330 ])
 331
 332
 333
 334 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0])
 335 # ------------------------------------------------------------
 336 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
 337 #
 338 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
 339 # NUM-STDERR-LINES is the number of expected lines on stderr.
 340 #
 341 # We don't count GLR's traces yet, since its traces are somewhat
 342 # different from LALR's.
 343 m4_define([_AT_CHECK_CALC],
 344 [AT_DATA([[input]],
 345 [[$2
 346 ]])
 347 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
 348 m4_bmatch([$1],
 349   [%debug.*%glr\|%glr.*%debug],
 350      [],
 351   [%debug],
 352      [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
 353 ])])
 354 ])
 355
 356
 357 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, INPUT, [NUM-DEBUG-LINES],
 358 #                      [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
 359 # -------------------------------------------------------------
 360 # Run `calc' on INPUT, and expect a `parse error' message.
 361 #
 362 # If INPUT starts with a slash, it is used as absolute input file name,
 363 # otherwise as contents.
 364 #
 365 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
 366 # is correctly output on stderr.
 367 #
 368 # If BISON-OPTIONS contains `%error-verbose', then make sure the
 369 # IF-YYERROR-VERBOSE message is properly output after `parse error, '
 370 # on STDERR.
 371 #
 372 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
 373 # is the number of expected lines on stderr.
 374 m4_define([_AT_CHECK_CALC_ERROR],
 375 [m4_bmatch([$2], [^/],
 376            [AT_PARSER_CHECK([./calc $2], 0, [], [stderr])],
 377            [AT_DATA([[input]],
 378 [[$2
 379 ]])
 380 AT_PARSER_CHECK([./calc input], 0, [], [stderr])])
 381 m4_bmatch([$1],
 382   [%debug.*%glr\|%glr.*%debug],
 383      [],
 384   [%debug],
 385      [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
 386 ])])
 387
 388 # Normalize the observed and expected error messages, depending upon the
 389 # options.
 390 # 1. Remove the traces from observed.
 391 sed '/^Starting/d
 392 /^Entering/d
 393 /^Stack/d
 394 /^Reading/d
 395 /^Reducing/d
 396 /^Shifting/d
 397 /^state/d
 398 /^Error:/d
 399 /^Next/d
 400 /^Discarding/d
 401 /^yydestructor:/d' stderr >at-stderr
 402 mv at-stderr stderr
 403 # 2. Create the reference error message.
 404 AT_DATA([[expout]],
 405 [$4
 406 ])
 407 # 3. If locations are not used, remove them.
 408 AT_YYERROR_SEES_LOC_IF([],
 409 [[sed 's/^[-0-9.]*: //' expout >at-expout
 410 mv at-expout expout]])
 411 # 4. If error-verbose is not used, strip the`, unexpected....' part.
 412 m4_bmatch([$1], [%error-verbose], [],
 413 [[sed 's/parse error, .*$/parse error/' expout >at-expout
 414 mv at-expout expout]])
 415 # 5. Check
 416 AT_CHECK([cat stderr], 0, [expout])
 417 ])
 418
 419
 420 # AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS])
 421 # -----------------------------------------
 422 # This macro works around the impossibility to define macros
 423 # inside macros, because issuing `[$1]' is not possible in M4 :(.
 424 # This sucks hard, GNU M4 should really provide M5 like $$1.
 425 m4_define([AT_CHECK_PUSHDEFS],
 426 [m4_if([$1$2], $[1]$[2], [],
 427        [m4_fatal([$0: Invalid arguments: $@])])dnl
 428 m4_pushdef([AT_PARAM_IF],
 429 [m4_bmatch([$3], [%parse-param], [$1], [$2])])
 430 m4_pushdef([AT_LOCATION_IF],
 431 [m4_bmatch([$3], [%locations], [$1], [$2])])
 432 m4_pushdef([AT_PURE_IF],
 433 [m4_bmatch([$3], [%pure-parser], [$1], [$2])])
 434 m4_pushdef([AT_GLR_IF],
 435 [m4_bmatch([$3], [%glr-parser], [$1], [$2])])
 436 m4_pushdef([AT_PURE_AND_LOC_IF],
 437 [m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations],
 438            [$1], [$2])])
 439 m4_pushdef([AT_GLR_OR_PARAM_IF],
 440 [m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
 441
 442 # yyerror receives the location if %location & %pure & (%glr or %parse-param).
 443 m4_pushdef([AT_YYERROR_ARG_LOC_IF],
 444 [AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
 445                     [$2])])
 446 # yyerror cannot see the locations if !glr & pure & !param.
 447 m4_pushdef([AT_YYERROR_SEES_LOC_IF],
 448 [AT_LOCATION_IF([AT_GLR_IF([$1],
 449                            [AT_PURE_IF([AT_PARAM_IF([$1], [$2])],
 450                                        [$1])])],
 451                 [$2])])
 452 ])
 453
 454
 455 # AT_CALC_POPDEFS
 456 # ---------------
 457 m4_define([AT_CHECK_POPDEFS],
 458 [m4_popdef([AT_YYERROR_SEES_LOC_IF])
 459 m4_popdef([AT_YYERROR_ARG_LOC_IF])
 460 m4_popdef([AT_GLR_OR_PARAM_IF])
 461 m4_popdef([AT_PURE_AND_LOC_IF])
 462 m4_popdef([AT_GLR_IF])
 463 m4_popdef([AT_LOCATION_IF])
 464 m4_popdef([AT_PARAM_IF])
 465 ])
 466
 467
 468
 469 # AT_CHECK_CALC([BISON-OPTIONS])
 470 # ------------------------------
 471 # Start a testing chunk which compiles `calc' grammar with
 472 # BISON-OPTIONS, and performs several tests over the parser.
 473 m4_define([AT_CHECK_CALC],
 474 [# We use integers to avoid dependencies upon the precision of doubles.
 475 AT_SETUP([Calculator $1])
 476
 477 AT_CHECK_PUSHDEFS($[1], $[2], [$1])
 478
 479 AT_DATA_CALC_Y([$1])
 480
 481 # Specify the output files to avoid problems on different file systems.
 482 AT_CHECK([bison -o calc.c calc.y],
 483          [0], [], [])
 484
 485 AT_COMPILE([calc])
 486
 487 # Test the priorities.
 488 _AT_CHECK_CALC([$1],
 489 [1 + 2 * 3 = 7
 490 1 + 2 * -3 = -5
 491
 492 -1^2 = -1
 493 (-1)^2 = 1
 494
 495 ---1 = -1
 496
 497 1 - 2 - 3 = -4
 498 1 - (2 - 3) = 2
 499
 500 2^2^3 = 256
 501 (2^2)^3 = 64],
 502                [486])
 503
 504 # Some parse errors.
 505 _AT_CHECK_CALC_ERROR([$1], [0 0], [11],
 506                      [1.3-1.4: parse error, unexpected "number"])
 507 _AT_CHECK_CALC_ERROR([$1], [1//2], [15],
 508                      [1.3-1.4: parse error, unexpected '/', expecting "number" or '-' or '('])
 509 _AT_CHECK_CALC_ERROR([$1], [error], [4],
 510                      [1.1-1.2: parse error, unexpected $undefined, expecting "number" or '-' or '\n' or '('])
 511 _AT_CHECK_CALC_ERROR([$1], [1 = 2 = 3], [22],
 512                      [1.7-1.8: parse error, unexpected '='])
 513 _AT_CHECK_CALC_ERROR([$1],
 514                      [
 515 +1],
 516                      [14],
 517                      [2.1-2.2: parse error, unexpected '+'])
 518 # Exercise error messages with EOF: work on an empty file.
 519 _AT_CHECK_CALC_ERROR([$1], [/dev/null], [4],
 520                      [1.1-1.2: parse error, unexpected "end of input", expecting "number" or '-' or '\n' or '('])
 521
 522 # Exercise the error token: without it, we die at the first error,
 523 # hence be sure i. to have several errors, ii. to test the action
 524 # associated to `error'.
 525 _AT_CHECK_CALC_ERROR([$1], [(1 ++ 2) + (0 0) = 1], [82],
 526 [1.5-1.6: parse error, unexpected '+', expecting "number" or '-' or '('
 527 1.15-1.16: parse error, unexpected "number"
 528 calc: error: 0 != 1])
 529
 530 AT_CHECK_POPDEFS
 531
 532 AT_CLEANUP
 533 ])# AT_CHECK_CALC
 534
 535
 536
 537
 538 # ------------------------ #
 539 # Simple LALR Calculator.  #
 540 # ------------------------ #
 541
 542 AT_BANNER([[Simple LALR Calculator.]])
 543
 544 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
 545 # -----------------------------------
 546 # Start a testing chunk which compiles `calc' grammar with
 547 # BISON-OPTIONS, and performs several tests over the parser.
 548 m4_define([AT_CHECK_CALC_LALR],
 549 [AT_CHECK_CALC($@)])
 550
 551 AT_CHECK_CALC_LALR()
 552
 553 AT_CHECK_CALC_LALR([%defines])
 554 AT_CHECK_CALC_LALR([%locations])
 555 AT_CHECK_CALC_LALR([%name-prefix="calc"])
 556 AT_CHECK_CALC_LALR([%verbose])
 557 AT_CHECK_CALC_LALR([%yacc])
 558 AT_CHECK_CALC_LALR([%error-verbose])
 559
 560 AT_CHECK_CALC_LALR([%error-verbose %locations])
 561
 562 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 563
 564 AT_CHECK_CALC_LALR([%debug])
 565 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 566
 567 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 568
 569 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param "value_t *result", "result" %parse-param "int *count", "count"])
 570
 571
 572 # ----------------------- #
 573 # Simple GLR Calculator.  #
 574 # ----------------------- #
 575
 576 AT_BANNER([[Simple GLR Calculator.]])
 577
 578 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
 579 # ----------------------------------
 580 # Start a testing chunk which compiles `calc' grammar with
 581 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
 582 m4_define([AT_CHECK_CALC_GLR],
 583 [AT_CHECK_CALC([%glr-parser] $@)])
 584
 585
 586 AT_CHECK_CALC_GLR()
 587
 588 AT_CHECK_CALC_GLR([%defines])
 589 AT_CHECK_CALC_GLR([%locations])
 590 AT_CHECK_CALC_GLR([%name-prefix="calc"])
 591 AT_CHECK_CALC_GLR([%verbose])
 592 AT_CHECK_CALC_GLR([%yacc])
 593 AT_CHECK_CALC_GLR([%error-verbose])
 594
 595 AT_CHECK_CALC_GLR([%error-verbose %locations])
 596
 597 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
 598
 599 AT_CHECK_CALC_GLR([%debug])
 600 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 601
 602 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
 603
 604 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param "value_t *result", "result" %parse-param "int *count", "count"])