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