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