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
to check the return value of your socket() call? See
L<perlfunc/accept>.
-=item Allocation too large: %lx
+=item Allocation too large: %x
(X) You can't allocate more than 64K on an MS-DOS machine.
to be an object method (see L<perlsub/"Subroutine Attributes"> or
L<attributes>).
+=item Ambiguous overloaded argument to %s resolved as %s
+
+(W ambiguous) You called C<keys>, C<values> or C<each> on an object that had
+overloading of C<%{}> or C<@{}> or both. In such a case, the object is
+dereferenced according to its overloading, not its underlying reference type.
+The warning is issued when C<%{}> overloading exists on a blessed arrayref,
+when C<@{}> overloading exists on a blessed hashref, or when both overloadings
+are defined (in which case C<%{}> is used). You can force the interpretation
+of the object by explicitly dereferencing it as an array or hash instead of
+passing the object itself to C<keys>, C<values> or C<each>.
+
=item Ambiguous range in transliteration operator
(F) You wrote something like C<tr/a-z-0//> which doesn't mean anything at
you thought. Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, parenthesis pair or declaration.
+=item Ambiguous use of %c resolved as operator %c
+
+(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
+bitwise and, and multiplication) I<and> initial special characters
+(denoting hashes, subroutines and typeglobs), and you said something
+like C<*foo * foo> that might be interpreted as either of them. We
+assumed you meant the infix operator, but please try to make it more
+clear -- in the example given, you might write C<*foo * foo()> if you
+really meant to multiply a glob by the result of calling a function.
+
+=item Ambiguous use of %c{%s} resolved to %c%s
+
+(W ambiguous) You wrote something like C<@{foo}>, which might be
+asking for the variable C<@foo>, or it might be calling a function
+named foo, and dereferencing it as an array reference. If you wanted
+the varable, you can just write C<@foo>. If you wanted to call the
+function, write C<@{foo()}> ... or you could just not have a variable
+and a function with the same name, and save yourself a lot of trouble.
+
+=item Ambiguous use of %c{%s%s} resolved to %c%s%s
+
+(W ambiguous) You wrote something like C<${foo[2]}> (where foo
+represents the name of a Perl keyword), which might be looking for
+element number 2 of the array named C<@foo>, in which case please write
+C<$foo[2]>, or you might have meant to pass an anonymous arrayref to
+the function named foo, and then do a scalar deref on the value it
+returns. If you meant that, write C<${foo([2])}>.
+
+In regular expressions, the C<${foo[2]}> syntax is sometimes necessary
+to disambiguate between array subscripts and character classes.
+C</$length[2345]/>, for instance, will be interpreted as C<$length>
+followed by the character class C<[2345]>. If an array subscript is what
+you want, you can avoid the warning by changing C</${length[2345]}/>
+to the unsightly C</${\$length[2345]}/>, by renaming your array to
+something that does not coincide with a built-in keyword, or by
+simply turning off warnings with C<no warnings 'ambiguous';>.
+
+=item Ambiguous use of -%s resolved as -&%s()
+
+(W ambiguous) You wrote something like C<-foo>, which might be the
+string C<"-foo">, or a call to the function C<foo>, negated. If you meant
+the string, just write C<"-foo">. If you meant the function call,
+write C<-foo()>.
+
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
(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
(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
+Usually it's a good idea first to collect the return values of the
+created threads by joining them, and only then to exit from the main
thread. See L<threads>.
=item Attempt to access disallowed key '%s' in 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
+=item Attempt to free non-arena SV: 0x%x
(P internal) All SV objects are supposed to be allocated from arenas
that will be garbage collected on exit. An SV was discovered to be
=item Attempt to free nonexistent shared string
-(P internal) Perl maintains a reference counted internal table of
+(P internal) Perl maintains a reference-counted internal table of
strings to optimize the storage and access of hash keys and other
strings. This indicates someone tried to decrement the reference count
of a string that can no longer be found in the table.
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
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 pragma 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 a future
+release of Perl 5.
+
+=item Attribute "unique" is deprecated
+
+(D deprecated) You have used the attributes pragma 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 a future release
+of Perl 5.
+
+=item Bad arg length for %s, is %u, 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
never been malloc()ed in the first place. Mandatory, but can be disabled
-by setting environment variable C<PERL_BADFREE> to 1.
+by setting
the environment variable C<PERL_BADFREE> to 1.
=item Bad symbol for array
=item binmode() on closed filehandle %s
(W unopened) You tried binmode() on a filehandle that was never opened.
-Check you control flow and number of arguments.
+Check your control flow and number of arguments.
+
+=item "\b{" is deprecated; use "\b\{" instead
+
+=item "\B{" is deprecated; use "\B\{" instead
+
+(W deprecated, regexp) Use of an unescaped "{" immediately following a
+C<\b> or C<\B> is now deprecated so as to reserve its use for Perl
+itself in a future release.
=item Bit vector size > 32 non-portable
=item Bizarre copy of %s in %s
(P) Perl detected an attempt to copy an internal value that is not
-copyable.
+copiable.
=item Buffer overflow in prime_env_iter: %s
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 to.
+
+=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
(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
-functioning as a class, but that package doesn't have ANYTHING defined
-in it, let alone methods. See L<perlobj>.
-
=item Can't call method "%s" on an undefined value
(F) You used the syntax of a method call, but the slot filled by the
(P) For some reason you can't check the filesystem of the script for
nosuid.
-=item Can't coerce array into hash
-
-(F) You used an array where a hash was expected, but the array has no
-information on how to map from keys to array indices. You can do that
-only with arrays that have a hash reference at index 0.
-
-=item Can't coerce %s to integer in %s
+=item Can't coerce %s to %s in %s
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are. So you can't
but then $foo no longer contains a glob.
-=item Can't coerce %s to number in %s
-
-(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 coerce %s to string in %s
-
-(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>
(P) An error peculiar to VMS. The process is suffering from exhausted
quotas or other plumbing problems.
-=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
-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
=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
=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.
-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>).
+(F) You may have tried to use C<\p> which means a Unicode
+property (for 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, or
+until 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
the stat buffer, so that ACLs and other protections can be taken into
account. Unfortunately, Perl assumes that the stat buffer contains all
the necessary information, and passes it, instead of the filespec, to
-the access checking routine. It will try to retrieve the filespec using
+the access-checking routine. It will try to retrieve the filespec using
the device name and FID present in the stat buffer, but this works only
if you haven't made a subsequent call to the CRTL stat() routine,
because the device name is overwritten with each call. If this warning
-appears, the name lookup failed, and the access checking routine gave up
-and returned FALSE, just to be conservative. (Note: The access checking
+appears, the name lookup failed, and the access-checking routine gave up
+and returned FALSE, just to be conservative. (Note: The access-checking
routine knows about the Perl C<stat> operator and file tests, so you
shouldn't ever see this warning in response to a Perl command; it arises
only if some internal code takes stat buffers lightly.)
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
=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.
=item Can't modify non-lvalue subroutine call
(F) Subroutines meant to be used in lvalue context should be declared as
-such
, see L<perlsub/"Lvalue subroutines">.
+such
. See L<perlsub/"Lvalue subroutines">.
=item Can't msgrcv to read-only var
=item Can't open a reference
(W io) You tried to open a scalar reference for reading or writing,
-using the 3-arg open() syntax :
+using the 3-arg open() syntax:
open FH, '>', $ref;
(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.
+the method name is C<???>, this is an internal error.
=item Can't return %s from lvalue subroutine
(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
however, redefine it while it's running, and you can even undef the
redefined subroutine while the old routine is running. Go figure.
-=item Can't unshift
-
-(F) You tried to unshift an "unreal" array that can't be unshifted, such
-as the main Perl stack.
-
=item Can't upgrade %s (%d) to %d
(P) The internal sv_upgrade routine adds "members" to an SV, making it
(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
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 following "\c" must be ASCII
+
+(F|W deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
+It is planned to make this fatal in all instances in Perl 5.16. In the
+cases where it isn't fatal, the character this evaluates to is
+derived by exclusive or'ing the code point of this character with 0x40.
+
+Note that non-alphabetic ASCII characters are discouraged here as well.
+
=item Character in 'C' format wrapped in pack
(W pack) You said
unpack("H", "\x{2a1}")
-where the format expects to process a byte (a character with a value
+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:
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
+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")
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
+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 "\c{" is deprecated and is more clearly written as ";"
+
+(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
+to specify non-printable characters. You used it with a "{" which
+evaluates to ";", which is printable. It is planned to remove the
+ability to specify a semi-colon this way in Perl 5.16. Just use a
+semi-colon or a backslash-semi-colon without the "\c".
+
+=item "\c%c" is more clearly written simply as "%s"
+
+(W syntax) The C<\cI<X>> construct is intended to be a way to specify
+non-printable characters. You used it for a printable one, which is better
+written as simply itself, perhaps preceded by a backslash for non-word
+characters.
+
=item close() on unopened filehandle %s
(W unopened) You tried to close a filehandle that was never opened.
(W io) The dirhandle you tried to close is either closed or not really
a dirhandle. Check your control flow.
+=item Closure prototype called
+
+(F) If a closure has attributes, the subroutine passed to an attribute
+handler is the prototype that is cloned when a new closure is created.
+This subroutine cannot be called.
+
=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 Code point 0x%X is not Unicode, may not be portable
+
+=item Code point 0x%X is not Unicode, no properties match it; all inverse properties do
+
+(W utf8) You had a code point above the Unicode maximum of U+10FFFF.
+
+Perl allows strings to contain a superset of Unicode code
+points, up to the limit of what is storable in an unsigned integer on
+your system, but these may not be accepted by other languages/systems.
+At one time, it was legal in some standards to have code points up to
+0x7FFF_FFFF, but not higher. Code points above 0xFFFF_FFFF require
+larger than a 32 bit word.
+
+None of the Unicode or Perl-defined properties will match a non-Unicode
+code point. For example,
+
+ chr(0x7FF_FFFF) =~ /\p{Any}/
+
+will not match, because the code point is not in Unicode. But
+
+ chr(0x7FF_FFFF) =~ /\P{Any}/
+
+will match.
+
=item %s: Command not found
(A) You've accidentally run your script through B<csh> instead of Perl.
(W threads) Within a thread-enabled program, you tried to call
cond_broadcast() on a variable which wasn't locked. The cond_broadcast()
-function is used to wake up another thread that is waiting in a
+function is used to wake up another thread that is waiting in a
cond_wait(). To ensure that the signal isn't sent before the other thread
-has a chance to enter the wait, it is usual for the signaling thread to
-first wait for a lock on variable. This lock attempt will only succeed
+has a chance to enter the wait, it is usual for the signaling thread
+first to wait for a lock on variable. This lock attempt will only succeed
after the other thread has entered cond_wait() and thus relinquished the
lock.
(W threads) Within a thread-enabled program, you tried to call
cond_signal() on a variable which wasn't locked. The cond_signal()
-function is used to wake up another thread that is waiting in a
+function is used to wake up another thread that is waiting in a
cond_wait(). To ensure that the signal isn't sent before the other thread
-has a chance to enter the wait, it is usual for the signaling thread to
-first wait for a lock on variable. This lock attempt will only succeed
+has a chance to enter the wait, it is usual for the signaling thread
+first to wait for a lock on variable. This lock attempt will only succeed
after the other thread has entered cond_wait() and thus relinquished the
lock.
=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?
+(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>.
(P) The regular expression engine got passed a regexp program without a
valid magic number.
-=item Corrupt malloc ptr 0x%lx at 0x%lx
+=item Corrupt malloc ptr 0x%x at 0x%x
(P) The malloc package that comes with Perl had an internal failure.
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 in \N{...}; marked by <-- HERE in \N{%s<-- HERE %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>.
=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"?)
=item Died
(F) You passed die() an empty string (the equivalent of C<die "">) or
-you called it with no args and both C<$@> and C<$_> were empty.
+you called it with no args and C<$@> was empty.
=item Document contains no data
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
-pattern contains interpolated values. Since that is a security risk, it
-is not allowed. If you insist, you may still do this by explicitly
-building the pattern from an interpolated string at run time and using
-that in an eval(). See L<perlre/(?{ code })>.
+pattern contains interpolated values. Since that is a security risk,
+it is not allowed. If you insist, you may still do this by using the
+C<re 'eval'> pragma or by explicitly building the pattern from an
+interpolated string at run time and using that in an eval(). See
+L<perlre/(?{ code })>.
=item %s: Eval-group not allowed, use re 'eval'
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
=item exec? I'm not *that* kind of operating system
-(F) The C<exec> function is not implemented in MacPerl. See L<perlport>.
+(F) The C<exec> function is not implemented on some systems, e.g., Symbian
+OS. 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/
"-", "\-". The <-- HERE shows in the regular expression about where the
problem was discovered. See L<perlre>.
-=item Fatal VMS error at %s, line %d
+=item Fatal VMS error (status=%d) at %s, line %d
(P) An error peculiar to VMS. Something untoward happened in a VMS
system service or RTL routine; Perl's exit status should provide more
(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.
+C<u63> as the format.
=item Filehandle %s opened only for input
(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?).
+with "+<" or "+>" or "+>>" instead of with ">". 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
=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(%f) 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(%f) 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
=item ()-group starts with a count
-(F) A ()-group started with a count. A count is
-supposed to follow something: a template character or a ()-group.
- See L<perlfunc/pack>.
+(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.
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
+=item Having no space between pattern and following word is deprecated
+
+(D syntax)
+
+You had a word that isn't a regex modifier immediately following a pattern
+without an intervening space. For example, the two constructs:
+
+ $a =~ m/$foo/sand $bar
+ $a =~ m/$foo/s and $bar
+
+both currently mean the same thing, but it is planned to disallow the first
+form in Perl 5.16. And,
+
+ $a =~ m/$foo/and $bar
+
+will be disallowed too.
+
=item Hexadecimal number > 0xffffffff non-portable
(W portable) The hexadecimal number you specified is larger than 2**32-1
names (like C<$A::B>). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
-=item Ignoring %s in character class in regex; marked by <-- HERE in m/%s/
+=item Ignoring zero length \N{} in character class
-(W) Named unicode character escapes (\N{...}) may return multi-char
-or zero length sequences. When such an escape is used in a character class
-its behaviour is not well defined. Check that the correct escape has
+(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
binary number. Interpretation of the binary number stopped before the
offending digit.
-=item Illegal character %s (carriage return)
+=item Illegal character \%o (carriage return)
(F) Perl normally treats carriage returns in the program text as it
would any other whitespace, which means you should never see this error
=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
(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<-[CDIMUdmtwA]>.
+following switches: B<-[CDIMUdmtw]>.
=item Ill-formed CRTL environ value "%s"
didn't see the expected delimiter between key and value, so the line was
ignored.
-=item Impossible to activate assertion call
-
-(W assertions) You're calling an assertion function in a block that is
-not under the control of the C<assertions> pragma.
-
=item (in cleanup) %s
(W misc) This prefix usually indicates that a DESTROY() method raised
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.
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 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 %s number
(W overflow) The hexadecimal, octal or binary number you have specified
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
=item Invalid %s attribute: %s
-The indicated attribute for a subroutine or variable was not recognized
+(F) The indicated attribute for a subroutine or variable was not recognized
by Perl or by a user-supplied handler. See L<attributes>.
=item Invalid %s attributes: %s
-The indicated attributes for a subroutine or variable were not
+(F) The indicated attributes for a subroutine or variable were not
recognized by Perl or by a user-supplied handler. See L<attributes>.
=item Invalid conversion in %s: "%s"
(W printf) Perl does not understand the given format conversion. See
L<perlfunc/sprintf>.
+=item Invalid escape in the specified encoding in regex; marked by <-- HERE in m/%s/
+
+(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 supported are C<dfs> and C<c3>, unless you have loaded
+a module that is a MRO plugin. See L<mro> and L<perlmroapi>.
+
=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
(F) The range specified in a character class had a minimum character
=item Invalid separator character %s in PerlIO layer specification %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.
+(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 strict version format (%s)
+
+(F) A version number did not meet the "strict" criteria for versions.
+A "strict" version number is a positive decimal number (integer or
+decimal-fraction) without exponentiation or else a dotted-decimal
+v-string with a leading 'v' character and at least three components.
+The parenthesized text indicates which criteria were not met.
+See the L<version> module for more details on allowed version formats.
+
=item Invalid type '%s' in %s
(F) The given character is not a valid pack or unpack type.
(W) The given character is not a valid pack or unpack type but used to be
silently ignored.
-=item Invalid version format (multiple underscores)
+=item Invalid version format (%s)
-(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.
+(F) A version number did not meet the "lax" criteria for versions.
+A "lax" version number is a positive decimal number (integer or
+decimal-fraction) without exponentiation or else a dotted-decimal
+v-string. If the v-string has less than three components, it must have a
+leading 'v' character. Otherwise, the leading 'v' is optional. Both
+decimal and dotted-decimal versions may have a trailing "alpha"
+component separated by an underscore character after a fractional or
+dotted-decimal component. The parenthesized text indicates which
+criteria were not met. See the L<version> module for more details on
+allowed version formats.
-=item Invalid version format (underscores before decimal)
+=item Invalid version object
-(F) Versions may not contain decimals after the optional underscore.
-See L<version> for the allowed version formats.
+(F) The internal structure of the version object was invalid. Perhaps
+the internals were modified directly in some way or an arbitrary reference
+was blessed into the "version" class.
=item ioctl is not implemented
(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
+=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
=item $* is no longer supported
-(D deprecated) The special variable C<$*>, deprecated in older perls, has
-been removed as of 5.9.0 and is no longer supported. You should use the
-C<//m> and C<//s> regexp modifiers instead.
+(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) The special variable C<$#>, deprecated in older perls, has
+(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.
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 Lookbehind longer than %d not implemented in regex; marked by <-- HERE in m/%s/
+=item localtime(%f) 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(%f) 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. The <-- HERE
-shows in the regular expression about where the problem was discovered.
+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
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 an lvalue attribute is not
+possible. To make the subroutine an lvalue subroutine add the
+lvalue attribute to the definition, or put the declaration before
+the definition.
+
=item Lvalue subs returning %s not implemented yet
(F) Due to limitations in the current implementation, array and hash
=item Malformed UTF-8 character (%s)
-(S utf8) (F) 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 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.
-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().
+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 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
(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 Maximal count of pending signals (%u) 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
(W syntax) An underscore (underbar) in a numeric constant did not
separate two digits.
+=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 %sbrace%s on \N{}
+=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 braces on \o{}
+
+(F) A C<\o> must be followed immediately by a C<{> in double-quotish context.
=item Missing comma after first argument to %s function
=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
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
(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.
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
(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
(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) 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
=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
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
+=item Non-octal character '%c'. Resolved as "%s"
+
+(W digit) In parsing an octal numeric constant, a character was unexpectedly
+encountered that isn't octal. The resulting value is as indicated.
+
=item Non-string passed as bitmask
(W misc) A number has been passed as a bitmask argument to select().
the meantime, try using scientific notation (e.g. "1e6" instead of
"1_000_000").
+=item Number with no digits
+
+(F) Perl was looking for a number but found nothing that looked like a number.
+This happens, for example with C<\o{}>, with no number between the braces.
+
=item Octal number in vector unsupported
(F) Numbers with a leading C<0> are not currently allowed in vectors.
=item Offset outside string
-(F, W layer) You tried to do a read/write/send/recv/seek operation
+(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 exception to this is that C<sysread()>ing past the
-buffer will extend the buffer and zero pad the new area.
+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
(S internal) An internal warning that the grammar is screwed up.
+=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
of other handlers, there is no default handler for any operation, unless
C<fallback> overloading key is specified to be true. See L<overload>.
+=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
+
+(W) You performed an operation requiring Unicode semantics on a Unicode
+surrogate. Unicode frowns upon the use of surrogates for anything but
+storing strings in UTF-16, but semantics are (reluctantly) defined for
+the surrogates, and they are to do nothing for this operation. Because
+the use of surrogates can be dangerous, Perl warns.
+
+If the operation shown is "ToFold", it means that case-insensitive
+matching in a regular expression was done on the code point.
+
+If you know what you are doing you can turn off this warning by
+C<no warnings 'utf8';>.
+
+=item Operation "%s" returns its argument for non-Unicode code point 0x%X
+
+(W) You performed an operation requiring Unicode semantics on a code
+point that is not in Unicode, so what it should do is not defined. Perl
+has chosen to have it do nothing, and warn you.
+
+If the operation shown is "ToFold", it means that case-insensitive
+matching in a regular expression was done on the code point.
+
+If you know what you are doing you can turn off this warning by
+C<no warnings 'utf8';>.
+
=item Operator or semicolon missing before %s
(S ambiguous) You used a variable or subroutine call where the parser
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 \p{} uses Unicode rules, not locale rules
+
+(W) You compiled a regular expression that contained a Unicode property
+match (C<\p> or C<\P>), but the regular expression is also being told to
+use the run-time locale, not Unicode. Instead, use a POSIX character
+class, which should know about the locale's rules.
+(See L<perlrecharclass/POSIX Character Classes>.)
+
+Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of
+Unicode, some properties will give results that are not valid for that
+subset.
+
+Here are a couple of examples to help you see what's going on. If the
+locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK
+CAPITAL LETTER CHI". But in Unicode that code point means the
+"MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode
+meaning. That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]>
+should. Only in the Latin1 locale are all the characters in the same
+positions as they are in Unicode. But, even here, some properties give
+incorrect results. An example is C<\p{Changes_When_Uppercased}> which
+is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper
+case of that character is not in Latin1, in that locale it doesn't
+change when upper cased.
+
=item pack/unpack repeat count overflow
(F) You can't specify a repeat count so large that it overflows your
(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: gp_free failed to free glob pointer
+
+(P) The internal routine used to clear a typeglob's entries tried
+repeatedly, but each time something re-created entries in the glob. Most
+likely the glob contains an object with a reference back to the glob and a
+destructor that adds a new object to the glob.
+
=item panic: hfreeentries failed to free hash
-(P) The internal routine used to clear a hashes entries tried repeatedly,
+(P) The internal routine used to clear a hash's 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.
(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) 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 Parsing code internal error (%s)
+
+(F) Parsing code supplied by an extension violated the parser's API in
+a detectable way.
+
+=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
you run Perl. How to really fix the problem can be found in
L<perllocale> section B<LOCALE PROBLEMS>.
-=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
(F) The unpack format P must have an explicit size, not "*".
-=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 POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
(F) The class in the character class [: :] syntax is unknown. The <-- HERE
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
-=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);
- }
-
-You should use the new declaration syntax instead.
-
- sub doit : locked
- {
- ...
+If this is what you intended then you can silence the warning by using
+C<m/${\}/> (for example: C<m/foo${\}s+bar/>).
-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
=item readdir() attempted on invalid dirhandle %s
-(W io) The dirhandle you're reading from is either closed or not really
+(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 unopened) You tried to read from a filehandle that was never opened.
-=item Reallocation too large: %lx
+=item Reallocation too large: %x
(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 invalid group 0
+
+(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
-wanted to have the character with value 7 inserted into the regular expression,
-prepend a zero to make the number at least two digits: C<\07>
+wanted to have the character with ordinal 7 inserted into the regular expression,
+prepend zeroes to make it three digits long: C<\007>
+
+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.
numeric field that will never go blank so that the repetition never
terminates. You might use ^# instead. See L<perlform>.
+=item Replacement list is longer than search list
+
+(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
(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
really a dirhandle. Check your control flow.
-=item Runaway format
-
-(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>.
-
=item Scalars leaked: %d
(P) Something went wrong in Perl's internal bookkeeping of scalars:
not magically convert between scalars and lists for you. See
L<perlref>.
-=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{}
(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>.
+discovered. This happens when using the C<(?^...)> construct to tell
+Perl to use the default regular expression modifiers, and you
+redundantly specify a default modifier; or having a modifier that can't
+be turned off (such as C<"p"> or C<"l">) after a minus; or specifying
+more than one of the C<"d">, C<"l">, or C<"u"> modifiers. For other
+causes, see L<perlre>.
+
+=item Sequence \%s... not terminated in regex; 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/
the regular expression about where the problem was discovered. See
L<perlre>.
-=item 500 Server error
+=item "500 Server error"
See Server error.
=item Server error
-This is the error message generally seen in a browser window when trying
+(A) This is the error message generally seen in a browser window when trying
to run a CGI program (including SSI) over the web. The actual error text
varies widely from server to server. The most frequently-seen variants
are "500 Server error", "Method (something) not permitted", "Document
(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
iterate more times than there are characters of input, which is what
happened.) See L<perlfunc/split>.
-=item State variable %s will be reinitialized
-
-(W misc) You're declaring a C<state> variable inside a list. The list
-assignment will be treated by perl as a regular assignment, which means
-that the C<state> variable will be reinitialized each time the statement
-is run. The solution to have it initialized only once is to write the
-assignment on its own line, as in:
-
- state $var = 42;
-
=item Statement unlikely to be reached
(W exec) You did an exec() with some statement after it other than a
(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
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
(P) Perl tried to force the upgrade an SV to a type which was actually
=item The %s function is unimplemented
-The function indicated isn't implemented on this architecture, according
+(F) The function indicated isn't implemented on this architecture, according
to the probings of Configure.
=item The stat preceding %s wasn't an lstat
=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'
=item Too deeply nested ()-groups
-(F) Your template contains ()-groups with a ridiculously deep nesting level.
+(F) Your template contains ()-groups with a ridiculously deep nesting level.
=item Too few args to syscall
=item Too late for "-%s" option
(X) The #! line (or local equivalent) in a Perl script contains the
-B<-M>, B<-m> or B<-C> option. This is an error because those 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
%NAME or C<%{EXPR}>. No implicit dereferencing is allowed--use the
{EXPR} forms as an explicit dereference. See L<perlref>.
+=item Type of argument to %s must be hashref or arrayref
+
+(F) You called C<keys>, C<values> or C<each> with an argument that was
+expected to be a reference to a hash or a reference to an array.
+
=item umask not implemented
(F) Your machine doesn't implement the umask function and you tried to
(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 U+%X is illegal for open 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. If you know what you are doing you can turn
+off this warning by C<no warnings 'utf8';>.
=item Unknown BYTEORDER
=item Unknown "re" subpragma '%s' (known ones are: %s)
-You tried to use an unknown subpragma of the "re" pragma.
+(W) 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 (?(%s 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
=item Unknown Unicode option letter '%c'
-You specified an unknown Unicode option. See L<perlrun> documentation
+
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
=item Unknown Unicode option value %x
-You specified an unknown Unicode option. See L<perlrun> documentation
+
(F) 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.
+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
+=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/
+=item Unrecognized escape \%s 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
+recognized by Perl. The character(s) were 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"
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
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
(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
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
+=item Use of := for an empty attribute list is not allowed
+
+(F) The construction C<my $x := 42> used to parse as equivalent to
+C<my $x : = 42> (applying an empty attribute list to C<$x>).
+This construct was deprecated in 5.12.0, and has now been made a syntax
+error, so C<:=> can be reclaimed as a new operator in the future.
+
+If you need an empty attribute list, for example in a code generator, add
+a space before the C<=>.
+
+=item Use of ?PATTERN? without explicit operator is deprecated
+
+(D deprecated) You have written something like C<?\w?>, for a regular
+expression that matches only once. Starting this term directly with
+the question mark delimiter is now deprecated, so that the question mark
+will be available for use in new operators in the future. Write C<m?\w?>
+instead, explicitly using the C<m> operator: the question mark delimiter
+still invokes match-once behaviour.
+
=item Use of freed value in iteration
(F) Perhaps you modified the iterated array within the loop?
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
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=item Use of %s on a handle without * is deprecated
+
+(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that
+scalar happens to hold a typeglob, which means its filehandle will
+be tied. If you mean to tie a handle, use an explicit * as in
+C<tie *$handle>.
+
+This is a long-standing bug that will be removed in Perl 5.16, as
+there is currently no way to tie the scalar itself when it holds
+a typeglob, and no way to untie a scalar that has had a typeglob
+assigned to it.
+
=item Use of -l on filehandle %s
(W io) A filehandle represents an opened file, and when you opened the file
otherwise reasonable constructs to fail in baffling ways. C<use strict;>
instead.
+=item Use of qw(...) as parentheses is deprecated
+
+(D deprecated) You have something like C<foreach $x qw(a b c) {...}>,
+using a C<qw(...)> list literal where a parenthesised expression is
+expected. Historically the parser fooled itself into thinking that
+C<qw(...)> literals were always enclosed in parentheses, and as a result
+you could sometimes omit parentheses around them. (You could never do
+the C<foreach qw(a b c) {...}> that you might have expected, though.)
+The parser no longer lies to itself in this way. Wrap the list literal
+in parentheses, like C<foreach $x (qw(a b c)) {...}>.
+
=item Use of reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
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 presumably know what you are doing.
=item Use of reserved word "%s" is deprecated
allow this syntax, but shouldn't have. It is now deprecated, and will be
removed in a future version.
-=item UTF-16 surrogate %s
+=item Using !~ with %s doesn't make sense
+
+(F) Using the C<!~> operator with C<s///r>, C<tr///r> or C<y///r> is
+currently reserved for future use, as the exact behaviour has not
+been decided. (Simply returning the boolean opposite of the
+modified string is usually not particularly useful.)
+
+=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 Unicode surrogate U+%X is illegal in UTF-8
+
+=item UTF-16 surrogate U+%X
-(W utf8) You tried to generate half of an 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
-this warning by C<no warnings 'utf8';>.
+(W utf8) You had a UTF-16 surrogate in a context where they are
+not considered acceptable. These code points, between U+D800 and
+U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl
+internally allows all unsigned integer code points (up to the size limit
+available on your platform), including surrogates. But these can cause
+problems when being input or output, which is likely where this message
+came from. 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()
=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 regex; marked by <-- HERE in m/%s/
+=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. The <-- HERE shows in the regular expression about
-where the problem was discovered. See L<perlre>.
+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
reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.
+=item Verb pattern '%s' has a mandatory argument in regex; 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.
+
+=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
(P) The attempt to translate a C<use Module n.n LIST> statement into
(W misc) The version string contains invalid characters at the end, which
are being ignored.
-=item v-string in use/require is non-portable
-
-(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.
-
=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
+(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
(W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
-=item %s "\x%s" does not map to Unicode
+=item %s "\x%X" does not map to Unicode
-When reading in different encodings Perl tries to map everything
+(F) 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
=back
+=head1 SEE ALSO
+
+L<warnings>, L<perllexwarn>.
+
=cut
https://perl5.git.perl.org / perl5.git / blobdiff