]>
Commit | Line | Data |
---|---|---|
342b8b6e | 1 | # Bison Regressions. -*- Autotest -*- |
d42cf844 | 2 | |
34136e65 | 3 | # Copyright (C) 2001-2012 Free Software Foundation, Inc. |
c95f2d78 | 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/>. |
c95f2d78 | 17 | |
342b8b6e | 18 | AT_BANNER([[Regression tests.]]) |
c95f2d78 | 19 | |
2b25d624 | 20 | |
276f48df PE |
21 | ## ------------------ ## |
22 | ## Trivial grammars. ## | |
23 | ## ------------------ ## | |
24 | ||
25 | AT_SETUP([Trivial grammars]) | |
26 | ||
71c7e24f | 27 | AT_BISON_OPTION_PUSHDEFS |
276f48df PE |
28 | AT_DATA_GRAMMAR([input.y], |
29 | [[%{ | |
55f48c48 AD |
30 | ]AT_YYERROR_DECLARE_EXTERN[ |
31 | ]AT_YYLEX_DECLARE_EXTERN[ | |
50cce58e | 32 | #define YYSTYPE int * |
276f48df PE |
33 | %} |
34 | ||
35 | %error-verbose | |
36 | ||
37 | %% | |
38 | ||
39 | program: 'x'; | |
40 | ]]) | |
71c7e24f | 41 | AT_BISON_OPTION_POPDEFS |
276f48df | 42 | |
da730230 | 43 | AT_BISON_CHECK([-o input.c input.y]) |
91ce0b3a | 44 | AT_COMPILE([input.o]) |
50cce58e | 45 | AT_COMPILE([input.o], [-DYYDEBUG -c input.c]) |
276f48df PE |
46 | |
47 | AT_CLEANUP | |
48 | ||
49 | ||
50 | ||
ddc8ede1 PE |
51 | ## ----------------- ## |
52 | ## YYSTYPE typedef. ## | |
53 | ## ----------------- ## | |
54 | ||
55 | AT_SETUP([YYSTYPE typedef]) | |
56 | ||
71c7e24f | 57 | AT_BISON_OPTION_PUSHDEFS |
ddc8ede1 PE |
58 | AT_DATA_GRAMMAR([input.y], |
59 | [[%{ | |
55f48c48 AD |
60 | ]AT_YYERROR_DECLARE_EXTERN[ |
61 | ]AT_YYLEX_DECLARE_EXTERN[ | |
ddc8ede1 PE |
62 | typedef union { char const *val; } YYSTYPE; |
63 | %} | |
64 | ||
65 | %type <val> program | |
66 | ||
67 | %% | |
68 | ||
69 | program: { $$ = ""; }; | |
70 | ]]) | |
71c7e24f | 71 | AT_BISON_OPTION_POPDEFS |
ddc8ede1 | 72 | |
da730230 | 73 | AT_BISON_CHECK([-o input.c input.y]) |
91ce0b3a | 74 | AT_COMPILE([input.o]) |
ddc8ede1 PE |
75 | |
76 | AT_CLEANUP | |
77 | ||
78 | ||
79 | ||
b931235e JD |
80 | ## ------------------------------------- ## |
81 | ## Early token definitions with --yacc. ## | |
82 | ## ------------------------------------- ## | |
69078d4b AD |
83 | |
84 | ||
b931235e | 85 | AT_SETUP([Early token definitions with --yacc]) |
69078d4b AD |
86 | |
87 | # Found in GCJ: they expect the tokens to be defined before the user | |
88 | # prologue, so that they can use the token definitions in it. | |
89 | ||
71c7e24f | 90 | AT_BISON_OPTION_PUSHDEFS |
9501dc6e | 91 | AT_DATA_GRAMMAR([input.y], |
69078d4b | 92 | [[%{ |
55f48c48 AD |
93 | ]AT_YYERROR_DECLARE_EXTERN[ |
94 | ]AT_YYLEX_DECLARE_EXTERN[ | |
69078d4b AD |
95 | %} |
96 | ||
97 | %union | |
98 | { | |
99 | int val; | |
100 | }; | |
9bc0dd67 JD |
101 | %{ |
102 | #ifndef MY_TOKEN | |
103 | # error "MY_TOKEN not defined." | |
104 | #endif | |
105 | %} | |
b931235e JD |
106 | %token MY_TOKEN |
107 | %% | |
108 | exp: MY_TOKEN; | |
109 | %% | |
110 | ]]) | |
71c7e24f | 111 | AT_BISON_OPTION_POPDEFS |
b931235e | 112 | |
da730230 | 113 | AT_BISON_CHECK([-y -o input.c input.y]) |
91ce0b3a | 114 | AT_COMPILE([input.o]) |
b931235e JD |
115 | |
116 | AT_CLEANUP | |
117 | ||
118 | ||
119 | ||
120 | ## ---------------------------------------- ## | |
121 | ## Early token definitions without --yacc. ## | |
122 | ## ---------------------------------------- ## | |
123 | ||
124 | ||
125 | AT_SETUP([Early token definitions without --yacc]) | |
126 | ||
127 | # Found in GCJ: they expect the tokens to be defined before the user | |
128 | # prologue, so that they can use the token definitions in it. | |
129 | ||
71c7e24f | 130 | AT_BISON_OPTION_PUSHDEFS |
b931235e JD |
131 | AT_DATA_GRAMMAR([input.y], |
132 | [[%{ | |
133 | #include <stdio.h> | |
55f48c48 AD |
134 | ]AT_YYERROR_DECLARE_EXTERN[ |
135 | ]AT_YYLEX_DECLARE_EXTERN[ | |
b931235e | 136 | void print_my_token (void); |
9bc0dd67 JD |
137 | %} |
138 | ||
139 | %union | |
140 | { | |
141 | int val; | |
142 | }; | |
143 | %{ | |
b931235e JD |
144 | void |
145 | print_my_token (void) | |
146 | { | |
147 | enum yytokentype my_token = MY_TOKEN; | |
148 | printf ("%d\n", my_token); | |
149 | } | |
69078d4b AD |
150 | %} |
151 | %token MY_TOKEN | |
152 | %% | |
153 | exp: MY_TOKEN; | |
154 | %% | |
155 | ]]) | |
71c7e24f | 156 | AT_BISON_OPTION_POPDEFS |
69078d4b | 157 | |
da730230 | 158 | AT_BISON_CHECK([-o input.c input.y]) |
91ce0b3a | 159 | AT_COMPILE([input.o]) |
69078d4b AD |
160 | |
161 | AT_CLEANUP | |
162 | ||
163 | ||
164 | ||
2b25d624 AD |
165 | ## ---------------- ## |
166 | ## Braces parsing. ## | |
167 | ## ---------------- ## | |
168 | ||
169 | ||
69078d4b | 170 | AT_SETUP([Braces parsing]) |
2b25d624 | 171 | |
71c7e24f | 172 | AT_BISON_OPTION_PUSHDEFS |
2b25d624 | 173 | AT_DATA([input.y], |
ae93e4e4 | 174 | [[/* Bison used to swallow the character after '}'. */ |
2b25d624 AD |
175 | |
176 | %% | |
bfcf1f3a | 177 | exp: { tests = {{{{{{{{{{}}}}}}}}}}; }; |
2b25d624 AD |
178 | %% |
179 | ]]) | |
71c7e24f | 180 | AT_BISON_OPTION_POPDEFS |
2b25d624 | 181 | |
da730230 | 182 | AT_BISON_CHECK([-v -o input.c input.y]) |
2b25d624 | 183 | |
a4bf0390 | 184 | AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore]) |
2b25d624 AD |
185 | |
186 | AT_CLEANUP | |
187 | ||
188 | ||
c95f2d78 AD |
189 | ## ------------------ ## |
190 | ## Duplicate string. ## | |
191 | ## ------------------ ## | |
192 | ||
193 | ||
194 | AT_SETUP([Duplicate string]) | |
195 | ||
71c7e24f | 196 | AT_BISON_OPTION_PUSHDEFS |
f499b062 | 197 | AT_DATA([input.y], |
ae93e4e4 | 198 | [[/* 'Bison -v' used to dump core when two tokens are defined with the same |
c95f2d78 AD |
199 | string, as LE and GE below. */ |
200 | ||
201 | %token NUM | |
202 | %token LE "<=" | |
203 | %token GE "<=" | |
204 | ||
205 | %% | |
206 | exp: '(' exp ')' | NUM ; | |
207 | %% | |
208 | ]]) | |
71c7e24f | 209 | AT_BISON_OPTION_POPDEFS |
c95f2d78 | 210 | |
da730230 | 211 | AT_BISON_CHECK([-v -o input.c input.y], 0, [], |
73370a9d | 212 | [[input.y:6.8-14: warning: symbol "<=" used more than once as a literal string [-Wother] |
69078d4b | 213 | ]]) |
c95f2d78 | 214 | |
d803322e | 215 | AT_CLEANUP |
c95f2d78 AD |
216 | |
217 | ||
2ca209c1 AD |
218 | ## ------------------- ## |
219 | ## Rule Line Numbers. ## | |
220 | ## ------------------- ## | |
221 | ||
222 | AT_SETUP([Rule Line Numbers]) | |
223 | ||
6b98e4b5 AD |
224 | AT_KEYWORDS([report]) |
225 | ||
71c7e24f | 226 | AT_BISON_OPTION_PUSHDEFS |
2ca209c1 AD |
227 | AT_DATA([input.y], |
228 | [[%% | |
229 | expr: | |
230 | 'a' | |
231 | ||
232 | { | |
233 | ||
234 | } | |
235 | ||
236 | 'b' | |
237 | ||
238 | { | |
239 | ||
240 | } | |
241 | ||
242 | | | |
243 | ||
244 | ||
245 | { | |
246 | ||
247 | ||
248 | } | |
249 | ||
250 | 'c' | |
251 | ||
252 | { | |
253 | ||
bfcf1f3a | 254 | }; |
2ca209c1 | 255 | ]]) |
71c7e24f | 256 | AT_BISON_OPTION_POPDEFS |
2ca209c1 | 257 | |
da730230 | 258 | AT_BISON_CHECK([-o input.c -v input.y]) |
2ca209c1 AD |
259 | |
260 | # Check the contents of the report. | |
261 | AT_CHECK([cat input.output], [], | |
d2d1b42b | 262 | [[Grammar |
2ca209c1 | 263 | |
88bce5a2 | 264 | 0 $accept: expr $end |
6b98e4b5 | 265 | |
f91b1629 | 266 | 1 $@1: /* empty */ |
6b98e4b5 | 267 | |
f91b1629 | 268 | 2 expr: 'a' $@1 'b' |
6b98e4b5 | 269 | |
f91b1629 | 270 | 3 $@2: /* empty */ |
6b98e4b5 | 271 | |
f91b1629 | 272 | 4 expr: $@2 'c' |
2ca209c1 | 273 | |
d2d1b42b | 274 | |
2ca209c1 AD |
275 | Terminals, with rules where they appear |
276 | ||
88bce5a2 | 277 | $end (0) 0 |
2ca209c1 AD |
278 | 'a' (97) 2 |
279 | 'b' (98) 2 | |
280 | 'c' (99) 4 | |
281 | error (256) | |
282 | ||
d2d1b42b | 283 | |
2ca209c1 AD |
284 | Nonterminals, with rules where they appear |
285 | ||
88bce5a2 | 286 | $accept (6) |
b365aa05 AD |
287 | on left: 0 |
288 | expr (7) | |
289 | on left: 2 4, on right: 0 | |
f91b1629 | 290 | $@1 (8) |
2ca209c1 | 291 | on left: 1, on right: 2 |
f91b1629 | 292 | $@2 (9) |
2ca209c1 AD |
293 | on left: 3, on right: 4 |
294 | ||
295 | ||
296 | state 0 | |
297 | ||
88bce5a2 | 298 | 0 $accept: . expr $end |
643a5994 | 299 | |
87675353 | 300 | 'a' shift, and go to state 1 |
2ca209c1 | 301 | |
f91b1629 | 302 | $default reduce using rule 3 ($@2) |
2ca209c1 | 303 | |
87675353 | 304 | expr go to state 2 |
f91b1629 | 305 | $@2 go to state 3 |
2ca209c1 AD |
306 | |
307 | ||
308 | state 1 | |
309 | ||
f91b1629 | 310 | 2 expr: 'a' . $@1 'b' |
2ca209c1 | 311 | |
f91b1629 | 312 | $default reduce using rule 1 ($@1) |
2ca209c1 | 313 | |
f91b1629 | 314 | $@1 go to state 4 |
2ca209c1 AD |
315 | |
316 | ||
317 | state 2 | |
318 | ||
88bce5a2 | 319 | 0 $accept: expr . $end |
2ca209c1 | 320 | |
88bce5a2 | 321 | $end shift, and go to state 5 |
2ca209c1 AD |
322 | |
323 | ||
324 | state 3 | |
325 | ||
f91b1629 | 326 | 4 expr: $@2 . 'c' |
2ca209c1 | 327 | |
87675353 | 328 | 'c' shift, and go to state 6 |
2ca209c1 AD |
329 | |
330 | ||
331 | state 4 | |
332 | ||
f91b1629 | 333 | 2 expr: 'a' $@1 . 'b' |
2ca209c1 | 334 | |
87675353 | 335 | 'b' shift, and go to state 7 |
2ca209c1 AD |
336 | |
337 | ||
338 | state 5 | |
339 | ||
88bce5a2 | 340 | 0 $accept: expr $end . |
2ca209c1 | 341 | |
e8832397 | 342 | $default accept |
2ca209c1 AD |
343 | |
344 | ||
345 | state 6 | |
346 | ||
f91b1629 | 347 | 4 expr: $@2 'c' . |
b365aa05 | 348 | |
87675353 | 349 | $default reduce using rule 4 (expr) |
2ca209c1 AD |
350 | |
351 | ||
352 | state 7 | |
353 | ||
f91b1629 | 354 | 2 expr: 'a' $@1 'b' . |
b365aa05 | 355 | |
87675353 | 356 | $default reduce using rule 2 (expr) |
2ca209c1 AD |
357 | ]]) |
358 | ||
359 | AT_CLEANUP | |
360 | ||
361 | ||
362 | ||
cd5aafcf AD |
363 | ## ---------------------- ## |
364 | ## Mixing %token styles. ## | |
365 | ## ---------------------- ## | |
366 | ||
367 | ||
368 | AT_SETUP([Mixing %token styles]) | |
369 | ||
370 | # Taken from the documentation. | |
371 | AT_DATA([input.y], | |
372 | [[%token <operator> OR "||" | |
373 | %token <operator> LE 134 "<=" | |
374 | %left OR "<=" | |
375 | %% | |
376 | exp: ; | |
377 | %% | |
378 | ]]) | |
379 | ||
da730230 | 380 | AT_BISON_CHECK([-v -o input.c input.y]) |
cd5aafcf | 381 | |
d803322e | 382 | AT_CLEANUP |
cd5aafcf AD |
383 | |
384 | ||
385 | ||
29ae55f1 AD |
386 | ## ---------------- ## |
387 | ## Invalid inputs. ## | |
388 | ## ---------------- ## | |
561f9a30 AD |
389 | |
390 | ||
29ae55f1 | 391 | AT_SETUP([Invalid inputs]) |
561f9a30 AD |
392 | |
393 | AT_DATA([input.y], | |
394 | [[%% | |
395 | ? | |
561f9a30 | 396 | default: 'a' } |
29ae55f1 | 397 | %& |
2dfbfc12 | 398 | %a-does-not-exist |
29ae55f1 | 399 | %- |
e9955c83 | 400 | %{ |
561f9a30 AD |
401 | ]]) |
402 | ||
da730230 | 403 | AT_BISON_CHECK([input.y], [1], [], |
ae93e4e4 JM |
404 | [[input.y:2.1: invalid character: '?' |
405 | input.y:3.14: invalid character: '}' | |
406 | input.y:4.1: invalid character: '%' | |
407 | input.y:4.2: invalid character: '&' | |
408 | input.y:5.1-17: invalid directive: '%a-does-not-exist' | |
409 | input.y:6.1: invalid character: '%' | |
410 | input.y:6.2: invalid character: '-' | |
411 | input.y:7.1-8.0: missing '%}' at end of file | |
47aee066 | 412 | input.y:7.1-8.0: syntax error, unexpected %{...%} |
e0c40012 | 413 | ]]) |
561f9a30 AD |
414 | |
415 | AT_CLEANUP | |
416 | ||
417 | ||
fc01665e PE |
418 | AT_SETUP([Invalid inputs with {}]) |
419 | ||
420 | AT_DATA([input.y], | |
421 | [[ | |
422 | %destructor | |
423 | %initial-action | |
424 | %lex-param | |
425 | %parse-param | |
426 | %printer | |
427 | %union | |
428 | ]]) | |
429 | ||
da730230 | 430 | AT_BISON_CHECK([input.y], [1], [], |
e9071366 | 431 | [[input.y:3.1-15: syntax error, unexpected %initial-action, expecting {...} |
fc01665e PE |
432 | ]]) |
433 | ||
434 | AT_CLEANUP | |
435 | ||
436 | ||
270a173c | 437 | |
b87f8b21 AD |
438 | ## ------------------- ## |
439 | ## Token definitions. ## | |
440 | ## ------------------- ## | |
441 | ||
442 | ||
443 | AT_SETUP([Token definitions]) | |
444 | ||
71c7e24f | 445 | AT_BISON_OPTION_PUSHDEFS |
ae93e4e4 | 446 | # Bison managed, when fed with '%token 'f' "f"' to #define 'f'! |
9501dc6e | 447 | AT_DATA_GRAMMAR([input.y], |
db7c8e9a | 448 | [%{ |
cf806753 | 449 | #include <stdlib.h> |
ca407bdf | 450 | #include <stdio.h> |
55f48c48 AD |
451 | ]AT_YYERROR_DECLARE[ |
452 | ]AT_YYLEX_DECLARE[ | |
db7c8e9a | 453 | %} |
ca407bdf PE |
454 | [%error-verbose |
455 | %token MYEOF 0 "end of file" | |
b87f8b21 | 456 | %token 'a' "a" |
4f136612 PE |
457 | %token B_TOKEN "b" |
458 | %token C_TOKEN 'c' | |
459 | %token 'd' D_TOKEN | |
3d54b576 | 460 | %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!" |
1cfe6375 | 461 | %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!" |
b87f8b21 | 462 | %% |
3d54b576 | 463 | exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"; |
ca407bdf | 464 | %% |
290a8ff2 | 465 | ]AT_YYERROR_DEFINE[ |
087dcd78 | 466 | ]AT_YYLEX_DEFINE([{ SPECIAL }])[ |
ca407bdf PE |
467 | |
468 | int | |
469 | main (void) | |
470 | { | |
471 | return yyparse (); | |
472 | } | |
b87f8b21 | 473 | ]]) |
71c7e24f | 474 | AT_BISON_OPTION_POPDEFS |
b87f8b21 | 475 | |
1cfe6375 JD |
476 | # Checking the warning message guarantees that the trigraph "??!" isn't |
477 | # unnecessarily escaped here even though it would need to be if encoded in a | |
478 | # C-string literal. Also notice that unnecessary escaping, such as "\?", from | |
479 | # the user specification is eliminated. | |
480 | AT_BISON_CHECK([-o input.c input.y], [[0]], [[]], | |
73370a9d VS |
481 | [[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother] |
482 | input.y:22.8-63: warning: symbol "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!" used more than once as a literal string [-Wother] | |
1cfe6375 | 483 | ]]) |
ca407bdf | 484 | AT_COMPILE([input]) |
1cfe6375 JD |
485 | |
486 | # Checking the error message here guarantees that yytname, which does contain | |
487 | # C-string literals, does have the trigraph escaped correctly. Thus, the | |
488 | # symbol name reported by the parser is exactly the same as that reported by | |
489 | # Bison itself. | |
3d54b576 | 490 | AT_DATA([experr], |
1cfe6375 | 491 | [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a |
3d54b576 PE |
492 | ]]) |
493 | AT_PARSER_CHECK([./input], 1, [], [experr]) | |
b87f8b21 AD |
494 | AT_CLEANUP |
495 | ||
496 | ||
497 | ||
eb714592 AD |
498 | ## -------------------- ## |
499 | ## Characters Escapes. ## | |
500 | ## -------------------- ## | |
501 | ||
502 | ||
503 | AT_SETUP([Characters Escapes]) | |
504 | ||
55f48c48 | 505 | AT_BISON_OPTION_PUSHDEFS |
9501dc6e | 506 | AT_DATA_GRAMMAR([input.y], |
eb714592 | 507 | [%{ |
55f48c48 AD |
508 | ]AT_YYERROR_DECLARE_EXTERN[ |
509 | ]AT_YYLEX_DECLARE_EXTERN[ | |
eb714592 | 510 | %} |
6d0ef4ec | 511 | [%% |
eb714592 AD |
512 | exp: |
513 | '\'' "\'" | |
514 | | '\"' "\"" | |
55f48c48 | 515 | | '"' "'" /* Pacify font-lock-mode: ". */ |
eb714592 AD |
516 | ; |
517 | ]]) | |
55f48c48 AD |
518 | |
519 | AT_BISON_OPTION_POPDEFS | |
eb714592 | 520 | |
da730230 | 521 | AT_BISON_CHECK([-o input.c input.y]) |
91ce0b3a | 522 | AT_COMPILE([input.o]) |
eb714592 AD |
523 | AT_CLEANUP |
524 | ||
525 | ||
526 | ||
b9752825 AD |
527 | ## -------------- ## |
528 | ## Web2c Report. ## | |
529 | ## -------------- ## | |
776209d6 AD |
530 | |
531 | # The generation of the reduction was once wrong in Bison, and made it | |
532 | # miss some reductions. In the following test case, the reduction on | |
ae93e4e4 | 533 | # 'undef_id_tok' in state 1 was missing. This is stripped down from |
776209d6 AD |
534 | # the actual web2c.y. |
535 | ||
b9752825 | 536 | AT_SETUP([Web2c Report]) |
776209d6 | 537 | |
6b98e4b5 AD |
538 | AT_KEYWORDS([report]) |
539 | ||
776209d6 | 540 | AT_DATA([input.y], |
e9690142 | 541 | [[%token undef_id_tok const_id_tok |
776209d6 AD |
542 | |
543 | %start CONST_DEC_PART | |
544 | \f | |
545 | %% | |
546 | CONST_DEC_PART: | |
547 | CONST_DEC_LIST | |
548 | ; | |
549 | ||
550 | CONST_DEC_LIST: | |
e9690142 | 551 | CONST_DEC |
776209d6 AD |
552 | | CONST_DEC_LIST CONST_DEC |
553 | ; | |
554 | ||
555 | CONST_DEC: | |
e9690142 | 556 | { } undef_id_tok '=' const_id_tok ';' |
776209d6 AD |
557 | ; |
558 | %% | |
776209d6 AD |
559 | ]]) |
560 | ||
da730230 | 561 | AT_BISON_CHECK([-v input.y]) |
87675353 | 562 | AT_CHECK([cat input.output], 0, |
776209d6 | 563 | [[Grammar |
87675353 | 564 | |
88bce5a2 | 565 | 0 $accept: CONST_DEC_PART $end |
87675353 | 566 | |
6b98e4b5 | 567 | 1 CONST_DEC_PART: CONST_DEC_LIST |
87675353 | 568 | |
6b98e4b5 AD |
569 | 2 CONST_DEC_LIST: CONST_DEC |
570 | 3 | CONST_DEC_LIST CONST_DEC | |
87675353 | 571 | |
f91b1629 | 572 | 4 $@1: /* empty */ |
87675353 | 573 | |
f91b1629 | 574 | 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' |
87675353 AD |
575 | |
576 | ||
776209d6 | 577 | Terminals, with rules where they appear |
87675353 | 578 | |
88bce5a2 | 579 | $end (0) 0 |
776209d6 AD |
580 | ';' (59) 5 |
581 | '=' (61) 5 | |
582 | error (256) | |
007a50a4 AD |
583 | undef_id_tok (258) 5 |
584 | const_id_tok (259) 5 | |
87675353 AD |
585 | |
586 | ||
776209d6 | 587 | Nonterminals, with rules where they appear |
87675353 | 588 | |
88bce5a2 | 589 | $accept (7) |
78d5bae9 AD |
590 | on left: 0 |
591 | CONST_DEC_PART (8) | |
592 | on left: 1, on right: 0 | |
593 | CONST_DEC_LIST (9) | |
776209d6 | 594 | on left: 2 3, on right: 1 3 |
78d5bae9 | 595 | CONST_DEC (10) |
776209d6 | 596 | on left: 5, on right: 2 3 |
f91b1629 | 597 | $@1 (11) |
776209d6 | 598 | on left: 4, on right: 5 |
87675353 AD |
599 | |
600 | ||
776209d6 | 601 | state 0 |
87675353 | 602 | |
88bce5a2 | 603 | 0 $accept: . CONST_DEC_PART $end |
87675353 | 604 | |
f91b1629 | 605 | $default reduce using rule 4 ($@1) |
87675353 AD |
606 | |
607 | CONST_DEC_PART go to state 1 | |
608 | CONST_DEC_LIST go to state 2 | |
609 | CONST_DEC go to state 3 | |
f91b1629 | 610 | $@1 go to state 4 |
87675353 AD |
611 | |
612 | ||
776209d6 | 613 | state 1 |
87675353 | 614 | |
88bce5a2 | 615 | 0 $accept: CONST_DEC_PART . $end |
87675353 | 616 | |
88bce5a2 | 617 | $end shift, and go to state 5 |
87675353 AD |
618 | |
619 | ||
78d5bae9 | 620 | state 2 |
87675353 | 621 | |
ce4ccb4b AD |
622 | 1 CONST_DEC_PART: CONST_DEC_LIST . |
623 | 3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC | |
87675353 | 624 | |
f91b1629 | 625 | undef_id_tok reduce using rule 4 ($@1) |
87675353 AD |
626 | $default reduce using rule 1 (CONST_DEC_PART) |
627 | ||
628 | CONST_DEC go to state 6 | |
f91b1629 | 629 | $@1 go to state 4 |
87675353 AD |
630 | |
631 | ||
78d5bae9 | 632 | state 3 |
87675353 | 633 | |
ce4ccb4b | 634 | 2 CONST_DEC_LIST: CONST_DEC . |
87675353 AD |
635 | |
636 | $default reduce using rule 2 (CONST_DEC_LIST) | |
637 | ||
638 | ||
776209d6 | 639 | state 4 |
87675353 | 640 | |
f91b1629 | 641 | 5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';' |
87675353 AD |
642 | |
643 | undef_id_tok shift, and go to state 7 | |
644 | ||
645 | ||
78d5bae9 | 646 | state 5 |
87675353 | 647 | |
88bce5a2 | 648 | 0 $accept: CONST_DEC_PART $end . |
87675353 | 649 | |
e8832397 | 650 | $default accept |
87675353 AD |
651 | |
652 | ||
78d5bae9 | 653 | state 6 |
87675353 | 654 | |
ce4ccb4b | 655 | 3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC . |
87675353 AD |
656 | |
657 | $default reduce using rule 3 (CONST_DEC_LIST) | |
658 | ||
659 | ||
78d5bae9 | 660 | state 7 |
87675353 | 661 | |
f91b1629 | 662 | 5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';' |
87675353 AD |
663 | |
664 | '=' shift, and go to state 8 | |
665 | ||
666 | ||
78d5bae9 | 667 | state 8 |
87675353 | 668 | |
f91b1629 | 669 | 5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';' |
87675353 AD |
670 | |
671 | const_id_tok shift, and go to state 9 | |
672 | ||
673 | ||
78d5bae9 | 674 | state 9 |
87675353 | 675 | |
f91b1629 | 676 | 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';' |
87675353 AD |
677 | |
678 | ';' shift, and go to state 10 | |
679 | ||
680 | ||
78d5bae9 | 681 | state 10 |
87675353 | 682 | |
f91b1629 | 683 | 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' . |
87675353 AD |
684 | |
685 | $default reduce using rule 5 (CONST_DEC) | |
776209d6 AD |
686 | ]]) |
687 | ||
688 | AT_CLEANUP | |
b9752825 AD |
689 | |
690 | ||
691 | ## --------------- ## | |
692 | ## Web2c Actions. ## | |
693 | ## --------------- ## | |
694 | ||
ae93e4e4 | 695 | # The generation of the mapping 'state -> action' was once wrong in |
b9752825 AD |
696 | # extremely specific situations. web2c.y exhibits this situation. |
697 | # Below is a stripped version of the grammar. It looks like one can | |
698 | # simplify it further, but just don't: it is tuned to exhibit a bug, | |
699 | # which disapears when applying sane grammar transformations. | |
700 | # | |
701 | # It used to be wrong on yydefact only: | |
702 | # | |
d42cf844 | 703 | # static const yytype_uint8 yydefact[] = |
b9752825 AD |
704 | # { |
705 | # - 2, 0, 1, 0, 0, 2, 3, 2, 5, 4, | |
706 | # + 2, 0, 1, 0, 0, 0, 3, 2, 5, 4, | |
707 | # 0, 0 | |
708 | # }; | |
709 | # | |
710 | # but let's check all the tables. | |
711 | ||
712 | ||
713 | AT_SETUP([Web2c Actions]) | |
714 | ||
6b98e4b5 AD |
715 | AT_KEYWORDS([report]) |
716 | ||
b9752825 AD |
717 | AT_DATA([input.y], |
718 | [[%% | |
719 | statement: struct_stat; | |
720 | struct_stat: /* empty. */ | if else; | |
721 | if: "if" "const" "then" statement; | |
722 | else: "else" statement; | |
723 | %% | |
724 | ]]) | |
725 | ||
da730230 | 726 | AT_BISON_CHECK([-v -o input.c input.y]) |
b9752825 | 727 | |
728c4be2 | 728 | # Check only the tables. |
ce4ccb4b AD |
729 | [sed -n 's/ *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c] |
730 | ||
731 | AT_CHECK([[cat tables.c]], 0, | |
d42cf844 | 732 | [[static const yytype_uint8 yytranslate[] = |
b9752825 AD |
733 | { |
734 | 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
735 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
736 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
737 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
738 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
739 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
740 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
741 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
742 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
743 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
744 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
745 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
746 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
747 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
748 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
749 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
750 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
751 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
752 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
753 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
754 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
755 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
756 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
757 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
758 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
007a50a4 AD |
759 | 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, |
760 | 5, 6 | |
b9752825 | 761 | }; |
d42cf844 | 762 | static const yytype_uint8 yyrline[] = |
b9752825 | 763 | { |
e7b8bef1 | 764 | 0, 2, 2, 3, 3, 4, 5 |
b9752825 AD |
765 | }; |
766 | static const char *const yytname[] = | |
767 | { | |
9e0876fb | 768 | "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"", |
ef51bfa7 | 769 | "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL |
b9752825 | 770 | }; |
d42cf844 | 771 | static const yytype_uint16 yytoknum[] = |
b9752825 | 772 | { |
3650b4b8 | 773 | 0, 256, 257, 258, 259, 260, 261 |
b9752825 | 774 | }; |
0991e29b | 775 | static const yytype_int8 yypact[] = |
b9752825 | 776 | { |
0991e29b AD |
777 | -2, -1, 4, -8, 0, 2, -8, -2, -8, -2, |
778 | -8, -8 | |
b9752825 | 779 | }; |
d42cf844 | 780 | static const yytype_uint8 yydefact[] = |
b9752825 | 781 | { |
e8832397 | 782 | 3, 0, 0, 2, 0, 0, 1, 3, 4, 3, |
e7b8bef1 | 783 | 6, 5 |
b9752825 | 784 | }; |
d42cf844 | 785 | static const yytype_int8 yypgoto[] = |
b9752825 | 786 | { |
12b0043a | 787 | -8, -7, -8, -8, -8 |
b9752825 | 788 | }; |
0991e29b AD |
789 | static const yytype_int8 yydefgoto[] = |
790 | { | |
791 | -1, 2, 3, 4, 8 | |
792 | }; | |
d42cf844 | 793 | static const yytype_uint8 yytable[] = |
b9752825 | 794 | { |
e7b8bef1 | 795 | 10, 1, 11, 5, 6, 0, 7, 9 |
b9752825 | 796 | }; |
d42cf844 | 797 | static const yytype_int8 yycheck[] = |
b9752825 | 798 | { |
e7b8bef1 | 799 | 7, 3, 9, 4, 0, -1, 6, 5 |
b9752825 | 800 | }; |
d42cf844 | 801 | static const yytype_uint8 yystos[] = |
5504898e AD |
802 | { |
803 | 0, 3, 8, 9, 10, 4, 0, 6, 11, 5, | |
804 | 8, 8 | |
805 | }; | |
0991e29b AD |
806 | static const yytype_uint8 yyr1[] = |
807 | { | |
808 | 0, 7, 8, 9, 9, 10, 11 | |
809 | }; | |
810 | static const yytype_uint8 yyr2[] = | |
811 | { | |
812 | 0, 2, 1, 0, 2, 4, 2 | |
813 | }; | |
b9752825 AD |
814 | ]]) |
815 | ||
816 | AT_CLEANUP | |
22e304a6 AD |
817 | |
818 | ||
819 | ## ------------------------- ## | |
820 | ## yycheck Bound Violation. ## | |
821 | ## ------------------------- ## | |
822 | ||
823 | ||
824 | # _AT_DATA_DANCER_Y(BISON-OPTIONS) | |
825 | # -------------------------------- | |
826 | # The following grammar, taken from Andrew Suffield's GPL'd implementation | |
827 | # of DGMTP, the Dancer Generic Message Transport Protocol, used to violate | |
828 | # yycheck's bounds where issuing a verbose error message. Keep this test | |
829 | # so that possible bound checking compilers could check all the skeletons. | |
830 | m4_define([_AT_DATA_DANCER_Y], | |
831 | [AT_DATA_GRAMMAR([dancer.y], | |
087dcd78 AD |
832 | [[%code provides |
833 | { | |
834 | ]AT_YYERROR_DECLARE[ | |
835 | ]AT_YYLEX_DECLARE[ | |
836 | } | |
22e304a6 AD |
837 | $1 |
838 | %token ARROW INVALID NUMBER STRING DATA | |
839 | %defines | |
840 | %verbose | |
841 | %error-verbose | |
842 | /* Grammar follows */ | |
843 | %% | |
844 | line: header body | |
845 | ; | |
846 | ||
847 | header: '<' from ARROW to '>' type ':' | |
848 | | '<' ARROW to '>' type ':' | |
849 | | ARROW to type ':' | |
850 | | type ':' | |
851 | | '<' '>' | |
852 | ; | |
853 | ||
854 | from: DATA | |
855 | | STRING | |
856 | | INVALID | |
857 | ; | |
858 | ||
859 | to: DATA | |
860 | | STRING | |
861 | | INVALID | |
862 | ; | |
863 | ||
864 | type: DATA | |
865 | | STRING | |
866 | | INVALID | |
867 | ; | |
868 | ||
869 | body: /* empty */ | |
870 | | body member | |
871 | ; | |
872 | ||
873 | member: STRING | |
874 | | DATA | |
875 | | '+' NUMBER | |
876 | | '-' NUMBER | |
877 | | NUMBER | |
878 | | INVALID | |
879 | ; | |
880 | %% | |
087dcd78 AD |
881 | ]AT_YYERROR_DEFINE[ |
882 | ]AT_YYLEX_DEFINE([":"])[ | |
290a8ff2 AD |
883 | ]AT_LALR1_CC_IF( |
884 | [int | |
99880de5 | 885 | yyparse () |
22e304a6 | 886 | { |
99880de5 | 887 | yy::parser parser; |
fa7b79c0 PE |
888 | #if YYDEBUG |
889 | parser.set_debug_level (YYDEBUG); | |
890 | #endif | |
22e304a6 AD |
891 | return parser.parse (); |
892 | } | |
087dcd78 | 893 | ])[ |
22e304a6 AD |
894 | |
895 | int | |
896 | main (void) | |
897 | { | |
898 | return yyparse (); | |
899 | } | |
087dcd78 | 900 | ]]) |
22e304a6 AD |
901 | ])# _AT_DATA_DANCER_Y |
902 | ||
903 | ||
904 | # AT_CHECK_DANCER(BISON-OPTIONS) | |
905 | # ------------------------------ | |
906 | # Generate the grammar, compile it, run it. | |
907 | m4_define([AT_CHECK_DANCER], | |
908 | [AT_SETUP([Dancer $1]) | |
909 | AT_BISON_OPTION_PUSHDEFS([$1]) | |
910 | _AT_DATA_DANCER_Y([$1]) | |
da730230 | 911 | AT_BISON_CHECK([-o dancer.c dancer.y]) |
7ca2266a | 912 | AT_FULL_COMPILE([dancer]) |
22e304a6 | 913 | AT_PARSER_CHECK([./dancer], 1, [], |
d5286af1 | 914 | [syntax error, unexpected ':' |
22e304a6 AD |
915 | ]) |
916 | AT_BISON_OPTION_POPDEFS | |
917 | AT_CLEANUP | |
918 | ]) | |
919 | ||
920 | AT_CHECK_DANCER() | |
921 | AT_CHECK_DANCER([%glr-parser]) | |
922 | AT_CHECK_DANCER([%skeleton "lalr1.cc"]) | |
d6645148 PE |
923 | |
924 | ||
925 | ## ------------------------------------------ ## | |
926 | ## Diagnostic that expects two alternatives. ## | |
927 | ## ------------------------------------------ ## | |
928 | ||
929 | ||
930 | # _AT_DATA_EXPECT2_Y(BISON-OPTIONS) | |
931 | # -------------------------------- | |
932 | m4_define([_AT_DATA_EXPECT2_Y], | |
933 | [AT_DATA_GRAMMAR([expect2.y], | |
934 | [%{ | |
935 | static int yylex (AT_LALR1_CC_IF([int *], [void])); | |
e436fa67 AD |
936 | AT_LALR1_CC_IF([[#include <cstdlib>]], |
937 | [[#include <stdlib.h> | |
938 | #include <stdio.h> | |
71c7e24f | 939 | ]AT_YYERROR_DECLARE])[ |
d6645148 PE |
940 | %} |
941 | $1 | |
942 | %defines | |
943 | %error-verbose | |
944 | %token A 1000 | |
945 | %token B | |
946 | ||
947 | %% | |
948 | program: /* empty */ | |
949 | | program e ';' | |
950 | | program error ';'; | |
951 | ||
952 | e: e '+' t | t; | |
953 | t: A | B; | |
954 | ||
955 | %% | |
71c7e24f AD |
956 | ]AT_YYERROR_DEFINE[ |
957 | ]AT_LALR1_CC_IF( | |
958 | [int | |
d6645148 PE |
959 | yyparse () |
960 | { | |
961 | yy::parser parser; | |
962 | return parser.parse (); | |
963 | } | |
71c7e24f | 964 | ])[ |
d6645148 | 965 | |
77519a7d | 966 | #include <assert.h> |
d6645148 | 967 | static int |
71c7e24f AD |
968 | yylex (]AT_LALR1_CC_IF([int *lval], [void])[) |
969 | { | |
cf806753 | 970 | static int const tokens[] = |
d6645148 PE |
971 | { |
972 | 1000, '+', '+', -1 | |
973 | }; | |
cf806753 | 974 | static size_t toknum; |
d6645148 | 975 | ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[ |
77519a7d | 976 | assert (toknum < sizeof tokens / sizeof *tokens); |
d6645148 | 977 | return tokens[toknum++]; |
71c7e24f | 978 | } |
d6645148 PE |
979 | |
980 | int | |
981 | main (void) | |
982 | { | |
983 | return yyparse (); | |
984 | } | |
71c7e24f | 985 | ]]) |
d6645148 PE |
986 | ])# _AT_DATA_EXPECT2_Y |
987 | ||
988 | ||
989 | # AT_CHECK_EXPECT2(BISON-OPTIONS) | |
71c7e24f | 990 | # ------------------------------- |
d6645148 PE |
991 | # Generate the grammar, compile it, run it. |
992 | m4_define([AT_CHECK_EXPECT2], | |
993 | [AT_SETUP([Expecting two tokens $1]) | |
994 | AT_BISON_OPTION_PUSHDEFS([$1]) | |
995 | _AT_DATA_EXPECT2_Y([$1]) | |
da730230 | 996 | AT_BISON_CHECK([-o expect2.c expect2.y]) |
7ca2266a | 997 | AT_FULL_COMPILE([expect2]) |
d6645148 PE |
998 | AT_PARSER_CHECK([./expect2], 1, [], |
999 | [syntax error, unexpected '+', expecting A or B | |
1000 | ]) | |
1001 | AT_BISON_OPTION_POPDEFS | |
1002 | AT_CLEANUP | |
1003 | ]) | |
1004 | ||
1005 | AT_CHECK_EXPECT2() | |
1006 | AT_CHECK_EXPECT2([%glr-parser]) | |
1007 | AT_CHECK_EXPECT2([%skeleton "lalr1.cc"]) | |
4210cd0b JD |
1008 | |
1009 | ||
1010 | ||
1011 | ## --------------------------------------------- ## | |
1012 | ## Braced code in declaration in rules section. ## | |
1013 | ## --------------------------------------------- ## | |
1014 | ||
1015 | AT_SETUP([Braced code in declaration in rules section]) | |
1016 | ||
1017 | # Bison once mistook braced code in a declaration in the rules section to be a | |
1018 | # rule action. | |
55f48c48 | 1019 | AT_BISON_OPTION_PUSHDEFS |
4210cd0b JD |
1020 | AT_DATA_GRAMMAR([input.y], |
1021 | [[%{ | |
1022 | #include <stdio.h> | |
55f48c48 AD |
1023 | ]AT_YYERROR_DECLARE[ |
1024 | ]AT_YYLEX_DECLARE[ | |
4210cd0b JD |
1025 | %} |
1026 | ||
1027 | %error-verbose | |
1028 | ||
1029 | %% | |
1030 | ||
1031 | start: | |
1032 | { | |
1033 | printf ("Bison would once convert this action to a midrule because of the" | |
e9690142 | 1034 | " subsequent braced code.\n"); |
4210cd0b JD |
1035 | } |
1036 | ; | |
1037 | ||
1038 | %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a'; | |
1039 | %printer { fprintf (yyoutput, "PRINTER"); } 'a'; | |
1040 | ||
1041 | %% | |
55f48c48 | 1042 | ]AT_YYERROR_DEFINE[ |
087dcd78 | 1043 | ]AT_YYLEX_DEFINE(["a"])[ |
4210cd0b JD |
1044 | |
1045 | int | |
1046 | main (void) | |
1047 | { | |
1048 | yydebug = 1; | |
1049 | return !yyparse (); | |
1050 | } | |
1051 | ]]) | |
55f48c48 | 1052 | AT_BISON_OPTION_POPDEFS |
4210cd0b | 1053 | |
da730230 | 1054 | AT_BISON_CHECK([-t -o input.c input.y]) |
4210cd0b JD |
1055 | AT_COMPILE([input]) |
1056 | AT_PARSER_CHECK([./input], 0, | |
1057 | [[Bison would once convert this action to a midrule because of the subsequent braced code. | |
1058 | ]], | |
1059 | [[Starting parse | |
1060 | Entering state 0 | |
231ed89a | 1061 | Reducing stack by rule 1 (line 20): |
4210cd0b JD |
1062 | -> $$ = nterm start () |
1063 | Stack now 0 | |
1064 | Entering state 1 | |
1065 | Reading a token: Next token is token 'a' (PRINTER) | |
1066 | syntax error, unexpected 'a', expecting $end | |
1067 | Error: popping nterm start () | |
1068 | Stack now 0 | |
1069 | Cleanup: discarding lookahead token 'a' (PRINTER) | |
1070 | DESTRUCTOR | |
1071 | Stack now 0 | |
1072 | ]]) | |
1073 | ||
1074 | AT_CLEANUP | |
965537bc JD |
1075 | |
1076 | ||
1077 | ||
1078 | ## --------------------------------- ## | |
1079 | ## String alias declared after use. ## | |
1080 | ## --------------------------------- ## | |
1081 | ||
1082 | AT_SETUP([String alias declared after use]) | |
1083 | ||
1084 | # Bison once incorrectly asserted that the symbol number for either a token or | |
1085 | # its alias was the highest symbol number so far at the point of the alias | |
1086 | # declaration. That was true unless the declaration appeared after their first | |
6d0ef4ec | 1087 | # uses and other tokens appeared in between. |
965537bc JD |
1088 | |
1089 | AT_DATA([input.y], | |
1090 | [[%% | |
1091 | start: 'a' "A" 'b'; | |
1092 | %token 'a' "A"; | |
1093 | ]]) | |
1094 | ||
da730230 | 1095 | AT_BISON_CHECK([-t -o input.c input.y]) |
965537bc JD |
1096 | |
1097 | AT_CLEANUP | |
a0de5091 JD |
1098 | |
1099 | ||
1100 | ||
1101 | ## -------------------------------- ## | |
1102 | ## Extra lookahead sets in report. ## | |
1103 | ## -------------------------------- ## | |
1104 | ||
1105 | AT_SETUP([[Extra lookahead sets in report]]) | |
1106 | ||
88c78747 JD |
1107 | # Bison prints each reduction's lookahead set only next to the associated |
1108 | # state's one item that (1) is associated with the same rule as the reduction | |
1109 | # and (2) has its dot at the end of its RHS. Previously, Bison also | |
1110 | # erroneously printed the lookahead set next to all of the state's other items | |
ae93e4e4 | 1111 | # associated with the same rule. This bug affected only the '.output' file and |
88c78747 | 1112 | # not the generated parser source code. |
a0de5091 JD |
1113 | |
1114 | AT_DATA([[input.y]], | |
1115 | [[%% | |
1116 | start: a | 'a' a 'a' ; | |
1117 | a: 'a' ; | |
1118 | ]]) | |
1119 | ||
da730230 | 1120 | AT_BISON_CHECK([[--report=all input.y]]) |
a0de5091 JD |
1121 | AT_CHECK([[sed -n '/^state 1$/,/^state 2$/p' input.output]], [[0]], |
1122 | [[state 1 | |
1123 | ||
1124 | 2 start: 'a' . a 'a' | |
1125 | 3 a: . 'a' | |
1126 | 3 | 'a' . [$end] | |
1127 | ||
1128 | 'a' shift, and go to state 4 | |
1129 | ||
1130 | $default reduce using rule 3 (a) | |
1131 | ||
1132 | a go to state 5 | |
1133 | ||
1134 | ||
1135 | state 2 | |
1136 | ]]) | |
1137 | ||
1138 | AT_CLEANUP | |
ab7f29f8 JD |
1139 | |
1140 | ||
1141 | ||
1142 | ## ---------------------------------------- ## | |
1143 | ## Token number in precedence declaration. ## | |
1144 | ## ---------------------------------------- ## | |
1145 | ||
58bd33b7 | 1146 | AT_SETUP([[Token number in precedence declaration]]) |
ab7f29f8 JD |
1147 | |
1148 | # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but | |
1149 | # we lost this in Bison 1.50. | |
55f48c48 | 1150 | AT_BISON_OPTION_PUSHDEFS |
ab7f29f8 JD |
1151 | AT_DATA_GRAMMAR([input.y], |
1152 | [[%{ | |
1153 | #include <stdio.h> | |
55f48c48 AD |
1154 | ]AT_YYERROR_DECLARE[ |
1155 | ]AT_YYLEX_DECLARE[ | |
ab7f29f8 JD |
1156 | %} |
1157 | ||
1158 | %error-verbose | |
1f36f544 | 1159 | %right END 0 |
ab7f29f8 JD |
1160 | %left TK1 1 TK2 2 "tok alias" 3 |
1161 | ||
1162 | %% | |
1163 | ||
1f36f544 JD |
1164 | start: |
1165 | TK1 sr_conflict "tok alias" | |
1166 | | start %prec END | |
1167 | ; | |
ab7f29f8 JD |
1168 | sr_conflict: |
1169 | TK2 | |
1170 | | TK2 "tok alias" | |
1171 | ; | |
1172 | ||
1173 | %% | |
1174 | ||
55f48c48 | 1175 | ]AT_YYERROR_DEFINE[ |
087dcd78 | 1176 | ]AT_YYLEX_DEFINE([{ 1, 2, 3, 0 }])[ |
ab7f29f8 JD |
1177 | |
1178 | int | |
1179 | main (void) | |
1180 | { | |
1181 | return yyparse (); | |
1182 | } | |
1183 | ]]) | |
55f48c48 | 1184 | AT_BISON_OPTION_POPDEFS |
ab7f29f8 JD |
1185 | |
1186 | AT_BISON_CHECK([[-o input.c input.y]], [[0]],, | |
73370a9d VS |
1187 | [[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start [-Wother] |
1188 | input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias" [-Wother] | |
ab7f29f8 JD |
1189 | ]]) |
1190 | AT_COMPILE([[input]]) | |
1191 | AT_PARSER_CHECK([[./input]]) | |
1192 | ||
1193 | AT_CLEANUP | |
43aabb70 JD |
1194 | |
1195 | ||
1196 | ||
1197 | ## --------------------------- ## | |
1198 | ## parse-gram.y: LALR = IELR. ## | |
1199 | ## --------------------------- ## | |
1200 | ||
1201 | # If parse-gram.y's LALR and IELR parser tables ever begin to differ, we | |
1202 | # need to fix parse-gram.y or start using IELR. | |
1203 | ||
1204 | AT_SETUP([[parse-gram.y: LALR = IELR]]) | |
1205 | ||
1206 | # Avoid tests/bison's dark magic by processing a local copy of the | |
1207 | # grammar. Avoid differences in synclines by telling bison that the | |
1208 | # output files have the same name. | |
d8f68fc2 JD |
1209 | [cp $abs_top_srcdir/src/parse-gram.y input.y] |
1210 | AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]]) | |
035810ed AD |
1211 | [mv input.c lalr.c] |
1212 | AT_CAPTURE_FILE([lalr.c]) | |
d8f68fc2 JD |
1213 | AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]]) |
1214 | [mv input.c ielr.c] | |
035810ed AD |
1215 | AT_CAPTURE_FILE([ielr.c]) |
1216 | AT_CHECK([[diff lalr.c ielr.c]], [[0]]) | |
43aabb70 JD |
1217 | |
1218 | AT_CLEANUP | |
52cea04a JD |
1219 | |
1220 | ||
1221 | ||
1222 | ## -------------------------------------------- ## | |
1223 | ## parse.error=verbose and YYSTACK_USE_ALLOCA. ## | |
1224 | ## -------------------------------------------- ## | |
1225 | ||
1226 | AT_SETUP([[parse.error=verbose and YYSTACK_USE_ALLOCA]]) | |
1227 | ||
55f48c48 | 1228 | AT_BISON_OPTION_PUSHDEFS |
52cea04a JD |
1229 | AT_DATA_GRAMMAR([input.y], |
1230 | [[%code { | |
1231 | #include <stdio.h> | |
55f48c48 AD |
1232 | ]AT_YYERROR_DECLARE[ |
1233 | ]AT_YYLEX_DECLARE[ | |
52cea04a JD |
1234 | #define YYSTACK_USE_ALLOCA 1 |
1235 | } | |
1236 | ||
1237 | %define parse.error verbose | |
1238 | ||
1239 | %% | |
1240 | ||
1241 | start: check syntax_error syntax_error ; | |
1242 | ||
1243 | check: | |
1244 | { | |
1245 | if (128 < sizeof yymsgbuf) | |
1246 | { | |
1247 | fprintf (stderr, | |
1248 | "The initial size of yymsgbuf in yyparse has increased\n" | |
1249 | "since this test group was last updated. As a result,\n" | |
1250 | "this test group may no longer manage to induce a\n" | |
1251 | "reallocation of the syntax error message buffer.\n" | |
1252 | "This test group must be adjusted to produce a longer\n" | |
1253 | "error message.\n"); | |
1254 | YYABORT; | |
1255 | } | |
1256 | } | |
1257 | ; | |
1258 | ||
1259 | // Induce a syntax error message whose total length is more than | |
1260 | // sizeof yymsgbuf in yyparse. Each token here is 64 bytes. | |
1261 | syntax_error: | |
1262 | "123456789112345678921234567893123456789412345678951234567896123A" | |
1263 | | "123456789112345678921234567893123456789412345678951234567896123B" | |
1264 | | error 'a' 'b' 'c' | |
1265 | ; | |
1266 | ||
1267 | %% | |
1268 | ||
55f48c48 | 1269 | ]AT_YYERROR_DEFINE[ |
52cea04a JD |
1270 | /* Induce two syntax error messages (which requires full error |
1271 | recovery by shifting 3 tokens) in order to detect any loss of the | |
1272 | reallocated buffer. */ | |
95361618 | 1273 | ]AT_YYLEX_DEFINE(["abc"])[ |
52cea04a JD |
1274 | int |
1275 | main (void) | |
1276 | { | |
1277 | return yyparse (); | |
1278 | } | |
1279 | ]]) | |
55f48c48 | 1280 | AT_BISON_OPTION_POPDEFS |
52cea04a JD |
1281 | |
1282 | AT_BISON_CHECK([[-o input.c input.y]]) | |
1283 | AT_COMPILE([[input]]) | |
1284 | AT_PARSER_CHECK([[./input]], [[1]], [], | |
1285 | [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B | |
1286 | syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B | |
1287 | ]]) | |
1288 | ||
1289 | AT_CLEANUP | |
1290 | ||
1291 | ||
1292 | ||
1293 | ## ------------------------------ ## | |
1294 | ## parse.error=verbose overflow. ## | |
1295 | ## ------------------------------ ## | |
1296 | ||
1297 | # Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an | |
1298 | # invocation of yysyntax_error has caused yymsg_alloc to grow to exactly | |
1299 | # YYSTACK_ALLOC_MAXIMUM (perhaps because the normal doubling of size had | |
45319f13 JD |
1300 | # to be clipped to YYSTACK_ALLOC_MAXIMUM). In an old version of yacc.c, |
1301 | # a subsequent invocation of yysyntax_error that overflows during its | |
1302 | # size calculation would return YYSIZE_MAXIMUM to yyparse. Then, | |
1303 | # yyparse would invoke yyerror using the old contents of yymsg. | |
52cea04a JD |
1304 | |
1305 | AT_SETUP([[parse.error=verbose overflow]]) | |
1306 | ||
55f48c48 | 1307 | AT_BISON_OPTION_PUSHDEFS |
52cea04a JD |
1308 | AT_DATA_GRAMMAR([input.y], |
1309 | [[%code { | |
1310 | #include <stdio.h> | |
55f48c48 AD |
1311 | ]AT_YYERROR_DECLARE[ |
1312 | ]AT_YYLEX_DECLARE[ | |
52cea04a JD |
1313 | |
1314 | /* This prevents this test case from having to induce error messages | |
1315 | large enough to overflow size_t. */ | |
1316 | #define YYSIZE_T unsigned char | |
1317 | ||
8ff146cd | 1318 | /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to |
d6b347e4 | 1319 | provide a malloc prototype using our YYSIZE_T. */ |
52cea04a | 1320 | #include <stdlib.h> |
8ff146cd PE |
1321 | #ifndef EXIT_SUCCESS |
1322 | # define EXIT_SUCCESS 0 | |
d6b347e4 | 1323 | #endif |
52cea04a JD |
1324 | |
1325 | /* Max depth is usually much smaller than YYSTACK_ALLOC_MAXIMUM, and | |
1326 | we don't want gcc to warn everywhere this constant would be too big | |
1327 | to make sense for our YYSIZE_T. */ | |
1328 | #define YYMAXDEPTH 100 | |
1329 | } | |
1330 | ||
1331 | %define parse.error verbose | |
1332 | ||
1333 | %% | |
1334 | ||
1335 | start: syntax_error1 check syntax_error2 ; | |
1336 | ||
1337 | // Induce a syntax error message whose total length causes yymsg in | |
1338 | // yyparse to be reallocated to size YYSTACK_ALLOC_MAXIMUM, which | |
1339 | // should be 255. Each token here is 64 bytes. | |
1340 | syntax_error1: | |
1341 | "123456789112345678921234567893123456789412345678951234567896123A" | |
1342 | | "123456789112345678921234567893123456789412345678951234567896123B" | |
1343 | | "123456789112345678921234567893123456789412345678951234567896123C" | |
1344 | | error 'a' 'b' 'c' | |
1345 | ; | |
1346 | ||
1347 | check: | |
1348 | { | |
1349 | if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM | |
1350 | || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM | |
1351 | || YYSIZE_MAXIMUM != 255) | |
1352 | { | |
1353 | fprintf (stderr, | |
1354 | "The assumptions of this test group are no longer\n" | |
1355 | "valid, so it may no longer catch the error it was\n" | |
1356 | "designed to catch. Specifically, the following\n" | |
1357 | "values should all be 255:\n\n"); | |
1358 | fprintf (stderr, " yymsg_alloc = %d\n", yymsg_alloc); | |
1359 | fprintf (stderr, " YYSTACK_ALLOC_MAXIMUM = %d\n", | |
1360 | YYSTACK_ALLOC_MAXIMUM); | |
1361 | fprintf (stderr, " YYSIZE_MAXIMUM = %d\n", YYSIZE_MAXIMUM); | |
1362 | YYABORT; | |
1363 | } | |
1364 | } | |
1365 | ; | |
1366 | ||
1367 | // Now overflow. | |
1368 | syntax_error2: | |
1369 | "123456789112345678921234567893123456789412345678951234567896123A" | |
1370 | | "123456789112345678921234567893123456789412345678951234567896123B" | |
1371 | | "123456789112345678921234567893123456789412345678951234567896123C" | |
1372 | | "123456789112345678921234567893123456789412345678951234567896123D" | |
1373 | | "123456789112345678921234567893123456789412345678951234567896123E" | |
1374 | ; | |
1375 | ||
1376 | %% | |
1377 | ||
55f48c48 | 1378 | ]AT_YYERROR_DEFINE[ |
52cea04a JD |
1379 | /* Induce two syntax error messages (which requires full error |
1380 | recovery by shifting 3 tokens). */ | |
95361618 | 1381 | ]AT_YYLEX_DEFINE(["abc"])[ |
52cea04a JD |
1382 | int |
1383 | main (void) | |
1384 | { | |
1385 | /* Push parsers throw away the message buffer between tokens, so skip | |
1386 | this test under maintainer-push-check. */ | |
1387 | if (YYPUSH) | |
1388 | return 77; | |
1389 | return yyparse (); | |
1390 | } | |
1391 | ]]) | |
1392 | ||
1393 | AT_BISON_CHECK([[-o input.c input.y]]) | |
1394 | ||
1395 | # gcc warns about tautologies and fallacies involving comparisons for | |
1396 | # unsigned char. However, it doesn't produce these same warnings for | |
1397 | # size_t and many other types when the warnings would seem to make just | |
1398 | # as much sense. We ignore the warnings. | |
1399 | [CFLAGS="$NO_WERROR_CFLAGS"] | |
1400 | AT_COMPILE([[input]]) | |
1401 | ||
1402 | AT_PARSER_CHECK([[./input]], [[2]], [], | |
1403 | [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C | |
1404 | syntax error | |
1405 | memory exhausted | |
1406 | ]]) | |
55f48c48 | 1407 | AT_BISON_OPTION_POPDEFS |
52cea04a | 1408 | AT_CLEANUP |
bf35c71c JD |
1409 | |
1410 | ||
1411 | ||
1412 | ## ------------------------ ## | |
1413 | ## LAC: Exploratory stack. ## | |
1414 | ## ------------------------ ## | |
1415 | ||
1416 | AT_SETUP([[LAC: Exploratory stack]]) | |
1417 | ||
1418 | m4_pushdef([AT_LAC_CHECK], [ | |
1419 | ||
1420 | AT_BISON_OPTION_PUSHDEFS([$1]) | |
1421 | ||
1422 | AT_DATA_GRAMMAR([input.y], | |
1423 | [[%code { | |
1424 | #include <stdio.h> | |
55f48c48 | 1425 | ]AT_YYERROR_DECLARE[ |
bf35c71c JD |
1426 | int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[); |
1427 | } | |
1428 | ||
1429 | ]$1[ | |
1430 | %define parse.error verbose | |
1431 | %token 'c' | |
1432 | ||
1433 | %% | |
1434 | ||
1435 | // default reductions in inconsistent states | |
1436 | // v v v v v v v v v v v v v v | |
1437 | S: A B A A B A A A A B A A A A A A A B C C A A A A A A A A A A A A B ; | |
107844a3 JD |
1438 | // ^ ^ ^ |
1439 | // LAC reallocs | |
bf35c71c JD |
1440 | |
1441 | A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ; | |
1442 | B: 'b' ; | |
1443 | C: /*empty*/ { printf ("consistent default reduction\n"); } ; | |
1444 | ||
1445 | %% | |
55f48c48 | 1446 | ]AT_YYERROR_DEFINE[ |
bf35c71c JD |
1447 | int |
1448 | yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[) | |
1449 | { | |
1450 | static char const *input = "bbbbc";]AT_PURE_IF([[ | |
1451 | *v = 0;]])[ | |
1452 | return *input++; | |
1453 | } | |
1454 | ||
1455 | int | |
1456 | main (void) | |
1457 | { | |
1458 | yydebug = 1; | |
1459 | return yyparse (); | |
1460 | } | |
1461 | ]]) | |
1462 | ||
107844a3 JD |
1463 | AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \ |
1464 | -Dparse.lac.memory-trace=full \ | |
bf35c71c JD |
1465 | -t -o input.c input.y]], [[0]], [], |
1466 | [[input.y: conflicts: 21 shift/reduce | |
1467 | ]]) | |
1468 | AT_COMPILE([[input]]) | |
1469 | AT_PARSER_CHECK([[./input > stdout.txt 2> stderr.txt]], [[1]]) | |
1470 | ||
1471 | # Make sure syntax error doesn't forget that 'a' is expected. It would | |
1472 | # be forgotten without lookahead correction. | |
1473 | AT_CHECK([[grep 'syntax error,' stderr.txt]], [[0]], | |
1474 | [[syntax error, unexpected 'c', expecting 'a' or 'b' | |
1475 | ]]) | |
1476 | ||
1477 | # Check number of default reductions in inconsistent states to be sure | |
1478 | # syntax error is detected before unnecessary reductions are performed. | |
1479 | AT_CHECK([[perl -0777 -ne 'print s/inconsistent default reduction//g;' \ | |
1480 | < stdout.txt || exit 77]], [[0]], [[14]]) | |
1481 | ||
1482 | # Check number of default reductions in consistent states to be sure | |
1483 | # it is performed before the syntax error is detected. | |
1484 | AT_CHECK([[perl -0777 -ne 'print s/\bconsistent default reduction//g;' \ | |
1485 | < stdout.txt || exit 77]], [[0]], [[2]]) | |
1486 | ||
107844a3 JD |
1487 | # Check number of reallocs to be sure reallocated memory isn't somehow |
1488 | # lost between LAC invocations. | |
1489 | AT_CHECK([[perl -0777 -ne 'print s/\(realloc//g;' < stderr.txt \ | |
1490 | || exit 77]], [[0]], [[3]]) | |
1491 | ||
bf35c71c JD |
1492 | AT_BISON_OPTION_POPDEFS |
1493 | ]) | |
1494 | ||
1495 | AT_LAC_CHECK([[%define api.push-pull pull]]) | |
1496 | AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]]) | |
1497 | AT_LAC_CHECK([[%define api.push-pull both]]) | |
1498 | AT_LAC_CHECK([[%define api.push-pull both %define api.pure]]) | |
1499 | ||
1500 | m4_popdef([AT_LAC_CHECK]) | |
1501 | ||
1502 | AT_CLEANUP | |
1503 | ||
1504 | ||
1505 | ||
1506 | ## ------------------------ ## | |
1507 | ## LAC: Memory exhaustion. ## | |
1508 | ## ------------------------ ## | |
1509 | ||
1510 | AT_SETUP([[LAC: Memory exhaustion]]) | |
1511 | ||
55f48c48 AD |
1512 | m4_pushdef([AT_LAC_CHECK], |
1513 | [AT_BISON_OPTION_PUSHDEFS | |
bf35c71c JD |
1514 | AT_DATA_GRAMMAR([input.y], |
1515 | [[%code { | |
1516 | #include <stdio.h> | |
55f48c48 AD |
1517 | ]AT_YYERROR_DECLARE[ |
1518 | ]AT_YYLEX_DECLARE[ | |
107844a3 | 1519 | #define YYMAXDEPTH 8 |
bf35c71c JD |
1520 | } |
1521 | ||
1522 | %error-verbose | |
1523 | ||
1524 | %% | |
1525 | ||
1526 | S: A A A A A A A A A ; | |
1527 | A: /*empty*/ | 'a' ; | |
1528 | ||
1529 | %% | |
55f48c48 | 1530 | ]AT_YYERROR_DEFINE[ |
95361618 | 1531 | ]AT_YYLEX_DEFINE(["$1"])[ |
bf35c71c JD |
1532 | int |
1533 | main (void) | |
1534 | { | |
1535 | yydebug = 1; | |
1536 | return yyparse (); | |
1537 | } | |
1538 | ]]) | |
1539 | ||
107844a3 | 1540 | AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \ |
bf35c71c JD |
1541 | -t -o input.c input.y]], [[0]], [], |
1542 | [[input.y: conflicts: 8 shift/reduce | |
1543 | ]]) | |
1544 | AT_COMPILE([[input]]) | |
55f48c48 | 1545 | AT_BISON_OPTION_POPDEFS |
bf35c71c JD |
1546 | ]) |
1547 | ||
1548 | # Check for memory exhaustion during parsing. | |
55f48c48 AD |
1549 | AT_LAC_CHECK([]) |
1550 | AT_PARSER_CHECK([[./input]], [[2]], [], | |
bf35c71c JD |
1551 | [[Starting parse |
1552 | Entering state 0 | |
1553 | Reading a token: Now at end of input. | |
1554 | LAC: initial context established for $end | |
107844a3 | 1555 | LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded) |
bf35c71c JD |
1556 | memory exhausted |
1557 | Cleanup: discarding lookahead token $end () | |
1558 | Stack now 0 | |
1559 | ]]) | |
1560 | ||
1561 | # Induce an immediate syntax error with an undefined token, and check | |
1562 | # for memory exhaustion while building syntax error message. | |
55f48c48 AD |
1563 | AT_LAC_CHECK([z], [[0]]) |
1564 | AT_PARSER_CHECK([[./input]], [[2]], [], | |
bf35c71c JD |
1565 | [[Starting parse |
1566 | Entering state 0 | |
1567 | Reading a token: Next token is token $undefined () | |
1568 | LAC: initial context established for $undefined | |
1569 | LAC: checking lookahead $undefined: Always Err | |
1570 | Constructing syntax error message | |
107844a3 | 1571 | LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded) |
bf35c71c JD |
1572 | syntax error |
1573 | memory exhausted | |
1574 | Cleanup: discarding lookahead token $undefined () | |
1575 | Stack now 0 | |
1576 | ]]) | |
1577 | ||
1578 | m4_popdef([AT_LAC_CHECK]) | |
1579 | ||
1580 | AT_CLEANUP |