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
+
+(W deprecated, ambiguous) You wrote a pattern match with substitution
+immediately followed by "le". In Perl 5.14 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
+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.
+
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
you meant to do. See L<perlfunc/grep> and L<perlfunc/map> for
alternatives.
-=item Args must match #! line
-
-(F) The setuid emulator requires that the arguments Perl was invoked
-with match the arguments specified on the #! line. Since some systems
-impose a one-argument limit on the #! line, try combining switches;
-for example, turn C<-w -U> into C<-wU>.
-
=item Arg too short for msgsnd
(F) msgsnd() requires a string at least as long as sizeof(long).
=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 Assignment to both a list and a scalar
=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
(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
print q(The character '(' starts a side comment.);
-If you're getting this error from a here-document, you may have included
-unseen whitespace before or after your closing tag. A good programmer's
-editor will have a way to help you find these characters.
+If you're getting this error from a here-document, you may have
+included unseen whitespace before or after your closing tag or there
+may not be a linebreak after it. A good programmer's editor will have
+a way to help you find these characters (or lack of characters). See
+L<perlop> for the full details on here-documents.
=item Can't find Unicode property definition "%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
-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 Character following "\c" must be ASCII
-(F|W deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
+(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.
=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) You had a code point above the Unicode maximum of U+10FFFF.
+(W utf8, non_unicode) 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
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.
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)
=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
(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. Most 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
+most likely cause of this error is that you left out a parenthesis inside
+of the C<....> part.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
=item %s defines neither package nor VERSION--version check failed
(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
+date. This warning is also triggered with NaN (the special
not-a-number value).
=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. For example, 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
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
supplied (or potentially supplied) by the user. The script must set
the path to a known value, using trustworthy data. See L<perlsec>.
+=item Insecure user-defined property %s
+
+(F) Perl detected tainted data when trying to compile a regular
+expression that contains a call to a user-defined character property
+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()>
The <-- HERE shows in the regular expression about where the
escape was discovered.
+=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 Invalid mro name: '%s'
(F) You tried to C<mro::set_mro("classname", "foo")> or C<use mro 'foo'>,
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.
-=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.
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_flags|perlapi/lex_stuff_pvn_flags> or similar), but tried to insert a character
+(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.
(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
+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/
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
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
+=item Name "%s::%s" used only once: possible typo
+
+(W once) Typographical errors often show up as unique variable names.
+If you had a good reason for having a unique name, then just mention it
+again somehow to suppress the message. The C<our> declaration is
+provided for this purpose.
+
+NOTE: This warning detects symbols that have been used only once so $c, @c,
+%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
+the same; if a program uses $c only once but also uses any of the others it
+will not trigger this warning.
+
=item \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.
+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:
+(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!
/\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.
-If you had a good reason for having a unique name, then just mention it
-again somehow to suppress the message. The C<our> declaration is
-provided for this purpose.
-
-NOTE: This warning detects symbols that have been used only once so $c, @c,
-%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
-the same; if a program uses $c only once but also uses any of the others it
-will not trigger this warning.
-
-=item Invalid hexadecimal number in \N{U+...}
-
-(F) The character constant represented by C<...> is not a valid hexadecimal
-number. Either it is empty, or you tried to use a character other than 0 - 9
-or A - F, a - f in a hexadecimal number.
-
=item Negative '/' count in unpack
(F) The length count obtained from a length/code unpack operation was
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
+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
=item No DB::DB routine defined
(F) The currently executing code was compiled with the B<-d> switch, but
-for some reason the
current debugger (e.g. F<perl5db.pl> or a C<Devel::>
+for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
module) didn't define a routine to be called at the beginning of each
statement.
module) didn't define a C<DB::sub> routine to be called at the beginning
of each ordinary subroutine call.
-=item No B<-e> allowed in setuid scripts
-
-(F) A setuid script can't be specified by the user.
-
=item No error file after 2> or 2>> on command line
(F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a '<' on the command line, but can't find the
name of the file from which to read data for stdin.
-=item No #! line
-
-(F) The setuid emulator requires that scripts have a well-formed #! line
-even on machines that don't support the #! construct.
-
=item No next::method '%s' found for %s
(F) C<next::method> found no further instances of this method name
(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", "our" or "state" declaration, but
-this class doesn't exist at this point in your program.
+(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
+(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
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 a perl script
+=item Not an unblessed ARRAY reference
-(F) The setuid emulator requires that scripts have a well-formed #! line
-even on machines that don't support the #! construct. The line must
-mention perl.
+(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
=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.
+(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().
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 the braces.
+(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
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
-See also L<perlport> for writing portable code.
-
=item Odd number of arguments for overload::constant
(W overload) The call to overload::constant contained an odd number of
=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
(F) An attempt was made to perform an overloaded operation for which no
handler was defined. While some handlers can be autogenerated in terms
of other handlers, there is no default handler for any operation, unless
-C<fallback> overloading key is specified to be true. See L<overload>.
+the C<fallback> overloading key is specified to be true. See L<overload>.
-=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
+=item Operation "%s" returns its argument for non-Unicode code point 0x%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.
+(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.
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';>.
+C<no warnings 'non_unicode';>.
-=item Operation "%s" returns its argument for non-Unicode code point 0x%X
+=item Operation "%s" returns its argument for UTF-16 surrogate U+%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.
+(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.
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';>.
+C<no warnings 'surrogate';>.
=item Operator or semicolon missing before %s
=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.
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) 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
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.
-
=item panic: INTERPCASEMOD
(P) The lexer got into a bad state at a case modifier.
(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 panic: unimplemented op %s (#%d) called
-(P) The compiler is screwed up and attempted to use an op that isn't permitted
-at run time.
+(P) The compiler is screwed up and attempted to use an op that isn't
+permitted at run time.
=item panic: utf16_to_utf8: odd bytelen
"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
+
+(W regex, deprecated) You used a regular expression with
+case-insensitive matching, and there is a bug in Perl in which the
+built-in regular expression folding rules are not accurate. This may
+lead to incorrect results. Please report this as a bug using the
+"perlbug" utility. (This message is marked deprecated, so that it by
+default will be turned-on.)
+
=item Perl_my_%s() not available
(F) Your platform has very uncommon byte-order and integer size,
system supplier and/or system administrator have set up the so-called
locale system but Perl could not use those settings. This was not
dead serious, fortunately: there is a "default locale" called "C" that
-Perl can and will use, the script will be run. Before you really fix
-the problem, however, you will get the same error message each time
-you run Perl. How to really fix the problem can be found in
+Perl can and will use, and the script will be run. Before you really
+fix the problem, however, you will get the same error message each
+time you run Perl. How to really fix the problem can be found in
L<perllocale> section B<LOCALE PROBLEMS>.
=item pid %x not a child
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
-literal @foo, then write it as \@foo; otherwise find out what happened
-to the array you apparently lost track of.
-
=item Possible unintended interpolation of $\ in regex
(W ambiguous) You said something like C<m/$\/> in a regex.
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 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
+literal @foo, then write it as \@foo; otherwise find out what happened
+to the array you apparently lost track of.
+
=item Precedence problem: open %s should be open(%s)
(S precedence) The old irregular construct
(F) You've omitted the closing parenthesis in a function prototype
definition.
+=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 Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
(F) You started a regular expression with a quantifier. Backslash it if you
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
+=item refcnt_dec: fd %d%s
-(F) More than 100 levels of inheritance were encountered while invoking
-a method. Probably indicates an unintended loop in your inheritance
-hierarchy.
+=item refcnt: fd %d%s
+
+=item refcnt_inc: fd %d%s
+
+(P) Perl's I/O implementation failed an internal consistency check. If
+you see this message, something is very wrong.
=item Reference found where even-sized list expected
(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 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.
+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 you
-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.
+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>
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.
+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/
+=item Reference to nonexistent or unclosed group 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.
+(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.
(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, 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, regexp) The regular expression pattern had more than one of these
+mutually exclusive modifiers. Retain only the modifier that is
+supposed to be there.
+
=item Regexp out of space
(P) A "can't happen" error, because safemalloc() should have caught it
=item Reversed %s= operator
(W syntax) You wrote your assignment operator backwards. The = must
-always comes last, to avoid ambiguity with subsequent unary operators.
+always come last, to avoid ambiguity with subsequent unary operators.
=item rewinddir() attempted on invalid dirhandle %s
parsed. One way to disambiguate the parsing is to put parentheses around
the conditional expression, i.e. C<(foo) ? 0 : 1>.
-=item %sseek() on unopened filehandle
-
-(W unopened) You tried to use the seek() or sysseek() function on a
-filehandle that was either never opened or has since been closed.
-
=item seekdir() attempted on invalid dirhandle %s
(W io) The dirhandle you are doing a seekdir() on is either closed or not
really a dirhandle. Check your control flow.
+=item %sseek() on unopened filehandle
+
+(W unopened) You tried to use the seek() or sysseek() function on a
+filehandle that was either never opened or has since been closed.
+
=item select not implemented
(F) This machine doesn't implement the select() system call.
<-- 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<"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/
=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
-(F) If the contents of a (?{...}) clause contains braces, they must balance
-for Perl to properly detect the end of the clause. The <-- HERE shows in
+(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 "500 Server error"
+=item Z<>500 Server error
See Server error.
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
-=item Setuid/gid script is writable by world
-
-(F) The setuid emulator won't run a script that is writable by the
-world, because the world might have written on it already.
-
-=item Setuid script not plain file
-
-(F) The setuid emulator won't run a script that isn't read from a file,
-but from a socket, a pipe or another device.
-
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
(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
=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
+(P) Perl tried to force the upgrade of an SV to a type which was actually
inferior to its current type.
=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
=item Switch condition not recognized in regex; marked by <-- HERE in m/%s/
-(F) If the argument to the (?(...)if-clause|else-clause) construct is a
-number, it can be only a number. The <-- HERE shows in the regular expression
-about where the problem was discovered. See L<perlre>.
+(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>.
=item switching effective %s is not implemented
(F) While under the C<use filetest> pragma, we cannot switch the real
and effective uids or gids.
-=item %s syntax
+=item %s syntax OK
(F) The final summary message when a C<perl -c> succeeds.
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
(F) You tried to use C<goto> to reach a label that was too deeply nested
for Perl to reach. Perl is doing you a favor by refusing.
-=item tell() on unopened filehandle
-
-(W unopened) You tried to use the tell() function on a filehandle that
-was either never opened or has since been closed.
-
=item telldir() attempted on invalid dirhandle %s
(W io) The dirhandle you tried to telldir() is either closed or not really
a dirhandle. Check your control flow.
+=item tell() on unopened filehandle
+
+(W unopened) You tried to use the tell() function on a filehandle that
+was either never opened or has since been closed.
+
=item That use of $[ is unsupported
(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
...
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
(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) Certain codepoints, such as U+FFFE and U+FFFF, are defined by the
+(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 'utf8';>.
+off this warning by C<no warnings 'nonchar';>.
+
+=item Unicode surrogate U+%X is illegal in UTF-8
+
+(W utf8, surrogate) 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 'surrogate';>.
=item Unknown BYTEORDER
=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
-is true if the lookahead or lookbehind is true), a (?{...}) construct (the
-condition is true if the code evaluates to a true value), or a number (the
-condition is true if the set of capturing parentheses named by the number
-matched).
+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
+ (?=...) (?<=...) true if subpattern matches
+ (?!...) (?<!...) true if subpattern fails to match
+ (?{ CODE }) true if code returns a true value
+ (R) true if evaluating inside recursion
+ (R1) (R2) ... true if directly inside capture group 1, 2, etc.
+ (R&NAME) true if directly inside named capture
+ (DEFINE) always false; for defining named subpatterns
The <-- HERE shows in the regular expression about where the problem was
discovered. See L<perlre>.
(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'
-
-(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 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 Unknown warnings category '%s'
+
+(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
+module (e.g. C<use warnings 'File::Find'>), you must have loaded this
+module first.
=item unmatched [ in regex; marked by <-- HERE in m/%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
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=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 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 untie attempted while %d inner references still exist
(W untie) A copy of the object returned from C<tie> (or C<tied>) was
(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 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?
=item Use of inherited AUTOLOAD for non-method %s() is deprecated
-(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
-are looked up as methods (using the C<@ISA> hierarchy) even when the
-subroutines to be autoloaded were called as plain functions (e.g.
-C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or C<<
-$obj->bar() >>).
+(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD>
+subroutines are looked up as methods (using the C<@ISA> hierarchy)
+even when the subroutines to be autoloaded were called as plain
+functions (e.g. C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or
+C<< $obj->bar() >>).
This bug will be rectified in future by using method lookup only for
methods' C<AUTOLOAD>s. However, there is a significant base of existing
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=item Use of -l on filehandle %s
+
+(W io) A filehandle represents an opened file, and when you opened the file
+it already went past any symlink you are presumably trying to look for.
+The operation returned C<undef>. Use a filename instead.
+
=item Use of %s on a handle without * is deprecated
(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that
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
-it already went past any symlink you are presumably trying to look for.
-The operation returned C<undef>. Use a filename instead.
-
-=item Use of "package" with no arguments is deprecated
+=item Use of ?PATTERN? without explicit operator is deprecated
-(D deprecated) You used the C<package> keyword without specifying a package
-name. So no namespace is current at all. Using this can cause many
-otherwise reasonable constructs to fail in baffling ways. C<use strict;>
-instead.
+(D deprecated) 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 qw(...) as parentheses is deprecated
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
+however, because you can overload the numification and stringification
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 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 Using !~ with %s doesn't make sense
-=item Unicode surrogate U+%X is illegal in UTF-8
+(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 UTF-16 surrogate U+%X
-(W utf8) You had a UTF-16 surrogate in a context where they are
+(W utf8, surrogate) 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';>.
+off this warning by C<no warnings 'surrogate';>.
=item Value of %s can be "0"; test with defined()
=item "%s" variable %s masks earlier declaration in same %s
-(W misc) A "my", "our" or "state" variable has been redeclared in the current
-scope or statement, effectively eliminating all access to the previous
-instance. This is almost always a typographical error. Note that the
-earlier variable will still exist until the end of the scope or until
-all closure referents to it are destroyed.
+(W misc) A "my", "our" or "state" variable has been redeclared in the
+current scope or statement, effectively eliminating all access to the
+previous instance. This is almost always a typographical error. Note
+that the earlier variable will still exist until the end of the scope
+or until all closure referents to it are destroyed.
=item Variable syntax
(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
C<TEMPLATE> always matches the same amount of packed bytes that can be
-determined from the template alone. This is not possible if it contains an
+determined from the template alone. This is not possible if it contains any
of the codes @, /, U, u, w or a *-length. Redesign the template.
=item write() on closed filehandle %s
=head1 SEE ALSO
-L<warnings>, L<perllexwarn>.
+L<warnings>, L<perllexwarn>, L<diagnostics>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff