[perl5.git] / t / lib / warnings / regexec

  regexec.c	

  This test generates "bad free" warnings when run under
  PERL_DESTRUCT_LEVEL.  This file merely serves as a placeholder
  for investigation.

  Complex regular subexpression recursion limit (%d) exceeded

        $_ = 'a' x (2**15+1); /^()(a\1)*$/ ;
  Complex regular subexpression recursion limit (%d) exceeded

        $_ = 'a' x (2**15+1); /^()(a\1)*?$/ ;

  (The actual value substituted for %d is masked in the tests so that
  REG_INFTY configuration variable value does not affect outcome.)
__END__
# regexec.c
print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
use warnings 'regexp' ;
$SIG{__WARN__} = sub{local ($m) = shift;
                 $m =~ s/\(\d+\)/(*MASKED*)/;
                 print STDERR $m};
$_ = 'a' x (2**15+1); 
/^()(a\1)*$/ ;
#
# If this test fails with a segmentation violation or similar,
# you may have to increase the default stacksize limit in your
# shell.  You may need superuser privileges.
#
# Under the sh, ksh, zsh:
#    $ ulimit -s
#    8192
#    $ ulimit -s 16000
#
# Under the csh:
#    % limit stacksize
#    stacksize        8192 kbytes
#    % limit stacksize 16000
#
EXPECT
Complex regular subexpression recursion limit (*MASKED*) exceeded at - line 9.
########
# regexec.c
print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
no warnings 'regexp' ;
$SIG{__WARN__} = sub{local ($m) = shift;
                 $m =~ s/\(\d+\)/(*MASKED*)/;
                 print STDERR $m};
$_ = 'a' x (2**15+1); 
/^()(a\1)*$/ ;
#
# If this test fails with a segmentation violation or similar,
# you may have to increase the default stacksize limit in your
# shell.  You may need superuser privileges.
#
# Under the sh, ksh, zsh:
#    $ ulimit -s
#    8192
#    $ ulimit -s 16000
#
# Under the csh:
#    % limit stacksize
#    stacksize        8192 kbytes
#    % limit stacksize 16000
#
EXPECT

########
# regexec.c
print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
use warnings 'regexp' ;
$SIG{__WARN__} = sub{local ($m) = shift;
                 $m =~ s/\(\d+\)/(*MASKED*)/;
                 print STDERR $m};
$_ = 'a' x (2**15+1);
/^()(a\1)*?$/ ;
#
# If this test fails with a segmentation violation or similar,
# you may have to increase the default stacksize limit in your
# shell.  You may need superuser privileges.
#
# Under the sh, ksh, zsh:
#    $ ulimit -s
#    8192
#    $ ulimit -s 16000
#
# Under the csh:
#    % limit stacksize
#    stacksize        8192 kbytes
#    % limit stacksize 16000
#
EXPECT
Complex regular subexpression recursion limit (*MASKED*) exceeded at - line 9.
########
# regexec.c
print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
no warnings 'regexp' ;
$SIG{__WARN__} = sub{local ($m) = shift;
                 $m =~ s/\(\d+\)/(*MASKED*)/;
                 print STDERR $m};
$_ = 'a' x (2**15+1);
/^()(a\1)*?$/ ;
#
# If this test fails with a segmentation violation or similar,
# you may have to increase the default stacksize limit in your
# shell.  You may need superuser privileges.
#
# Under the sh, ksh, zsh:
#    $ ulimit -s
#    8192
#    $ ulimit -s 16000
#
# Under the csh:
#    % limit stacksize
#    stacksize        8192 kbytes
#    % limit stacksize 16000
#
EXPECT

