]> git.saurik.com Git - bison.git/blame - tests/torture.at
tests: do not use grep -q
[bison.git] / tests / torture.at
CommitLineData
6d7d248e 1# Torturing Bison. -*- Autotest -*-
6e30ede8 2
7d6bad19 3# Copyright (C) 2001-2002, 2004-2007, 2009-2013 Free Software
ea0a7676 4# Foundation, Inc.
6d7d248e 5
f16b0819 6# This program is free software: you can redistribute it and/or modify
6d7d248e 7# it under the terms of the GNU General Public License as published by
f16b0819
PE
8# the Free Software Foundation, either version 3 of the License, or
9# (at your option) any later version.
10#
6d7d248e
AD
11# This program is distributed in the hope that it will be useful,
12# but WITHOUT ANY WARRANTY; without even the implied warranty of
13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14# GNU General Public License for more details.
f16b0819 15#
6d7d248e 16# You should have received a copy of the GNU General Public License
f16b0819 17# along with this program. If not, see <http://www.gnu.org/licenses/>.
6d7d248e
AD
18
19AT_BANNER([[Torture Tests.]])
20
21
49e794c5 22# AT_INCREASE_DATA_SIZE(SIZE)
f79b4f5c 23# ---------------------------
49e794c5
PE
24# Try to increase the data size to SIZE KiB if possible.
25m4_define([AT_INCREASE_DATA_SIZE],
26[data_limit=`(ulimit -S -d) 2>/dev/null`
27case $data_limit in
28[[0-9]]*)
29 if test "$data_limit" -lt $1; then
f79b4f5c 30 AT_CHECK([ulimit -S -d $1 || exit 77])
49e794c5
PE
31 ulimit -S -d $1
32 fi
33esac])
34
35
817e9f41
AD
36## ------------------------------------- ##
37## Creating a large artificial grammar. ##
38## ------------------------------------- ##
39
40# AT_DATA_TRIANGULAR_GRAMMAR(FILE-NAME, SIZE)
41# -------------------------------------------
42# Create FILE-NAME, containing a self checking parser for a huge
43# triangular grammar.
817e9f41 44m4_define([AT_DATA_TRIANGULAR_GRAMMAR],
71c7e24f
AD
45[AT_BISON_OPTION_PUSHDEFS
46AT_DATA([[gengram.pl]],
817e9f41
AD
47[[#! /usr/bin/perl -w
48
49use strict;
50my $max = $ARGV[0] || 10;
51
52print <<EOF;
9501dc6e 53]AT_DATA_GRAMMAR_PROLOGUE[
8f3596a6
AD
54%error-verbose
55%debug
817e9f41
AD
56%{
57#include <stdio.h>
58#include <stdlib.h>
77519a7d 59#include <assert.h>
290a8ff2 60#define MAX $max
55f48c48
AD
61]AT_YYLEX_DECLARE[
62]AT_YYERROR_DECLARE[
817e9f41
AD
63%}
64%union
65{
66 int val;
67};
68
69%token END "end"
70%type <val> exp input
71EOF
72
73for my $size (1 .. $max)
74 {
e9955c83 75 print "%token t$size $size \"$size\"\n";
817e9f41
AD
76 };
77
78print <<EOF;
79%%
80input:
77519a7d
AD
81 exp { assert (\@S|@1 == 0); \$\$ = \@S|@1; }
82| input exp { assert (\@S|@2 == \@S|@1 + 1); \$\$ = \@S|@2; }
817e9f41
AD
83;
84
85exp:
86 END
87 { \$\$ = 0; }
88EOF
89
90for my $size (1 .. $max)
91 {
92 use Text::Wrap;
93 print wrap ("| ", " ",
975bdced
AD
94 (map { "\"$_\"" } (1 .. $size)),
95 " END \n"),
96 " { \$\$ = $size; }\n";
817e9f41
AD
97 };
98print ";\n";
99
290a8ff2 100print <<\EOF;
817e9f41 101%%
290a8ff2 102]AT_YYERROR_DEFINE[
817e9f41
AD
103static int
104yylex (void)
105{
106 static int inner = 1;
107 static int outer = 0;
290a8ff2 108 if (outer > MAX)
817e9f41
AD
109 return 0;
110 else if (inner > outer)
111 {
112 inner = 1;
113 ++outer;
114 return END;
115 }
23c5a174 116 return inner++;
817e9f41 117}
3ef9fa8f 118]AT_MAIN_DEFINE[
817e9f41
AD
119EOF
120]])
71c7e24f 121AT_BISON_OPTION_POPDEFS
817e9f41 122
c955769a 123AT_CHECK([$PERL -w ./gengram.pl $2 || exit 77], 0, [stdout])
817e9f41
AD
124mv stdout $1
125])
126
127
128## -------------- ##
129## Big triangle. ##
130## -------------- ##
131
817e9f41
AD
132AT_SETUP([Big triangle])
133
355e7c1c
AD
134# I have been able to go up to 2000 on my machine.
135# I tried 3000, a 29Mb grammar file, but then my system killed bison.
e9955c83
AD
136# With 500 and the new parser, which consume far too much memory,
137# it gets killed too. Of course the parser is to be cleaned.
138AT_DATA_TRIANGULAR_GRAMMAR([input.y], [200])
da730230 139AT_BISON_CHECK_NO_XML([-v -o input.c input.y])
1154cced
AD
140AT_COMPILE([input])
141AT_PARSER_CHECK([./input])
817e9f41
AD
142
143AT_CLEANUP
144
145
146
62a3e4f0
AD
147# AT_DATA_HORIZONTAL_GRAMMAR(FILE-NAME, SIZE)
148# -------------------------------------------
149# Create FILE-NAME, containing a self checking parser for a huge
150# horizontal grammar.
62a3e4f0 151m4_define([AT_DATA_HORIZONTAL_GRAMMAR],
71c7e24f
AD
152[AT_BISON_OPTION_PUSHDEFS
153AT_DATA([[gengram.pl]],
62a3e4f0
AD
154[[#! /usr/bin/perl -w
155
156use strict;
157my $max = $ARGV[0] || 10;
158
159print <<EOF;
9501dc6e 160]AT_DATA_GRAMMAR_PROLOGUE[
8f3596a6
AD
161%error-verbose
162%debug
62a3e4f0
AD
163%{
164#include <stdio.h>
165#include <stdlib.h>
290a8ff2 166#define MAX $max
55f48c48
AD
167]AT_YYLEX_DECLARE[
168]AT_YYERROR_DECLARE[
62a3e4f0 169%}
62a3e4f0 170
8f3596a6
AD
171%token
172EOF
62a3e4f0
AD
173for my $size (1 .. $max)
174 {
8f3596a6 175 print " t$size $size \"$size\"\n";
62a3e4f0
AD
176 };
177
178print <<EOF;
8f3596a6 179
62a3e4f0
AD
180%%
181EOF
182
183use Text::Wrap;
184print
185 wrap ("exp: ", " ",
975bdced 186 (map { "\"$_\"" } (1 .. $max)), ";"),
62a3e4f0
AD
187 "\n";
188
290a8ff2 189print <<\EOF;
62a3e4f0 190%%
77519a7d 191#include <assert.h>
290a8ff2 192]AT_YYERROR_DEFINE[
62a3e4f0
AD
193static int
194yylex (void)
195{
196 static int counter = 1;
290a8ff2 197 if (counter <= MAX)
cf806753 198 return counter++;
77519a7d 199 assert (counter++ == MAX + 1);
cf806753 200 return 0;
62a3e4f0 201}
3ef9fa8f 202]AT_MAIN_DEFINE[
62a3e4f0
AD
203EOF
204]])
205
c955769a 206AT_CHECK([$PERL -w ./gengram.pl $2 || exit 77], 0, [stdout])
62a3e4f0 207mv stdout $1
71c7e24f 208AT_BISON_OPTION_POPDEFS
62a3e4f0
AD
209])
210
211
212## ---------------- ##
213## Big horizontal. ##
214## ---------------- ##
215
216AT_SETUP([Big horizontal])
217
218# I have been able to go up to 10000 on my machine, but I had to
219# increase the maximum stack size (* 100). It gave:
220#
221# input.y 263k
222# input.tab.c 1.3M
223# input 453k
224#
225# gengram.pl 10000 0.70s user 0.01s sys 99% cpu 0.711 total
226# bison input.y 730.56s user 0.53s sys 99% cpu 12:12.34 total
227# gcc -Wall input.tab.c -o input 5.81s user 0.20s sys 100% cpu 6.01 total
228# ./input 0.00s user 0.01s sys 108% cpu 0.01 total
229#
230AT_DATA_HORIZONTAL_GRAMMAR([input.y], [1000])
49e794c5
PE
231
232# GNU m4 requires about 70 MiB for this test on a 32-bit host.
233# Ask for 200 MiB, which should be plenty even on a 64-bit host.
234AT_INCREASE_DATA_SIZE(204000)
235
da730230 236AT_BISON_CHECK_NO_XML([-v -o input.c input.y])
1154cced
AD
237AT_COMPILE([input])
238AT_PARSER_CHECK([./input])
62a3e4f0
AD
239
240AT_CLEANUP
241
242
243
742e4900 244# AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR(FILE-NAME, SIZE)
8f3596a6 245# --------------------------------------------------
39ceb25b 246# Create FILE-NAME, containing a self checking parser for a grammar
742e4900
JD
247# requiring SIZE lookahead tokens.
248m4_define([AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR],
71c7e24f
AD
249[AT_BISON_OPTION_PUSHDEFS
250AT_DATA([[gengram.pl]],
39ceb25b
AD
251[[#! /usr/bin/perl -w
252
253use strict;
254use Text::Wrap;
255my $max = $ARGV[0] || 10;
256
257print <<EOF;
8f3596a6
AD
258%error-verbose
259%debug
39ceb25b 260%{
6ee95cd0 261]AT_DATA_SOURCE_PROLOGUE[
8f3596a6
AD
262# include <stdio.h>
263# include <stdlib.h>
264# include <assert.h>
290a8ff2 265# define MAX $max
55f48c48
AD
266]AT_YYLEX_DECLARE[
267]AT_YYERROR_DECLARE[
39ceb25b
AD
268%}
269%union
270{
271 int val;
272};
273
274%type <val> input exp
275%token token
276EOF
277
278print
279 wrap ("%type <val> ",
975bdced
AD
280 " ",
281 map { "n$_" } (1 .. $max)),
39ceb25b
AD
282 "\n";
283
8f3596a6 284print "%token\n";
39ceb25b
AD
285for my $count (1 .. $max)
286 {
8f3596a6 287 print " t$count $count \"$count\"\n";
39ceb25b
AD
288 };
289
290print <<EOF;
291%%
292input:
8f3596a6
AD
293 exp { assert (\@S|@1 == 1); \$\$ = \@S|@1; }
294| input exp { assert (\@S|@2 == \@S|@1 + 1); \$\$ = \@S|@2; }
39ceb25b
AD
295;
296
297exp:
8f3596a6 298 n1 "1" { assert (\@S|@1 == 1); \@S|@\@S|@ = \@S|@1; }
39ceb25b
AD
299EOF
300
301for my $count (2 .. $max)
302 {
8f3596a6 303 print "| n$count \"$count\" { assert (\@S|@1 == $count); \@S|@\@S|@ = \@S|@1; }\n";
39ceb25b
AD
304 };
305print ";\n";
306
307for my $count (1 .. $max)
308 {
e9955c83 309 print "n$count: token { \$\$ = $count; };\n";
39ceb25b
AD
310 };
311
290a8ff2 312print <<\EOF;
39ceb25b 313%%
290a8ff2 314]AT_YYERROR_DEFINE[
39ceb25b
AD
315static int
316yylex (void)
317{
318 static int return_token = 1;
319 static int counter = 1;
290a8ff2 320 if (counter > MAX)
cf806753 321 {
77519a7d 322 assert (counter++ == MAX + 1);
cf806753
PE
323 return 0;
324 }
39ceb25b
AD
325 if (return_token)
326 {
327 return_token = 0;
328 return token;
329 }
330 return_token = 1;
331 return counter++;
332}
333
3ef9fa8f 334]AT_MAIN_DEFINE[
39ceb25b
AD
335EOF
336]])
337
c955769a 338AT_CHECK([$PERL -w ./gengram.pl $2 || exit 77], 0, [stdout])
39ceb25b 339mv stdout $1
71c7e24f 340AT_BISON_OPTION_POPDEFS
39ceb25b
AD
341])
342
343
8dd162d3 344## ------------------------ ##
7d596384 345## Many lookahead tokens. ##
8dd162d3 346## ------------------------ ##
39ceb25b 347
742e4900 348AT_SETUP([Many lookahead tokens])
39ceb25b 349
742e4900 350AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR([input.y], [1000])
49e794c5
PE
351
352# GNU m4 requires about 70 MiB for this test on a 32-bit host.
353# Ask for 200 MiB, which should be plenty even on a 64-bit host.
354AT_INCREASE_DATA_SIZE(204000)
355
da730230 356AT_BISON_CHECK([-v -o input.c input.y])
1154cced
AD
357AT_COMPILE([input])
358AT_PARSER_CHECK([./input])
39ceb25b
AD
359
360AT_CLEANUP
361
362
363
7d596384
JD
364# AT_DATA_STACK_TORTURE(C-PROLOGUE, [BISON-DECLS])
365# ------------------------------------------------
6d7d248e
AD
366# A parser specialized in torturing the stack size.
367m4_define([AT_DATA_STACK_TORTURE],
55f48c48
AD
368[AT_BISON_OPTION_PUSHDEFS([$2])
369# A grammar of parens growing the stack thanks to right recursion.
6d7d248e 370# exp:
6ee95cd0 371AT_DATA_GRAMMAR([input.y],
6d7d248e 372[[%{
04098407
PE
373#include <errno.h>
374#include <limits.h>
6d7d248e
AD
375#include <stdio.h>
376#include <stdlib.h>
6d7d248e 377]$1[
55f48c48
AD
378 ]AT_YYLEX_DECLARE[
379 ]AT_YYERROR_DECLARE[
6d7d248e 380%}
7d596384 381]$2[
04d843a2 382%error-verbose
6d7d248e
AD
383%debug
384%token WAIT_FOR_EOF
385%%
386exp: WAIT_FOR_EOF exp | ;
387%%
55f48c48 388]AT_YYERROR_DEFINE[
77519a7d 389#include <assert.h>
6d7d248e
AD
390static int
391yylex (void)
392{
77519a7d 393 assert (0 <= yylval);
6d7d248e
AD
394 if (yylval--)
395 return WAIT_FOR_EOF;
396 else
397 return EOF;
398}
399
e411069e
AD
400/* Return argv[1] as an int. */
401static int
402get_args (int argc, const char **argv)
6d7d248e 403{
e411069e 404 int res;
04098407 405 char *endp;
77519a7d 406 assert (argc == 2);
e411069e 407 res = strtol (argv[1], &endp, 10);
77519a7d 408 assert (argv[1] != endp);
e411069e
AD
409 assert (0 <= res);
410 assert (res <= INT_MAX);
77519a7d 411 assert (errno != ERANGE);
e411069e
AD
412 return res;
413}
414
415int
416main (int argc, const char **argv)
417{
418 YYSTYPE yylval_init = get_args (argc, argv);
54dccdb2 419 int status = 0;
e411069e 420 int count;
ae62d0fc 421]m4_bmatch([$2], [api.push-pull both],
e411069e
AD
422[[ yypstate *ps = yypstate_new ();
423]])[ yydebug = 1;
424 for (count = 0; count < 2; ++count)
425 {
426 int new_status;
427 yylval = yylval_init;
428 new_status = ]m4_bmatch([$2], [api.push-pull both],
429 [[yypull_parse (ps)]],
430 [[yyparse ()]])[;
431 if (count == 0)
7d596384 432 status = new_status;
e411069e
AD
433 else
434 assert (new_status == status);
435 }]m4_bmatch([$2], [api.push-pull both],[[
436 yypstate_delete (ps);]])[
437 return status;
6d7d248e
AD
438}
439]])
55f48c48 440AT_BISON_OPTION_POPDEFS([$2])
da730230 441AT_BISON_CHECK([-o input.c input.y])
1154cced 442AT_COMPILE([input])
6d7d248e
AD
443])
444
445
446## -------------------------------------- ##
447## Exploding the Stack Size with Alloca. ##
448## -------------------------------------- ##
449
450AT_SETUP([Exploding the Stack Size with Alloca])
451
7d596384 452m4_pushdef([AT_USE_ALLOCA], [[
0d50976f 453#if (defined __GNUC__ || defined __BUILTIN_VA_ARG_INCR \
62c4328e 454 || defined _AIX || defined _MSC_VER || defined _ALLOCA_H)
577d7c33
PE
455# define YYSTACK_USE_ALLOCA 1
456#endif
457]])
6d7d248e 458
7d596384
JD
459AT_DATA_STACK_TORTURE([AT_USE_ALLOCA])
460
6d7d248e 461# Below the limit of 200.
e0ac9b4b
JD
462AT_PARSER_CHECK([./input 20], 0, [], [ignore],
463 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
6d7d248e 464# Two enlargements: 2 * 2 * 200.
e0ac9b4b
JD
465AT_PARSER_CHECK([./input 900], 0, [], [ignore],
466 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
6d7d248e
AD
467# Fails: beyond the limit of 10,000 (which we don't reach anyway since we
468# multiply by two starting at 200 => 5120 is the last possible).
e0ac9b4b
JD
469AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
470 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
6d7d248e 471
78143faa
JD
472# The push parser can't use alloca since the stacks can't be locals. This test
473# just helps guarantee we don't let the YYSTACK_USE_ALLOCA feature affect
474# push parsers.
7d596384 475AT_DATA_STACK_TORTURE([AT_USE_ALLOCA],
f37495f6 476[[%define api.push-pull both
7d596384 477]])
e0ac9b4b
JD
478AT_PARSER_CHECK([./input 20], 0, [], [ignore],
479 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
480AT_PARSER_CHECK([./input 900], 0, [], [ignore],
481 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
482AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
483 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
7d596384
JD
484
485m4_popdef([AT_USE_ALLOCA])
486
6d7d248e
AD
487AT_CLEANUP
488
489
490
491
492## -------------------------------------- ##
493## Exploding the Stack Size with Malloc. ##
494## -------------------------------------- ##
495
496AT_SETUP([Exploding the Stack Size with Malloc])
497
7d596384
JD
498m4_pushdef([AT_USE_ALLOCA], [[#define YYSTACK_USE_ALLOCA 0]])
499
500AT_DATA_STACK_TORTURE([AT_USE_ALLOCA])
6d7d248e
AD
501
502# Below the limit of 200.
e0ac9b4b
JD
503AT_PARSER_CHECK([./input 20], 0, [], [ignore],
504 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
6d7d248e 505# Two enlargements: 2 * 2 * 200.
e0ac9b4b
JD
506AT_PARSER_CHECK([./input 900], 0, [], [ignore],
507 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
6d7d248e
AD
508# Fails: beyond the limit of 10,000 (which we don't reach anyway since we
509# multiply by two starting at 200 => 5120 is the possible).
e0ac9b4b
JD
510AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
511 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
6d7d248e 512
7d596384 513AT_DATA_STACK_TORTURE([AT_USE_ALLOCA],
f37495f6 514[[%define api.push-pull both
7d596384 515]])
e0ac9b4b
JD
516AT_PARSER_CHECK([./input 20], 0, [], [ignore],
517 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
518AT_PARSER_CHECK([./input 900], 0, [], [ignore],
519 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
520AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
521 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
7d596384
JD
522
523m4_popdef([AT_USE_ALLOCA])
524
6d7d248e 525AT_CLEANUP