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
(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
+the variable, 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.
the string, just write C<"-foo">. If you meant the function call,
write C<-foo()>.
-=item Ambiguous use of 's//le...' resolved as 's// le...'; Rewrite as 's//el' if you meant 'use locale rules and evaluate rhs as an expression'. In Perl 5.16, it will be resolved the other way
+=item Ambiguous use of 's//le...' resolved as 's// le...'; Rewrite as 's//el' if you meant 'use locale rules and evaluate rhs as an expression'. In Perl 5.18, it will be resolved the other way
(W deprecated, ambiguous) You wrote a pattern match with substitution
-immediately followed by "le". In Perl 5.14 and earlier, this is
+immediately followed by "le". In Perl 5.16 and earlier, this is
resolved as meaning to take the result of the substitution, and see if
it is stringwise less-than-or-equal-to what follows in the expression.
Having the "le" immediately following a pattern is deprecated behavior,
-so in Perl 5.16, this expression will be resolved as meaning to do the
+so in Perl 5.18, this expression will be resolved as meaning to do the
pattern match using the rules of the current locale, and evaluate the
-rhs as an expression when doing the substitution. In 5.14, if you want
-the latter interpretation, you can simply write "el" instead.
+rhs as an expression when doing the substitution. In 5.14, and 5.16 if
+you want the latter interpretation, you can simply write "el" instead.
+But note that the C</l> modifier should not be used explicitly anyway;
+you should use C<use locale> instead. See L<perllocale>.
=item '|' and '<' may not both be specified on command line
=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.
+(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()
=item assertion botched: %s
-(P) The malloc package that comes with Perl had an internal failure.
+(X) The malloc package that comes with Perl had an internal failure.
=item Assertion failed: file "%s"
-(P) A general assertion failed. The file in question must be examined.
+(X) A general assertion failed. The file in question must be examined.
+
+=item Assigning non-zero to $[ is no longer possible
+
+(F) When the "array_base" feature is disabled (e.g., under C<use v5.16;>)
+the special variable C<$[>, which is deprecated, is now a fixed zero value.
=item Assignment to both a list and a scalar
=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.
+(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 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 bless into a reference
(F) The CLASSNAME argument to the bless() operator is expected to be
-the name of the package to bless the resulting object into. You've
+the name of the package to bless the resulting object into. You've
supplied instead a reference to something: perhaps you wrote
bless $self, $proto;
=item Attempt to free non-arena SV: 0x%x
-(P internal) All SV objects are supposed to be allocated from arenas
+(S internal) All SV objects are supposed to be allocated from arenas
that will be garbage collected on exit. An SV was discovered to be
outside any of those arenas.
-=item Attempt to free nonexistent shared string
+=item Attempt to free nonexistent shared string '%s'%s
-(P internal) Perl maintains a reference-counted internal table of
+(S 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.
=item Attempt to free temp prematurely
-(W debugging) Mortalized values are supposed to be freed by the
+(S debugging) Mortalized values are supposed to be freed by the
free_tmps() routine. This indicates that something else is freeing the
SV before the free_tmps() routine gets a chance, which means that the
free_tmps() routine will be freeing an unreferenced scalar when it does
=item Attempt to free unreferenced glob pointers
-(P internal) The reference counts got screwed up on symbol aliases.
+(S internal) The reference counts got screwed up on symbol aliases.
=item Attempt to free unreferenced scalar
=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.
+(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.
+(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
setting environment variable C<PERL_BADFREE> to 0.
This message can be seen quite often with DB_File on systems with "hard"
-dynamic linking, like C<AIX> and C<OS/2>. It is a bug of C<Berkeley DB>
+dynamic linking, like C<AIX> and C<OS/2>. It is a bug of C<Berkeley DB>
which is left unnoticed if C<DB> uses I<forgiving> system malloc().
=item Bad hash
=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 the environment variable C<PERL_BADFREE> to 1.
+(S malloc) An internal routine called realloc() on something that
+had never been malloc()ed in the first place. Mandatory, but can
+b
e disabled by setting the environment variable C<PERL_BADFREE> to 1.
=item Bad symbol for array
(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
=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.
+(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
+=item Cannot copy to %s
(P) Perl detected an attempt to copy a value to an internal type that cannot
be directly assigned to.
=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>.
+a C<given> block. You probably meant to use C<next> or C<last>.
=item Can't "break" outside a given block
(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 "default" outside a topicalizer
+
+(F) You have used a C<default> 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<default> block, so you won't get the
+error if you use an explicit C<continue>.)
+
=item Can't do inplace edit: %s is not a regular file
(S inplace) You tried to use the B<-i> switch on a special file, such as
=item Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/
-(F) Minima must be less than or equal to maxima. If you really want your
-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>.
+(F) Minima must be less than or equal to maxima. If you really
+want your 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 waitpid with flags
=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?
+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.
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
+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 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.
+(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" or "state". This is not allowed. If you want to
-localize a package variable of the same name, qualify it with the
-package name.
+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 localize through a reference
=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
+for example, F<foo.so> or F<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 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
+=item Can't make list assignment to %ENV on this system
(F) List assignment to %ENV is not supported on some systems, notably
VMS.
=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
-the method name is C<???>, this is an internal error.
+(F)(P) Error resolving overloading specified by a method name (as
+opposed to a subroutine reference): no such method callable via the
+package. If the method name is C<???>, this is an internal error.
=item Can't return %s from lvalue subroutine
=item Can't return %s to lvalue scalar context
-(F) You tried to return a complete array or hash from an lvalue subroutine,
-but you called the subroutine in a way that made Perl think you meant
-to return only one value. You probably meant to write parentheses around
-the call to the subroutine, which tell Perl that the call should be in
-list context.
+(F) You tried to return a complete array or hash from an lvalue
+subroutine, but you called the subroutine in a way that made Perl
+think you meant to return only one value. You probably meant to
+write parentheses around the call to the subroutine, which tell
+Perl that the call should be in list context.
=item Can't stat script "%s"
=item Can't take log of %g
(F) For ordinary real numbers, you can't take the logarithm of a
-negative number or zero. There's a Math::Complex package that comes
+negative number or zero. There's a Math::Complex package that comes
standard with Perl, though, if you really want to do that for the
negative numbers.
=item Can't use %! because Errno.pm is not available
-(F) The first time the %! hash is used, perl automatically loads the
-Errno.pm module. The Errno module is expected to tie the %! hash to
+(F) The first time the C<%!> hash is used, perl automatically loads the
+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
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
references can be weakened.
+=item Can't "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 x= to read-only value
(F) You tried to repeat a constant value (often the undefined value)
=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
+(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.18. 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.
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:
+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)
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:
+below 256), but a higher value was provided instead. Perl uses the
+value modulus 256 instead, as if you had provided:
unpack("H", "\x{a1}")
pack("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
+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
+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")
(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
+ability to specify a semi-colon this way in Perl 5.18. Just use a
semi-colon or a backslash-semi-colon without the "\c".
=item "\c%c" is more clearly written simply as "%s"
=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>.
+(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
+=item Code point 0x%X is not Unicode, all \p{} matches fail; all \P{} matches succeed
(W utf8, non_unicode) You had a code point above the Unicode maximum of U+10FFFF.
will match.
+This may be counterintuitive at times, as both these fail:
+
+ chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # Fails.
+ chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # Also fails!
+
+and both these succeed:
+
+ chr(0x110000) =~ \P{ASCII_Hex_Digit=True} # Succeeds.
+ chr(0x110000) =~ \P{ASCII_Hex_Digit=False} # Also succeeds!
+
=item %s: Command not found
(A) You've accidentally run your script through B<csh> instead of Perl.
=item cond_broadcast() called on unlocked variable
-(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
-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
-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_broadcast() on a variable which wasn't locked.
+The cond_broadcast() 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 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 cond_signal() called on unlocked variable
-(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
-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
-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 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 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 connect() on closed socket %s
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)
is being dereferenced, but it amounts to the wrong type of reference.
-The message indicates the type of reference that was expected. This
+The message indicates the type of reference that was expected. This
usually indicates a syntax error in dereferencing the constant value.
See L<perlsub/"Constant Functions"> and L<constant>.
=item Constant subroutine %s redefined
-(S) You redefined a subroutine which had previously been
-eligible for inlining. See L<perlsub/"Constant Functions"> for
-commentary and workarounds.
+(W redefine)(S) You redefined a subroutine which had previously
+been eligible for inlining. See L<perlsub/"Constant Functions">
+for commentary and workarounds.
=item Constant subroutine %s undefined
=item Copy method did not return a reference
-(F) The method which overloads "=" is buggy. See
+(F) The method which overloads "=" is buggy. See
L<overload/Copy Constructor>.
+=item &CORE::%s cannot be called directly
+
+(F) You tried to call a subroutine in the C<CORE::> namespace
+with C<&foo> syntax or through a reference. Some subroutines
+in this package cannot yet be called that way, but must be
+called as barewords. Something like this will work:
+
+ BEGIN { *shove = \&CORE::push; }
+ shove @array, 1,2,3; # pushes on to @array
+
=item CORE::%s is not a keyword
(F) The CORE:: namespace is reserved for Perl keywords.
=item defined(%hash) is deprecated
-(D deprecated) defined() is not usually useful on hashes because it
-checks for an undefined I<scalar> value. If you want to see if the hash
-is empty, just use C<if (%hash) { # not empty }> for example.
+(D deprecated) C<defined()> is not usually right on hashes and has been
+discouraged since 5.004.
+
+Although C<defined %hash> is false on a plain not-yet-used hash, it
+becomes true in several non-obvious circumstances, including iterators,
+weak references, stash names, even remaining true after C<undef %hash>.
+These things make C<defined %hash> fairly useless in practice.
+
+If a check for non-empty is what you wanted then just put it in boolean
+context (see L<perldata/Scalar values>):
+
+ if (%hash) {
+ # not empty
+ }
+
+If you had C<defined %Foo::Bar::QUUX> to check whether such a package
+variable exists then that's never really been reliable, and isn't
+a good way to enquire about the features of a package, or whether
+it's loaded, etc.
+
=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
+(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.
(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
+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
+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++ }
=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.
+just being DESTROYed. Perl is confused, and prefers to abort rather
+than to create a dangling reference.
=item Did not produce a valid header
=item Empty %s
(F) C<\p> and C<\P> are used to introduce a named Unicode property, as
-described in L<perlunicode> and L<perlre>. You used C<\p> or C<\P> in
+described in L<perlunicode> and L<perlre>. You used C<\p> or C<\P> in
a regular expression without specifying the property name.
=item entering effective %s failed
(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.
+program's environment. This is potentially insecure.
=item Error converting file specification %s
=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.
+any text. Restructure the pattern so that text is consumed.
The <-- HERE shows in the regular expression about where the problem was
discovered.
=item exec? I'm not *that* kind of operating system
(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 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
+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 the format.
=item Filehandle %s opened only for input
=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 occurred 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
=item glob failed (%s)
-(W glob) Something went wrong with the external program(s) used for
-C<glob> and C<< <*.c> >>. Usually, this means that you supplied a
-C<glob> pattern that caused the external program to fail and exit with a
+(W glob) Something went wrong with the external program(s) used
+for C<glob> and C<< <*.c> >>. Usually, this means that you supplied a C<glob>
+pattern that caused the external program to fail and exit with a
nonzero status. If the message indicates that the abnormal exit
-resulted in a coredump, this may also mean that your csh (C shell) is
-broken. If so, you should change all of the csh-related variables in
-config.sh: If you have tcsh, make the variables refer to it as if it
-were csh (e.g. C<full_csh='/usr/bin/tcsh'>); otherwise, make them all
-empty (except that C<d_csh> should be C<'undef'>) so that Perl will
+resulted in a coredump, this may also mean that your csh (C shell)
+is broken. If so, you should change all of the csh-related variables
+in config.sh: If you have tcsh, make the variables refer to it as
+if it were csh (e.g. C<full_csh='/usr/bin/tcsh'>); otherwise, make them
+all empty (except that C<d_csh> should be C<'undef'>) so that Perl will
think csh is missing. In either case, after editing config.sh, run
C<./Configure -S> and rebuild Perl.
(W overflow) You called C<gmtime> with a 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
+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 a 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).
+it can reliably handle and C<gmtime> probably returned the wrong date.
=item Got an error from DosAllocMem
(D syntax)
-You had a word that isn't a regex modifier immediately following a
-pattern without an intervening space. If you are trying to use the C</le>
-flags on a substitution, use C</el> instead. Otherwise, add white space
-between the pattern and following word to eliminate the warning. As an
-example of the latter, the two constructs:
+You had a word that isn't a regex modifier immediately following
+a pattern without an intervening space. If you are trying to use
+the C</le> flags on a substitution, use C</el> instead. Otherwise, add
+white space between the pattern and following word to eliminate
+the warning. As an example of the latter, 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,
+both currently mean the same thing, but it is planned to disallow
+the first form in Perl 5.18. And,
$a =~ m/$foo/and $bar
=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
+(W) Named Unicode character escapes C<(\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 after '_' in prototype for %s : %s
+
+(W illegalproto) An illegal character was found in a prototype declaration.
+Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
+
=item Illegal character \%o (carriage return)
(F) Perl normally treats carriage returns in the program text as it
=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>.
+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>.
+(F) A subroutine was not declared correctly.
See L<perlsub>.
=item Illegal division by zero
=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
+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
=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.
+(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
function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
-
=item Integer overflow in format string for %s
(F) The indexes and widths specified in the format string of C<printf()>
(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 $* 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
+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. You can enable C</m> for a lexical scope (even a whole file)
-with C<use re '/m'>. (In older versions: when C<$*> was set to a true value
+modifiers. You can enable C</m> for a lexical scope (even a whole file)
+with C<use re '/m'>. (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
+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
+=item '%s' is not a code reference
-(W overload) The second (fourth, sixth, ...) argument of overload::constant
-needs to be a code reference. Either an anonymous subroutine, or a reference
-to a subroutine.
+(W overload) The second (fourth, sixth, ...) argument of
+overload::constant needs to be a code reference. Either
+an anonymous subroutine, or a reference to a subroutine.
-=item `%s' is not an overloadable type
+=item '%s' is not an overloadable type
(W overload) You tried to overload a constant type the overload package is
unaware of.
=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>.
+length/code combination tried to obtain more data. This results in
+an undefined value for the length. See L<perlfunc/pack>.
+
+=item length() used on %s
+
+(W syntax) You used length() on either an array or a hash when you
+probably wanted a count of the items.
+
+Array size can be obtained by doing:
+
+ scalar(@array);
+
+The number of items in a hash can be obtained by doing:
+
+ scalar(keys %hash);
=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|perlapi/lex_stuff_pvn> 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.
+(using L<lex_stuff_pvn|perlapi/lex_stuff_pvn> 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)
(W overflow) You called C<localtime> with a 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
+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 a 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).
+wrong date.
=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.
+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
+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.
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
+=item lvalue attribute cannot be removed 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.
+(W misc) The lvalue attribute on a Perl subroutine cannot be turned off
+once the subroutine is defined.
-=item Lvalue subs returning %s not implemented yet
+=item lvalue attribute ignored after the subroutine has been defined
-(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">.
+(W misc) Making a Perl subroutine an lvalue subroutine after it has been
+defined, whether by declaring the subroutine with an lvalue attribute
+or by using L<attributes.pm|attributes>, 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 Malformed integer in [] in pack
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.
+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
=item Maximal count of pending signals (%u) exceeded
-(F) Perl aborted due to too high a number of signals pending. This
+(F) Perl aborted due to too high a 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)">.)
+safely.
(See L<perlipc/"Deferred Signals (Safe Signals)">.)
=item "%s" may clash with future reserved word
Yet another way is to assign to a C<foreach> loop I<VAR> when I<VAR>
is aliased to a constant in the look I<LIST>:
- $x = 1;
- foreach my $n ($x, 2) {
- $n *= 2; # modifies the $x, but fails on attempt to modify the 2
- }
+ $x = 1;
+ foreach my $n ($x, 2) {
+ $n *= 2; # modifies the $x, but fails on attempt to
+ } # modify the 2
=item Modification of non-creatable array value attempted, %s
=item More than one argument to '%s' open
-(F) The C<open> function has been asked to open multiple files. This
+(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
list of arguments, but have forgotten to specify a piped open mode.
See L<perlfunc/open> for details.
=item Nested quantifiers in regex; marked by <-- HERE in m/%s/
-(F) You can't quantify a quantifier without intervening parentheses. So
-things like ** or +* or ?* are illegal. The <-- HERE shows in the regular
-expression about where the problem was discovered.
+(F) You can't quantify a quantifier without intervening parentheses.
+So things like ** or +* or ?* are illegal. The <-- HERE shows in the
+regular expression about where the problem was discovered.
Note that the minimal matching quantifiers, C<*?>, C<+?>, and
C<??> appear to be nested quantifiers, but aren't. See L<perlre>.
=item No comma allowed after %s
-(F) A list operator that has a filehandle or "indirect object" is not
-allowed to have a comma between that and the following arguments.
+(F) A list operator that has a filehandle or "indirect object" is
+not allowed to have a comma between that and the following arguments.
Otherwise it'd be just another one of the arguments.
-One possible cause for this is that you expected to have imported a
-constant to your name space with B<use> or B<import> while no such
-importing took place, it may for example be that your operating system
-does not support that particular constant. Hopefully you did use an
-explicit import list for the constants you expect to see; please see
-L<perlfunc/use> and L<perlfunc/import>. While an explicit import list
-would probably have caught this error earlier it naturally does not
-remedy the fact that your operating system still does not support that
-constant. Maybe you have a typo in the constants of the symbol import
-list of B<use> or B<import> or in the constant name at the line where
-this error was triggered?
+One possible cause for this is that you expected to have imported
+a constant to your name space with B<use> or B<import> while no such
+importing took place, it may for example be that your operating
+system does not support that particular constant. Hopefully you did
+use an explicit import list for the constants you expect to see;
+please see L<perlfunc/use> and L<perlfunc/import>. While an
+explicit import list would probably have caught this error earlier
+it naturally does not remedy the fact that your operating system
+still does not support that constant. Maybe you have a typo in
+the constants of the symbol import list of B<use> or B<import> or in the
+constant name at the line where this error was triggered?
=item No command into which to pipe on command line
=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>.
+matching counterpart.
See L<perlfunc/pack>.
=item No input file after < on command line
=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.
+(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
a reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See L<perlref>.
+=item Not an unblessed ARRAY reference
+
+(F) You passed a reference to a blessed array to C<push>, C<shift> or
+another array function. These only accept unblessed array references
+or arrays beginning explicitly with C<@>.
+
=item Not a SCALAR reference
(F) Perl was trying to evaluate a reference to a scalar value, but found
(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>.
+select.
See L<perlfunc/select>.
=item Null filename used
=item NULL OP IN RUN
-(P debugging) Some internal routine called run() with a null opcode
+(S debugging) Some internal routine called run() with a null opcode
pointer.
=item Null picture in formline
=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
+a number. This happens, for example with C<\o{}>, with no number between
the braces.
=item Octal number in vector unsupported
=item Odd number of arguments for overload::constant
(W overload) The call to overload::constant contained an odd number of
-arguments. The arguments should come in pairs.
+arguments. The arguments should come in pairs.
=item Odd number of elements in anonymous hash
=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 exceptions to this are that zero padding will
take place when going past the end of the string when either
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
(W utf8, non_unicode) 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.
+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.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
(W utf8, surrogate) 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.
+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.
=item Out of memory during "large" request for %s
(F) The malloc() function returned 0, indicating there was insufficient
-remaining memory (or virtual memory) to satisfy the request. However,
+remaining memory (or virtual memory) to satisfy the request. However,
the request was judged large enough (compile-time default is 64K), so a
possibility to shut down by trapping this error is granted.
=item Out of memory during request for %s
-(X|F) The malloc() function returned 0, indicating there was
+(X)(F) The malloc() function returned 0, indicating there was
insufficient remaining memory (or virtual memory) to satisfy the
request.
=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
+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
+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>.
+overloaded operation didn't return a compiled regexp. See L<overload>.
=item %s package attribute may clash with future reserved word: %s
(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
=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 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.
+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: INTERPCASEMOD
(P) Something requested a negative number of bytes of realloc.
+=item panic: reference miscount on nsv in sv_replace() (%d != 1)
+
+(P) The internal sv_replace() function was handed a new SV with a
+reference count other than 1.
+
=item panic: restartop
(P) Some internal routine requested a goto (or something like it), and
(P) The sv_insert() routine was told to remove more string than there
was string.
+=item panic: strxfrm() gets absurd - a => %u, ab => %u
+
+(P) The interpreter's sanity check of the C function strxfrm() failed.
+In your current locale the returned transformation of the string "ab" is
+shorter than that of the string "a", which makes no sense.
+
=item panic: top_env
(P) The compiler attempted to do a goto, or something weird like that.
=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.
+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.
"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 folding rules are not up-to-date for 0x%x; please use the perlbug utility to report;
+=item Perl folding rules are not up-to-date for 0x%x; please use the perlbug utility to report
(W regex, deprecated) You used a regular expression with
case-insensitive matching, and there is a bug in Perl in which the
if ($x & $y == 0) { ... }
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
+higher precedence of C<==>. This is probably not what you want. (If you
really meant to write this, disable the warning, or, better, put the
parentheses explicitly and write C<$x & ($y == 0)>).
=item Possible unintended interpolation of %s in string
-(W ambiguous) You said something like `@foo' in a double-quoted string
-but there was no array C<@foo> in scope at the time. If you wanted a
+(W ambiguous) You said something like '@foo' in a double-quoted string
+but there was no array C<@foo> in scope at the time. If you wanted a
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
=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>.
+(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 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>.
+(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 Reference found where even-sized list expected
(W misc) You gave a single reference where Perl was expecting a list
-with an even number of elements (for assignment to a hash). This usually
-means that you used the anon hash constructor when you meant to use
-
parens. In any case, a hash requires key/value B<pairs>.
+with an even number of elements (for assignment to a hash). This
+usually means that you used the anon hash constructor when you meant
+
to use parens. In any case, a hash requires key/value B<pairs>.
%hash = { one => 1, two => 2, }; # WRONG
%hash = [ qw/ an anon array / ]; # WRONG
(W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
-=item Reference miscount in sv_replace()
-
-(W internal) The internal sv_replace() function was handed a new SV with
-a reference count 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). Using 0 does not make sense.
+(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). 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
+not at least seven sets of capturing parentheses in the expression. If
you wanted to have the character with ordinal 7 inserted into the regular
expression, prepend zeroes to make it three digits long: C<\007>
(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
+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
(P) The regular expression engine got confused by what the regular
expression compiler gave it.
+=item Regexp modifier "/%c" may appear a maximum of twice
+
=item Regexp modifier "/%c" may not appear twice
-(F syntax) The regular expression pattern had one of the
-mutually exclusive modifiers repeated. Remove all but one of the
-occurrences.
+(F syntax, regexp) The regular expression pattern had too many occurrences
+of the specified modifier. Remove the extraneous ones.
+
+=item Regexp modifier "%c" may not appear after the "-"
+
+(F regexp) Turning off the given modifier has the side effect of turning
+on another one. Perl currently doesn't allow this. Reword the regular
+expression to use the modifier you want to turn on (and place it before
+the minus), instead of the one you want to turn off.
=item Regexp modifiers "/%c" and "/%c" are mutually exclusive
-(F syntax) The regular expression pattern had more than one of the
+(F syntax, regexp) The regular expression pattern had more than one of these
mutually exclusive modifiers. Retain only the modifier that is
supposed to be there.
(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>.
+terminates.
You might use ^# instead. See L<perlform>.
=item Replacement list is longer than search list
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
+parsed. One way to disambiguate the parsing is to put parentheses around
the conditional expression, i.e. C<(foo) ? 0 : 1>.
=item seekdir() attempted on invalid dirhandle %s
=item Sequence (? incomplete in regex; marked by <-- HERE in m/%s/
-(F) A regular expression ended with an incomplete extension (?. The <-- HERE
-shows in the regular expression about where the problem was discovered. See
-L<perlre>.
+(F) A regular expression ended with an incomplete extension (?. 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/
-(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>.
+(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/
<-- HERE shows in the regular expression about where the problem was
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<"a>, C<"d">, C<"l">, or C<"u"> modifiers. For other
+redundantly specify a default modifier. For other
causes, see L<perlre>.
=item Sequence \%s... 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
+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 contain braces, they must balance
-for Perl to detect the end of the clause properly. The <-- HERE shows in
-the regular expression about where the problem was discovered. See
-L<perlre>.
+(F) If the contents of a (?{...}) clause contain braces, they
+must balance for Perl to detect the end of the clause properly.
+The <-- HERE shows in the regular expression about where the
+
problem was discovered. See L<perlre>.
=item Z<>500 Server error
=item Server error
-(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
-contains no data", "Premature end of script headers", and "Did not
-produce a valid header".
+(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 contains no data", "Premature end of script
+headers", and "Did not produce a valid header".
B<This is a CGI error, not a Perl error>.
-You need to make sure your script is executable, is accessible by the
-user CGI is running the script under (which is probably not the user
-account you tested it under), does not rely on any environment variables
-(like PATH) from the user it isn't running under, and isn't in a
-location where the CGI server can't find it, basically, more or less.
-Please see the following for more information:
+You need to make sure your script is executable, is accessible by
+the user CGI is running the script under (which is probably not the
+user account you tested it under), does not rely on any environment
+variables (like PATH) from the user it isn't running under, and isn't
+in a location where the CGI server can't find it, basically, more or
+less. Please see the following for more information:
http://www.perl.org/CGI_MetaFAQ.html
http://www.htmlhelp.org/faq/cgifaq.html
(F) A sort comparison subroutine may not return a list value with more
or less than one element. See L<perlfunc/sort>.
+=item Source filters apply only to byte streams
+
+(F) You tried to activate a source filter (usually by loading a
+source filter module) within a string passed to C<eval>. This is
+not permitted under the C<unicode_eval> feature. Consider using
+C<evalbytes> instead. See L<feature>.
+
=item splice() offset past end of array
(W misc) You attempted to specify an offset that was past the end of
the array passed to splice(). Splicing will instead commence at the end
-of the array, rather than past it. If this isn't what you want, try
-explicitly pre-extending the array by assigning $#array = $offset. See
+of the array, rather than past it. If this isn't what you want, try
+explicitly pre-extending the array by assigning $#array = $offset. See
L<perlfunc/splice>.
=item Split loop
(P) The split was looping infinitely. (Obviously, a split shouldn't
iterate more times than there are characters of input, which is what
-happened.) See L<perlfunc/split>.
+happened.)
See L<perlfunc/split>.
=item Statement unlikely to be reached
(?(condition)(?:this|that|other)|else-clause)
The <-- HERE shows in the regular expression about where the problem was
-discovered. See L<perlre>.
+discovered.
See L<perlre>.
=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 about where the problem was discovered. See L<perlre>.
+expression about where the problem was discovered.
See L<perlre>.
=item switching effective %s is not implemented
Occasionally the line number may be misleading, and once in a blue moon
the only way to figure out what's triggering the error is to call
C<perl -c> repeatedly, chopping away half the program each time to see
-if the error went away. Sort of the cybernetic version of S<20
-questions>.
+if the error went away. Sort of the cybernetic version of S<20 questions>.
-=item syntax error at line %d: `%s' unexpected
+=item syntax error at line %d: '%s' unexpected
(A) You've accidentally run your script through the Bourne shell instead
of Perl. Check the #! line, or manually feed your script into Perl
...
This is to prevent the problem of one module changing the array base out
-from under another module inadvertently. See L<perlvar/$[>.
+from under another module inadvertently. See L<perlvar/$[> and L<arybase>.
=item The crypt() function is unimplemented due to excessive paranoia
=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 (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.
+(X) The #! line (or local equivalent) in a Perl script contains
+the 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<-%c> option is a part of Perl's first
-argument: e.g. change C<perl -n -%c> to C<perl -%c -n>.
+mechanism (or its local equivalent), this error can usually be
+fixed by 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<-%c> option must appear on the command line: C<perl -%c scriptname>.
(X) The #! line (or local equivalent) in a Perl script contains the
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.
+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.
+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 '%s' trapped by operation mask
(F) You tried to use an operator from a Safe compartment in which it's
-disallowed. See L<Safe>.
+disallowed. See L<Safe>.
=item truncate not implemented
(F) Your machine doesn't implement a file truncation mechanism that
Configure knows about.
+=item Type of arg %d to &CORE::%s must be %s
+
+(F) The subroutine in question in the CORE package requires its argument
+to be a hard reference to data of the specified type. Overloading is
+ignored, so a reference to an object that is not the specified type, but
+nonetheless has overloading to handle it, will still not be accepted.
+
=item Type of arg %d to %s must be %s (not %s)
(F) This function requires the argument in that position to be of a
%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
+=item Type of argument to %s must be unblessed 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.
+(F) You called C<keys>, C<values> or C<each> with a scalar argument that
+was not a reference to an unblessed hash or array.
=item umask not implemented
=item Unicode non-character U+%X is illegal for open interchange
(W utf8, nonchar) 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 'nonchar';>.
+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 'nonchar';>.
=item Unicode surrogate U+%X is illegal in UTF-8
=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 must be one of the following:
+is not known. The condition must be one of the following:
(1) (2) ... true if 1st, 2nd, etc., capture matched
(<NAME>) ('NAME') true if named capture matched
=item Unknown warnings category '%s'
-(F) An error issued by the C<warnings> pragma. You specified a warnings
+(F) An error issued by the C<warnings> pragma. You specified a warnings
category that is unknown to perl at this point.
Note that if you want to enable a warnings category registered by a
=item unmatched [ in regex; marked by <-- HERE in m/%s/
-(F) The brackets around a character class must match. If you wish to
+(F) The brackets around a character class must match. If you wish to
include a closing bracket in a character class, backslash it or put it
-first. The <-- HERE shows in the regular expression about where the problem
-
was discovered. See L<perlre>.
+first. The <-- HERE shows in the regular expression about where the
+
problem was discovered. See L<perlre>.
=item unmatched ( in regex; marked by <-- HERE in m/%s/
(F) Unbackslashed parentheses must always be balanced in regular
-expressions. If you're a vi user, the % key is valuable for finding the
-matching parenthesis. The <-- HERE shows in the regular expression about
-
where the problem was discovered. See L<perlre>.
+expressions. If you're a vi user, the % key is valuable for finding
+the matching parenthesis. The <-- HERE shows in the regular expression
+
about where the problem was discovered. See L<perlre>.
=item Unmatched right %s bracket
=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. 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.
+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"
(F) Your version of executable does not support forking.
Note that under some systems, like OS/2, there may be different flavors
-of Perl executables, some of which may support fork, some not. Try
+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 %s
=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.
+the pattern with a C<)>. Fix the pattern and retry.
=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.
+the pattern with a C<)>. Fix the pattern and retry.
=item untie attempted while %d inner references still exist
(F) You called a Win32 function with incorrect arguments.
See L<Win32> for more information.
+=item $[ used in %s (did you mean $] ?)
+
+(W syntax) You used C<$[> in a comparison, such as:
+
+ if ($[ > 5.006) {
+ ...
+ }
+
+You probably meant to use C<$]> instead. C<$[> is the base for indexing
+arrays. C<$]> is the Perl version number in decimal.
+
+=item Useless assignment to a temporary
+
+(W misc) You assigned to an lvalue subroutine, but what
+the subroutine returned was a temporary scalar about to
+be discarded, so the assignment had no effect.
+
=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
if ($string =~ /$pattern/) { ... }
The <-- HERE shows in the regular expression about
-where the problem was discovered. See L<perlre>.
+where the problem was discovered.
See L<perlre>.
=item Useless localization of %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
+(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.
=item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
if ($string =~ /$pattern/o) { ... }
The <-- HERE shows in the regular expression about
-where the problem was discovered. See L<perlre>.
+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
+same length as the replacelist.
See L<perlop> for more information
about the /d modifier.
=item Useless use of %s in void context
=item Useless use of "re" pragma
-(W) You did C<use re;> without any arguments. That isn't very useful.
+(W) You did C<use re;> without any arguments. That isn't very useful.
=item Useless use of sort in scalar context
=item Useless use of %s with no values
(W syntax) You used the push() or unshift() function with no arguments
-apart from the array, like C<push(@x)> or C<unshift(@foo)>. That won't
-usually have any effect on the array, so is completely useless. It's
+apart from the array, like C<push(@x)> or C<unshift(@foo)>. That won't
+usually have any effect on the array, so is completely useless. It's
possible in principle that push(@tied_array) could have some effect
-if the array is tied to a class which implements a PUSH method. If so,
+if the array is tied to a class which implements a PUSH method. If so,
you can write it as C<push(@tied_array,())> to avoid this warning.
=item "use" not allowed in expression
=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/"$[">.
+is deprecated.
See L<perlvar/"$[">.
=item Use of bare << to mean <<"" 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 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.
+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
+anid 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
(D deprecated) You tried to use a hash as a reference, as in
C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1
-used to allow this syntax, but shouldn't have. It is now deprecated, and will
-be removed in a future version.
+used to allow this syntax, but shouldn't have. It is now
+deprecated, and will be removed in a future version.
=item Using an array as a reference is deprecated
(D deprecated) You tried to use an array as a reference, as in
C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.6.1 used to
-allow this syntax, but shouldn't have. It is now deprecated, and will be
-removed in a future version.
+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
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 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
+been decided. (Simply returning the boolean opposite of the
modified string is usually not particularly useful.)
-=item User-defined case-mapping '%s' is deprecated
-
-(W deprecated) You defined a function, such as C<ToLower> that overrides
-the standard case mapping, such as C<lc()> gives. This feature is being
-deprecated due to its many issues, as documented in
-L<perlunicode/User-Defined Case Mappings (for serious hackers only)>.
-It is planned to remove this feature in Perl 5.16. A CPAN module
-providing improved functionality is being prepared.
-
=item UTF-16 surrogate U+%X
(W utf8, surrogate) You had a UTF-16 surrogate in a context where they are
(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
+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,
+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,
+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:
=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.
+(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
+(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
=head1 SEE ALSO
-L<warnings>, L<perllexwarn>.
+L<warnings>, L<perllexwarn>, L<diagnostics>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff