to check the return value of your socket() call? See
L<perlfunc/accept>.
-=item Allocation too large: %lx
+=item Allocation too large: %x
(X) You can't allocate more than 64K on an MS-DOS machine.
to be an object method (see L<perlsub/"Subroutine Attributes"> or
L<attributes>).
+=item Ambiguous overloaded argument to %s resolved as %s
+
+(W ambiguous) You called C<keys>, C<values> or C<each> on an object that had
+overloading of C<%{}> or C<@{}> or both. In such a case, the object is
+dereferenced according to its overloading, not its underlying reference type.
+The warning is issued when C<%{}> overloading exists on a blessed arrayref,
+when C<@{}> overloading exists on a blessed hashref, or when both overloadings
+are defined (in which case C<%{}> is used). You can force the interpretation
+of the object by explicitly dereferencing it as an array or hash instead of
+passing the object itself to C<keys>, C<values> or C<each>.
+
=item Ambiguous range in transliteration operator
(F) You wrote something like C<tr/a-z-0//> which doesn't mean anything at
you thought. Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, parenthesis pair or declaration.
+=item Ambiguous use of %c resolved as operator %c
+
+(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
+bitwise and, and multiplication) I<and> initial special characters
+(denoting hashes, subroutines and typeglobs), and you said something
+like C<*foo * foo> that might be interpreted as either of them. We
+assumed you meant the infix operator, but please try to make it more
+clear -- in the example given, you might write C<*foo * foo()> if you
+really meant to multiply a glob by the result of calling a function.
+
+=item Ambiguous use of %c{%s} resolved to %c%s
+
+(W ambiguous) You wrote something like C<@{foo}>, which might be
+asking for the variable C<@foo>, or it might be calling a function
+named foo, and dereferencing it as an array reference. If you wanted
+the varable, you can just write C<@foo>. If you wanted to call the
+function, write C<@{foo()}> ... or you could just not have a variable
+and a function with the same name, and save yourself a lot of trouble.
+
+=item Ambiguous use of %c{%s%s} resolved to %c%s%s
+
+(W ambiguous) You wrote something like C<${foo[2]}> (where foo
+represents the name of a Perl keyword), which might be looking for
+element number 2 of the array named C<@foo>, in which case please write
+C<$foo[2]>, or you might have meant to pass an anonymous arrayref to
+the function named foo, and then do a scalar deref on the value it
+returns. If you meant that, write C<${foo([2])}>.
+
+In regular expressions, the C<${foo[2]}> syntax is sometimes necessary
+to disambiguate between array subscripts and character classes.
+C</$length[2345]/>, for instance, will be interpreted as C<$length>
+followed by the character class C<[2345]>. If an array subscript is what
+you want, you can avoid the warning by changing C</${length[2345]}/>
+to the unsightly C</${\$length[2345]}/>, by renaming your array to
+something that does not coincide with a built-in keyword, or by
+simply turning off warnings with C<no warnings 'ambiguous';>.
+
+=item Ambiguous use of -%s resolved as -&%s()
+
+(W ambiguous) You wrote something like C<-foo>, which might be the
+string C<"-foo">, or a call to the function C<foo>, negated. If you meant
+the string, just write C<"-foo">. If you meant the function call,
+write C<-foo()>.
+
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
(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
had no effect since Perl 5.8.8, and will be removed in the next major
release of Perl 5.
-=item Bad arg length for %s, is %d, should be %d
+=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,
For example you cannot force little-endianness on a type that
is inside a big-endian group.
-=item Can't use keyword '%s' as a label
-
-(F) You attempted to use a reserved keyword, such as C<print> or C<BEGIN>,
-as a statement label. This is disallowed since Perl 5.11.0.
-
=item Can't use "my %s" in sort comparison
(F) The global variables $a and $b are reserved for sort comparisons.
with an assignment operator, which implies modifying the value itself.
Perhaps you need to copy the value to a temporary, and repeat that.
+=item Character following "\c" must be ASCII
+
+(F|W deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
+It is planned to make this fatal in all instances in Perl 5.16. In the
+cases where it isn't fatal, the character this evaluates to is
+derived by exclusive or'ing the code point of this character with 0x40.
+
+Note that non-alphabetic ASCII characters are discouraged here as well.
+
=item Character in 'C' format wrapped in pack
(W pack) You said
(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{" is deprecated and is more clearly written as ";"
+
+(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
+to specify non-printable characters. You used it with a "{" which
+evaluates to ";", which is printable. It is planned to remove the
+ability to specify a semi-colon this way in Perl 5.16. Just use a
+semi-colon or a backslash-semi-colon without the "\c".
+
+=item "\c%c" is more clearly written simply as "%s"
+
+(W syntax) The C<\cI<X>> construct is intended to be a way to specify
+non-printable characters. You used it for a printable one, which is better
+written as simply itself, perhaps preceded by a backslash for non-word
+characters.
+
=item Deep recursion on subroutine "%s"
(W recursion) This subroutine has called itself (directly or indirectly)
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
-=item Deprecated character(s) in \\N{...} starting at '%s'
+=item Deprecated character in \N{...}; marked by <-- HERE in \N{%s<-- HERE %s
(D deprecated) Just about anything is legal for the C<...> in C<\N{...}>.
But starting in 5.12, non-reasonable ones that don't look like names are
=item (Did you mean &%s instead?)
-(W) You probably referred to an imported subroutine &FOO as $FOO or some
-such.
+(W misc) You probably referred to an imported subroutine &FOO as $FOO or
+some such.
=item (Did you mean "local" instead of "our"?)
"-", "\-". The <-- HERE shows in the regular expression about where the
problem was discovered. See L<perlre>.
-=item Fatal VMS error at %s, line %d
+=item Fatal VMS error (status=%d) at %s, line %d
(P) An error peculiar to VMS. Something untoward happened in a VMS
system service or RTL routine; Perl's exit status should provide more
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
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
+=item Having no space between pattern and following word is deprecated
+
+(D syntax)
+
+You had a word that isn't a regex modifier immediately following a pattern
+without an intervening space. For example, the two constructs:
+
+ $a =~ m/$foo/sand $bar
+ $a =~ m/$foo/s and $bar
+
+both currently mean the same thing, but it is planned to disallow the first form
+in Perl 5.16. And,
+
+ $a =~ m/$foo/and $bar
+
+will be disallowed too.
+
=item Hexadecimal number > 0xffffffff non-portable
(W portable) The hexadecimal number you specified is larger than 2**32-1
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"
If the previous attribute had a parenthesised parameter list, perhaps that
list was terminated too soon.
+=item Invalid strict version format (%s)
+
+(F) A version number did not meet the "strict" criteria for versions.
+A "strict" version number is a positive decimal number (integer or
+decimal-fraction) without exponentiation or else a dotted-decimal
+v-string with a leading 'v' character and at least three components.
+The parenthesized text indicates which criteria were not met.
+See the L<version> module for more details on allowed version formats.
+
=item Invalid type '%s' in %s
(F) The given character is not a valid pack or unpack type.
(W) The given character is not a valid pack or unpack type but used to be
silently ignored.
-=item Invalid version format (multiple underscores)
+=item Invalid version format (%s)
-(F) Versions may contain at most a single underscore, which signals
-that the version is a beta release. See L<version> for the allowed
-version formats.
+(F) A version number did not meet the "lax" criteria for versions.
+A "lax" version number is a positive decimal number (integer or
+decimal-fraction) without exponentiation or else a dotted-decimal
+v-string. If the v-string has less than three components, it must have a
+leading 'v' character. Otherwise, the leading 'v' is optional. Both
+decimal and dotted-decimal versions may have a trailing "alpha"
+component separated by an underscore character after a fractional or
+dotted-decimal component. The parenthesized text indicates which
+criteria were not met. See the L<version> module for more details on
+allowed version formats.
-=item Invalid version format (underscores before decimal)
+=item Invalid version object
-(F) Versions may not contain decimals after the optional underscore.
-See L<version> for the allowed version formats.
+(F) The internal structure of the version object was invalid. Perhaps
+the internals were modified directly in some way or an arbitrary reference
+was blessed into the "version" class.
=item ioctl is not implemented
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
This modifier does not change the requirement that the brace immediately follow
the C<\N>.
+=item Missing braces on \o{}
+
+(F) A C<\o> must be followed immediately by a C<{> in double-quotish context.
+
=item Missing comma after first argument to %s function
(F) While certain functions allow you to specify a filehandle or an
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
-=item Missing right brace on \\N{} or unescaped left brace after \\N
+=item Missing right brace on \N{} or unescaped left brace after \N
(F)
C<\N> has two meanings.
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
-=item \\N in a character class must be a named character: \\N{...}
+=item \N in a character class must be a named character: \N{...}
(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed
character class, for the same reason that C<.> in a character class loses its
specialness: it matches almost everything, which is probably not what you want.
-=item \\N{NAME} must be resolved by the lexer
+=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,
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+...}
+=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
(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
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
+=item Non-octal character '%c'. Resolved as "%s"
+
+(W digit) In parsing an octal numeric constant, a character was unexpectedly
+encountered that isn't octal. The resulting value is as indicated.
+
=item Non-string passed as bitmask
(W misc) A number has been passed as a bitmask argument to select().
the meantime, try using scientific notation (e.g. "1e6" instead of
"1_000_000").
+=item Number with no digits
+
+(F) Perl was looking for a number but found nothing that looked like a number.
+This happens, for example with C<\o{}>, with no number between the braces.
+
=item Octal number in vector unsupported
(F) Numbers with a leading C<0> are not currently allowed in vectors.
=item Offset outside string
-(F, W layer) You tried to do a read/write/send/recv/seek operation
+(F|W layer) You tried to do a read/write/send/recv/seek operation
with an offset pointing outside the buffer. This is difficult to
imagine. The sole 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.
(P) The lexer got into a bad state while processing a case modifier.
+=item Parsing code internal error (%s)
+
+(F) Parsing code supplied by an extension violated the parser's API in
+a detectable way.
+
=item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
(F) You used a pattern that uses too many nested subpattern calls without
conversion functions. This is only a problem when you're using the
'<' or '>' modifiers in (un)pack templates. See L<perlfunc/pack>.
-=item Perl_pmflag() is deprecated, and will be removed from the XS API
-
-(D deprecated) XS code called the C function C<Perl_pmflag>. This was part of
-Perl's listed public API for extending or embedding the perl interpreter. It has
-now been removed from the public API, and will be removed in a future release,
-hence XS code should be re-written not to use it.
-
=item Perl %s required--this is only version %s, stopped
(F) The module in question uses features of a version of Perl more
(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.
(F) You used something like C<\7> in your regular expression, but there are
not at least seven sets of capturing parentheses in the expression. If you
-wanted to have the character with value 7 inserted into the regular expression,
-prepend a zero to make the number at least two digits: C<\07>
+wanted to have the character with ordinal 7 inserted into the regular expression,
+prepend zeroes to make it three digits long: C<\007>
The <-- HERE shows in the regular expression about where the problem was
discovered.
(F) You used a regular expression extension that doesn't make sense. The
<-- HERE shows in the regular expression about where the problem was
-discovered. See L<perlre>.
+discovered. This happens when using the C<(?^...)> construct to tell
+Perl to use the default regular expression modifiers, and you
+redundantly specify a default modifier; or having a modifier that can't
+be turned off (such as C<"p"> or C<"l">) after a minus; or specifying
+more than one of the C<"d">, C<"l">, or C<"u"> modifiers. For other
+causes, see L<perlre>.
-=item Sequence \\%s... not terminated in regex; marked by <-- HERE in m/%s/
+=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
(F) The regular expression expects a mandatory argument following the escape
sequence and this has been omitted or incorrectly written.
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'
in your Perl script (or eval) near the specified column. Perhaps you tried
to run a compressed script, a binary program, or a directory as a Perl program.
-=item Unrecognized escape \\%c in character class passed through in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%c in character class passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl inside character classes. The character was
The <-- HERE shows in the regular expression about where the
escape was discovered.
-=item Unrecognized escape \\%c passed through
+=item Unrecognized escape \%c passed through
(W misc) You used a backslash-character combination which is not
recognized by Perl. 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 \%c passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl. The character was understood literally, but this may
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
+=item Use of := for an empty attribute list is not allowed
+
+(F) The construction C<my $x := 42> used to parse as equivalent to
+C<my $x : = 42> (applying an empty attribute list to C<$x>).
+This construct was deprecated in 5.12.0, and has now been made a syntax
+error, so C<:=> can be reclaimed as a new operator in the future.
+
+If you need an empty attribute list, for example in a code generator, add
+a space before the C<=>.
+
+=item Use of ?PATTERN? without explicit operator is deprecated
+
+(D deprecated) You have written something like C<?\w?>, for a regular
+expression that matches only once. Starting this term directly with
+the question mark delimiter is now deprecated, so that the question mark
+will be available for use in new operators in the future. Write C<m?\w?>
+instead, explicitly using the C<m> operator: the question mark delimiter
+still invokes match-once behaviour.
+
=item Use of freed value in iteration
(F) Perhaps you modified the iterated array within the loop?
you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
C<use AutoLoader 'AUTOLOAD';>.
-=item Use of octal value above 377 is deprecated
-
-(D deprecated, W regexp) There is a constant in the regular expression whose
-value is interpeted by Perl as octal and larger than 377 (255 decimal, 0xFF
-hex). Perl may take this to mean different things depending on the rest of
-the regular expression. If you meant such an octal value, convert it to
-hexadecimal and use C<\xHH> or C<\x{HH}> instead. If you meant to have
-part of it mean a backreference, use C<\g> for that. See L<perlre>.
-
=item Use of %s in printf format not supported
(F) You attempted to use a feature of printf that is accessible from
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=item Use of %s on a handle without * is deprecated
+
+(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that
+scalar happens to hold a typeglob, which means its filehandle will
+be tied. If you mean to tie a handle, use an explicit * as in
+C<tie *$handle>.
+
+This is a long-standing bug that will be removed in Perl 5.16, as
+there is currently no way to tie the scalar itself when it holds
+a typeglob, and no way to untie a scalar that has had a typeglob
+assigned to it.
+
=item Use of -l on filehandle %s
(W io) A filehandle represents an opened file, and when you opened the file
otherwise reasonable constructs to fail in baffling ways. C<use strict;>
instead.
+=item Use of qw(...) as parentheses is deprecated
+
+(D deprecated) You have something like C<foreach $x qw(a b c) {...}>,
+using a C<qw(...)> list literal where a parenthesised expression is
+expected. Historically the parser fooled itself into thinking that
+C<qw(...)> literals were always enclosed in parentheses, and as a result
+you could sometimes omit parentheses around them. (You could never do
+the C<foreach qw(a b c) {...}> that you might have expected, though.)
+The parser no longer lies to itself in this way. Wrap the list literal
+in parentheses, like C<foreach $x (qw(a b c)) {...}>.
+
=item Use of reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
either, because you can overload the numification and stringification
-operators and then you 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
-(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';>.
+=item UTF-16 surrogate U+%X
+
+(W utf8) You had a UTF-16 surrogate in a context where they are
+not considered acceptable. These code points, between U+D800 and
+U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl
+internally allows all unsigned integer code points (up to the size limit
+available on your platform), including surrogates. But these can cause
+problems when being input or output, which is likely where this message
+came from. If you really really know what you are doing you can turn
+off this warning by C<no warnings 'utf8';>.
=item Value of %s can be "0"; test with defined()
=item Variable "%s" is not imported%s
-(F) While "use strict" in effect, you referred to a global variable that
-you apparently thought was imported from another module, because
+(W misc) With "use strict" in effect, you referred to a global variable
+that you apparently thought was imported from another module, because
something else of the same name (usually a subroutine) is exported by
that module. It usually means you put the wrong funny character on the
front of your variable.
(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