1 # Checking the output filenames. -*- Autotest -*-
2 # Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
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)
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.
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
19 ## ---------------------------------------------------- ##
20 ## Compile the grammar described in the documentation. ##
21 ## ---------------------------------------------------- ##
24 # ------------------------- #
25 # Helping Autotest macros. #
26 # ------------------------- #
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 */
50 extern void perror (const char *s);
52 /* Exercise pre-prologue dependency to %union. */
55 static value global_result = 0;
56 static int global_count = 0;
58 ]AT_LALR1_CC_IF([typedef yy::Location YYLTYPE;])[
61 /* Exercise %union. */
68 static int power (int base, int exponent);
69 /* yyerror receives the location if:
70 - %location & %pure & %glr
71 - %location & %pure & %yacc & %parse-param. */
72 static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
73 ]AT_PARAM_IF([value *result, int *count, ])[
76 static int yylex (]AT_LEX_FORMALS[);
77 static int yygetc (]AT_LEX_FORMALS[);
78 static void yyungetc (]AT_LEX_PRE_FORMALS[ int c);
81 /* Bison Declarations */
82 %token CALC_EOF 0 "end of input"
83 %token <ival> NUM "number"
86 %nonassoc '=' /* comparison */
89 %left NEG /* negation--unary minus */
90 %right '^' /* exponentiation */
96 | input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
101 | exp '\n' { ]AT_PARAM_IF([*result = global_result = $1;])[ }
109 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
112 | exp '+' exp { $$ = $1 + $3; }
113 | exp '-' exp { $$ = $1 - $3; }
114 | exp '*' exp { $$ = $1 * $3; }
115 | exp '/' exp { $$ = $1 / $3; }
116 | '-' exp %prec NEG { $$ = -$2; }
117 | exp '^' exp { $$ = power ($1, $3); }
118 | '(' exp ')' { $$ = $2; }
119 | '(' error ')' { $$ = 1111; }
127 [/* Currently, print_ is required in C++. */
129 yy::Parser::print_ ()
131 std::cerr << location;
134 /* A C++ error reporting function. */
136 yy::Parser::error_ ()
138 std::cerr << location << ": " << message << std::endl;
144 yy::Parser parser = yy::Parser (!!YYDEBUG[]AT_LOCATION_IF([,
145 yy::Location::Location ()]));
146 return parser.parse ();
150 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])
151 AT_PARAM_IF([value *result, int *count, ])
154 AT_PARAM_IF([(void) result; (void) count;])
155 AT_YYERROR_SEES_LOC_IF([
156 fprintf (stderr, "%d.%d",
157 AT_LOC.first_line, AT_LOC.first_column);
158 if (AT_LOC.first_line != AT_LOC.last_line)
159 fprintf (stderr, "-%d.%d",
160 AT_LOC.last_line, AT_LOC.last_column - 1);
161 else if (AT_LOC.first_column != AT_LOC.last_column - 1)
162 fprintf (stderr, "-%d",
163 AT_LOC.last_column - 1);
164 fprintf (stderr, ": ");])
165 fprintf (stderr, "%s\n", s);
170 static YYLTYPE last_yylloc;
173 yygetc (]AT_LEX_FORMALS[)
175 int res = getc (yyin);
178 last_yylloc = AT_LOC;
183 AT_LOC.end.column = 0;],
184 [ AT_LOC.last_line++;
185 AT_LOC.last_column = 0;])
189 [ AT_LOC.end.column++;],
190 [ AT_LOC.last_column++;])
197 yyungetc (]AT_LEX_PRE_FORMALS[ int c)
201 /* Wrong when C == `\n'. */
202 AT_LOC = last_yylloc;
208 read_signed_integer (]AT_LEX_FORMALS[)
210 int c = yygetc (]AT_LEX_ARGS[);
217 c = yygetc (]AT_LEX_ARGS[);
223 n = 10 * n + (c - '0');
224 c = yygetc (]AT_LEX_ARGS[);
227 yyungetc (]AT_LEX_PRE_ARGS[ c);
234 /*---------------------------------------------------------------.
235 | Lexical analyzer returns an integer on the stack and the token |
236 | NUM, or the ASCII character read if not a number. Skips all |
237 | blanks and tabs, returns 0 for EOF. |
238 `---------------------------------------------------------------*/
241 yylex (]AT_LEX_FORMALS[)
251 AT_LOC.last_column = 0;
252 AT_LOC.last_line = 1;
257 [ AT_LOC.begin = AT_LOC.end;],
259 AT_LOC.first_column = AT_LOC.last_column;
260 AT_LOC.first_line = AT_LOC.last_line;
263 /* Skip white space. */
264 while ((c = yygetc (]AT_LEX_ARGS[)) == ' ' || c == '\t')
267 [ AT_LOC.begin = AT_LOC.end;],
269 AT_LOC.first_column = AT_LOC.last_column;
270 AT_LOC.first_line = AT_LOC.last_line;
274 /* process numbers */
275 if (c == '.' || isdigit (c))
277 yyungetc (]AT_LEX_PRE_ARGS[ c);
278 ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
282 /* Return end-of-file. */
286 /* Return single chars. */
291 power (int base, int exponent)
296 for (/* Niente */; exponent; --exponent)
303 main (int argc, const char **argv)
310 yyin = fopen (argv[1], "r");
323 status = yyparse (]AT_PARAM_IF([&result, &count])[);
324 if (global_result != result)
326 if (global_count != count)
334 # AT_DATA_CALC_Y([BISON-OPTIONS])
335 # -------------------------------
337 m4_define([AT_DATA_CALC_Y],
338 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
343 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0])
344 # ------------------------------------------------------------
345 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
347 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
348 # NUM-STDERR-LINES is the number of expected lines on stderr.
350 # We don't count GLR's traces yet, since its traces are somewhat
351 # different from LALR's.
352 m4_define([_AT_CHECK_CALC],
356 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
358 [%debug.*%glr\|%glr.*%debug],
361 [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
366 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
368 # [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
369 # ---------------------------------------------------------
370 # Run `calc' on INPUT, and expect a `syntax error' message.
372 # If INPUT starts with a slash, it is used as absolute input file name,
373 # otherwise as contents.
375 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
376 # is correctly output on stderr.
378 # If BISON-OPTIONS contains `%error-verbose', then make sure the
379 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
382 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
383 # is the number of expected lines on stderr.
384 m4_define([_AT_CHECK_CALC_ERROR],
385 [m4_bmatch([$3], [^/],
386 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
390 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
392 [%debug.*%glr\|%glr.*%debug],
395 [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4
398 # Normalize the observed and expected error messages, depending upon the
400 # 1. Remove the traces from observed.
411 /^yydestructor:/d' stderr >at-stderr
413 # 2. Create the reference error message.
417 # 3. If locations are not used, remove them.
418 AT_YYERROR_SEES_LOC_IF([],
419 [[sed 's/^[-0-9.]*: //' expout >at-expout
420 mv at-expout expout]])
421 # 4. If error-verbose is not used, strip the`, unexpected....' part.
422 m4_bmatch([$1], [%error-verbose], [],
423 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
424 mv at-expout expout]])
426 AT_CHECK([cat stderr], 0, [expout])
430 # AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS])
431 # -----------------------------------------
432 # This macro works around the impossibility to define macros
433 # inside macros, because issuing `[$1]' is not possible in M4 :(.
434 # This sucks hard, GNU M4 should really provide M5 like $$1.
435 m4_define([AT_CHECK_PUSHDEFS],
436 [m4_if([$1$2], $[1]$[2], [],
437 [m4_fatal([$0: Invalid arguments: $@])])dnl
438 m4_pushdef([AT_LALR1_CC_IF],
439 [m4_bmatch([$3], ["lalr1.cc"], [$1], [$2])])
440 m4_pushdef([AT_GLR_IF],
441 [m4_bmatch([$3], [%glr-parser], [$1], [$2])])
442 m4_pushdef([AT_PARAM_IF],
443 [m4_bmatch([$3], [%parse-param], [$1], [$2])])
444 m4_pushdef([AT_LOCATION_IF],
445 [m4_bmatch([$3], [%locations], [$1], [$2])])
446 m4_pushdef([AT_PURE_IF],
447 [m4_bmatch([$3], [%pure-parser], [$1], [$2])])
448 m4_pushdef([AT_PURE_AND_LOC_IF],
449 [m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations],
451 m4_pushdef([AT_GLR_OR_PARAM_IF],
452 [m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
454 # yyerror receives the location if %location & %pure & (%glr or %parse-param).
455 m4_pushdef([AT_YYERROR_ARG_LOC_IF],
456 [AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
458 # yyerror cannot see the locations if !glr & pure & !param.
459 m4_pushdef([AT_YYERROR_SEES_LOC_IF],
460 [AT_LALR1_CC_IF([$1],
461 [AT_LOCATION_IF([AT_GLR_IF([$1],
462 [AT_PURE_IF([AT_PARAM_IF([$1],
467 # The interface is pure: either because %pure-parser, or because we
468 # are using the C++ parsers.
469 m4_pushdef([AT_PURE_LEX_IF],
471 [AT_LALR1_CC_IF([$1], [$2])])])
474 [m4_pushdef([AT_LOC], [(*yylloc)])
475 m4_pushdef([AT_VAL], [(*yylval)])
476 m4_pushdef([AT_LEX_FORMALS],
477 [YYSTYPE *yylval[]AT_LOCATION_IF([, YYLTYPE *yylloc])])
478 m4_pushdef([AT_LEX_ARGS],
479 [yylval[]AT_LOCATION_IF([, yylloc])])
480 m4_pushdef([AT_USE_LEX_ARGS],
481 [(void) yylval;AT_LOCATION_IF([(void) yylloc])])
482 m4_pushdef([AT_LEX_PRE_FORMALS],
484 m4_pushdef([AT_LEX_PRE_ARGS],
487 [m4_pushdef([AT_LOC], [(yylloc)])
488 m4_pushdef([AT_VAL], [(yylval)])
489 m4_pushdef([AT_LEX_FORMALS], [void])
490 m4_pushdef([AT_LEX_ARGS], [])
491 m4_pushdef([AT_USE_LEX_ARGS], [])
492 m4_pushdef([AT_LEX_PRE_FORMALS], [])
493 m4_pushdef([AT_LEX_PRE_ARGS], [])
500 m4_define([AT_CHECK_POPDEFS],
501 [m4_popdef([AT_LEX_PRE_ARGS])
502 m4_popdef([AT_LEX_PRE_FORMALS])
503 m4_popdef([AT_USE_LEX_ARGS])
504 m4_popdef([AT_LEX_ARGS])
505 m4_popdef([AT_LEX_FORMALS])
508 m4_popdef([AT_PURE_LEX_IF])
509 m4_popdef([AT_YYERROR_SEES_LOC_IF])
510 m4_popdef([AT_YYERROR_ARG_LOC_IF])
511 m4_popdef([AT_GLR_OR_PARAM_IF])
512 m4_popdef([AT_PURE_AND_LOC_IF])
513 m4_popdef([AT_LOCATION_IF])
514 m4_popdef([AT_PARAM_IF])
515 m4_popdef([AT_GLR_IF])
516 m4_popdef([AT_LALR1_CC_IF])
521 # AT_CHECK_CALC([BISON-OPTIONS])
522 # ------------------------------
523 # Start a testing chunk which compiles `calc' grammar with
524 # BISON-OPTIONS, and performs several tests over the parser.
525 m4_define([AT_CHECK_CALC],
526 [# We use integers to avoid dependencies upon the precision of doubles.
527 AT_SETUP([Calculator $1])
529 AT_CHECK_PUSHDEFS($[1], $[2], [$1])
533 # Specify the output files to avoid problems on different file systems.
534 AT_CHECK([bison -o calc.c calc.y],
538 [AT_CHECK([$CXX --version || exit 77], 0, ignore, ignore)
539 AT_COMPILE_CXX([calc])],
540 [AT_COMPILE([calc])])
542 # Test the priorities.
559 # Some syntax errors.
560 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [11],
561 [1.2: syntax error, unexpected "number"])
562 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [15],
563 [1.2: syntax error, unexpected '/', expecting "number" or '-' or '(' or '!'])
564 _AT_CHECK_CALC_ERROR([$1], [1], [error], [4],
565 [1.0: syntax error, unexpected $undefined])
566 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [22],
567 [1.6: syntax error, unexpected '='])
568 _AT_CHECK_CALC_ERROR([$1], [1],
572 [2.0: syntax error, unexpected '+'])
573 # Exercise error messages with EOF: work on an empty file.
574 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
575 [1.0: syntax error, unexpected "end of input"])
577 # Exercise the error token: without it, we die at the first error,
580 # - have several errors which exercise different shift/discardings
581 # - (): nothing to pop, nothing to discard
582 # - (1 + 1 + 1 +): a lot to pop, nothing to discard
583 # - (* * *): nothing to pop, a lot to discard
584 # - (1 + 2 * *): some to pop and discard
586 # - test the action associated to `error'
588 # - check the lookahead that triggers an error is not discarded
589 # when we enter error recovery. Below, the lookahead causing the
590 # first error is ")", which is needed to recover from the error and
591 # produce the "0" that triggers the "0 != 1" error.
593 _AT_CHECK_CALC_ERROR([$1], [0],
594 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
596 [1.1: syntax error, unexpected ')', expecting "number" or '-' or '(' or '!'
597 1.17: syntax error, unexpected ')', expecting "number" or '-' or '(' or '!'
598 1.22: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
599 1.40: syntax error, unexpected '*', expecting "number" or '-' or '(' or '!'
600 calc: error: 4444 != 1])
602 # The same, but this time exercising explicitly triggered syntax errors.
603 # POSIX says the lookahead causing the error should not be discarded.
604 _AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [64],
605 [1.9: syntax error, unexpected "number"
606 calc: error: 2222 != 1])
615 # ------------------------ #
616 # Simple LALR Calculator. #
617 # ------------------------ #
619 AT_BANNER([[Simple LALR Calculator.]])
621 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
622 # -----------------------------------
623 # Start a testing chunk which compiles `calc' grammar with
624 # BISON-OPTIONS, and performs several tests over the parser.
625 m4_define([AT_CHECK_CALC_LALR],
630 AT_CHECK_CALC_LALR([%defines])
631 AT_CHECK_CALC_LALR([%locations])
632 AT_CHECK_CALC_LALR([%name-prefix="calc"])
633 AT_CHECK_CALC_LALR([%verbose])
634 AT_CHECK_CALC_LALR([%yacc])
635 AT_CHECK_CALC_LALR([%error-verbose])
637 AT_CHECK_CALC_LALR([%error-verbose %locations])
639 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
641 AT_CHECK_CALC_LALR([%debug])
642 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
644 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
646 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 # Simple GLR Calculator. #
651 # ----------------------- #
653 AT_BANNER([[Simple GLR Calculator.]])
655 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
656 # ----------------------------------
657 # Start a testing chunk which compiles `calc' grammar with
658 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
659 m4_define([AT_CHECK_CALC_GLR],
660 [AT_CHECK_CALC([%glr-parser] $@)])
665 AT_CHECK_CALC_GLR([%defines])
666 AT_CHECK_CALC_GLR([%locations])
667 AT_CHECK_CALC_GLR([%name-prefix="calc"])
668 AT_CHECK_CALC_GLR([%verbose])
669 AT_CHECK_CALC_GLR([%yacc])
670 AT_CHECK_CALC_GLR([%error-verbose])
672 AT_CHECK_CALC_GLR([%error-verbose %locations])
674 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
676 AT_CHECK_CALC_GLR([%debug])
677 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
679 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
681 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 # Simple LALR1 C++ Calculator. #
686 # ----------------------------- #
688 AT_BANNER([[Simple LALR1 C++ Calculator.]])
690 # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
691 # ---------------------------------------
692 # Start a testing chunk which compiles `calc' grammar with
693 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
694 m4_define([AT_CHECK_CALC_LALR1_CC],
695 [AT_CHECK_CALC([%skeleton "lalr1.cc"] $@)])
697 # AT_CHECK_CALC_LALR1_CC()
699 AT_CHECK_CALC_LALR1_CC([%defines %pure-parser %locations])
701 # AT_CHECK_CALC_LALR1_CC([%defines])
702 # AT_CHECK_CALC_LALR1_CC([%locations])
703 # AT_CHECK_CALC_LALR1_CC([%name-prefix="calc"])
704 # AT_CHECK_CALC_LALR1_CC([%verbose])
705 # AT_CHECK_CALC_LALR1_CC([%yacc])
706 # AT_CHECK_CALC_LALR1_CC([%error-verbose])
708 # AT_CHECK_CALC_LALR1_CC([%error-verbose %locations])
710 # AT_CHECK_CALC_LALR1_CC([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
712 # AT_CHECK_CALC_LALR1_CC([%debug])
713 # AT_CHECK_CALC_LALR1_CC([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
715 # AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
717 # 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}])