to check the return value of your socket() call? See
L<perlfunc/accept>.
-=item Allocation too large: %lx
+=item Allocation too large: %x
(X) You can't allocate more than 64K on an MS-DOS machine.
to be an object method (see L<perlsub/"Subroutine Attributes"> or
L<attributes>).
+=item Ambiguous overloaded argument to %s resolved as %s
+
+(W ambiguous) You called C<keys>, C<values> or C<each> on an object that had
+overloading of C<%{}> or C<@{}> or both. In such a case, the object is
+dereferenced according to its overloading, not its underlying reference type.
+The warning is issued when C<%{}> overloading exists on a blessed arrayref,
+when C<@{}> overloading exists on a blessed hashref, or when both overloadings
+are defined (in which case C<%{}> is used). You can force the interpretation
+of the object by explicitly dereferencing it as an array or hash instead of
+passing the object itself to C<keys>, C<values> or C<each>.
+
=item Ambiguous range in transliteration operator
(F) You wrote something like C<tr/a-z-0//> which doesn't mean anything at
=item Ambiguous use of %c resolved as operator %c
(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
-bitwise and, and multpication), and you said something like C<*foo *
-foo> that might be interpreted as either of them. We assumed you
-meant the infix operator, but please try to make it more clear -- in
-the example given, you might write C<*foo * foo()> if you really meant
-to multiply a glob by the result of calling a function.
+bitwise and, and multiplication) I<and> initial special characters
+(denoting hashes, subroutines and typeglobs), and you said something
+like C<*foo * foo> that might be interpreted as either of them. We
+assumed you meant the infix operator, but please try to make it more
+clear -- in the example given, you might write C<*foo * foo()> if you
+really meant to multiply a glob by the result of calling a function.
=item Ambiguous use of %c{%s} resolved to %c%s
=item Ambiguous use of %c{%s%s} resolved to %c%s%s
-(W ambiguous) You wrote something like C<${foo[2]}>, which might be
-looking for element number 2 of the array named C<@foo>, in which case
-please write C<$foo[2]>, or you might have meant to pass an anonymous
-arrayref to the function named foo, then do a scalar deref on the
-value it returns. If you meant that, write C<${foo([2])}>.
+(W ambiguous) You wrote something like C<${foo[2]}> (where foo
+represents the name of a Perl keyword), which might be looking for
+element number 2 of the array named C<@foo>, in which case please write
+C<$foo[2]>, or you might have meant to pass an anonymous arrayref to
+the function named foo, and then do a scalar deref on the value it
+returns. If you meant that, write C<${foo([2])}>.
+
+In regular expressions, the C<${foo[2]}> syntax is sometimes necessary
+to disambiguate between array subscripts and character classes.
+C</$length[2345]/>, for instance, will be interpreted as C<$length>
+followed by the character class C<[2345]>. If an array subscript is what
+you want, you can avoid the warning by changing C</${length[2345]}/>
+to the unsightly C</${\$length[2345]}/>, by renaming your array to
+something that does not coincide with a built-in keyword, or by
+simply turning off warnings with C<no warnings 'ambiguous';>.
=item Ambiguous use of -%s resolved as -&%s()
(W ambiguous) You wrote something like C<-foo>, which might be the
-string C<"-foo"> (outside of C<use strict 'subs'>), or a call to the
-function C<foo>, negated. If you meant the string, just write
-C<"-foo">, and please use strict. If you meant the function call,
+string C<"-foo">, or a call to the function C<foo>, negated. If you meant
+the string, just write C<"-foo">. If you meant the function call,
write C<-foo()>.
=item '|' and '<' may not both be specified on command line
(W threads)(S) When using threaded Perl, a thread (not necessarily the main
thread) exited while there were still other threads running.
-Usually it's a good idea to first collect the return values of the
-created threads by joining them, and only then exit from the main
+Usually it's a good idea first to collect the return values of the
+created threads by joining them, and only then to exit from the main
thread. See L<threads>.
=item Attempt to access disallowed key '%s' in a restricted hash
(F) The failing code attempted to delete a key whose value has been
declared readonly from a restricted hash.
-=item Attempt to free non-arena SV: 0x%lx
+=item Attempt to free non-arena SV: 0x%x
(P internal) All SV objects are supposed to be allocated from arenas
that will be garbage collected on exit. An SV was discovered to be
=item Attempt to free nonexistent shared string
-(P internal) Perl maintains a reference counted internal table of
+(P internal) Perl maintains a reference-counted internal table of
strings to optimize the storage and access of hash keys and other
strings. This indicates someone tried to decrement the reference count
of a string that can no longer be found in the table.
=item Attribute "locked" is deprecated
-(D deprecated) You have used the attributes pragam to modify the "locked"
+(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 the next major
+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 pragam to modify the "unique"
+(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 the next major
-release of Perl 5.
+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 %d, should be %d
+=item Bad arg length for %s, is %u, should be %d
(F) You passed a buffer of the wrong size to one of msgctl(), semctl()
or shmctl(). In C parlance, the correct sizes are, respectively,
(S malloc) An internal routine called realloc() on something that had
never been malloc()ed in the first place. Mandatory, but can be disabled
-by setting environment variable C<PERL_BADFREE> to 1.
+by setting
the environment variable C<PERL_BADFREE> to 1.
=item Bad symbol for array
because other Perl programmers will expect it, and it works better if
there are more than 9 backreferences.
+=item "\b{" is deprecated; use "\b\{" instead
+
+=item "\B{" is deprecated; use "\B\{" instead
+
+(W deprecated, regexp) Use of an unescaped "{" immediately following a
+C<\b> or C<\B> is now deprecated so as to reserve its use for Perl
+itself in a future release.
+
=item Binary number > 0b11111111111111111111111111111111 non-portable
(W portable) The binary number you specified is larger than 2**32-1
=item binmode() on closed filehandle %s
(W unopened) You tried binmode() on a filehandle that was never opened.
-Check you control flow and number of arguments.
+Check your control flow and number of arguments.
=item Bit vector size > 32 non-portable
=item Bizarre copy of %s in %s
(P) Perl detected an attempt to copy an internal value that is not
-copyable.
+copiable.
=item Buffer overflow in prime_env_iter: %s
=item Cannot copy to %s in %s
(P) Perl detected an attempt to copy a value to an internal type that cannot
-be directly assigned not.
+be directly assigned to.
=item Cannot find encoding "%s"
(F) You called C<break>, but you're not inside a C<given> block.
-=item Can't call method "%s" in empty package "%s"
-
-(F) You called a method correctly, and it correctly indicated a package
-functioning as a class, but that package doesn't have ANYTHING defined
-in it, let alone methods. See L<perlobj>.
-
=item Can't call method "%s" on an undefined value
(F) You used the syntax of a method call, but the slot filled by the
(P) For some reason you can't check the filesystem of the script for
nosuid.
-=item Can't coerce array into hash
-
-(F) You used an array where a hash was expected, but the array has no
-information on how to map from keys to array indices. You can do that
-only with arrays that have a hash reference at index 0.
-
-=item Can't coerce %s to integer in %s
+=item Can't coerce %s to %s in %s
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are. So you can't
but then $foo no longer contains a glob.
-=item Can't coerce %s to number in %s
-
-(F) Certain types of SVs, in particular real symbol table entries
-(typeglobs), can't be forced to stop being what they are.
-
-=item Can't coerce %s to string in %s
-
-(F) Certain types of SVs, in particular real symbol table entries
-(typeglobs), can't be forced to stop being what they are.
-
=item Can't "continue" outside a when block
(F) You called C<continue>, but you're not inside a C<when>
(P) An error peculiar to VMS. The process is suffering from exhausted
quotas or other plumbing problems.
-=item Can't declare class for non-scalar %s in "%s"
-
-(F) Currently, only scalar variables can be declared with a specific
-class qualifier in a "my", "our" or "state" declaration. The semantics may be
-extended for other types of variables in future.
-
=item Can't declare %s in "%s"
(F) Only scalar, array, and hash variables may be declared as "my", "our" or
=item Can't find Unicode property definition "%s"
-(F) You may have tried to use C<\p> which means a Unicode property (for
-example C<\p{Lu}> matches all uppercase letters). If you did mean to use a
-Unicode property, see
+(F) You may have tried to use C<\p> which means a Unicode
+property (for example C<\p{Lu}> matches all uppercase
+letters). If you did mean to use a Unicode property, see
L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available properties.
-If you didn't mean to use a Unicode property, escape the C<\p>, either
-by C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, until
-possible C<\E>).
+for a complete list of available properties. If you didn't
+mean to use a Unicode property, escape the C<\p>, either by C<\\p>
+(just the C<\p>) or by C<\Q\p> (the rest of the string, or
+until C<\E>).
=item Can't fork: %s
the stat buffer, so that ACLs and other protections can be taken into
account. Unfortunately, Perl assumes that the stat buffer contains all
the necessary information, and passes it, instead of the filespec, to
-the access checking routine. It will try to retrieve the filespec using
+the access-checking routine. It will try to retrieve the filespec using
the device name and FID present in the stat buffer, but this works only
if you haven't made a subsequent call to the CRTL stat() routine,
because the device name is overwritten with each call. If this warning
-appears, the name lookup failed, and the access checking routine gave up
-and returned FALSE, just to be conservative. (Note: The access checking
+appears, the name lookup failed, and the access-checking routine gave up
+and returned FALSE, just to be conservative. (Note: The access-checking
routine knows about the Perl C<stat> operator and file tests, so you
shouldn't ever see this warning in response to a Perl command; it arises
only if some internal code takes stat buffers lightly.)
=item Can't modify non-lvalue subroutine call
(F) Subroutines meant to be used in lvalue context should be declared as
-such
, see L<perlsub/"Lvalue subroutines">.
+such
. See L<perlsub/"Lvalue subroutines">.
=item Can't msgrcv to read-only var
=item Can't open a reference
(W io) You tried to open a scalar reference for reading or writing,
-using the 3-arg open() syntax :
+using the 3-arg open() syntax:
open FH, '>', $ref;
(F|P) Error resolving overloading specified by a method name (as opposed
to a subroutine reference): no such method callable via the package. If
-method name is C<???>, this is an internal error.
+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) 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.
+
+Note that non-alphabetic ASCII characters are discouraged here as well.
=item Character in 'C' format wrapped in pack
(W io) The dirhandle you tried to close is either closed or not really
a dirhandle. Check your control flow.
+=item Closure prototype called
+
+(F) If a closure has attributes, the subroutine passed to an attribute
+handler is the prototype that is cloned when a new closure is created.
+This subroutine cannot be called.
+
=item Code missing after '/'
(F) You had a (sub-)template that ends with a '/'. There must be another
template code following the slash. See L<perlfunc/pack>.
+=item Code point 0x%X is not Unicode, may not be portable
+
+=item Code point 0x%X is not Unicode, no properties match it; all inverse properties do
+
+(W utf8) You had a code point above the Unicode maximum of U+10FFFF.
+
+Perl allows strings to contain a superset of Unicode code
+points, up to the limit of what is storable in an unsigned integer on
+your system, but these may not be accepted by other languages/systems.
+At one time, it was legal in some standards to have code points up to
+0x7FFF_FFFF, but not higher. Code points above 0xFFFF_FFFF require
+larger than a 32 bit word.
+
+None of the Unicode or Perl-defined properties will match a non-Unicode
+code point. For example,
+
+ chr(0x7FF_FFFF) =~ /\p{Any}/
+
+will not match, because the code point is not in Unicode. But
+
+ chr(0x7FF_FFFF) =~ /\P{Any}/
+
+will match.
+
=item %s: Command not found
(A) You've accidentally run your script through B<csh> instead of Perl.
(P) The regular expression engine got passed a regexp program without a
valid magic number.
-=item Corrupt malloc ptr 0x%lx at 0x%lx
+=item Corrupt malloc ptr 0x%x at 0x%x
(P) The malloc package that comes with Perl had an internal failure.
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
-=item "\c%c" more clearly written simply as "%s"
+=item "\c{" is deprecated and is more clearly written as ";"
+
+(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
+to specify non-printable characters. You used it with a "{" which
+evaluates to ";", which is printable. It is planned to remove the
+ability to specify a semi-colon this way in Perl 5.16. Just use a
+semi-colon or a backslash-semi-colon without the "\c".
-(D deprecated) The C<\cI<X>> construct is intended to be a way to specify
+=item "\c%c" is more clearly written simply as "%s"
+
+(W syntax) The C<\cI<X>> construct is intended to be a way to specify
non-printable characters. You used it for a printable one, which is better
written as simply itself, perhaps preceded by a backslash for non-word
-characters. This message may not remain as Deprecated beyond 5.13.
+characters.
=item Deep recursion on subroutine "%s"
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
-=item gmtime(%.0f) too large
+=item gmtime(%f) too large
(W overflow) You called C<gmtime> with an number that was larger than
it can reliably handle and C<gmtime> probably returned the wrong
date. This warning is also triggered with nan (the special
not-a-number value).
-=item gmtime(%.0f) too small
+=item gmtime(%f) too small
(W overflow) You called C<gmtime> with an number that was smaller than
it can reliably handle and C<gmtime> probably returned the wrong
binary number. Interpretation of the binary number stopped before the
offending digit.
-=item Illegal character %s (carriage return)
+=item Illegal character \%o (carriage return)
(F) Perl normally treats carriage returns in the program text as it
would any other whitespace, which means you should never see this error
=item Invalid %s attribute: %s
-The indicated attribute for a subroutine or variable was not recognized
+(F) The indicated attribute for a subroutine or variable was not recognized
by Perl or by a user-supplied handler. See L<attributes>.
=item Invalid %s attributes: %s
-The indicated attributes for a subroutine or variable were not
+(F) The indicated attributes for a subroutine or variable were not
recognized by Perl or by a user-supplied handler. See L<attributes>.
=item Invalid conversion in %s: "%s"
A "strict" version number is a positive decimal number (integer or
decimal-fraction) without exponentiation or else a dotted-decimal
v-string with a leading 'v' character and at least three components.
-The parenthesized text indicates which criteria was not met.
+The parenthesized text indicates which criteria were not met.
See the L<version> module for more details on allowed version formats.
=item Invalid type '%s' in %s
decimal and dotted-decimal versions may have a trailing "alpha"
component separated by an underscore character after a fractional or
dotted-decimal component. The parenthesized text indicates which
-criteria was not met. See the L<version> module for more details on
+criteria were not met. See the L<version> module for more details on
allowed version formats.
=item Invalid version object
to check the return value of your socket() call? See
L<perlfunc/listen>.
-=item localtime(%.0f) too large
+=item localtime(%f) too large
(W overflow) You called C<localtime> with an number that was larger
than it can reliably handle and C<localtime> probably returned the
wrong date. This warning is also triggered with nan (the special
not-a-number value).
-=item localtime(%.0f) too small
+=item localtime(%f) too small
(W overflow) You called C<localtime> with an number that was smaller
than it can reliably handle and C<localtime> probably returned the
=item lvalue attribute ignored after the subroutine has been defined
(W misc) Making a subroutine an lvalue subroutine after it has been defined
-by declaring the subroutine with a lvalue attribute is not
-possible. To make the the subroutine a lvalue subroutine add the
-lvalue attribute to the definition, or put the the declaration before
+by declaring the subroutine with an lvalue attribute is not
+possible. To make the subroutine an lvalue subroutine add the
+lvalue attribute to the definition, or put the declaration before
the definition.
=item Lvalue subs returning %s not implemented yet
(F) You tried to unpack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
-=item Maximal count of pending signals (%d) exceeded
+=item Maximal count of pending signals (%u) exceeded
(F) Perl aborted due to a too high number of signals pending. This
usually indicates that your operating system tried to deliver signals
=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 Opening dirhandle %s also as a file
-(W io deprecated) You used open() to associate a filehandle to
+(W io, deprecated) You used open() to associate a filehandle to
a symbol (glob or scalar) that already holds a dirhandle.
Although legal, this idiom might render your code confusing
and is deprecated.
=item Opening filehandle %s also as a directory
-(W io deprecated) You used opendir() to associate a dirhandle to
+(W io, deprecated) You used opendir() to associate a dirhandle to
a symbol (glob or scalar) that already holds a filehandle.
Although legal, this idiom might render your code confusing
and is deprecated.
of other handlers, there is no default handler for any operation, unless
C<fallback> overloading key is specified to be true. See L<overload>.
+=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
+
+(W) You performed an operation requiring Unicode semantics on a Unicode
+surrogate. Unicode frowns upon the use of surrogates for anything but
+storing strings in UTF-16, but semantics are (reluctantly) defined for
+the surrogates, and they are to do nothing for this operation. Because
+the use of surrogates can be dangerous, Perl warns.
+
+If the operation shown is "ToFold", it means that case-insensitive
+matching in a regular expression was done on the code point.
+
+If you know what you are doing you can turn off this warning by
+C<no warnings 'utf8';>.
+
+=item Operation "%s" returns its argument for non-Unicode code point 0x%X
+
+(W) You performed an operation requiring Unicode semantics on a code
+point that is not in Unicode, so what it should do is not defined. Perl
+has chosen to have it do nothing, and warn you.
+
+If the operation shown is "ToFold", it means that case-insensitive
+matching in a regular expression was done on the code point.
+
+If you know what you are doing you can turn off this warning by
+C<no warnings 'utf8';>.
+
=item Operator or semicolon missing before %s
(S ambiguous) You used a variable or subroutine call where the parser
some day, even though it doesn't yet. Perhaps you should use a
mixed-case attribute name, instead. See L<attributes>.
+=item \p{} uses Unicode rules, not locale rules
+
+(W) You compiled a regular expression that contained a Unicode property
+match (C<\p> or C<\P>), but the regular expression is also being told to
+use the run-time locale, not Unicode. Instead, use a POSIX character
+class, which should know about the locale's rules.
+(See L<perlrecharclass/POSIX Character Classes>.)
+
+Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of
+Unicode, some properties will give results that are not valid for that
+subset.
+
+Here are a couple of examples to help you see what's going on. If the
+locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK
+CAPITAL LETTER CHI". But in Unicode that code point means the
+"MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode
+meaning. That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]>
+should. Only in the Latin1 locale are all the characters in the same
+positions as they are in Unicode. But, even here, some properties give
+incorrect results. An example is C<\p{Changes_When_Uppercased}> which
+is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper
+case of that character is not in Latin1, in that locale it doesn't
+change when upper cased.
+
=item pack/unpack repeat count overflow
(F) You can't specify a repeat count so large that it overflows your
(P) We popped the context stack to a context with the specified label,
and then discovered it wasn't a context we know how to do a goto in.
+=item panic: gp_free failed to free glob pointer
+
+(P) The internal routine used to clear a typeglob's entries tried
+repeatedly, but each time something re-created entries in the glob. Most
+likely the glob contains an object with a reference back to the glob and a
+destructor that adds a new object to the glob.
+
=item panic: hfreeentries failed to free hash
-(P) The internal routine used to clear a hashes entries tried repeatedly,
+(P) The internal routine used to clear a hash's entries tried repeatedly,
but each time something added more entries to the hash. Most likely the hash
contains an object with a reference back to the hash and a destructor that
adds a new object to the hash.
(W unopened) You tried to read from a filehandle that was never opened.
-=item Reallocation too large: %lx
+=item Reallocation too large: %x
(F) You can't allocate more than 64K on an MS-DOS machine.
<-- 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. For other causes, see
-L<perlre>.
+redundantly specify a default modifier; or having a modifier that can't
+be turned off (such as C<"p"> or C<"l">) after a minus; or specifying
+more than one of the C<"d">, C<"l">, or C<"u"> modifiers. For other
+causes, see L<perlre>.
=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
the regular expression about where the problem was discovered. See
L<perlre>.
-=item 500 Server error
+=item "500 Server error"
See Server error.
=item Server error
-This is the error message generally seen in a browser window when trying
+(A) This is the error message generally seen in a browser window when trying
to run a CGI program (including SSI) over the web. The actual error text
varies widely from server to server. The most frequently-seen variants
are "500 Server error", "Method (something) not permitted", "Document
=item The %s function is unimplemented
-The function indicated isn't implemented on this architecture, according
+(F) The function indicated isn't implemented on this architecture, according
to the probings of Configure.
=item The stat preceding %s wasn't an lstat
%NAME or C<%{EXPR}>. No implicit dereferencing is allowed--use the
{EXPR} forms as an explicit dereference. See L<perlref>.
+=item Type of argument to %s must be hashref or arrayref
+
+(F) You called C<keys>, C<values> or C<each> with an argument that was
+expected to be a reference to a hash or a reference to an array.
+
=item umask not implemented
(F) Your machine doesn't implement the umask function and you tried to
(F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
-=item Unicode non-character %s is illegal for interchange
+=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
Unicode standard to be non-characters. Those are legal codepoints, but are
reserved for internal use; so, applications shouldn't attempt to exchange
-them. In some cases, this message is also given if you use a codepoint that
-isn't in Unicode--that is it is above the legal maximum of U+10FFFF. These
-aren't legal at all in Unicode, so they are illegal for interchange, but can be
-used internally in a Perl program. If you know what you are doing you can turn
+them. If you know what you are doing you can turn
off this warning by C<no warnings 'utf8';>.
=item Unknown BYTEORDER
=item Unknown "re" subpragma '%s' (known ones are: %s)
-You tried to use an unknown subpragma of the "re" pragma.
+(W) You tried to use an unknown subpragma of the "re" pragma.
-=item Unknown switch condition (?(%.2s in regex; marked by <-- HERE in m/%s/
+=item Unknown switch condition (?(%s in regex; marked by <-- HERE in m/%s/
(F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition may be lookahead or lookbehind (the condition
=item Unknown Unicode option letter '%c'
-You specified an unknown Unicode option. See L<perlrun> documentation
+
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
=item Unknown Unicode option value %x
-You specified an unknown Unicode option. See L<perlrun> documentation
+
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
=item Unknown warnings category '%s'
recognized by Perl. The character was understood literally, but this may
change in a future version of Perl.
-=item Unrecognized escape \%c passed through in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%s passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
-recognized by Perl. The character was understood literally, but this may
+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.
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
-=item Use of := for an empty attribute list is deprecated
+=item Use of := for an empty attribute list is not allowed
+
+(F) The construction C<my $x := 42> used to parse as equivalent to
+C<my $x : = 42> (applying an empty attribute list to C<$x>).
+This construct was deprecated in 5.12.0, and has now been made a syntax
+error, so C<:=> can be reclaimed as a new operator in the future.
+
+If you need an empty attribute list, for example in a code generator, add
+a space before the C<=>.
+
+=item Use of ?PATTERN? without explicit operator is deprecated
-(D deprecated) The construction C<my $x := 42> currently
-parses correctly in perl, being equivalent to C<my $x : = 42>
-(applying an empty attribute list to C<$x>). This useless
-construct is now deprecated, so C<:=> can be reclaimed as a new
-operator in the future.
+(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
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=item Use of %s on a handle without * is deprecated
+
+(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that
+scalar happens to hold a typeglob, which means its filehandle will
+be tied. If you mean to tie a handle, use an explicit * as in
+C<tie *$handle>.
+
+This is a long-standing bug that will be removed in Perl 5.16, as
+there is currently no way to tie the scalar itself when it holds
+a typeglob, and no way to untie a scalar that has had a typeglob
+assigned to it.
+
=item Use of -l on filehandle %s
(W io) A filehandle represents an opened file, and when you opened the file
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
either, because you can overload the numification and stringification
-operators and then you assumably know what you are doing.
+operators and then you presumably know what you are doing.
=item Use of reserved word "%s" is deprecated
allow this syntax, but shouldn't have. It is now deprecated, and will be
removed in a future version.
+=item 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.
dots, and each is shown by its ordinal in hex. Anything to the left of the
C<HERE> was retained; anything to the right was discarded.
-=item UTF-16 surrogate %s
+=item Unicode surrogate U+%X is illegal in UTF-8
+
+=item UTF-16 surrogate U+%X
-(W utf8) You tried to generate half of a UTF-16 surrogate by
-requesting a Unicode character between the code points 0xD800 and
-0xDFFF (inclusive). That range is reserved exclusively for the use of
-UTF-16 encoding (by having two 16-bit UCS-2 characters); but Perl
-encodes its characters in UTF-8, so what you got is a very illegal
-character. If you really really know what you are doing you can turn off
-this warning by C<no warnings 'utf8';>.
+(W utf8) You had a UTF-16 surrogate in a context where they are
+not considered acceptable. These code points, between U+D800 and
+U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl
+internally allows all unsigned integer code points (up to the size limit
+available on your platform), including surrogates. But these can cause
+problems when being input or output, which is likely where this message
+came from. If you really really know what you are doing you can turn
+off this warning by C<no warnings 'utf8';>.
=item Value of %s can be "0"; test with defined()
(W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
-=item %s "\x%s" does not map to Unicode
+=item %s "\x%X" does not map to Unicode
-When reading in different encodings Perl tries to map everything
+(F) When reading in different encodings Perl tries to map everything
into Unicode characters. The bytes you read in are not legal in
this encoding, for example
https://perl5.git.perl.org / perl5.git / blobdiff