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