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