1 # Simple calculator. -*- Autotest -*-
3 # Copyright (C) 2000-2010 Free Software Foundation, Inc.
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 3 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 ## ---------------------------------------------------- ##
19 ## Compile the grammar described in the documentation. ##
20 ## ---------------------------------------------------- ##
23 # ------------------------- #
24 # Helping Autotest macros. #
25 # ------------------------- #
28 # _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
29 # -----------------------------------------------
30 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
33 # Don't call this macro directly, because it contains some occurrences
34 # of `$1' etc. which will be interpreted by m4. So you should call it
35 # with $1, $2, and $3 as arguments, which is what AT_DATA_CALC_Y does.
36 m4_define([_AT_DATA_CALC_Y],
37 [m4_if([$1$2$3], $[1]$[2]$[3], [],
38 [m4_fatal([$0: Invalid arguments: $@])])dnl
39 m4_pushdef([AT_CALC_LEX],
42 int ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[);
43 static int get_char (]AT_LEX_FORMALS[);
44 static void unget_char (]AT_LEX_PRE_FORMALS[ int c);
47 static YYLTYPE last_yylloc;
50 get_char (]AT_LEX_FORMALS[)
52 int res = getc (input);
59 AT_LOC_LAST_COLUMN = 1;
68 unget_char (]AT_LEX_PRE_FORMALS[ int c)
72 /* Wrong when C == `\n'. */
79 read_signed_integer (]AT_LEX_FORMALS[)
81 int c = get_char (]AT_LEX_ARGS[);
88 c = get_char (]AT_LEX_ARGS[);
94 n = 10 * n + (c - '0');
95 c = get_char (]AT_LEX_ARGS[);
98 unget_char (]AT_LEX_PRE_ARGS[ c);
104 /*---------------------------------------------------------------.
105 | Lexical analyzer returns an integer on the stack and the token |
106 | NUM, or the ASCII character read if not a number. Skips all |
107 | blanks and tabs, returns 0 for EOF. |
108 `---------------------------------------------------------------*/
111 ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[)
120 AT_LOC_LAST_COLUMN = 1;
121 AT_LOC_LAST_LINE = 1;
126 AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
127 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
130 /* Skip white space. */
131 while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t')
134 [ AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
135 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
139 /* process numbers */
140 if (c == '.' || isdigit (c))
142 unget_char (]AT_LEX_PRE_ARGS[ c);
143 ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
147 /* Return end-of-file. */
151 /* Return single chars. */
156 AT_DATA_GRAMMAR([calc.y],
157 [[/* Infix notation calculator--calc */
160 [%define global_tokens_and_yystype])[
163 ]AT_LOCATION_TYPE_IF([
177 /* Exercise pre-prologue dependency to %union. */
178 typedef int semantic_value;
181 /* Exercise %union. */
191 extern FILE *input;]AT_SKEL_CC_IF([[
193 # define YYLTYPE ]AT_NAME_PREFIX[::parser::location_type
206 # define alarm(seconds) /* empty */
211 static semantic_value global_result = 0;
212 static int global_count = 0;
213 static int power (int base, int exponent);
215 [/* yyerror receives the location if:
216 - %location & %pure & %glr
217 - %location & %pure & %yacc & %parse-param. */
218 static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
219 AT_PARAM_IF([semantic_value *result, int *count, ])
222 int yylex (]AT_LEX_FORMALS[);
225 ]AT_SKEL_CC_IF([AT_LOCATION_TYPE_IF([], [
226 /* The lalr1.cc skeleton, for backward compatibility, defines
227 a constructor for position that initializes the filename. The
228 glr.cc skeleton does not (and in fact cannot: location/position
229 are stored in a union, from which objects with constructors are
236 /* Bison Declarations */
237 %token CALC_EOF 0 "end of input"
238 %token <ival> NUM "number"
241 %nonassoc '=' /* comparison */
244 %left NEG /* negation--unary minus */
245 %right '^' /* exponentiation */
247 /* Grammar follows */
251 | input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
256 | exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
264 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
267 | exp '+' exp { $$ = $1 + $3; }
268 | exp '-' exp { $$ = $1 - $3; }
269 | exp '*' exp { $$ = $1 * $3; }
270 | exp '/' exp { $$ = $1 / $3; }
271 | '-' exp %prec NEG { $$ = -$2; }
272 | exp '^' exp { $$ = power ($1, $3); }
273 | '(' exp ')' { $$ = $2; }
274 | '(' error ')' { $$ = 1111; yyerrok; }
275 | '!' { $$ = 0; YYERROR; }
276 | '-' error { $$ = 0; YYERROR; }
281 [AT_LOCATION_TYPE_IF([[
283 operator<< (std::ostream& o, const Span& s)
285 o << s.begin.l << '.' << s.begin.c;
286 if (s.begin.l != s.end.l)
287 o << '-' << s.end.l << '.' << s.end.c - 1;
288 else if (s.begin.c != s.end.c - 1)
289 o << '-' << s.end.c - 1;
294 /* A C++ error reporting function. */
296 AT_NAME_PREFIX::parser::error (const location_type& l, const std::string& m)
299 std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
302 /* A C++ yyparse that simulates the C signature. */
304 yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
306 AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
308 parser.set_debug_level (1);
310 return parser.parse ();
313 [/* A C error reporting function. */
315 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
316 AT_PARAM_IF([semantic_value *result, int *count, ])
319 AT_PARAM_IF([(void) result; (void) count;])
320 AT_YYERROR_SEES_LOC_IF([
321 fprintf (stderr, "%d.%d",
322 AT_LOC_FIRST_LINE, AT_LOC_FIRST_COLUMN);
323 if (AT_LOC_FIRST_LINE != AT_LOC_LAST_LINE)
324 fprintf (stderr, "-%d.%d",
325 AT_LOC_LAST_LINE, AT_LOC_LAST_COLUMN - 1);
326 else if (AT_LOC_FIRST_COLUMN != AT_LOC_LAST_COLUMN - 1)
327 fprintf (stderr, "-%d",
328 AT_LOC_LAST_COLUMN - 1);
329 fprintf (stderr, ": ");])
330 fprintf (stderr, "%s\n", s);
333 ]AT_DEFINES_IF(, [AT_CALC_LEX])[
336 power (int base, int exponent)
341 for (/* Niente */; exponent; --exponent)
347 /* A C main function. */
349 main (int argc, const char **argv)
351 semantic_value result = 0;
355 /* This used to be alarm (10), but that isn't enough time for
356 a July 1995 vintage DEC Alphastation 200 4/100 system,
357 according to Nelson H. F. Beebe. 100 seconds is enough. */
361 input = fopen (argv[1], "r");
371 ]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
373 status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
376 if (global_result != result)
378 if (global_count != count)
383 AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
384 [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
387 m4_popdef([AT_CALC_LEX])
391 # AT_DATA_CALC_Y([BISON-OPTIONS])
392 # -------------------------------
393 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
395 m4_define([AT_DATA_CALC_Y],
396 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
401 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
402 # --------------------------------------------------------
403 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
405 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
407 # NUM-STDERR-LINES is the number of expected lines on stderr.
408 # Currently this is ignored, though, since the output format is fluctuating.
410 # We don't count GLR's traces yet, since its traces are somewhat
411 # different from LALR's.
412 m4_define([_AT_CHECK_CALC],
416 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
420 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
421 # [NUM-STDERR-LINES],
422 # [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
423 # ---------------------------------------------------------
424 # Run `calc' on INPUT, and expect a `syntax error' message.
426 # If INPUT starts with a slash, it is used as absolute input file name,
427 # otherwise as contents.
429 # NUM-STDERR-LINES is the number of expected lines on stderr.
430 # Currently this is ignored, though, since the output format is fluctuating.
432 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
433 # is correctly output on stderr.
435 # If BISON-OPTIONS contains `%error-verbose', then make sure the
436 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
439 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
440 # is the number of expected lines on stderr.
441 m4_define([_AT_CHECK_CALC_ERROR],
442 [m4_bmatch([$3], [^/],
443 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
447 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
449 # Normalize the observed and expected error messages, depending upon the
451 # 1. Remove the traces from observed.
466 /^yydestructor:/d' stderr >at-stderr
468 # 2. Create the reference error message.
472 # 3. If locations are not used, remove them.
473 AT_YYERROR_SEES_LOC_IF([],
474 [[sed 's/^[-0-9.]*: //' expout >at-expout
475 mv at-expout expout]])
476 # 4. If error-verbose is not used, strip the`, unexpected....' part.
477 m4_bmatch([$1], [%error-verbose], [],
478 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
479 mv at-expout expout]])
481 AT_CHECK([cat stderr], 0, [expout])
485 # AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
486 # --------------------------------------------------
487 # Start a testing chunk which compiles `calc' grammar with
488 # BISON-OPTIONS, and performs several tests over the parser.
489 # However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
490 m4_define([AT_CHECK_CALC],
491 [# We use integers to avoid dependencies upon the precision of doubles.
492 AT_SETUP([Calculator $1])
494 m4_ifval([$2], [AT_CHECK([exit 77])])
496 AT_BISON_OPTION_PUSHDEFS([$1])
499 AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
501 # Test the priorities.
518 # Some syntax errors.
519 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
520 [1.3: syntax error, unexpected number])
521 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
522 [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
523 _AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
524 [1.1: syntax error, unexpected $undefined])
525 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
526 [1.7: syntax error, unexpected '='])
527 _AT_CHECK_CALC_ERROR([$1], [1],
531 [2.1: syntax error, unexpected '+'])
532 # Exercise error messages with EOF: work on an empty file.
533 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
534 [1.1: syntax error, unexpected end of input])
536 # Exercise the error token: without it, we die at the first error,
539 # - have several errors which exercise different shift/discardings
540 # - (): nothing to pop, nothing to discard
541 # - (1 + 1 + 1 +): a lot to pop, nothing to discard
542 # - (* * *): nothing to pop, a lot to discard
543 # - (1 + 2 * *): some to pop and discard
545 # - test the action associated to `error'
547 # - check the lookahead that triggers an error is not discarded
548 # when we enter error recovery. Below, the lookahead causing the
549 # first error is ")", which is needed to recover from the error and
550 # produce the "0" that triggers the "0 != 1" error.
552 _AT_CHECK_CALC_ERROR([$1], [0],
553 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
555 [1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
556 1.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
557 1.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
558 1.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
559 calc: error: 4444 != 1])
561 # The same, but this time exercising explicitly triggered syntax errors.
562 # POSIX says the lookahead causing the error should not be discarded.
563 _AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
564 [1.10: syntax error, unexpected number
565 calc: error: 2222 != 1])
566 _AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
567 [1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
568 1.12: syntax error, unexpected number
569 calc: error: 2222 != 1])
571 # Check that yyerrok works properly: second error is not reported,
572 # third and fourth are. Parse status is succesfull.
573 _AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
574 [1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
575 1.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
576 1.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
578 AT_BISON_OPTION_POPDEFS
586 # ------------------------ #
587 # Simple LALR Calculator. #
588 # ------------------------ #
590 AT_BANNER([[Simple LALR(1) Calculator.]])
592 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
593 # -----------------------------------
594 # Start a testing chunk which compiles `calc' grammar with
595 # BISON-OPTIONS, and performs several tests over the parser.
596 m4_define([AT_CHECK_CALC_LALR],
601 AT_CHECK_CALC_LALR([%defines])
602 AT_CHECK_CALC_LALR([%locations])
604 AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
605 AT_CHECK_CALC_LALR([%verbose])
606 AT_CHECK_CALC_LALR([%yacc])
607 AT_CHECK_CALC_LALR([%error-verbose])
609 AT_CHECK_CALC_LALR([%define api.pure %locations])
610 AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
611 AT_CHECK_CALC_LALR([%error-verbose %locations])
613 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
615 AT_CHECK_CALC_LALR([%debug])
616 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
618 AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
619 AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
621 AT_CHECK_CALC_LALR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
624 # ----------------------- #
625 # Simple GLR Calculator. #
626 # ----------------------- #
628 AT_BANNER([[Simple GLR Calculator.]])
630 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
631 # ----------------------------------
632 # Start a testing chunk which compiles `calc' grammar with
633 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
634 m4_define([AT_CHECK_CALC_GLR],
635 [AT_CHECK_CALC([%glr-parser] $@)])
640 AT_CHECK_CALC_GLR([%defines])
641 AT_CHECK_CALC_GLR([%locations])
642 AT_CHECK_CALC_GLR([%name-prefix "calc"])
643 AT_CHECK_CALC_GLR([%verbose])
644 AT_CHECK_CALC_GLR([%yacc])
645 AT_CHECK_CALC_GLR([%error-verbose])
647 AT_CHECK_CALC_GLR([%define api.pure %locations])
648 AT_CHECK_CALC_GLR([%error-verbose %locations])
650 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
652 AT_CHECK_CALC_GLR([%debug])
653 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
655 AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
657 AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
660 # ----------------------------- #
661 # Simple LALR1 C++ Calculator. #
662 # ----------------------------- #
664 AT_BANNER([[Simple LALR(1) C++ Calculator.]])
666 # First let's try using %skeleton
667 AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
669 # AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
670 # ---------------------------------------
671 # Start a testing chunk which compiles `calc' grammar with
672 # the C++ skeleton, and performs several tests over the parser.
673 m4_define([AT_CHECK_CALC_LALR1_CC],
674 [AT_CHECK_CALC([%language "C++" %defines %locations] $@)])
676 AT_CHECK_CALC_LALR1_CC([])
677 AT_CHECK_CALC_LALR1_CC([%define location_type Span])
678 AT_CHECK_CALC_LALR1_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
679 AT_CHECK_CALC_LALR1_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
681 AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
683 AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
687 # --------------------------- #
688 # Simple GLR C++ Calculator. #
689 # --------------------------- #
691 AT_BANNER([[Simple GLR C++ Calculator.]])
693 # Again, we try also using %skeleton.
694 AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
696 # AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
697 # -------------------------------------
698 # Start a testing chunk which compiles `calc' grammar with
699 # the GLR C++ skeleton, and performs several tests over the parser.
700 m4_define([AT_CHECK_CALC_GLR_CC],
701 [AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
703 AT_CHECK_CALC_GLR_CC([])
704 AT_CHECK_CALC_GLR_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
706 AT_CHECK_CALC_GLR_CC([%debug])
707 AT_CHECK_CALC_GLR_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
709 AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
711 AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])