]> git.saurik.com Git - bison.git/blame_incremental - tests/regression.at
maint: minor fixes
[bison.git] / tests / regression.at
... / ...
CommitLineData
1# Bison Regressions. -*- Autotest -*-
2
3# Copyright (C) 2001-2012 Free Software Foundation, Inc.
4
5# This program is free software: you can redistribute it and/or modify
6# it under the terms of the GNU General Public License as published by
7# the Free Software Foundation, either version 3 of the License, or
8# (at your option) any later version.
9#
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.
14#
15# You should have received a copy of the GNU General Public License
16# along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18AT_BANNER([[Regression tests.]])
19
20
21## ------------------ ##
22## Trivial grammars. ##
23## ------------------ ##
24
25AT_SETUP([Trivial grammars])
26
27AT_BISON_OPTION_PUSHDEFS
28AT_DATA_GRAMMAR([input.y],
29[[%{
30]AT_YYERROR_DECLARE_EXTERN[
31]AT_YYLEX_DECLARE_EXTERN[
32#define YYSTYPE int *
33%}
34
35%error-verbose
36
37%%
38
39program: 'x';
40]])
41AT_BISON_OPTION_POPDEFS
42
43AT_BISON_CHECK([-o input.c input.y])
44AT_COMPILE([input.o])
45AT_COMPILE([input.o], [-DYYDEBUG -c input.c])
46
47AT_CLEANUP
48
49
50
51## ----------------- ##
52## YYSTYPE typedef. ##
53## ----------------- ##
54
55AT_SETUP([YYSTYPE typedef])
56
57AT_BISON_OPTION_PUSHDEFS
58AT_DATA_GRAMMAR([input.y],
59[[%{
60]AT_YYERROR_DECLARE_EXTERN[
61]AT_YYLEX_DECLARE_EXTERN[
62typedef union { char const *val; } YYSTYPE;
63%}
64
65%type <val> program
66
67%%
68
69program: { $$ = ""; };
70]])
71AT_BISON_OPTION_POPDEFS
72
73AT_BISON_CHECK([-o input.c input.y])
74AT_COMPILE([input.o])
75
76AT_CLEANUP
77
78
79
80## ------------------------------------- ##
81## Early token definitions with --yacc. ##
82## ------------------------------------- ##
83
84
85AT_SETUP([Early token definitions with --yacc])
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
90AT_BISON_OPTION_PUSHDEFS
91AT_DATA_GRAMMAR([input.y],
92[[%{
93]AT_YYERROR_DECLARE_EXTERN[
94]AT_YYLEX_DECLARE_EXTERN[
95%}
96
97%union
98{
99 int val;
100};
101%{
102#ifndef MY_TOKEN
103# error "MY_TOKEN not defined."
104#endif
105%}
106%token MY_TOKEN
107%%
108exp: MY_TOKEN;
109%%
110]])
111AT_BISON_OPTION_POPDEFS
112
113AT_BISON_CHECK([-y -o input.c input.y])
114AT_COMPILE([input.o])
115
116AT_CLEANUP
117
118
119
120## ---------------------------------------- ##
121## Early token definitions without --yacc. ##
122## ---------------------------------------- ##
123
124
125AT_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
130AT_BISON_OPTION_PUSHDEFS
131AT_DATA_GRAMMAR([input.y],
132[[%{
133#include <stdio.h>
134]AT_YYERROR_DECLARE_EXTERN[
135]AT_YYLEX_DECLARE_EXTERN[
136void print_my_token (void);
137%}
138
139%union
140{
141 int val;
142};
143%{
144void
145print_my_token (void)
146{
147 enum yytokentype my_token = MY_TOKEN;
148 printf ("%d\n", my_token);
149}
150%}
151%token MY_TOKEN
152%%
153exp: MY_TOKEN;
154%%
155]])
156AT_BISON_OPTION_POPDEFS
157
158AT_BISON_CHECK([-o input.c input.y])
159AT_COMPILE([input.o])
160
161AT_CLEANUP
162
163
164
165## ---------------- ##
166## Braces parsing. ##
167## ---------------- ##
168
169
170AT_SETUP([Braces parsing])
171
172AT_BISON_OPTION_PUSHDEFS
173AT_DATA([input.y],
174[[/* Bison used to swallow the character after '}'. */
175
176%%
177exp: { tests = {{{{{{{{{{}}}}}}}}}}; };
178%%
179]])
180AT_BISON_OPTION_POPDEFS
181
182AT_BISON_CHECK([-v -o input.c input.y])
183
184AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore])
185
186AT_CLEANUP
187
188
189## ------------------ ##
190## Duplicate string. ##
191## ------------------ ##
192
193
194AT_SETUP([Duplicate string])
195
196AT_BISON_OPTION_PUSHDEFS
197AT_DATA([input.y],
198[[/* 'Bison -v' used to dump core when two tokens are defined with the same
199 string, as LE and GE below. */
200
201%token NUM
202%token LE "<="
203%token GE "<="
204
205%%
206exp: '(' exp ')' | NUM ;
207%%
208]])
209AT_BISON_OPTION_POPDEFS
210
211AT_BISON_CHECK([-v -o input.c input.y], 0, [],
212[[input.y:6.8-14: warning: symbol "<=" used more than once as a literal string [-Wother]
213]])
214
215AT_CLEANUP
216
217
218## ------------------- ##
219## Rule Line Numbers. ##
220## ------------------- ##
221
222AT_SETUP([Rule Line Numbers])
223
224AT_KEYWORDS([report])
225
226AT_BISON_OPTION_PUSHDEFS
227AT_DATA([input.y],
228[[%%
229expr:
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
254};
255]])
256AT_BISON_OPTION_POPDEFS
257
258AT_BISON_CHECK([-o input.c -v input.y])
259
260# Check the contents of the report.
261AT_CHECK([cat input.output], [],
262[[Grammar
263
264 0 $accept: expr $end
265
266 1 $@1: /* empty */
267
268 2 expr: 'a' $@1 'b'
269
270 3 $@2: /* empty */
271
272 4 expr: $@2 'c'
273
274
275Terminals, with rules where they appear
276
277$end (0) 0
278'a' (97) 2
279'b' (98) 2
280'c' (99) 4
281error (256)
282
283
284Nonterminals, with rules where they appear
285
286$accept (6)
287 on left: 0
288expr (7)
289 on left: 2 4, on right: 0
290$@1 (8)
291 on left: 1, on right: 2
292$@2 (9)
293 on left: 3, on right: 4
294
295
296state 0
297
298 0 $accept: . expr $end
299
300 'a' shift, and go to state 1
301
302 $default reduce using rule 3 ($@2)
303
304 expr go to state 2
305 $@2 go to state 3
306
307
308state 1
309
310 2 expr: 'a' . $@1 'b'
311
312 $default reduce using rule 1 ($@1)
313
314 $@1 go to state 4
315
316
317state 2
318
319 0 $accept: expr . $end
320
321 $end shift, and go to state 5
322
323
324state 3
325
326 4 expr: $@2 . 'c'
327
328 'c' shift, and go to state 6
329
330
331state 4
332
333 2 expr: 'a' $@1 . 'b'
334
335 'b' shift, and go to state 7
336
337
338state 5
339
340 0 $accept: expr $end .
341
342 $default accept
343
344
345state 6
346
347 4 expr: $@2 'c' .
348
349 $default reduce using rule 4 (expr)
350
351
352state 7
353
354 2 expr: 'a' $@1 'b' .
355
356 $default reduce using rule 2 (expr)
357]])
358
359AT_CLEANUP
360
361
362
363## ---------------------- ##
364## Mixing %token styles. ##
365## ---------------------- ##
366
367
368AT_SETUP([Mixing %token styles])
369
370# Taken from the documentation.
371AT_DATA([input.y],
372[[%token <operator> OR "||"
373%token <operator> LE 134 "<="
374%left OR "<="
375%%
376exp: ;
377%%
378]])
379
380AT_BISON_CHECK([-v -o input.c input.y])
381
382AT_CLEANUP
383
384
385
386## ---------------- ##
387## Invalid inputs. ##
388## ---------------- ##
389
390
391AT_SETUP([Invalid inputs])
392
393AT_DATA([input.y],
394[[%%
395?
396default: 'a' }
397%&
398%a-does-not-exist
399%-
400%{
401]])
402
403AT_BISON_CHECK([input.y], [1], [],
404[[input.y:2.1: invalid character: '?'
405input.y:3.14: invalid character: '}'
406input.y:4.1: invalid character: '%'
407input.y:4.2: invalid character: '&'
408input.y:5.1-17: invalid directive: '%a-does-not-exist'
409input.y:6.1: invalid character: '%'
410input.y:6.2: invalid character: '-'
411input.y:7.1-8.0: missing '%}' at end of file
412input.y:7.1-8.0: syntax error, unexpected %{...%}
413]])
414
415AT_CLEANUP
416
417
418AT_SETUP([Invalid inputs with {}])
419
420AT_DATA([input.y],
421[[
422%destructor
423%initial-action
424%lex-param
425%parse-param
426%printer
427%union
428]])
429
430AT_BISON_CHECK([input.y], [1], [],
431[[input.y:3.1-15: syntax error, unexpected %initial-action, expecting {...}
432]])
433
434AT_CLEANUP
435
436
437
438## ------------------- ##
439## Token definitions. ##
440## ------------------- ##
441
442
443AT_SETUP([Token definitions])
444
445AT_BISON_OPTION_PUSHDEFS
446# Bison managed, when fed with '%token 'f' "f"' to #define 'f'!
447AT_DATA_GRAMMAR([input.y],
448[%{
449#include <stdlib.h>
450#include <stdio.h>
451]AT_YYERROR_DECLARE[
452]AT_YYLEX_DECLARE[
453%}
454[%error-verbose
455%token MYEOF 0 "end of file"
456%token 'a' "a"
457%token B_TOKEN "b"
458%token C_TOKEN 'c'
459%token 'd' D_TOKEN
460%token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
461%token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
462%%
463exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!";
464%%
465]AT_YYERROR_DEFINE[
466]AT_YYLEX_DEFINE([{ SPECIAL }])[
467
468int
469main (void)
470{
471 return yyparse ();
472}
473]])
474AT_BISON_OPTION_POPDEFS
475
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.
480AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
481[[input.y:22.8-14: warning: symbol SPECIAL redeclared [-Wother]
482input.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]
483]])
484AT_COMPILE([input])
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.
490AT_DATA([experr],
491[[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
492]])
493AT_PARSER_CHECK([./input], 1, [], [experr])
494AT_CLEANUP
495
496
497
498## -------------------- ##
499## Characters Escapes. ##
500## -------------------- ##
501
502
503AT_SETUP([Characters Escapes])
504
505AT_BISON_OPTION_PUSHDEFS
506AT_DATA_GRAMMAR([input.y],
507[%{
508]AT_YYERROR_DECLARE_EXTERN[
509]AT_YYLEX_DECLARE_EXTERN[
510%}
511[%%
512exp:
513 '\'' "\'"
514| '\"' "\""
515| '"' "'" /* Pacify font-lock-mode: ". */
516;
517]])
518
519AT_BISON_OPTION_POPDEFS
520
521AT_BISON_CHECK([-o input.c input.y])
522AT_COMPILE([input.o])
523AT_CLEANUP
524
525
526
527## -------------- ##
528## Web2c Report. ##
529## -------------- ##
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
533# 'undef_id_tok' in state 1 was missing. This is stripped down from
534# the actual web2c.y.
535
536AT_SETUP([Web2c Report])
537
538AT_KEYWORDS([report])
539
540AT_DATA([input.y],
541[[%token undef_id_tok const_id_tok
542
543%start CONST_DEC_PART
544\f
545%%
546CONST_DEC_PART:
547 CONST_DEC_LIST
548 ;
549
550CONST_DEC_LIST:
551 CONST_DEC
552 | CONST_DEC_LIST CONST_DEC
553 ;
554
555CONST_DEC:
556 { } undef_id_tok '=' const_id_tok ';'
557 ;
558%%
559]])
560
561AT_BISON_CHECK([-v input.y])
562AT_CHECK([cat input.output], 0,
563[[Grammar
564
565 0 $accept: CONST_DEC_PART $end
566
567 1 CONST_DEC_PART: CONST_DEC_LIST
568
569 2 CONST_DEC_LIST: CONST_DEC
570 3 | CONST_DEC_LIST CONST_DEC
571
572 4 $@1: /* empty */
573
574 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';'
575
576
577Terminals, with rules where they appear
578
579$end (0) 0
580';' (59) 5
581'=' (61) 5
582error (256)
583undef_id_tok (258) 5
584const_id_tok (259) 5
585
586
587Nonterminals, with rules where they appear
588
589$accept (7)
590 on left: 0
591CONST_DEC_PART (8)
592 on left: 1, on right: 0
593CONST_DEC_LIST (9)
594 on left: 2 3, on right: 1 3
595CONST_DEC (10)
596 on left: 5, on right: 2 3
597$@1 (11)
598 on left: 4, on right: 5
599
600
601state 0
602
603 0 $accept: . CONST_DEC_PART $end
604
605 $default reduce using rule 4 ($@1)
606
607 CONST_DEC_PART go to state 1
608 CONST_DEC_LIST go to state 2
609 CONST_DEC go to state 3
610 $@1 go to state 4
611
612
613state 1
614
615 0 $accept: CONST_DEC_PART . $end
616
617 $end shift, and go to state 5
618
619
620state 2
621
622 1 CONST_DEC_PART: CONST_DEC_LIST .
623 3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC
624
625 undef_id_tok reduce using rule 4 ($@1)
626 $default reduce using rule 1 (CONST_DEC_PART)
627
628 CONST_DEC go to state 6
629 $@1 go to state 4
630
631
632state 3
633
634 2 CONST_DEC_LIST: CONST_DEC .
635
636 $default reduce using rule 2 (CONST_DEC_LIST)
637
638
639state 4
640
641 5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';'
642
643 undef_id_tok shift, and go to state 7
644
645
646state 5
647
648 0 $accept: CONST_DEC_PART $end .
649
650 $default accept
651
652
653state 6
654
655 3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC .
656
657 $default reduce using rule 3 (CONST_DEC_LIST)
658
659
660state 7
661
662 5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';'
663
664 '=' shift, and go to state 8
665
666
667state 8
668
669 5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';'
670
671 const_id_tok shift, and go to state 9
672
673
674state 9
675
676 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';'
677
678 ';' shift, and go to state 10
679
680
681state 10
682
683 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' .
684
685 $default reduce using rule 5 (CONST_DEC)
686]])
687
688AT_CLEANUP
689
690
691## --------------- ##
692## Web2c Actions. ##
693## --------------- ##
694
695# The generation of the mapping 'state -> action' was once wrong in
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#
703# static const yytype_uint8 yydefact[] =
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
713AT_SETUP([Web2c Actions])
714
715AT_KEYWORDS([report])
716
717AT_DATA([input.y],
718[[%%
719statement: struct_stat;
720struct_stat: /* empty. */ | if else;
721if: "if" "const" "then" statement;
722else: "else" statement;
723%%
724]])
725
726AT_BISON_CHECK([-v -o input.c input.y])
727
728# Check only the tables.
729[sed -n 's/ *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c]
730
731AT_CHECK([[cat tables.c]], 0,
732[[static const yytype_uint8 yytranslate[] =
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,
759 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
760 5, 6
761};
762static const yytype_uint8 yyrline[] =
763{
764 0, 2, 2, 3, 3, 4, 5
765};
766static const char *const yytname[] =
767{
768 "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
769 "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL
770};
771static const yytype_uint16 yytoknum[] =
772{
773 0, 256, 257, 258, 259, 260, 261
774};
775static const yytype_int8 yypact[] =
776{
777 -2, -1, 4, -8, 0, 2, -8, -2, -8, -2,
778 -8, -8
779};
780static const yytype_uint8 yydefact[] =
781{
782 3, 0, 0, 2, 0, 0, 1, 3, 4, 3,
783 6, 5
784};
785static const yytype_int8 yypgoto[] =
786{
787 -8, -7, -8, -8, -8
788};
789static const yytype_int8 yydefgoto[] =
790{
791 -1, 2, 3, 4, 8
792};
793static const yytype_uint8 yytable[] =
794{
795 10, 1, 11, 5, 6, 0, 7, 9
796};
797static const yytype_int8 yycheck[] =
798{
799 7, 3, 9, 4, 0, -1, 6, 5
800};
801static const yytype_uint8 yystos[] =
802{
803 0, 3, 8, 9, 10, 4, 0, 6, 11, 5,
804 8, 8
805};
806static const yytype_uint8 yyr1[] =
807{
808 0, 7, 8, 9, 9, 10, 11
809};
810static const yytype_uint8 yyr2[] =
811{
812 0, 2, 1, 0, 2, 4, 2
813};
814]])
815
816AT_CLEANUP
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.
830m4_define([_AT_DATA_DANCER_Y],
831[AT_DATA_GRAMMAR([dancer.y],
832[[%code provides
833{
834 ]AT_YYERROR_DECLARE[
835 ]AT_YYLEX_DECLARE[
836}
837$1
838%token ARROW INVALID NUMBER STRING DATA
839%defines
840%verbose
841%error-verbose
842/* Grammar follows */
843%%
844line: header body
845 ;
846
847header: '<' from ARROW to '>' type ':'
848 | '<' ARROW to '>' type ':'
849 | ARROW to type ':'
850 | type ':'
851 | '<' '>'
852 ;
853
854from: DATA
855 | STRING
856 | INVALID
857 ;
858
859to: DATA
860 | STRING
861 | INVALID
862 ;
863
864type: DATA
865 | STRING
866 | INVALID
867 ;
868
869body: /* empty */
870 | body member
871 ;
872
873member: STRING
874 | DATA
875 | '+' NUMBER
876 | '-' NUMBER
877 | NUMBER
878 | INVALID
879 ;
880%%
881]AT_YYERROR_DEFINE[
882]AT_YYLEX_DEFINE([":"])[
883]AT_LALR1_CC_IF(
884[int
885yyparse ()
886{
887 yy::parser parser;
888#if YYDEBUG
889 parser.set_debug_level (YYDEBUG);
890#endif
891 return parser.parse ();
892}
893])[
894
895int
896main (void)
897{
898 return yyparse ();
899}
900]])
901])# _AT_DATA_DANCER_Y
902
903
904# AT_CHECK_DANCER(BISON-OPTIONS)
905# ------------------------------
906# Generate the grammar, compile it, run it.
907m4_define([AT_CHECK_DANCER],
908[AT_SETUP([Dancer $1])
909AT_BISON_OPTION_PUSHDEFS([$1])
910_AT_DATA_DANCER_Y([$1])
911AT_BISON_CHECK([-o dancer.c dancer.y])
912AT_FULL_COMPILE([dancer])
913AT_PARSER_CHECK([./dancer], 1, [],
914[syntax error, unexpected ':'
915])
916AT_BISON_OPTION_POPDEFS
917AT_CLEANUP
918])
919
920AT_CHECK_DANCER()
921AT_CHECK_DANCER([%glr-parser])
922AT_CHECK_DANCER([%skeleton "lalr1.cc"])
923
924
925## ------------------------------------------ ##
926## Diagnostic that expects two alternatives. ##
927## ------------------------------------------ ##
928
929
930# _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
931# --------------------------------
932m4_define([_AT_DATA_EXPECT2_Y],
933[AT_DATA_GRAMMAR([expect2.y],
934[%{
935static int yylex (AT_LALR1_CC_IF([int *], [void]));
936AT_LALR1_CC_IF([[#include <cstdlib>]],
937[[#include <stdlib.h>
938#include <stdio.h>
939]AT_YYERROR_DECLARE])[
940%}
941$1
942%defines
943%error-verbose
944%token A 1000
945%token B
946
947%%
948program: /* empty */
949 | program e ';'
950 | program error ';';
951
952e: e '+' t | t;
953t: A | B;
954
955%%
956]AT_YYERROR_DEFINE[
957]AT_LALR1_CC_IF(
958[int
959yyparse ()
960{
961 yy::parser parser;
962 return parser.parse ();
963}
964])[
965
966#include <assert.h>
967static int
968yylex (]AT_LALR1_CC_IF([int *lval], [void])[)
969{
970 static int const tokens[] =
971 {
972 1000, '+', '+', -1
973 };
974 static size_t toknum;
975 ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[
976 assert (toknum < sizeof tokens / sizeof *tokens);
977 return tokens[toknum++];
978}
979
980int
981main (void)
982{
983 return yyparse ();
984}
985]])
986])# _AT_DATA_EXPECT2_Y
987
988
989# AT_CHECK_EXPECT2(BISON-OPTIONS)
990# -------------------------------
991# Generate the grammar, compile it, run it.
992m4_define([AT_CHECK_EXPECT2],
993[AT_SETUP([Expecting two tokens $1])
994AT_BISON_OPTION_PUSHDEFS([$1])
995_AT_DATA_EXPECT2_Y([$1])
996AT_BISON_CHECK([-o expect2.c expect2.y])
997AT_FULL_COMPILE([expect2])
998AT_PARSER_CHECK([./expect2], 1, [],
999[syntax error, unexpected '+', expecting A or B
1000])
1001AT_BISON_OPTION_POPDEFS
1002AT_CLEANUP
1003])
1004
1005AT_CHECK_EXPECT2()
1006AT_CHECK_EXPECT2([%glr-parser])
1007AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
1008
1009
1010
1011## --------------------------------------------- ##
1012## Braced code in declaration in rules section. ##
1013## --------------------------------------------- ##
1014
1015AT_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.
1019AT_BISON_OPTION_PUSHDEFS
1020AT_DATA_GRAMMAR([input.y],
1021[[%{
1022#include <stdio.h>
1023]AT_YYERROR_DECLARE[
1024]AT_YYLEX_DECLARE[
1025%}
1026
1027%error-verbose
1028
1029%%
1030
1031start:
1032 {
1033 printf ("Bison would once convert this action to a midrule because of the"
1034 " subsequent braced code.\n");
1035 }
1036 ;
1037
1038%destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1039%printer { fprintf (yyoutput, "PRINTER"); } 'a';
1040
1041%%
1042]AT_YYERROR_DEFINE[
1043]AT_YYLEX_DEFINE(["a"])[
1044
1045int
1046main (void)
1047{
1048 yydebug = 1;
1049 return !yyparse ();
1050}
1051]])
1052AT_BISON_OPTION_POPDEFS
1053
1054AT_BISON_CHECK([-t -o input.c input.y])
1055AT_COMPILE([input])
1056AT_PARSER_CHECK([./input], 0,
1057[[Bison would once convert this action to a midrule because of the subsequent braced code.
1058]],
1059[[Starting parse
1060Entering state 0
1061Reducing stack by rule 1 (line 20):
1062-> $$ = nterm start ()
1063Stack now 0
1064Entering state 1
1065Reading a token: Next token is token 'a' (PRINTER)
1066syntax error, unexpected 'a', expecting $end
1067Error: popping nterm start ()
1068Stack now 0
1069Cleanup: discarding lookahead token 'a' (PRINTER)
1070DESTRUCTOR
1071Stack now 0
1072]])
1073
1074AT_CLEANUP
1075
1076
1077
1078## --------------------------------- ##
1079## String alias declared after use. ##
1080## --------------------------------- ##
1081
1082AT_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
1087# uses and other tokens appeared in between.
1088
1089AT_DATA([input.y],
1090[[%%
1091start: 'a' "A" 'b';
1092%token 'a' "A";
1093]])
1094
1095AT_BISON_CHECK([-t -o input.c input.y])
1096
1097AT_CLEANUP
1098
1099
1100
1101## -------------------------------- ##
1102## Extra lookahead sets in report. ##
1103## -------------------------------- ##
1104
1105AT_SETUP([[Extra lookahead sets in report]])
1106
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
1111# associated with the same rule. This bug affected only the '.output' file and
1112# not the generated parser source code.
1113
1114AT_DATA([[input.y]],
1115[[%%
1116start: a | 'a' a 'a' ;
1117a: 'a' ;
1118]])
1119
1120AT_BISON_CHECK([[--report=all input.y]])
1121AT_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
1135state 2
1136]])
1137
1138AT_CLEANUP
1139
1140
1141
1142## ---------------------------------------- ##
1143## Token number in precedence declaration. ##
1144## ---------------------------------------- ##
1145
1146AT_SETUP([[Token number in precedence declaration]])
1147
1148# POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1149# we lost this in Bison 1.50.
1150AT_BISON_OPTION_PUSHDEFS
1151AT_DATA_GRAMMAR([input.y],
1152[[%{
1153 #include <stdio.h>
1154 ]AT_YYERROR_DECLARE[
1155 ]AT_YYLEX_DECLARE[
1156%}
1157
1158%error-verbose
1159%right END 0
1160%left TK1 1 TK2 2 "tok alias" 3
1161
1162%%
1163
1164start:
1165 TK1 sr_conflict "tok alias"
1166 | start %prec END
1167 ;
1168sr_conflict:
1169 TK2
1170 | TK2 "tok alias"
1171 ;
1172
1173%%
1174
1175]AT_YYERROR_DEFINE[
1176]AT_YYLEX_DEFINE([{ 1, 2, 3, 0 }])[
1177
1178int
1179main (void)
1180{
1181 return yyparse ();
1182}
1183]])
1184AT_BISON_OPTION_POPDEFS
1185
1186AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
1187[[input.y:23.5-19: warning: rule useless in parser due to conflicts: start: start [-Wother]
1188input.y:27.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias" [-Wother]
1189]])
1190AT_COMPILE([[input]])
1191AT_PARSER_CHECK([[./input]])
1192
1193AT_CLEANUP
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
1204AT_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.
1209[cp $abs_top_srcdir/src/parse-gram.y input.y]
1210AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]])
1211[mv input.c lalr.c]
1212AT_CAPTURE_FILE([lalr.c])
1213AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]])
1214[mv input.c ielr.c]
1215AT_CAPTURE_FILE([ielr.c])
1216AT_CHECK([[diff lalr.c ielr.c]], [[0]])
1217
1218AT_CLEANUP
1219
1220
1221
1222## -------------------------------------------- ##
1223## parse.error=verbose and YYSTACK_USE_ALLOCA. ##
1224## -------------------------------------------- ##
1225
1226AT_SETUP([[parse.error=verbose and YYSTACK_USE_ALLOCA]])
1227
1228AT_BISON_OPTION_PUSHDEFS
1229AT_DATA_GRAMMAR([input.y],
1230[[%code {
1231 #include <stdio.h>
1232 ]AT_YYERROR_DECLARE[
1233 ]AT_YYLEX_DECLARE[
1234 #define YYSTACK_USE_ALLOCA 1
1235}
1236
1237%define parse.error verbose
1238
1239%%
1240
1241start: check syntax_error syntax_error ;
1242
1243check:
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.
1261syntax_error:
1262 "123456789112345678921234567893123456789412345678951234567896123A"
1263| "123456789112345678921234567893123456789412345678951234567896123B"
1264| error 'a' 'b' 'c'
1265;
1266
1267%%
1268
1269]AT_YYERROR_DEFINE[
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. */
1273]AT_YYLEX_DEFINE(["abc"])[
1274int
1275main (void)
1276{
1277 return yyparse ();
1278}
1279]])
1280AT_BISON_OPTION_POPDEFS
1281
1282AT_BISON_CHECK([[-o input.c input.y]])
1283AT_COMPILE([[input]])
1284AT_PARSER_CHECK([[./input]], [[1]], [],
1285[[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1286syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1287]])
1288
1289AT_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
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.
1304
1305AT_SETUP([[parse.error=verbose overflow]])
1306
1307AT_BISON_OPTION_PUSHDEFS
1308AT_DATA_GRAMMAR([input.y],
1309[[%code {
1310 #include <stdio.h>
1311 ]AT_YYERROR_DECLARE[
1312 ]AT_YYLEX_DECLARE[
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
1318 /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to
1319 provide a malloc prototype using our YYSIZE_T. */
1320 #include <stdlib.h>
1321 #ifndef EXIT_SUCCESS
1322 # define EXIT_SUCCESS 0
1323 #endif
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
1335start: 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.
1340syntax_error1:
1341 "123456789112345678921234567893123456789412345678951234567896123A"
1342| "123456789112345678921234567893123456789412345678951234567896123B"
1343| "123456789112345678921234567893123456789412345678951234567896123C"
1344| error 'a' 'b' 'c'
1345;
1346
1347check:
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.
1368syntax_error2:
1369 "123456789112345678921234567893123456789412345678951234567896123A"
1370| "123456789112345678921234567893123456789412345678951234567896123B"
1371| "123456789112345678921234567893123456789412345678951234567896123C"
1372| "123456789112345678921234567893123456789412345678951234567896123D"
1373| "123456789112345678921234567893123456789412345678951234567896123E"
1374;
1375
1376%%
1377
1378]AT_YYERROR_DEFINE[
1379 /* Induce two syntax error messages (which requires full error
1380 recovery by shifting 3 tokens). */
1381]AT_YYLEX_DEFINE(["abc"])[
1382int
1383main (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
1393AT_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"]
1400AT_COMPILE([[input]])
1401
1402AT_PARSER_CHECK([[./input]], [[2]], [],
1403[[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
1404syntax error
1405memory exhausted
1406]])
1407AT_BISON_OPTION_POPDEFS
1408AT_CLEANUP
1409
1410
1411
1412## ------------------------ ##
1413## LAC: Exploratory stack. ##
1414## ------------------------ ##
1415
1416AT_SETUP([[LAC: Exploratory stack]])
1417
1418m4_pushdef([AT_LAC_CHECK], [
1419
1420AT_BISON_OPTION_PUSHDEFS([$1])
1421
1422AT_DATA_GRAMMAR([input.y],
1423[[%code {
1424 #include <stdio.h>
1425 ]AT_YYERROR_DECLARE[
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
1437S: 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 ;
1438// ^ ^ ^
1439// LAC reallocs
1440
1441A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ;
1442B: 'b' ;
1443C: /*empty*/ { printf ("consistent default reduction\n"); } ;
1444
1445%%
1446]AT_YYERROR_DEFINE[
1447int
1448yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[)
1449{
1450 static char const *input = "bbbbc";]AT_PURE_IF([[
1451 *v = 0;]])[
1452 return *input++;
1453}
1454
1455int
1456main (void)
1457{
1458 yydebug = 1;
1459 return yyparse ();
1460}
1461]])
1462
1463AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1464 -Dparse.lac.memory-trace=full \
1465 -t -o input.c input.y]], [[0]], [],
1466[[input.y: conflicts: 21 shift/reduce
1467]])
1468AT_COMPILE([[input]])
1469AT_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.
1473AT_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.
1479AT_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.
1484AT_CHECK([[perl -0777 -ne 'print s/\bconsistent default reduction//g;' \
1485 < stdout.txt || exit 77]], [[0]], [[2]])
1486
1487# Check number of reallocs to be sure reallocated memory isn't somehow
1488# lost between LAC invocations.
1489AT_CHECK([[perl -0777 -ne 'print s/\(realloc//g;' < stderr.txt \
1490 || exit 77]], [[0]], [[3]])
1491
1492AT_BISON_OPTION_POPDEFS
1493])
1494
1495AT_LAC_CHECK([[%define api.push-pull pull]])
1496AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]])
1497AT_LAC_CHECK([[%define api.push-pull both]])
1498AT_LAC_CHECK([[%define api.push-pull both %define api.pure]])
1499
1500m4_popdef([AT_LAC_CHECK])
1501
1502AT_CLEANUP
1503
1504
1505
1506## ------------------------ ##
1507## LAC: Memory exhaustion. ##
1508## ------------------------ ##
1509
1510AT_SETUP([[LAC: Memory exhaustion]])
1511
1512m4_pushdef([AT_LAC_CHECK],
1513[AT_BISON_OPTION_PUSHDEFS
1514AT_DATA_GRAMMAR([input.y],
1515[[%code {
1516 #include <stdio.h>
1517 ]AT_YYERROR_DECLARE[
1518 ]AT_YYLEX_DECLARE[
1519 #define YYMAXDEPTH 8
1520}
1521
1522%error-verbose
1523
1524%%
1525
1526S: A A A A A A A A A ;
1527A: /*empty*/ | 'a' ;
1528
1529%%
1530]AT_YYERROR_DEFINE[
1531]AT_YYLEX_DEFINE(["$1"])[
1532int
1533main (void)
1534{
1535 yydebug = 1;
1536 return yyparse ();
1537}
1538]])
1539
1540AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1541 -t -o input.c input.y]], [[0]], [],
1542[[input.y: conflicts: 8 shift/reduce
1543]])
1544AT_COMPILE([[input]])
1545AT_BISON_OPTION_POPDEFS
1546])
1547
1548# Check for memory exhaustion during parsing.
1549AT_LAC_CHECK([])
1550AT_PARSER_CHECK([[./input]], [[2]], [],
1551[[Starting parse
1552Entering state 0
1553Reading a token: Now at end of input.
1554LAC: initial context established for $end
1555LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1556memory exhausted
1557Cleanup: discarding lookahead token $end ()
1558Stack 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.
1563AT_LAC_CHECK([z], [[0]])
1564AT_PARSER_CHECK([[./input]], [[2]], [],
1565[[Starting parse
1566Entering state 0
1567Reading a token: Next token is token $undefined ()
1568LAC: initial context established for $undefined
1569LAC: checking lookahead $undefined: Always Err
1570Constructing syntax error message
1571LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1572syntax error
1573memory exhausted
1574Cleanup: discarding lookahead token $undefined ()
1575Stack now 0
1576]])
1577
1578m4_popdef([AT_LAC_CHECK])
1579
1580AT_CLEANUP