]>
Commit | Line | Data |
---|---|---|
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 |
43 | m4_define([_AT_DATA_CALC_Y], |
44 | [m4_if([$1$2$3], $[1]$[2]$[3], [], | |
45 | [m4_fatal([$0: Invalid arguments: $@])])dnl | |
c8c220d1 AD |
46 | |
47 | m4_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 | ||
56 | AT_SKEL_CC_IF([[ | |
57 | /* A C++ ]AT_NAME_PREFIX[parse that simulates the C signature. */ | |
58 | int | |
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 | ||
69 | semantic_value global_result = 0; | |
70 | int global_count = 0; | |
71 | ||
72 | /* A C main function. */ | |
73 | int | |
74 | main (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 |
108 | m4_pushdef([AT_CALC_LEX], |
109 | [[#include <ctype.h> | |
110 | ||
230a3db4 AD |
111 | ]AT_YYLEX_DECLARE_EXTERN[ |
112 | static int get_char (]AT_YYLEX_FORMALS[); | |
113 | static void unget_char (]AT_YYLEX_PRE_FORMALS[ int c); | |
6c88b51e JD |
114 | |
115 | ]AT_LOCATION_IF([ | |
ad60e80f | 116 | static AT_YYLTYPE last_yylloc; |
6c88b51e JD |
117 | ])[ |
118 | static int | |
230a3db4 | 119 | get_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 | ||
136 | static void | |
230a3db4 | 137 | unget_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 | ||
147 | static int | |
230a3db4 | 148 | read_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 | 220 | AT_DATA_GRAMMAR([calc.y], |
bfb07874 | 221 | [[/* Infix notation calculator--calc */ |
fb9712a9 | 222 | ]$4 |
8f7e3cf9 | 223 | AT_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 | 280 | FILE *input; |
c19988b7 | 281 | static 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 | %% | |
315 | input: | |
b7c49edf | 316 | line |
2a8d363a | 317 | | input line { ]AT_PARAM_IF([++*count; ++global_count;])[ } |
bfb07874 AD |
318 | ; |
319 | ||
320 | line: | |
c19988b7 | 321 | '\n' |
affac613 | 322 | | exp '\n' { ]AT_PARAM_IF([*result = global_result = $1], [USE ($1)])[; } |
bfb07874 AD |
323 | ; |
324 | ||
325 | exp: | |
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 |
346 | static int |
347 | power (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 | 369 | AT_YYERROR_DEFINE], |
c499231d AD |
370 | [/* A C error reporting function. */ |
371 | static void | |
ad60e80f | 372 | yyerror (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 | { | |
376 | AT_PARAM_IF([(void) result; (void) count;]) | |
377 | AT_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 | 391 | AT_CALC_MAIN])]) |
c8c220d1 | 392 | |
6c88b51e JD |
393 | AT_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]) |
397 | AT_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 | ]) | |
402 | m4_popdef([AT_CALC_MAIN]) | |
6c88b51e | 403 | m4_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 | 411 | m4_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 |
428 | m4_define([_AT_CHECK_CALC], |
429 | [AT_DATA([[input]], | |
430 | [[$2 | |
431 | ]]) | |
f50adbbd | 432 | AT_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 | 457 | m4_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 | 463 | AT_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 |
468 | sed '/^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 | 483 | mv at-stderr stderr |
51dec47b AD |
484 | # 2. Create the reference error message. |
485 | AT_DATA([[expout]], | |
b0f98b10 | 486 | [$5 |
342b8b6e | 487 | ]) |
51dec47b | 488 | # 3. If locations are not used, remove them. |
2a8d363a | 489 | AT_YYERROR_SEES_LOC_IF([], |
51dec47b AD |
490 | [[sed 's/^[-0-9.]*: //' expout >at-expout |
491 | mv at-expout expout]]) | |
492 | # 4. If error-verbose is not used, strip the`, unexpected....' part. | |
cf499cff | 493 | m4_bmatch([$1], [%define parse.error verbose], [], |
6e649e65 | 494 | [[sed 's/syntax error, .*$/syntax error/' expout >at-expout |
51dec47b AD |
495 | mv at-expout expout]]) |
496 | # 5. Check | |
497 | AT_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. | |
505 | m4_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 | 524 | m4_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. |
528 | AT_SETUP([Calculator $1]) | |
907e3bc8 | 529 | |
67a25fed | 530 | AT_BISON_OPTION_PUSHDEFS([$1]) |
2a8d363a | 531 | |
bfb07874 | 532 | AT_DATA_CALC_Y([$1]) |
c8c220d1 | 533 | AT_FULL_COMPILE([calc], AT_DEFINES_IF([[lex], [main]])) |
dcd5344d AD |
534 | AT_CHECK_SPACES([calc.AT_SKEL_CC_IF([cc], [c])]) |
535 | AT_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 | |
540 | 1 + 2 * -3 = -5 | |
541 | ||
542 | -1^2 = -1 | |
543 | (-1)^2 = 1 | |
544 | ||
545 | ---1 = -1 | |
546 | ||
547 | 1 - 2 - 3 = -4 | |
548 | 1 - (2 - 3) = 2 | |
549 | ||
550 | 2^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 '!' |
592 | 1.18: syntax error, unexpected ')', expecting number or '-' or '(' or '!' | |
593 | 1.23: syntax error, unexpected '*', expecting number or '-' or '(' or '!' | |
594 | 1.41: syntax error, unexpected '*', expecting number or '-' or '(' or '!' | |
0b86fc41 AD |
595 | calc: 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 | 601 | calc: 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 '!' |
604 | 1.12: syntax error, unexpected number | |
82c53be4 | 605 | calc: 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 '!' | |
611 | 1.10: syntax error, unexpected '*', expecting number or '-' or '(' or '!' | |
612 | 1.16: syntax error, unexpected '*', expecting number or '-' or '(' or '!']) | |
613 | ||
67a25fed | 614 | AT_BISON_OPTION_POPDEFS |
2a8d363a | 615 | |
d803322e | 616 | AT_CLEANUP |
bfb07874 AD |
617 | ])# AT_CHECK_CALC |
618 | ||
619 | ||
620 | ||
621 | ||
f50adbbd AD |
622 | # ------------------------ # |
623 | # Simple LALR Calculator. # | |
624 | # ------------------------ # | |
625 | ||
8f7e3cf9 | 626 | AT_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. | |
632 | m4_define([AT_CHECK_CALC_LALR], | |
633 | [AT_CHECK_CALC($@)]) | |
634 | ||
635 | AT_CHECK_CALC_LALR() | |
636 | ||
9e32add8 | 637 | AT_CHECK_CALC_LALR([%defines]) |
ae7453f2 | 638 | AT_CHECK_CALC_LALR([%locations]) |
24bb8c8c | 639 | |
2062d72d | 640 | AT_CHECK_CALC_LALR([%name-prefix "calc"]) |
9e32add8 AD |
641 | AT_CHECK_CALC_LALR([%verbose]) |
642 | AT_CHECK_CALC_LALR([%yacc]) | |
cf499cff | 643 | AT_CHECK_CALC_LALR([%define parse.error verbose]) |
f50adbbd | 644 | |
d9df47b6 | 645 | AT_CHECK_CALC_LALR([%define api.pure %locations]) |
cf499cff JD |
646 | AT_CHECK_CALC_LALR([%define api.push-pull both %define api.pure %locations]) |
647 | AT_CHECK_CALC_LALR([%define parse.error verbose %locations]) | |
f50adbbd | 648 | |
60aa04a2 | 649 | AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %define api.prefix "calc" %verbose %yacc]) |
2a6b66c5 | 650 | AT_CHECK_CALC_LALR([%define parse.error verbose %locations %defines %name-prefix "calc" %define api.token.prefix "TOK_" %verbose %yacc]) |
f50adbbd AD |
651 | |
652 | AT_CHECK_CALC_LALR([%debug]) | |
cf499cff | 653 | AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc]) |
60aa04a2 | 654 | AT_CHECK_CALC_LALR([%define parse.error verbose %debug %locations %defines %define api.prefix "calc" %verbose %yacc]) |
c19988b7 | 655 | |
cf499cff | 656 | AT_CHECK_CALC_LALR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc]) |
60aa04a2 | 657 | AT_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 | 659 | AT_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 | ||
666 | AT_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. | |
672 | m4_define([AT_CHECK_CALC_GLR], | |
ae7453f2 | 673 | [AT_CHECK_CALC([%glr-parser] $@)]) |
f50adbbd | 674 | |
bfb07874 | 675 | |
f50adbbd | 676 | AT_CHECK_CALC_GLR() |
bfb07874 | 677 | |
9e32add8 | 678 | AT_CHECK_CALC_GLR([%defines]) |
ae7453f2 | 679 | AT_CHECK_CALC_GLR([%locations]) |
02975b9a | 680 | AT_CHECK_CALC_GLR([%name-prefix "calc"]) |
ad60e80f | 681 | AT_CHECK_CALC_GLR([%define api.prefix "calc"]) |
9e32add8 AD |
682 | AT_CHECK_CALC_GLR([%verbose]) |
683 | AT_CHECK_CALC_GLR([%yacc]) | |
cf499cff | 684 | AT_CHECK_CALC_GLR([%define parse.error verbose]) |
bfb07874 | 685 | |
d9df47b6 | 686 | AT_CHECK_CALC_GLR([%define api.pure %locations]) |
cf499cff | 687 | AT_CHECK_CALC_GLR([%define parse.error verbose %locations]) |
bfb07874 | 688 | |
cf499cff | 689 | AT_CHECK_CALC_GLR([%define parse.error verbose %locations %defines %name-prefix "calc" %verbose %yacc]) |
bfb07874 | 690 | |
f50adbbd | 691 | AT_CHECK_CALC_GLR([%debug]) |
cf499cff | 692 | AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc]) |
2a6b66c5 | 693 | AT_CHECK_CALC_GLR([%define parse.error verbose %debug %locations %defines %define api.prefix "calc" %define api.token.prefix "TOK_" %verbose %yacc]) |
21964f43 | 694 | |
cf499cff | 695 | AT_CHECK_CALC_GLR([%define api.pure %define parse.error verbose %debug %locations %defines %name-prefix "calc" %verbose %yacc]) |
2a8d363a | 696 | |
34904c57 AD |
697 | AT_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}]) |
698 | AT_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 | 705 | AT_BANNER([[Simple LALR(1) C++ Calculator.]]) |
7548fed2 | 706 | |
0e021770 | 707 | # First let's try using %skeleton |
34904c57 | 708 | AT_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 | 714 | m4_define([AT_CHECK_CALC_LALR1_CC], |
85f0b29e | 715 | [AT_CHECK_CALC([%language "C++"] $@)]) |
8f7e3cf9 AD |
716 | |
717 | AT_CHECK_CALC_LALR1_CC([]) | |
2ea7730c | 718 | AT_CHECK_CALC_LALR1_CC([%locations]) |
f6b561d9 | 719 | AT_CHECK_CALC_LALR1_CC([%locations %define api.location.type Span]) |
85f0b29e | 720 | AT_CHECK_CALC_LALR1_CC([%defines %locations %define parse.error verbose %name-prefix "calc" %verbose %yacc]) |
7548fed2 | 721 | |
60aa04a2 | 722 | AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %define api.prefix "calc" %verbose %yacc]) |
cf499cff | 723 | AT_CHECK_CALC_LALR1_CC([%locations %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc]) |
7548fed2 | 724 | |
60aa04a2 | 725 | AT_CHECK_CALC_LALR1_CC([%locations %pure-parser %define parse.error verbose %debug %define api.prefix "calc" %verbose %yacc]) |
2a6b66c5 | 726 | AT_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 | 728 | AT_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 | |
730 | AT_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 | 731 | AT_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 | ||
739 | AT_BANNER([[Simple GLR C++ Calculator.]]) | |
740 | ||
0e021770 | 741 | # Again, we try also using %skeleton. |
e4c0985b | 742 | AT_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. | |
748 | m4_define([AT_CHECK_CALC_GLR_CC], | |
e4c0985b | 749 | [AT_CHECK_CALC([%language "C++" %glr-parser] $@)]) |
8f7e3cf9 | 750 | |
fa7b79c0 | 751 | AT_CHECK_CALC_GLR_CC([]) |
34904c57 | 752 | AT_CHECK_CALC_GLR_CC([%locations]) |
f6b561d9 | 753 | AT_CHECK_CALC_GLR_CC([%locations %define api.location.type Span]) |
e4c0985b | 754 | AT_CHECK_CALC_GLR_CC([%defines %define parse.error verbose %name-prefix "calc" %verbose %yacc]) |
60aa04a2 | 755 | AT_CHECK_CALC_GLR_CC([%define parse.error verbose %define api.prefix "calc" %verbose %yacc]) |
8f7e3cf9 | 756 | |
fa7b79c0 | 757 | AT_CHECK_CALC_GLR_CC([%debug]) |
cf499cff | 758 | AT_CHECK_CALC_GLR_CC([%define parse.error verbose %debug %name-prefix "calc" %verbose %yacc]) |
7548fed2 | 759 | |
cf499cff | 760 | AT_CHECK_CALC_GLR_CC([%pure-parser %define parse.error verbose %debug %name-prefix "calc" %verbose %yacc]) |
2a6b66c5 | 761 | AT_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 |
763 | AT_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}]) |
764 | AT_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}]) |