desperation):
(W) A warning (optional).
- (D) A deprecation (optional).
- (S) A severe warning (default).
+ (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).
to a reference to a routine that will be called on each warning instead
of printing it. See L<perlvar>.
-Default warnings are always enabled unless they are explicitly disabled
+Severe warnings are always enabled, unless they are explicitly disabled
with the C<warnings> pragma or the B<-X> switch.
Trappable errors may be trapped using the eval operator. See
=over 4
-=item A thread exited while %d other threads were still running
-
-(W) When using threaded Perl, a thread (not necessarily the main
-thread) exited while there were still other threads running.
-Usually it's a good idea to first collect the return values of the
-created threads by joining them, and only then exit from the main
-thread. See L<threads>.
-
=item accept() on closed socket %s
(W closed) You tried to do an accept on a closed socket. Did you forget
(X) You can't allocate more than 64K on an MS-DOS machine.
-=item '!' allowed only after types %s
+=item '%c' allowed only after types %s
-(F) The '!' is allowed in pack() and unpack() only after certain types.
-See L<perlfunc/pack>.
+(F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only
+after certain types. See L<perlfunc/pack>.
=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
(W misc) The pattern match (C<//>), substitution (C<s///>), and
transliteration (C<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
+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 L<perlfunc/grep> and L<perlfunc/map> for
alternatives.
(F) msgsnd() requires a string at least as long as sizeof(long).
-=item %s argument is not a HASH or ARRAY element
+=item %s argument is not a HASH or ARRAY element or a subroutine
-(F) The argument to exists() must be a hash or array element, such as:
+(F) The argument to exists() must be a hash or array element or a
+subroutine with an ampersand, such as:
$foo{$bar}
$ref->{"susie"}[12]
+ &do_something
=item %s argument is not a HASH or ARRAY element or slice
that expected a numeric value instead. If you're fortunate the message
will identify which operator was so unfortunate.
+=item Argument list not closed for PerlIO layer "%s"
+
+(W layer) When pushing a layer with arguments onto the Perl I/O system you
+forgot the ) that closes the argument list. (Layers take care of transforming
+data between external and internal representations.) Perl stopped parsing
+the layer list at this point and did not attempt to push this layer.
+If your program didn't explicitly request the failing operation, it may be
+the result of the value of the environment variable PERLIO.
+
=item Array @%s missing the @ in argument %d of %s()
(D deprecated) Really old Perl let you omit the @ on array names in some
must either both be scalars or both be lists. Otherwise Perl won't
know which context to supply to the right side.
+=item A thread exited while %d threads were running
+
+(W threads)(S) When using threaded Perl, a thread (not necessarily the main
+thread) exited while there were still other threads running.
+Usually it's a good idea to first collect the return values of the
+created threads by joining them, and only then exit from the main
+thread. See L<threads>.
+
=item Attempt to access disallowed key '%s' in a restricted hash
(F) The failing code has attempted to get or set a key which is not in
the current set of allowed keys of a restricted hash.
-=item Attempt to clear a restricted hash
-
-(F) It is currently not allowed to clear a restricted hash, even if the
-new hash would contain the same keys as before. This may change in
-the future.
-
-=item Attempt to delete readonly key '%s' from a restricted hash
-
-(F) The failing code attempted to delete a key whose value has been
-declared readonly from a restricted hash.
-
-=item Attempt to delete disallowed key '%s' from a restricted hash
-
-(F) The failing code attempted to delete from a restricted hash a key
-which is not in its key set.
-
=item Attempt to bless into a reference
(F) The CLASSNAME argument to the bless() operator is expected to be
bless $self, "$proto";
+=item Attempt to delete disallowed key '%s' from a restricted hash
+
+(F) The failing code attempted to delete from a restricted hash a key
+which is not in its key set.
+
+=item Attempt to delete readonly key '%s' from a restricted hash
+
+(F) The failing code attempted to delete a key whose value has been
+declared readonly from a restricted hash.
+
=item Attempt to free non-arena SV: 0x%lx
(P internal) All SV objects are supposed to be allocated from arenas
literals or global values as arguments to the "p" pack() template to
avoid this warning.
+=item Attempt to reload %s aborted.
+
+(F) You tried to load a file with C<use> or C<require> that failed to
+compile once already. Perl will not try to compile this file again
+unless you delete its entry from %INC. See L<perlfunc/require> and
+L<perlvar/%INC>.
+
+=item Attempt to set length of freed array
+
+(W) You tried to set the length of an array which has been freed. You
+can do this by storing a reference to the scalar representing the last index
+of an array and later assigning through that reference. For example
+
+ $r = do {my @a; \$#a};
+ $$r = 503
+
=item Attempt to use reference as lvalue in substr
(W substr) You supplied a reference as the first argument to substr()
used as an lvalue, which is pretty strange. Perhaps you forgot to
dereference it first. See L<perlfunc/substr>.
-=item Bad arg length for %s, is %d, should be %s
+=item Attribute "locked" is deprecated
+
+(D deprecated) You have used the attributes pragam to modify the "locked"
+attribute on a code reference. The :locked attribute is obsolete, has had no
+effect since 5005 threads were removed, and will be removed in the next major
+release of Perl 5.
+
+=item Attribute "unique" is deprecated
+
+(D deprecated) You have used the attributes pragam to modify the "unique"
+attribute on an array, hash or scalar reference. The :unique attribute has
+had no effect since Perl 5.8.8, and will be removed in the next major
+release of Perl 5.
+
+=item Bad arg length for %s, is %d, should be %d
(F) You passed a buffer of the wrong size to one of msgctl(), semctl()
or shmctl(). In C parlance, the correct sizes are, respectively,
$var = 'myvar';
$sym = "mypack::$var";
+=item Bad plugin affecting keyword '%s'
+
+(F) An extension using the keyword plugin mechanism violated the
+plugin API.
+
=item Bad realloc() ignored
(S malloc) An internal routine called realloc() on something that had
(P) An internal request asked to add an array entry to something that
wasn't a symbol table entry.
+=item Bad symbol for dirhandle
+
+(P) An internal request asked to add a dirhandle entry to something
+that wasn't a symbol table entry.
+
+
=item Bad symbol for filehandle
(P) An internal request asked to add a filehandle entry to something
(P) Perl detected an attempt to copy an internal value that is not
copyable.
-=item B<-P> not allowed for setuid/setgid script
-
-(F) The script would have to be opened by the C preprocessor by name,
-which provides a race condition that breaks security.
-
=item Buffer overflow in prime_env_iter: %s
(W internal) A warning peculiar to VMS. While Perl was preparing to
function correctly, you may put an ampersand before the name to avoid
the warning. See L<perlsub>.
-=item / cannot take a count
+=item Cannot compress integer in pack
-(F) You had an unpack template indicating a counted-length string, but
-you have also specified an explicit size for the string. See
-L<perlfunc/pack>.
+(F) An argument to pack("w",...) was too large to compress. The BER
+compressed integer format can only be used with positive integers, and you
+attempted to compress Infinity or a very large number (> 1e308).
+See L<perlfunc/pack>.
+
+=item Cannot compress negative numbers in pack
+
+(F) An argument to pack("w",...) was negative. The BER compressed integer
+format can only be used with positive integers. See L<perlfunc/pack>.
+
+=item Cannot convert a reference to %s to typeglob
+
+(F) You manipulated Perl's symbol table directly, stored a reference in it,
+then tried to access that symbol via conventional Perl syntax. The access
+triggers Perl to autovivify that typeglob, but it there is no legal conversion
+from that type of reference to a typeglob.
+
+=item Cannot copy to %s in %s
+
+(P) Perl detected an attempt to copy a value to an internal type that cannot
+be directly assigned not.
+
+=item Cannot find encoding "%s"
+
+(S io) You tried to apply an encoding that did not exist to a filehandle,
+either with open() or binmode().
+
+=item Can only compress unsigned integers in pack
+
+(F) An argument to 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 L<perlfunc/pack>.
=item Can't bless non-reference value
(F) Only hard references may be blessed. This is how Perl "enforces"
encapsulation of objects. See L<perlobj>.
+=item Can't "break" in a loop topicalizer
+
+(F) You called C<break>, but you're in a C<foreach> block rather than
+a C<given> block. You probably meant to use C<next> or C<last>.
+
+=item Can't "break" outside a given block
+
+(F) You called C<break>, but you're not inside a C<given> block.
+
=item Can't call method "%s" in empty package "%s"
(F) You called a method correctly, and it correctly indicated a package
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are.
+=item Can't "continue" outside a when block
+
+(F) You called C<continue>, but you're not inside a C<when>
+or C<default> block.
+
=item Can't create pipe mailbox
(P) An error peculiar to VMS. The process is suffering from exhausted
=item Can't declare class for non-scalar %s in "%s"
(F) Currently, only scalar variables can be declared with a specific
-class qualifier in a "my" or "our" declaration. The semantics may be
+class qualifier in a "my", "our" or "state" declaration. The semantics may be
extended for other types of variables in future.
=item Can't declare %s in "%s"
-(F) Only scalar, array, and hash variables may be declared as "my" or
-"our" variables. They must have ordinary identifiers as names.
+(F) Only scalar, array, and hash variables may be declared as "my", "our" or
+"state" variables. They must have ordinary identifiers as names.
=item Can't do inplace edit: %s is not a regular file
regexp to match something 0 times, just put {0}. The <-- HERE shows in the
regular expression about where the problem was discovered. See L<perlre>.
-=item Can't do setegid!
-
-(P) The setegid() call failed for some reason in the setuid emulator of
-suidperl.
-
-=item Can't do seteuid!
-
-(P) The setuid emulator of suidperl failed for some reason.
-
-=item Can't do setuid
-
-(F) This typically means that ordinary perl tried to exec suidperl to do
-setuid emulation, but couldn't exec it. It looks for a name of the form
-sperl5.000 in the same directory that the perl executable resides under
-the name perl5.000, typically /usr/local/bin on Unix machines. If the
-file is there, check the execute permissions. If it isn't, ask your
-sysadmin why he and/or she removed it.
-
=item Can't do waitpid with flags
(F) This machine doesn't have either waitpid() or wait4(), so only
point. For example, it'd be kind of silly to put a B<-x> on the #!
line.
+=item Can't %s %s-endian %ss on this platform
+
+(F) Your platform's byte-order is neither big-endian nor little-endian,
+or it has a very strange pointer size. Packing and unpacking big- or
+little-endian floating point values and pointers may not be possible.
+See L<perlfunc/pack>.
+
=item Can't exec "%s": %s
(W exec) A system(), exec(), or piped open call could not execute the
=item Can't find %s character property "%s"
(F) You used C<\p{}> or C<\P{}> but the character property by that name
-could not be found. Maybe you misspelled the name of the property
-(remember that the names of character properties consist only of
-alphanumeric characters), or maybe you forgot the C<Is> or C<In> prefix?
+could not be found. Maybe you misspelled the name of the property?
+See L<perluniprops/Properties accessible through \p{} and \P{}>
+for a complete list of available properties.
=item Can't find label %s
unseen whitespace before or after your closing tag. A good programmer's
editor will have a way to help you find these characters.
-=item Can't find %s property definition %s
+=item Can't find Unicode property definition "%s"
(F) You may have tried to use C<\p> which means a Unicode property (for
-example C<\p{Lu}> is all uppercase letters). If you did mean to use a
-Unicode property, see L<perlunicode> for the list of known properties.
+example C<\p{Lu}> matches all uppercase letters). If you did mean to use a
+Unicode property, see
+L<perluniprops/Properties accessible through \p{} and \P{}>
+for a complete list of available properties.
If you didn't mean to use a Unicode property, escape the C<\p>, either
by C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, until
possible C<\E>).
-=item Can't fork
+=item Can't fork: %s
(F) A fatal error occurred while trying to fork while opening a
pipeline.
+=item Can't fork, trying again in 5 seconds
+
+(W pipe) A fork in a piped open failed with EAGAIN and will be retried
+after five seconds.
+
=item Can't get filespec - stale stat buffer?
(S) A warning peculiar to VMS. This arises because of the difference
you tried to jump out of a sort() block or subroutine, which is a no-no.
See L<perlfunc/goto>.
-=item Can't goto subroutine from an eval-string
+=item Can't goto subroutine from a sort sub (or similar callback)
+
+(F) The "goto subroutine" call can't be used to jump out of the
+comparison sub for a sort(), or from a similar callback (such
+as the reduce() function in List::Util).
+
+=item Can't goto subroutine from an eval-%s
(F) The "goto subroutine" call can't be used to jump out of an eval
-"string". (You can use it to jump out of an eval {BLOCK}, but you
-probably don't want to.)
+"string" or block.
=item Can't goto subroutine outside a subroutine
situation typically indicates that the parent program under which Perl
may be running (e.g. cron) is being very careless.
+=item Can't kill a non-numeric process ID
+
+(F) Process identifiers must be (signed) integers. It is a fatal error to
+attempt to kill() an undefined, empty-string or otherwise non-numeric
+process identifier.
+
=item Can't "last" outside a loop block
(F) A "last" statement was executed to break out of the current block,
inner curlies will be considered a block that loops once. See
L<perlfunc/last>.
+=item Can't linearize anonymous symbol table
+
+(F) Perl tried to calculate the method resolution order (MRO) of a
+package, but failed because the package stash has no name.
+
+=item Can't load '%s' for module %s
+
+(F) The module you tried to load failed to load a dynamic extension. This
+may either mean that you upgraded your version of perl to one that is
+incompatible with your old dynamic extensions (which is known to happen
+between major versions of perl), or (more likely) that your dynamic
+extension was built against an older version of the library that is
+installed on your system. You may need to rebuild your old dynamic
+extensions.
+
=item Can't localize lexical variable %s
(F) You used local on a variable name that was previously declared as a
-lexical variable using "my". This is not allowed. If you want to
+lexical variable using "my" or "state". This is not allowed. If you want to
localize a package variable of the same name, qualify it with the
package name.
are a misprint in a function/method name or a failure to C<AutoSplit>
the file, say, by doing C<make install>.
+=item Can't locate loadable object for module %s in @INC
+
+(F) The module you loaded is trying to load an external library, like
+for example, C<foo.so> or C<bar.dll>, but the L<DynaLoader> module was
+unable to locate this library. See L<DynaLoader>.
+
=item Can't locate object method "%s" via package "%s"
(F) You called a method correctly, and it correctly indicated a package
functioning as a class, but that package doesn't define that particular
method, nor does any of its base classes. See L<perlobj>.
-=item Can't locate PerlIO%s
-
-(F) You tried to use in open() a PerlIO layer that does not exist,
-e.g. open(FH, ">:nosuchlayer", "somefile").
-
-=item (perhaps you forgot to load "%s"?)
-
-(F) This is an educated guess made in conjunction with the message
-"Can't locate object method \"%s\" via package \"%s\"". It often means
-that a method requires a package that has not been loaded.
-
=item Can't locate package %s for @%s::ISA
(W syntax) The @ISA array contained the name of another package that
doesn't seem to exist.
+=item Can't locate PerlIO%s
+
+(F) You tried to use in open() a PerlIO layer that does not exist,
+e.g. open(FH, ">:nosuchlayer", "somefile").
+
=item Can't make list assignment to \%ENV on this system
(F) List assignment to %ENV is not supported on some systems, notably
redirection, and couldn't open the pipe into which to send data destined
for stdout.
-=item Can't open perl script%s: %s
+=item Can't open perl script%s
(F) The script you specified can't be opened for the indicated reason.
+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 C<`which $scriptname`>.
+
=item Can't read CRTL environ
(S) A warning peculiar to VMS. Perl tried to read an element of %ENV
or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
searched.
-=item Can't redefine active sort subroutine %s
-
-(F) Perl optimizes the internal handling of sort subroutines and keeps
-pointers into them. You tried to redefine one such sort subroutine when
-it was currently active, which is not allowed. If you really want to do
-this, you should write C<sort { &func } @x> instead of C<sort func @x>.
-
=item Can't "redo" outside a loop block
(F) A "redo" statement was executed to restart the current block, but
(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried
to reopen it to accept binary data. Alas, it failed.
-=item Can't resolve method `%s' overloading `%s' in package `%s'
+=item Can't resolve method "%s" overloading "%s" in package "%s"
(F|P) Error resolving overloading specified by a method name (as opposed
to a subroutine reference): no such method callable via the package. If
method name is C<???>, this is an internal error.
-=item Can't reswap uid and euid
-
-(P) The setreuid() call failed for some reason in the setuid emulator of
-suidperl.
-
=item Can't return %s from lvalue subroutine
(F) Perl detected an attempt to return illegal lvalues (such as
temporary or readonly values) from a subroutine used as an lvalue. This
is not allowed.
+=item Can't return outside a subroutine
+
+(F) The return statement was executed in mainline code, that is, where
+there was no subroutine call to return out of. See L<perlsub>.
+
=item Can't return %s to lvalue scalar context
(F) You tried to return a complete array or hash from an lvalue subroutine,
the call to the subroutine, which tell Perl that the call should be in
list context.
-=item Can't return outside a subroutine
-
-(F) The return statement was executed in mainline code, that is, where
-there was no subroutine call to return out of. See L<perlsub>.
-
=item Can't stat script "%s"
(P) For some reason you can't fstat() the script even though you have it
open already. Bizarre.
-=item Can't swap uid and euid
-
-(P) The setreuid() call failed for some reason in the setuid emulator of
-suidperl.
-
=item Can't take log of %g
(F) For ordinary real numbers, you can't take the logarithm of a
(F) You tried to unshift an "unreal" array that can't be unshifted, such
as the main Perl stack.
-=item Can't upgrade that kind of scalar
+=item Can't upgrade %s (%d) to %d
(P) The internal sv_upgrade routine adds "members" to an SV, making it
into a more specialized kind of SV. The top several SV types are so
specialized, however, that they cannot be interconverted. This message
indicates that such a conversion was attempted.
-=item Can't upgrade to undef
+=item Can't use anonymous symbol table for method lookup
-(P) The undefined SV is the bottom of the totem pole, in the scheme of
-upgradability. Upgrading to undef indicates an error in the code
-calling sv_upgrade.
+(F) The internal routine that does method lookup was handed a symbol
+table that doesn't have a name. Symbol tables can become anonymous
+for example by undefining stashes: C<undef %Some::Package::>.
=item Can't use an undefined value as %s reference
(F) A value used as either a hard reference or a symbolic reference must
be a defined value. This helps to delurk some insidious errors.
-=item Can't use anonymous symbol table for method lookup
-
-(P) The internal routine that does method lookup was handed a symbol
-table that doesn't have a name. Symbol tables can become anonymous
-for example by undefining stashes: C<undef %Some::Package::>.
-
=item Can't use bareword ("%s") as %s ref while "strict refs" in use
(F) Only hard references are allowed by "strict refs". Symbolic
Errno.pm module. The Errno module is expected to tie the %! hash to
provide symbolic names for C<$!> errno values.
+=item Can't use both '<' and '>' after type '%c' in %s
+
+(F) A type cannot be forced to have both big-endian and little-endian
+byte-order at the same time, so this combination of modifiers is not
+allowed. See L<perlfunc/pack>.
+
=item Can't use %s for loop variable
(F) Only a simple scalar variable may be used as a loop variable on a
foreach.
-=item Can't use global %s in "my"
+=item Can't use global %s in "%s"
(F) You tried to declare a magical variable as a lexical variable. This
is not allowed, because the magic can be tied to only one location
have variables in your program that looked like magical variables but
weren't.
+=item Can't use '%c' in a group with different byte-order in %s
+
+(F) You attempted to force a different byte-order on a type
+that is already inside a group with a byte-order modifier.
+For example you cannot force little-endianness on a type that
+is inside a big-endian group.
+
=item Can't use "my %s" in sort comparison
(F) The global variables $a and $b are reserved for sort comparisons.
(F) The compiler tried to interpret a bracketed expression as a
subscript. But to the left of the brackets was an expression that
-didn't look like an array reference, or anything else subscriptable.
+didn't look like a hash or array reference, or anything else subscriptable.
=item Can't use \%c to mean $%c in expression
value that prints out looking like SCALAR(0xdecaf). Use the $1 form
instead.
+=item Can't use "when" outside a topicalizer
+
+(F) You have used a when() block that is neither inside a C<foreach>
+loop nor a C<given> block. (Note that this error is issued on exit
+from the C<when> block, so you won't get the error if the match fails,
+or if you use an explicit C<continue>.)
+
=item Can't weaken a nonreference
(F) You attempted to weaken something that was not a reference. Only
with an assignment operator, which implies modifying the value itself.
Perhaps you need to copy the value to a temporary, and repeat that.
-=item Character in "C" format wrapped
+=item Character in 'C' format wrapped in pack
(W pack) You said
If you actually want to pack Unicode codepoints, use the C<"U"> format
instead.
-=item Character in "c" format wrapped
+=item Character in 'W' format wrapped in pack
+
+(W pack) You said
+
+ pack("U0W", $x)
+
+where $x is either less than 0 or more than 255. However, C<U0>-mode expects
+all values to fall in the interval [0, 255], so Perl behaved as if you
+meant:
+
+ pack("U0W", $x & 255)
+
+=item Character in 'c' format wrapped in pack
(W pack) You said
If you actually want to pack Unicode codepoints, use the C<"U"> format
instead.
+=item Character in '%c' format wrapped in unpack
+
+(W unpack) You tried something like
+
+ 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}")
+
+=item Character(s) in '%c' format wrapped in pack
+
+(W pack) You tried something like
+
+ 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")
+
+=item Character(s) in '%c' format wrapped in unpack
+
+(W unpack) You tried something like
+
+ 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")
+
=item close() on unopened filehandle %s
(W unopened) You tried to close a filehandle that was never opened.
+=item closedir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to close is either closed or not really
+a dirhandle. Check your control flow.
+
+=item Code missing after '/'
+
+(F) You had a (sub-)template that ends with a '/'. There must be another
+template code following the slash. See L<perlfunc/pack>.
+
=item %s: Command not found
(A) You've accidentally run your script through B<csh> instead of Perl.
after the other thread has entered cond_wait() and thus relinquished the
lock.
-
=item cond_signal() called on unlocked variable
(W threads) Within a thread-enabled program, you tried to call
corresponding C<overload> or C<charnames> pragma? See L<charnames> and
L<overload>.
+=item Constant(%s)%s: %s in regex; marked by <-- HERE in m/%s/
+
+(F) The parser found inconsistencies while attempting to find
+the character name specified in the C<\N{...}> escape. Perhaps you
+forgot to load the corresponding C<charnames> pragma?
+See L<charnames>.
+
+
=item Constant is not %s reference
(F) A constant value (perhaps declared using the C<use constant> pragma)
(P) The malloc package that comes with Perl had an internal failure.
-=item C<-p> destination: %s
-
-(F) An error occurred during the implicit output invoked by the C<-p>
-command-line switch. (This output goes to STDOUT unless you've
-redirected it with select().)
-
-=item C<-T> and C<-B> not implemented on filehandles
+=item Count after length/code in unpack
-(F) Perl can't peek at the stdio buffer of filehandles when it doesn't
-know about your kind of stdio. You'll have to use a filename instead.
+(F) You had an unpack template indicating a counted-length string, but
+you have also specified an explicit size for the string. See
+L<perlfunc/pack>.
=item Deep recursion on subroutine "%s"
infinite recursion, unless you're writing strange benchmark programs, in
which case it indicates something else.
+This threshold can be changed from 100, by recompiling the F<perl> binary,
+setting the C pre-processor macro C<PERL_SUB_DEPTH_WARN> to the desired value.
+
=item defined(@array) is deprecated
(D deprecated) defined() is not usually useful on arrays because it
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
+=item Deprecated character(s) in \\N{...} starting at '%s'
+
+(D deprecated) Just about anything is legal for the C<...> in C<\N{...}>.
+But starting in 5.12, non-reasonable ones that don't look like names are
+deprecated. A reasonable name begins with an alphabetic character and
+continues with any combination of alphanumerics, dashes, spaces, parentheses or
+colons.
+
+=item Deprecated use of my() in false conditional
+
+(D deprecated) You used a declaration similar to C<my $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.9.4, you can also use C<state> variables to
+have lexicals that are initialized only once (see L<feature>):
+
+ sub f { state $x; return $x++ }
+
+=item DESTROY created new reference to dead object '%s'
+
+(F) A 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.
+
=item Did not produce a valid header
See Server error.
=item (Did you mean &%s instead?)
-(W) You probably referred to an imported subroutine &FOO as $FOO or some
-such.
+(W misc) You probably referred to an imported subroutine &FOO as $FOO or
+some such.
=item (Did you mean "local" instead of "our"?)
(F) You said something like "use Module 42" but the Module did not
define a C<$VERSION.>
+=item '/' does not take a repeat count
+
+(F) You cannot put a repeat count of any kind right after the '/' code.
+See L<perlfunc/pack>.
+
=item Don't know how to handle magic of type '%s'
(P) The internal handling of magical variables has been cursed.
=item (Do you need to predeclare %s?)
-(S) This is an educated guess made in conjunction with the message "%s
-found where operator expected". It often means a subroutine or module
+(S syntax) This is an educated guess made in conjunction with the message
+"%s found where operator expected". It often means a subroutine or module
name is being referenced that hasn't been declared yet. This may be
because of ordering problems in your file, or because of a missing
"sub", "package", "require", or "use" statement. If you're referencing
(W misc) You used the obsolescent C<dump()> built-in function, without fully
qualifying it as C<CORE::dump()>. Maybe it's a typo. See L<perlfunc/dump>.
+=item dump is not supported
+
+(F) Your machine doesn't support dump/undump.
+
=item Duplicate free() ignored
(S malloc) An internal routine called free() on something that had
already been freed.
+=item Duplicate modifier '%c' after '%c' in %s
+
+(W) You have applied the same modifier more than once after a type
+in a pack template. See L<perlfunc/pack>.
+
=item elseif should be elsif
-(S) There is no keyword "elseif" in Perl because Larry thinks it's ugly.
-Your code will be interpreted as an attempt to call a method named
+(S syntax) There is no keyword "elseif" in Perl because Larry thinks it's
+ugly. Your code will be interpreted as an attempt to call a method named
"elseif" for the class returned by the following block. This is
unlikely to be what you want.
(F) While under the C<use filetest> pragma, switching the real and
effective uids or gids failed.
+=item %ENV is aliased to %s
+
+(F) You're running under taint mode, and the C<%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.
+
=item Error converting file specification %s
(F) An error peculiar to VMS. Because Perl may have to deal with file
expression that contains the C<(?{ ... })> zero-width assertion, which
is unsafe. See L<perlre/(?{ code })>, and L<perlsec>.
-=item %s: Eval-group not allowed at run time
+=item %s: Eval-group not allowed at runtime, use re 'eval'
(F) Perl tried to compile a regular expression containing the
C<(?{ ... })> zero-width assertion at run time, as it would when the
assertion, but that construct is only allowed when the C<use re 'eval'>
pragma is in effect. See L<perlre/(?{ code })>.
+=item EVAL without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern that nested too many EVAL calls without consuming
+any text. Restructure the pattern so that text is consumed.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
=item Excessively long <> operator
(F) The contents of a <> operator may not exceed the maximum size of a
(F) The C<exec> function is not implemented in MacPerl. See L<perlport>.
-=item Execution of %s aborted due to compilation errors
+=item Execution of %s aborted due to compilation errors.
(F) The final summary message when a Perl compilation fails.
=item %s failed--call queue aborted
-(F) An untrapped exception was raised while executing a CHECK, INIT, or
-END subroutine. Processing of the remainder of the queue of such
-routines has been prematurely ended.
+(F) An untrapped exception was raised while executing a UNITCHECK,
+CHECK, INIT, or END subroutine. Processing of the remainder of the
+queue of such routines has been prematurely ended.
=item False [] range "%s" in regex; marked by <-- HERE in m/%s/
(F) Your machine apparently doesn't implement fcntl(). What is this, a
PDP-11 or something?
+=item FETCHSIZE returned a negative value
+
+(F) A tied array claimed to have a negative number of elements, which
+is not possible.
+
+=item Field too wide in 'u' format in pack
+
+(W pack) Each line in an uuencoded string start with a length indicator
+which can't encode values above 63. So there is no point in asking for
+a line length bigger than that. Perl will behave as if you specified
+C<u63> as format.
+
=item Filehandle %s opened only for input
-(W io) You tried to write on a read-only filehandle. If you intended it
-to be a read-write filehandle, you needed to open it with "+<" or "+>"
-or "+>>" instead of with "<" or nothing. If you intended only to write
-the file, use ">" or ">>". See L<perlfunc/open>.
+(W io) You tried to write on a read-only filehandle. If you intended
+it to be a read-write filehandle, you needed to open it with "+<" or
+"+>" or "+>>" instead of with "<" or nothing. If you intended only to
+write the file, use ">" or ">>". See L<perlfunc/open>.
=item Filehandle %s opened only for output
-(W io) You tried to read from a filehandle opened only for writing.
-If you intended it to be a read/write filehandle, you needed to open it
+(W io) You tried to read from a filehandle opened only for writing, If
+you intended it to be a read/write filehandle, you needed to open it
with "+<" or "+>" or "+>>" instead of with "<" or nothing. If you
intended only to read from the file, use "<". See L<perlfunc/open>.
+Another possibility is that you attempted to open filedescriptor 0
+(also known as STDIN) for output (maybe you closed STDIN earlier?).
=item Filehandle %s reopened as %s only for input
(W io) You opened for reading a filehandle that got the same filehandle id
-as STDOUT or STDERR. This occured because you closed STDOUT or STDERR
+as STDOUT or STDERR. This occurred because you closed STDOUT or STDERR
previously.
=item Filehandle STDIN reopened as %s only for output
(W io) You opened for writing a filehandle that got the same filehandle id
-as STDIN. This occured because you closed STDIN previously.
+as STDIN. This occurred because you closed STDIN previously.
=item Final $ should be \$ or $name
happens to be missing. So you have to put either the backslash or the
name.
-=item Final @ should be \@ or @name
-
-(F) You must now decide whether the final @ in a string was meant to be
-a literal "at" sign, or was meant to introduce a variable name that
-happens to be missing. So you have to put either the backslash or the
-name.
-
=item flock() on closed filehandle %s
(W closed) The filehandle you're attempting to flock() got itself closed
filehandles. Are you attempting to call flock() on a dirhandle by the
same name?
-=item Quantifier follows nothing in regex;
-
-marked by <-- HERE in m/%s/
-
-(F) You started a regular expression with a quantifier. Backslash it if you
-meant it literally. The <-- HERE shows in the regular expression about
-where the problem was discovered. See L<perlre>.
-
=item Format not terminated
(F) A format must be terminated by a line with a solitary dot. Perl got
=item %s found where operator expected
-(S) The Perl lexer knows whether to expect a term or an operator. If it
-sees what it knows to be a term when it was expecting to see an
+(S syntax) The Perl lexer knows whether to expect a term or an operator.
+If it sees what it knows to be a term when it was expecting to see an
operator, it gives you this warning. Usually it indicates that an
operator or delimiter was omitted, such as a semicolon.
=item Global symbol "%s" requires explicit package name
-(F) You've said "use strict vars", which indicates that all variables
-must either be lexically scoped (using "my"), declared beforehand using
-"our", or explicitly qualified to say which package the global variable
-is in (using "::").
+(F) You've said "use strict" or "use strict vars", which indicates
+that all variables must either be lexically scoped (using "my" or "state"),
+declared beforehand using "our", or explicitly qualified to say
+which package the global variable is in (using "::").
=item glob failed (%s)
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=item gmtime(%.0f) too large
+
+(W overflow) You called C<gmtime> with an number that was larger than
+it can reliably handle and C<gmtime> probably returned the wrong
+date. This warning is also triggered with nan (the special
+not-a-number value).
+
+=item gmtime(%.0f) too small
+
+(W overflow) You called C<gmtime> with an number that was smaller than
+it can reliably handle and C<gmtime> probably returned the wrong
+date. This warning is also triggered with nan (the special
+not-a-number value).
+
=item Got an error from DosAllocMem
(P) An error peculiar to OS/2. Most probably you're using an obsolete
(F) Unlike with "next" or "last", you're not allowed to goto an
unspecified destination. See L<perlfunc/goto>.
-=item %s-group starts with a count
+=item ()-group starts with a count
-(F) In pack/unpack a ()-group started with a count. A count is
+(F) A ()-group started with a count. A count is
supposed to follow something: a template character or a ()-group.
+ See L<perlfunc/pack>.
-=item %s had compilation errors
+=item %s had compilation errors.
(F) The final summary message when a C<perl -c> fails.
names (like C<$A::B>). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
+=item Ignoring zero length \N{} in character class
+
+(W) Named Unicode character escapes (\N{...}) may return a
+zero length sequence. When such an escape is used in a character class
+its behaviour is not well defined. Check that the correct escape has
+been used, and the correct charname handler is in scope.
+
=item Illegal binary digit %s
(F) You used a digit other than 0 or 1 in a binary number.
=item Illegal character in prototype for %s : %s
-(W syntax) An illegal character was found in a prototype declaration. Legal
-characters in prototypes are $, @, %, *, ;, [, ], &, and \.
+(W illegalproto) An illegal character was found in a prototype declaration.
+Legal characters in prototypes are $, @, %, *, ;, [, ], &, and \.
+
+=item Illegal declaration of anonymous subroutine
+
+(F) When using the C<sub> keyword to construct an anonymous subroutine,
+you must always specify a block of code. See L<perlsub>.
+
+=item Illegal declaration of subroutine %s
+
+(F) A subroutine was not declared correctly. See L<perlsub>.
=item Illegal division by zero
(W digit) You may have tried to use an 8 or 9 in an octal number.
Interpretation of the octal number stopped before the 8 or 9.
-=item Illegal switch in PERL5OPT: %s
+=item Illegal switch in PERL5OPT: -%c
(X) The PERL5OPT environment variable may only be used to set the
-following switches: B<-[DIMUdmtw]>.
+following switches: B<-[CDIMUdmtw]>.
=item Ill-formed CRTL environ value "%s"
Failure of user callbacks dispatched using the C<G_KEEPERR> flag could
also result in this warning. See L<perlcall/G_KEEPERR>.
+=item Inconsistent hierarchy during C3 merge of class '%s': merging failed on parent '%s'
+
+(F) The method resolution order (MRO) of the given class is not
+C3-consistent, and you have enabled the C3 MRO for this class. See the C3
+documentation in L<mro> for more information.
+
=item In EBCDIC the v-string components cannot exceed 2147483647
(F) An error peculiar to EBCDIC. Internally, v-strings are stored as
Unicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC
encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
+=item Infinite recursion in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern that references itself without consuming any input
+text. You should check the pattern to ensure that recursive patterns
+either consume text or fail.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
+=item Initialization of state variables in list context currently forbidden
+
+(F) Currently the implementation of "state" only permits the initialization
+of scalar variables in scalar context. Re-write C<state ($a) = 42> as
+C<state $a = 42> to change from list to scalar context. Constructions such
+as C<state (@a) = foo()> will be supported in a future perl release.
+
=item Insecure dependency in %s
(F) You tried to do something that the tainting mechanism didn't like.
(F) You can't use system(), exec(), or a piped open in a setuid or
setgid script if C<$ENV{PATH}> contains a directory that is writable by
-the world. See L<perlsec>.
+the world. Also, the PATH must not contain any relative directory.
+See L<perlsec>.
=item Insecure $ENV{%s} while running %s
(F) You can't use system(), exec(), or a piped open in a setuid or
setgid script if any of C<$ENV{PATH}>, C<$ENV{IFS}>, C<$ENV{CDPATH}>,
-C<$ENV{ENV}> or C<$ENV{BASH_ENV}> 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 L<perlsec>.
+C<$ENV{ENV}>, C<$ENV{BASH_ENV}> or C<$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 L<perlsec>.
=item Integer overflow in %s number
internally--subject to loss of precision errors in subsequent
operations.
+=item Integer overflow in format string for %s
+
+(F) The indexes and widths specified in the format string of C<printf()>
+or C<sprintf()> are too large. The numbers must not overflow the size of
+integers for your architecture.
+
+=item Integer overflow in version
+
+(F) Some portion of a version initialization is too large for the
+size of integers for your architecture. This is not a warning
+because there is no rational reason for a version to try and use a
+element larger than typically 2**32. This is usually caused by
+trying to use some odd mathematical operation as a version, like
+100/9.
+
=item Internal disaster in regex; marked by <-- HERE in m/%s/
(P) Something went badly wrong in the regular expression parser.
(W printf) Perl does not understand the given format conversion. See
L<perlfunc/sprintf>.
-=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
+=item Invalid escape in the specified encoding in regex; marked by <-- HERE in m/%s/
-(F) The range specified in a character class had a minimum character
-greater than the maximum character. One possibility is that you forgot the
-C<{}> from your ending C<\x{}> - C<\x> without the curly braces can go only
+(W regexp) The numeric escape (for example C<\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.
+The <-- HERE shows in the regular expression about where the
+escape was discovered.
+
+=item Invalid mro name: '%s'
+
+(F) You tried to C<mro::set_mro("classname", "foo")>
+or C<use mro 'foo'>, where C<foo> is not a valid method resolution order (MRO).
+(Currently, the only valid ones are C<dfs> and C<c3>). See L<mro>.
+
+=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
+
+(F) The range specified in a character class had a minimum character
+greater than the maximum character. One possibility is that you forgot the
+C<{}> from your ending C<\x{}> - C<\x> without the curly braces can go only
up to C<ff>. The <-- HERE shows in the regular expression about where the
problem was discovered. See L<perlre>.
parenthesised parameter list, perhaps that list was terminated too soon.
See L<attributes>.
-=item Invalid type in pack: '%s'
+=item Invalid separator character %s in PerlIO layer specification %s
-(F) The given character is not a valid pack type. See L<perlfunc/pack>.
-(W pack) The given character is not a valid pack type but used to be
-silently ignored.
+(W layer) When pushing layers onto the Perl I/O system, something other than a
+colon or whitespace was seen between the elements of a layer list.
+If the previous attribute had a parenthesised parameter list, perhaps that
+list was terminated too soon.
-=item Invalid type in unpack: '%s'
+=item Invalid type '%s' in %s
-(F) The given character is not a valid unpack type. See
-L<perlfunc/unpack>.
-(W unpack) The given character is not a valid unpack type but used to be
+(F) The given character is not a valid pack or unpack type.
+See L<perlfunc/pack>.
+(W) The given character is not a valid pack or unpack type but used to be
silently ignored.
+=item Invalid version format (multiple underscores)
+
+(F) Versions may contain at most a single underscore, which signals
+that the version is a beta release. See L<version> for the allowed
+version formats.
+
+=item Invalid version format (underscores before decimal)
+
+(F) Versions may not contain decimals after the optional underscore.
+See L<version> for the allowed version formats.
+
=item ioctl is not implemented
(F) Your machine apparently doesn't implement ioctl(), which is pretty
(W unopened) You tried ioctl() on a filehandle that was never opened.
Check you control flow and number of arguments.
+=item IO layers (like '%s') unavailable
+
+(F) Your Perl has not been configured to have PerlIO, and therefore
+you cannot use IO layers. To have PerlIO Perl must be configured
+with 'useperlio'.
+
=item IO::Socket::atmark not implemented on this architecture
(F) Your machine doesn't implement the sockatmark() functionality,
neither as a system call or an ioctl call (SIOCATMARK).
+=item $* is no longer supported
+
+(D deprecated, syntax) The special variable C<$*>, deprecated in older perls, has
+been removed as of 5.9.0 and is no longer supported. In previous versions of perl the use of
+C<$*> enabled or disabled multi-line matching within a string.
+
+Instead of using C<$*> you should use the C</m> (and maybe C</s>) regexp
+modifiers. (In older versions: when C<$*> was set to a true value then all regular
+expressions behaved as if they were written using C</m>.)
+
+=item $# is no longer supported
+
+(D deprecated, syntax) The special variable C<$#>, deprecated in older perls, has
+been removed as of 5.9.3 and is no longer supported. You should use the
+printf/sprintf functions instead.
+
=item `%s' is not a code reference
(W overload) The second (fourth, sixth, ...) argument of overload::constant
(F) While under the C<use filetest> pragma, switching the real and
effective uids or gids failed.
+=item length/code after end of string in unpack
+
+(F) While unpacking, the string buffer was already used up when an unpack
+length/code combination tried to obtain more data. This results in
+an undefined value for the length. See L<perlfunc/pack>.
+
+=item Lexing code attempted to stuff non-Latin-1 character into Latin-1 input
+
+(F) An extension is attempting to insert text into the current parse
+(using L<lex_stuff_pvn_flags|perlapi/lex_stuff_pvn_flags> or similar), but
+tried to insert a character that couldn't be part of the current input.
+This is an inherent pitfall of the stuffing mechanism, and one of the
+reasons to avoid it. Where it is necessary to stuff, stuffing only
+plain ASCII is recommended.
+
+=item Lexing code internal error (%s)
+
+(F) Lexing code supplied by an extension violated the lexer's API in a
+detectable way.
+
=item listen() on closed socket %s
(W closed) You tried to do a listen on a closed socket. Did you forget
to check the return value of your socket() call? See
L<perlfunc/listen>.
+=item localtime(%.0f) too large
+
+(W overflow) You called C<localtime> with an number that was larger
+than it can reliably handle and C<localtime> probably returned the
+wrong date. This warning is also triggered with nan (the special
+not-a-number value).
+
+=item localtime(%.0f) too small
+
+(W overflow) You called C<localtime> with an number that was smaller
+than it can reliably handle and C<localtime> probably returned the
+wrong date. This warning is also triggered with nan (the special
+not-a-number value).
+
+=item Lookbehind longer than %d not implemented in regex m/%s/
+
+(F) There is currently a limit on the length of string which lookbehind can
+handle. This restriction may be eased in a future release.
+
+=item Lost precision when %s %f by 1
+
+(W) The value you attempted to increment or decrement by one is too large
+for the underlying floating point representation to store accurately,
+hence the target of C<++> or C<--> 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 L<Math::BigInt> explicitly.
+
=item lstat() on filehandle %s
(W io) You tried to do an lstat on a filehandle. What did you mean
by that? lstat() makes sense only on filenames. (Perl did a fstat()
instead on the filehandle.)
+=item lvalue attribute ignored after the subroutine has been defined
+
+(W misc) Making a subroutine an lvalue subroutine after it has been defined
+by declaring the subroutine with a lvalue attribute is not
+possible. To make the the subroutine a lvalue subroutine add the
+lvalue attribute to the definition, or put the the declaration before
+the definition.
+
=item Lvalue subs returning %s not implemented yet
(F) Due to limitations in the current implementation, array and hash
values cannot be returned in subroutines used in lvalue context. See
L<perlsub/"Lvalue subroutines">.
-=item Lookbehind longer than %d not implemented in regex;
+=item Malformed integer in [] in pack
-marked by <-- HERE in m/%s/
+(F) Between the brackets enclosing a numeric repeat count only digits
+are permitted. See L<perlfunc/pack>.
-(F) There is currently a limit on the length of string which lookbehind can
-handle. This restriction may be eased in a future release. The <-- HERE
-shows in the regular expression about where the problem was discovered.
+=item Malformed integer in [] in unpack
+
+(F) Between the brackets enclosing a numeric repeat count only digits
+are permitted. See L<perlfunc/pack>.
=item Malformed PERLLIB_PREFIX
=item Malformed UTF-8 character (%s)
-Perl detected something that didn't comply with UTF-8 encoding rules.
+(S utf8) (F) Perl detected a string that didn't comply with UTF-8
+encoding rules, even though it had the UTF8 flag on.
-One possible cause is that you read in data that you thought to be in
-UTF-8 but it wasn't (it was for example legacy 8-bit data). Another
-possibility is careless use of utf8::upgrade().
+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_utf8.
+
+If you use the C<:encoding(UTF-8)> PerlIO layer for input, invalid byte
+sequences are handled gracefully, but if you use C<:utf8>, the flag is
+set without validating the data, possibly resulting in this error
+message.
+
+See also L<Encode/"Handling Malformed Data">.
=item Malformed UTF-16 surrogate
-Perl thought it was reading UTF-16 encoded character data but while
+(F) Perl thought it was reading UTF-16 encoded character data but while
doing it Perl met a malformed Unicode surrogate.
-=item %s matches null string many times in regex;
+=item Malformed UTF-8 returned by \N
+
+(F) The charnames handler returned malformed UTF-8.
+
+=item Malformed UTF-8 string in pack
+
+(F) You tried to pack something that didn't comply with UTF-8 encoding
+rules and perl was unable to guess how to make more progress.
+
+=item Malformed UTF-8 string in unpack
+
+(F) You tried to unpack something that didn't comply with UTF-8 encoding
+rules and perl was unable to guess how to make more progress.
+
+=item Malformed UTF-8 string in '%c' format in unpack
+
+(F) You tried to unpack something that didn't comply with UTF-8 encoding
+rules and perl was unable to guess how to make more progress.
-marked by <-- HERE in m/%s/
+=item Maximal count of pending signals (%d) exceeded
+
+(F) Perl aborted due to a too high number of signals pending. This
+usually indicates that your operating system tried to deliver signals
+too fast (with a very high priority), starving the perl process from
+resources it would need to reach a point where it can process signals
+safely. (See L<perlipc/"Deferred Signals (Safe Signals)">.)
+
+=item %s matches null string many times in regex; marked by <-- HERE in m/%s/
(W regexp) The pattern you've specified would be an infinite loop if the
regular expression engine didn't specifically check for that. The <-- HERE
interpreter, especially if the word that is being warned about is
"use" or "my".
-=item % may only be used in unpack
+=item % may not be used in pack
(F) You can't pack a string by supplying a checksum, because the
checksumming process loses information, and you can't go the other way.
(W syntax) An underscore (underbar) in a numeric constant did not
separate two digits.
-=item Missing %sbrace%s on \N{}
+=item Missing argument in %s
+
+(W uninitialized) A printf-type format required more arguments than were
+supplied.
+
+=item Missing argument to -%c
+
+(F) The argument to the indicated command line switch must follow
+immediately after the switch, without intervening spaces.
+
+=item Missing braces on \N{}
(F) Wrong syntax of character name literal C<\N{charname}> within
-double-quotish context.
+double-quotish context. This can also happen when there is a space (or
+comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
+This modifier does not change the requirement that the brace immediately follow
+the C<\N>.
=item Missing comma after first argument to %s function
C<open(FH, "command |")> construction, but the command was missing or
blank.
+=item Missing control char name in \c
+
+(F) A double-quoted string ended with "\c", without the required control
+character name.
+
=item Missing name in "my sub"
(F) The reserved syntax for lexically scoped subroutines requires that
=item (Missing operator before %s?)
-(S) This is an educated guess made in conjunction with the message "%s
-found where operator expected". Often the missing operator is a comma.
+(S syntax) This is an educated guess made in conjunction with the message
+"%s found where operator expected". Often the missing operator is a comma.
=item Missing right brace on %s
-(F) Missing right brace in C<\p{...}> or C<\P{...}>.
+(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
+
+=item Missing right brace on \\N{} or unescaped left brace after \\N
+
+(F)
+C<\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 C<\N{ASTERISK}> is another way of writing C<*>, valid in both
+double-quoted strings and regular expression patterns. In patterns, it doesn't
+have the meaning an unescaped C<*> does.
+
+Starting in Perl 5.12.0, C<\N> also can have an additional meaning (only) in
+patterns, namely to match a non-newline character. (This is short for
+C<[^\n]>, and like C<.> but is not affected by the C</s> regex modifier.)
+
+This can lead to some ambiguities. When C<\N> is not followed immediately by a
+left brace, Perl assumes the C<[^\n]> meaning. Also, if
+the braces form a valid quantifier such as C<\N{3}> or C<\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 C<\N{>
+and a matching C<}>, Perl assumes that a character name is desired.
+
+However, if there is no matching C<}>, Perl doesn't know if it was mistakenly
+omitted, or if C<[^\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: C<\N\{>
=item Missing right curly or square bracket
=item (Missing semicolon on previous line?)
-(S) This is an educated guess made in conjunction with the message "%s
-found where operator expected". Don't automatically put a semicolon on
+(S syntax) This is an educated guess made in conjunction with the message
+"%s found where operator expected". Don't automatically put a semicolon on
the previous line just because you saw this message.
=item Modification of a read-only value attempted
you omitted the name of the module. Consult L<perlrun> for full details
about C<-M> and C<-m>.
-=item More than one argument to open
+=item More than one argument to '%s' open
(F) The C<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
(W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
They're written like C<$foo[1][2][3]>, as in C.
-=item / must be followed by a*, A* or Z*
-
-(F) You had a pack template indicating a counted-length string,
-Currently the only things that can have their length counted are a*, A*
-or Z*. See L<perlfunc/pack>.
-
-=item / must be followed by a, A or Z
+=item '/' must follow a numeric type in unpack
-(F) You had an unpack template indicating a counted-length string, which
-must be followed by one of the letters a, A or Z to indicate what sort
-of string is to be unpacked. See L<perlfunc/pack>.
-
-=item / must follow a numeric type
-
-(F) You had an unpack template that contained a '#', but this did not
-follow some numeric unpack specification. See L<perlfunc/pack>.
+(F) You had an unpack template that contained a '/', but this did not
+follow some unpack specification producing a numeric value.
+See L<perlfunc/pack>.
=item "my sub" not yet implemented
(F) Lexically scoped subroutines are not yet implemented. Don't try
that yet.
-=item "my" variable %s can't be in a package
+=item "%s" variable %s can't be in a package
(F) Lexically scoped variables aren't in a package, so it doesn't make
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
+=item \\N in a character class must be a named character: \\N{...}
+
+(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed
+character class, for the same reason that C<.> in a character class loses its
+specialness: it matches almost everything, which is probably not what you want.
+
+=item \\N{NAME} must be resolved by the lexer
+
+(F) When compiling a regex pattern, an unresolved named character or sequence
+was encountered. This can happen in any of several ways that bypass the lexer,
+such as using single-quotish context, or an extra backslash in double quotish:
+
+ $re = '\N{SPACE}'; # Wrong!
+ $re = "\\N{SPACE}"; # Wrong!
+ /$re/;
+
+Instead, use double-quotes with a single backslash:
+
+ $re = "\N{SPACE}"; # ok
+ /$re/;
+
+The lexer can be bypassed as well by creating the pattern from smaller
+components:
+
+ $re = '\N';
+ /${re}{SPACE}/; # Wrong!
+
+It's not a good idea to split a construct in the middle like this, and it
+doesn't work here. Instead use the solution above.
+
+Finally, the message also can happen under the C</x> regex modifier when the
+C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
+
+ /\N {SPACE}/x; # Wrong!
+ /\N{SPACE}/x; # ok
+
=item Name "%s::%s" used only once: possible typo
(W once) Typographical errors often show up as unique variable names.
again somehow to suppress the message. The C<our> declaration is
provided for this purpose.
+NOTE: This warning detects symbols that have been used only once so $c, @c,
+%c, *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.
+
+=item Invalid hexadecimal number in \\N{U+...}
+
+(F) The character constant represented by C<...> 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.
+
+=item Negative '/' count in unpack
+
+(F) The length count obtained from a length/code unpack operation was
+negative. See L<perlfunc/pack>.
+
=item Negative length
(F) You tried to do a read/write/send/recv operation with a buffer
(S internal) The symbol in question was declared but somehow went out of
scope before it could possibly have been used.
+=item next::method/next::can/maybe::next::method cannot find enclosing method
+
+(F) C<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 L<mro>.
+
=item No %s allowed while running setuid
(F) Certain operations are deemed to be too insecure for a setuid or
will be another way to do what you want that is, if not secure, at least
securable. See L<perlsec>.
-=item No B<-e> allowed in setuid scripts
-
-(F) A setuid script can't be specified by the user.
-
=item No comma allowed after %s
(F) A list operator that has a filehandle or "indirect object" is not
=item No DB::DB routine defined
(F) The currently executing code was compiled with the B<-d> switch, but
-for some reason the perl5db.pl file (or some facsimile thereof) didn't
-define a routine to be called at the beginning of each statement. Which
-is odd, because the file should have been required automatically, and
-should have blown up the require if it didn't parse right.
+for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
+module) didn't define a routine to be called at the beginning of each
+statement.
=item No dbm on this machine
(P) This is counted as an internal error, because every machine should
supply dbm nowadays, because Perl comes with SDBM. See L<SDBM_File>.
-=item No DBsub routine
+=item No DB::sub routine defined
+
+(F) The currently executing code was compiled with the B<-d> switch, but
+for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
+module) didn't define a C<DB::sub> routine to be called at the beginning
+of each ordinary subroutine call.
-(F) The currently executing code was compiled with the B<-d> switch,
-but for some reason the perl5db.pl file (or some facsimile thereof)
-didn't define a DB::sub routine to be called at the beginning of each
-ordinary subroutine call.
+=item No B<-e> allowed in setuid scripts
+
+(F) A setuid script can't be specified by the user.
=item No error file after 2> or 2>> on command line
redirection, and found a '2>' or a '2>>' on the command line, but can't
find the name of the file to which to write data destined for stderr.
+=item No group ending character '%c' found in template
+
+(F) A pack or unpack template has an opening '(' or '[' without its
+matching counterpart. See L<perlfunc/pack>.
+
=item No input file after < on command line
(F) An error peculiar to VMS. Perl handles its own command line
(F) The setuid emulator requires that scripts have a well-formed #! line
even on machines that don't support the #! construct.
+=item No next::method '%s' found for %s
+
+(F) C<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 C<maybe::next::method>
+or C<next::can>. See L<mro>.
+
=item "no" not allowed in expression
(F) The "no" keyword is recognized and executed at compile time, and
(F) Configure didn't find anything resembling the setreuid() call for
your system.
-=item No space allowed after -%c
-
-(F) The argument to the indicated command line switch must follow
-immediately after the switch, without intervening spaces.
-
=item No %s specified for -%c
(F) The indicated command line switch needs a mandatory argument, but
you haven't specified one.
+=item No such class field "%s" in variable %s of type %s
+
+(F) You tried to access a key from a hash through the indicated typed variable
+but that key is not allowed by the package of the same type. The indicated
+package has restricted the set of allowed keys using the L<fields> pragma.
+
=item No such class %s
-(F) You provided a class qualifier in a "my" or "our" declaration, but
+(F) You provided a class qualifier in a "my", "our" or "state" declaration, but
this class doesn't exist at this point in your program.
+=item No such hook: %s
+
+(F) You specified a signal hook that was not recognized by Perl. Currently, Perl
+accepts C<__DIE__> and C<__WARN__> as valid signal hooks
+
=item No such pipe open
(P) An error peculiar to VMS. The internal routine my_pclose() tried to
of Perl. Check the #! line, or manually feed your script into Perl
yourself.
-=item %s not allowed in length fields
-
-(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
-C<TEMPLATE> always matches the same amount of packed bytes. Redesign
-the template.
-
=item no UTC offset information; assuming local time is UTC
(S) A warning peculiar to VMS. Perl was unable to find the local
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
+=item Non-string passed as bitmask
+
+(W misc) A number has been passed as a bitmask argument to select().
+Use the vec() function to construct the file descriptor bitmasks for
+select. See L<perlfunc/select>
+
=item Null filename used
(F) You can't require the null filename, especially because on many
=item Offset outside string
-(F) You tried to do a read/write/send/recv operation with an offset
-pointing outside the buffer. This is difficult to imagine. The sole
-exception to this is that C<sysread()>ing past the buffer will extend
-the buffer and zero pad the new area.
-
-=item -%s on unopened filehandle %s
-
-(W unopened) You tried to invoke a file test operator on a filehandle
-that isn't open. Check your control flow. See also L<perlfunc/-X>.
+(F, W layer) You tried to do a read/write/send/recv/seek operation
+with an offset pointing outside the buffer. This is difficult to
+imagine. The sole exceptions to this are that zero padding will
+take place when going past the end of the string when either
+C<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 behaviour
+with real files).
=item %s() on unopened %s
never initialized. You need to do an open(), a sysopen(), or a socket()
call, or call a constructor from the FileHandle package.
+=item -%s on unopened filehandle %s
+
+(W unopened) You tried to invoke a file test operator on a filehandle
+that isn't open. Check your control flow. See also L<perlfunc/-X>.
+
=item oops: oopsAV
(S internal) An internal warning that the grammar is screwed up.
(S internal) An internal warning that the grammar is screwed up.
-=item Operation `%s': no method found, %s
+=item Opening dirhandle %s also as a file
+
+(W io deprecated) You used open() to associate a filehandle to
+a symbol (glob or scalar) that already holds a dirhandle.
+Although legal, this idiom might render your code confusing
+and is deprecated.
+
+=item Opening filehandle %s also as a directory
+
+(W io deprecated) You used opendir() to associate a dirhandle to
+a symbol (glob or scalar) that already holds a filehandle.
+Although legal, this idiom might render your code confusing
+and is deprecated.
+
+=item Operation "%s": no method found, %s
(F) An attempt was made to perform an overloaded operation for which no
handler was defined. While some handlers can be autogenerated in terms
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 C<limit> and
+C<limit datasize n> (where C<n> is the number of kilobytes) to check
+the current limits and change them, and in ksh/bash/zsh use C<ulimit -a>
+and C<ulimit -d n>, respectively.
+
+=item Out of memory during %s extend
+
+(X) An attempt was made to extend an array, a list, or a string beyond
+the largest possible memory allocation.
+
=item Out of memory during "large" request for %s
(F) The malloc() function returned 0, indicating there was insufficient
parsing, but realloc() wouldn't give it more memory, virtual or
otherwise.
-=item @ outside of string
+=item '.' outside of string in pack
+
+(F) The argument to a '.' in your template tried to move the working
+position to before the start of the packed string being built.
-(F) You had a pack template that specified an absolute position outside
+=item '@' outside of string in unpack
+
+(F) You had a template that specified an absolute position outside
the string being unpacked. See L<perlfunc/pack>.
+=item '@' outside of string with malformed UTF-8 in unpack
+
+(F) You had a template that specified an absolute position outside
+the string being unpacked. The string being unpacked was also invalid
+UTF-8. See L<perlfunc/pack>.
+
+=item Overloaded dereference did not return a reference
+
+(F) An object with an overloaded dereference operator was dereferenced,
+but the overloaded operation did not return a reference. See
+L<overload>.
+
+=item Overloaded qr did not return a REGEXP
+
+(F) An object with a C<qr> overload was used as part of a match, but the
+overloaded operation didn't return a compiled regexp. See L<overload>.
+
=item %s package attribute may clash with future reserved word: %s
(W reserved) A lowercase attribute name was used that had a
some day, even though it doesn't yet. Perhaps you should use a
mixed-case attribute name, instead. See L<attributes>.
+=item pack/unpack repeat count overflow
+
+(F) You can't specify a repeat count so large that it overflows your
+signed integers. See L<perlfunc/pack>.
+
=item page overflow
(W io) A single call to write() produced more lines than can fit on a
(P) An internal error.
+=item panic: attempt to call %s in %s
+
+(P) One of the file test operators entered a code branch that calls
+an ACL related-function, but that function is not available on this
+platform. Earlier checks mean that it should not be possible to
+enter this branch on this platform.
+
=item panic: ck_grep
(P) Failed an internal consistency check trying to compile a grep.
(P) Failed an internal consistency check while trying to reset a weak
reference.
+=item panic: Devel::DProf inconsistent subroutine return
+
+(P) Devel::DProf called a subroutine that exited using goto(LABEL),
+last(LABEL) or next(LABEL). Leaving that way a subroutine called from
+an XSUB will lead very probably to a crash of the interpreter. This is
+a bug that will hopefully one day get fixed.
+
=item panic: die %s
(P) We popped the context stack to an eval context, and then discovered
it wasn't an eval context.
-=item panic: pp_match%s
-
-(P) The internal pp_match() routine was called with invalid operational
-data.
-
=item panic: do_subst
(P) The internal pp_subst() routine was called with invalid operational
(P) The internal do_trans routines were called with invalid operational
data.
+=item panic: fold_constants JMPENV_PUSH returned %d
+
+(P) While attempting folding constants an exception other than an C<eval>
+failure was caught.
+
=item panic: frexp
(P) The library function frexp() failed, making printf("%f") impossible.
(P) We popped the context stack to a context with the specified label,
and then discovered it wasn't a context we know how to do a goto in.
+=item panic: hfreeentries failed to free hash
+
+(P) The internal routine used to clear a hashes entries tried repeatedly,
+but each time something added more entries to the hash. Most likely the hash
+contains an object with a reference back to the hash and a destructor that
+adds a new object to the hash.
+
=item panic: INTERPCASEMOD
(P) The lexer got into a bad state at a case modifier.
(P) Something requested a negative number of bytes of malloc.
-=item panic: mapstart
+=item panic: memory wrap
-(P) The compiler is screwed up with respect to the map() function.
-
-=item panic: null array
-
-(P) One of the internal array routines was passed a null AV pointer.
+(P) Something tried to allocate more memory than possible.
=item panic: pad_alloc
(P) The foreach iterator got called in a non-loop context frame.
+=item panic: pp_match%s
+
+(P) The internal pp_match() routine was called with invalid operational
+data.
+
=item panic: pp_split
(P) Something terrible went wrong in setting up for the split.
(P) scan_num() got called on something that wasn't a number.
+=item panic: sv_chop %s
+
+(P) The sv_chop() routine was passed a position that is not within the
+scalar's string buffer.
+
=item panic: sv_insert
(P) The sv_insert() routine was told to remove more string than there
(P) The compiler attempted to do a goto, or something weird like that.
-=item panic: yylex
+=item panic: unimplemented op %s (#%d) called
-(P) The lexer got into a bad state while processing a case modifier.
+(P) The compiler is screwed up and attempted to use an op that isn't permitted
+at run time.
=item panic: utf16_to_utf8: odd bytelen
(P) Something tried to call utf16_to_utf8 with an odd (as opposed
to even) byte length.
+=item panic: utf16_to_utf8_reversed: odd bytelen
+
+(P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed
+to even) byte length.
+
+=item panic: yylex
+
+(P) The lexer got into a bad state while processing a case modifier.
+
+=item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern that uses too many nested subpattern calls without
+consuming any text. Restructure the pattern so text is consumed before the
+nesting limit is exceeded.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
=item Parentheses missing around "%s" list
(W parenthesis) You said something like
my ($foo, $bar) = @_;
-Remember that "my", "our", and "local" bind tighter than comma.
+Remember that "my", "our", "local" and "state" bind tighter than comma.
+
+=item C<-p> destination: %s
+
+(F) An error occurred during the implicit output invoked by the C<-p>
+command-line switch. (This output goes to STDOUT unless you've
+redirected it with select().)
+
+=item (perhaps you forgot to load "%s"?)
+
+(F) This is an educated guess made in conjunction with the message
+"Can't locate object method \"%s\" via package \"%s\"". It often means
+that a method requires a package that has not been loaded.
+
+=item Perl_my_%s() not available
+
+(F) Your platform has very uncommon byte-order and integer size,
+so it was not possible to set up some or all fixed-width byte-order
+conversion functions. This is only a problem when you're using the
+'<' or '>' modifiers in (un)pack templates. See L<perlfunc/pack>.
+
+=item Perl_pmflag() is deprecated, and will be removed from the XS API
+
+(D deprecated) XS code called the C function C<Perl_pmflag>. This was part of
+Perl's listed public API for extending or embedding the perl interpreter. It has
+now been removed from the public API, and will be removed in a future release,
+hence XS code should be re-written not to use it.
=item Perl %s required--this is only version %s, stopped
(F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
C<sh>-shell in. See "PERL_SH_DIR" in L<perlos2>.
+=item PERL_SIGNALS illegal: "%s"
+
+See L<perlrun/PERL_SIGNALS> for legal values.
+
=item perl: warning: Setting locale failed.
(S) The whole warning message will look something like:
you run Perl. How to really fix the problem can be found in
L<perllocale> section B<LOCALE PROBLEMS>.
-=item perlio: argument list not closed for layer "%s"
-
-(W layer) When pushing a layer with arguments onto the Perl I/O system you
-forgot the ) that closes the argument list. (Layers take care of transforming
-data between external and internal representations.) Perl stopped parsing
-the layer list at this point and did not attempt to push this layer.
-If your program didn't explicitly request the failing operation, it may be
-the result of the value of the environment variable PERLIO.
-
-=item perlio: invalid separator character %s in layer specification list %s
-
-(W layer) When pushing layers onto the Perl I/O system, something other than a
-colon or whitespace was seen between the elements of a layer list.
-If the previous attribute had a parenthesised parameter list, perhaps that
-list was terminated too soon.
-
-=item perlio: unknown layer "%s"
-
-(W layer) An attempt was made to push an unknown layer onto the Perl I/O
-system. (Layers take care of transforming data between external and
-internal representations.) Note that some layers, such as C<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.
-
-=item Permission denied
-
-(F) The setuid emulator in suidperl decided you were up to no good.
-
=item pid %x not a child
(W exec) A warning peculiar to VMS. 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.
-=item P must have an explicit size
+=item 'P' must have an explicit size in unpack
(F) The unpack format P must have an explicit size, not "*".
-=item POSIX syntax [%s] belongs inside character classes in regex;
+=item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
+
+(F) The class in the character class [: :] syntax is unknown. The <-- HERE
+shows in the regular expression about where the problem was discovered.
+Note that the POSIX character classes do B<not> have the C<is> prefix
+the corresponding C interfaces have: in other words, it's C<[[:print:]]>,
+not C<isprint>. See L<perlre>.
+
+=item POSIX getpgrp can't take an argument
-marked by <-- HERE in m/%s/
+(F) Your system has POSIX getpgrp(), which takes no argument, unlike
+the BSD version, which takes a pid.
+
+=item POSIX syntax [%s] belongs inside character classes in regex; marked by <-- HERE in m/%s/
(W regexp) The character class constructs [: :], [= =], and [. .] go
I<inside> character classes, the [] are part of the construct, for example:
cause fatal errors. The <-- HERE shows in the regular expression about
where the problem was discovered. See L<perlre>.
-=item POSIX syntax [. .] is reserved for future extensions in regex;
-
-marked by <-- HERE in m/%s/
+=item POSIX syntax [. .] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
(F regexp) Within regular expression character classes ([]) the syntax
beginning with "[." and ending with ".]" is reserved for future extensions.
backslash: "\[." and ".\]". The <-- HERE shows in the regular expression
about where the problem was discovered. See L<perlre>.
-=item POSIX syntax [= =] is reserved for future extensions in regex;
-
-marked by <-- HERE in m/%s/
+=item POSIX syntax [= =] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
(F) Within regular expression character classes ([]) the syntax beginning
with "[=" and ending with "=]" is reserved for future extensions. If you
and "=\]". The <-- HERE shows in the regular expression about where the
problem was discovered. See L<perlre>.
-=item POSIX class [:%s:] unknown in regex;
-
-marked by <-- HERE in m/%s/
-
-(F) The class in the character class [: :] syntax is unknown. The <-- HERE
-shows in the regular expression about where the problem was discovered.
-Note that the POSIX character classes do B<not> have the C<is> prefix
-the corresponding C interfaces have: in other words, it's C<[[:print:]]>,
-not C<isprint>. See L<perlre>.
-
-=item POSIX getpgrp can't take an argument
-
-(F) Your system has POSIX getpgrp(), which takes no argument, unlike
-the BSD version, which takes a pid.
-
=item Possible attempt to put comments in qw() list
(W qw) qw() lists contain items separated by whitespace; as with literal
This expression is actually equivalent to C<$x & ($y == 0)>, due to the
higher precedence of C<==>. This is probably not what you want. (If you
-really meant to write this, disable the warning, or, better, write
-C<$x & ($y == 0 ? 1 : 0)>).
+really meant to write this, disable the warning, or, better, put the
+parentheses explicitly and write C<$x & ($y == 0)>).
=item Possible unintended interpolation of %s in string
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
-=item Possible Y2K bug: %s
-
-(W y2k) You are concatenating the number 19 with another number, which
-could be a potential Year 2000 problem.
-
-=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
+=item Possible unintended interpolation of $\ in regex
-(D deprecated) You have written something like this:
+(W ambiguous) You said something like C<m/$\/> in a regex.
+The regex C<m/foo$\s+bar/m> translates to: match the word 'foo', the output
+record separator (see L<perlvar/$\>) and the letter 's' (one time or more)
+followed by the word 'bar'.
- sub doit
- {
- use attrs qw(locked);
- }
+If this is what you intended then you can silence the warning by using
+C<m/${\}/> (for example: C<m/foo${\}s+bar/>).
-You should use the new declaration syntax instead.
-
- sub doit : locked
- {
- ...
-
-The C<use attrs> pragma is now obsolete, and is only provided for
-backward-compatibility. See L<perlsub/"Subroutine Attributes">.
+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
+C<m/$(?)\/> (for example: C<m/foo$(?)\s+bar/>).
=item Precedence problem: open %s should be open(%s)
L<perlipc/"Signals">. See also "Process terminated by SIGTERM/SIGINT"
in L<perlos2>.
+=item Prototype after '%c' for %s : %s
+
+(W illegalproto) A character follows % or @ in a prototype. This is useless,
+since % and @ gobble the rest of the subroutine arguments.
+
=item Prototype mismatch: %s vs %s
(S prototype) The subroutine being declared or defined had previously been
(F) You've omitted the closing parenthesis in a function prototype
definition.
-=item Quantifier in {,} bigger than %d in regex;
+=item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
+
+(F) You started a regular expression with a quantifier. Backslash it if you
+meant it literally. The <-- HERE shows in the regular expression about
+where the problem was discovered. See L<perlre>.
-marked by <-- HERE in m/%s/
+=item Quantifier in {,} bigger than %d in regex; marked by <-- HERE in m/%s/
(F) There is currently a limit to the size of the min and max values of the
{min,max} construct. The <-- HERE shows in the regular expression about where
the problem was discovered. See L<perlre>.
-=item Quantifier unexpected on zero-length expression;
-
-marked by <-- HERE in m/%s/
+=item Quantifier unexpected on zero-length expression; marked by <-- HERE in m/%s/
(W regexp) You applied a regular expression quantifier in a place where
it makes no sense, such as on a zero-width assertion. Try putting the
One possible workaround is to force Perl to use magical string increment
by prepending "0" to your numbers.
+=item readdir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you're reading from is either closed or not really
+a dirhandle. Check your control flow.
+
=item readline() on closed filehandle %s
(W closed) The filehandle you're reading from got itself closed sometime
before now. Check your control flow.
+=item read() on closed filehandle %s
+
+(W closed) You tried to read from a closed filehandle.
+
+=item read() on unopened filehandle %s
+
+(W unopened) You tried to read from a filehandle that was never opened.
+
=item Reallocation too large: %lx
(F) You can't allocate more than 64K on an MS-DOS machine.
=item Recursive inheritance detected in package '%s'
-(F) More than 100 levels of inheritance were used. Probably indicates
-an unintended loop in your inheritance hierarchy.
+(F) While calculating the method resolution order (MRO) of a package, Perl
+believes it found an infinite loop in the C<@ISA> hierarchy. This is a
+crude check that bails out after 100 levels of C<@ISA> depth.
=item Recursive inheritance detected while looking for method %s
(W internal) The internal sv_replace() function was handed a new SV with
a reference count of other than 1.
-=item Reference to nonexistent group in regex;
+=item Reference to invalid group 0
-marked by <-- HERE in m/%s/
+(F) You used C<\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), but using 0 does not make sense.
+
+=item Reference to nonexistent group in regex; marked by <-- HERE in m/%s/
(F) You used something like C<\7> in your regular expression, but there are
not at least seven sets of capturing parentheses in the expression. If you
The <-- HERE shows in the regular expression about where the problem was
discovered.
+=item Reference to nonexistent or unclosed group in regex; marked by <-- HERE in m/%s/
+
+(F) You used something like C<\g{-7}> in your regular expression, but there are
+not at least seven sets of closed capturing parentheses in the expression before
+where the C<\g{-7}> was located.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
+=item Reference to nonexistent named group in regex; marked by <-- HERE in m/%s/
+
+(F) You used something like C<\k'NAME'> or C<< \k<NAME> >> in your regular
+expression, but there is no corresponding named capturing parentheses such
+as C<(?'NAME'...)> or C<(?<NAME>...). Check if the name has been spelled
+correctly both in the backreference and the declaration.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
+=item (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in m/%s/
+
+(F) You used something like C<(?(DEFINE)...|..)> which is illegal. The
+most likely cause of this error is that you left out a parenthesis inside
+of the C<....> part.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
=item regexp memory corruption
(P) The regular expression engine got confused by what the regular
(P) A "can't happen" error, because safemalloc() should have caught it
earlier.
-=item Repeat count in pack overflows
-
-(F) You can't specify a repeat count so large that it overflows your
-signed integers. See L<perlfunc/pack>.
-
-=item Repeat count in unpack overflows
+=item Repeated format line will never terminate (~~ and @# incompatible)
-(F) You can't specify a repeat count so large that it overflows your
-signed integers. See L<perlfunc/unpack>.
+(F) Your format contains the ~~ repeat-until-blank sequence and a
+numeric field that will never go blank so that the repetition never
+terminates. You might use ^# instead. See L<perlform>.
-=item Result from %s larger than %d bytes
+=item Replacement list is longer than search list
-(W misc) A library call like getgrent() tried to return more results
-than Perl was willing to accept. This happens only when Perl has been
-compiled to have threads and to have an upper limit on such calls
-(the default is to keep regrowing the result buffer until the result fits).
-However, now the results were truncated.
+(W misc) You have used a replacement list that is longer than the
+search list. So the additional elements in the replacement list
+are meaningless.
=item Reversed %s= operator
(W syntax) You wrote your assignment operator backwards. The = must
always comes last, to avoid ambiguity with subsequent unary operators.
-=item Runaway format
+=item rewinddir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
+really a dirhandle. Check your control flow.
+
+=item Scalars leaked: %d
-(F) Your format contained the ~~ repeat-until-blank sequence, but it
-produced 200 lines at once, and the 200th line looked exactly like the
-199th line. Apparently you didn't arrange for the arguments to exhaust
-themselves, either by using ^ instead of @ (for scalar variables), or by
-shifting or popping (for array variables). See L<perlform>.
+(P) Something went wrong in Perl's internal bookkeeping of scalars:
+not all scalar variables were deallocated by the time Perl exited.
+What this usually indicates is a memory leak, which is of course bad,
+especially if the Perl program is intended to be long-running.
=item Scalar value @%s[%s] better written as $%s[%s]
not magically convert between scalars and lists for you. See
L<perlref>.
-=item Scalars leaked: %d
-
-(P) Something went wrong in Perl's internal bookkeeping of scalars:
-not all scalar variables were deallocated by the time Perl exited.
-What this usually indicates is a memory leak, which is of course bad,
-especially if the Perl program is intended to be long-running.
-
-=item Script is not setuid/setgid in suidperl
-
-(F) Oddly, the suidperl program was invoked on a script without a setuid
-or setgid bit set. This doesn't make much sense.
-
=item Search pattern not terminated
(F) The lexer couldn't find the final delimiter of a // or m{}
construct. Remember that bracketing delimiters count nesting level.
Missing the leading C<$> from a variable C<$m> may cause this error.
+Note that since Perl 5.9.0 a // can also be the I<defined-or>
+construct, not just the empty search pattern. Therefore code written
+in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
+misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
+
+=item Search pattern not terminated or ternary operator parsed as search pattern
+
+(F) The lexer couldn't find the final delimiter of a C<?PATTERN?>
+construct.
+
+The question mark is also used as part of the ternary operator (as in
+C<foo ? 0 : 1>) leading to some ambiguous constructions being wrongly
+parsed. One way to disambiguate the parsing is to put parentheses around
+the conditional expression, i.e. C<(foo) ? 0 : 1>.
+
=item %sseek() on unopened filehandle
(W unopened) You tried to use the seek() or sysseek() function on a
filehandle that was either never opened or has since been closed.
+=item seekdir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you are doing a seekdir() on is either closed or not
+really a dirhandle. Check your control flow.
+
=item select not implemented
(F) This machine doesn't implement the select() system call.
shows in the regular expression about where the problem was discovered. See
L<perlre>.
-=item Sequence (?{...}) not terminated or not {}-balanced in regex;
-
-marked by <-- HERE in m/%s/
-
-(F) If the contents of a (?{...}) clause contains braces, they must balance
-for Perl to properly detect the end of the clause. The <-- HERE shows in
-the regular expression about where the problem was discovered. See
-L<perlre>.
-
-=item Sequence (?%s...) not implemented in regex;
-
-marked by <-- HERE in m/%s/
+=item Sequence (?%s...) not implemented in regex; marked by <-- HERE in m/%s/
(F) A proposed regular expression extension has the character reserved but
has not yet been written. The <-- HERE shows in the regular expression about
where the problem was discovered. See L<perlre>.
-=item Sequence (?%s...) not recognized in regex;
-
-marked by <-- HERE in m/%s/
+=item Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/
(F) You used a regular expression extension that doesn't make sense. The
<-- HERE shows in the regular expression about where the problem was
discovered. See L<perlre>.
-=item Sequence (?#... not terminated in regex;
+=item Sequence \\%s... not terminated in regex; marked by <-- HERE in m/%s/
-marked by <-- HERE in m/%s/
+(F) The regular expression expects a mandatory argument following the escape
+sequence and this has been omitted or incorrectly written.
+
+=item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/
(F) A regular expression comment must be terminated by a closing
parenthesis. Embedded parentheses aren't allowed. The <-- HERE shows in
the regular expression about where the problem was discovered. See
L<perlre>.
+=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
+
+(F) If the contents of a (?{...}) clause contains braces, they must balance
+for Perl to properly detect the end of the clause. The <-- HERE shows in
+the regular expression about where the problem was discovered. See
+L<perlre>.
+
=item 500 Server error
See Server error.
(F) The setuid emulator won't run a script that is writable by the
world, because the world might have written on it already.
+=item Setuid script not plain file
+
+(F) The setuid emulator won't run a script that isn't read from a file,
+but from a socket, a pipe or another device.
+
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
+=item !=~ should be !~
+
+(W syntax) The non-matching operator is !~, not !=~. !=~ will be
+interpreted as the != (numeric not equal) and ~ (1's complement)
+operators: probably not what you intended.
+
=item <> should be quotes
(F) You wrote C<< require <file> >> when you should have written
(W signal) The signal handler named in %SIG doesn't, in fact, exist.
Perhaps you put it into the wrong package?
+=item Smart matching a non-overloaded object breaks encapsulation
+
+(F) You should not use the C<~~> operator on an object that does not
+overload it: Perl refuses to use the object's underlying structure for
+the smart match.
+
=item sort is now a reserved word
(F) An ancient error message that almost nobody ever runs into anymore.
But before sort was a keyword, people sometimes used it as a filehandle.
-=item Sort subroutine didn't return a numeric value
-
-(F) A sort comparison routine must return a number. You probably blew
-it by not using C<< <=> >> or C<cmp>, or by not using them correctly.
-See L<perlfunc/sort>.
-
=item Sort subroutine didn't return single value
(F) A sort comparison subroutine may not return a list value with more
(W unopened) You tried to use the stat() function on a filehandle that
was either never opened or has since been closed.
-=item Stub found while resolving method `%s' overloading %s
+=item Stub found while resolving method "%s" overloading "%s" in package "%s"
(P) Overloading resolution over @ISA tree may be broken by importation
stubs. Stubs should never be implicitly created, but explicit calls to
(P) The substitution was looping infinitely. (Obviously, a substitution
shouldn't iterate more times than there are characters of input, which
is what happened.) See the discussion of substitution in
-L<perlop/"Quote and Quote-like Operators">.
+L<perlop/"Regexp Quote-Like Operators">.
=item Substitution pattern not terminated
substr is used in an lvalue context (as the left hand side of an
assignment or as a subroutine argument for example).
-=item suidperl is no longer needed since %s
-
-(F) Your Perl was compiled with B<-D>SETUID_SCRIPTS_ARE_SECURE_NOW, but
-a version of the setuid emulator somehow got run anyway.
+=item sv_upgrade from type %d down to type %d
-=item Switch (?(condition)... contains too many branches in regex;
+(P) Perl tried to force the upgrade an SV to a type which was actually
+inferior to its current type.
-marked by <-- HERE in m/%s/
+=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
(F) A (?(condition)if-clause|else-clause) construct can have at most two
branches (the if-clause and the else-clause). If you want one or both to
The <-- HERE shows in the regular expression about where the problem was
discovered. See L<perlre>.
-=item Switch condition not recognized in regex;
-
-marked by <-- HERE in m/%s/
+=item Switch condition not recognized in regex; marked by <-- HERE in m/%s/
(F) If the argument to the (?(...)if-clause|else-clause) construct is a
number, it can be only a number. The <-- HERE shows in the regular expression
(F) While under the C<use filetest> pragma, we cannot switch the real
and effective uids or gids.
+=item %s syntax
+
+(F) The final summary message when a C<perl -c> succeeds.
+
=item syntax error
(F) Probably means you had a syntax error. Common reasons include:
a perl4 interpreter, especially if the next 2 tokens are "use strict"
or "my $var" or "our $var".
-=item %s syntax OK
+=item sysread() on closed filehandle %s
-(F) The final summary message when a C<perl -c> succeeds.
+(W closed) You tried to read from a closed filehandle.
+
+=item sysread() on unopened filehandle %s
+
+(W unopened) You tried to read from a filehandle that was never opened.
=item System V %s is not implemented on this machine
(W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
+=item C<-T> and C<-B> not implemented on filehandles
+
+(F) Perl can't peek at the stdio buffer of filehandles when it doesn't
+know about your kind of stdio. You'll have to use a filename instead.
+
=item Target of goto is too deeply nested
(F) You tried to use C<goto> to reach a label that was too deeply nested
(W unopened) You tried to use the tell() function on a filehandle that
was either never opened or has since been closed.
+=item telldir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to telldir() is either closed or not really
+a dirhandle. Check your control flow.
+
=item That use of $[ is unsupported
(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
past the symlink to get to the real file. Use an actual filename
instead.
+=item The 'unique' attribute may only be applied to 'our' variables
+
+(F) This attribute was never supported on C<my> or C<sub> declarations.
+
=item This Perl can't reset CRTL environ elements (%s)
=item This Perl can't set CRTL environ elements (%s=%s)
=item thread failed to start: %s
-(F) The entry point function of threads->create() failed for some reason.
+(W threads)(S) The entry point function of threads->create() failed for some reason.
=item times not implemented
(F) Your version of the C library apparently doesn't do times(). I
suspect you're not running on Unix.
-=item Too few args to syscall
-
-(F) There has to be at least one argument to syscall() to specify the
-system call to call, silly dilly.
-
-=item Too late for "B<-T>" option
+=item "-T" is on the #! line, it must also be used on the command line
(X) The #! line (or local equivalent) in a Perl script contains the
-B<-T> option, but Perl was not invoked with B<-T> in its command line.
+B<-T> option (or the B<-t> option), but Perl was not invoked with B<-T> in its command line.
This is an error because, by the time Perl discovers a B<-T> in a
script, it's too late to properly taint everything from the environment.
So Perl gives up.
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 B<-T> option is a part of Perl's first
-argument: e.g. change C<perl -n -T> to C<perl -T -n>.
+editing the #! line so that the B<-%c> option is a part of Perl's first
+argument: e.g. change C<perl -n -%c> to C<perl -%c -n>.
If the Perl script is being executed as C<perl scriptname>, then the
-B<-T> option must appear on the command line: C<perl -T scriptname>.
+B<-%c> option must appear on the command line: C<perl -%c scriptname>.
+
+=item To%s: illegal mapping '%s'
+
+(F) You tried to define a customized To-mapping for lc(), lcfirst,
+uc(), or ucfirst() (or their string-inlined versions), but you
+specified an illegal mapping.
+See L<perlunicode/"User-Defined Character Properties">.
+
+=item Too deeply nested ()-groups
+
+(F) Your template contains ()-groups with a ridiculously deep nesting level.
+
+=item Too few args to syscall
+
+(F) There has to be at least one argument to syscall() to specify the
+system call to call, silly dilly.
=item Too late for "-%s" option
(X) The #! line (or local equivalent) in a Perl script contains the
-B<-M> or B<-m> option. This is an error because B<-M> and B<-m> options
-are not intended for use inside scripts. Use the C<use> pragma instead.
+B<-M>, B<-m> or B<-C> option.
+
+In the case of B<-M> and B<-m>, this is an error because those options are
+not intended for use inside scripts. Use the C<use> pragma instead.
+
+The B<-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.
=item Too late to run %s block
=item Too many )'s
+(A) You've accidentally run your script through B<csh> instead of Perl.
+Check the #! line, or manually feed your script into Perl yourself.
+
=item Too many ('s
(A) You've accidentally run your script through B<csh> instead of Perl.
=item Transliteration replacement not terminated
-(F) The lexer couldn't find the final delimiter of a tr/// or tr[][]
-construct.
+(F) The lexer couldn't find the final delimiter of a tr///, tr[][],
+y/// or y[][] construct.
+
+=item '%s' trapped by operation mask
+
+(F) You tried to use an operator from a Safe compartment in which it's
+disallowed. See L<Safe>.
=item truncate not implemented
(F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
-=item Unicode character %s is illegal
+=item Unicode non-character %s is illegal for interchange
-(W utf8) Certain Unicode characters have been designated off-limits by
-the Unicode standard and should not be generated. If you really know
-what you are doing you can turn off this warning by C<no warnings 'utf8';>.
+(W utf8) Certain codepoints, such as U+FFFE and U+FFFF, are defined by the
+Unicode standard to be non-characters. Those are legal codepoints, but are
+reserved for internal use; so, applications shouldn't attempt to exchange
+them. In some cases, this message is also given if you use a codepoint that
+isn't in Unicode--that is it is above the legal maximum of U+10FFFF. These
+aren't legal at all in Unicode, so they are illegal for interchange, but can be
+used internally in a Perl program. If you know what you are doing you can turn
+off this warning by C<no warnings 'utf8';>.
=item Unknown BYTEORDER
(F) There are no byte-swapping functions for a machine with this byte
order.
+=item Unknown open() mode '%s'
+
+(F) The second argument of 3-argument open() is not among the list
+of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
+C<< +> >>, C<<< +>> >>>, C<-|>, C<|->, C<< <& >>, C<< >& >>.
+
+=item Unknown PerlIO layer "%s"
+
+(W layer) An attempt was made to push an unknown layer onto the Perl I/O
+system. (Layers take care of transforming data between external and
+internal representations.) Note that some layers, such as C<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.
+
+=item Unknown process %x sent message to prime_env_iter: %s
+
+(P) An error peculiar to VMS. Perl was reading values for %ENV before
+iterating over it, and someone else stuck a message in the stream of
+data Perl expected. Someone's very confused, or perhaps trying to
+subvert Perl's population of %ENV for nefarious purposes.
+
=item Unknown "re" subpragma '%s' (known ones are: %s)
You tried to use an unknown subpragma of the "re" pragma.
-=item Unknown switch condition (?(%.2s in regex;
-
-marked by <-- HERE in m/%s/
+=item Unknown switch condition (?(%.2s in regex; marked by <-- HERE in m/%s/
(F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition may be lookahead or lookbehind (the condition
The <-- HERE shows in the regular expression about where the problem was
discovered. See L<perlre>.
-=item Unknown open() mode '%s'
+=item Unknown Unicode option letter '%c'
-(F) The second argument of 3-argument open() is not among the list
-of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
-C<< +> >>, C<<< +>> >>>, C<-|>, C<|->, C<< <& >>, C<< >& >>.
+You specified an unknown Unicode option. See L<perlrun> documentation
+of the C<-C> switch for the list of known options.
-=item Unknown process %x sent message to prime_env_iter: %s
+=item Unknown Unicode option value %x
-(P) An error peculiar to VMS. Perl was reading values for %ENV before
-iterating over it, and someone else stuck a message in the stream of
-data Perl expected. Someone's very confused, or perhaps trying to
-subvert Perl's population of %ENV for nefarious purposes.
+You specified an unknown Unicode option. See L<perlrun> documentation
+of the C<-C> switch for the list of known options.
=item Unknown warnings category '%s'
Note that if you want to enable a warnings category registered by a module
(e.g. C<use warnings 'File::Find'>), you must have imported this module
+
+=item Unknown verb pattern '%s' in regex; marked by <-- HERE in m/%s/
+
+(F) You either made a typo or have incorrectly put a C<*> quantifier
+after an open brace in your pattern. Check the pattern and review
+L<perlre> for details on legal verb patterns.
+
first.
=item unmatched [ in regex; marked by <-- HERE in m/%s/
somehow, or insert an underbar into it. You might also declare it as a
subroutine.
-=item Unrecognized character %s
+=item Unrecognized character %s; marked by <-- HERE after %s near column %d
(F) The Perl parser has no idea what to do with the specified character
-in your Perl script (or eval). Perhaps you tried to run a compressed
-script, a binary program, or a directory as a Perl program.
+in your Perl script (or eval) near the specified column. Perhaps you tried
+to run a compressed script, a binary program, or a directory as a Perl program.
-=item /%s/: Unrecognized escape \\%c in character class passed through
+=item Unrecognized escape \\%c in character class passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl inside character classes. The character was
-understood literally.
-
-=item Unrecognized escape \\%c passed through in regex;
-
-marked by <-- HERE in m/%s/
-
-(W regexp) You used a backslash-character combination which is not
-recognized by Perl. This combination appears in an interpolated variable or
-a C<'>-delimited regular expression. The character was understood
-literally. The <-- HERE shows in the regular expression about where the
+understood literally, but this may change in a future version of Perl.
+The <-- HERE shows in the regular expression about where the
escape was discovered.
=item Unrecognized escape \\%c passed through
(W misc) You used a backslash-character combination which is not
-recognized by Perl.
+recognized by Perl. The character was understood literally, but this may
+change in a future version of Perl.
+
+=item Unrecognized escape \\%c passed through in regex; marked by <-- HERE in m/%s/
+
+(W regexp) You used a backslash-character combination which is not
+recognized by Perl. The character was understood literally, but this may
+change in a future version of Perl.
+The <-- HERE shows in the regular expression about where the
+escape was discovered.
=item Unrecognized signal name "%s"
of Perl executables, some of which may support fork, some not. Try
changing the name you call Perl by to C<perl_>, C<perl__>, and so on.
-=item Unsupported script encoding
+=item Unsupported script encoding %s
(F) Your program file begins with a Unicode Byte Order Mark (BOM) which
-declares it to be in a Unicode encoding that Perl cannot yet read.
+declares it to be in a Unicode encoding that Perl cannot read.
=item Unsupported socket function "%s" called
compressed integer format and could not be converted to an integer.
See L<perlfunc/pack>.
+=item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*VERB)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
+=item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
+=item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
+
+(F) You missed a close brace on a \g{..} pattern (group reference) in
+a regular expression. Fix the pattern and retry.
+
=item Unterminated <> operator
(F) The lexer saw a left angle bracket in a place where it was expecting
(W untie) A copy of the object returned from C<tie> (or C<tied>) was
still valid when C<untie> was called.
-=item Useless (?%s) - use /%s modifier in regex;
+=item Usage: POSIX::%s(%s)
-marked by <-- HERE in m/%s/
+(F) You called a POSIX function with incorrect arguments.
+See L<POSIX/FUNCTIONS> for more information.
-(W regexp) You have used an internal modifier such as (?o) that has no
-meaning unless applied to the entire regexp:
+=item Usage: Win32::%s(%s)
- if ($string =~ /(?o)$pattern/) { ... }
+(F) You called a Win32 function with incorrect arguments.
+See L<Win32> for more information.
+
+=item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/
+
+(W regexp) You have used an internal modifier such as (?-o) that has no
+meaning unless removed from the entire regexp:
+
+ if ($string =~ /(?-o)$pattern/o) { ... }
must be written as
- if ($string =~ /$pattern/o) { ... }
+ if ($string =~ /$pattern/) { ... }
The <-- HERE shows in the regular expression about
where the problem was discovered. See L<perlre>.
-=item Useless (?-%s) - don't use /%s modifier in regex;
+=item Useless localization of %s
-marked by <-- HERE in m/%s/
+(W syntax) The localization of lvalues such as C<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.
-(W regexp) You have used an internal modifier such as (?-o) that has no
-meaning unless removed from the entire regexp:
+=item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
- if ($string =~ /(?-o)$pattern/o) { ... }
+(W regexp) You have used an internal modifier such as (?o) that has no
+meaning unless applied to the entire regexp:
+
+ if ($string =~ /(?o)$pattern/) { ... }
must be written as
- if ($string =~ /$pattern/) { ... }
+ if ($string =~ /$pattern/o) { ... }
The <-- HERE shows in the regular expression about
where the problem was discovered. See L<perlre>.
+=item Useless use of /d modifier in transliteration operator
+
+(W misc) You have used the /d modifier where the searchlist has the
+same length as the replacelist. See L<perlop> for more information
+about the /d modifier.
+
=item Useless use of %s in void context
(W void) You did something without a side effect in a context that does
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() ;
+ 1 while sub_with_side_effects();
String constants that would normally evaluate to 0 or 1 are warned
about.
(F) The "use" keyword is recognized and executed at compile time, and
returns no useful value. See L<perlmod>.
+=item Use of assignment to $[ is deprecated
+
+(D deprecated) The C<$[> variable (index of the first element in an array)
+is deprecated. See L<perlvar/"$[">.
+
=item Use of bare << to mean <<"" is deprecated
-(D deprecated) You are now encouraged to use the explicitly quoted form
-if you wish to use an empty line as the terminator of the here-document.
+(D deprecated) You are now encouraged to use the explicitly quoted
+form if you wish to use an empty line as the terminator of the here-document.
+
+=item Use of comma-less variable list is deprecated
+
+(D deprecated) The values you give to a format should be
+separated by commas, not just aligned on a line.
+
+=item Use of chdir('') or chdir(undef) as chdir() deprecated
+
+(D deprecated) chdir() with no arguments is documented to change to
+$ENV{HOME} or $ENV{LOGDIR}. chdir(undef) and chdir('') share this
+behavior, but that has been deprecated. In future versions they
+will simply fail.
+
+Be careful to check that what you pass to chdir() is defined and not
+blank, else you might find yourself in your home directory.
=item Use of /c modifier is meaningless in s///
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
-=item Use of /g modifier is meaningless in split
+=item Use of := for an empty attribute list is deprecated
-(W regexp) You used the /g modifier on the pattern for a C<split>
-operator. Since C<split> always tries to match the pattern
-repeatedly, the C</g> has no effect.
+(D deprecated) The construction C<my $x := 42> currently
+parses correctly in perl, being equivalent to C<my $x : = 42>
+(applying an empty attribute list to C<$x>). This useless
+construct is now deprecated, so C<:=> can be reclaimed as a new
+operator in the future.
+
+=item Use of freed value in iteration
+
+(F) Perhaps you modified the iterated array within the loop?
+This error is typically caused by code like the following:
+
+ @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.
=item Use of *glob{FILEHANDLE} is deprecated
(D deprecated) You are now encouraged to use the shorter *glob{IO} form
to access the filehandle slot within a typeglob.
-=item Use of chdir('') or chdir(undef) as chdir() deprecated
-
-(D deprecated) chdir() with no arguments is documented to change to
-$ENV{HOME} or $ENV{LOGDIR}. chdir(undef) and chdir('') share this
-behavior, but that has been deprecated. In future versions they
-will simply fail.
+=item Use of /g modifier is meaningless in split
-Be careful to check that what you pass to chdir() is defined and not
-blank, else you might find yourself in your home directory.
+(W regexp) You used the /g modifier on the pattern for a C<split>
+operator. Since C<split> always tries to match the pattern
+repeatedly, the C</g> has no effect.
-=item Use of implicit split to @_ is deprecated
+=item Use of "goto" to jump into a construct is deprecated
-(D deprecated) It makes a lot of work for the compiler when you clobber
-a subroutine's argument list, so it's better if you assign the results
-of a split() explicitly to an array (or list).
+(D deprecated) Using C<goto> to jump from an outer scope into an inner
+scope is deprecated and should be avoided.
=item Use of inherited AUTOLOAD for non-method %s() is deprecated
you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
C<use AutoLoader 'AUTOLOAD';>.
-=item Use of -l on filehandle %s
-
-(W io) A filehandle represents an opened file, and when you opened the file
-it already went past any symlink you are presumably trying to look for.
-The operation returned C<undef>. Use a filename instead.
-
-=item Use of "package" with no arguments is deprecated
+=item Use of octal value above 377 is deprecated
-(D deprecated) You used the C<package> keyword without specifying a package
-name. So no namespace is current at all. Using this can cause many
-otherwise reasonable constructs to fail in baffling ways. C<use strict;>
-instead.
+(D deprecated, W regexp) There is a constant in the regular expression whose
+value is interpeted by Perl as octal and larger than 377 (255 decimal, 0xFF
+hex). Perl may take this to mean different things depending on the rest of
+the regular expression. If you meant such an octal value, convert it to
+hexadecimal and use C<\xHH> or C<\x{HH}> instead. If you meant to have
+part of it mean a backreference, use C<\g> for that. See L<perlre>.
=item Use of %s in printf format not supported
(F) You attempted to use a feature of printf that is accessible from
only C. This usually means there's a better way to do it in Perl.
-=item Use of $* is deprecated
-
-(D deprecated) This variable magically turned on multi-line pattern
-matching, both for you and for any luckless subroutine that you happen
-to call. You should use the new C<//m> and C<//s> modifiers now to do
-that without the dangerous action-at-a-distance effects of C<$*>.
-
=item Use of %s is deprecated
(D deprecated) The construct indicated is no longer recommended for use,
generally because there's a better way to do it, and also because the
old way has bad side effects.
-=item Use of $# is deprecated
+=item Use of -l on filehandle %s
+
+(W io) A filehandle represents an opened file, and when you opened the file
+it already went past any symlink you are presumably trying to look for.
+The operation returned C<undef>. Use a filename instead.
+
+=item Use of "package" with no arguments is deprecated
-(D deprecated) This was an ill-advised attempt to emulate a poorly
-defined B<awk> feature. Use an explicit printf() or sprintf() instead.
+(D deprecated) You used the C<package> keyword without specifying a package
+name. So no namespace is current at all. Using this can cause many
+otherwise reasonable constructs to fail in baffling ways. C<use strict;>
+instead.
=item Use of reference "%s" as array index
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
either, because you can overload the numification and stringification
-operators and then you assumedly know what you are doing.
+operators and then you assumably know what you are doing.
=item Use of reserved word "%s" is deprecated
defined. It was interpreted as a "" or a 0, but maybe it was a mistake.
To suppress this warning assign a defined value to your variables.
-To help you figure out what was undefined, perl 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, C<"that $foo"> is
-usually optimized into C<"that " . $foo>, and the warning will refer to
-the C<concatenation (.)> operator, even though there is no C<.> in your
-program.
+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, C<"that $foo"> is usually optimized into C<"that "
+. $foo>, and the warning will refer to the C<concatenation (.)> operator,
+even though there is no C<.> in your program.
=item Using a hash as a reference is deprecated
allow this syntax, but shouldn't have. It is now deprecated, and will be
removed in a future version.
+=item Using just the first character returned by \N{} in character class
+
+(W) A charnames handler may return a sequence of more than one character.
+Currently all but the first one are discarded when used in a regular
+expression pattern bracketed character class.
+
+=item Using just the first characters returned by \N{}
+
+(W) A charnames handler may return a sequence of characters. There is a finite
+limit as to the number of characters that can be used, which this sequence
+exceeded. In the message, the characters in the sequence are separated by
+dots, and each is shown by its ordinal in hex. Anything to the left of the
+C<HERE> was retained; anything to the right was discarded.
+
=item UTF-16 surrogate %s
-(W utf8) You tried to generate half of an UTF-16 surrogate by
+(W utf8) You tried to generate half of a UTF-16 surrogate by
requesting a Unicode character between the code points 0xD800 and
0xDFFF (inclusive). That range is reserved exclusively for the use of
UTF-16 encoding (by having two 16-bit UCS-2 characters); but Perl
encodes its characters in UTF-8, so what you got is a very illegal
-character. If you really know what you are doing you can turn off
+character. If you really really know what you are doing you can turn off
this warning by C<no warnings 'utf8';>.
=item Value of %s can be "0"; test with defined()
longer than 1024 characters. The return value has been truncated to
1024 characters.
+=item Variable "%s" is not available
+
+(W closure) During compilation, an inner named subroutine or eval is
+attempting to capture an outer lexical that is not currently available.
+This can happen for one of two reasons. First, the outer lexical may be
+declared in an outer anonymous subroutine that has not yet been created.
+(Remember that named subs are created at compile time, while anonymous
+subs are created at run-time.) For example,
+
+ 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.
+
=item Variable "%s" is not imported%s
-(F) While "use strict" in effect, you referred to a global variable that
-you apparently thought was imported from another module, because
+(W misc) With "use strict" in effect, you referred to a global variable
+that you apparently thought was imported from another module, because
something else of the same name (usually a subroutine) is exported by
that module. It usually means you put the wrong funny character on the
front of your variable.
+=item Variable length lookbehind not implemented in m/%s/
+
+(F) Lookbehind is allowed only for subexpressions whose length is fixed and
+known at compile time. See L<perlre>.
+
=item "%s" variable %s masks earlier declaration in same %s
-(W misc) A "my" or "our" variable has been redeclared in the current
+(W misc) A "my", "our" or "state" variable has been redeclared in the current
scope or statement, effectively eliminating all access to the previous
instance. This is almost always a typographical error. Note that the
earlier variable will still exist until the end of the scope or until
all closure referents to it are destroyed.
-=item Variable "%s" may be unavailable
-
-(W closure) An inner (nested) I<anonymous> subroutine is inside a
-I<named> subroutine, and outside that is another subroutine; and the
-anonymous (innermost) subroutine is referencing a lexical variable
-defined in the outermost subroutine. For example:
-
- sub outermost { my $a; sub middle { sub { $a } } }
-
-If the anonymous subroutine is called or referenced (directly or
-indirectly) from the outermost subroutine, it will share the variable as
-you would expect. But if the anonymous subroutine is called or
-referenced when the outermost subroutine is not active, it will see the
-value of the shared variable as it was before and during the *first*
-call to the outermost subroutine, which is probably not what you want.
-
-In these circumstances, it is usually best to make the middle subroutine
-anonymous, using the C<sub {}> syntax. Perl has specific support for
-shared variables in nested anonymous subroutines; a named subroutine in
-between interferes with this feature.
-
=item Variable syntax
(A) You've accidentally run your script through B<csh> instead
=item Variable "%s" will not stay shared
(W closure) An inner (nested) I<named> subroutine is referencing a
-lexical variable defined in an outer subroutine.
+lexical variable defined in an outer named subroutine.
-When the inner subroutine is called, it will probably see the value of
+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.
-Furthermore, if the outer subroutine is anonymous and references a
-lexical variable outside itself, then the outer and inner subroutines
-will I<never> share the given variable.
-
This problem can usually be solved by making the inner subroutine
anonymous, using the C<sub {}> syntax. When inner anonymous subs that
-reference variables in outer subroutines are called or referenced, they
+reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.
-=item Variable length lookbehind not implemented in regex;
+=item Verb pattern '%s' has a mandatory argument in regex; marked by <-- HERE in m/%s/
-marked by <-- HERE in m/%s/
+(F) You used a verb pattern that requires an argument. Supply an argument
+or check that you are using the right verb.
-(F) Lookbehind is allowed only for subexpressions whose length is fixed and
-known at compile time. The <-- HERE shows in the regular expression about
-where the problem was discovered. See L<perlre>.
+=item Verb pattern '%s' may not have an argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a verb pattern that is not allowed an argument. Remove the
+argument or check that you are using the right verb.
=item Version number must be a constant number
its equivalent C<BEGIN> block found an internal inconsistency with
the version number.
-=item v-string in use/require is non-portable
+=item Version string '%s' contains invalid data; ignoring: '%s'
-(W portable) The use of v-strings is non-portable to older, pre-5.6, Perls.
-If you want your scripts to be backward portable, use the floating
-point version number: for example, instead of C<use 5.6.1> say
-C<use 5.006_001>. This of course won't help: the older Perls
-won't suddenly start understanding newer features, but at least
-they will show a sensible error message indicating the required
-minimum version.
+(W misc) The version string contains invalid characters at the end, which
+are being ignored.
=item Warning: something's wrong
(W) You passed warn() an empty string (the equivalent of C<warn "">) or
-you called it with no args and C<$_> was empty.
+you called it with no args and C<$@> was empty.
=item Warning: unable to close filehandle %s properly
=item Wide character in %s
-(W utf8) Perl met a wide character (>255) when it wasn't expecting
-one. This warning is by default on for I/O (like print) but can be
-turned off by C<no warnings 'utf8';>. You are supposed to explicitly
-mark the filehandle with an encoding, see L<open> and L<perlfunc/binmode>.
+(S utf8) Perl met a wide character (>255) when it wasn't expecting
+one. This warning is by default on for I/O (like print). The easiest
+way to quiet this warning is simply to add the C<:utf8> layer to the
+output, e.g. C<binmode STDOUT, ':utf8'>. Another way to turn off the
+warning is to add C<no warnings 'utf8';> but that is often closer to
+cheating. In general, you are supposed to explicitly mark the
+filehandle with an encoding, see L<open> and L<perlfunc/binmode>.
+
+=item Within []-length '%c' not allowed
+
+(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
+C<TEMPLATE> always matches the same amount of packed bytes that can be
+determined from the template alone. This is not possible if it contains an
+of the codes @, /, U, u, w or a *-length. Redesign the template.
=item write() on closed filehandle %s
(W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
-=item X outside of string
+=item %s "\x%s" does not map to Unicode
-(F) You had a pack template that specified a relative position before
-the beginning of the string being unpacked. See L<perlfunc/pack>.
+When reading in different encodings Perl tries to map everything
+into Unicode characters. The bytes you read in are not legal in
+this encoding, for example
-=item x outside of string
+ utf8 "\xE4" does not map to Unicode
-(F) You had a pack template that specified a relative position after
-the end of the string being unpacked. See L<perlfunc/pack>.
+if you try to read in the a-diaereses Latin-1 as UTF-8.
-=item Xsub "%s" called in sort
+=item 'X' outside of string
-(F) The use of an external subroutine as a sort comparison is not yet
-supported.
+(F) You had a (un)pack template that specified a relative position before
+the beginning of the string being (un)packed. See L<perlfunc/pack>.
-=item Xsub called in sort
+=item 'x' outside of string in unpack
-(F) The use of an external subroutine as a sort comparison is not yet
-supported.
+(F) You had a pack template that specified a relative position after
+the end of the string being unpacked. See L<perlfunc/pack>.
=item YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!
assignment is executed, which is probably not what you want. (If it IS
what you want, put an & in front.)
+=item Your random numbers are not that random
+
+(F) When trying to initialise the random seed for hashes, Perl could
+not get any randomness out of your system. This usually indicates
+Something Very Wrong.
+
=back
+=head1 SEE ALSO
+
+L<warnings>, L<perllexwarn>.
+
=cut
projects / p5sagit/p5-mst-13.2.git / blobdiff