| perldiag - various Perl diagnostics |
perldiag - various Perl diagnostics
These messages are classified as follows (listed in increasing order of desperation):
(W) A warning (optional).
(D) A deprecation (enabled by default).
(S) A severe warning (enabled by default).
(F) A fatal error (trappable).
(P) An internal error you should never see (trappable).
(X) A very fatal error (nontrappable).
(A) An alien error message (not generated by Perl).
The majority of messages from the first three classifications above
(W, D & S) can be controlled using the warnings pragma.
If a message can be controlled by the warnings pragma, its warning
category is included with the classification letter in the description
below. E.g. (W closed) means a warning in the closed category.
Optional warnings are enabled by using the warnings pragma or the -w
and -W switches. Warnings may be captured by setting $SIG{__WARN__}
to a reference to a routine that will be called on each warning instead
of printing it. See the perlvar manpage.
Severe warnings are always enabled, unless they are explicitly disabled
with the warnings pragma or the -X switch.
Trappable errors may be trapped using the eval operator. See
eval in the perlfunc manpage. In almost all cases, warnings may be selectively
disabled or promoted to fatal errors using the warnings pragma.
See the warnings manpage.
The messages are in alphabetical order, without regard to upper or lower-case. Some of these messages are generic. Spots that vary are denoted with a %s or other printf-style escape. These escapes are ignored by the alphabetical order, as are all characters other than letters. To look up your message, just ignore anything that is not a letter.
accept() on closed socket %ssocket() call? See
accept in the perlfunc manpage.
no warnings "experimental::refaliasing";
use feature "refaliasing";
\$x = \$y;
pack() or unpack() only
after certain types. See pack in the perlfunc manpage.
numify() is lossyTo force interpretation as a subroutine call, either put an ampersand
before the subroutine name, or qualify the name with its package.
Alternatively, you can import the subroutine (or pretend that it's
imported with the use subs pragma).
To silently interpret it as the Perl operator, use the CORE:: prefix
on the operator (e.g. CORE::log($x)) or declare the subroutine
to be an object method (see Subroutine Attributes in the perlsub manpage or
the attributes manpage).
tr/a-z-0// which doesn't mean anything at
all. To include a - character in a transliteration, put it either
first or last. (In the past, tr/a-z-0// was synonymous with
tr/a-y//, which was probably not what you would have expected.)
-foo, which might be the
string "-foo", or a call to the function foo, negated. If you meant
the string, just write "-foo". If you meant the function call,
write -foo().
%, &, and * are both infix operators (modulus,
bitwise and, and multiplication) and initial special characters
(denoting hashes, subroutines and typeglobs), and you said something
like *foo * foo that might be interpreted as either of them. We
assumed you meant the infix operator, but please try to make it more
clear -- in the example given, you might write *foo * foo() if you
really meant to multiply a glob by the result of calling a function.
@{foo}, which might be
asking for the variable @foo, or it might be calling a function
named foo, and dereferencing it as an array reference. If you wanted
the variable, you can just write @foo. If you wanted to call the
function, write @{foo()} ... or you could just not have a variable
and a function with the same name, and save yourself a lot of trouble.
${foo[2]} (where foo represents
the name of a Perl keyword), which might be looking for element number
2 of the array named @foo, in which case please write $foo[2], or you
might have meant to pass an anonymous arrayref to the function named
foo, and then do a scalar deref on the value it returns. If you meant
that, write ${foo([2])}.
In regular expressions, the ${foo[2]} syntax is sometimes necessary
to disambiguate between array subscripts and character classes.
/$length[2345]/, for instance, will be interpreted as $length followed
by the character class [2345]. If an array subscript is what you
want, you can avoid the warning by changing /${length[2345]}/ to the
unsightly /${\$length[2345]}/, by renaming your array to something
that does not coincide with a built-in keyword, or by simply turning
off warnings with no warnings 'ambiguous';.
open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!";
while (<STDIN>) {
print;
print OUT;
}
close OUT;
scalar(%s)//), substitution (s///), and
transliteration (tr///) operators work on scalar values. If you apply
one of them to an array or a hash, it will convert the array or hash to
a scalar value (the length of an array, or the population info of a
hash) and then work on that scalar value. This is probably not what
you meant to do. See grep in the perlfunc manpage and map in the perlfunc manpage for
alternatives.
msgsnd() requires a string at least as long as sizeof(long).
Note that for the Inf and NaN (infinity and not-a-number) the
definition of ``numeric'' is somewhat unusual: the strings themselves
(like ``Inf'') are considered numeric, and anything following them is
considered non-numeric.
++
operator which expects either a number or a string matching
/^[a-zA-Z]*[0-9]*\z/. See Auto-increment and Auto-decrement in the perlop manpage for details.
stat() on an array, but the array will be
coerced to a scalar - the number of elements in the array.
sub foo ($a, $, $b = 1, @c) {}
sub foo ($a = 1) {} # legal
sub foo (@a = (1)) {} # invalid
sub foo (%a = (a => b)) {} # invalid
\$x = $y). If you meant to make $x an alias to $y, use
\$x = \$y.
\$x = \@y; # error
\@x = \%y; # error
$y = [];
\$x = $y; # error; did you mean \$y?
use v5.16;, and as of Perl 5.30)
the special variable $[, which is deprecated, is now a fixed zero value.
[[:alnum]] [[:digit:xyz]
They look like they might have been meant to be the POSIX classes
[:alnum:] or [:digit:]. If so, they should be written:
[[:alnum:]] [[:digit:]xyz]
Since these aren't legal POSIX class specifications, but are legal
bracketed character classes, Perl treats them as the latter. In the
first example, it matches the characters ":", "[", "a", "l",
"m", "n", and "u".
If these weren't meant to be POSIX classes, this warning message is spurious, and can be suppressed by reordering things, such as
[[al:num]]
or
[[:munla]]
require <file> when you should have written
require 'file'.
bless $foo with one argument after somehow causing
the current package to be freed. Perl cannot figure out what to
do, so it throws up its hands in despair.
bless() operator is expected to be
the name of the package to bless the resulting object into. You've
supplied instead a reference to something: perhaps you wrote
bless $self, $proto;
when you intended
bless $self, ref($proto) || $proto;
If you actually want to bless into the stringified version of the reference supplied, you need to stringify it yourself, for example by:
bless $self, "$proto";
av_clear from a custom magic
callback on the array.
free_tmps() routine. This indicates that something else is freeing the
SV before the free_tmps() routine gets a chance, which means that the
free_tmps() routine will be freeing an unreferenced scalar when it does
try to free it.
SvREFCNT_dec() was called too many times, or
that SvREFCNT_inc() was called too few times, or that the SV was
mortalized when it shouldn't have been, or that memory has been
corrupted.
pack() template. This
means the result contains a pointer to a location that could become
invalid anytime, even before the end of the current statement. Use
literals or global values as arguments to the ``p'' pack() template to
avoid this warning.
use or require that failed to
compile once already. Perl will not try to compile this file again
unless you delete its entry from %INC. See require in the perlfunc manpage and
%INC in the perlvar manpage.
$r = do {my @a; \$#a};
$$r = 503
substr()
used as an lvalue, which is pretty strange. Perhaps you forgot to
dereference it first. See substr in the perlfunc manpage.
prototype(%s) discards earlier prototype attribute in same subprototype(A) : prototype(B) {}, for
example. Since each sub can only have one prototype, the earlier
declaration(s) are discarded while the last one is applied.
@_ or @DB::args being tied.
semctl()
or shmctl(). In C parlance, the correct sizes are, respectively,
sizeof(struct msqid_ds *), sizeof(struct semid_ds *), and
sizeof(struct shmid_ds *).
/e switch to evaluate the replacement for a
substitution, but perl found a syntax error in the code to evaluate,
most likely an unexpected right brace '}'.
free() ignoredfree() on something that had never
been malloc()ed in the first place. Mandatory, but can be disabled by
setting environment variable PERL_BADFREE to 0.
This message can be seen quite often with DB_File on systems with ``hard''
dynamic linking, like AIX and OS/2. It is a bug of Berkeley DB
which is left unnoticed if DB uses forgiving system malloc().
$var = 'myvar';
$sym = mypack::$var;
is not the same as
$var = 'myvar';
$sym = "mypack::$var";
realloc() ignoredrealloc() on something that
had never been malloc()ed in the first place. Mandatory, but can
be disabled by setting the environment variable PERL_BADFREE to 1.
open FOO || die;
It may also indicate a misspelled constant that has been interpreted as a bareword:
use constant TYPO => 1;
if (TYOP) { print "foo" }
The strict pragma is useful in avoiding such errors.
Perl_load_module.
require Bare::Word, the bareword is not allowed to start with a
double-colon. Write require ::Foo::Bar as require Foo::Bar instead.
Foo::, but the
compiler saw no other uses of that namespace before that point. Perhaps
you need to predeclare a package?
BEGIN {} subroutine (or a use directive, which
implies a BEGIN {}) after one or more compilation errors had already
occurred. Since the intended environment for the BEGIN {} could not
be guaranteed (due to the errors), and since subsequent code likely
depends on its correct operation, Perl just gave up.
bind() on closed socket %ssocket() call? See bind in the perlfunc manpage.
binmode() on closed filehandle %sbinmode() on a filehandle that was never opened.
Check your control flow and number of arguments.
use re 'strict' or within (?[...]))
In a bracketed character class in a regular expression pattern, you
had a range which has exactly one end of it specified using \N{}, and
the other end is specified using a non-portable mechanism. Perl treats
the range as a Unicode range, that is, all the characters in it are
considered to be the Unicode characters, and which may be different code
points on some platforms Perl runs on. For example, [\N{U+06}-\x08]
is treated as if you had instead said [\N{U+06}-\N{U+08}], that is it
matches the characters whose code points in Unicode are 6, 7, and 8.
But that \x08 might indicate that you meant something different, so
the warning gets raised.
call_sv()
exited by calling exit.
chr.
pack(``w'',...) was too large to compress.
The BER compressed integer format can only be used with positive
integers, and you attempted to compress a very large number (> 1e308).
See pack in the perlfunc manpage.
pack(``w'',...) was negative. The BER compressed integer
format can only be used with positive integers. See pack in the perlfunc manpage.
open() or binmode().
opendir() to associate a dirhandle to a symbol (glob
or scalar) that already holds a filehandle. Since this idiom might render
your code confusing, it was deprecated in Perl 5.10. As of Perl 5.28, it
is a fatal error.
open() to associate a filehandle to a symbol (glob
or scalar) that already holds a dirhandle. Since this idiom might render
your code confusing, it was deprecated in Perl 5.10. As of Perl 5.28, it
is a fatal error.
caller tried to set @DB::args, but found it tied. Tying @DB::args
is not supported. (Before this error was added, it used to crash.)
tie on an array that does not
keep a reference count on its arguments and cannot be made to
do so. Such arrays are not even supposed to be accessible to
Perl code, but are only used internally.
sv_vcatpvfn() arguments from va_listsv_vcatpvfn() or a related function with a
format string that specifies explicit indexes for some of the elements, and
using a C-style variable-argument list (a va_list). This is not currently
supported. XS authors wanting to do this must instead construct a C array
of SV* scalars containing the arguments.
pack(``w'',...) was not an integer. The BER compressed
integer format can only be used with positive integers, and you attempted
to compress something else. See pack in the perlfunc manpage.
break, but you're in a foreach block rather than
a given block. You probably meant to use next or last.
break, but you're not inside a given block.
$BADREF = undef;
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
$BADREF = 42;
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
mro_isa_changed_in() on anonymous symbol tablemro_method_changed_in() on anonymous symbol tablemro_method_changed_in on a hash that was
not attached to the symbol table.
perl -x/foo/bar, but /foo/bar is not a directory
that you can chdir to, possibly because it doesn't exist.
*foo += 1;
You CAN say
$foo = *foo;
$foo += 1;
but then $foo no longer contains a glob.
continue, but you're not inside a when
or default block.
default block that is neither inside a
foreach loop nor a given block. (Note that this error is
issued on exit from the default block, so you won't get the
error if you use an explicit continue.)
use locale''; 2) the current
locale is not a UTF-8 one; 3) you tried to do the designated case-change
operation on the specified Unicode character; and 4) the result of this
operation would mix Unicode and locale rules, which likely conflict.
Mixing of different rule types is forbidden, so the operation was not
done; instead the result is the indicated value, which is the best
available that uses entirely Unicode rules. That turns out to almost
always be the original character, unchanged.
It is generally a bad idea to mix non-UTF-8 locales and Unicode, and this issue is one of the reasons why. This warning is raised when Unicode rules would normally cause the result of this operation to contain a character that is in the range specified by the locale, 0..255, and hence is subject to the locale's rules, not Unicode's.
If you are using locale purely for its characteristics related to things
like its numeric and time formatting (and not LC_CTYPE), consider
using a restricted form of the locale pragma (see The ``use locale'' pragma in the perllocale manpage) like ``use locale ':not_characters'''.
Note that failed case-changing operations done as a result of
case-insensitive /i regular expression matching will show up in this
warning as having the fc operation (as that is what the regular
expression engine calls behind the scenes.)
waitpid() or wait4(), so only
waitpid() without flags is emulated.
$ENV{PATH}, the executable in question was compiled for another
architecture, or the #! line in a script points to an interpreter that
can't be run for similar reasons. (Or maybe your system doesn't support
#! at all.)
CORE::word was given to prototype(), but there
is no builtin with the name word.
print q(The character '(' starts a side comment.);
If you're getting this error from a here-document, you may have included unseen whitespace before or after your closing tag or there may not be a linebreak after it. A good programmer's editor will have a way to help you find these characters (or lack of characters). See the perlop manpage for the full details on here-documents.
\p or \P is not one
known to Perl. Perhaps you misspelled the name? See
perluniprops/Properties accessible through \p{} and \P{}
for a complete list of available official
properties. If it is a
user-defined property
it must have been defined by the time the regular expression is
matched.
If you didn't mean to use a Unicode property, escape the \p, either
by \\p (just the \p) or by \Q\p (the rest of the string, or
until \E).
stat() routine,
because the device name is overwritten with each call. If this warning
appears, the name lookup failed, and the access-checking routine gave up
and returned FALSE, just to be conservative. (Note: The access-checking
routine knows about the Perl stat operator and file tests, so you
shouldn't ever see this warning in response to a Perl command; it arises
only if some internal code takes stat buffers lightly.)
goto F;
print do { F: }; # Can't jump into the arguments to print
goto G;
$x + do { G: $y }; # How is + supposed to get its first operand?
given
block. You can't get there from here. See goto in the perlfunc manpage.
sort() block or subroutine, which is a no-no.
See goto in the perlfunc manpage.
reduce() function in List::Util).
kill() an undefined, empty-string or otherwise non-numeric
process identifier.
map() or grep(). You can
usually double the curlies to get the same effect though, because the
inner curlies will be considered a block that loops once. See
last in the perlfunc manpage.
local $$ref, which Perl can't currently
handle, because when it goes to restore the old value of whatever $ref
pointed to after the scope of the local() is finished, it can't be sure
that $ref will still be a reference.
do (or require, or use) a file that couldn't be found.
Perl looks for the file in all the locations mentioned in @INC, unless
the file name included the full path to the file. Perhaps you need
to set the PERL5LIB or PERL5OPT environment variable to say where the
extra library is, or maybe the script needs to add the library name
to @INC. Or maybe you just misspelled the name of the file. See
require in the perlfunc manpage and the lib manpage.
AutoSplit
the file, say, by doing make install.
open() a PerlIO layer that does not exist,
e.g. open(FH, ``>:nosuchlayer'', ``somefile'').
substr() was handed
a NULL.
\local(@array) or \(local @array) is not supported, as
it is not clear exactly what it should do. If you meant to make @array
refer to some other array, use \@array = \@other_array. If you want to
make the elements of @array aliases of the scalars referenced on the
right-hand side, use \(@array) = @scalar_refs.
\(%hash) is not supported. If you meant to make %hash
refer to some other hash, use \%hash = \%other_hash. If you want to
make the elements of %hash into aliases of the scalars referenced on the
right-hand side, use a hash slice: \@hash{@keys} = @those_scalar_refs.
map() or
grep(). You can usually double the curlies to get the same effect
though, because the inner curlies will be considered a block that loops
once. See next in the perlfunc manpage.
<>
filehandle, either implicitly under the -n or -p command-line
switches, or explicitly, failed for the indicated reason. Usually
this is because you don't have read permission for a file which
you named on the command line.
(F) You tried to call perl with the -e switch, but /dev/null (or your operating system's equivalent) could not be opened.
open() syntax:
open FH, '>', $ref;
but your version of perl is compiled without perlio, and this form of open is not supported.
open(CMD, "|cmd|"), which is not supported.
You can try any of several modules in the Perl library to do this, such
as IPC::Open2. Alternately, direct the pipe's output to a file using
``>'', and then read it in under a different file handle.
If you're debugging a script that uses #!, and normally relies on the
shell's $PATH search, the -S option causes perl to do that search, so
you don't have to type the path or `which $scriptname`.
my ($x, my($y), $z) or our (my $x).
map()
or grep(). You can usually double the curlies to get the same effect
though, because the inner curlies will be considered a block that
loops once. See redo in the perlfunc manpage.
reset('E') or similar, which tried to reset
all variables in the current package beginning with ``E''. In
the main package, that includes %ENV. Resetting %ENV is not
supported on some systems, notably VMS.
???, this is an internal error.
fstat() the script even though you have it
open already. Bizarre.
%foo->{"bar"} or %$ref->{"hello"}. Versions of perl
<= 5.22.0 used to allow this syntax, but shouldn't
have. This was deprecated in perl 5.6.1.
@foo->[23] or @$ref->[99]. Versions of perl <= 5.22.0
used to allow this syntax, but shouldn't have. This
was deprecated in perl 5.6.1.
undef %Some::Package::.
%! hash is used, perl automatically loads the
Errno.pm module. The Errno module is expected to tie the %! hash to
provide symbolic names for $! errno values.
defined()?)defined() is not useful on arrays because it
checks for an undefined scalar value. If you want to see if the
array is empty, just use if (@array) { # not empty } for example.
defined()?)defined() is not usually right on hashes.
Although defined %hash is false on a plain not-yet-used hash, it
becomes true in several non-obvious circumstances, including iterators,
weak references, stash names, even remaining true after undef %hash.
These things make defined %hash fairly useless in practice, so it now
generates a fatal error.
If a check for non-empty is what you wanted then just put it in boolean context (see Scalar values in the perldata manpage):
if (%hash) {
# not empty
}
If you had defined %Foo::Bar::QUUX to check whether such a package
variable exists then that's never really been reliable, and isn't
a good way to enquire about the features of a package, or whether
it's loaded, etc.
foreach loop.
ref() function to
test the type of the reference, if need be.
use strict blocks to prevent it happening accidentally. See
Symbolic references in the perlref manpage. This can be triggered by an @ or $
in a double-quoted string immediately before interpolating a variable,
for example in "user @$twitter_id", which says to treat the contents
of $twitter_id as an array reference; use a \ to have a literal @
symbol followed by the contents of $twitter_id: "user \@$twitter_id".
when() block that is neither inside a foreach
loop nor a given block. (Note that this error is issued on exit
from the when block, so you won't get the error if the match fails,
or if you use an explicit continue.)
\cX, X must be a printable (non-control) ASCII character.
Note that ASCII characters that don't map to control characters are discouraged, and will generate the warning (when enabled) ``\c%c'' is more clearly written simply as ``%s''.
%c is replaced by either p or P.) You
specified something that isn't a legal Unicode property name. Most
Unicode properties are specified by \p{...}. But if the name is a
single character one, the braces may be omitted.
pack("C", $x)
where $x is either less than 0 or more than 255; the "C" format is
only for encoding native operating system characters (ASCII, EBCDIC,
and so on) and not for Unicode characters, so Perl behaved as if you meant
pack("C", $x & 255)
If you actually want to pack Unicode codepoints, use the "U" format
instead.
pack("c", $x)
where $x is either less than -128 or more than 127; the "c" format
is only for encoding native operating system characters (ASCII, EBCDIC,
and so on) and not for Unicode characters, so Perl behaved as if you meant
pack("c", $x & 255);
If you actually want to pack Unicode codepoints, use the "U" format
instead.
unpack("H", "\x{2a1}")
where the format expects to process a byte (a character with a value below 256), but a higher value was provided instead. Perl uses the value modulus 256 instead, as if you had provided:
unpack("H", "\x{a1}")
pack("U0W", $x)
where $x is either less than 0 or more than 255. However, U0-mode
expects all values to fall in the interval [0, 255], so Perl behaved
as if you meant:
pack("U0W", $x & 255)
Character(s) in '%c' format wrapped in pack
pack("u", "\x{1f3}b")
where the format expects to process a sequence of bytes (character with a value below 256), but some of the characters had a higher value. Perl uses the character values modulus 256 instead, as if you had provided:
pack("u", "\x{f3}b")
Character(s) in '%c' format wrapped in unpack
unpack("s", "\x{1f3}b")
where the format expects to process a sequence of bytes (character with a value below 256), but some of the characters had a higher value. Perl uses the character values modulus 256 instead, as if you had provided:
unpack("s", "\x{f3}b")
:alias import argument to use charnames, but they
could be defined by a translator installed into $^H{charnames}. See
CUSTOM ALIASES in the charnames manpage.
:alias import argument to use charnames, but they
could be defined by a translator installed into $^H{charnames}.
See CUSTOM ALIASES in the charnames manpage.
chdir() on unopened filehandle %schdir() on a filehandle that was never opened.
\cX construct is intended to be a way to specify
non-printable characters. You used it for a printable one, which
is better written as simply itself, perhaps preceded by a backslash
for non-word characters. Doing it the way you did is not portable
between ASCII and EBCDIC platforms.
s/// operator is not supported.
closedir() attempted on invalid dirhandle %sclose() on unopened filehandle %sAcceptance of these code points is a Perl extension, and you should expect that nothing other than Perl can handle them; Perl itself on EBCDIC platforms before v5.24 does not handle them.
Code points above 0xFFFF_FFFF require larger than a 32 bit word.
Perl also makes no guarantees that the representation of these code points won't change at some point in the future, say when machines become available that have larger than a 64-bit word. At that time, files written by an older Perl would require conversion before being readable by a newer Perl.
Perl allows strings to contain a superset of Unicode code points, but these may not be accepted by other languages/systems. Further, even if these languages/systems accept these large code points, they may have chosen a different representation for them than the UTF-8-like one that Perl has, which would mean files are not exchangeable between them and Perl.
On EBCDIC platforms, code points above 0x3FFF_FFFF have a different representation in Perl v5.24 than before, so any file containing these that was written before that version will require conversion before being readable by a later Perl.
#!/usr/bin/perl
#!/usr/bin/perl
#!/usr/bin/perl
require statement.
Perl uses this generic message when none of the errors that it
encountered were severe enough to halt compilation immediately.
while) rather than
in the regular expression engine; or rewriting the regular expression so
that it is simpler or backtracks less. (See the perlfaq2 manpage for information
on Mastering Regular Expressions.)
connect() on closed socket %ssocket() call? See
connect in the perlfunc manpage.
use constant pragma)
is being dereferenced, but it amounts to the wrong type of reference.
The message indicates the type of reference that was expected. This
usually indicates a syntax error in dereferencing the constant value.
See Constant Functions in the perlsub manpage and the constant manpage.
my $var;
$sub = sub () { $var };
but $var is referenced elsewhere and could be modified after the sub
expression is evaluated. Either it is explicitly modified elsewhere
($var = 3) or it is passed to a subroutine or to an operator like
printf or map, which may or may not modify the variable.
Traditionally, Perl has captured the value of the variable at that point and turned the subroutine into a constant eligible for inlining. In those cases where the variable can be modified elsewhere, this breaks the behavior of closures, in which the subroutine captures the variable itself, rather than its value, so future changes to the variable are reflected in the subroutine's return value.
This usage is deprecated, and will no longer be allowed in Perl 5.32, making it possible to change the behavior in the future.
If you intended for the subroutine to be eligible for inlining, then make sure the variable is not referenced elsewhere, possibly by copying it:
my $var2 = $var;
$sub = sub () { $var2 };
If you do want this subroutine to be a closure that reflects future
changes to the variable that it closes over, add an explicit return:
my $var;
$sub = sub () { return $var };
Constant(%s) unknown\N{...} escape. Perhaps you
forgot to load the corresponding the overload manpage pragma?
no warnings
'experimental::const_attr', but know that in doing so you are taking
the risk that your code may break in a future Perl version.
CORE:: namespace
with &foo syntax or through a reference. Some subroutines
in this package cannot yet be called that way, but must be
called as barewords. Something like this will work:
BEGIN { *shove = \&CORE::push; }
shove @array, 1,2,3; # pushes on to @array
my, state, our, or
local. Simply suppress the warning if you want to use the feature, but
know that in doing so you are taking the risk of using an experimental
feature which may change or be removed in a future Perl version:
no warnings "experimental::declared_refs";
use feature "declared_refs";
$fooref = my \$foo;
This threshold can be changed from 100, by recompiling the perl binary,
setting the C pre-processor macro PERL_SUB_DEPTH_WARN to the desired value.
(?(DEFINE)...|..) which is illegal. The
most likely cause of this error is that you left out a parenthesis inside
of the .... part.
The <-- HERE shows whereabouts in the regular expression the problem was discovered.
$VERSION.
delete must be either a hash or array element,
such as:
$foo{$bar}
$ref->{"susie"}[12]
or a hash or array slice, such as:
@foo[$bar, $baz, $xyzzy]
@{$ref->[12]}{"susie", "queue"}
or a hash key/value or array index/value slice, such as:
%foo[$bar, $baz, $xyzzy]
%{$ref->[12]}{"susie", "queue"}
<<FOO, the label FOO is too
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
my() in false conditional. This will be a fatal error in Perl 5.30my $x if 0. There
has been a long-standing bug in Perl that causes a lexical variable
not to be cleared at scope exit when its declaration includes a false
conditional. Some people have exploited this bug to achieve a kind of
static variable. Since we intend to fix this bug, we don't want people
relying on this behavior. You can achieve a similar static effect by
declaring the variable in a separate block outside the function, eg
sub f { my $x if 0; return $x++ }
becomes
{ my $x; sub f { return $x++ } }
Beginning with perl 5.10.0, you can also use state variables to have
lexicals that are initialized only once (see the feature manpage):
sub f { state $x; return $x++ }
This use of my() in a false conditional has been deprecated since
Perl 5.10, and it will become a fatal error in Perl 5.30.
DESTROY() method created a new reference to the object which is
just being DESTROYed. Perl is confused, and prefers to abort rather
than to create a dangling reference.
die() an empty string (the equivalent of die "") or
you called it with no args and $@ was empty.
$VERSION.
do "somefile"; would search the current
directory for the specified file. Since perl v5.26.0, . has been
removed from @INC by default, so this is no longer true. To search the
current directory (and only the current directory) you can write
do "./somefile"; .
PerlIO_getname, a perl internal I/O function specific to VMS, was
somehow called on another platform. This should not happen.
safemalloc() instead.
dump() must be written as CORE::dump() as of Perl 5.30dump() built-in function. That was deprecated in
Perl 5.8.0. As of Perl 5.30 it must be written in fully qualified format:
CORE::dump().
free() ignoredfree() on something that had
already been freed.
\b{}, \B{}, \o{}, \p, \P, or
\x without specifying anything for it to operate on.
Unfortunately, for backwards compatibility reasons, an empty \x is
legal outside use re 'strict' and expands to a NUL character.
use re 'strict')
(?) does nothing, so perhaps this is a typo.
${^ENCODING}, formerly used to implement
the encoding pragma, is no longer supported as of Perl 5.26.0.
Setting it to anything other than undef is a fatal error as of Perl
5.28.
use filetest pragma, switching the real and
effective uids or gids failed.
%ENV variable has been
aliased to another hash, so it doesn't reflect anymore the state of the
program's environment. This is potentially insecure.
(?{ ... }) zero-width assertion, which
is unsafe. See (?{ code }) in the perlre manpage, and the perlsec manpage.
(?{ ... }) zero-width assertion at run time, as it would when the
pattern contains interpolated values. Since that is a security risk,
it is not allowed. If you insist, you may still do this by using the
re 'eval' pragma or by explicitly building the pattern from an
interpolated string at run time and using that in an eval(). See
(?{ code }) in the perlre manpage.
(?{ ... }) zero-width
assertion, but that construct is only allowed when the use re 'eval'
pragma is in effect. See (?{ code }) in the perlre manpage.
The <-- HERE shows whereabouts in the regular expression the problem was discovered.
glob() operator, or put the filenames into a
variable and glob that.
exec function is not implemented on some systems, e.g., Symbian
OS. See the perlport manpage.
exists must be a hash or array element or a
subroutine with an ampersand, such as:
$foo{$bar}
$ref->{"susie"}[12]
&do_something
exists for exists &sub must be a subroutine name,
and not a subroutine call. exists &sub() will generate this error.
(?13
to denote a capturing group of the form
(?PARNO),
but omitted the ")".
(?[ ... (?flags:(?[ ... ])) ... ])
^
we expected to see a close paren ')' (marked by ^) but did not.
(?[ ... (?flags:(?[ ... ])) ... ])
^
we expected to see a close paren ')' (marked by ^) but did not.
(?[...]) extended character class regular expression construct
only allows character classes (including character class escapes like
\d), operators, and parentheses. The one exception is (?flags:...)
containing at least one flag and exactly one (?[...]) construct.
This allows a regular expression containing just (?[...]) to be
interpolated. If you see this error message, then you probably
have some other (?...) construct inside your character class. See
Extended Bracketed Character Classes in the perlrecharclass manpage.
no warnings "experimental::refaliasing";
use feature "refaliasing";
\$x = \$y;
each, keys,
push, pop, shift, splice, unshift, and values to be called with a
scalar argument. This experiment is considered unsuccessful, and
has been removed. The postderef feature may meet your needs better.
no warnings "experimental::signatures";
use feature "signatures";
sub foo ($left, $right) { ... }
-i
command-line switch, failed.
\d or [:alpha:]. The ``-''
in your false range is interpreted as a literal ``-''. In a (?[...])
construct, this is an error, rather than a warning. Consider quoting
the ``-'', ``\-''. The <-- HERE shows whereabouts in the regular expression
the problem was discovered. See the perlre manpage.
u63 as the format.
File::Glob has a function called glob, which
just calls bsd_glob. However, its prototype is different from the
prototype of CORE::glob, and hence, File::Glob::glob should
not be used.
File::Glob::glob() was deprecated in perl 5.8.0. A deprecation
message was issued from perl 5.26.0 onwards, and the function will
disappear in perl 5.30.0.
Code using File::Glob::glob() should call
File::Glob::bsd_glob() instead.
flock() on closed filehandle %sflock() got itself closed
some time before now. Check your control flow. flock() operates on
filehandles. Are you attempting to call flock() on a dirhandle by the
same name?
{
no warnings 'redefine';
eval "format NAME =...";
}
if ($foo = 123)
when you meant
if ($foo == 123)
(or something like that).
socket() call?
sys$getuai underlying the
getpwnam operator returned an invalid UIC.
getsockopt() on closed socket %ssocket() call? See
getsockopt in the perlfunc manpage.
given depends on smartmatch, which
is experimental, so its behavior may change or even be removed
in any future release of perl. See the explanation under
Experimental Details on given and when in the perlsyn manpage.
program(s) used
for glob and <*.c>. Usually, this means that you supplied a glob
pattern that caused the external program to fail and exit with a
nonzero status. If the message indicates that the abnormal exit
resulted in a coredump, this may also mean that your csh (C shell)
is broken. If so, you should change all of the csh-related variables
in config.sh: If you have tcsh, make the variables refer to it as
if it were csh (e.g. full_csh='/usr/bin/tcsh'); otherwise, make them
all empty (except that d_csh should be 'undef') so that Perl will
think csh is missing. In either case, after editing config.sh, run
./Configure -S and rebuild Perl.
gmtime(%f) failedgmtime with a number that it could not handle:
too large, too small, or NaN. The returned value is undef.
gmtime(%f) too largegmtime with a number that was larger than
it can reliably handle and gmtime probably returned the wrong
date. This warning is also triggered with NaN (the special
not-a-number value).
gmtime(%f) too smallgmtime with a number that was smaller than
it can reliably handle and gmtime probably returned the wrong date.
goto &sub syntax, but
the indicated subroutine hasn't been defined, or if it was, it
has since been undefined.
perl -c fails.
$A::B). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
\N{...}) may return a
zero-length sequence. When such an escape is used in a character
class its behavior is not well defined. Check that the correct
escape has been used, and the correct charname handler is in scope.
$, @ or % sigil character. Normally the sigil
should be followed by the variable name or = etc. Perhaps you are
trying use a prototype while in the scope of use feature 'signatures'?
For example:
sub foo ($$) {} # legal - a prototype
use feature 'signatures;
sub foo ($$) {} # illegal - was expecting a signature
sub foo ($a, $b)
:prototype($$) {} # legal
use feature 'signatures'), so your signature was
instead interpreted as a bad prototype.
sub keyword to construct an anonymous subroutine,
you must always specify a block of code. See the perlsub manpage.
vec() (the third argument) must be a power of
two from 1 to 32 (or 64, if your platform supports that).
= introducing a default, , or ).
use feature 'signatures';
sub foo ($=1) {} # legal
sub foo ($a = 1) {} # legal
sub foo ($a += 1) {} # illegal
sub foo ($a == 1) {} # illegal
(?+foo)
The "+" is valid only when followed by digits, indicating a
capturing group. See
(?PARNO).
\p{} or \P{}) that Perl knows isn't an official
Unicode property, and was likely meant to be a user-defined property
name, but it can't be one of those, as they must begin with either In
or Is. Check the spelling. See also
Can't find Unicode property definition ``%s.
=
delimiter used to separate keys from values. The element is ignored.
DESTROY() method raised
the indicated exception. Since destructors are usually called by the
system at arbitrary points during execution, and often a vast number of
times, the warning is issued only once for any number of failures that
would otherwise result in the same message being repeated.
Failure of user callbacks dispatched using the G_KEEPERR flag could
also result in this warning. See G_KEEPERR in the perlcall manpage.
(?[ ]). This can happen if the
expression inside the construct was completely empty, or if there are
too many or few operands for the number of operators. Perl is not smart
enough to give you a more precise indication as to what is wrong.
For example, line 2 below is wrong because it does not have at least 2 spaces, but lines 1 and 3 are fine because they have at least 2:
if ($something) {
print <<~EOF;
Line 1
Line 2 not
Line 3
EOF
}
Note that tabs and spaces are compared strictly, meaning 1 tab will not match 8 spaces.
/(?{ s!!! })/, which resulted in re-executing
the same pattern, which is an infinite loop which is broken by
throwing an exception.
state only permits initializing a single variable, specified
without parentheses. So state $a = 42 and state @a = qw(a b c) are
allowed, but not state ($a) = 42 or (state $a) = 42. To initialize
more than one state variable, initialize them one at a time.
$foo[&bar] always behaves like a scalar, both in the value it
returns and when evaluating its argument, while %foo[&bar] provides
a list context to its subscript, which can do weird things if you're
expecting only one subscript. When called in list context, it also
returns the index (what &bar returns) in addition to the value.
$foo{&bar} always behaves like a scalar, both in the value
it returns and when evaluating its argument, while @foo{&bar} and
provides a list context to its subscript, which can do weird things
if you're expecting only one subscript. When called in list context,
it also returns the key in addition to the value.
$ENV{PATH} contains a directory that is writable by
the world. Also, the PATH must not contain any relative directory.
See the perlsec manpage.
$ENV{PATH}, $ENV{IFS}, $ENV{CDPATH},
$ENV{ENV}, $ENV{BASH_ENV} or $ENV{TERM} are derived from data
supplied (or potentially supplied) by the user. The script must set
the path to a known value, using trustworthy data. See the perlsec manpage.
\p{IsFoo} or \p{InFoo}.
See User-Defined Character Properties in the perlunicode manpage and the perlsec manpage.
printf()
or sprintf() are too large. The numbers must not overflow the size of
integers for your architecture.
hex() or oct() is too big for
your architecture, and has been converted to a floating point number.
On a 32-bit architecture the largest hexadecimal, octal or binary number
representable without overflow is 0xFFFFFFFF, 037777777777, or
0b11111111111111111111111111111111 respectively. Note that Perl
transparently promotes all numbers to a floating point representation
internally--subject to loss of precision errors in subsequent
operations.
fork and exec, to determine whether the current call
to exec should affect the current script or a subprocess (see
exec LIST in the perlvms manpage). Somehow, this count has become scrambled, so
Perl is making a guess and treating this exec as a request to
terminate the Perl script and execute the specified command.
printf and sprintf
formatting follows a slightly different set of rules when called from
C or XS code. Specifically, formats consisting of digits followed
by ``p'' (e.g., ``%7p'') are reserved for future use. If you see this
message, then an XS module tried to call that routine with one such
reserved format.
"(?" in this context in a regular
expression pattern should be an indivisible token, with nothing
intervening between the "(" and the "?", but you separated them
with whitespace.
"(*" in this context in a regular
expression pattern should be an indivisible token, with nothing
intervening between the "(" and the "*", but you separated them.
Fix the pattern and retry.
:alias option to use charnames and the specified character in
the indicated name isn't valid. See CUSTOM ALIASES in the charnames manpage.
\xHH) of value < 256
didn't correspond to a single character through the conversion
from the encoding specified by the encoding pragma.
The escape was replaced with REPLACEMENT CHARACTER (U+FFFD)
instead, except within (?[ ]), where it is a fatal error.
The <-- HERE shows whereabouts in the regular expression the
escape was discovered.
... is not a valid hexadecimal
number. Either it is empty, or you tried to use a character other than
0 - 9 or A - F, a - f in a hexadecimal number.
mro::set_mro("classname", "foo") or use mro 'foo',
where foo is not a valid method resolution order (MRO). Currently,
the only valid ones supported are dfs and c3, unless you have loaded
a module that is a MRO plugin. See the mro manpage and the perlmroapi manpage.
chr. Negative numbers are
not valid character numbers, so it returns the Unicode replacement
character (U+FFFD).
{} from your ending \x{} - \x without the curly braces can go only
up to ff. The <-- HERE shows whereabouts in the regular expression the
problem was discovered. See the perlre manpage.
(W) The given character is not a valid pack or unpack type but used to be silently ignored.
"(*" in this context in a regular
expression pattern should be an indivisible token, with nothing
intervening between the "(" and the "*", but you separated them.
ioctl() on unopened %sioctl() on a filehandle that was never opened.
Check your control flow and number of arguments.
sockatmark() functionality,
neither as a system call nor an ioctl call (SIOCATMARK).
\b{...} or \B{...} and the ... is not known to
Perl. The current valid ones are given in
\b{}, \b, \B{}, \B in the perlrebackslash manpage.
syswrite() and send() operators are
not allowed on handles that have the :utf8 layer, either explicitly, or
implicitly, eg., with the :encoding(UTF-16LE) layer.
Previously sysread() and recv() currently use only the :utf8 flag for the stream,
ignoring the actual layers. Since sysread() and recv() did no UTF-8
validation they can end up creating invalidly encoded scalars.
Similarly, syswrite() and send() used only the :utf8 flag, otherwise ignoring
any layers. If the flag is set, both wrote the value UTF-8 encoded, even if
the layer is some different encoding, such as the example above.
Ideally, all of these operators would completely ignore the :utf8 state,
working only with bytes, but this would result in silently breaking existing
code.
use re 'strict' or within (?[...]))
You specified a character that has the given plainer way of writing it, and which is also portable to platforms running with different character sets.
$*, deprecated in older perls, was removed in
5.10.0, is no longer supported and is a fatal error as of Perl 5.30. In
previous versions of perl the use of $* enabled or disabled multi-line
matching within a string.
Instead of using $* you should use the /m (and maybe /s) regexp
modifiers. You can enable /m for a lexical scope (even a whole file)
with use re '/m'. (In older versions: when $* was set to a true value
then all regular expressions behaved as if they were written using /m.)
Use of this variable will be a fatal error in Perl 5.30.
$#, deprecated in older perls, was removed as of
5.10.0, is no longer supported and is a fatal error as of Perl 5.30. You
should use the printf/sprintf functions instead.
-i option was passed on the command line, indicating
that the script is intended to edit files in place, but no files were
given. This is usually a mistake, since editing STDIN in place doesn't
make sense, and can be confusing because it can make perl look like
it is hanging when it is really just trying to read from STDIN. You
should either pass a filename to edit, or remove -i from the command
line. See the perlrun manpage for more details.
use filetest pragma, switching the real and
effective uids or gids failed.
length() used on %s (did you mean ``scalar(%s)''?)length() on either an array or a hash when you
probably wanted a count of the items.
Array size can be obtained by doing:
scalar(@array);
The number of items in a hash can be obtained by doing:
scalar(keys %hash);
listen() on closed socket %ssocket() call? See
listen in the perlfunc manpage.
open does not support pipes, such as open($pipe, '|-', @args).
Use the two-argument open($pipe, '|prog arg1 arg2...') form instead.
use re 'strict' or within (?[...]))
Likely you forgot the /x modifier or there was a typo in the pattern.
For example, did you really mean to match a form-feed? If so, all the
ASCII vertical space control characters are representable by escape
sequences which won't present such a jarring appearance as your pattern
does when displayed.
\r carriage return \f form feed \n line feed \cK vertical tab
.so or .dll was being loaded into the
process that was built against a different build of perl than the
said library was compiled against. Reinstalling the XS module will
likely fix this error.
One of these is because that, contrary to the claims, Unicode is not
completely locale insensitive. Turkish and some related languages
have two types of "I" characters. One is dotted in both upper- and
lowercase, and the other is dotless in both cases. Unicode allows a
locale to use either the Turkish rules, or the rules used in all other
instances, where there is only one type of "I", which is dotless in
the uppercase, and dotted in the lower. The perl core does not (yet)
handle the Turkish case, and this message warns you of that. Instead,
the the Unicode::Casing manpage module allows you to mostly implement the Turkish
casing rules.
The other common cause is for the characters
$ + < = > ^ ` | ~
These are probematic. The C standard says that these should be
considered punctuation in the C locale (and the POSIX standard defers to
the C standard), and Unicode is generally considered a superset of
the C locale. But Unicode has added an extra category, ``Symbol'', and
classifies these particular characters as being symbols. Most UTF-8
locales have them treated as punctuation, so that ispunct(2) returns
non-zero for them. But a few locales have it return 0. Perl takes
the first approach, not using ispunct() at all (see Note [5] in perlrecharclass), and this message is raised to notify you that you
are getting Perl's approach, not the locale's.
%s gives a reason.
By far the most common reason is that the locale has characters in it that are represented by more than one byte. The only such locales that Perl can handle are the UTF-8 locales. Most likely the specified locale is a non-UTF-8 one for an East Asian language such as Chinese or Japanese. If the locale is a superset of ASCII, the ASCII portion of it may work in Perl.
Some essentially obsolete locales that aren't supersets of ASCII, mainly those in ISO 646 or other 7-bit locales, such as ASMO 449, can also have problems, depending on what portions of the ASCII character set get changed by the locale and are also used by the program. The warning message lists the determinable conflicting characters.
Note that not all incompatibilities are found.
If this happens to you, there's not much you can do except switch to use a different locale or use the Encode manpage to translate from the locale into UTF-8; if that's impracticable, you have been warned that some things may break.
This message is output once each time a bad locale is switched into
within the scope of use locale, or on the first possibly-affected
operation if the use locale inherits a bad one. It is not raised
for any operations from the the POSIX manpage module.
localtime(%f) failedlocaltime with a number that it could not handle:
too large, too small, or NaN. The returned value is undef.
localtime(%f) too largelocaltime with a number that was larger
than it can reliably handle and localtime probably returned the
wrong date. This warning is also triggered with NaN (the special
not-a-number value).
localtime(%f) too smalllocaltime with a number that was smaller
than it can reliably handle and localtime probably returned the
wrong date.
++ or -- is unchanged. Perl issues this
warning because it has already switched from integers to floating point
when values are too large for integers, and now even floating point is
insufficient. You may wish to switch to using the Math::BigInt manpage explicitly.
lstat() on filehandle%slstat() makes sense only on filenames. (Perl did a fstat()
instead on the filehandle.)
:lvalue declarative syntax to make a Perl
subroutine an lvalue subroutine after it has been defined is
not permitted. To make the subroutine an lvalue subroutine,
add the lvalue attribute to the definition, or put the sub
foo :lvalue; declaration before the definition.
See also attributes.pm.
prefix1;prefix2
or prefix1 prefix2
with nonempty prefix1 and prefix2. If prefix1 is indeed a prefix of
a builtin library search path, prefix2 is substituted. The error may
appear if components are not found, or are too long. See
``PERLLIB_PREFIX'' in perlos2.
use feature 'signatures'),
so the signature was instead interpreted as a bad prototype.
%s, part of the message.
One possible cause is that you set the UTF8 flag yourself for data that
you thought to be in UTF-8 but it wasn't (it was for example legacy 8-bit
data). To guard against this, you can use Encode::decode('UTF-8', ...).
If you use the :encoding(UTF-8) PerlIO layer for input, invalid byte
sequences are handled gracefully, but if you use :utf8, the flag is set
without validating the data, possibly resulting in this error message.
%s is replaced by a string that can be used
by knowledgeable people to determine what the type being checked
against was.
Passing malformed strings was deprecated in Perl 5.18, and became fatal in Perl 5.26.
\p{...} or
\P{...}. Unicode properties are only defined on Unicode code points,
so the result of this match is undefined by Unicode, but Perl (starting
in v5.20) treats non-Unicode code points as if they were typical
unassigned Unicode ones, and matched this one accordingly. Whether a
given property matches these code points or not is specified in
perluniprops/Properties accessible through \p{} and \P{}.
This message is suppressed (unless it has been made fatal) if it is
immaterial to the results of the match if the code point is Unicode or
not. For example, the property \p{ASCII_Hex_Digit} only can match
the 22 characters [0-9A-Fa-f], so obviously all other code points,
Unicode or not, won't match it. (And \P{ASCII_Hex_Digit} will match
every code point except these 22.)
Getting this message indicates that the outcome of the match arguably
should have been the opposite of what actually happened. If you think
that is the case, you may wish to make the non_unicode warnings
category fatal; if you agree with Perl's decision, you may wish to turn
off this category.
See Beyond Unicode code points in the perlunicode manpage for more information.
%n was used in a format string with no corresponding argument for
perl to write the current string length to.
Currently only emitted when a printf-type format required more arguments than were supplied, but might be used in the future for other cases where we can statically determine that arguments to functions are missing, e.g. for the pack in the perlfunc manpage function.
\N{charname} within
double-quotish context. This can also happen when there is a space
(or comment) between the \N and the { in a regex with the /x modifier.
This modifier does not change the requirement that the brace immediately
follow the \N.
\o must be followed immediately by a { in double-quotish context.
open(FH, "| command") or
open(FH, "command |") construction, but the command was missing or
blank.
[ but never closed with ].
\x{...}, \p{...}, \P{...}, or \N{...}.
\N has two meanings.
The traditional one has it followed by a name enclosed in braces,
meaning the character (or sequence of characters) given by that
name. Thus \N{ASTERISK} is another way of writing *, valid in both
double-quoted strings and regular expression patterns. In patterns,
it doesn't have the meaning an unescaped * does.
Starting in Perl 5.12.0, \N also can have an additional meaning (only)
in patterns, namely to match a non-newline character. (This is short
for [^\n], and like . but is not affected by the /s regex modifier.)
This can lead to some ambiguities. When \N is not followed immediately
by a left brace, Perl assumes the [^\n] meaning. Also, if the braces
form a valid quantifier such as \N{3} or \N{5,}, Perl assumes that this
means to match the given quantity of non-newlines (in these examples,
3; and 5 or more, respectively). In all other case, where there is a
\N{ and a matching }, Perl assumes that a character name is desired.
However, if there is no matching }, Perl doesn't know if it was
mistakenly omitted, or if [^\n]{ was desired, and raises this error.
If you meant the former, add the right brace; if you meant the latter,
escape the brace with a backslash, like so: \N\{
sub mod { $_[0] = 1 }
mod(2);
Another way is to assign to a substr() that's off the end of the string.
Yet another way is to assign to a foreach loop VAR when VAR
is aliased to a constant in the look LIST:
$x = 1;
foreach my $n ($x, 2) {
$n *= 2; # modifies the $x, but fails on attempt to
} # modify the 2
-M or -m options say that Perl should load some module, but
you omitted the name of the module. Consult the perlrun manpage for full details
about -M and -m.
open function has been asked to open multiple files. This
can happen if you are trying to open a pipe to a command that takes a
list of arguments, but have forgotten to specify a piped open mode.
See open in the perlfunc manpage for details.
$foo[1,2,3].
They're written like $foo[1][2][3], as in C.
@ or %) must be
the last parameter, and there must not be more than one of them; for
example:
sub foo ($a, @b) {} # legal
sub foo ($a, @b, %) {} # invalid
tr/// and y///) transliterates individual
characters. But a named sequence by definition is more than an
individual character, and hence doing this operation on it doesn't make
sense.
<=> or cmp operator inside a
sort comparison block, and the variable had earlier been declared as a
lexical variable. Either qualify the sort variable with the package
name, or rename the lexical variable.
local() if you want to localize a package variable.
our
declaration is also provided for this purpose.
NOTE: This warning detects package symbols that have been used only once. This means lexical variables will never trigger this warning. It also means that all of the package variables $c, @c, %c, as well as *c, &c, sub c{}, c(), and c (the filehandle or format) are considered the same; if a program uses $c only once but also uses any of the others it will not trigger this warning. Symbols beginning with an underscore and symbols using special identifiers (q.v. the perldata manpage) are exempt from this warning.
(?[ ]), all constants interpreted as octal need to be
exactly 3 digits long. This helps catch some ambiguities. If your
constant is too short, add leading zeros, like
(?[ [ \078 ] ]) # Syntax error! (?[ [ \0078 ] ]) # Works (?[ [ \007 8 ] ]) # Clearer
The maximum number this construct can express is \777. If you
need a larger one, you need to use \o{} instead. If you meant
two separate things, you need to separate them:
(?[ [ \7776 ] ]) # Syntax error!
(?[ [ \o{7776} ] ]) # One meaning
(?[ [ \777 6 ] ]) # Another meaning
(?[ [ \777 \006 ] ]) # Still another
vec is called in an lvalue context, the second argument must be
greater than or equal to zero.
x repetition operator fewer than 0
times, which doesn't make sense.
Note that the minimal matching quantifiers, *?, +?, and
?? appear to be nested quantifiers, but aren't. See the perlre manpage.
next::method needs to be called within the context of a
real method in a real package, and it could not find such a context.
See the mro manpage.
\N as [^\n] is not valid in a
bracketed character class, for the same reason that . in a character
class loses its specialness: it matches almost everything, which is
probably not what you want.
\N{...}) may return a
multi-character sequence. Even though a character class is
supposed to match just one character of input, perl will match the
whole thing correctly, except under certain conditions. These currently
are
[^...])\N{...} is used as one of the end points of the range, such as in
[\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
What is meant here is unclear, as the \N{...} escape is a sequence
of code points, so this is made an error.
(?[ ]) in a regular expression yields a list of
single code points, none can be a sequence.
perl -e ""
perl -e0
perl -e1
One possible cause for this is that you expected to have imported a constant to your name space with use or import while no such importing took place, it may for example be that your operating system does not support that particular constant. Hopefully you did use an explicit import list for the constants you expect to see; please see use in the perlfunc manpage and import in the perlfunc manpage. While an explicit import list would probably have caught this error earlier it naturally does not remedy the fact that your operating system still does not support that constant. Maybe you have a typo in the constants of the symbol import list of use or import or in the constant name at the line where this error was triggered?
Devel::
module) didn't define a routine to be called at the beginning of each
statement.
Devel::
module) didn't define a DB::sub routine to be called at the beginning
of each ordinary subroutine call.
next::method found no further instances of this method name
in the remaining packages of the MRO of this class. If you don't want
it throwing an exception, use maybe::next::method
or next::can. See the mro manpage.
x repetition operator Inf (or
-Inf) or NaN times, which doesn't make sense.
(?[ [ \xDG ] ])
(?[ [ \x{DEKA} ] ])
(?[ [ \o{1278} ] ])
vec() function to construct the file descriptor bitmasks for
select. See select in the perlfunc manpage.
perl -x, but no line was found in the file beginning
with #! and containing the word ``perl''.
setregid() call for
your system.
setreuid() call for
your system.
__DIE__ and __WARN__ as valid signal hooks.
my_pclose() tried to
close a pipe which hadn't been opened. This should have been caught
earlier as an attempt to close an unopened filehandle.
kill -l in your shell to see the valid signal
names on your system.
ref() function to find out what kind of ref it really was. See
also the perlref manpage.
*foo), but found a reference to
something else instead. You can use the ref() function to find out what
kind of ref it really was. See the perlref manpage.
ref() function to
find out what kind of ref it really was. See the perlref manpage.
$, @ or %), needs to be separated by whitespace or a comma etc., in
particular to avoid confusion with the $# variable. For example:
# bad
sub f ($# ignore first arg
, $b) {}
# good
sub f ($, # ignore first arg
$b) {}
ref() function
to find out what kind of ref it really was. See the perlref manpage.
ref() function
to find out what kind of ref it really was. See the perlref manpage.
ref() function to find out what kind of ref it really was. See
also the perlref manpage.
run() with a null opcode
pointer.
\o{}, with no number between
the braces.
The message attempts to include the name of the called subroutine. If the subroutine has been aliased, the subroutine's original name will be shown, regardless of what name the caller used.
sysread()ing a file, or when seeking past the end of a scalar opened
for I/O (in anticipation of future reads and to imitate the behavior
with real files).
"In $name's house". This
is equivalent to "In $name::s house". If you meant the former, put
a backslash before the apostrophe ("In $name\'s house").
socket()
call, or call a constructor from the FileHandle package.
(?[ \p{Digit} \p{Thai} ])
There are two operands, but no operator giving how you want to combine them.
fallback overloading key is specified to be true. See the overload manpage.
If the operation shown is ``ToFold'', it means that case-insensitive matching in a regular expression was done on the code point.
If you know what you are doing you can turn off this warning by
no warnings 'non_unicode';.
If the operation shown is ``ToFold'', it means that case-insensitive matching in a regular expression was done on the code point.
If you know what you are doing you can turn off this warning by
no warnings 'surrogate';.
malloc() function returned 0, indicating there was insufficient
remaining memory (or virtual memory) to satisfy the request. Perl has
no option but to exit immediately.
At least in Unix you may be able to get past this by increasing your
process datasize limits: in csh/tcsh use limit and
limit datasize n (where n is the number of kilobytes) to check
the current limits and change them, and in ksh/bash/zsh use ulimit -a
and ulimit -d n, respectively.
malloc() function returned 0, indicating there was insufficient
remaining memory (or virtual memory) to satisfy the request. However,
the request was judged large enough (compile-time default is 64K), so a
possibility to shut down by trapping this error is granted.
malloc() function returned 0, indicating there was
insufficient remaining memory (or virtual memory) to satisfy the
request.
The request was judged to be small, so the possibility to trap it
depends on the way perl was compiled. By default it is not trappable.
However, if compiled for this, Perl may use the contents of $^M as an
emergency pool after die()ing with this message. In this case the error
is trappable once, and the error message will include the line and file
where the failed request happened.
$arr[time] instead of $arr[$time].
realloc() wouldn't give it more memory, virtual or
otherwise.
qr overload was used as part of a match, but the
overloaded operation didn't return a compiled regexp. See the overload manpage.
write() produced more lines than can fit on a
page. See the perlform manpage.
pp_subst() routine was called with invalid operational
data.
eval
failure was caught.
frexp() failed, making printf(``%f'') impossible.
pp_match() routine was called with invalid operational
data.
sv_replace() (%d != 1)sv_replace() function was handed a new SV with a
reference count other than 1.
scan_num() got called on something that wasn't a number.
strxfrm() gets absurd - a => %u, ab => %ustrxfrm() failed.
In your current locale the returned transformation of the string ``ab''
is shorter than that of the string ``a'', which makes no sense.
sv_chop() routine was passed a position that is not within the
scalar's string buffer.
sv_insert() routine was told to remove more string than there
was string.
&CORE::foo()
subroutine calls was unable to determine what type of arguments
were expected.
my $foo, $bar = @_;
when you meant
my ($foo, $bar) = @_;
Remember that ``my'', ``our'', ``local'' and ``state'' bind tighter than comma.
-p destination: %s-p
command-line switch. (This output goes to STDOUT unless you've
redirected it with select().)
:win32 PerlIO layer is
experimental. If you want to take the risk of using this layer,
simply disable this warning:
no warnings "experimental::win32_perlio";
use 5.10 was written instead
of use 5.010 or use v5.10. Without the leading v, the number is
interpreted as a decimal, with every three digits after the
decimal point representing a part of the version number. So 5.10
is equivalent to v5.100.
sh-shell in. See ``PERL_SH_DIR'' in perlos2.
perl: warning: Setting locale failed.
perl: warning: Please check that your locale settings:
LC_ALL = "En_US",
LANG = (unset)
are supported and installed on your system.
perl: warning: Falling back to the standard locale ("C").
Exactly what were the failed locale settings varies. In the above the settings were that the LC_ALL was ``En_US'' and the LANG had no value. This error means that Perl detected that you and/or your operating system supplier and/or system administrator have set up the so-called locale system but Perl could not use those settings. This was not dead serious, fortunately: there is a ``default locale'' called ``C'' that Perl can and will use, and the script will be run. Before you really fix the problem, however, you will get the same error message each time you run Perl. How to really fix the problem can be found in the perllocale manpage section LOCALE PROBLEMS.
Numeric | String | Result
--------+---------------+-----------------------------------------
0 | NO | Disables key traversal randomization
1 | RANDOM | Enables full key traversal randomization
2 | DETERMINISTIC | Enables repeatable key traversal
| | randomization
Both numeric and string values are accepted, but note that string values are case sensitive. The default for this setting is ``RANDOM'' or 1.
Waitpid() was asked to wait for a
process which isn't a subprocess of the current process. While this is
fine from VMS' perspective, it's probably not what you intended.
is prefix
the corresponding C interfaces have: in other words, it's [[:print:]],
not isprint. See the perlre manpage.
qr/[012[:alpha:]345]/. What the regular
expression pattern compiled to is probably not what you were intending.
For example, qr/[:alpha:]/ compiles to a regular bracketed character
class consisting of the four characters ":", "a", "l",
"h", and "p". To specify the POSIX class, it should have been
written qr/[[:alpha:]]/.
Note that [= =] and [. .] are not currently implemented; they are simply placeholders for future extensions and will cause fatal errors. The <-- HERE shows whereabouts in the regular expression the problem was discovered. See the perlre manpage.
If the specification of the class was not completely valid, the message indicates that.
qw() listqw() lists contain items separated by whitespace; as with literal
strings, comment characters are not ignored, but are instead treated as
literal data. (You may have used different delimiters than the
parentheses shown here; braces are also frequently used.)
You probably wrote something like this:
@list = qw(
a # a comment
b # another comment
);
when you should have written this:
@list = qw(
a
b
);
If you really want comments, build your list the old-fashioned way, with quotes and commas:
@list = (
'a', # a comment
'b', # another comment
);
qw() lists contain items separated by whitespace; therefore
commas aren't needed to separate the items. (You may have used
different delimiters than the parentheses shown here; braces are also
frequently used.)
You probably wrote something like this:
qw! a, b, c !;
which puts literal commas into some of the list items. Write it without commas if you don't want them to appear in your data:
qw! a b c !;
ioctl() or fcntl() returned more than Perl was bargaining for.
Perl guesses a reasonable buffer size, but puts a sentinel byte at the
end of the buffer just in case. This sentinel byte got clobbered, and
Perl assumes that memory is now corrupted. See ioctl in the perlfunc manpage.
return) and a low-precedence operator like
or. Consider:
sub { return $a or $b; }
This is parsed as:
sub { (return $a) or $b; }
Which is effectively just:
sub { return $a; }
Either use parentheses or the high-precedence variant of the operator.
Note this may be also triggered for constructs like:
sub { 1 if die; }
if ($x & $y == 0) { ... }
This expression is actually equivalent to $x & ($y == 0), due to the
higher precedence of ==. This is probably not what you want. (If you
really meant to write this, disable the warning, or, better, put the
parentheses explicitly and write $x & ($y == 0)).
m/$\/ in a regex.
The regex m/foo$\s+bar/m translates to: match the word 'foo', the output
record separator (see $\ in the perlvar manpage) and the letter 's' (one time or more)
followed by the word 'bar'.
If this is what you intended then you can silence the warning by using
m/${\}/ (for example: m/foo${\}s+bar/).
If instead you intended to match the word 'foo' at the end of the line
followed by whitespace and the word 'bar' on the next line then you can use
m/$(?)\/ (for example: m/foo$(?)\s+bar/).
@foo in scope at the time. If you wanted a
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
open(%s)
open FOO || die;
is now misinterpreted as
open(FOO || die);
because of the strict regularization of Perl 5's grammar into unary and list operators. (The old open was a little of both.) You must put parentheses around the filehandle, or use the new ``or'' operator instead of ``||''.
printf() on closed filehandle %sprint() on closed filehandle %s/abc(?=(?:xyz){3})/, not /abc(?=xyz){3}/.
use re 'strict' or within (?[...]))
Stricter rules help to find typos and other errors. Perhaps you didn't
even intend a range here, if the "-" was meant to be some other
character, or should have been escaped (like "\-"). If you did
intend a range, the one that was used is not portable between ASCII and
EBCDIC platforms, and doesn't have an obvious meaning to a casual
reader.
[3-7] # OK; Obvious and portable [d-g] # OK; Obvious and portable [A-Y] # OK; Obvious and portable [A-z] # WRONG; Not portable; not clear what is meant [a-Z] # WRONG; Not portable; not clear what is meant [%-.] # WRONG; Not portable; not clear what is meant [\x41-Z] # WRONG; Not portable; not obvious to non-geek
(You can force portability by specifying a Unicode range, which means that
the endpoints are specified by
\N{...}, but the meaning may
still not be obvious.)
The stricter rules require that ranges that start or stop with an ASCII
character that is not a control have all their endpoints be the literal
character, and not some escape sequence (like "\x41"), and the ranges
must be all digits, or all uppercase letters, or all lowercase letters.
use re 'strict' or within (?[...]))
Stricter rules help to find typos and other errors. You included a range, and at least one of the end points is a decimal digit. Under the stricter rules, when this happens, both end points should be digits in the same group of 10 consecutive digits.
readdir() attempted on invalid dirhandle %sreadline() on closed filehandle %sread() on closed filehandle %sread() on unopened filehandle %srealloc() of freed memory ignoredrealloc() on something that had
already been freed.
open my
$fh, '<', \$scalar, which implicitly loads PerlIO::scalar. Try
loading PerlIO::scalar explicitly first.
@ISA hierarchy. This is a
crude check that bails out after 100 levels of @ISA depth.
%hash = { one => 1, two => 2, }; # WRONG
%hash = [ qw/ an anon array / ]; # WRONG
%hash = ( one => 1, two => 2, ); # right
%hash = qw( one 1 two 2 ); # also fine
\g0 or similar in a regular expression. You may refer
to capturing parentheses only with strictly positive integers
(normal backreferences) or with strictly negative integers (relative
backreferences). Using 0 does not make sense.
\7 in your regular expression, but there are
not at least seven sets of capturing parentheses in the expression. If
you wanted to have the character with ordinal 7 inserted into the regular
expression, prepend zeroes to make it three digits long: \007
The <-- HERE shows whereabouts in the regular expression the problem was discovered.
\k'NAME' or \k<NAME> in your regular
expression, but there is no corresponding named capturing parentheses
such as (?'NAME'...) or (?<NAME>...). Check if the name has been
spelled correctly both in the backreference and the declaration.
The <-- HERE shows whereabouts in the regular expression the problem was discovered.
\g{-7} in your regular expression, but there
are not at least seven sets of closed capturing parentheses in the
expression before where the \g{-7} was located.
The <-- HERE shows whereabouts in the regular expression the problem was discovered.
safemalloc() should have caught it
earlier.
\08, or \179 in a
double-quotish string. All but the last digit is treated as a single
character, specified in octal. The last digit is the next character in
the string. To tell Perl that this is indeed what you want, you can use
the \o{ } syntax, or use exactly three digits to specify the octal
for the character.
rewinddir() attempted on invalid dirhandle %srewinddir() on is either closed
or not really a dirhandle. Check your control flow.
$foo[&bar] always
behaves like a scalar, both when assigning to it and when evaluating its
argument, while @foo[&bar] behaves like a list when you assign to it,
and provides a list context to its subscript, which can do weird things
if you're expecting only one subscript.
On the other hand, if you were actually hoping to treat the array element as a list, you need to look into how references work, because Perl will not magically convert between scalars and lists for you. See the perlref manpage.
$foo{&bar} always behaves
like a scalar, both when assigning to it and when evaluating its
argument, while @foo{&bar} behaves like a list when you assign to it,
and provides a list context to its subscript, which can do weird things
if you're expecting only one subscript.
On the other hand, if you were actually hoping to treat the hash element as a list, you need to look into how references work, because Perl will not magically convert between scalars and lists for you. See the perlref manpage.
$ from a variable $m may cause this error.
Note that since Perl 5.10.0 a // can also be the defined-or construct, not just the empty search pattern. Therefore code written in Perl 5.10.0 or later that uses the // as the defined-or can be misparsed by pre-5.10.0 Perls as a non-terminated search pattern.
seekdir() attempted on invalid dirhandle %sseekdir() on is either closed or not
really a dirhandle. Check your control flow.
seek() or sysseek() function on a
filehandle that was either never opened or has since been closed.
select() system call.
newSVsv() routine was called to duplicate a
scalar that had previously been marked as free.
send() on closed socket %s(?^...) construct to tell
Perl to use the default regular expression modifiers, and you
redundantly specify a default modifier. For other
causes, see the perlre manpage.
(?&...) was missing the final
closing parenthesis after the name. The <-- HERE shows whereabouts
in the regular expression the problem was discovered.
(?'...') or (?<...>) was missing the final
closing quote or angle bracket. The <-- HERE shows whereabouts in the
regular expression the problem was discovered.
(?('...')...) or (?(<...>)...) was
missing the final closing quote or angle bracket after the name. The
<-- HERE shows whereabouts in the regular expression the problem was
discovered.
(?P>...) was missing the final
closing parenthesis after the name. The <-- HERE shows whereabouts
in the regular expression the problem was discovered.
(?P<...>') was missing the final
closing angle bracket. The <-- HERE shows whereabouts in the
regular expression the problem was discovered.
(?P=...) was missing the final
closing parenthesis after the name. The <-- HERE shows whereabouts
in the regular expression the problem was discovered.
(?R) or (?0) sequence in a regular expression was missing the
final parenthesis.
This is a CGI error, not a Perl error.
You need to make sure your script is executable, is accessible by the user CGI is running the script under (which is probably not the user account you tested it under), does not rely on any environment variables (like PATH) from the user it isn't running under, and isn't in a location where the CGI server can't find it, basically, more or less. Please see the following for more information:
http://www.perl.org/CGI_MetaFAQ.html
http://www.htmlhelp.org/faq/cgifaq.html
http://www.w3.org/Security/Faq/
You should also look at the perlfaq9 manpage.
setegid() not implemented$), and your operating system doesn't
support the setegid() system call (or equivalent), or at least Configure
didn't think so.
seteuid() not implemented$>, and your operating system doesn't
support the seteuid() system call (or equivalent), or at least Configure
didn't think so.
setpgrp() from BSD 4.2, which takes no
arguments, unlike POSIX setpgid(), which takes a process ID and process
group ID.
setrgid() not implemented$(, and your operating system doesn't
support the setrgid() system call (or equivalent), or at least Configure
didn't think so.
setruid() not implemented$<, and your operating system doesn't
support the setruid() system call (or equivalent), or at least Configure
didn't think so.
setsockopt() on closed socket %ssocket() call? See
setsockopt in the perlfunc manpage.
$/ where the referenced item is
not a positive integer. In older perls this appeared to work the same as
setting it to undef but was in fact internally different, less efficient
and with very bad luck could have resulted in your file being split by a
stringified form of the reference.
In Perl 5.20.0 this was changed so that it would be exactly the same as
setting $/ to undef, with the exception that this warning would be thrown.
You are recommended to change your code to set $/ to undef explicitly if
you wish to slurp the file. As of Perl 5.28 assigning $/ to a reference
to an integer which isn't positive is a fatal error.
$/. In older
Perls this would have behaved similarly to setting it to a reference to
a positive integer, where the integer was the address of the reference.
As of Perl 5.20.0 this is a fatal error, to allow future versions of Perl
to use non-integer refs for more interesting purposes.
join. Perl will treat the true or false
result of matching the pattern against $_ as the string, which is
probably not what you had in mind.
shutdown() on closed socket %ssleep(%u) too largesleep with a number that was larger than
it can reliably handle and sleep probably slept for less time than
requested.
~~ operator on an object that does not
overload it: Perl refuses to use the object's underlying structure
for the smart match.
~~) operator. This is currently an experimental
feature, and its details are subject to change in future releases of
Perl. Particularly, its current behavior is noticed for being
unnecessarily complex and unintuitive, and is very likely to be
overhauled.
eval. This is
not permitted under the unicode_eval feature. Consider using
evalbytes instead. See the feature manpage.
splice() offset past end of arrayexec() with some statement after it other than a
die(). This is almost always an error, because exec() never returns
unless there was a failure. You probably wanted to use system()
instead, which does return. To suppress this warning, put the exec() in
a block by itself.
<=> or cmp operator inside a
sort comparison block, and the variable had earlier been declared as a
lexical variable. Either qualify the sort variable with the package
name, or rename the lexical variable.
local() if you want to localize a package variable.
stat() on unopened filehandle %sstat() function on a filehandle that
was either never opened or has since been closed.
can may break this.
sub foo :lvalue ($a, $b) { ... } # 5.20 and 5.28 +
sub foo ($a, $b) :lvalue { ... } # 5.22 .. 5.26
sub { my sub a {...} sub f { \&a } }
At the time that f is created, it can't capture the current ``a'' sub, since the anonymous subroutine hasn't been created yet. Conversely, the following won't give a warning since the anonymous subroutine has by now been created and is live:
sub { my sub a {...} eval 'sub f { \&a }' }->();
The second situation is caused by an eval accessing a lexical subroutine that has gone out of scope, for example,
sub f {
my sub a {...}
sub { eval '\&a' }
}
f()->();
Here, when the '\&a' in the eval is being compiled, f() is not currently
being executed, so its &a is not available for capture.
{
no warnings 'redefine';
eval "sub name { ... }";
}
When the inner subroutine is called, it will see the value of the outer subroutine's lexical subroutine as it was before and during the *first* call to the outer subroutine; in this case, after the first call to the outer subroutine is complete, the inner and outer subroutines will no longer share a common value for the lexical subroutine. In other words, it will no longer be shared. This will especially make a difference if the lexical subroutines accesses lexical variables declared in its surrounding scope.
This problem can usually be solved by making the inner subroutine
anonymous, using the sub {} syntax. When inner anonymous subs that
reference lexical subroutines in outer subroutines are created, they
are automatically rebound to the current values of such lexical subs.
$ from variable $s may cause this error.
$ from variable $s may cause this error.
substr() that pointed outside of
a string. That is, the absolute value of the offset was larger than the
length of the string. See substr in the perlfunc manpage. This warning is fatal if
substr is used in an lvalue context (as the left hand side of an
assignment or as a subroutine argument for example).
this|that|other, enclose
it in clustering parentheses:
(?(condition)(?:this|that|other)|else-clause)
The <-- HERE shows whereabouts in the regular expression the problem was discovered. See the perlre manpage.
(1) (2) ... true if 1st, 2nd, etc., capture matched
(<NAME>) ('NAME') true if named capture matched
(?=...) (?<=...) true if subpattern matches
(?!...) (?<!...) true if subpattern fails to match
(?{ CODE }) true if code returns a true value
(R) true if evaluating inside recursion
(R1) (R2) ... true if directly inside capture group 1, 2, etc.
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
The <-- HERE shows whereabouts in the regular expression the problem was discovered. See the perlre manpage.
use filetest pragma, we cannot switch the real
and effective uids or gids.
A keyword is misspelled.
A semicolon is missing.
A comma is missing.
An opening or closing parenthesis is missing.
An opening or closing brace is missing.
A closing quote is missing.
Often there will be another error message associated with the syntax
error giving more information. (Sometimes it helps to turn on -w.)
The error message itself often tells you where it was in the line when
it decided to give up. Sometimes the actual error is several tokens
before this, because Perl is good at understanding random input.
Occasionally the line number may be misleading, and once in a blue moon
the only way to figure out what's triggering the error is to call
perl -c repeatedly, chopping away half the program each time to see
if the error went away. Sort of the cybernetic version of 20 questions.
perl -c succeeds.
sysread() on closed filehandle %ssysread() on unopened filehandle %ssyswrite() on closed filehandle %s-T and -B not implemented on filehandlesgoto to reach a label that was too deeply nested
for Perl to reach. Perl is doing you a favor by refusing.
telldir() attempted on invalid dirhandle %stelldir() is either closed or not really
a dirhandle. Check your control flow.
tell() on unopened filehandletell() function on a filehandle that
was either never opened or has since been closed.
crypt() function is unimplemented due to excessive paranoia.crypt() function on your machine,
probably because your vendor didn't supply it, probably because they
think the U.S. Government thinks it's a secret, or at least that they
will continue to pretend that it is. And if you quote me on that, I
will deny it.
my \%x, you must first enable
the feature:
no warnings "experimental::declared_refs";
use feature "declared_refs";
(?[ ]) in a regular expression.
The details of this feature are subject to change.
If you want to use it, but know that in doing so you
are taking the risk of using an experimental feature which may
change in a future Perl version, you can do this to silence the
warning:
no warnings "experimental::regex_sets";
no warnings "experimental::signatures";
use feature "signatures";
sub foo ($left, $right) { ... }
my or sub declarations.
setenv() function. You'll
need to rebuild Perl with a CRTL that does, or redefine
PERL_ENV_TABLES (see the perlvms manpage) so that the environ array isn't the
target of the change to
%ENV which produced the warning.
my() in false conditional is no longer allowedmy $x if 0. There
has been a long-standing bug in Perl that causes a lexical variable
not to be cleared at scope exit when its declaration includes a false
conditional. Some people have exploited this bug to achieve a kind of
static variable. Since we intend to fix this bug, we don't want people
relying on this behavior. You can achieve a similar static effect by
declaring the variable in a separate block outside the function, eg
sub f { my $x if 0; return $x++ }
becomes
{ my $x; sub f { return $x++ } }
Beginning with perl 5.10.0, you can also use state variables to have
lexicals that are initialized only once (see the feature manpage):
sub f { state $x; return $x++ }
This use of my() in a false conditional was deprecated beginning in
Perl 5.10 and became a fatal error in Perl 5.30.
If the Perl script is being executed as a command using the #!
mechanism (or its local equivalent), this error can usually be
fixed by editing the #! line so that the -%c option is a part of
Perl's first argument: e.g. change perl -n -%c to perl -%c -n.
If the Perl script is being executed as perl scriptname, then the
-%c option must appear on the command line: perl -%c scriptname.
ucfirst() (or their string-inlined versions), but you
specified an illegal mapping.
See User-Defined Character Properties in the perlunicode manpage.
syscall() to specify the
system call to call, silly dilly.
The message attempts to include the name of the called subroutine. If the subroutine has been aliased, the subroutine's original name will be shown, regardless of what name the caller used.
In the case of -M and -m, this is an error because those options
are not intended for use inside scripts. Use the use pragma instead.
The -C option only works if it is specified on the command line as well (with the same sequence of letters or numbers following). Either specify this option on the command line, or, if your system supports it, make your script executable and run it directly instead of passing it to perl.
require or do when you should be using use
instead. Or perhaps you should put the require or do inside a
BEGIN block.
The message attempts to include the name of the called subroutine. If the subroutine has been aliased, the subroutine's original name will be shown, regardless of what name the caller used.
"(" parentheses that haven't
been matched by corresponding closing ones. This limit prevents eating
up too much memory. It is initially set to 1000, but may be changed by
setting ${^RE_COMPILE_RECURSION_LIMIT} to some other value. This may
need to be done in a BEGIN block before the regular expression pattern
is compiled.
$ from variables
$tr or $y may cause this error.
@{EXPR}. Hashes must be
%NAME or %{EXPR}. No implicit dereferencing is allowed--use the
{EXPR} forms as an explicit dereference. See the perlref manpage.
*foo = undef. This does nothing. It's possible that you really mean
undef *foo.
"{" character (U+007B LEFT CURLY BRACKET) in a
regular expression pattern, is to escape each literal instance of it in
some way. Generally easiest is to precede it with a backslash, like
"\{" or enclose it in square brackets ("[{]"). If the pattern
delimiters are also braces, any matching right brace ("}") should
also be escaped to avoid confusing the parser, for example,
qr{abc\{def\}ghi}
Forcing literal "{" characters to be escaped will enable the Perl
language to be extended in various ways in future releases. To avoid
needlessly breaking existing code, the restriction is is not enforced in
contexts where there are unlikely to ever be extensions that could
conflict with the use there of "{" as a literal. Those that are
not potentially ambiguous do not warn; those that are do raise a
non-deprecation warning.
In this release of Perl, some literal uses of "{" are fatal, and some
still just deprecated. This is because of an oversight: some uses of a
literal "{" that should have raised a deprecation warning starting in
v5.20 did not warn until v5.26. By making the already-warned uses fatal
now, some of the planned extensions can be made to the language sooner.
The cases which are still allowed will be fatal in Perl 5.32.
The contexts where no warnings or errors are raised are:
"^" indicating to
anchor the match to the beginning of a line.
as the first character following a "|" indicating alternation.
as the first character in a parenthesized grouping like
/foo({bar)/
/foo(?:{bar)/
as the first character following a quantifier
/\s*{/
"{" character (U+007B LEFT CURLY BRACKET) in a
regular expression pattern, is to escape each literal instance of it in
some way. Generally easiest is to precede it with a backslash, like
"\{" or enclose it in square brackets ("[{]"). If the pattern
delimiters are also braces, any matching right brace ("}") should
also be escaped to avoid confusing the parser, for example,
qr{abc\{def\}ghi}
Forcing literal "{" characters to be escaped will enable the Perl
language to be extended in various ways in future releases. To avoid
needlessly breaking existing code, the restriction is is not enforced in
contexts where there are unlikely to ever be extensions that could
conflict with the use there of "{" as a literal. Those that are
not potentially ambiguous do not warn; those that are do raise a
non-deprecation warning.
In this release of Perl, some literal uses of "{" are fatal, and some
still just deprecated. This is because of an oversight: some uses of a
literal "{" that should have raised a deprecation warning starting in
v5.20 did not warn until v5.26. By making the already-warned uses fatal
now, some of the planned extensions can be made to the language sooner.
The cases which are still allowed will be fatal in Perl 5.32.
The contexts where no warnings or errors are raised are:
"^" indicating to
anchor the match to the beginning of a line.
as the first character following a "|" indicating alternation.
as the first character in a parenthesized grouping like
/foo({bar)/
/foo(?:{bar)/
as the first character following a quantifier
/\s*{/
"{" character (U+007B LEFT CURLY BRACKET) in a
regular expression pattern, is to escape each literal instance of it in
some way. Generally easiest is to precede it with a backslash, like
"\{" or enclose it in square brackets ("[{]"). If the pattern
delimiters are also braces, any matching right brace ("}") should
also be escaped to avoid confusing the parser, for example,
qr{abc\{def\}ghi}
Forcing literal "{" characters to be escaped will enable the Perl
language to be extended in various ways in future releases. To avoid
needlessly breaking existing code, the restriction is is not enforced in
contexts where there are unlikely to ever be extensions that could
conflict with the use there of "{" as a literal. Those that are
not potentially ambiguous do not warn; those that are do raise a
non-deprecation warning.
In this release of Perl, some literal uses of "{" are fatal, and some
still just deprecated. This is because of an oversight: some uses of a
literal "{" that should have raised a deprecation warning starting in
v5.20 did not warn until v5.26. By making the already-warned uses fatal
now, some of the planned extensions can be made to the language sooner.
The cases which are still allowed will be fatal in Perl 5.32.
The contexts where no warnings or errors are raised are:
"^" indicating to
anchor the match to the beginning of a line.
as the first character following a "|" indicating alternation.
as the first character in a parenthesized grouping like
/foo({bar)/
/foo(?:{bar)/
as the first character following a quantifier
/\s*{/
use re 'strict')
Within the scope of use re 'strict' in a regular expression
pattern, you included an unescaped } or ] which was interpreted
literally. These two characters are sometimes metacharacters, and
sometimes literals, depending on what precedes them in the
pattern. This is unlike the similar ) which is always a
metacharacter unless escaped.
This action at a distance, perhaps a large distance, can lead to Perl
silently misinterpreting what you meant, so when you specify that you
want extra checking by use re 'strict', this warning is generated.
If you meant the character as a literal, simply confirm that to Perl by
preceding the character with a backslash, or make it into a bracketed
character class (like [}]). If you meant it as closing a
corresponding [ or {, you'll need to look back through the pattern
to find out why that isn't happening.
unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
(?[ | \p{Digit} ])
where the "|" is a binary operator with an operand on the right, but
no operand on the left.
(?[ z ])
Within (?[ ]), no literal characters are allowed unless they are
within an inner pair of square brackets, like
(?[ [ z ] ])
Another possibility is that you forgot a backslash. Perl isn't smart enough to figure out what you really meant.
exit() was called or the script otherwise finished gracefully when
PERL_EXIT_WARN was set in PL_exit_flags.
die() was called when PERL_EXIT_WARN was set in
PL_exit_flags.
(?[ ( \p{Digit} + ) ])
The ")" is out-of-place. Something apparently was supposed to
be combined with the digits, or the "+" shouldn't be there, or
something like that. Perl can't figure out what was intended.
(?[ \p{Digit} ( \p{Lao} + \p{Thai} ) ])
There should be an operator before the "(", as there's
no indication as to how the digits are to be combined
with the characters in the Lao and Thai scripts.
no warnings 'nonchar';.
This is not really a ``severe'' error, but it is supposed to be raised by default even if warnings are not enabled, and currently the only way to do that in Perl is to mark it as serious.
\p{...}.
The closing delimtter to match the opening one was not found. If the
opening one is escaped by preceding it with a backslash, the closing one
must also be so escaped.
no warnings 'surrogate';.
\N{} is unknown to Perl. Check the
spelling. You can say use charnames ":loose" to not have to be
so precise about spaces, hyphens, and capitalization on standard Unicode
names. (Any custom aliases that have been created must be specified
exactly, regardless of whether :loose is used or not.) This error may
also happen if the \N{} is not in the scope of the corresponding
use charnames.
(* was followed by something that the regular expression
compiler does not recognize. Check your spelling.
$@, but the $@ variable
did not exist, even after an attempt to create it.
open() mode '%s'open() is not among the list
of valid modes: <, >, >>, +<,
+>, +>>, -|, |-, <&, >&.
mmap,
are not supported in all environments. If your program didn't
explicitly request the failing operation, it may be the result of the
value of the environment variable PERLIO.
if ($a =~ /foo/and $bar == 3) { ... }
The "a" is a valid modifier flag, but the "n" is not, and raises
this error. Likely what was meant instead was:
if ($a =~ /foo/ and $bar == 3) { ... }
(1) (2) ... true if 1st, 2nd, etc., capture matched
(<NAME>) ('NAME') true if named capture matched
(?=...) (?<=...) true if subpattern matches
(*pla:...) (*plb:...) true if subpattern matches; also
(*positive_lookahead:...)
(*positive_lookbehind:...)
(*nla:...) (*nlb:...) true if subpattern fails to match; also
(*negative_lookahead:...)
(*negative_lookbehind:...)
(?{ CODE }) true if code returns a true value
(R) true if evaluating inside recursion
(R1) (R2) ... true if directly inside capture group 1, 2,
etc.
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
The <-- HERE shows whereabouts in the regular expression the problem was discovered. See the perlre manpage.
-C switch for the list of known options.
-C switch for the list of known options.
* quantifier
after an open brace in your pattern. Check the pattern and review
the perlre manpage for details on legal verb patterns.
warnings pragma. You specified a warnings
category that is unknown to perl at this point.
Note that if you want to enable a warnings category registered by a
module (e.g. use warnings 'File::Find'), you must have loaded this
module first.
(?[ ]).
character(s) were understood literally, but
this may change in a future version of Perl. The <-- HERE shows
whereabouts in the regular expression the escape was discovered.
kill() function that was not
recognized. Say kill -l in your shell to see the valid signal names
on your system.
chomp() it off. See chomp in the perlfunc manpage.
opendir() and readdir().
Note that under some systems, like OS/2, there may be different flavors
of Perl executables, some of which may support fork, some not. Try
changing the name you call Perl by to perl_, perl__, and so on.
(*...:...) but did not terminate
the pattern with a ). Fix the pattern and retry.
unpack(``w'',...) was incompatible with the BER
compressed integer format and could not be converted to an integer.
See pack in the perlfunc manpage.
(*...) but did not terminate
the pattern with a ). Fix the pattern and retry.
<<"foo
instead of:
<<"foo"
\g that wasn't followed by a
proper group reference. In the case of \g{, the closing brace is
missing; otherwise the \g must be followed by an integer. Fix the
pattern and retry.
(*VERB:ARG) but did not terminate
the pattern with a ). Fix the pattern and retry.
(*VERB) but did not terminate
the pattern with a ). Fix the pattern and retry.
tie (or tied) was
still valid when untie was called.
$[ in a comparison, such as:
if ($[ > 5.006) {
...
}
You probably meant to use $] instead. $[ is the base for indexing
arrays. $] is the Perl version number in decimal.
if ($string =~ /(?-o)$pattern/o) { ... }
must be written as
if ($string =~ /$pattern/) { ... }
The <-- HERE shows whereabouts in the regular expression the problem was discovered. See the perlre manpage.
local($x=10) is legal,
but in fact the local() currently has no effect. This may change at
some point in the future, but in the meantime such code is discouraged.
if ($string =~ /(?o)$pattern/) { ... }
must be written as
if ($string =~ /$pattern/o) { ... }
The <-- HERE shows whereabouts in the regular expression the problem was discovered. See the perlre manpage.
const attribute has no effect except
on anonymous closure prototypes. You applied it to
a subroutine via attributes.pm. This is only useful
inside an attribute handler for an anonymous subroutine.
\U,
\L or \Q preceding it.
qr/a{3}?/
qr/b{1,1}+/
The "?" and "+" don't have any effect, as they modify whether to
match more or fewer when there is a choice, and by specifying to match
exactly a given numer, there is no room left for a choice.
$one, $two = 1, 2;
when you meant to say
($one, $two) = (1, 2);
Another common error is to use ordinary parentheses to construct a list reference when you should be using square or curly brackets, for example, if you say
$array = (1,2);
when you should have said
$array = [1,2];
The square brackets explicitly turn a list value into a scalar value, while parentheses do not. So when a parenthesized list is evaluated in a scalar context, the comma is treated like C's comma operator, which throws away the left argument, which is not what you want. See the perlref manpage for more on this.
This warning will not be issued for numerical constants equal to 0 or 1 since they are often used in statements like
1 while sub_with_side_effects();
String constants that would normally evaluate to 0 or 1 are warned about.
p modifier cannot be turned off once set. Trying to do
so is futile.
use re; without any arguments. That isn't very useful.
my $x = sort @y;
This is not very useful, and perl currently optimizes this away.
push() or unshift() function with no arguments
apart from the array, like push(@x) or unshift(@foo). That won't
usually have any effect on the array, so is completely useless. It's
possible in principle that push(@tied_array) could have some effect
if the array is tied to a class which implements a PUSH method. If so,
you can write it as push(@tied_array,()) to avoid this warning.
Use of a bare terminator was deprecated in Perl 5.000, and is a fatal error as of Perl 5.28.
If your code is to run on various platforms, keep in mind that the upper limit depends on the platform. It is much larger on 64-bit word sizes than 32-bit ones.
The use of out of range code points was deprecated in Perl 5.24, and became a fatal error in Perl 5.28.
each() on hash after insertion without resetting hash iterator results in undefined behavioreach() after insertion is undefined;
it may skip items, or visit items more than once. Consider using
keys() instead of each().
my $x := 42 used to parse as equivalent to
my $x : = 42 (applying an empty attribute list to $x).
This construct was deprecated in 5.12.0, and has now been made a syntax
error, so := can be reclaimed as a new operator in the future.
If you need an empty attribute list, for example in a code generator, add
a space before the =.
@a = (3,4);
@a = () for (1,2,@a);
You are not supposed to modify arrays while they are being iterated over. For speed and efficiency reasons, Perl internally does not do full reference-counting of iterated items, hence deleting such an item in the middle of an iteration causes Perl to see a freed value.
split
operator. Since split always tries to match the pattern
repeatedly, the /g has no effect.
goto to jump from an outer scope into an inner
scope is deprecated and should be avoided.
This was deprecated in Perl 5.12.
AUTOLOAD subroutines were looked up as
methods (using the @ISA hierarchy), even when the subroutines to be
autoloaded were called as plain functions (e.g. Foo::bar()), not as
methods (e.g. Foo->bar() or $obj->bar()).
This was deprecated in Perl 5.004, and was made fatal in Perl 5.28.
undef. Use a filename instead.
If you really do mean it, explicitly numify your reference, like so:
$array[0+$ref]. This warning is not given for overloaded objects,
however, because you can overload the numification and stringification
operators and then you presumably know what you are doing.
& or | or ^ or
~) on a string containing a code point over 0xFF. The string bitwise
operators treat their operands as strings of bytes, and values beyond
0xFF are nonsensical in this context.
This became fatal in Perl 5.28.
vec
is deprecated. This will be a fatal error in Perl 5.32vec
on a string containing a code point over 0xFF, which is nonsensical here.
Such usage will be a fatal error in Perl 5.32.
system() or exec() with multiple
arguments and at least one of them is tainted. This used to be allowed
but will become a fatal error in a future version of perl. Untaint your
arguments. See the perlsec manpage.
To help you figure out what was undefined, perl will try to tell you
the name of the variable (if any) that was undefined. In some cases
it cannot do this, so it also tells you what operation you used the
undefined value in. Note, however, that perl optimizes your program
and the operation displayed in the warning may not necessarily appear
literally in your program. For example, "that $foo" is usually
optimized into "that " . $foo, and the warning will refer to the
concatenation (.) operator, even though there is no . in
your program.
'strict' are subject to change
in future Perl releases in incompatible ways. This means that a pattern
that compiles today may not in a future Perl release. This warning is
to alert you to that risk.
(?[ [ \xBEEF ] ])
Perl isn't sure if you meant this
(?[ [ \x{BEEF} ] ])
or if you meant this
(?[ [ \x{BE} E F ] ])
You need to add either braces or blanks to disambiguate.
(\N{...}) may return
a multi-character sequence. Even though a character class is
supposed to match just one character of input, perl will match
the whole thing correctly, except when the class is inverted
([^...]), or the escape is the beginning or final end point of
a range. For these, what should happen isn't clear at all. In
these circumstances, Perl discards all but the first character
of the returned sequence, which is not likely what you want.
\b{...} or \B{...}) in a
portion of a regular expression where the character set modifiers /a
or /aa are in effect. These two modifiers indicate an ASCII
interpretation, and this doesn't make sense for a Unicode definition.
The generated regular expression will compile so that the boundary uses
all of Unicode. No other portion of the regular expression is affected.
!~ operator with s///r, tr///r or y///r is
currently reserved for future use, as the exact behavior has not
been decided. (Simply returning the boolean opposite of the
modified string is usually not particularly useful.)
no warnings 'surrogate';.
defined()each(), or readdir() as a boolean value. Each of these constructs
can return a value of ``0''; that would make the conditional expression
false, which is probably not what you intended. When using these
constructs in conditional expressions, test their values with the
defined operator.
sub { my $a; sub f { $a } }
At the time that f is created, it can't capture the current value of $a, since the anonymous subroutine hasn't been created yet. Conversely, the following won't give a warning since the anonymous subroutine has by now been created and is live:
sub { my $a; eval 'sub f { $a }' }->();
The second situation is caused by an eval accessing a variable that has gone out of scope, for example,
sub f {
my $a;
sub { eval '$a' }
}
f()->();
Here, when the '$a' in the eval is being compiled, f() is not currently
being executed, so its $a is not available for capture.
In Perl 5.30 and earlier, lookbehind is allowed
only for subexpressions whose length is fixed and
known at compile time. For positive lookbehind, you can use the \K
regex construct as a way to get the equivalent functionality. See
(?<=pattern) and \K in perlre.
Starting in Perl 5.18, there are non-obvious Unicode rules under /i
that can match variably, but which you might not think could. For
example, the substring "ss" can match the single character LATIN
SMALL LETTER SHARP S. Here's a complete list of the current ones
affecting ASCII characters:
ASCII
sequence Matches single letter under /i
FF U+FB00 LATIN SMALL LIGATURE FF
FFI U+FB03 LATIN SMALL LIGATURE FFI
FFL U+FB04 LATIN SMALL LIGATURE FFL
FI U+FB01 LATIN SMALL LIGATURE FI
FL U+FB02 LATIN SMALL LIGATURE FL
SS U+00DF LATIN SMALL LETTER SHARP S
U+1E9E LATIN CAPITAL LETTER SHARP S
ST U+FB06 LATIN SMALL LIGATURE ST
U+FB05 LATIN SMALL LIGATURE LONG S T
This list is subject to change, but is quite unlikely to. Each ASCII sequence can be any combination of upper- and lowercase.
You can avoid this by using a bracketed character class in the lookbehind assertion, like
(?<![sS]t) (?<![fF]f[iI])
This fools Perl into not matching the ligatures.
Another option for Perls starting with 5.16, if you only care about
ASCII matches, is to add the /aa modifier to the regex. This will
exclude all these non-obvious matches, thus getting rid of this message.
You can also say
use if $] ge 5.016, re => '/aa';
to apply /aa to all regular expressions compiled within its scope.
See the re manpage.
When the inner subroutine is called, it will see the value of the outer subroutine's variable as it was before and during the *first* call to the outer subroutine; in this case, after the first call to the outer subroutine is complete, the inner and outer subroutines will no longer share a common value for the variable. In other words, the variable will no longer be shared.
This problem can usually be solved by making the inner subroutine
anonymous, using the sub {} syntax. When inner anonymous subs that
reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.
<<<<<<<,
>>>>>>>, or =======. These may be left by a
version control system to mark conflicts after a failed merge operation.
use Module n.n LIST statement into
its equivalent BEGIN block found an internal inconsistency with
the version number.
warn() an empty string (the equivalent of warn "") or
you called it with no args and $@ was empty.
close() done by an open() got an error indication on
the close(). This usually indicates your file system ran out of disk
space.
close() done on a filehandle
when its reference count reached zero while it was still open, e.g.:
{
open my $fh, '>', $file or die "open: '$file': $!\n";
print $fh $data or die "print: $!";
} # implicit close here
Because various errors may only be detected by close() (e.g. buffering could
allow the print in this example to return true even when the disk is full),
it is dangerous to ignore its result. So when it happens implicitly, perl
will signal errors by warning.
Prior to version 5.22.0, perl ignored such errors, so the common idiom shown above was liable to cause silent data loss.
rand + 5;
you may THINK you wrote the same thing as
rand() + 5;
but in actual fact, you got
rand(+5);
So put in parentheses to say what you really mean.
when depends on smartmatch, which is
experimental. Additionally, it has several special cases that may
not be immediately obvious, and their behavior may change or
even be removed in any future release of perl. See the explanation
under Experimental Details on given and when in the perlsyn manpage.
If this warning does come from I/O, the easiest
way to quiet it is simply to add the :utf8 layer, e.g.,
binmode STDOUT, ':utf8'. Another way to turn off the warning is
to add no warnings 'utf8'; but that is often closer to
cheating. In general, you are supposed to explicitly mark the
filehandle with an encoding, see the open manpage and binmode in the perlfunc manpage.
If the warning comes from other than I/O, this diagnostic probably indicates that incorrect results are being obtained. You should examine your code to determine how a wide character is getting to an operation that doesn't handle them.
You likely need to figure out how this multi-byte character got mixed up with your single-byte locale (or perhaps you thought you had a UTF-8 locale, but Perl disagrees).
[TEMPLATE]
only if TEMPLATE always matches the same amount of packed bytes that
can be determined from the template alone. This is not possible if
it contains any of the codes @, /, U, u, w or a *-length. Redesign
the template.
write() on closed filehandle %s
utf8 "\xE4" does not map to Unicode
if you try to read in the a-diaereses Latin-1 as UTF-8.
\N{...}) may return a zero-length
sequence. Such an escape was used in an extended character class, i.e.
(?[...]), or under use re 'strict', which is not permitted. Check
that the correct escape has been used, and the correct charnames handler
is in scope. The <-- HERE shows whereabouts in the regular
expression the problem was discovered.
the warnings manpage, the diagnostics manpage.
| perldiag - various Perl diagnostics |