]> git.saurik.com Git - bison.git/blob - tests/calc.at
(GNU Cim Grammar): Switch to Yacc-style reports.
[bison.git] / tests / calc.at
1 # Checking the output filenames. -*- Autotest -*-
2 # Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
3
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 2, or (at your option)
7 # any later version.
8
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
13
14 # You should have received a copy of the GNU General Public License
15 # along with this program; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
17 # 02111-1307, USA.
18
19 ## ---------------------------------------------------- ##
20 ## Compile the grammar described in the documentation. ##
21 ## ---------------------------------------------------- ##
22
23
24 # ------------------------- #
25 # Helping Autotest macros. #
26 # ------------------------- #
27
28
29 # _AT_DATA_CALC_Y($1, $2, $3, [BISON-DIRECTIVES])
30 # -----------------------------------------------
31 # Produce `calc.y'. Don't call this macro directly, because it contains
32 # some occurrences of `$1' etc. which will be interpreted by m4. So
33 # you should call it with $1, $2, and $3 as arguments, which is what
34 # AT_DATA_CALC_Y does.
35 m4_define([_AT_DATA_CALC_Y],
36 [m4_if([$1$2$3], $[1]$[2]$[3], [],
37 [m4_fatal([$0: Invalid arguments: $@])])dnl
38 AT_DATA_GRAMMAR([calc.y],
39 [[/* Infix notation calculator--calc */
40 ]$4[
41 %{
42 #include <stdio.h>
43
44 #if STDC_HEADERS
45 # include <stdlib.h>
46 # include <string.h>
47 #endif
48 #include <ctype.h>
49
50 extern void perror (const char *s);
51
52 /* Exercise pre-prologue dependency to %union. */
53 typedef int value;
54
55 static value global_result = 0;
56 static int global_count = 0;
57
58 %}
59
60 /* Exercise %union. */
61 %union
62 {
63 value ival;
64 };
65
66 %{
67 #if YYPURE
68 # define LOC (*yylloc)
69 # define VAL (*yylval)
70 #else
71 # define LOC (yylloc)
72 # define VAL (yylval)
73 #endif
74
75 #define YYLLOC_FORMAL ]AT_LOCATION_IF([, YYLTYPE *yylloc])[
76 #define YYLLOC_ARG ]AT_LOCATION_IF([, yylloc])[
77 #define USE_YYLLOC ]AT_LOCATION_IF([(void) yylloc;])[
78
79 #if YYPURE
80 # define LEX_FORMALS YYSTYPE *yylval YYLLOC_FORMAL
81 # define LEX_ARGS yylval YYLLOC_ARG
82 # define USE_LEX_ARGS (void) yylval; USE_YYLLOC
83 # define LEX_PRE_FORMALS LEX_FORMALS,
84 # define LEX_PRE_ARGS LEX_ARGS,
85 #else
86 # define LEX_FORMALS void
87 # define LEX_PRE_FORMALS
88 # define LEX_ARGS
89 # define LEX_PRE_ARGS
90 # define USE_LEX_ARGS
91 #endif
92
93 static int power (int base, int exponent);
94 /* yyerror receives the location if:
95 - %location & %pure & %glr
96 - %location & %pure & %yacc & %parse-param. */
97 static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
98 ]AT_PARAM_IF([value *result, int *count, ])[
99 const char *s
100 );
101 static int yylex (LEX_FORMALS);
102 static int yygetc (LEX_FORMALS);
103 static void yyungetc (LEX_PRE_FORMALS int c);
104 %}
105
106 /* Bison Declarations */
107 %token CALC_EOF 0 "end of input"
108 %token <ival> NUM "number"
109 %type <ival> exp
110
111 %nonassoc '=' /* comparison */
112 %left '-' '+'
113 %left '*' '/'
114 %left NEG /* negation--unary minus */
115 %right '^' /* exponentiation */
116
117 /* Grammar follows */
118 %%
119 input:
120 line
121 | input line { ]AT_PARAM_IF([++*count; ++global_count;])[ }
122 ;
123
124 line:
125 '\n'
126 | exp '\n' { ]AT_PARAM_IF([*result = global_result = $1;])[ }
127 ;
128
129 exp:
130 NUM { $$ = $1; }
131 | exp '=' exp
132 {
133 if ($1 != $3)
134 fprintf (stderr, "calc: error: %d != %d\n", $1, $3);
135 $$ = $1;
136 }
137 | exp '+' exp { $$ = $1 + $3; }
138 | exp '-' exp { $$ = $1 - $3; }
139 | exp '*' exp { $$ = $1 * $3; }
140 | exp '/' exp { $$ = $1 / $3; }
141 | '-' exp %prec NEG { $$ = -$2; }
142 | exp '^' exp { $$ = power ($1, $3); }
143 | '(' exp ')' { $$ = $2; }
144 | '(' error ')' { $$ = 0; }
145 ;
146 %%
147 /* The input. */
148 static FILE *yyin;
149
150 static void
151 yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
152 ]AT_PARAM_IF([value *result, int *count, ])[
153 const char *s
154 )
155 {
156 ]AT_PARAM_IF([(void) result; (void) count; ])[
157 ]AT_YYERROR_SEES_LOC_IF([
158 fprintf (stderr, "%d.%d-%d.%d: ",
159 LOC.first_line, LOC.first_column,
160 LOC.last_line, LOC.last_column);
161 ])[
162 fprintf (stderr, "%s\n", s);
163 }
164
165
166 ]AT_LOCATION_IF([
167 static YYLTYPE last_yylloc;
168 ])[
169 static int
170 yygetc (LEX_FORMALS)
171 {
172 int res = getc (yyin);
173 USE_LEX_ARGS;
174 ]AT_LOCATION_IF([
175 last_yylloc = LOC;
176 if (res == '\n')
177 {
178 LOC.last_line++;
179 LOC.last_column = 1;
180 }
181 else
182 LOC.last_column++;
183 ])[
184 return res;
185 }
186
187
188 static void
189 yyungetc (LEX_PRE_FORMALS int c)
190 {
191 USE_LEX_ARGS;
192 ]AT_LOCATION_IF([
193 /* Wrong when C == `\n'. */
194 LOC = last_yylloc;
195 ])[
196 ungetc (c, yyin);
197 }
198
199 static int
200 read_signed_integer (LEX_FORMALS)
201 {
202 int c = yygetc (LEX_ARGS);
203 int sign = 1;
204 int n = 0;
205
206 USE_LEX_ARGS;
207 if (c == '-')
208 {
209 c = yygetc (LEX_ARGS);
210 sign = -1;
211 }
212
213 while (isdigit (c))
214 {
215 n = 10 * n + (c - '0');
216 c = yygetc (LEX_ARGS);
217 }
218
219 yyungetc (LEX_PRE_ARGS c);
220
221 return sign * n;
222 }
223
224
225
226 /*---------------------------------------------------------------.
227 | Lexical analyzer returns an integer on the stack and the token |
228 | NUM, or the ASCII character read if not a number. Skips all |
229 | blanks and tabs, returns 0 for EOF. |
230 `---------------------------------------------------------------*/
231
232 static int
233 yylex (LEX_FORMALS)
234 {
235 static int init = 1;
236 int c;
237
238 if (init)
239 {
240 init = 0;
241 ]AT_LOCATION_IF([
242 LOC.last_column = 1;
243 LOC.last_line = 1;
244 ])[
245 }
246
247 ]AT_LOCATION_IF([
248 LOC.first_column = LOC.last_column;
249 LOC.first_line = LOC.last_line;
250 ])[
251
252 /* Skip white space. */
253 while ((c = yygetc (LEX_ARGS)) == ' ' || c == '\t')
254 {
255 ]AT_LOCATION_IF([
256 LOC.first_column = LOC.last_column;
257 LOC.first_line = LOC.last_line;
258 ])[
259 }
260
261 /* process numbers */
262 if (c == '.' || isdigit (c))
263 {
264 yyungetc (LEX_PRE_ARGS c);
265 VAL.ival = read_signed_integer (LEX_ARGS);
266 return NUM;
267 }
268
269 /* Return end-of-file. */
270 if (c == EOF)
271 return CALC_EOF;
272
273 /* Return single chars. */
274 return c;
275 }
276
277 static int
278 power (int base, int exponent)
279 {
280 int res = 1;
281 if (exponent < 0)
282 exit (1);
283 for (/* Niente */; exponent; --exponent)
284 res *= base;
285 return res;
286 }
287
288 int
289 main (int argc, const char **argv)
290 {
291 value result = 0;
292 int count = 0;
293 int status;
294
295 if (argc == 2)
296 yyin = fopen (argv[1], "r");
297 else
298 yyin = stdin;
299
300 if (!yyin)
301 {
302 perror (argv[1]);
303 exit (1);
304 }
305
306 #if YYDEBUG
307 yydebug = 1;
308 #endif
309 status = yyparse (]AT_PARAM_IF([&result, &count])[);
310 if (global_result != result)
311 abort ();
312 if (global_count != count)
313 abort ();
314 return status;
315 }
316 ]])
317 ])# _AT_DATA_CALC_Y
318
319
320 # AT_DATA_CALC_Y([BISON-OPTIONS])
321 # -------------------------------
322 # Produce `calc.y'.
323 m4_define([AT_DATA_CALC_Y],
324 [_AT_DATA_CALC_Y($[1], $[2], $[3], [$1])
325 ])
326
327
328
329 # _AT_CHECK_CALC(BISON-OPTIONS, INPUT, [NUM-STDERR-LINES = 0])
330 # ------------------------------------------------------------
331 # Run `calc' on INPUT and expect no STDOUT nor STDERR.
332 #
333 # If BISON-OPTIONS contains `%debug' but not `%glr-parser', then
334 # NUM-STDERR-LINES is the number of expected lines on stderr.
335 #
336 # We don't count GLR's traces yet, since its traces are somewhat
337 # different from LALR's.
338 m4_define([_AT_CHECK_CALC],
339 [AT_DATA([[input]],
340 [[$2
341 ]])
342 AT_PARSER_CHECK([./calc input], 0, [], [stderr])
343 m4_bmatch([$1],
344 [%debug.*%glr\|%glr.*%debug],
345 [],
346 [%debug],
347 [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$3
348 ])])
349 ])
350
351
352 # _AT_CHECK_CALC_ERROR(BISON-OPTIONS, EXIT-STATUS, INPUT,
353 # [NUM-DEBUG-LINES],
354 # [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
355 # ---------------------------------------------------------
356 # Run `calc' on INPUT, and expect a `syntax error' message.
357 #
358 # If INPUT starts with a slash, it is used as absolute input file name,
359 # otherwise as contents.
360 #
361 # If BISON-OPTIONS contains `%location', then make sure the ERROR-LOCATION
362 # is correctly output on stderr.
363 #
364 # If BISON-OPTIONS contains `%error-verbose', then make sure the
365 # IF-YYERROR-VERBOSE message is properly output after `syntax error, '
366 # on STDERR.
367 #
368 # If BISON-OPTIONS contains `%debug' but not `%glr', then NUM-STDERR-LINES
369 # is the number of expected lines on stderr.
370 m4_define([_AT_CHECK_CALC_ERROR],
371 [m4_bmatch([$3], [^/],
372 [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
373 [AT_DATA([[input]],
374 [[$3
375 ]])
376 AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
377 m4_bmatch([$1],
378 [%debug.*%glr\|%glr.*%debug],
379 [],
380 [%debug],
381 [AT_CHECK([wc -l <stderr | sed 's/[[^0-9]]//g'], 0, [$4
382 ])])
383
384 # Normalize the observed and expected error messages, depending upon the
385 # options.
386 # 1. Remove the traces from observed.
387 sed '/^Starting/d
388 /^Entering/d
389 /^Stack/d
390 /^Reading/d
391 /^Reducing/d
392 /^Shifting/d
393 /^state/d
394 /^Error:/d
395 /^Next/d
396 /^Discarding/d
397 /^yydestructor:/d' stderr >at-stderr
398 mv at-stderr stderr
399 # 2. Create the reference error message.
400 AT_DATA([[expout]],
401 [$5
402 ])
403 # 3. If locations are not used, remove them.
404 AT_YYERROR_SEES_LOC_IF([],
405 [[sed 's/^[-0-9.]*: //' expout >at-expout
406 mv at-expout expout]])
407 # 4. If error-verbose is not used, strip the`, unexpected....' part.
408 m4_bmatch([$1], [%error-verbose], [],
409 [[sed 's/syntax error, .*$/syntax error/' expout >at-expout
410 mv at-expout expout]])
411 # 5. Check
412 AT_CHECK([cat stderr], 0, [expout])
413 ])
414
415
416 # AT_CALC_PUSHDEFS($1, $2, [BISON-OPTIONS])
417 # -----------------------------------------
418 # This macro works around the impossibility to define macros
419 # inside macros, because issuing `[$1]' is not possible in M4 :(.
420 # This sucks hard, GNU M4 should really provide M5 like $$1.
421 m4_define([AT_CHECK_PUSHDEFS],
422 [m4_if([$1$2], $[1]$[2], [],
423 [m4_fatal([$0: Invalid arguments: $@])])dnl
424 m4_pushdef([AT_PARAM_IF],
425 [m4_bmatch([$3], [%parse-param], [$1], [$2])])
426 m4_pushdef([AT_LOCATION_IF],
427 [m4_bmatch([$3], [%locations], [$1], [$2])])
428 m4_pushdef([AT_PURE_IF],
429 [m4_bmatch([$3], [%pure-parser], [$1], [$2])])
430 m4_pushdef([AT_GLR_IF],
431 [m4_bmatch([$3], [%glr-parser], [$1], [$2])])
432 m4_pushdef([AT_PURE_AND_LOC_IF],
433 [m4_bmatch([$3], [%locations.*%pure-parser\|%pure-parser.*%locations],
434 [$1], [$2])])
435 m4_pushdef([AT_GLR_OR_PARAM_IF],
436 [m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
437
438 # yyerror receives the location if %location & %pure & (%glr or %parse-param).
439 m4_pushdef([AT_YYERROR_ARG_LOC_IF],
440 [AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
441 [$2])])
442 # yyerror cannot see the locations if !glr & pure & !param.
443 m4_pushdef([AT_YYERROR_SEES_LOC_IF],
444 [AT_LOCATION_IF([AT_GLR_IF([$1],
445 [AT_PURE_IF([AT_PARAM_IF([$1], [$2])],
446 [$1])])],
447 [$2])])
448 ])
449
450
451 # AT_CALC_POPDEFS
452 # ---------------
453 m4_define([AT_CHECK_POPDEFS],
454 [m4_popdef([AT_YYERROR_SEES_LOC_IF])
455 m4_popdef([AT_YYERROR_ARG_LOC_IF])
456 m4_popdef([AT_GLR_OR_PARAM_IF])
457 m4_popdef([AT_PURE_AND_LOC_IF])
458 m4_popdef([AT_GLR_IF])
459 m4_popdef([AT_LOCATION_IF])
460 m4_popdef([AT_PARAM_IF])
461 ])
462
463
464
465 # AT_CHECK_CALC([BISON-OPTIONS])
466 # ------------------------------
467 # Start a testing chunk which compiles `calc' grammar with
468 # BISON-OPTIONS, and performs several tests over the parser.
469 m4_define([AT_CHECK_CALC],
470 [# We use integers to avoid dependencies upon the precision of doubles.
471 AT_SETUP([Calculator $1])
472
473 AT_CHECK_PUSHDEFS($[1], $[2], [$1])
474
475 AT_DATA_CALC_Y([$1])
476
477 # Specify the output files to avoid problems on different file systems.
478 AT_CHECK([bison -o calc.c calc.y],
479 [0], [], [])
480
481 AT_COMPILE([calc])
482
483 # Test the priorities.
484 _AT_CHECK_CALC([$1],
485 [1 + 2 * 3 = 7
486 1 + 2 * -3 = -5
487
488 -1^2 = -1
489 (-1)^2 = 1
490
491 ---1 = -1
492
493 1 - 2 - 3 = -4
494 1 - (2 - 3) = 2
495
496 2^2^3 = 256
497 (2^2)^3 = 64],
498 [486])
499
500 # Some syntax errors.
501 _AT_CHECK_CALC_ERROR([$1], [1], [0 0], [11],
502 [1.3-1.4: syntax error, unexpected "number"])
503 _AT_CHECK_CALC_ERROR([$1], [1], [1//2], [15],
504 [1.3-1.4: syntax error, unexpected '/', expecting "number" or '-' or '('])
505 _AT_CHECK_CALC_ERROR([$1], [1], [error], [4],
506 [1.1-1.2: syntax error, unexpected $undefined, expecting "number" or '-' or '\n' or '('])
507 _AT_CHECK_CALC_ERROR([$1], [1], [1 = 2 = 3], [22],
508 [1.7-1.8: syntax error, unexpected '='])
509 _AT_CHECK_CALC_ERROR([$1], [1],
510 [
511 +1],
512 [14],
513 [2.1-2.2: syntax error, unexpected '+'])
514 # Exercise error messages with EOF: work on an empty file.
515 _AT_CHECK_CALC_ERROR([$1], [1], [/dev/null], [4],
516 [1.1-1.2: syntax error, unexpected "end of input", expecting "number" or '-' or '\n' or '('])
517
518 # Exercise the error token: without it, we die at the first error,
519 # hence be sure i. to have several errors, ii. to test the action
520 # associated to `error'.
521 _AT_CHECK_CALC_ERROR([$1], [0], [(1 ++ 2) + (0 0) = 1], [82],
522 [1.5-1.6: syntax error, unexpected '+', expecting "number" or '-' or '('
523 1.15-1.16: syntax error, unexpected "number"
524 calc: error: 0 != 1])
525
526 AT_CHECK_POPDEFS
527
528 AT_CLEANUP
529 ])# AT_CHECK_CALC
530
531
532
533
534 # ------------------------ #
535 # Simple LALR Calculator. #
536 # ------------------------ #
537
538 AT_BANNER([[Simple LALR Calculator.]])
539
540 # AT_CHECK_CALC_LALR([BISON-OPTIONS])
541 # -----------------------------------
542 # Start a testing chunk which compiles `calc' grammar with
543 # BISON-OPTIONS, and performs several tests over the parser.
544 m4_define([AT_CHECK_CALC_LALR],
545 [AT_CHECK_CALC($@)])
546
547 AT_CHECK_CALC_LALR()
548
549 AT_CHECK_CALC_LALR([%defines])
550 AT_CHECK_CALC_LALR([%locations])
551 AT_CHECK_CALC_LALR([%name-prefix="calc"])
552 AT_CHECK_CALC_LALR([%verbose])
553 AT_CHECK_CALC_LALR([%yacc])
554 AT_CHECK_CALC_LALR([%error-verbose])
555
556 AT_CHECK_CALC_LALR([%error-verbose %locations])
557
558 AT_CHECK_CALC_LALR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
559
560 AT_CHECK_CALC_LALR([%debug])
561 AT_CHECK_CALC_LALR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
562
563 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
564
565 AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param {int *count}])
566
567
568 # ----------------------- #
569 # Simple GLR Calculator. #
570 # ----------------------- #
571
572 AT_BANNER([[Simple GLR Calculator.]])
573
574 # AT_CHECK_CALC_GLR([BISON-OPTIONS])
575 # ----------------------------------
576 # Start a testing chunk which compiles `calc' grammar with
577 # BISON-OPTIONS and %glr-parser, and performs several tests over the parser.
578 m4_define([AT_CHECK_CALC_GLR],
579 [AT_CHECK_CALC([%glr-parser] $@)])
580
581
582 AT_CHECK_CALC_GLR()
583
584 AT_CHECK_CALC_GLR([%defines])
585 AT_CHECK_CALC_GLR([%locations])
586 AT_CHECK_CALC_GLR([%name-prefix="calc"])
587 AT_CHECK_CALC_GLR([%verbose])
588 AT_CHECK_CALC_GLR([%yacc])
589 AT_CHECK_CALC_GLR([%error-verbose])
590
591 AT_CHECK_CALC_GLR([%error-verbose %locations])
592
593 AT_CHECK_CALC_GLR([%error-verbose %locations %defines %name-prefix="calc" %verbose %yacc])
594
595 AT_CHECK_CALC_GLR([%debug])
596 AT_CHECK_CALC_GLR([%error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
597
598 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc])
599
600 AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines %name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param {int *count}])