]> git.saurik.com Git - bison.git/blame - tests/calc.at
lalr1.cc: rename lex_symbol as api.token.constructor
[bison.git] / tests / calc.at
CommitLineData
82c53be4 1# Simple calculator. -*- Autotest -*-
419ab105 2
34136e65 3# Copyright (C) 2000-2012 Free Software Foundation, Inc.
bfb07874 4
f16b0819 5# This program is free software: you can redistribute it and/or modify
342b8b6e 6# it under the terms of the GNU General Public License as published by
f16b0819
PE
7# the Free Software Foundation, either version 3 of the License, or
8# (at your option) any later version.
9#
342b8b6e
AD
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.
f16b0819 14#
342b8b6e 15# You should have received a copy of the GNU General Public License
f16b0819 16# along with this program. If not, see <http://www.gnu.org/licenses/>.
bfb07874 17
bfb07874
AD
18## ---------------------------------------------------- ##
19## Compile the grammar described in the documentation. ##
20## ---------------------------------------------------- ##
21
22
23# ------------------------- #
24# Helping Autotest macros. #
25# ------------------------- #
26
27
2a8d363a
AD
28# _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
29# -----------------------------------------------
6c88b51e
JD
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.
c8c220d1
AD
36#
37# When %defines is not passed, generate a single self-contained file.
38# Otherwise, generate three: calc.y with the parser, calc-lex.c with
39# the scanner, and calc-main.c with "main()". This is in order to
40# stress the use of the generated parser header. To avoid code
41# duplication, AT_CALC_LEX and AT_CALC_MAIN contain the body of these
42# two later files.
342b8b6e
AD
43m4_define([_AT_DATA_CALC_Y],
44[m4_if([$1$2$3], $[1]$[2]$[3], [],
45 [m4_fatal([$0: Invalid arguments: $@])])dnl
c8c220d1
AD
46
47m4_pushdef([AT_CALC_MAIN],
77519a7d 48[#include <assert.h>
363bf732 49#if HAVE_UNISTD_H
c8c220d1
AD
50# include <unistd.h>
51#else
52# undef alarm
53# define alarm(seconds) /* empty */
54#endif
55
56AT_SKEL_CC_IF([[
57/* A C++ ]AT_NAME_PREFIX[parse that simulates the C signature. */
58int
59]AT_NAME_PREFIX[parse (]AT_PARAM_IF([semantic_value *result, int *count]))[
60{
61 ]AT_NAME_PREFIX[::parser parser]AT_PARAM_IF([ (result, count)])[;
ad60e80f 62#if ]AT_API_PREFIX[DEBUG
c8c220d1
AD
63 parser.set_debug_level (1);
64#endif
65 return parser.parse ();
66}
67]])[
68
69semantic_value global_result = 0;
70int global_count = 0;
71
72/* A C main function. */
73int
74main (int argc, const char **argv)
75{
76 semantic_value result = 0;
77 int count = 0;
78 int status;
79
80 /* This used to be alarm (10), but that isn't enough time for
81 a July 1995 vintage DEC Alphastation 200 4/100 system,
82 according to Nelson H. F. Beebe. 100 seconds is enough. */
83 alarm (100);
84
85 if (argc == 2)
86 input = fopen (argv[1], "r");
87 else
88 input = stdin;
89
90 if (!input)
91 {
92 perror (argv[1]);
93 return 3;
94 }
95
96]AT_SKEL_CC_IF([], [m4_bmatch([$4], [%debug],
97[ ]AT_NAME_PREFIX[debug = 1;])])[
98 status = ]AT_NAME_PREFIX[parse (]AT_PARAM_IF([[&result, &count]])[);
99 if (fclose (input))
100 perror ("fclose");
77519a7d
AD
101 assert (global_result == result);
102 assert (global_count == count);
c8c220d1
AD
103 return status;
104}
105]])
106
107
6c88b51e
JD
108m4_pushdef([AT_CALC_LEX],
109[[#include <ctype.h>
110
230a3db4
AD
111]AT_YYLEX_DECLARE_EXTERN[
112static int get_char (]AT_YYLEX_FORMALS[);
113static void unget_char (]AT_YYLEX_PRE_FORMALS[ int c);
6c88b51e
JD
114
115]AT_LOCATION_IF([
ad60e80f 116static AT_YYLTYPE last_yylloc;
6c88b51e
JD
117])[
118static int
230a3db4 119get_char (]AT_YYLEX_FORMALS[)
6c88b51e
JD
120{
121 int res = getc (input);
122 ]AT_USE_LEX_ARGS[;
123]AT_LOCATION_IF([
124 last_yylloc = AT_LOC;
125 if (res == '\n')
126 {
4f756f88
AD
127 AT_LOC_LAST_LINE++;
128 AT_LOC_LAST_COLUMN = 1;
6c88b51e
JD
129 }
130 else
4f756f88 131 AT_LOC_LAST_COLUMN++;
6c88b51e
JD
132])[
133 return res;
134}
135
136static void
230a3db4 137unget_char (]AT_YYLEX_PRE_FORMALS[ int c)
6c88b51e
JD
138{
139 ]AT_USE_LEX_ARGS[;
140]AT_LOCATION_IF([
141 /* Wrong when C == `\n'. */
142 AT_LOC = last_yylloc;
143])[
144 ungetc (c, input);
145}
146
147static int
230a3db4 148read_signed_integer (]AT_YYLEX_FORMALS[)
6c88b51e 149{
230a3db4 150 int c = get_char (]AT_YYLEX_ARGS[);
6c88b51e
JD
151 int sign = 1;
152 int n = 0;
153
154 ]AT_USE_LEX_ARGS[;
155 if (c == '-')
156 {
230a3db4 157 c = get_char (]AT_YYLEX_ARGS[);
6c88b51e
JD
158 sign = -1;
159 }
160
161 while (isdigit (c))
162 {
163 n = 10 * n + (c - '0');
230a3db4 164 c = get_char (]AT_YYLEX_ARGS[);
6c88b51e
JD
165 }
166
230a3db4 167 unget_char (]AT_YYLEX_PRE_ARGS[ c);
6c88b51e
JD
168
169 return sign * n;
170}
171
172
173/*---------------------------------------------------------------.
174| Lexical analyzer returns an integer on the stack and the token |
175| NUM, or the ASCII character read if not a number. Skips all |
176| blanks and tabs, returns 0 for EOF. |
177`---------------------------------------------------------------*/
178
230a3db4 179]AT_YYLEX_PROTOTYPE[
6c88b51e
JD
180{
181 static int init = 1;
182 int c;
183
184 if (init)
185 {
186 init = 0;
187]AT_LOCATION_IF([
4f756f88
AD
188 AT_LOC_LAST_COLUMN = 1;
189 AT_LOC_LAST_LINE = 1;
6c88b51e
JD
190])[
191 }
192
67f1a2c2
AD
193 /* Skip current token, then white spaces. */
194 do
6c88b51e
JD
195 {
196]AT_LOCATION_IF(
4f756f88
AD
197[ AT_LOC_FIRST_COLUMN = AT_LOC_LAST_COLUMN;
198 AT_LOC_FIRST_LINE = AT_LOC_LAST_LINE;
6c88b51e
JD
199])[
200 }
230a3db4 201 while ((c = get_char (]AT_YYLEX_ARGS[)) == ' ' || c == '\t');
6c88b51e
JD
202
203 /* process numbers */
204 if (c == '.' || isdigit (c))
205 {
230a3db4
AD
206 unget_char (]AT_YYLEX_PRE_ARGS[ c);
207 ]AT_VAL[.ival = read_signed_integer (]AT_YYLEX_ARGS[);
417e31d2 208 return ]AT_TOKEN_PREFIX[NUM;
6c88b51e
JD
209 }
210
211 /* Return end-of-file. */
212 if (c == EOF)
417e31d2 213 return ]AT_TOKEN_PREFIX[CALC_EOF;
6c88b51e
JD
214
215 /* Return single chars. */
216 return c;
217}
218]])
219
9501dc6e 220AT_DATA_GRAMMAR([calc.y],
bfb07874 221[[/* Infix notation calculator--calc */
fb9712a9 222]$4
8f7e3cf9 223AT_SKEL_CC_IF(
16dc6a9e 224[%define global_tokens_and_yystype])[
c499231d
AD
225%code requires
226{
49976d5c 227]AT_LOCATION_TYPE_IF([[
24bb8c8c
AD
228# include <iostream>
229 struct Point
230 {
231 int l;
232 int c;
233 };
234
235 struct Span
236 {
49976d5c
AD
237 Point first;
238 Point last;
24bb8c8c 239 };
49976d5c
AD
240
241# define YYLLOC_DEFAULT(Current, Rhs, N) \
bb9191dd
AD
242 do \
243 if (N) \
244 { \
245 (Current).first = YYRHSLOC (Rhs, 1).first; \
246 (Current).last = YYRHSLOC (Rhs, N).last; \
247 } \
248 else \
249 { \
250 (Current).first = (Current).last = YYRHSLOC (Rhs, 0).last; \
251 } \
252 while (false)
49976d5c
AD
253
254]])[
24bb8c8c
AD
255 /* Exercise pre-prologue dependency to %union. */
256 typedef int semantic_value;
6c88b51e
JD
257}
258
259/* Exercise %union. */
260%union
261{
262 semantic_value ival;
263};
264
c499231d
AD
265%code provides
266{
ad60e80f
AD
267 #include <stdio.h>
268 /* The input. */
269 extern FILE *input;
270 extern semantic_value global_result;
271 extern int global_count;
6c88b51e 272}
2ce10144 273
c499231d
AD
274%code
275{
459a57a9 276#include <assert.h>
6e26ca8c 277#include <string.h>
affac613 278#define USE(Var)
bfb07874 279
6c88b51e 280FILE *input;
c19988b7 281static int power (int base, int exponent);
49976d5c 282
6c88b51e 283]AT_SKEL_CC_IF(,
ad60e80f 284[static void yyerror (AT_YYERROR_ARG_LOC_IF([AT_YYLTYPE *llocp, ])
caf37a36 285 AT_PARAM_IF([semantic_value *result, int *count, ])
93724f13 286 const char *s
d02b25f9 287 );])[
230a3db4 288]AT_YYLEX_DECLARE_EXTERN[
6c88b51e 289}
c19988b7 290
24bb8c8c 291]AT_SKEL_CC_IF([AT_LOCATION_IF([AT_LOCATION_TYPE_IF([], [
2ea7730c 292/* The lalr1.cc skeleton, for backward compatibility, defines
8f7e3cf9
AD
293 a constructor for position that initializes the filename. The
294 glr.cc skeleton does not (and in fact cannot: location/position
295 are stored in a union, from which objects with constructors are
2ea7730c 296 excluded in C++). */
8f7e3cf9 297%initial-action {
ef51bfa7 298 @$.initialize ();
8f7e3cf9 299}
24bb8c8c 300])])])[
8f7e3cf9 301
6b7e85b9 302/* Bison Declarations */
c19988b7 303%token CALC_EOF 0 "end of input"
213e640e
AD
304%token <ival> NUM "number"
305%type <ival> exp
bfb07874 306
e9690142 307%nonassoc '=' /* comparison */
bfb07874
AD
308%left '-' '+'
309%left '*' '/'
d78f0ac9
AD
310%precedence NEG /* negation--unary minus */
311%right '^' /* exponentiation */
bfb07874
AD
312
313/* Grammar follows */
314%%
315input:
b7c49edf 316 line
2a8d363a 317| input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
bfb07874
AD
318;
319
320line:
c19988b7 321 '\n'
affac613 322| exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; }
bfb07874
AD
323;
324
325exp:
326 NUM { $$ = $1; }
327| exp '=' exp
328 {
2a8d363a
AD
329 if ($1 != $3)
330 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
331 $$ = $1;
bfb07874
AD
332 }
333| exp '+' exp { $$ = $1 + $3; }
334| exp '-' exp { $$ = $1 - $3; }
335| exp '*' exp { $$ = $1 * $3; }
336| exp '/' exp { $$ = $1 / $3; }
337| '-' exp %prec NEG { $$ = -$2; }
338| exp '^' exp { $$ = power ($1, $3); }
339| '(' exp ')' { $$ = $2; }
65015668 340| '(' error ')' { $$ = 1111; yyerrok; }
8f3596a6
AD
341| '!' { $$ = 0; YYERROR; }
342| '-' error { $$ = 0; YYERROR; }
bfb07874
AD
343;
344%%
bfb07874 345
3d8082ad
AD
346static int
347power (int base, int exponent)
348{
349 int res = 1;
350 assert (0 <= exponent);
351 for (/* Niente */; exponent; --exponent)
352 res *= base;
353 return res;
354}
355
8f7e3cf9 356]AT_SKEL_CC_IF(
24bb8c8c
AD
357[AT_LOCATION_TYPE_IF([[
358 std::ostream&
359 operator<< (std::ostream& o, const Span& s)
360 {
49976d5c
AD
361 o << s.first.l << '.' << s.first.c;
362 if (s.first.l != s.last.l)
363 o << '-' << s.last.l << '.' << s.last.c - 1;
364 else if (s.first.c != s.last.c - 1)
365 o << '-' << s.last.c - 1;
24bb8c8c
AD
366 return o;
367 }
368]])
74909941 369AT_YYERROR_DEFINE],
c499231d
AD
370[/* A C error reporting function. */
371static void
ad60e80f 372yyerror (AT_YYERROR_ARG_LOC_IF([AT_YYLTYPE *llocp, ])
caf37a36 373 AT_PARAM_IF([semantic_value *result, int *count, ])
7548fed2
AD
374 const char *s)
375{
376AT_PARAM_IF([(void) result; (void) count;])
377AT_YYERROR_SEES_LOC_IF([
378 fprintf (stderr, "%d.%d",
4f756f88
AD
379 AT_LOC_FIRST_LINE, AT_LOC_FIRST_COLUMN);
380 if (AT_LOC_FIRST_LINE != AT_LOC_LAST_LINE)
7548fed2 381 fprintf (stderr, "-%d.%d",
e9690142 382 AT_LOC_LAST_LINE, AT_LOC_LAST_COLUMN - 1);
4f756f88 383 else if (AT_LOC_FIRST_COLUMN != AT_LOC_LAST_COLUMN - 1)
7548fed2 384 fprintf (stderr, "-%d",
e9690142 385 AT_LOC_LAST_COLUMN - 1);
7548fed2
AD
386 fprintf (stderr, ": ");])
387 fprintf (stderr, "%s\n", s);
388}])[
c8c220d1
AD
389]AT_DEFINES_IF([],
390[AT_CALC_LEX
dcd5344d 391AT_CALC_MAIN])])
c8c220d1 392
6c88b51e
JD
393AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
394[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
395
c8c220d1
AD
396]AT_CALC_LEX])
397AT_DATA_SOURCE([[calc-main.c]AT_SKEL_CC_IF([[c]])],
398[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
399
400]AT_CALC_MAIN])
401])
402m4_popdef([AT_CALC_MAIN])
6c88b51e 403m4_popdef([AT_CALC_LEX])
bfb07874
AD
404])# _AT_DATA_CALC_Y
405
406
407# AT_DATA_CALC_Y([BISON-OPTIONS])
408# -------------------------------
6c88b51e
JD
409# Produce `calc.y' and, if %defines was specified, `calc-lex.c' or
410# `calc-lex.cc'.
342b8b6e 411m4_define([AT_DATA_CALC_Y],
9e32add8 412[_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
f50adbbd 413])
bfb07874
AD
414
415
416
d9963c85
PE
417# _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES])
418# --------------------------------------------------------
bfb07874 419# Run `calc' on INPUT and expect no STDOUT nor STDERR.
342b8b6e 420#
f50adbbd 421# If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
d9963c85 422#
f50adbbd 423# NUM-STDERR-LINES is the number of expected lines on stderr.
d9963c85 424# Currently this is ignored, though, since the output format is fluctuating.
f50adbbd
AD
425#
426# We don't count GLR's traces yet, since its traces are somewhat
427# different from LALR's.
342b8b6e
AD
428m4_define([_AT_CHECK_CALC],
429[AT_DATA([[input]],
430[[$2
431]])
f50adbbd 432AT_PARSER_CHECK([./calc input], 0, [], [stderr])
342b8b6e
AD
433])
434
435
b0f98b10 436# _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
d9963c85 437# [NUM-STDERR-LINES],
2a8d363a 438# [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
b0f98b10 439# ---------------------------------------------------------
6e649e65 440# Run `calc' on INPUT, and expect a `syntax error' message.
342b8b6e 441#
b7c49edf
AD
442# If INPUT starts with a slash, it is used as absolute input file name,
443# otherwise as contents.
444#
d9963c85
PE
445# NUM-STDERR-LINES is the number of expected lines on stderr.
446# Currently this is ignored, though, since the output format is fluctuating.
447#
9e32add8 448# If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
342b8b6e
AD
449# is correctly output on stderr.
450#
cf499cff 451# If BISON-OPTIONS contains `%define parse.error verbose', then make sure the
6e649e65 452# IF-YYERROR-VERBOSE message is properly output after `syntax error, '
342b8b6e
AD
453# on STDERR.
454#
f50adbbd
AD
455# If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
456# is the number of expected lines on stderr.
342b8b6e 457m4_define([_AT_CHECK_CALC_ERROR],
b0f98b10
AD
458[m4_bmatch([$3], [^/],
459 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
b7c49edf 460 [AT_DATA([[input]],
b0f98b10 461[[$3
342b8b6e 462]])
b0f98b10 463AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
342b8b6e 464
51dec47b
AD
465# Normalize the observed and expected error messages, depending upon the
466# options.
467# 1. Remove the traces from observed.
9280d3ef
AD
468sed '/^Starting/d
469/^Entering/d
f50adbbd 470/^Stack/d
9280d3ef
AD
471/^Reading/d
472/^Reducing/d
31c10e38 473/^Return/d
9280d3ef
AD
474/^Shifting/d
475/^state/d
dd5f2af2 476/^Cleanup:/d
9280d3ef
AD
477/^Error:/d
478/^Next/d
31c10e38 479/^Now/d
9280d3ef 480/^Discarding/d
62b08cfc 481/ \$[[0-9$]]* = /d
9280d3ef 482/^yydestructor:/d' stderr >at-stderr
342b8b6e 483mv at-stderr stderr
51dec47b
AD
484# 2. Create the reference error message.
485AT_DATA([[expout]],
b0f98b10 486[$5
342b8b6e 487])
51dec47b 488# 3. If locations are not used, remove them.
2a8d363a 489AT_YYERROR_SEES_LOC_IF([],
51dec47b
AD
490[[sed 's/^[-0-9.]*: //' expout >at-expout
491mv at-expout expout]])
492# 4. If error-verbose is not used, strip the`, unexpected....' part.
cf499cff 493m4_bmatch([$1], [%define parse.error verbose], [],
6e649e65 494[[sed 's/syntax error, .*$/syntax error/' expout >at-expout
51dec47b
AD
495mv at-expout expout]])
496# 5. Check
497AT_CHECK([cat stderr], 0, [expout])
342b8b6e 498])
bfb07874
AD
499
500
dcd5344d
AD
501# AT_CHECK_SPACES([FILE])
502# -----------------------
503# Make sure we did not introduce bad spaces. Checked here because all
504# the skeletons are (or should be) exercized here.
505m4_define([AT_CHECK_SPACES],
ff020c30 506[AT_CHECK([$PERL -ne '
a727e712
AD
507 chomp;
508 print "$.: {$_}\n"
509 if (# No starting/ending empty lines.
510 (eof || $. == 1) && /^\s*$/
23d13411
AD
511 # No trailing space.
512 || /\s$/
513 # No tabs.
514 || /\t/
a727e712
AD
515 )' $1
516])dnl
dcd5344d
AD
517])
518
519
eb46d61f
AD
520# AT_CHECK_CALC([BISON-OPTIONS])
521# ------------------------------
bfb07874
AD
522# Start a testing chunk which compiles `calc' grammar with
523# BISON-OPTIONS, and performs several tests over the parser.
342b8b6e 524m4_define([AT_CHECK_CALC],
eb46d61f 525[m4_ifval([$2], [m4_fatal([$0: expected a single argument])])
bfb07874 526
eb46d61f
AD
527# We use integers to avoid dependencies upon the precision of doubles.
528AT_SETUP([Calculator $1])
907e3bc8 529
67a25fed 530AT_BISON_OPTION_PUSHDEFS([$1])
2a8d363a 531
bfb07874 532AT_DATA_CALC_Y([$1])
c8c220d1 533AT_FULL_COMPILE([calc], AT_DEFINES_IF([[lex], [main]]))
dcd5344d
AD
534AT_CHECK_SPACES([calc.AT_SKEL_CC_IF([cc], [c])])
535AT_DEFINES_IF([AT_CHECK_SPACES([calc.AT_SKEL_CC_IF([hh], [h])])])
bfb07874
AD
536
537# Test the priorities.
538_AT_CHECK_CALC([$1],
539[1 + 2 * 3 = 7
5401 + 2 * -3 = -5
541
542-1^2 = -1
543(-1)^2 = 1
544
545---1 = -1
546
5471 - 2 - 3 = -4
5481 - (2 - 3) = 2
549
5502^2^3 = 256
e7cb57c0 551(2^2)^3 = 64],
d1ff7a7c 552 [842])
bfb07874 553
6e649e65 554# Some syntax errors.
d1ff7a7c 555_AT_CHECK_CALC_ERROR([$1], [1], [0 0], [15],
cd48d21d 556 [1.3: syntax error, unexpected number])
d1ff7a7c 557_AT_CHECK_CALC_ERROR([$1], [1], [1//2], [20],
cd48d21d 558 [1.3: syntax error, unexpected '/', expecting number or '-' or '(' or '!'])
e757bb10 559_AT_CHECK_CALC_ERROR([$1], [1], [error], [5],
cd48d21d 560 [1.1: syntax error, unexpected $undefined])
d1ff7a7c 561_AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [30],
cd48d21d 562 [1.7: syntax error, unexpected '='])
b0f98b10 563_AT_CHECK_CALC_ERROR([$1], [1],
bfb07874
AD
564 [
565+1],
d1ff7a7c 566 [20],
cd48d21d 567 [2.1: syntax error, unexpected '+'])
b7c49edf 568# Exercise error messages with EOF: work on an empty file.
cea1469d 569_AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
cd48d21d 570 [1.1: syntax error, unexpected end of input])
51dec47b
AD
571
572# Exercise the error token: without it, we die at the first error,
0b86fc41
AD
573# hence be sure to
574#
575# - have several errors which exercise different shift/discardings
576# - (): nothing to pop, nothing to discard
577# - (1 + 1 + 1 +): a lot to pop, nothing to discard
578# - (* * *): nothing to pop, a lot to discard
579# - (1 + 2 * *): some to pop and discard
580#
581# - test the action associated to `error'
582#
742e4900
JD
583# - check the lookahead that triggers an error is not discarded
584# when we enter error recovery. Below, the lookahead causing the
0b86fc41
AD
585# first error is ")", which is needed to recover from the error and
586# produce the "0" that triggers the "0 != 1" error.
587#
588_AT_CHECK_CALC_ERROR([$1], [0],
589 [() + (1 + 1 + 1 +) + (* * *) + (1 * 2 * *) = 1],
d1ff7a7c 590 [250],
cd48d21d
AD
591[1.2: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5921.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!'
5931.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
5941.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
0b86fc41
AD
595calc: error: 4444 != 1])
596
597# The same, but this time exercising explicitly triggered syntax errors.
742e4900 598# POSIX says the lookahead causing the error should not be discarded.
d1ff7a7c 599_AT_CHECK_CALC_ERROR([$1], [0], [(!) + (0 0) = 1], [102],
cd48d21d 600[1.10: syntax error, unexpected number
0b86fc41 601calc: error: 2222 != 1])
d1ff7a7c 602_AT_CHECK_CALC_ERROR([$1], [0], [(- *) + (0 0) = 1], [113],
cd48d21d
AD
603[1.4: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
6041.12: syntax error, unexpected number
82c53be4 605calc: error: 2222 != 1])
65015668
AD
606
607# Check that yyerrok works properly: second error is not reported,
608# third and fourth are. Parse status is succesfull.
609_AT_CHECK_CALC_ERROR([$1], [0], [(* *) + (*) + (*)], [113],
610[1.2: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
6111.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!'
6121.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!'])
613
67a25fed 614AT_BISON_OPTION_POPDEFS
2a8d363a 615
d803322e 616AT_CLEANUP
bfb07874
AD
617])# AT_CHECK_CALC
618
619
620
621
f50adbbd
AD
622# ------------------------ #
623# Simple LALR Calculator. #
624# ------------------------ #
625
8f7e3cf9 626AT_BANNER([[Simple LALR(1) Calculator.]])
f50adbbd
AD
627
628# AT_CHECK_CALC_LALR([BISON-OPTIONS])
629# -----------------------------------
630# Start a testing chunk which compiles `calc' grammar with
631# BISON-OPTIONS, and performs several tests over the parser.
632m4_define([AT_CHECK_CALC_LALR],
633[AT_CHECK_CALC($@)])
634
635AT_CHECK_CALC_LALR()
636
9e32add8 637AT_CHECK_CALC_LALR([%defines])
ae7453f2 638AT_CHECK_CALC_LALR([%locations])
24bb8c8c 639
2062d72d 640AT_CHECK_CALC_LALR([%name-prefix "calc"])
9e32add8
AD
641AT_CHECK_CALC_LALR([%verbose])
642AT_CHECK_CALC_LALR([%yacc])
cf499cff 643AT_CHECK_CALC_LALR([%define parse.error verbose])
f50adbbd 644
d9df47b6 645AT_CHECK_CALC_LALR([%define api.pure %locations])
cf499cff
JD
646AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations])
647AT_CHECK_CALC_LALR([%define parse.error verbose %locations])
f50adbbd 648
60aa04a2 649AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %define api.prefix "calc" %verbose %yacc])
2a6b66c5 650AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %define api.token.prefix "TOK_" %verbose %yacc])
f50adbbd
AD
651
652AT_CHECK_CALC_LALR([%debug])
cf499cff 653AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
60aa04a2 654AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
c19988b7 655
cf499cff 656AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
60aa04a2 657AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc])
2a8d363a 658
34904c57 659AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
f50adbbd
AD
660
661
662# ----------------------- #
663# Simple GLR Calculator. #
664# ----------------------- #
665
666AT_BANNER([[Simple GLR Calculator.]])
667
668# AT_CHECK_CALC_GLR([BISON-OPTIONS])
669# ----------------------------------
670# Start a testing chunk which compiles `calc' grammar with
671# BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
672m4_define([AT_CHECK_CALC_GLR],
ae7453f2 673[AT_CHECK_CALC([%glr-parser] $@)])
f50adbbd 674
bfb07874 675
f50adbbd 676AT_CHECK_CALC_GLR()
bfb07874 677
9e32add8 678AT_CHECK_CALC_GLR([%defines])
ae7453f2 679AT_CHECK_CALC_GLR([%locations])
02975b9a 680AT_CHECK_CALC_GLR([%name-prefix "calc"])
ad60e80f 681AT_CHECK_CALC_GLR([%define api.prefix "calc"])
9e32add8
AD
682AT_CHECK_CALC_GLR([%verbose])
683AT_CHECK_CALC_GLR([%yacc])
cf499cff 684AT_CHECK_CALC_GLR([%define parse.error verbose])
bfb07874 685
d9df47b6 686AT_CHECK_CALC_GLR([%define api.pure %locations])
cf499cff 687AT_CHECK_CALC_GLR([%define parse.error verbose %locations])
bfb07874 688
cf499cff 689AT_CHECK_CALC_GLR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc])
bfb07874 690
f50adbbd 691AT_CHECK_CALC_GLR([%debug])
cf499cff 692AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
2a6b66c5 693AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %define api.prefix "calc" %define api.token.prefix "TOK_" %verbose %yacc])
21964f43 694
cf499cff 695AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc])
2a8d363a 696
34904c57
AD
697AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
698AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
7548fed2
AD
699
700
701# ----------------------------- #
702# Simple LALR1 C++ Calculator. #
703# ----------------------------- #
704
8f7e3cf9 705AT_BANNER([[Simple LALR(1) C++ Calculator.]])
7548fed2 706
0e021770 707# First let's try using %skeleton
34904c57 708AT_CHECK_CALC([%skeleton "lalr1.cc" %defines])
0e021770 709
7548fed2
AD
710# AT_CHECK_CALC_LALR1_CC([BISON-OPTIONS])
711# ---------------------------------------
712# Start a testing chunk which compiles `calc' grammar with
caf37a36 713# the C++ skeleton, and performs several tests over the parser.
7548fed2 714m4_define([AT_CHECK_CALC_LALR1_CC],
85f0b29e 715[AT_CHECK_CALC([%language "C++"] $@)])
8f7e3cf9
AD
716
717AT_CHECK_CALC_LALR1_CC([])
2ea7730c 718AT_CHECK_CALC_LALR1_CC([%locations])
f6b561d9 719AT_CHECK_CALC_LALR1_CC([%locations %define api.location.type Span])
85f0b29e 720AT_CHECK_CALC_LALR1_CC([%defines %locations %define parse.error verbose %name-prefix "calc" %verbose %yacc])
7548fed2 721
60aa04a2 722AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %define api.prefix "calc" %verbose %yacc])
cf499cff 723AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
7548fed2 724
60aa04a2 725AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc])
2a6b66c5 726AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %define api.token.prefix "TOK_" %verbose %yacc])
0b86fc41 727
85f0b29e 728AT_CHECK_CALC_LALR1_CC([%defines %locations %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
34904c57
AD
729
730AT_CHECK_CALC_LALR1_CC([%pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
85f0b29e 731AT_CHECK_CALC_LALR1_CC([%defines %locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
7548fed2 732
7548fed2 733
7548fed2 734
8f7e3cf9
AD
735# --------------------------- #
736# Simple GLR C++ Calculator. #
737# --------------------------- #
738
739AT_BANNER([[Simple GLR C++ Calculator.]])
740
0e021770 741# Again, we try also using %skeleton.
e4c0985b 742AT_CHECK_CALC([%skeleton "glr.cc"])
0e021770 743
8f7e3cf9
AD
744# AT_CHECK_CALC_GLR_CC([BISON-OPTIONS])
745# -------------------------------------
746# Start a testing chunk which compiles `calc' grammar with
747# the GLR C++ skeleton, and performs several tests over the parser.
748m4_define([AT_CHECK_CALC_GLR_CC],
e4c0985b 749[AT_CHECK_CALC([%language "C++" %glr-parser] $@)])
8f7e3cf9 750
fa7b79c0 751AT_CHECK_CALC_GLR_CC([])
34904c57 752AT_CHECK_CALC_GLR_CC([%locations])
f6b561d9 753AT_CHECK_CALC_GLR_CC([%locations %define api.location.type Span])
e4c0985b 754AT_CHECK_CALC_GLR_CC([%defines %define parse.error verbose %name-prefix "calc" %verbose %yacc])
60aa04a2 755AT_CHECK_CALC_GLR_CC([%define parse.error verbose %define api.prefix "calc" %verbose %yacc])
8f7e3cf9 756
fa7b79c0 757AT_CHECK_CALC_GLR_CC([%debug])
cf499cff 758AT_CHECK_CALC_GLR_CC([%define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
7548fed2 759
cf499cff 760AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc])
2a6b66c5 761AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %define api.token.prefix "TOK_" %verbose %yacc])
7548fed2 762
e4c0985b
AD
763AT_CHECK_CALC_GLR_CC([%locations %defines %pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])
764AT_CHECK_CALC_GLR_CC([%locations %defines %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc %parse-param {semantic_value *result} {int *count}])