########
# NAME Wide character in non-UTF-8 locale
require '../loc_tools.pl';
unless (locales_enabled()) {
    print("SKIPPED\n# locales not available\n"),exit;
}
eval { require POSIX; POSIX->import("locale_h") };
if ($@) {
    print("SKIPPED\n# no POSIX\n"),exit;
}
use warnings 'locale';
use locale;
setlocale(&POSIX::LC_CTYPE, "C");
"\x{100}" =~ /\x{100}|\x{101}/il;
"\x{100}" =~ /\x{100}|\x{101}/l;
"\x{100}" =~ /\w/l;
"\x{100}" =~ /\x{100}+/l;
"\x{100}" =~ /[\x{100}\x{102}]/l;
no warnings 'locale';
EXPECT
Wide character (U+100) in pattern match (m//) at - line 12.
Wide character (U+100) in pattern match (m//) at - line 12.
Wide character (U+100) in pattern match (m//) at - line 13.
Wide character (U+100) in pattern match (m//) at - line 13.
Wide character (U+100) in pattern match (m//) at - line 13.
Wide character (U+100) in pattern match (m//) at - line 14.
Wide character (U+100) in pattern match (m//) at - line 14.
Wide character (U+100) in pattern match (m//) at - line 15.
Wide character (U+100) in pattern match (m//) at - line 16.
Wide character (U+100) in pattern match (m//) at - line 16.
########
# NAME Wide character in UTF-8 locale
require '../loc_tools.pl';
unless (locales_enabled()) {
    print("SKIPPED\n# locales not available\n"),exit;
}
eval { require POSIX; POSIX->import("locale_h") };
if ($@) {
    print("SKIPPED\n# no POSIX\n"),exit;
}
my @utf8_locales = find_utf8_ctype_locale();
unless (@utf8_locales) {
    print("SKIPPED\n# no UTF-8 locales\n"),exit;
}
use warnings 'locale';
use locale;
setlocale(&POSIX::LC_CTYPE, $utf8_locales[0]);
"\x{100}" =~ /\x{100}|\x{101}/il;
"\x{100}" =~ /\x{100}|\x{101}/l;
"\x{100}" =~ /\w/l;
"\x{100}" =~ /\x{100}+/l;
"\x{100}" =~ /[\x{100}\x{102}]/l;
EXPECT
########
# NAME \b{} in non-UTF-8 locale
eval { require POSIX; POSIX->import("locale_h") };
if ($@) {
    print("SKIPPED\n# no POSIX\n"),exit;
}
use warnings 'locale';
use locale;
setlocale(&POSIX::LC_CTYPE, "C");
"a" =~ /\b{gcb}/l;
no warnings 'locale';
"a" =~ /\b{gcb}/l;
EXPECT
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 8.
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 8.
########
# NAME \b{} in UTF-8 locale
require '../loc_tools.pl';
unless (locales_enabled()) {
    print("SKIPPED\n# locales not available\n"),exit;
}
eval { require POSIX; POSIX->import("locale_h") };
if ($@) {
    print("SKIPPED\n# no POSIX\n"),exit;
}
my $utf8_locale = find_utf8_ctype_locale();
unless ($utf8_locale) {
    print("SKIPPED\n# No UTF-8 locale available\n"),exit;
}
use warnings 'locale';
use locale;
setlocale(&POSIX::LC_CTYPE, "C");
 "abc def" =~ /\b{wb}.*?/;
 "abc def" =~ /\B{wb}.*?/;
setlocale(&POSIX::LC_CTYPE, $utf8_locale);
 "abc def" =~ /\b{wb}.*?/;
 "abc def" =~ /\B{wb}.*?/;
EXPECT
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 16.
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 16.
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 17.
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 17.
Use of \b{} or \B{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 17.
########
# NAME (?[ ]) in non-UTF-8 locale
eval { require POSIX; POSIX->import("locale_h") };
if ($@) {
    print("SKIPPED\n# no POSIX\n"),exit;
}
no warnings 'experimental::regex_sets';
use warnings 'locale';
use locale;
setlocale(&POSIX::LC_CTYPE, "C");
"\N{KELVIN SIGN}" =~ /(?[ \N{KELVIN SIGN} ])/i;
"K" =~ /(?[ \N{KELVIN SIGN} ])/i;
"k" =~ /(?[ \N{KELVIN SIGN} ])/i;
":" =~ /(?[ \: ])/;
no warnings 'locale';
EXPECT
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 9.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 9.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 10.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 10.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 11.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 11.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 12.
Use of (?[ ]) for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale at - line 12.
########
# NAME (?[ ]) in UTF-8 locale
require '../loc_tools.pl';
unless (locales_enabled()) {
    print("SKIPPED\n# locales not available\n"),exit;
}
eval { require POSIX; POSIX->import("locale_h") };
if ($@) {
    print("SKIPPED\n# no POSIX\n"),exit;
}
my $utf8_locale = find_utf8_ctype_locale();
unless ($utf8_locale) {
    print("SKIPPED\n# No UTF-8 locale available\n"),exit;
}
no warnings 'experimental::regex_sets';
use warnings 'locale';
use locale;
setlocale(&POSIX::LC_CTYPE, $utf8_locale);
"\N{KELVIN SIGN}" =~ /(?[ \N{KELVIN SIGN} ])/i;
"K" =~ /(?[ \N{KELVIN SIGN} ])/i;
"k" =~ /(?[ \N{KELVIN SIGN} ])/i;
":" =~ /(?[ \: ])/;
EXPECT
Commit	Line	Data
599cee73 PM	1	regexec.c
599cee73 PM	2
0f4592ef GS	3	This test generates "bad free" warnings when run under
	4	PERL_DESTRUCT_LEVEL. This file merely serves as a placeholder
	5	for investigation.
	6
90ba36ed	7	Complex regular subexpression recursion limit (%d) exceeded
599cee73 PM	8
599cee73 PM	9	$_ = 'a' x (2*15+1); /^()(a\1)$/ ;
90ba36ed	10	Complex regular subexpression recursion limit (%d) exceeded
599cee73 PM	11
	12	$_ = 'a' x (2*15+1); /^()(a\1)?$/ ;
	13
90ba36ed DD	14	(The actual value substituted for %d is masked in the tests so that
90ba36ed DD	15	REG_INFTY configuration variable value does not affect outcome.)
599cee73 PM	16	__END__
599cee73 PM	17	# regexec.c
0f4592ef	18	print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
e476b1b5	19	use warnings 'regexp' ;
90ba36ed DD	20	$SIG{__WARN__} = sub{local ($m) = shift;
	21	$m =~ s/\(\d+\)/(MASKED)/;
	22	print STDERR $m};
599cee73 PM	23	$_ = 'a' x (2**15+1);
599cee73 PM	24	/^()(a\1)*$/ ;
d008e5eb GS	25	#
	26	# If this test fails with a segmentation violation or similar,
	27	# you may have to increase the default stacksize limit in your
	28	# shell. You may need superuser privileges.
	29	#
	30	# Under the sh, ksh, zsh:
	31	# $ ulimit -s
	32	# 8192
	33	# $ ulimit -s 16000
	34	#
	35	# Under the csh:
	36	# % limit stacksize
	37	# stacksize 8192 kbytes
	38	# % limit stacksize 16000
	39	#
599cee73	40	EXPECT
90ba36ed	41	Complex regular subexpression recursion limit (MASKED) exceeded at - line 9.
599cee73 PM	42	########
599cee73 PM	43	# regexec.c
0f4592ef	44	print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
e476b1b5	45	no warnings 'regexp' ;
0453d815 PM	46	$SIG{__WARN__} = sub{local ($m) = shift;
	47	$m =~ s/\(\d+\)/(MASKED)/;
	48	print STDERR $m};
	49	$_ = 'a' x (2**15+1);
	50	/^()(a\1)*$/ ;
	51	#
	52	# If this test fails with a segmentation violation or similar,
	53	# you may have to increase the default stacksize limit in your
	54	# shell. You may need superuser privileges.
	55	#
	56	# Under the sh, ksh, zsh:
	57	# $ ulimit -s
	58	# 8192
	59	# $ ulimit -s 16000
	60	#
	61	# Under the csh:
	62	# % limit stacksize
	63	# stacksize 8192 kbytes
	64	# % limit stacksize 16000
	65	#
	66	EXPECT
	67
	68	########
	69	# regexec.c
	70	print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
e476b1b5	71	use warnings 'regexp' ;
90ba36ed DD	72	$SIG{__WARN__} = sub{local ($m) = shift;
	73	$m =~ s/\(\d+\)/(MASKED)/;
	74	print STDERR $m};
599cee73 PM	75	$_ = 'a' x (2**15+1);
599cee73 PM	76	/^()(a\1)*?$/ ;
d008e5eb GS	77	#
	78	# If this test fails with a segmentation violation or similar,
	79	# you may have to increase the default stacksize limit in your
	80	# shell. You may need superuser privileges.
	81	#
	82	# Under the sh, ksh, zsh:
	83	# $ ulimit -s
	84	# 8192
	85	# $ ulimit -s 16000
	86	#
	87	# Under the csh:
	88	# % limit stacksize
	89	# stacksize 8192 kbytes
	90	# % limit stacksize 16000
	91	#
599cee73	92	EXPECT
90ba36ed	93	Complex regular subexpression recursion limit (MASKED) exceeded at - line 9.
0453d815 PM	94	########
	95	# regexec.c
	96	print("SKIPPED\n# most systems run into stacksize limits\n"),exit;
e476b1b5	97	no warnings 'regexp' ;
0453d815 PM	98	$SIG{__WARN__} = sub{local ($m) = shift;
	99	$m =~ s/\(\d+\)/(MASKED)/;
	100	print STDERR $m};
	101	$_ = 'a' x (2**15+1);
	102	/^()(a\1)*?$/ ;
	103	#
	104	# If this test fails with a segmentation violation or similar,
	105	# you may have to increase the default stacksize limit in your
	106	# shell. You may need superuser privileges.
	107	#
	108	# Under the sh, ksh, zsh:
	109	# $ ulimit -s
	110	# 8192
	111	# $ ulimit -s 16000
	112	#
	113	# Under the csh:
	114	# % limit stacksize
	115	# stacksize 8192 kbytes
	116	# % limit stacksize 16000
	117	#
	118	EXPECT
	119
613abc6d KW	120	########
613abc6d KW	121	# NAME Wide character in non-UTF-8 locale
ef9d5242 KW	122	require '../loc_tools.pl';
	123	unless (locales_enabled()) {
	124	print("SKIPPED\n# locales not available\n"),exit;
	125	}
613abc6d KW	126	eval { require POSIX; POSIX->import("locale_h") };
	127	if ($@) {
	128	print("SKIPPED\n# no POSIX\n"),exit;
	129	}
	130	use warnings 'locale';
	131	use locale;
	132	setlocale(&POSIX::LC_CTYPE, "C");
	133	"\x{100}" =~ /\x{100}\|\x{101}/il;
	134	"\x{100}" =~ /\x{100}\|\x{101}/l;
	135	"\x{100}" =~ /\w/l;
	136	"\x{100}" =~ /\x{100}+/l;
	137	"\x{100}" =~ /[\x{100}\x{102}]/l;
	138	no warnings 'locale';
	139	EXPECT
613abc6d KW	140	Wide character (U+100) in pattern match (m//) at - line 12.
613abc6d KW	141	Wide character (U+100) in pattern match (m//) at - line 12.
ef9d5242 KW	142	Wide character (U+100) in pattern match (m//) at - line 13.
	143	Wide character (U+100) in pattern match (m//) at - line 13.
	144	Wide character (U+100) in pattern match (m//) at - line 13.
	145	Wide character (U+100) in pattern match (m//) at - line 14.
	146	Wide character (U+100) in pattern match (m//) at - line 14.
	147	Wide character (U+100) in pattern match (m//) at - line 15.
	148	Wide character (U+100) in pattern match (m//) at - line 16.
	149	Wide character (U+100) in pattern match (m//) at - line 16.
64935bc6	150	########
008e8e82 KW	151	# NAME Wide character in UTF-8 locale
	152	require '../loc_tools.pl';
	153	unless (locales_enabled()) {
	154	print("SKIPPED\n# locales not available\n"),exit;
	155	}
	156	eval { require POSIX; POSIX->import("locale_h") };
	157	if ($@) {
	158	print("SKIPPED\n# no POSIX\n"),exit;
	159	}
	160	my @utf8_locales = find_utf8_ctype_locale();
	161	unless (@utf8_locales) {
	162	print("SKIPPED\n# no UTF-8 locales\n"),exit;
	163	}
	164	use warnings 'locale';
	165	use locale;
	166	setlocale(&POSIX::LC_CTYPE, $utf8_locales[0]);
	167	"\x{100}" =~ /\x{100}\|\x{101}/il;
	168	"\x{100}" =~ /\x{100}\|\x{101}/l;
	169	"\x{100}" =~ /\w/l;
	170	"\x{100}" =~ /\x{100}+/l;
	171	"\x{100}" =~ /[\x{100}\x{102}]/l;
	172	EXPECT
	173	########
64935bc6 KW	174	# NAME \b{} in non-UTF-8 locale
	175	eval { require POSIX; POSIX->import("locale_h") };
	176	if ($@) {
	177	print("SKIPPED\n# no POSIX\n"),exit;
	178	}
	179	use warnings 'locale';
	180	use locale;
	181	setlocale(&POSIX::LC_CTYPE, "C");
	182	"a" =~ /\b{gcb}/l;
	183	no warnings 'locale';
	184	"a" =~ /\b{gcb}/l;
	185	EXPECT
89ad707a KW	186	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 8.
	187	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 8.
	188	########
	189	# NAME \b{} in UTF-8 locale
	190	require '../loc_tools.pl';
	191	unless (locales_enabled()) {
	192	print("SKIPPED\n# locales not available\n"),exit;
	193	}
	194	eval { require POSIX; POSIX->import("locale_h") };
	195	if ($@) {
	196	print("SKIPPED\n# no POSIX\n"),exit;
	197	}
	198	my $utf8_locale = find_utf8_ctype_locale();
	199	unless ($utf8_locale) {
	200	print("SKIPPED\n# No UTF-8 locale available\n"),exit;
	201	}
	202	use warnings 'locale';
	203	use locale;
	204	setlocale(&POSIX::LC_CTYPE, "C");
	205	"abc def" =~ /\b{wb}.*?/;
	206	"abc def" =~ /\B{wb}.*?/;
	207	setlocale(&POSIX::LC_CTYPE, $utf8_locale);
	208	"abc def" =~ /\b{wb}.*?/;
	209	"abc def" =~ /\B{wb}.*?/;
	210	EXPECT
	211	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 16.
	212	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 16.
	213	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 17.
	214	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 17.
67481c39	215	Use of \b{} or \B{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 17.
a0bd1a30 KW	216	########
	217	# NAME (?[ ]) in non-UTF-8 locale
	218	eval { require POSIX; POSIX->import("locale_h") };
	219	if ($@) {
	220	print("SKIPPED\n# no POSIX\n"),exit;
	221	}
	222	no warnings 'experimental::regex_sets';
	223	use warnings 'locale';
	224	use locale;
	225	setlocale(&POSIX::LC_CTYPE, "C");
	226	"\N{KELVIN SIGN}" =~ /(?[ \N{KELVIN SIGN} ])/i;
	227	"K" =~ /(?[ \N{KELVIN SIGN} ])/i;
	228	"k" =~ /(?[ \N{KELVIN SIGN} ])/i;
	229	":" =~ /(?[ \: ])/;
	230	no warnings 'locale';
	231	EXPECT
	232	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 9.
	233	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 9.
	234	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 10.
	235	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 10.
	236	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 11.
	237	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 11.
	238	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 12.
	239	Use of (?[ ]) for non-UTF-8 locale is wrong. Assuming a UTF-8 locale at - line 12.
	240	########
	241	# NAME (?[ ]) in UTF-8 locale
	242	require '../loc_tools.pl';
	243	unless (locales_enabled()) {
	244	print("SKIPPED\n# locales not available\n"),exit;
	245	}
	246	eval { require POSIX; POSIX->import("locale_h") };
	247	if ($@) {
	248	print("SKIPPED\n# no POSIX\n"),exit;
	249	}
	250	my $utf8_locale = find_utf8_ctype_locale();
	251	unless ($utf8_locale) {
	252	print("SKIPPED\n# No UTF-8 locale available\n"),exit;
	253	}
	254	no warnings 'experimental::regex_sets';
	255	use warnings 'locale';
	256	use locale;
	257	setlocale(&POSIX::LC_CTYPE, $utf8_locale);
	258	"\N{KELVIN SIGN}" =~ /(?[ \N{KELVIN SIGN} ])/i;
	259	"K" =~ /(?[ \N{KELVIN SIGN} ])/i;
	260	"k" =~ /(?[ \N{KELVIN SIGN} ])/i;
	261	":" =~ /(?[ \: ])/;
	262	EXPECT