]> git.saurik.com Git - bison.git/blame_incremental - tests/calc.at
tests: enhance AT_SYNCLINES_COMPILE.
[bison.git] / tests / calc.at
... / ...
CommitLineData
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.
36m4_define([_AT_DATA_CALC_Y],
37[m4_if([$1$2$3], $[1]$[2]$[3], [],
38 [m4_fatal([$0: Invalid arguments: $@])])dnl
39m4_pushdef([AT_CALC_LEX],
40[[#include <ctype.h>
41
42int ]AT_NAME_PREFIX[lex (]AT_LEX_FORMALS[);
43static int get_char (]AT_LEX_FORMALS[);
44static void unget_char (]AT_LEX_PRE_FORMALS[ int c);
45
46]AT_LOCATION_IF([
47static YYLTYPE last_yylloc;
48])[
49static int
50get_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
67static void
68unget_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
78static int
79read_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
110int
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 /* Skip current token, then white spaces. */
126 do
127 {
128]AT_LOCATION_IF(
129[ AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
130 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
131])[
132 }
133 while ((c = get_char (]AT_LEX_ARGS[)) == ' ' || c == '\t');
134
135 /* process numbers */
136 if (c == '.' || isdigit (c))
137 {
138 unget_char (]AT_LEX_PRE_ARGS[ c);
139 ]AT_VAL[.ival = read_signed_integer (]AT_LEX_ARGS[);
140 return ]AT_TOKEN_PREFIX[NUM;
141 }
142
143 /* Return end-of-file. */
144 if (c == EOF)
145 return ]AT_TOKEN_PREFIX[CALC_EOF;
146
147 /* Return single chars. */
148 return c;
149}
150]])
151
152AT_DATA_GRAMMAR([calc.y],
153[[/* Infix notation calculator--calc */
154]$4
155AT_SKEL_CC_IF(
156[%define global_tokens_and_yystype])[
157%code requires
158{
159]AT_LOCATION_TYPE_IF([[
160# include <iostream>
161 struct Point
162 {
163 int l;
164 int c;
165 };
166
167 struct Span
168 {
169 Point first;
170 Point last;
171 };
172
173# define YYLLOC_DEFAULT(Current, Rhs, N) \
174do { \
175 if (N) \
176 { \
177 (Current).first = (Rhs)[1].location.first; \
178 (Current).last = (Rhs)[N].location.last; \
179 } \
180 else \
181 { \
182 (Current).first = (Current).last = (Rhs)[0].location.last; \
183 } \
184} while (false)
185
186]])[
187 /* Exercise pre-prologue dependency to %union. */
188 typedef int semantic_value;
189}
190
191/* Exercise %union. */
192%union
193{
194 semantic_value ival;
195};
196
197%code provides
198{
199#include <stdio.h>
200/* The input. */
201extern FILE *input;]AT_SKEL_CC_IF([[
202#ifndef YYLTYPE
203# define YYLTYPE ]AT_NAME_PREFIX[::parser::location_type
204#endif
205]])[
206}
207
208%code
209{
210#include <stdlib.h>
211#include <string.h>
212#if HAVE_UNISTD_H
213# include <unistd.h>
214#else
215# undef alarm
216# define alarm(seconds) /* empty */
217#endif
218#define USE(Var)
219
220FILE *input;
221static semantic_value global_result = 0;
222static int global_count = 0;
223static int power (int base, int exponent);
224
225]AT_SKEL_CC_IF(,
226[/* yyerror receives the location if:
227 - %location & %pure & %glr
228 - %location & %pure & %yacc & %parse-param. */
229static void yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
230 AT_PARAM_IF([semantic_value *result, int *count, ])
231 const char *s
232 );])[
233int yylex (]AT_LEX_FORMALS[);
234}
235
236]AT_SKEL_CC_IF([AT_LOCATION_IF([AT_LOCATION_TYPE_IF([], [
237/* The lalr1.cc skeleton, for backward compatibility, defines
238 a constructor for position that initializes the filename. The
239 glr.cc skeleton does not (and in fact cannot: location/position
240 are stored in a union, from which objects with constructors are
241 excluded in C++). */
242%initial-action {
243 @$.initialize (0);
244}
245])])])[
246
247/* Bison Declarations */
248%token CALC_EOF 0 "end of input"
249%token <ival> NUM "number"
250%type <ival> exp
251
252%nonassoc '=' /* comparison */
253%left '-' '+'
254%left '*' '/'
255%precedence NEG /* negation--unary minus */
256%right '^' /* exponentiation */
257
258/* Grammar follows */
259%%
260input:
261 line
262| input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
263;
264
265line:
266 '\n'
267| exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
268;
269
270exp:
271 NUM { $$ = $1; }
272| exp '=' exp
273 {
274 if ($1 != $3)
275 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
276 $$ = $1;
277 }
278| exp '+' exp { $$ = $1 + $3; }
279| exp '-' exp { $$ = $1 - $3; }
280| exp '*' exp { $$ = $1 * $3; }
281| exp '/' exp { $$ = $1 / $3; }
282| '-' exp %prec NEG { $$ = -$2; }
283| exp '^' exp { $$ = power ($1, $3); }
284| '(' exp ')' { $$ = $2; }
285| '(' error ')' { $$ = 1111; yyerrok; }
286| '!' { $$ = 0; YYERROR; }
287| '-' error { $$ = 0; YYERROR; }
288;
289%%
290
291]AT_SKEL_CC_IF(
292[AT_LOCATION_TYPE_IF([[
293 std::ostream&
294 operator<< (std::ostream& o, const Span& s)
295 {
296 o << s.first.l << '.' << s.first.c;
297 if (s.first.l != s.last.l)
298 o << '-' << s.last.l << '.' << s.last.c - 1;
299 else if (s.first.c != s.last.c - 1)
300 o << '-' << s.last.c - 1;
301 return o;
302 }
303]])
304
305/* A C++ error reporting function. */
306void
307AT_NAME_PREFIX::parser::error (AT_LOCATION_IF([const location_type& l, ])const std::string& m)
308{
309 std::cerr << AT_LOCATION_IF([l << ": " << ])m << std::endl;
310}
311
312/* A C++ yyparse that simulates the C signature. */
313int
314yyparse (AT_PARAM_IF([semantic_value *result, int *count]))
315{
316 AT_NAME_PREFIX::parser parser[]AT_PARAM_IF([ (result, count)]);
317#if YYDEBUG
318 parser.set_debug_level (1);
319#endif
320 return parser.parse ();
321}
322],
323[/* A C error reporting function. */
324static void
325yyerror (AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])
326 AT_PARAM_IF([semantic_value *result, int *count, ])
327 const char *s)
328{
329AT_PARAM_IF([(void) result; (void) count;])
330AT_YYERROR_SEES_LOC_IF([
331 fprintf (stderr, "%d.%d",
332 AT_LOC_FIRST_LINE, AT_LOC_FIRST_COLUMN);
333 if (AT_LOC_FIRST_LINE != AT_LOC_LAST_LINE)
334 fprintf (stderr, "-%d.%d",
335 AT_LOC_LAST_LINE, AT_LOC_LAST_COLUMN - 1);
336 else if (AT_LOC_FIRST_COLUMN != AT_LOC_LAST_COLUMN - 1)
337 fprintf (stderr, "-%d",
338 AT_LOC_LAST_COLUMN - 1);
339 fprintf (stderr, ": ");])
340 fprintf (stderr, "%s\n", s);
341}])[
342
343]AT_DEFINES_IF(, [AT_CALC_LEX])[
344
345static int
346power (int base, int exponent)
347{
348 int res = 1;
349 if (exponent < 0)
350 exit (3);
351 for (/* Niente */; exponent; --exponent)
352 res *= base;
353 return res;
354}
355
356
357/* A C main function. */
358int
359main (int argc, const char **argv)
360{
361 semantic_value result = 0;
362 int count = 0;
363 int status;
364
365 /* This used to be alarm (10), but that isn't enough time for
366 a July 1995 vintage DEC Alphastation 200 4/100 system,
367 according to Nelson H. F. Beebe. 100 seconds is enough. */
368 alarm (100);
369
370 if (argc == 2)
371 input = fopen (argv[1], "r");
372 else
373 input = stdin;
374
375 if (!input)
376 {
377 perror (argv[1]);
378 return 3;
379 }
380
381]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
382[ yydebug = 1;])])[
383 status = yyparse (]AT_PARAM_IF([[&result, &count]])[);
384 if (fclose (input))
385 perror ("fclose");
386 if (global_result != result)
387 abort ();
388 if (global_count != count)
389 abort ();
390 return status;
391}
392]])
393AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
394[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
395
396]AT_CALC_LEX])])
397m4_popdef([AT_CALC_LEX])
398])# _AT_DATA_CALC_Y
399
400
401# AT_DATA_CALC_Y([BISON-OPTIONS])
402# -------------------------------
403# Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
404# `calc-lex.cc'.
405m4_define([AT_DATA_CALC_Y],
406[_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
407])
408
409
410
411# _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
412# --------------------------------------------------------
413# Run `calc' on INPUT and expect no STDOUT nor STDERR.
414#
415# If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
416#
417# NUM-STDERR-LINES is the number of expected lines on stderr.
418# Currently this is ignored, though, since the output format is fluctuating.
419#
420# We don't count GLR's traces yet, since its traces are somewhat
421# different from LALR's.
422m4_define([_AT_CHECK_CALC],
423[AT_DATA([[input]],
424[[$2
425]])
426AT_PARSER_CHECK([./calc input], 0, [], [stderr])
427])
428
429
430# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
431# [NUM-STDERR-LINES],
432# [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
433# ---------------------------------------------------------
434# Run `calc' on INPUT, and expect a `syntax error' message.
435#
436# If INPUT starts with a slash, it is used as absolute input file name,
437# otherwise as contents.
438#
439# NUM-STDERR-LINES is the number of expected lines on stderr.
440# Currently this is ignored, though, since the output format is fluctuating.
441#
442# If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
443# is correctly output on stderr.
444#
445# If BISON-OPTIONS contains `%define parse.error verbose', then make sure the
446# IF-YYERROR-VERBOSE message is properly output after `syntax error, '
447# on STDERR.
448#
449# If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
450# is the number of expected lines on stderr.
451m4_define([_AT_CHECK_CALC_ERROR],
452[m4_bmatch([$3], [^/],
453 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
454 [AT_DATA([[input]],
455[[$3
456]])
457AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
458
459# Normalize the observed and expected error messages, depending upon the
460# options.
461# 1. Remove the traces from observed.
462sed '/^Starting/d
463/^Entering/d
464/^Stack/d
465/^Reading/d
466/^Reducing/d
467/^Return/d
468/^Shifting/d
469/^state/d
470/^Cleanup:/d
471/^Error:/d
472/^Next/d
473/^Now/d
474/^Discarding/d
475/ \$[[0-9$]]* = /d
476/^yydestructor:/d' stderr >at-stderr
477mv at-stderr stderr
478# 2. Create the reference error message.
479AT_DATA([[expout]],
480[$5
481])
482# 3. If locations are not used, remove them.
483AT_YYERROR_SEES_LOC_IF([],
484[[sed 's/^[-0-9.]*: //' expout >at-expout
485mv at-expout expout]])
486# 4. If error-verbose is not used, strip the`, unexpected....' part.
487m4_bmatch([$1], [%define parse.error verbose], [],
488[[sed 's/syntax error, .*$/syntax error/' expout >at-expout
489mv at-expout expout]])
490# 5. Check
491AT_CHECK([cat stderr], 0, [expout])
492])
493
494
495# AT_CHECK_CALC([BISON-OPTIONS, [EXPECTED-TO-FAIL]])
496# --------------------------------------------------
497# Start a testing chunk which compiles `calc' grammar with
498# BISON-OPTIONS, and performs several tests over the parser.
499# However, if EXPECTED-TO-FAIL is nonempty, this test is expected to fail.
500m4_define([AT_CHECK_CALC],
501[# We use integers to avoid dependencies upon the precision of doubles.
502AT_SETUP([Calculator $1])
503
504m4_ifval([$2], [AT_CHECK([exit 77])])
505
506AT_BISON_OPTION_PUSHDEFS([$1])
507
508AT_DATA_CALC_Y([$1])
509AT_FULL_COMPILE([calc], [AT_DEFINES_IF([[lex]])])
510
511# Test the priorities.
512_AT_CHECK_CALC([$1],
513[1 + 2 * 3 = 7
5141 + 2 * -3 = -5
515
516-1^2 = -1
517(-1)^2 = 1
518
519---1 = -1
520
5211 - 2 - 3 = -4
5221 - (2 - 3) = 2
523
5242^2^3 = 256
525(2^2)^3 = 64],
526 [842])
527
528# Some syntax errors.
529_AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
530 [1.3: syntax error, unexpected number])
531_AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
532 [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
533_AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
534 [1.1: syntax error, unexpected $undefined])
535_AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
536 [1.7: syntax error, unexpected '='])
537_AT_CHECK_CALC_ERROR([$1], [1],
538 [
539+1],
540 [20],
541 [2.1: syntax error, unexpected '+'])
542# Exercise error messages with EOF: work on an empty file.
543_AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
544 [1.1: syntax error, unexpected end of input])
545
546# Exercise the error token: without it, we die at the first error,
547# hence be sure to
548#
549# - have several errors which exercise different shift/discardings
550# - (): nothing to pop, nothing to discard
551# - (1 + 1 + 1 +): a lot to pop, nothing to discard
552# - (* * *): nothing to pop, a lot to discard
553# - (1 + 2 * *): some to pop and discard
554#
555# - test the action associated to `error'
556#
557# - check the lookahead that triggers an error is not discarded
558# when we enter error recovery. Below, the lookahead causing the
559# first error is ")", which is needed to recover from the error and
560# produce the "0" that triggers the "0 != 1" error.
561#
562_AT_CHECK_CALC_ERROR([$1], [0],
563 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
564 [250],
565[1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5661.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5671.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5681.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
569calc: error: 4444 != 1])
570
571# The same, but this time exercising explicitly triggered syntax errors.
572# POSIX says the lookahead causing the error should not be discarded.
573_AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
574[1.10: syntax error, unexpected number
575calc: error: 2222 != 1])
576_AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
577[1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5781.12: syntax error, unexpected number
579calc: error: 2222 != 1])
580
581# Check that yyerrok works properly: second error is not reported,
582# third and fourth are. Parse status is succesfull.
583_AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
584[1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5851.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5861.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
587
588AT_BISON_OPTION_POPDEFS
589
590AT_CLEANUP
591])# AT_CHECK_CALC
592
593
594
595
596# ------------------------ #
597# Simple LALR Calculator. #
598# ------------------------ #
599
600AT_BANNER([[Simple LALR(1) Calculator.]])
601
602# AT_CHECK_CALC_LALR([BISON-OPTIONS])
603# -----------------------------------
604# Start a testing chunk which compiles `calc' grammar with
605# BISON-OPTIONS, and performs several tests over the parser.
606m4_define([AT_CHECK_CALC_LALR],
607[AT_CHECK_CALC($@)])
608
609AT_CHECK_CALC_LALR()
610
611AT_CHECK_CALC_LALR([%defines])
612AT_CHECK_CALC_LALR([%locations])
613
614AT_CHECK_CALC_LALR([%name-prefix="calc"]) dnl test deprecated `='
615AT_CHECK_CALC_LALR([%verbose])
616AT_CHECK_CALC_LALR([%yacc])
617AT_CHECK_CALC_LALR([%define parse.error verbose])
618
619AT_CHECK_CALC_LALR([%define api.pure %locations])
620AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
621AT_CHECK_CALC_LALR([%define parse.error verbose %locations])
622
623AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
624AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
625
626AT_CHECK_CALC_LALR([%debug])
627AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
628
629AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
630AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
631
632AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
633
634
635# ----------------------- #
636# Simple GLR Calculator. #
637# ----------------------- #
638
639AT_BANNER([[Simple GLR Calculator.]])
640
641# AT_CHECK_CALC_GLR([BISON-OPTIONS])
642# ----------------------------------
643# Start a testing chunk which compiles `calc' grammar with
644# BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
645m4_define([AT_CHECK_CALC_GLR],
646[AT_CHECK_CALC([%glr-parser] $@)])
647
648
649AT_CHECK_CALC_GLR()
650
651AT_CHECK_CALC_GLR([%defines])
652AT_CHECK_CALC_GLR([%locations])
653AT_CHECK_CALC_GLR([%name-prefix "calc"])
654AT_CHECK_CALC_GLR([%verbose])
655AT_CHECK_CALC_GLR([%yacc])
656AT_CHECK_CALC_GLR([%define parse.error verbose])
657
658AT_CHECK_CALC_GLR([%define api.pure %locations])
659AT_CHECK_CALC_GLR([%define parse.error verbose %locations])
660
661AT_CHECK_CALC_GLR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
662
663AT_CHECK_CALC_GLR([%debug])
664AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
665AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
666
667AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
668
669AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
670
671
672# ----------------------------- #
673# Simple LALR1 C++ Calculator. #
674# ----------------------------- #
675
676AT_BANNER([[Simple LALR(1) C++ Calculator.]])
677
678# First let's try using %skeleton
679AT_CHECK_CALC([%skeleton "lalr1.cc" %defines %locations])
680
681# AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
682# ---------------------------------------
683# Start a testing chunk which compiles `calc' grammar with
684# the C++ skeleton, and performs several tests over the parser.
685m4_define([AT_CHECK_CALC_LALR1_CC],
686[AT_CHECK_CALC([%language "C++" %defines] $@)])
687
688AT_CHECK_CALC_LALR1_CC([])
689AT_CHECK_CALC_LALR1_CC([%locations])
690AT_CHECK_CALC_LALR1_CC([%locations %define location_type Span])
691AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
692
693AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
694
695AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
696AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
697
698AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])
699
700
701
702# --------------------------- #
703# Simple GLR C++ Calculator. #
704# --------------------------- #
705
706AT_BANNER([[Simple GLR C++ Calculator.]])
707
708# Again, we try also using %skeleton.
709AT_CHECK_CALC([%skeleton "glr.cc" %defines %locations])
710
711# AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
712# -------------------------------------
713# Start a testing chunk which compiles `calc' grammar with
714# the GLR C++ skeleton, and performs several tests over the parser.
715m4_define([AT_CHECK_CALC_GLR_CC],
716[AT_CHECK_CALC([%language "C++" %glr-parser %defines %locations] $@)])
717
718AT_CHECK_CALC_GLR_CC([])
719AT_CHECK_CALC_GLR_CC([%define parse.error verbose %name-prefix "calc" %verbose %yacc])
720
721AT_CHECK_CALC_GLR_CC([%debug])
722AT_CHECK_CALC_GLR_CC([%define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
723
724AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
725AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.tokens.prefix "TOK_" %verbose %yacc])
726
727AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count}])