]> git.saurik.com Git - bison.git/blob - tests/regression.at
* data/yacc.c: Fix last apostrophe warning from xgettext.
[bison.git] / tests / regression.at
1 # Bison Regressions. -*- Autotest -*-
2
3 # Copyright (C) 2001-2011 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
18 AT_BANNER([[Regression tests.]])
19
20
21 ## ------------------ ##
22 ## Trivial grammars. ##
23 ## ------------------ ##
24
25 AT_SETUP([Trivial grammars])
26
27 AT_DATA_GRAMMAR([input.y],
28 [[%{
29 void yyerror (char const *);
30 int yylex (void);
31 #define YYSTYPE int *
32 %}
33
34 %error-verbose
35
36 %%
37
38 program: 'x';
39 ]])
40
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])
44
45 AT_CLEANUP
46
47
48
49 ## ----------------- ##
50 ## YYSTYPE typedef. ##
51 ## ----------------- ##
52
53 AT_SETUP([YYSTYPE typedef])
54
55 AT_DATA_GRAMMAR([input.y],
56 [[%{
57 void yyerror (char const *);
58 int yylex (void);
59 typedef union { char const *val; } YYSTYPE;
60 %}
61
62 %type <val> program
63
64 %%
65
66 program: { $$ = ""; };
67 ]])
68
69 AT_BISON_CHECK([-o input.c input.y])
70 AT_COMPILE([input.o], [-c input.c])
71
72 AT_CLEANUP
73
74
75
76 ## ------------------------------------- ##
77 ## Early token definitions with --yacc. ##
78 ## ------------------------------------- ##
79
80
81 AT_SETUP([Early token definitions with --yacc])
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
86 AT_DATA_GRAMMAR([input.y],
87 [[%{
88 void yyerror (const char *s);
89 int yylex (void);
90 %}
91
92 %union
93 {
94 int val;
95 };
96 %{
97 #ifndef MY_TOKEN
98 # error "MY_TOKEN not defined."
99 #endif
100 %}
101 %token MY_TOKEN
102 %%
103 exp: MY_TOKEN;
104 %%
105 ]])
106
107 AT_BISON_CHECK([-y -o input.c input.y])
108 AT_COMPILE([input.o], [-c input.c])
109
110 AT_CLEANUP
111
112
113
114 ## ---------------------------------------- ##
115 ## Early token definitions without --yacc. ##
116 ## ---------------------------------------- ##
117
118
119 AT_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
124 AT_DATA_GRAMMAR([input.y],
125 [[%{
126 #include <stdio.h>
127 void yyerror (const char *s);
128 int yylex (void);
129 void print_my_token (void);
130 %}
131
132 %union
133 {
134 int val;
135 };
136 %{
137 void
138 print_my_token (void)
139 {
140 enum yytokentype my_token = MY_TOKEN;
141 printf ("%d\n", my_token);
142 }
143 %}
144 %token MY_TOKEN
145 %%
146 exp: MY_TOKEN;
147 %%
148 ]])
149
150 AT_BISON_CHECK([-o input.c input.y])
151 AT_COMPILE([input.o], [-c input.c])
152
153 AT_CLEANUP
154
155
156
157 ## ---------------- ##
158 ## Braces parsing. ##
159 ## ---------------- ##
160
161
162 AT_SETUP([Braces parsing])
163
164 AT_DATA([input.y],
165 [[/* Bison used to swallow the character after `}'. */
166
167 %%
168 exp: { tests = {{{{{{{{{{}}}}}}}}}}; };
169 %%
170 ]])
171
172 AT_BISON_CHECK([-v -o input.c input.y])
173
174 AT_CHECK([grep 'tests = {{{{{{{{{{}}}}}}}}}};' input.c], 0, [ignore])
175
176 AT_CLEANUP
177
178
179 ## ------------------ ##
180 ## Duplicate string. ##
181 ## ------------------ ##
182
183
184 AT_SETUP([Duplicate string])
185
186 AT_DATA([input.y],
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 %%
195 exp: '(' exp ')' | NUM ;
196 %%
197 ]])
198
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
201 ]])
202
203 AT_CLEANUP
204
205
206 ## ------------------- ##
207 ## Rule Line Numbers. ##
208 ## ------------------- ##
209
210 AT_SETUP([Rule Line Numbers])
211
212 AT_KEYWORDS([report])
213
214 AT_DATA([input.y],
215 [[%%
216 expr:
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
241 };
242 ]])
243
244 AT_BISON_CHECK([-o input.c -v input.y])
245
246 # Check the contents of the report.
247 AT_CHECK([cat input.output], [],
248 [[Grammar
249
250 0 $accept: expr $end
251
252 1 $@1: /* empty */
253
254 2 expr: 'a' $@1 'b'
255
256 3 $@2: /* empty */
257
258 4 expr: $@2 'c'
259
260
261 Terminals, with rules where they appear
262
263 $end (0) 0
264 'a' (97) 2
265 'b' (98) 2
266 'c' (99) 4
267 error (256)
268
269
270 Nonterminals, with rules where they appear
271
272 $accept (6)
273 on left: 0
274 expr (7)
275 on left: 2 4, on right: 0
276 $@1 (8)
277 on left: 1, on right: 2
278 $@2 (9)
279 on left: 3, on right: 4
280
281
282 state 0
283
284 0 $accept: . expr $end
285
286 'a' shift, and go to state 1
287
288 $default reduce using rule 3 ($@2)
289
290 expr go to state 2
291 $@2 go to state 3
292
293
294 state 1
295
296 2 expr: 'a' . $@1 'b'
297
298 $default reduce using rule 1 ($@1)
299
300 $@1 go to state 4
301
302
303 state 2
304
305 0 $accept: expr . $end
306
307 $end shift, and go to state 5
308
309
310 state 3
311
312 4 expr: $@2 . 'c'
313
314 'c' shift, and go to state 6
315
316
317 state 4
318
319 2 expr: 'a' $@1 . 'b'
320
321 'b' shift, and go to state 7
322
323
324 state 5
325
326 0 $accept: expr $end .
327
328 $default accept
329
330
331 state 6
332
333 4 expr: $@2 'c' .
334
335 $default reduce using rule 4 (expr)
336
337
338 state 7
339
340 2 expr: 'a' $@1 'b' .
341
342 $default reduce using rule 2 (expr)
343 ]])
344
345 AT_CLEANUP
346
347
348
349 ## ---------------------- ##
350 ## Mixing %token styles. ##
351 ## ---------------------- ##
352
353
354 AT_SETUP([Mixing %token styles])
355
356 # Taken from the documentation.
357 AT_DATA([input.y],
358 [[%token <operator> OR "||"
359 %token <operator> LE 134 "<="
360 %left OR "<="
361 %%
362 exp: ;
363 %%
364 ]])
365
366 AT_BISON_CHECK([-v -o input.c input.y])
367
368 AT_CLEANUP
369
370
371
372 ## ---------------- ##
373 ## Invalid inputs. ##
374 ## ---------------- ##
375
376
377 AT_SETUP([Invalid inputs])
378
379 AT_DATA([input.y],
380 [[%%
381 ?
382 default: 'a' }
383 %&
384 %a-does-not-exist
385 %-
386 %{
387 ]])
388
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 %{...%}
398 ]])
399
400 AT_CLEANUP
401
402
403 AT_SETUP([Invalid inputs with {}])
404
405 AT_DATA([input.y],
406 [[
407 %destructor
408 %initial-action
409 %lex-param
410 %parse-param
411 %printer
412 %union
413 ]])
414
415 AT_BISON_CHECK([input.y], [1], [],
416 [[input.y:3.1-15: syntax error, unexpected %initial-action, expecting {...}
417 ]])
418
419 AT_CLEANUP
420
421
422
423 ## ------------------- ##
424 ## Token definitions. ##
425 ## ------------------- ##
426
427
428 AT_SETUP([Token definitions])
429
430 # Bison managed, when fed with `%token 'f' "f"' to #define 'f'!
431 AT_DATA_GRAMMAR([input.y],
432 [%{
433 #include <stdlib.h>
434 #include <stdio.h>
435 void yyerror (const char *s);
436 int yylex (void);
437 %}
438 [%error-verbose
439 %token MYEOF 0 "end of file"
440 %token 'a' "a"
441 %token B_TOKEN "b"
442 %token C_TOKEN 'c'
443 %token 'd' D_TOKEN
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??!"
446 %%
447 exp: "a" "\\\'\?\"\a\b\f\n\r\t\v\001\201\x001\x000081??!";
448 %%
449 void
450 yyerror (char const *s)
451 {
452 fprintf (stderr, "%s\n", s);
453 }
454
455 int
456 yylex (void)
457 {
458 static int called;
459 if (called++)
460 abort ();
461 return SPECIAL;
462 }
463
464 int
465 main (void)
466 {
467 return yyparse ();
468 }
469 ]])
470
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
478 ]])
479 AT_COMPILE([input])
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.
485 AT_DATA([experr],
486 [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
487 ]])
488 AT_PARSER_CHECK([./input], 1, [], [experr])
489 AT_CLEANUP
490
491
492
493 ## -------------------- ##
494 ## Characters Escapes. ##
495 ## -------------------- ##
496
497
498 AT_SETUP([Characters Escapes])
499
500 AT_DATA_GRAMMAR([input.y],
501 [%{
502 void yyerror (const char *s);
503 int yylex (void);
504 %}
505 [%%
506 exp:
507 '\'' "\'"
508 | '\"' "\""
509 | '"' "'"
510 ;
511 ]])
512 # Pacify font-lock-mode: "
513
514 AT_BISON_CHECK([-o input.c input.y])
515 AT_COMPILE([input.o], [-c input.c])
516 AT_CLEANUP
517
518
519
520 ## -------------- ##
521 ## Web2c Report. ##
522 ## -------------- ##
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
529 AT_SETUP([Web2c Report])
530
531 AT_KEYWORDS([report])
532
533 AT_DATA([input.y],
534 [[%token undef_id_tok const_id_tok
535
536 %start CONST_DEC_PART
537 \f
538 %%
539 CONST_DEC_PART:
540 CONST_DEC_LIST
541 ;
542
543 CONST_DEC_LIST:
544 CONST_DEC
545 | CONST_DEC_LIST CONST_DEC
546 ;
547
548 CONST_DEC:
549 { } undef_id_tok '=' const_id_tok ';'
550 ;
551 %%
552 ]])
553
554 AT_BISON_CHECK([-v input.y])
555 AT_CHECK([cat input.output], 0,
556 [[Grammar
557
558 0 $accept: CONST_DEC_PART $end
559
560 1 CONST_DEC_PART: CONST_DEC_LIST
561
562 2 CONST_DEC_LIST: CONST_DEC
563 3 | CONST_DEC_LIST CONST_DEC
564
565 4 $@1: /* empty */
566
567 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';'
568
569
570 Terminals, with rules where they appear
571
572 $end (0) 0
573 ';' (59) 5
574 '=' (61) 5
575 error (256)
576 undef_id_tok (258) 5
577 const_id_tok (259) 5
578
579
580 Nonterminals, with rules where they appear
581
582 $accept (7)
583 on left: 0
584 CONST_DEC_PART (8)
585 on left: 1, on right: 0
586 CONST_DEC_LIST (9)
587 on left: 2 3, on right: 1 3
588 CONST_DEC (10)
589 on left: 5, on right: 2 3
590 $@1 (11)
591 on left: 4, on right: 5
592
593
594 state 0
595
596 0 $accept: . CONST_DEC_PART $end
597
598 $default reduce using rule 4 ($@1)
599
600 CONST_DEC_PART go to state 1
601 CONST_DEC_LIST go to state 2
602 CONST_DEC go to state 3
603 $@1 go to state 4
604
605
606 state 1
607
608 0 $accept: CONST_DEC_PART . $end
609
610 $end shift, and go to state 5
611
612
613 state 2
614
615 1 CONST_DEC_PART: CONST_DEC_LIST .
616 3 CONST_DEC_LIST: CONST_DEC_LIST . CONST_DEC
617
618 undef_id_tok reduce using rule 4 ($@1)
619 $default reduce using rule 1 (CONST_DEC_PART)
620
621 CONST_DEC go to state 6
622 $@1 go to state 4
623
624
625 state 3
626
627 2 CONST_DEC_LIST: CONST_DEC .
628
629 $default reduce using rule 2 (CONST_DEC_LIST)
630
631
632 state 4
633
634 5 CONST_DEC: $@1 . undef_id_tok '=' const_id_tok ';'
635
636 undef_id_tok shift, and go to state 7
637
638
639 state 5
640
641 0 $accept: CONST_DEC_PART $end .
642
643 $default accept
644
645
646 state 6
647
648 3 CONST_DEC_LIST: CONST_DEC_LIST CONST_DEC .
649
650 $default reduce using rule 3 (CONST_DEC_LIST)
651
652
653 state 7
654
655 5 CONST_DEC: $@1 undef_id_tok . '=' const_id_tok ';'
656
657 '=' shift, and go to state 8
658
659
660 state 8
661
662 5 CONST_DEC: $@1 undef_id_tok '=' . const_id_tok ';'
663
664 const_id_tok shift, and go to state 9
665
666
667 state 9
668
669 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok . ';'
670
671 ';' shift, and go to state 10
672
673
674 state 10
675
676 5 CONST_DEC: $@1 undef_id_tok '=' const_id_tok ';' .
677
678 $default reduce using rule 5 (CONST_DEC)
679 ]])
680
681 AT_CLEANUP
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 #
696 # static const yytype_uint8 yydefact[] =
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
706 AT_SETUP([Web2c Actions])
707
708 AT_KEYWORDS([report])
709
710 AT_DATA([input.y],
711 [[%%
712 statement: struct_stat;
713 struct_stat: /* empty. */ | if else;
714 if: "if" "const" "then" statement;
715 else: "else" statement;
716 %%
717 ]])
718
719 AT_BISON_CHECK([-v -o input.c input.y])
720
721 # Check only the tables.
722 [sed -n 's/ *$//;/^static const.*\[\] =/,/^}/p' input.c >tables.c]
723
724 AT_CHECK([[cat tables.c]], 0,
725 [[static const yytype_uint8 yytranslate[] =
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,
752 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
753 5, 6
754 };
755 static const yytype_uint8 yyprhs[] =
756 {
757 0, 0, 3, 5, 6, 9, 14
758 };
759 static const yytype_int8 yyrhs[] =
760 {
761 8, 0, -1, 9, -1, -1, 10, 11, -1, 3,
762 4, 5, 8, -1, 6, 8, -1
763 };
764 static const yytype_uint8 yyrline[] =
765 {
766 0, 2, 2, 3, 3, 4, 5
767 };
768 static const char *const yytname[] =
769 {
770 "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
771 "\"else\"", "$accept", "statement", "struct_stat", "if", "else", 0
772 };
773 static const yytype_uint16 yytoknum[] =
774 {
775 0, 256, 257, 258, 259, 260, 261
776 };
777 static const yytype_uint8 yyr1[] =
778 {
779 0, 7, 8, 9, 9, 10, 11
780 };
781 static const yytype_uint8 yyr2[] =
782 {
783 0, 2, 1, 0, 2, 4, 2
784 };
785 static const yytype_uint8 yydefact[] =
786 {
787 3, 0, 0, 2, 0, 0, 1, 3, 4, 3,
788 6, 5
789 };
790 static const yytype_int8 yydefgoto[] =
791 {
792 -1, 2, 3, 4, 8
793 };
794 static const yytype_int8 yypact[] =
795 {
796 -2, -1, 4, -8, 0, 2, -8, -2, -8, -2,
797 -8, -8
798 };
799 static const yytype_int8 yypgoto[] =
800 {
801 -8, -7, -8, -8, -8
802 };
803 static const yytype_uint8 yytable[] =
804 {
805 10, 1, 11, 5, 6, 0, 7, 9
806 };
807 static const yytype_int8 yycheck[] =
808 {
809 7, 3, 9, 4, 0, -1, 6, 5
810 };
811 static const yytype_uint8 yystos[] =
812 {
813 0, 3, 8, 9, 10, 4, 0, 6, 11, 5,
814 8, 8
815 };
816 ]])
817
818 AT_CLEANUP
819
820
821 ## ------------------------- ##
822 ## yycheck Bound Violation. ##
823 ## ------------------------- ##
824
825
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],
834 [%{
835 static int yylex (AT_LALR1_CC_IF([int *], [void]));
836 AT_LALR1_CC_IF([],
837 [#include <stdlib.h>
838 #include <stdio.h>
839 static void yyerror (const char *);])
840 %}
841 $1
842 %token ARROW INVALID NUMBER STRING DATA
843 %defines
844 %verbose
845 %error-verbose
846 /* Grammar follows */
847 %%
848 line: header body
849 ;
850
851 header: '<' from ARROW to '>' type ':'
852 | '<' ARROW to '>' type ':'
853 | ARROW to type ':'
854 | type ':'
855 | '<' '>'
856 ;
857
858 from: DATA
859 | STRING
860 | INVALID
861 ;
862
863 to: DATA
864 | STRING
865 | INVALID
866 ;
867
868 type: DATA
869 | STRING
870 | INVALID
871 ;
872
873 body: /* empty */
874 | body member
875 ;
876
877 member: STRING
878 | DATA
879 | '+' NUMBER
880 | '-' NUMBER
881 | NUMBER
882 | INVALID
883 ;
884 %%
885 AT_LALR1_CC_IF(
886 [/* A C++ error reporting function. */
887 void
888 yy::parser::error (const location&, const std::string& m)
889 {
890 std::cerr << m << std::endl;
891 }
892
893 int
894 yyparse ()
895 {
896 yy::parser parser;
897 #if YYDEBUG
898 parser.set_debug_level (YYDEBUG);
899 #endif
900 return parser.parse ();
901 }
902 ],
903 [static void
904 yyerror (const char *s)
905 {
906 fprintf (stderr, "%s\n", s);
907 }])
908
909 static int
910 yylex (AT_LALR1_CC_IF([int *lval], [void]))
911 [{
912 static int const tokens[] =
913 {
914 ':', -1
915 };
916 static size_t toknum;
917 ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[
918 if (! (toknum < sizeof tokens / sizeof *tokens))
919 abort ();
920 return tokens[toknum++];
921 }]
922
923 int
924 main (void)
925 {
926 return yyparse ();
927 }
928 ])
929 ])# _AT_DATA_DANCER_Y
930
931
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 ':'
943 ])
944 AT_BISON_OPTION_POPDEFS
945 AT_CLEANUP
946 ])
947
948 AT_CHECK_DANCER()
949 AT_CHECK_DANCER([%glr-parser])
950 AT_CHECK_DANCER([%skeleton "lalr1.cc"])
951
952
953 ## ------------------------------------------ ##
954 ## Diagnostic that expects two alternatives. ##
955 ## ------------------------------------------ ##
956
957
958 # _AT_DATA_EXPECT2_Y(BISON-OPTIONS)
959 # --------------------------------
960 m4_define([_AT_DATA_EXPECT2_Y],
961 [AT_DATA_GRAMMAR([expect2.y],
962 [%{
963 static int yylex (AT_LALR1_CC_IF([int *], [void]));
964 AT_LALR1_CC_IF([],
965 [#include <stdio.h>
966 #include <stdlib.h>
967 static void yyerror (const char *);])
968 %}
969 $1
970 %defines
971 %error-verbose
972 %token A 1000
973 %token B
974
975 %%
976 program: /* empty */
977 | program e ';'
978 | program error ';';
979
980 e: e '+' t | t;
981 t: A | B;
982
983 %%
984 AT_LALR1_CC_IF(
985 [/* A C++ error reporting function. */
986 void
987 yy::parser::error (const location&, const std::string& m)
988 {
989 std::cerr << m << std::endl;
990 }
991
992 int
993 yyparse ()
994 {
995 yy::parser parser;
996 return parser.parse ();
997 }
998 ],
999 [static void
1000 yyerror (const char *s)
1001 {
1002 fprintf (stderr, "%s\n", s);
1003 }])
1004
1005 static int
1006 yylex (AT_LALR1_CC_IF([int *lval], [void]))
1007 [{
1008 static int const tokens[] =
1009 {
1010 1000, '+', '+', -1
1011 };
1012 static size_t toknum;
1013 ]AT_LALR1_CC_IF([*lval = 0; /* Pacify GCC. */])[
1014 if (! (toknum < sizeof tokens / sizeof *tokens))
1015 abort ();
1016 return tokens[toknum++];
1017 }]
1018
1019 int
1020 main (void)
1021 {
1022 return yyparse ();
1023 }
1024 ])
1025 ])# _AT_DATA_EXPECT2_Y
1026
1027
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
1039 ])
1040 AT_BISON_OPTION_POPDEFS
1041 AT_CLEANUP
1042 ])
1043
1044 AT_CHECK_EXPECT2()
1045 AT_CHECK_EXPECT2([%glr-parser])
1046 AT_CHECK_EXPECT2([%skeleton "lalr1.cc"])
1047
1048
1049
1050 ## --------------------------------------------- ##
1051 ## Braced code in declaration in rules section. ##
1052 ## --------------------------------------------- ##
1053
1054 AT_SETUP([Braced code in declaration in rules section])
1055
1056 # Bison once mistook braced code in a declaration in the rules section to be a
1057 # rule action.
1058
1059 AT_DATA_GRAMMAR([input.y],
1060 [[%{
1061 #include <stdio.h>
1062 static void yyerror (char const *msg);
1063 static int yylex (void);
1064 %}
1065
1066 %error-verbose
1067
1068 %%
1069
1070 start:
1071 {
1072 printf ("Bison would once convert this action to a midrule because of the"
1073 " subsequent braced code.\n");
1074 }
1075 ;
1076
1077 %destructor { fprintf (stderr, "DESTRUCTOR\n"); } 'a';
1078 %printer { fprintf (yyoutput, "PRINTER"); } 'a';
1079
1080 %%
1081
1082 static void
1083 yyerror (char const *msg)
1084 {
1085 fprintf (stderr, "%s\n", msg);
1086 }
1087
1088 static int
1089 yylex (void)
1090 {
1091 return 'a';
1092 }
1093
1094 int
1095 main (void)
1096 {
1097 yydebug = 1;
1098 return !yyparse ();
1099 }
1100 ]])
1101
1102 AT_BISON_CHECK([-t -o input.c input.y])
1103 AT_COMPILE([input])
1104 AT_PARSER_CHECK([./input], 0,
1105 [[Bison would once convert this action to a midrule because of the subsequent braced code.
1106 ]],
1107 [[Starting parse
1108 Entering state 0
1109 Reducing stack by rule 1 (line 20):
1110 -> $$ = nterm start ()
1111 Stack now 0
1112 Entering state 1
1113 Reading a token: Next token is token 'a' (PRINTER)
1114 syntax error, unexpected 'a', expecting $end
1115 Error: popping nterm start ()
1116 Stack now 0
1117 Cleanup: discarding lookahead token 'a' (PRINTER)
1118 DESTRUCTOR
1119 Stack now 0
1120 ]])
1121
1122 AT_CLEANUP
1123
1124
1125
1126 ## --------------------------------- ##
1127 ## String alias declared after use. ##
1128 ## --------------------------------- ##
1129
1130 AT_SETUP([String alias declared after use])
1131
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.
1136
1137 AT_DATA([input.y],
1138 [[%%
1139 start: 'a' "A" 'b';
1140 %token 'a' "A";
1141 ]])
1142
1143 AT_BISON_CHECK([-t -o input.c input.y])
1144
1145 AT_CLEANUP
1146
1147
1148
1149 ## -------------------------------- ##
1150 ## Extra lookahead sets in report. ##
1151 ## -------------------------------- ##
1152
1153 AT_SETUP([[Extra lookahead sets in report]])
1154
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.
1161
1162 AT_DATA([[input.y]],
1163 [[%%
1164 start: a | 'a' a 'a' ;
1165 a: 'a' ;
1166 ]])
1167
1168 AT_BISON_CHECK([[--report=all input.y]])
1169 AT_CHECK([[sed -n '/^state 1$/,/^state 2$/p' input.output]], [[0]],
1170 [[state 1
1171
1172 2 start: 'a' . a 'a'
1173 3 a: . 'a'
1174 3 | 'a' . [$end]
1175
1176 'a' shift, and go to state 4
1177
1178 $default reduce using rule 3 (a)
1179
1180 a go to state 5
1181
1182
1183 state 2
1184 ]])
1185
1186 AT_CLEANUP
1187
1188
1189
1190 ## ---------------------------------------- ##
1191 ## Token number in precedence declaration. ##
1192 ## ---------------------------------------- ##
1193
1194 AT_SETUP([[Token number in precedence declaration]])
1195
1196 # POSIX says token numbers can be declared in %left, %right, and %nonassoc, but
1197 # we lost this in Bison 1.50.
1198
1199 AT_DATA_GRAMMAR([input.y],
1200 [[%{
1201 #include <stdio.h>
1202 void yyerror (char const *);
1203 int yylex (void);
1204 %}
1205
1206 %error-verbose
1207 %left TK1 1 TK2 2 "tok alias" 3
1208
1209 %%
1210
1211 start: TK1 sr_conflict "tok alias" ;
1212
1213 sr_conflict:
1214 TK2
1215 | TK2 "tok alias"
1216 ;
1217
1218 %%
1219
1220 void
1221 yyerror (char const *msg)
1222 {
1223 fprintf (stderr, "%s\n", msg);
1224 }
1225
1226 int
1227 yylex (void)
1228 {
1229 static int const input[] = { 1, 2, 3, 0 };
1230 static int const *inputp = input;
1231 return *inputp++;
1232 }
1233
1234 int
1235 main (void)
1236 {
1237 return yyparse ();
1238 }
1239 ]])
1240
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"
1243 ]])
1244 AT_COMPILE([[input]])
1245 AT_PARSER_CHECK([[./input]])
1246
1247 AT_CLEANUP
1248
1249
1250
1251 ## --------------------------- ##
1252 ## parse-gram.y: LALR = IELR. ##
1253 ## --------------------------- ##
1254
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.
1257
1258 AT_SETUP([[parse-gram.y: LALR = IELR]])
1259
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]])
1264 [mv input.c lalr.c]
1265 AT_BISON_CHECK([[-o input.c -Dlr.type=ielr input.y]])
1266 [mv input.c ielr.c]
1267 AT_CHECK([[diff -u lalr.c ielr.c]])
1268
1269 AT_CLEANUP
1270
1271
1272
1273 ## --------------------------------------- ##
1274 ## %error-verbose and YYSTACK_USE_ALLOCA. ##
1275 ## --------------------------------------- ##
1276
1277 AT_SETUP([[%error-verbose and YYSTACK_USE_ALLOCA]])
1278
1279 AT_DATA_GRAMMAR([input.y],
1280 [[%code {
1281 #include <stdio.h>
1282 void yyerror (char const *);
1283 int yylex (void);
1284 #define YYSTACK_USE_ALLOCA 1
1285 }
1286
1287 %error-verbose
1288
1289 %%
1290
1291 start: check syntax_error syntax_error ;
1292
1293 check:
1294 {
1295 if (128 < sizeof yymsgbuf)
1296 {
1297 fprintf (stderr,
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");
1304 YYABORT;
1305 }
1306 }
1307 ;
1308
1309 // Induce a syntax error message whose total length is more than
1310 // sizeof yymsgbuf in yyparse. Each token here is 64 bytes.
1311 syntax_error:
1312 "123456789112345678921234567893123456789412345678951234567896123A"
1313 | "123456789112345678921234567893123456789412345678951234567896123B"
1314 | error 'a' 'b' 'c'
1315 ;
1316
1317 %%
1318
1319 void
1320 yyerror (char const *msg)
1321 {
1322 fprintf (stderr, "%s\n", msg);
1323 }
1324
1325 int
1326 yylex (void)
1327 {
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";
1332 return *input++;
1333 }
1334
1335 int
1336 main (void)
1337 {
1338 return yyparse ();
1339 }
1340 ]])
1341
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
1347 ]])
1348
1349 AT_CLEANUP
1350
1351
1352
1353 ## ------------------------- ##
1354 ## %error-verbose overflow. ##
1355 ## ------------------------- ##
1356
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.
1364
1365 AT_SETUP([[%error-verbose overflow]])
1366
1367 AT_DATA_GRAMMAR([input.y],
1368 [[%code {
1369 #include <stdio.h>
1370 void yyerror (char const *);
1371 int yylex (void);
1372
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
1376
1377 /* Bring in malloc and set EXIT_SUCCESS so yacc.c doesn't try to
1378 provide a malloc prototype using our YYSIZE_T. */
1379 #include <stdlib.h>
1380 #ifndef EXIT_SUCCESS
1381 # define EXIT_SUCCESS 0
1382 #endif
1383
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
1388 }
1389
1390 %error-verbose
1391
1392 %%
1393
1394 start: syntax_error1 check syntax_error2 ;
1395
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.
1399 syntax_error1:
1400 "123456789112345678921234567893123456789412345678951234567896123A"
1401 | "123456789112345678921234567893123456789412345678951234567896123B"
1402 | "123456789112345678921234567893123456789412345678951234567896123C"
1403 | error 'a' 'b' 'c'
1404 ;
1405
1406 check:
1407 {
1408 if (yymsg_alloc != YYSTACK_ALLOC_MAXIMUM
1409 || YYSTACK_ALLOC_MAXIMUM != YYSIZE_MAXIMUM
1410 || YYSIZE_MAXIMUM != 255)
1411 {
1412 fprintf (stderr,
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);
1421 YYABORT;
1422 }
1423 }
1424 ;
1425
1426 // Now overflow.
1427 syntax_error2:
1428 "123456789112345678921234567893123456789412345678951234567896123A"
1429 | "123456789112345678921234567893123456789412345678951234567896123B"
1430 | "123456789112345678921234567893123456789412345678951234567896123C"
1431 | "123456789112345678921234567893123456789412345678951234567896123D"
1432 | "123456789112345678921234567893123456789412345678951234567896123E"
1433 ;
1434
1435 %%
1436
1437 void
1438 yyerror (char const *msg)
1439 {
1440 fprintf (stderr, "%s\n", msg);
1441 }
1442
1443 int
1444 yylex (void)
1445 {
1446 /* Induce two syntax error messages (which requires full error
1447 recovery by shifting 3 tokens). */
1448 static char const *input = "abc";
1449 return *input++;
1450 }
1451
1452 int
1453 main (void)
1454 {
1455 /* Push parsers throw away the message buffer between tokens, so skip
1456 this test under maintainer-push-check. */
1457 if (YYPUSH)
1458 return 77;
1459 return yyparse ();
1460 }
1461 ]])
1462
1463 AT_BISON_CHECK([[-o input.c input.y]])
1464
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]])
1471
1472 AT_PARSER_CHECK([[./input]], [[2]], [],
1473 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
1474 syntax error
1475 memory exhausted
1476 ]])
1477
1478 AT_CLEANUP
1479
1480
1481
1482 ## ------------------------ ##
1483 ## LAC: Exploratory stack. ##
1484 ## ------------------------ ##
1485
1486 AT_SETUP([[LAC: Exploratory stack]])
1487
1488 m4_pushdef([AT_LAC_CHECK], [
1489
1490 AT_BISON_OPTION_PUSHDEFS([$1])
1491
1492 AT_DATA_GRAMMAR([input.y],
1493 [[%code {
1494 #include <stdio.h>
1495 void yyerror (char const *);
1496 int yylex (]AT_PURE_IF([[YYSTYPE *]], [[void]])[);
1497 }
1498
1499 ]$1[
1500 %error-verbose
1501 %token 'c'
1502
1503 %%
1504
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 ;
1508 // ^ ^ ^
1509 // LAC reallocs
1510
1511 A: 'a' | /*empty*/ { printf ("inconsistent default reduction\n"); } ;
1512 B: 'b' ;
1513 C: /*empty*/ { printf ("consistent default reduction\n"); } ;
1514
1515 %%
1516
1517 void
1518 yyerror (char const *msg)
1519 {
1520 fprintf (stderr, "%s\n", msg);
1521 }
1522
1523 int
1524 yylex (]AT_PURE_IF([[YYSTYPE *v]], [[void]])[)
1525 {
1526 static char const *input = "bbbbc";]AT_PURE_IF([[
1527 *v = 0;]])[
1528 return *input++;
1529 }
1530
1531 int
1532 main (void)
1533 {
1534 yydebug = 1;
1535 return yyparse ();
1536 }
1537 ]])
1538
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
1543 ]])
1544 AT_COMPILE([[input]])
1545 AT_PARSER_CHECK([[./input > stdout.txt 2> stderr.txt]], [[1]])
1546
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'
1551 ]])
1552
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]])
1557
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]])
1562
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]])
1567
1568 AT_BISON_OPTION_POPDEFS
1569 ])
1570
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]])
1575
1576 m4_popdef([AT_LAC_CHECK])
1577
1578 AT_CLEANUP
1579
1580
1581
1582 ## ------------------------ ##
1583 ## LAC: Memory exhaustion. ##
1584 ## ------------------------ ##
1585
1586 AT_SETUP([[LAC: Memory exhaustion]])
1587
1588 m4_pushdef([AT_LAC_CHECK], [
1589
1590 AT_DATA_GRAMMAR([input.y],
1591 [[%code {
1592 #include <stdio.h>
1593 void yyerror (char const *);
1594 int yylex (void);
1595 #define YYMAXDEPTH 8
1596 }
1597
1598 %error-verbose
1599
1600 %%
1601
1602 S: A A A A A A A A A ;
1603 A: /*empty*/ | 'a' ;
1604
1605 %%
1606
1607 void
1608 yyerror (char const *msg)
1609 {
1610 fprintf (stderr, "%s\n", msg);
1611 }
1612
1613 int
1614 yylex (void)
1615 {
1616 static char const *input = "]$1[";
1617 return *input++;
1618 }
1619
1620 int
1621 main (void)
1622 {
1623 yydebug = 1;
1624 return yyparse ();
1625 }
1626 ]])
1627
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
1631 ]])
1632 AT_COMPILE([[input]])
1633
1634 ])
1635
1636 # Check for memory exhaustion during parsing.
1637 AT_LAC_CHECK([[]])
1638 AT_PARSER_CHECK([[./input]], [[2]], [[]],
1639 [[Starting parse
1640 Entering state 0
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)
1644 memory exhausted
1645 Cleanup: discarding lookahead token $end ()
1646 Stack now 0
1647 ]])
1648
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]], [[]],
1653 [[Starting parse
1654 Entering state 0
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)
1660 syntax error
1661 memory exhausted
1662 Cleanup: discarding lookahead token $undefined ()
1663 Stack now 0
1664 ]])
1665
1666 m4_popdef([AT_LAC_CHECK])
1667
1668 AT_CLEANUP