1 # Bison Regressions. -*- Autotest -*-
3 # Copyright (C) 2001-2011 Free Software Foundation, Inc.
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.
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.
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/>.
18 AT_BANNER([[Regression tests.]])
21 ## ------------------ ##
22 ## Trivial grammars. ##
23 ## ------------------ ##
25 AT_SETUP([Trivial grammars])
27 AT_DATA_GRAMMAR([input.y],
29 void yyerror (char const *);
41 AT_BISON_CHECK([-o input.c input.y])
42 AT_COMPILE([input.o], [-c input.c])
43 AT_COMPILE([input.o], [-DYYDEBUG -c input.c])
49 ## ----------------- ##
50 ## YYSTYPE typedef. ##
51 ## ----------------- ##
53 AT_SETUP([YYSTYPE typedef])
55 AT_DATA_GRAMMAR([input.y],
57 void yyerror (char const *);
59 typedef union { char const *val; } YYSTYPE;
66 program: { $$ = ""; };
69 AT_BISON_CHECK([-o input.c input.y])
70 AT_COMPILE([input.o], [-c input.c])
76 ## ------------------------------------- ##
77 ## Early token definitions with --yacc. ##
78 ## ------------------------------------- ##
81 AT_SETUP([Early token definitions with --yacc])
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.
86 AT_DATA_GRAMMAR([input.y],
88 void yyerror (const char *s);
98 # error "MY_TOKEN not defined."
107 AT_BISON_CHECK([-y -o input.c input.y])
108 AT_COMPILE([input.o], [-c input.c])
114 ## ---------------------------------------- ##
115 ## Early token definitions without --yacc. ##
116 ## ---------------------------------------- ##
119 AT_SETUP([Early token definitions without --yacc])
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.
124 AT_DATA_GRAMMAR([input.y],
127 void yyerror (const char *s);
129 void print_my_token (void);
138 print_my_token (void)
140 enum yytokentype my_token = MY_TOKEN;
141 printf ("%d\n", my_token);
150 AT_BISON_CHECK([-o input.c input.y])
151 AT_COMPILE([input.o], [-c input.c])
157 ## ---------------- ##
158 ## Braces parsing. ##
159 ## ---------------- ##
162 AT_SETUP([Braces parsing])
165 [[/* Bison used to swallow the character after `}'. */
168 exp: { tests = {{{{{{{{{{}}}}}}}}}}; };
172 AT_BISON_CHECK([-v -o input.c input.y])
174 AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore])
179 ## ------------------ ##
180 ## Duplicate string. ##
181 ## ------------------ ##
184 AT_SETUP([Duplicate string])
187 [[/* `Bison -v' used to dump core when two tokens are defined with the same
188 string, as LE and GE below. */
195 exp: '(' exp ')' | NUM ;
199 AT_BISON_CHECK([-v -o input.c input.y], 0, [],
200 [[input.y:6.8-14: warning: symbol `"<="' used more than once as a literal string
206 ## ------------------- ##
207 ## Rule Line Numbers. ##
208 ## ------------------- ##
210 AT_SETUP([Rule Line Numbers])
212 AT_KEYWORDS([report])
244 AT_BISON_CHECK([-o input.c -v input.y])
246 # Check the contents of the report.
247 AT_CHECK([cat input.output], [],
261 Terminals, with rules where they appear
270 Nonterminals, with rules where they appear
275 on left: 2 4, on right: 0
277 on left: 1, on right: 2
279 on left: 3, on right: 4
284 0 $accept: . expr $end
286 'a' shift, and go to state 1
288 $default reduce using rule 3 ($@2)
296 2 expr: 'a' . $@1 'b'
298 $default reduce using rule 1 ($@1)
305 0 $accept: expr . $end
307 $end shift, and go to state 5
314 'c' shift, and go to state 6
319 2 expr: 'a' $@1 . 'b'
321 'b' shift, and go to state 7
326 0 $accept: expr $end .
335 $default reduce using rule 4 (expr)
340 2 expr: 'a' $@1 'b' .
342 $default reduce using rule 2 (expr)
349 ## ---------------------- ##
350 ## Mixing %token styles. ##
351 ## ---------------------- ##
354 AT_SETUP([Mixing %token styles])
356 # Taken from the documentation.
358 [[%token <operator> OR "||"
359 %token <operator> LE 134 "<="
366 AT_BISON_CHECK([-v -o input.c input.y])
372 ## ---------------- ##
373 ## Invalid inputs. ##
374 ## ---------------- ##
377 AT_SETUP([Invalid inputs])
389 AT_BISON_CHECK([input.y], [1], [],
390 [[input.y:2.1: invalid character: `?'
391 input.y:3.14: invalid character: `}'
392 input.y:4.1: invalid character: `%'
393 input.y:4.2: invalid character: `&'
394 input.y:5.1-17: invalid directive: `%a-does-not-exist'
395 input.y:6.1-2: invalid directive: `%-'
396 input.y:7.1-8.0: missing `%}' at end of file
397 input.y:7.1-8.0: syntax error, unexpected %{...%}
403 AT_SETUP([Invalid inputs with {}])
415 AT_BISON_CHECK([input.y], [1], [],
416 [[input.y:3.1-15: syntax error, unexpected %initial-action, expecting {...}
423 ## ------------------- ##
424 ## Token definitions. ##
425 ## ------------------- ##
428 AT_SETUP([Token definitions])
430 # Bison managed, when fed with `%token 'f' "f"' to #define 'f'!
431 AT_DATA_GRAMMAR([input.y],
435 void yyerror (const char *s);
439 %token MYEOF 0 "end of file"
444 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
445 %token SPECIAL "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!"
447 exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!";
450 yyerror (char const *s)
452 fprintf (stderr, "%s\n", s);
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.
475 AT_BISON_CHECK([-o input.c input.y], [[0]], [[]],
476 [[input.y:22.8-14: warning: symbol SPECIAL redeclared
477 input.y:22.8-63: warning: symbol `"\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!"' used more than once as a literal string
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
486 [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
488 AT_PARSER_CHECK([./input], 1, [], [experr])
493 ## -------------------- ##
494 ## Characters Escapes. ##
495 ## -------------------- ##
498 AT_SETUP([Characters Escapes])
500 AT_DATA_GRAMMAR([input.y],
502 void yyerror (const char *s);
512 # Pacify font-lock-mode: "
514 AT_BISON_CHECK([-o input.c input.y])
515 AT_COMPILE([input.o], [-c input.c])
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.
529 AT_SETUP([Web2c Report])
531 AT_KEYWORDS([report])
534 [[%token undef_id_tok const_id_tok
536 %start CONST_DEC_PART
545 | CONST_DEC_LIST CONST_DEC
549 { } undef_id_tok '=' const_id_tok ';'
554 AT_BISON_CHECK([-v input.y])
555 AT_CHECK([cat input.output], 0,
558 0 $accept: CONST_DEC_PART $end
560 1 CONST_DEC_PART: CONST_DEC_LIST
562 2 CONST_DEC_LIST: CONST_DEC
563 3 | CONST_DEC_LIST CONST_DEC
567 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';'
570 Terminals, with rules where they appear
580 Nonterminals, with rules where they appear
585 on left: 1, on right: 0
587 on left: 2 3, on right: 1 3
589 on left: 5, on right: 2 3
591 on left: 4, on right: 5
596 0 $accept: . CONST_DEC_PART $end
598 $default reduce using rule 4 ($@1)
600 CONST_DEC_PART go to state 1
601 CONST_DEC_LIST go to state 2
602 CONST_DEC go to state 3
608 0 $accept: CONST_DEC_PART . $end
610 $end shift, and go to state 5
615 1 CONST_DEC_PART: CONST_DEC_LIST .
616 3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC
618 undef_id_tok reduce using rule 4 ($@1)
619 $default reduce using rule 1 (CONST_DEC_PART)
621 CONST_DEC go to state 6
627 2 CONST_DEC_LIST: CONST_DEC .
629 $default reduce using rule 2 (CONST_DEC_LIST)
634 5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';'
636 undef_id_tok shift, and go to state 7
641 0 $accept: CONST_DEC_PART $end .
648 3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC .
650 $default reduce using rule 3 (CONST_DEC_LIST)
655 5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';'
657 '=' shift, and go to state 8
662 5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';'
664 const_id_tok shift, and go to state 9
669 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';'
671 ';' shift, and go to state 10
676 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' .
678 $default reduce using rule 5 (CONST_DEC)
684 ## --------------- ##
686 ## --------------- ##
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.
694 # It used to be wrong on yydefact only:
696 # static const yytype_uint8 yydefact[] =
698 # - 2, 0, 1, 0, 0, 2, 3, 2, 5, 4,
699 # + 2, 0, 1, 0, 0, 0, 3, 2, 5, 4,
703 # but let's check all the tables.
706 AT_SETUP([Web2c Actions])
708 AT_KEYWORDS([report])
712 statement: struct_stat;
713 struct_stat: /* empty. */ | if else;
714 if: "if" "const" "then" statement;
715 else: "else" statement;
719 AT_BISON_CHECK([-v -o input.c input.y])
721 # Check only the tables.
722 [sed -n 's/ *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c]
724 AT_CHECK([[cat tables.c]], 0,
725 [[static const yytype_uint8 yytranslate[] =
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,
752 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
755 static const yytype_uint8 yyprhs[] =
759 static const yytype_int8 yyrhs[] =
761 8, 0, -1, 9, -1, -1, 10, 11, -1, 3,
762 4, 5, 8, -1, 6, 8, -1
764 static const yytype_uint8 yyrline[] =
768 static const char *const yytname[] =
770 "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
771 "\"else\"", "$accept", "statement", "struct_stat", "if", "else", 0
773 static const yytype_uint16 yytoknum[] =
775 0, 256, 257, 258, 259, 260, 261
777 static const yytype_uint8 yyr1[] =
779 0, 7, 8, 9, 9, 10, 11
781 static const yytype_uint8 yyr2[] =
785 static const yytype_uint8 yydefact[] =
787 3, 0, 0, 2, 0, 0, 1, 3, 4, 3,
790 static const yytype_int8 yydefgoto[] =
794 static const yytype_int8 yypact[] =
796 -2, -1, 4, -8, 0, 2, -8, -2, -8, -2,
799 static const yytype_int8 yypgoto[] =
803 static const yytype_uint8 yytable[] =
805 10, 1, 11, 5, 6, 0, 7, 9
807 static const yytype_int8 yycheck[] =
809 7, 3, 9, 4, 0, -1, 6, 5
811 static const yytype_uint8 yystos[] =
813 0, 3, 8, 9, 10, 4, 0, 6, 11, 5,
821 ## ------------------------- ##
822 ## yycheck Bound Violation. ##
823 ## ------------------------- ##
826 # _AT_DATA_DANCER_Y(BISON-OPTIONS)
827 # --------------------------------
828 # The following grammar, taken from Andrew Suffield's GPL'd implementation
829 # of DGMTP, the Dancer Generic Message Transport Protocol, used to violate
830 # yycheck's bounds where issuing a verbose error message. Keep this test
831 # so that possible bound checking compilers could check all the skeletons.
832 m4_define([_AT_DATA_DANCER_Y],
833 [AT_DATA_GRAMMAR([dancer.y],
835 static int yylex (AT_LALR1_CC_IF([int *], [void]));
839 static void yyerror (const char *);])
842 %token ARROW INVALID NUMBER STRING DATA
846 /* Grammar follows */
851 header: '<' from ARROW to '>' type ':'
852 | '<' ARROW to '>' type ':'
886 [/* A C++ error reporting function. */
888 yy::parser::error (const location&, const std::string& m)
890 std::cerr << m << std::endl;
898 parser.set_debug_level (YYDEBUG);
900 return parser.parse ();
904 yyerror (const char *s)
906 fprintf (stderr, "%s\n", s);
910 yylex (AT_LALR1_CC_IF([int *lval], [void]))
912 static int const tokens[] =
916 static size_t toknum;
917 ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[
918 if (! (toknum < sizeof tokens / sizeof *tokens))
920 return tokens[toknum++];
929 ])# _AT_DATA_DANCER_Y
932 # AT_CHECK_DANCER(BISON-OPTIONS)
933 # ------------------------------
934 # Generate the grammar, compile it, run it.
935 m4_define([AT_CHECK_DANCER],
936 [AT_SETUP([Dancer $1])
937 AT_BISON_OPTION_PUSHDEFS([$1])
938 _AT_DATA_DANCER_Y([$1])
939 AT_BISON_CHECK([-o dancer.c dancer.y])
940 AT_FULL_COMPILE([dancer])
941 AT_PARSER_CHECK([./dancer], 1, [],
942 [syntax error, unexpected ':'
944 AT_BISON_OPTION_POPDEFS
949 AT_CHECK_DANCER([%glr-parser])
950 AT_CHECK_DANCER([%skeleton "lalr1.cc"])
953 ## ------------------------------------------ ##
954 ## Diagnostic that expects two alternatives. ##
955 ## ------------------------------------------ ##
958 # _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
959 # --------------------------------
960 m4_define([_AT_DATA_EXPECT2_Y],
961 [AT_DATA_GRAMMAR([expect2.y],
963 static int yylex (AT_LALR1_CC_IF([int *], [void]));
967 static void yyerror (const char *);])
985 [/* A C++ error reporting function. */
987 yy::parser::error (const location&, const std::string& m)
989 std::cerr << m << std::endl;
996 return parser.parse ();
1000 yyerror (const char *s)
1002 fprintf (stderr, "%s\n", s);
1006 yylex (AT_LALR1_CC_IF([int *lval], [void]))
1008 static int const tokens[] =
1012 static size_t toknum;
1013 ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[
1014 if (! (toknum < sizeof tokens / sizeof *tokens))
1016 return tokens[toknum++];
1025 ])# _AT_DATA_EXPECT2_Y
1028 # AT_CHECK_EXPECT2(BISON-OPTIONS)
1029 # ------------------------------
1030 # Generate the grammar, compile it, run it.
1031 m4_define([AT_CHECK_EXPECT2],
1032 [AT_SETUP([Expecting two tokens $1])
1033 AT_BISON_OPTION_PUSHDEFS([$1])
1034 _AT_DATA_EXPECT2_Y([$1])
1035 AT_BISON_CHECK([-o expect2.c expect2.y])
1036 AT_FULL_COMPILE([expect2])
1037 AT_PARSER_CHECK([./expect2], 1, [],
1038 [syntax error, unexpected '+', expecting A or B
1040 AT_BISON_OPTION_POPDEFS
1045 AT_CHECK_EXPECT2([%glr-parser])
1046 AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
1050 ## --------------------------------------------- ##
1051 ## Braced code in declaration in rules section. ##
1052 ## --------------------------------------------- ##
1054 AT_SETUP([Braced code in declaration in rules section])
1056 # Bison once mistook braced code in a declaration in the rules section to be a
1059 AT_DATA_GRAMMAR([input.y],
1062 static void yyerror (char const *msg);
1063 static int yylex (void);
1072 printf ("Bison would once convert this action to a midrule because of the"
1073 " subsequent braced code.\n");
1077 %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1078 %printer { fprintf (yyoutput, "PRINTER"); } 'a';
1083 yyerror (char const *msg)
1085 fprintf (stderr, "%s\n", msg);
1102 AT_BISON_CHECK([-t -o input.c input.y])
1104 AT_PARSER_CHECK([./input], 0,
1105 [[Bison would once convert this action to a midrule because of the subsequent braced code.
1109 Reducing stack by rule 1 (line 20):
1110 -> $$ = nterm start ()
1113 Reading a token: Next token is token 'a' (PRINTER)
1114 syntax error, unexpected 'a', expecting $end
1115 Error: popping nterm start ()
1117 Cleanup: discarding lookahead token 'a' (PRINTER)
1126 ## --------------------------------- ##
1127 ## String alias declared after use. ##
1128 ## --------------------------------- ##
1130 AT_SETUP([String alias declared after use])
1132 # Bison once incorrectly asserted that the symbol number for either a token or
1133 # its alias was the highest symbol number so far at the point of the alias
1134 # declaration. That was true unless the declaration appeared after their first
1135 # uses and other tokens appeared in between.
1143 AT_BISON_CHECK([-t -o input.c input.y])
1149 ## -------------------------------- ##
1150 ## Extra lookahead sets in report. ##
1151 ## -------------------------------- ##
1153 AT_SETUP([[Extra lookahead sets in report]])
1155 # Bison prints each reduction's lookahead set only next to the associated
1156 # state's one item that (1) is associated with the same rule as the reduction
1157 # and (2) has its dot at the end of its RHS. Previously, Bison also
1158 # erroneously printed the lookahead set next to all of the state's other items
1159 # associated with the same rule. This bug affected only the `.output' file and
1160 # not the generated parser source code.
1162 AT_DATA([[input.y]],
1164 start: a | 'a' a 'a' ;
1168 AT_BISON_CHECK([[--report=all input.y]])
1169 AT_CHECK([[sed -n '/^state 1$/,/^state 2$/p' input.output]], [[0]],
1172 2 start: 'a' . a 'a'
1176 'a' shift, and go to state 4
1178 $default reduce using rule 3 (a)
1190 ## ---------------------------------------- ##
1191 ## Token number in precedence declaration. ##
1192 ## ---------------------------------------- ##
1194 AT_SETUP([[Token number in precedence declaration]])
1196 # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1197 # we lost this in Bison 1.50.
1199 AT_DATA_GRAMMAR([input.y],
1202 void yyerror (char const *);
1207 %left TK1 1 TK2 2 "tok alias" 3
1211 start: TK1 sr_conflict "tok alias" ;
1221 yyerror (char const *msg)
1223 fprintf (stderr, "%s\n", msg);
1229 static int const input[] = { 1, 2, 3, 0 };
1230 static int const *inputp = input;
1241 AT_BISON_CHECK([[-o input.c input.y]], [[0]],,
1242 [[input.y:24.5-19: warning: rule useless in parser due to conflicts: sr_conflict: TK2 "tok alias"
1244 AT_COMPILE([[input]])
1245 AT_PARSER_CHECK([[./input]])
1251 ## --------------------------- ##
1252 ## parse-gram.y: LALR = IELR. ##
1253 ## --------------------------- ##
1255 # If parse-gram.y's LALR and IELR parser tables ever begin to differ, we
1256 # need to fix parse-gram.y or start using IELR.
1258 AT_SETUP([[parse-gram.y: LALR = IELR]])
1260 # Avoid differences in synclines by telling bison that the output files
1261 # have the same name.
1262 [cp $abs_top_srcdir/src/parse-gram.y input.y]
1263 AT_BISON_CHECK([[-o input.c -Dlr.type=lalr input.y]])
1265 AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]])
1267 AT_CHECK([[diff -u lalr.c ielr.c]])
1273 ## --------------------------------------- ##
1274 ## %error-verbose and YYSTACK_USE_ALLOCA. ##
1275 ## --------------------------------------- ##
1277 AT_SETUP([[%error-verbose and YYSTACK_USE_ALLOCA]])
1279 AT_DATA_GRAMMAR([input.y],
1282 void yyerror (char const *);
1284 #define YYSTACK_USE_ALLOCA 1
1291 start: check syntax_error syntax_error ;
1295 if (128 < sizeof yymsgbuf)
1298 "The initial size of yymsgbuf in yyparse has increased\n"
1299 "since this test group was last updated. As a result,\n"
1300 "this test group may no longer manage to induce a\n"
1301 "reallocation of the syntax error message buffer.\n"
1302 "This test group must be adjusted to produce a longer\n"
1303 "error message.\n");
1309 // Induce a syntax error message whose total length is more than
1310 // sizeof yymsgbuf in yyparse. Each token here is 64 bytes.
1312 "123456789112345678921234567893123456789412345678951234567896123A"
1313 | "123456789112345678921234567893123456789412345678951234567896123B"
1320 yyerror (char const *msg)
1322 fprintf (stderr, "%s\n", msg);
1328 /* Induce two syntax error messages (which requires full error
1329 recovery by shifting 3 tokens) in order to detect any loss of the
1330 reallocated buffer. */
1331 static char const *input = "abc";
1342 AT_BISON_CHECK([[-o input.c input.y]])
1343 AT_COMPILE([[input]])
1344 AT_PARSER_CHECK([[./input]], [[1]], [],
1345 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1346 syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
1353 ## ------------------------- ##
1354 ## %error-verbose overflow. ##
1355 ## ------------------------- ##
1357 # Imagine the case where YYSTACK_ALLOC_MAXIMUM = YYSIZE_MAXIMUM and an
1358 # invocation of yysyntax_error has caused yymsg_alloc to grow to exactly
1359 # YYSTACK_ALLOC_MAXIMUM (perhaps because the normal doubling of size had
1360 # to be clipped to YYSTACK_ALLOC_MAXIMUM). In an old version of yacc.c,
1361 # a subsequent invocation of yysyntax_error that overflows during its
1362 # size calculation would return YYSIZE_MAXIMUM to yyparse. Then,
1363 # yyparse would invoke yyerror using the old contents of yymsg.
1365 AT_SETUP([[%error-verbose overflow]])
1367 AT_DATA_GRAMMAR([input.y],
1370 void yyerror (char const *);
1373 /* This prevents this test case from having to induce error messages
1374 large enough to overflow size_t. */
1375 #define YYSIZE_T unsigned char
1377 /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to
1378 provide a malloc prototype using our YYSIZE_T. */
1380 #ifndef EXIT_SUCCESS
1381 # define EXIT_SUCCESS 0
1384 /* Max depth is usually much smaller than YYSTACK_ALLOC_MAXIMUM, and
1385 we don't want gcc to warn everywhere this constant would be too big
1386 to make sense for our YYSIZE_T. */
1387 #define YYMAXDEPTH 100
1394 start: syntax_error1 check syntax_error2 ;
1396 // Induce a syntax error message whose total length causes yymsg in
1397 // yyparse to be reallocated to size YYSTACK_ALLOC_MAXIMUM, which
1398 // should be 255. Each token here is 64 bytes.
1400 "123456789112345678921234567893123456789412345678951234567896123A"
1401 | "123456789112345678921234567893123456789412345678951234567896123B"
1402 | "123456789112345678921234567893123456789412345678951234567896123C"
1408 if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM
1409 || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM
1410 || YYSIZE_MAXIMUM != 255)
1413 "The assumptions of this test group are no longer\n"
1414 "valid, so it may no longer catch the error it was\n"
1415 "designed to catch. Specifically, the following\n"
1416 "values should all be 255:\n\n");
1417 fprintf (stderr, " yymsg_alloc = %d\n", yymsg_alloc);
1418 fprintf (stderr, " YYSTACK_ALLOC_MAXIMUM = %d\n",
1419 YYSTACK_ALLOC_MAXIMUM);
1420 fprintf (stderr, " YYSIZE_MAXIMUM = %d\n", YYSIZE_MAXIMUM);
1428 "123456789112345678921234567893123456789412345678951234567896123A"
1429 | "123456789112345678921234567893123456789412345678951234567896123B"
1430 | "123456789112345678921234567893123456789412345678951234567896123C"
1431 | "123456789112345678921234567893123456789412345678951234567896123D"
1432 | "123456789112345678921234567893123456789412345678951234567896123E"
1438 yyerror (char const *msg)
1440 fprintf (stderr, "%s\n", msg);
1446 /* Induce two syntax error messages (which requires full error
1447 recovery by shifting 3 tokens). */
1448 static char const *input = "abc";
1455 /* Push parsers throw away the message buffer between tokens, so skip
1456 this test under maintainer-push-check. */
1463 AT_BISON_CHECK([[-o input.c input.y]])
1465 # gcc warns about tautologies and fallacies involving comparisons for
1466 # unsigned char. However, it doesn't produce these same warnings for
1467 # size_t and many other types when the warnings would seem to make just
1468 # as much sense. We ignore the warnings.
1469 [CFLAGS="$NO_WERROR_CFLAGS"]
1470 AT_COMPILE([[input]])
1472 AT_PARSER_CHECK([[./input]], [[2]], [],
1473 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
1482 ## ------------------------ ##
1483 ## LAC: Exploratory stack. ##
1484 ## ------------------------ ##
1486 AT_SETUP([[LAC: Exploratory stack]])
1488 m4_pushdef([AT_LAC_CHECK], [
1490 AT_BISON_OPTION_PUSHDEFS([$1])
1492 AT_DATA_GRAMMAR([input.y],
1495 void yyerror (char const *);
1496 int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[);
1505 // default reductions in inconsistent states
1506 // v v v v v v v v v v v v v v
1507 S: A B A A B A A A A B A A A A A A A B C C A A A A A A A A A A A A B ;
1511 A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ;
1513 C: /*empty*/ { printf ("consistent default reduction\n"); } ;
1518 yyerror (char const *msg)
1520 fprintf (stderr, "%s\n", msg);
1524 yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[)
1526 static char const *input = "bbbbc";]AT_PURE_IF([[
1539 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1540 -Dparse.lac.memory-trace=full \
1541 -t -o input.c input.y]], [[0]], [],
1542 [[input.y: conflicts: 21 shift/reduce
1544 AT_COMPILE([[input]])
1545 AT_PARSER_CHECK([[./input > stdout.txt 2> stderr.txt]], [[1]])
1547 # Make sure syntax error doesn't forget that 'a' is expected. It would
1548 # be forgotten without lookahead correction.
1549 AT_CHECK([[grep 'syntax error,' stderr.txt]], [[0]],
1550 [[syntax error, unexpected 'c', expecting 'a' or 'b'
1553 # Check number of default reductions in inconsistent states to be sure
1554 # syntax error is detected before unnecessary reductions are performed.
1555 AT_CHECK([[perl -0777 -ne 'print s/inconsistent default reduction//g;' \
1556 < stdout.txt || exit 77]], [[0]], [[14]])
1558 # Check number of default reductions in consistent states to be sure
1559 # it is performed before the syntax error is detected.
1560 AT_CHECK([[perl -0777 -ne 'print s/\bconsistent default reduction//g;' \
1561 < stdout.txt || exit 77]], [[0]], [[2]])
1563 # Check number of reallocs to be sure reallocated memory isn't somehow
1564 # lost between LAC invocations.
1565 AT_CHECK([[perl -0777 -ne 'print s/\(realloc//g;' < stderr.txt \
1566 || exit 77]], [[0]], [[3]])
1568 AT_BISON_OPTION_POPDEFS
1571 AT_LAC_CHECK([[%define api.push-pull pull]])
1572 AT_LAC_CHECK([[%define api.push-pull pull %define api.pure]])
1573 AT_LAC_CHECK([[%define api.push-pull both]])
1574 AT_LAC_CHECK([[%define api.push-pull both %define api.pure]])
1576 m4_popdef([AT_LAC_CHECK])
1582 ## ------------------------ ##
1583 ## LAC: Memory exhaustion. ##
1584 ## ------------------------ ##
1586 AT_SETUP([[LAC: Memory exhaustion]])
1588 m4_pushdef([AT_LAC_CHECK], [
1590 AT_DATA_GRAMMAR([input.y],
1593 void yyerror (char const *);
1595 #define YYMAXDEPTH 8
1602 S: A A A A A A A A A ;
1603 A: /*empty*/ | 'a' ;
1608 yyerror (char const *msg)
1610 fprintf (stderr, "%s\n", msg);
1616 static char const *input = "]$1[";
1628 AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
1629 -t -o input.c input.y]], [[0]], [],
1630 [[input.y: conflicts: 8 shift/reduce
1632 AT_COMPILE([[input]])
1636 # Check for memory exhaustion during parsing.
1638 AT_PARSER_CHECK([[./input]], [[2]], [[]],
1641 Reading a token: Now at end of input.
1642 LAC: initial context established for $end
1643 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1645 Cleanup: discarding lookahead token $end ()
1649 # Induce an immediate syntax error with an undefined token, and check
1650 # for memory exhaustion while building syntax error message.
1651 AT_LAC_CHECK([[z]], [[0]])
1652 AT_PARSER_CHECK([[./input]], [[2]], [[]],
1655 Reading a token: Next token is token $undefined ()
1656 LAC: initial context established for $undefined
1657 LAC: checking lookahead $undefined: Always Err
1658 Constructing syntax error message
1659 LAC: checking lookahead $end: R2 G3 R2 G5 R2 G6 R2 G7 R2 G8 R2 G9 R2 G10 R2 G11 R2 (max size exceeded)
1662 Cleanup: discarding lookahead token $undefined ()
1666 m4_popdef([AT_LAC_CHECK])