]> git.saurik.com Git - bison.git/blob - tests/calc.at
tests: calc: simplify location management.
[bison.git] / tests / calc.at
1 # Simple calculator. -*- Autotest -*-
2
3 # Copyright (C) 2000-2010 Free Software Foundation, Inc.
4
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.
9 #
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.
14 #
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/>.
17
18 ## ---------------------------------------------------- ##
19 ## Compile the grammar described in the documentation. ##
20 ## ---------------------------------------------------- ##
21
22
23 # ------------------------- #
24 # Helping Autotest macros. #
25 # ------------------------- #
26
27
28 # _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
29 # -----------------------------------------------
30 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
31 # `calc-lex.cc'.
32 #
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],
40 [[#include <ctype.h>
41
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);
45
46 ]AT_LOCATION_IF([
47 static YYLTYPE last_yylloc;
48 ])[
49 static int
50 get_char (]AT_LEX_FORMALS[)
51 {
52 int res = getc (input);
53 ]AT_USE_LEX_ARGS[;
54 ]AT_LOCATION_IF([
55 last_yylloc = AT_LOC;
56 if (res == '\n')
57 {
58 AT_LOC_LAST_LINE++;
59 AT_LOC_LAST_COLUMN = 1;
60 }
61 else
62 AT_LOC_LAST_COLUMN++;
63 ])[
64 return res;
65 }
66
67 static void
68 unget_char (]AT_LEX_PRE_FORMALS[ int c)
69 {
70 ]AT_USE_LEX_ARGS[;
71 ]AT_LOCATION_IF([
72 /* Wrong when C == `\n'. */
73 AT_LOC = last_yylloc;
74 ])[
75 ungetc (c, input);
76 }
77
78 static int
79 read_signed_integer (]AT_LEX_FORMALS[)
80 {
81 int c = get_char (]AT_LEX_ARGS[);
82 int sign = 1;
83 int n = 0;
84
85 ]AT_USE_LEX_ARGS[;
86 if (c == '-')
87 {
88 c = get_char (]AT_LEX_ARGS[);
89 sign = -1;
90 }
91
92 while (isdigit (c))
93 {
94 n = 10 * n + (c - '0');
95 c = get_char (]AT_LEX_ARGS[);
96 }
97
98 unget_char (]AT_LEX_PRE_ARGS[ c);
99
100 return sign * n;
101 }
102
103
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 `---------------------------------------------------------------*/
109
110 int
111 ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[)
112 {
113 static int init = 1;
114 int c;
115
116 if (init)
117 {
118 init = 0;
119 ]AT_LOCATION_IF([
120 AT_LOC_LAST_COLUMN = 1;
121 AT_LOC_LAST_LINE = 1;
122 ])[
123 }
124
125 ]AT_LOCATION_IF([
126 AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
127 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
128 ])[
129
130 /* Skip white space. */
131 while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t')
132 {
133 ]AT_LOCATION_IF(
134 [ AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
135 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
136 ])[
137 }
138
139 /* process numbers */
140 if (c == '.' || isdigit (c))
141 {
142 unget_char (]AT_LEX_PRE_ARGS[ c);
143 ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
144 return NUM;
145 }
146
147 /* Return end-of-file. */
148 if (c == EOF)
149 return CALC_EOF;
150
151 /* Return single chars. */
152 return c;
153 }
154 ]])
155
156 AT_DATA_GRAMMAR([calc.y],
157 [[/* Infix notation calculator--calc */
158 ]$4
159 AT_SKEL_CC_IF(
160 [%define global_tokens_and_yystype])[
161 %code requires
162 {
163 ]AT_LOCATION_TYPE_IF([
164 # include <iostream>
165 struct Point
166 {
167 int l;
168 int c;
169 };
170
171 struct Span
172 {
173 Point begin;
174 Point end;
175 };
176 ])[
177 /* Exercise pre-prologue dependency to %union. */
178 typedef int semantic_value;
179 }
180
181 /* Exercise %union. */
182 %union
183 {
184 semantic_value ival;
185 };
186
187 %code provides
188 {
189 #include <stdio.h>
190 /* The input. */
191 extern FILE *input;]AT_SKEL_CC_IF([[
192 #ifndef YYLTYPE
193 # define YYLTYPE ]AT_NAME_PREFIX[::parser::location_type
194 #endif
195 ]])[
196 }
197
198 %code
199 {
200 #include <stdlib.h>
201 #include <string.h>
202 #if HAVE_UNISTD_H
203 # include <unistd.h>
204 #else
205 # undef alarm
206 # define alarm(seconds) /* empty */
207 #endif
208 #define USE(Var)
209
210 FILE *input;
211 static semantic_value global_result = 0;
212 static int global_count = 0;
213 static int power (int base, int exponent);
214 ]AT_SKEL_CC_IF(,
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, ])
220 const char *s
221 );])[
222 int yylex (]AT_LEX_FORMALS[);
223 }
224
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
230 excluded in C++. */
231 %initial-action {
232 @$.initialize (0);
233 }
234 ])])[
235
236 /* Bison Declarations */
237 %token CALC_EOF 0 "end of input"
238 %token <ival> NUM "number"
239 %type <ival> exp
240
241 %nonassoc '=' /* comparison */
242 %left '-' '+'
243 %left '*' '/'
244 %left NEG /* negation--unary minus */
245 %right '^' /* exponentiation */
246
247 /* Grammar follows */
248 %%
249 input:
250 line
251 | input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
252 ;
253
254 line:
255 '\n'
256 | exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
257 ;
258
259 exp:
260 NUM { $$ = $1; }
261 | exp '=' exp
262 {
263 if ($1 != $3)
264 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
265 $$ = $1;
266 }
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; }
277 ;
278 %%
279
280 ]AT_SKEL_CC_IF(
281 [AT_LOCATION_TYPE_IF([[
282 std::ostream&
283 operator<< (std::ostream& o, const Span& s)
284 {
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;
290 return o;
291 }
292 ]])
293
294 /* A C++ error reporting function. */
295 void
296 AT_NAME_PREFIX::parser::error (const location_type& l, const std::string& m)
297 {
298 (void) l;
299 std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
300 }
301
302 /* A C++ yyparse that simulates the C signature. */
303 int
304 yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
305 {
306 AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
307 #if YYDEBUG
308 parser.set_debug_level (1);
309 #endif
310 return parser.parse ();
311 }
312 ],
313 [/* A C error reporting function. */
314 static void
315 yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
316 AT_PARAM_IF([semantic_value *result, int *count, ])
317 const char *s)
318 {
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);
331 }])[
332
333 ]AT_DEFINES_IF(, [AT_CALC_LEX])[
334
335 static int
336 power (int base, int exponent)
337 {
338 int res = 1;
339 if (exponent < 0)
340 exit (3);
341 for (/* Niente */; exponent; --exponent)
342 res *= base;
343 return res;
344 }
345
346
347 /* A C main function. */
348 int
349 main (int argc, const char **argv)
350 {
351 semantic_value result = 0;
352 int count = 0;
353 int status;
354
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. */
358 alarm (100);
359
360 if (argc == 2)
361 input = fopen (argv[1], "r");
362 else
363 input = stdin;
364
365 if (!input)
366 {
367 perror (argv[1]);
368 return 3;
369 }
370
371 ]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
372 [ yydebug = 1;])])[
373 status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
374 if (fclose (input))
375 perror ("fclose");
376 if (global_result != result)
377 abort ();
378 if (global_count != count)
379 abort ();
380 return status;
381 }
382 ]])
383 AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
384 [[#include "calc.h]AT_SKEL_CC_IF([[h]])["
385
386 ]AT_CALC_LEX])])
387 m4_popdef([AT_CALC_LEX])
388 ])# _AT_DATA_CALC_Y
389
390
391 # AT_DATA_CALC_Y([BISON-OPTIONS])
392 # -------------------------------
393 # Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
394 # `calc-lex.cc'.
395 m4_define([AT_DATA_CALC_Y],
396 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
397 ])
398
399
400
401 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
402 # --------------------------------------------------------
403 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
404 #
405 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
406 #
407 # NUM-STDERR-LINES is the number of expected lines on stderr.
408 # Currently this is ignored, though, since the output format is fluctuating.
409 #
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],
413 [AT_DATA([[input]],
414 [[$2
415 ]])
416 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
417 ])
418
419
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.
425 #
426 # If INPUT starts with a slash, it is used as absolute input file name,
427 # otherwise as contents.
428 #
429 # NUM-STDERR-LINES is the number of expected lines on stderr.
430 # Currently this is ignored, though, since the output format is fluctuating.
431 #
432 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
433 # is correctly output on stderr.
434 #
435 # If BISON-OPTIONS contains `%error-verbose', then make sure the
436 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
437 # on STDERR.
438 #
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])],
444 [AT_DATA([[input]],
445 [[$3
446 ]])
447 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
448
449 # Normalize the observed and expected error messages, depending upon the
450 # options.
451 # 1. Remove the traces from observed.
452 sed '/^Starting/d
453 /^Entering/d
454 /^Stack/d
455 /^Reading/d
456 /^Reducing/d
457 /^Return/d
458 /^Shifting/d
459 /^state/d
460 /^Cleanup:/d
461 /^Error:/d
462 /^Next/d
463 /^Now/d
464 /^Discarding/d
465 / \$[[0-9$]]* = /d
466 /^yydestructor:/d' stderr >at-stderr
467 mv at-stderr stderr
468 # 2. Create the reference error message.
469 AT_DATA([[expout]],
470 [$5
471 ])
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]])
480 # 5. Check
481 AT_CHECK([cat stderr], 0, [expout])
482 ])
483
484
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])
493
494 m4_ifval([$2], [AT_CHECK([exit 77])])
495
496 AT_BISON_OPTION_PUSHDEFS([$1])
497
498 AT_DATA_CALC_Y([$1])
499 AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
500
501 # Test the priorities.
502 _AT_CHECK_CALC([$1],
503 [1 + 2 * 3 = 7
504 1 + 2 * -3 = -5
505
506 -1^2 = -1
507 (-1)^2 = 1
508
509 ---1 = -1
510
511 1 - 2 - 3 = -4
512 1 - (2 - 3) = 2
513
514 2^2^3 = 256
515 (2^2)^3 = 64],
516 [842])
517
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],
528 [
529 +1],
530 [20],
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])
535
536 # Exercise the error token: without it, we die at the first error,
537 # hence be sure to
538 #
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
544 #
545 # - test the action associated to `error'
546 #
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.
551 #
552 _AT_CHECK_CALC_ERROR([$1], [0],
553 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
554 [250],
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])
560
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])
570
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 '!'])
577
578 AT_BISON_OPTION_POPDEFS
579
580 AT_CLEANUP
581 ])# AT_CHECK_CALC
582
583
584
585
586 # ------------------------ #
587 # Simple LALR Calculator. #
588 # ------------------------ #
589
590 AT_BANNER([[Simple LALR(1) Calculator.]])
591
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],
597 [AT_CHECK_CALC($@)])
598
599 AT_CHECK_CALC_LALR()
600
601 AT_CHECK_CALC_LALR([%defines])
602 AT_CHECK_CALC_LALR([%locations])
603
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])
608
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])
612
613 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
614
615 AT_CHECK_CALC_LALR([%debug])
616 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
617
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])
620
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}])
622
623
624 # ----------------------- #
625 # Simple GLR Calculator. #
626 # ----------------------- #
627
628 AT_BANNER([[Simple GLR Calculator.]])
629
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] $@)])
636
637
638 AT_CHECK_CALC_GLR()
639
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])
646
647 AT_CHECK_CALC_GLR([%define api.pure %locations])
648 AT_CHECK_CALC_GLR([%error-verbose %locations])
649
650 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix "calc" %verbose %yacc])
651
652 AT_CHECK_CALC_GLR([%debug])
653 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
654
655 AT_CHECK_CALC_GLR([%define api.pure %error-verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
656
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}])
658
659
660 # ----------------------------- #
661 # Simple LALR1 C++ Calculator. #
662 # ----------------------------- #
663
664 AT_BANNER([[Simple LALR(1) C++ Calculator.]])
665
666 # First let's try using %skeleton
667 AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
668
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] $@)])
675
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])
680
681 AT_CHECK_CALC_LALR1_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
682
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}])
684
685
686
687 # --------------------------- #
688 # Simple GLR C++ Calculator. #
689 # --------------------------- #
690
691 AT_BANNER([[Simple GLR C++ Calculator.]])
692
693 # Again, we try also using %skeleton.
694 AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
695
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] $@)])
702
703 AT_CHECK_CALC_GLR_CC([])
704 AT_CHECK_CALC_GLR_CC([%error-verbose %name-prefix "calc" %verbose %yacc])
705
706 AT_CHECK_CALC_GLR_CC([%debug])
707 AT_CHECK_CALC_GLR_CC([%error-verbose %debug %name-prefix "calc" %verbose %yacc])
708
709 AT_CHECK_CALC_GLR_CC([%pure-parser %error-verbose %debug %name-prefix "calc" %verbose %yacc])
710
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}])