C</^[a-zA-Z]*[0-9]*\z/>. See L<perlop/Auto-increment and
Auto-decrement> for details.
-=item Array @%s missing the @ in argument %d of %s()
-
-(D deprecated) Really old Perl let you omit the @ on array names in some
-spots. This is now heavily deprecated.
-
-=item A sequence of multiple spaces in a charnames alias definition is deprecated
-
-(D deprecated) You defined a character name which had multiple space
-characters in a row. Change them to single spaces. Usually these
-names are defined in the C<:alias> import argument to C<use charnames>, but
-they could be defined by a translator installed into C<$^H{charnames}>.
-See L<charnames/CUSTOM ALIASES>.
-
=item assertion botched: %s
(X) The malloc package that comes with Perl had an internal failure.
(X) A general assertion failed. The file in question must be examined.
+=item Assigned value is not a reference
+
+(F) You tried to assign something that was not a reference to an lvalue
+reference (e.g., C<\$x = $y>). If you meant to make $x an alias to $y, use
+C<\$x = \$y>.
+
+=item Assigned value is not %s reference
+
+(F) You tried to assign a reference to an lvalue reference, but the two
+references were not of the same type. You cannot alias a scalar to an
+array, or an array to a hash; the two types must match.
+
+ \$x = \@y; # error
+ \@x = \%y; # error
+ $y = [];
+ \$x = $y; # error; did you mean \$y?
+
=item Assigning non-zero to $[ is no longer possible
(F) When the "array_base" feature is disabled (e.g., under C<use v5.16;>)
must either both be scalars or both be lists. Otherwise Perl won't
know which context to supply to the right side.
+=item <> at require-statement should be quotes
+
+(F) You wrote C<< require <file> >> when you should have written
+C<require 'file'>.
+
=item Attempt to access disallowed key '%s' in a restricted hash
(F) The failing code has attempted to get or set a key which is not in
(W unopened) You tried binmode() on a filehandle that was never opened.
Check your control flow and number of arguments.
-=item "\b{" is deprecated; use "\b\{" or "\b[{]" instead in regex; marked
-by S<<-- HERE> in m/%s/
-
-=item "\B{" is deprecated; use "\B\{" or "\B[{]" instead in regex; marked
-by S<<-- HERE> in m/%s/
-
-(D deprecated) 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. You can either precede the brace
-with a backslash, or enclose it in square brackets; the latter
-is the way to go if the pattern delimiters are C<{}>.
-
=item Bit vector size > 32 non-portable
(W portable) Using bit vector sizes larger than 32 is non-portable.
function correctly, you may put an ampersand before the name to avoid
the warning. See L<perlsub>.
+=item Calling POSIX::%s() is deprecated
+
+(D deprecated) You called a function whose use is deprecated. See
+the function's name in L<POSIX> for details.
+
+=item Cannot chr %f
+
+(F) You passed an invalid number (like an infinity or not-a-number) to C<chr>.
+
+=item Cannot compress %f in pack
+
+(F) You tried compressing an infinity or not-a-number as an unsigned
+integer with BER, which makes no sense.
+
=item Cannot compress integer in pack
-(F) An argument to pack("w",...) was too large to compress. The BER
-compressed integer format can only be used with positive integers, and you
-attempted to compress Infinity or a very large number (> 1e308).
+(F) An argument to pack("w",...) was too large to compress.
+The BER compressed integer format can only be used with positive
+integers, and you attempted to compress a very large number (> 1e308).
See L<perlfunc/pack>.
=item Cannot compress negative numbers in pack
(S io) You tried to apply an encoding that did not exist to a filehandle,
either with open() or binmode().
+=item Cannot pack %f with '%c'
+
+(F) You tried converting an infinity or not-a-number to an integer,
+which makes no sense.
+
+=item Cannot printf %f with '%c'
+
+(F) You tried printing an infinity or not-a-number as a character (%c),
+which makes no sense. Maybe you meant '%s', or just stringifying it?
+
=item Cannot set tied @DB::args
(F) C<caller> tried to set C<@DB::args>, but found it tied. Tying C<@DB::args>
functioning as a class, but that package doesn't define that particular
method, nor does any of its base classes. See L<perlobj>.
+=item Can't locate object method "%s" via package "%s" (perhaps you forgot
+to load "%s"?)
+
+(F) You called a method on a class that did not exist, and the method
+could not be found in UNIVERSAL. This often means that a method
+requires a package that has not been loaded.
+
=item Can't locate package %s for @%s::ISA
(W syntax) The @ISA array contained the name of another package that
though, because the inner curlies will be considered a block that loops
once. See L<perlfunc/next>.
-=item Can't open %s
-
-(F) You tried to run a perl built with MAD support with
-the PERL_XMLDUMP environment variable set, but the file
-named by that variable could not be opened.
-
=item Can't open %s: %s
(S inplace) The implicit opening of a file through use of the C<< <> >>
(F) You tried to call perl with the B<-m> switch, but you put something
other than "=" after the module name.
+=item Can't use a hash as a reference
+
+(F) You tried to use a hash as a reference, as in
+C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl
+<= 5.22.0 used to allow this syntax, but shouldn't
+have. This was deprecated in perl 5.6.1.
+
+=item Can't use an array as a reference
+
+(F) You tried to use an array as a reference, as in
+C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.22.0
+used to allow this syntax, but shouldn't have. This
+was deprecated in perl 5.6.1.
+
=item Can't use anonymous symbol table for method lookup
(F) The internal routine that does method lookup was handed a symbol
byte-order at the same time, so this combination of modifiers is not
allowed. See L<perlfunc/pack>.
+=item Can't use 'defined(@array)' (Maybe you should just omit the defined()?)
+
+(F) defined() is not useful on arrays because it
+checks for an undefined I<scalar> value. If you want to see if the
+array is empty, just use C<if (@array) { # not empty }> for example.
+
+=item Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)
+
+(F) C<defined()> is not usually right on hashes.
+
+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, so it now
+generates a fatal error.
+
+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 Can't use %s for loop variable
(F) Only a simple scalar variable may be used as a loop variable on a
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
+=item Character following "\c" must be printable ASCII
-(F)(D 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 v5.20. 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.
+(F) In C<\cI<X>>, I<X> must be a printable (non-control) ASCII character.
-Note that non-alphabetic ASCII characters are discouraged here as well,
-and using non-printable ones will be deprecated starting in v5.18.
+Note that ASCII characters that don't map to control characters are
+discouraged, and will generate the warning (when enabled)
+L</""\c%c" is more clearly written simply as "%s"">.
=item Character in 'C' format wrapped in pack
unpack("s", "\x{f3}b")
-=item "\c{" is deprecated and is more clearly written as ";"
+=item charnames alias definitions may not contain a sequence of multiple spaces
+
+(F) You defined a character name which had multiple space characters
+in a row. Change them to single spaces. Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>. See
+L<charnames/CUSTOM ALIASES>.
+
+=item charnames alias definitions may not contain trailing white-space
+
+(F) You defined a character name which ended in a space
+character. Remove the trailing space(s). Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>.
+See L<charnames/CUSTOM ALIASES>.
+
+=item \C is deprecated in regex; marked by <-- HERE in m/%s/
-(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.20. Just use a
-semi-colon or a backslash-semi-colon without the "\c".
+(D deprecated, regexp) The \C character class is deprecated, and will
+become a compile-time error in a future release of perl (tentatively
+v5.24). This construct allows you to match a single byte of what makes
+up a multi-byte single UTF8 character, and breaks encapsulation. It is
+currently also very buggy. If you really need to process the individual
+bytes, you probably want to convert your string to one where each
+underlying byte is stored as a character, with utf8::encode().
=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.
+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. Doing it the way you did is not portable
+between ASCII and EBCDIC platforms.
=item Cloning substitution context is unimplemented
(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, all \p{} matches fail; all \P{} matches
-succeed
-
=item Code point 0x%X is not Unicode, may not be portable
-(S utf8, non_unicode) You had a code point above the Unicode maximum
+(S 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
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.
-
-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> or another shell
-shell instead of Perl. Check the #! line, or manually feed your script
-into Perl yourself. The #! line at the top of your file could look like
+instead of Perl. Check the #! line, or manually feed your script into
+Perl yourself. The #! line at the top of your file could look like
#!/usr/bin/perl -w
(F) The parser found inconsistencies while attempting to define an
overloaded constant. Perhaps you forgot to load the corresponding
-L<overload> pragma?.
+L<overload> pragma?
=item Constant is not %s reference
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
+=for comment
+The following are used in lib/diagnostics.t for testing two =items that
+share the same description. Changes here need to be propagated to there
+
=item Deep recursion on anonymous subroutine
=item Deep recursion on subroutine "%s"
This threshold can be changed from 100, by recompiling the F<perl> binary,
setting the C pre-processor macro C<PERL_SUB_DEPTH_WARN> to the desired value.
-=item defined(@array) is deprecated
-
-(D deprecated) defined() is not usually useful on arrays because it
-checks for an undefined I<scalar> value. If you want to see if the
-array is empty, just use C<if (@array) { # not empty }> for example.
-
-=item defined(%hash) is deprecated
-
-(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
S<<-- HERE> in m/%s/
{ my $x; sub f { return $x++ } }
-Beginning with perl 5.9.4, you can also use C<state> variables to have
+Beginning with perl 5.10.0, you can also use C<state> variables to have
lexicals that are initialized only once (see L<feature>):
sub f { state $x; return $x++ }
(W unpack) You have applied the same modifier more than once after a
type in a pack template. See L<perlfunc/pack>.
+=item each on reference is experimental
+
+(S experimental::autoderef) C<each> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item elseif should be elsif
(S syntax) There is no keyword "elseif" in Perl because Larry thinks
an invalid file specification to Perl, or you've found a case the
conversion routines don't handle. Drat.
-=item Escape literal pattern white space under /x
-
-(D deprecated) You compiled a regular expression pattern with C</x> to
-ignore white space, and you used, as a literal, one of the characters
-that Perl plans to eventually treat as white space. The character must
-be escaped somehow, or it will work differently on a future Perl that
-does treat it as white space. The easiest way is to insert a backslash
-immediately before it, or to enclose it with square brackets. This
-change is to bring Perl into conformance with Unicode recommendations.
-Here are the five characters that generate this warning:
-U+0085 NEXT LINE,
-U+200E LEFT-TO-RIGHT MARK,
-U+200F RIGHT-TO-LEFT MARK,
-U+2028 LINE SEPARATOR,
-and
-U+2029 PARAGRAPH SEPARATOR.
-
=item Eval-group in insecure regular expression
(F) Perl detected tainted data when trying to compile a regular
have some other C<(?...)> construct inside your character class. See
L<perlrecharclass/Extended Bracketed Character Classes>.
+=item Experimental lvalue references not enabled
+
+(F) To use lvalue references, you must first enable them:
+
+ no warnings "experimental::lvalue_refs";
+ use feature "lvalue_refs";
+ \$x = \$y;
+
+=item Experimental subroutine signatures not enabled
+
+(F) To use subroutine signatures, you must first enable them:
+
+ no warnings "experimental::signatures";
+ use feature "signatures";
+ sub foo ($left, $right) { ... }
+
=item Experimental "%s" subs not enabled
(F) To use lexical subs, you must first enable them:
in any future release of perl. See the explanation under
L<perlsyn/Experimental Details on given and when>.
-=item Global symbol "%s" requires explicit package name
+=item Global symbol "%s" requires explicit package name (did you forget to
+declare "my %s"?)
(F) You've said "use strict" or "use strict vars", which indicates
that all variables must either be lexically scoped (using "my" or "state"),
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=item gmtime(%f) failed
+
+(W overflow) You called C<gmtime> with a number that it could not handle:
+too large, too small, or NaN. The returned value is C<undef>.
+
=item gmtime(%f) too large
(W overflow) You called C<gmtime> with a number that was larger than
to have existed already, but for some reason it didn't, and had to be
created on an emergency basis to prevent a core dump.
-=item Hash %%s missing the % in argument %d of %s()
-
-(D deprecated) Really old Perl let you omit the % on hash names in some
-spots. This is now heavily deprecated.
-
=item %s has too many errors
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
+=item Having more than one /%c regexp modifier is deprecated
+
+(D deprecated, regexp) You used the indicated regular expression pattern
+modifier at least twice in a string of modifiers. It is deprecated to
+do this with this particular modifier, to allow future extensions to the
+Perl language.
+
+=item Hexadecimal float: exponent overflow
+
+(W overflow) The hexadecimal floating point has a larger exponent
+than the floating point supports.
+
+=item Hexadecimal float: exponent underflow
+
+(W overflow) The hexadecimal floating point has a smaller exponent
+than the floating point supports.
+
+=item Hexadecimal float: internal error
+
+(F) Something went horribly bad in hexadecimal float handling.
+
+=item Hexadecimal float: mantissa overflow
+
+(W overflow) The hexadecimal floating point literal had more bits in
+the mantissa (the part between the 0x and the exponent, also known as
+the fraction or the significand) than the floating point supports.
+
+=item Hexadecimal float: precision loss
+
+(W overflow) The hexadecimal floating point had internally more
+digits than could be output. This can be caused by unsupported
+long double formats, or by 64-bit integers not being available
+(needed to retrieve the digits under some configurations).
+
+=item Hexadecimal float: unsupported long double format
+
+(F) You have configured Perl to use long doubles but
+the internals of the long double format are unknown;
+therefore the hexadecimal float output is impossible.
+
=item Hexadecimal number > 0xffffffff non-portable
(W portable) The hexadecimal number you specified is larger than 2**32-1
=item Ignoring zero length \N{} in character class in regex; marked by
S<<-- HERE> in m/%s/
-(W regexp) Named Unicode character escapes C<(\N{...})> may return a
+(W regexp) Named Unicode character escapes (C<\N{...}>) may return a
zero-length sequence. When such an escape is used in a character class
its behaviour is not well defined. Check that the correct escape has
been used, and the correct charname handler is in scope.
(W illegalproto) An illegal character was found in a prototype declaration.
Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
+Perhaps you were trying to write a subroutine signature but didn't enable
+that feature first (C<use feature 'signatures'>), so your signature was
+instead interpreted as a bad prototype.
=item Illegal declaration of anonymous subroutine
capturing group. See
L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>.
+=item Illegal suidscript
+
+(F) The script run under suidperl was somehow illegal.
+
=item Illegal switch in PERL5OPT: -%c
(X) The PERL5OPT environment variable may only be used to set the
function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
-=item In '(?...)', splitting the initial '(?' is deprecated in regex;
-marked by S<<-- HERE> in m/%s/
-
-(D regexp, deprecated) The two-character sequence C<"(?"> in
-this context in a regular expression pattern should be an
-indivisible token, with nothing intervening between the C<"(">
-and the C<"?">, but you separated them. Due to an accident of
-implementation, this prohibition was not enforced, but we do
-plan to forbid it in a future Perl version. This message
-serves as giving you fair warning of this pending change.
-
=item Integer overflow in format string for %s
(F) The indexes and widths specified in the format string of C<printf()>
operators arguments found inside the parentheses. See
L<perlop/Terms and List Operators (Leftward)>.
+=item In '(?...)', the '(' and '?' must be adjacent in regex;
+marked by S<<-- HERE> in m/%s/
+
+(F) The two-character sequence C<"(?"> in this context in a regular
+expression pattern should be an indivisible token, with nothing
+intervening between the C<"("> and the C<"?">, but you separated them
+with whitespace.
+
=item Invalid %s attribute: %s
(F) The indicated attribute for a subroutine or variable was not recognized
=item Invalid escape in the specified encoding in regex; marked by
S<<-- HERE> in m/%s/
-(W regexp) The numeric escape (for example C<\xHH>) of value < 256
+(W regexp)(F) The numeric escape (for example C<\xHH>) of value < 256
didn't correspond to a single character through the conversion
from the encoding specified by the encoding pragma.
-The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead.
+The escape was replaced with REPLACEMENT CHARACTER (U+FFFD)
+instead, except within S<C<(?[ ])>>, where it is a fatal error.
The S<<-- HERE> shows whereabouts in the regular expression the
escape was discovered.
=item Invalid negative number (%s) in chr
(W utf8) You passed a negative number to C<chr>. Negative numbers are
-not valid characters numbers, so it return the Unicode replacement
+not valid character numbers, so it returns the Unicode replacement
character (U+FFFD).
=item invalid option -D%c, use -D'' to see choices
Perhaps the internals were modified directly in some way or
an arbitrary reference was blessed into the "version" class.
-=item In '(*VERB...)', splitting the initial '(*' is deprecated in regex;
+=item In '(*VERB...)', the '(' and '*' must be adjacent in regex;
marked by S<<-- HERE> in m/%s/
-(D regexp, deprecated) The two-character sequence C<"(*"> in
+(F) The two-character sequence C<"(*"> in
this context in a regular expression pattern should be an
indivisible token, with nothing intervening between the C<"(">
-and the C<"*">, but you separated them. Due to an accident of
-implementation, this prohibition was not enforced, but we do
-plan to forbid it in a future Perl version. This message
-serves as giving you fair warning of this pending change.
+and the C<"*">, but you separated them.
=item ioctl is not implemented
=item $* is no longer supported
(D deprecated, syntax) The special variable C<$*>, deprecated in older
-perls, has been removed as of 5.9.0 and is no longer supported. In
+perls, has been removed as of 5.10.0 and is no longer supported. In
previous versions of perl the use of C<$*> enabled or disabled multi-line
matching within a string.
=item $# is no longer supported
(D deprecated, syntax) The special variable C<$#>, deprecated in older
-perls, has been removed as of 5.9.3 and is no longer supported. You
+perls, has been removed as of 5.10.0 and is no longer supported. You
should use the printf/sprintf functions instead.
=item '%s' is not a code reference
(P) The regular expression parser is confused.
+=item keys on reference is experimental
+
+(S experimental::autoderef) C<keys> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Label not found for "last %s"
(F) You named a loop to break out of, but you're not currently in a loop
form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>.
Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead.
+=item localtime(%f) failed
+
+(W overflow) You called C<localtime> with a number that it could not handle:
+too large, too small, or NaN. The returned value is C<undef>.
+
=item localtime(%f) too large
(W overflow) You called C<localtime> with a number that was larger
See also L<attributes.pm|attributes>.
+=item Lvalue references are experimental
+
+(S experimental::lvalue_refs) This warning is emitted if you use
+a reference constructor on the left-hand side of an assignment to
+alias one variable to another. Simply suppress the warning if you
+want to use the feature, but know that in doing so you are taking
+the risk of using an experimental feature which may change or be
+removed in a future Perl version:
+
+ no warnings "experimental::lvalue_refs";
+ use feature "lvalue_refs";
+ \$x = \$y;
+
=item Magical list constants are not supported
(F) You assigned a magical array to a stash element, and then tried
syntax of function prototypes is given a brief compile-time check for
obvious errors like invalid characters. A more rigorous check is run
when the function is called.
+Perhaps the function's author was trying to write a subroutine signature
+but didn't enable that feature first (C<use feature 'signatures'>),
+so the signature was instead interpreted as a bad prototype.
=item Malformed UTF-8 character (%s)
(F) Perl thought it was reading UTF-16 encoded character data but while
doing it Perl met a malformed Unicode surrogate.
+=item Mandatory parameter follows optional parameter
+
+(F) In a subroutine signature, you wrote something like "$a = undef,
+$b", making an earlier parameter optional and a later one mandatory.
+Parameters are filled from left to right, so it's impossible for the
+caller to omit an earlier one and pass a later one. If you want to act
+as if the parameters are filled from right to left, declare the rightmost
+optional and then shuffle the parameters around in the subroutine's body.
+
+=item Matched non-Unicode code point 0x%X against Unicode property; may
+not be portable
+
+(S non_unicode) Perl allows strings to contain a superset of
+Unicode code points; each code point may be as large as what is storable
+in an unsigned integer on your system, but these may not be accepted by
+other languages/systems. This message occurs when you matched a string
+containing such a code point against a regular expression pattern, and
+the code point was matched against a Unicode property, C<\p{...}> or
+C<\P{...}>. Unicode properties are only defined on Unicode code points,
+so the result of this match is undefined by Unicode, but Perl (starting
+in v5.20) treats non-Unicode code points as if they were typical
+unassigned Unicode ones, and matched this one accordingly. Whether a
+given property matches these code points or not is specified in
+L<perluniprops/Properties accessible through \p{} and \P{}>.
+
+This message is suppressed (unless it has been made fatal) if it is
+immaterial to the results of the match if the code point is Unicode or
+not. For example, the property C<\p{ASCII_Hex_Digit}> only can match
+the 22 characters C<[0-9A-Fa-f]>, so obviously all other code points,
+Unicode or not, won't match it. (And C<\P{ASCII_Hex_Digit}> will match
+every code point except these 22.)
+
+Getting this message indicates that the outcome of the match arguably
+should have been the opposite of what actually happened. If you think
+that is the case, you may wish to make the C<non_unicode> warnings
+category fatal; if you agree with Perl's decision, you may wish to turn
+off this category.
+
+See L<perlunicode/Beyond Unicode code points> for more information.
+
=item %s matches null string many times in regex; marked by S<<-- HERE> in
m/%s/
=item Missing argument in %s
-(W uninitialized) A printf-type format required more arguments than were
-supplied.
+(W missing) You called a function with fewer arguments than other
+arguments you supplied indicated would be needed.
+
+Currently only emitted when a printf-type format required more
+arguments than were supplied, but might be used in the future for
+other cases where we can statically determine that arguments to
+functions are missing, e.g. for the L<perlfunc/pack> function.
=item Missing argument to -%c
(S syntax) This is an educated guess made in conjunction with the message
"%s found where operator expected". Often the missing operator is a comma.
+=item Missing or undefined argument to require
+
+(F) You tried to call require with no argument or with an undefined
+value as an argument. Require expects either a package name or a
+file-specification as an argument. See L<perlfunc/require>.
+
=item Missing right brace on \%c{} in regex; marked by S<<-- HERE> in m/%s/
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
list of arguments, but have forgotten to specify a piped open mode.
See L<perlfunc/open> for details.
+=item mprotect for COW string %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_COW (see
+L<perlguts/"Copy on Write">), but a shared string buffer
+could not be made read-only.
+
=item mprotect for %p %u failed with %d
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see L<perlhacktips>),
+but an op tree could not be made read-only.
+
+=item mprotect RW for COW string %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_COW (see
+L<perlguts/"Copy on Write">), but a read-only shared string
+buffer could not be made mutable.
+
=item mprotect RW for %p %u failed with %d
(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see
-L<perlhacktips>), but an op tree could not be made read-only, or a
-read-only op tree could not be made mutable before freeing the ops.
+L<perlhacktips>), but a read-only op tree could not be made
+mutable before freeing the ops.
=item msg%s not implemented
(F) Lexically scoped subroutines are not yet implemented. Don't try
that yet.
+=item "my" subroutine %s can't be in a package
+
+(F) Lexically scoped subroutines aren't in a package, so it doesn't make
+sense to try to declare one with a package qualifier on the front.
+
=item "my %s" used in sort comparison
(W syntax) The package variables $a and $b are used for sort comparisons.
(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.
+declaration is also 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
+NOTE: This warning detects package symbols that have been used
+only once. This means lexical variables will never trigger this
+warning. It also means that all of the package variables $c, @c,
+%c, as well as *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.
Symbols beginning with an underscore and symbols using special
(F) When C<vec> is called in an lvalue context, the second argument must be
greater than or equal to zero.
+=item Negative repeat count does nothing
+
+(W numeric) You tried to execute the
+L<C<x>|perlop/Multiplicative Operators> repetition operator fewer than 0
+times, which doesn't make sense.
+
=item Nested quantifiers in regex; marked by S<<-- HERE> in m/%s/
(F) You can't quantify a quantifier without intervening parentheses.
class loses its specialness: it matches almost everything, which is
probably not what you want.
-=item \N{} in character class restricted to one character in regex; marked
+=item \N{} in inverted character class or as a range end-point is restricted to one character in regex; marked
by S<<-- HERE> in m/%s/
-(F) Named Unicode character escapes C<(\N{...})> may return a
-multi-character sequence. Such an escape may not be used in
-a character class, because character classes always match one
-character of input. Check that the correct escape has been used,
-and the correct charname handler is in scope. The S<<-- HERE> shows
-whereabouts in the regular expression the problem was discovered.
+(F) Named Unicode character escapes (C<\N{...}>) may return a
+multi-character sequence. Even though a character class is
+supposed to match just one character of input, perl will match the
+whole thing correctly, except when the class is inverted (C<[^...]>),
+or the escape is the beginning or final end point of a range. The
+mathematically logical behavior for what matches when inverting
+is very different from what people expect, so we have decided to
+forbid it. Similarly unclear is what should be generated when the
+C<\N{...}> is used as one of the end points of the range, such as in
+
+ [\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
+
+What is meant here is unclear, as the C<\N{...}> escape is a sequence
+of code points, so this is made an error.
=item \N{NAME} must be resolved by the lexer in regex; marked by
S<<-- HERE> in m/%s/
will be another way to do what you want that is, if not secure, at least
securable. See L<perlsec>.
+=item NO-BREAK SPACE in a charnames alias definition is deprecated
+
+(D deprecated) You defined a character name which contained a no-break
+space character. Change it to a regular space. Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>. See
+L<charnames/CUSTOM ALIASES>.
+
=item No code specified for -%c
(F) Perl's B<-e> and B<-E> command-line options require an argument. If
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
-=item Null filename used
-
-(F) You can't require the null filename, especially because on many
-machines that means the current directory! See L<perlfunc/require>.
-
=item NULL OP IN RUN
(S debugging) Some internal routine called run() with a null opcode
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
+=item Odd name/value argument for subroutine
+
+(F) A subroutine using a slurpy hash parameter in its signature
+received an odd number of arguments to populate the hash. It requires
+the arguments to be paired, with the same number of keys as values.
+The caller of the subroutine is presumably at fault. Inconveniently,
+this error will be reported at the location of the subroutine, not that
+of the caller.
+
=item Odd number of arguments for overload::constant
(W overload) The call to overload::constant contained an odd number of
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(S 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.
+(S 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.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(S 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.
+(S 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.
example, if you say "*foo *foo" it will be interpreted as if you said
"*foo * 'foo'".
+=item Optional parameter lacks default expression
+
+(F) In a subroutine signature, you wrote something like "$a =", making a
+named optional parameter without a default value. A nameless optional
+parameter is permitted to have no default value, but a named one must
+have a specific default. You probably want "$a = undef".
+
=item "our" variable %s redeclared
(W misc) You seem to have already declared the same global once before
(P) While attempting folding constants an exception other than an C<eval>
failure was caught.
-=item panic: frexp
+=item panic: frexp: %f
(P) The library function frexp() failed, making printf("%f") impossible.
=item panic: pad_free po
-(P) An invalid scratch pad offset was detected internally.
+(P) A zero scratch pad offset was detected internally. An attempt was
+made to free a target that had not been allocated to begin with.
=item panic: pad_reset curpad, %p!=%p
=item panic: pad_sv po
-(P) An invalid scratch pad offset was detected internally.
+(P) A zero scratch pad offset was detected internally. Most likely
+an operator needed a target but that target had not been allocated
+for whatever reason.
=item panic: pad_swipe curpad, %p!=%p
command-line switch. (This output goes to STDOUT unless you've
redirected it with select().)
-=item (perhaps you forgot to load "%s"?)
-
-(F) This is an educated guess made in conjunction with the message
-"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
+=item Perl folding rules are not up-to-date for 0x%X; please use the perlbug
utility to report; in regex; marked by S<<-- HERE> in m/%s/
(S regexp) You used a regular expression with case-insensitive matching,
folding rules are not accurate. This may lead to incorrect results.
Please report this as a bug using the L<perlbug> utility.
+=item PerlIO layer ':win32' is experimental
+
+(S experimental::win32_perlio) The C<:win32> PerlIO layer is
+experimental. If you want to take the risk of using this layer,
+simply disable this warning:
+
+ no warnings "experimental::win32_perlio";
+
=item Perl_my_%s() not available
(F) Your platform has very uncommon byte-order and integer size,
(F) The unpack format P must have an explicit size, not "*".
-=item POSIX class [:%s:] unknown in regex; marked by S<<-- HERE> in m/%s/
+=item pop on reference is experimental
+
+(S experimental::autoderef) C<pop> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
+=item POSIX class [:%s:] unknown in regex; marked by S<< <-- HERE in m/%s/ >>
(F) The class in the character class [: :] syntax is unknown. The S<<-- HERE>
shows whereabouts in the regular expression the problem was discovered.
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 S<<-- HERE> in m/%s/
+=item push on reference is experimental
+
+(S experimental::autoderef) C<push> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
+=item Quantifier follows nothing in regex; marked by S<< <-- HERE in m/%s/ >>
(F) You started a regular expression with a quantifier. Backslash it if
you meant it literally. The S<<-- HERE> shows whereabouts in the regular
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 Redundant argument in %s
+
+(W redundant) You called a function with more arguments than other
+arguments you supplied indicated would be needed. Currently only
+emitted when a printf-type format required fewer arguments than were
+supplied, but might be used in the future for e.g. L<perlfunc/pack>.
+
=item refcnt_dec: fd %d%s
=item refcnt: fd %d%s
=item rewinddir() attempted on invalid dirhandle %s
-(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
-really a dirhandle. Check your control flow.
+(W io) The dirhandle you tried to do a rewinddir() on is either closed
+or not really a dirhandle. Check your control flow.
=item Scalars leaked: %d
construct. Remember that bracketing delimiters count nesting level.
Missing the leading C<$> from a variable C<$m> may cause this error.
-Note that since Perl 5.9.0 a // can also be the I<defined-or>
+Note that since Perl 5.10.0 a // can also be the I<defined-or>
construct, not just the empty search pattern. Therefore code written
-in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
-misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
-
-=item Search pattern not terminated or ternary operator parsed as search pattern
-
-(F) The lexer couldn't find the final delimiter of a C<?PATTERN?>
-construct.
-
-The question mark is also used as part of the ternary operator (as in
-C<foo ? 0 : 1>) leading to some ambiguous constructions being wrongly
-parsed. One way to disambiguate the parsing is to put parentheses around
-the conditional expression, i.e. C<(foo) ? 0 : 1>.
+in Perl 5.10.0 or later that uses the // as the I<defined-or> can be
+misparsed by pre-5.10.0 Perls as a non-terminated search pattern.
=item seekdir() attempted on invalid dirhandle %s
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
+=item Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef
+
+(W deprecated) You assigned a reference to a scalar to C<$/> where the
+referenced item is not a positive integer. In older perls this B<appeared>
+to work the same as setting it to C<undef> but was in fact internally
+different, less efficient and with very bad luck could have resulted in
+your file being split by a stringified form of the reference.
+
+In Perl 5.20.0 this was changed so that it would be B<exactly> the same as
+setting C<$/> to undef, with the exception that this warning would be
+thrown.
+
+You are recommended to change your code to set C<$/> to C<undef> explicitly
+if you wish to slurp the file. In future versions of Perl assigning
+a reference to will throw a fatal error.
+
+=item Setting $/ to %s reference is forbidden
+
+(F) You tried to assign a reference to a non integer to C<$/>. In older
+Perls this would have behaved similarly to setting it to a reference to
+a positive integer, where the integer was the address of the reference.
+As of Perl 5.20.0 this is a fatal error, to allow future versions of Perl
+to use non-integer refs for more interesting purposes.
+
+=item shift on reference is experimental
+
+(S experimental::autoderef) C<shift> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
interpreted as the != (numeric not equal) and ~ (1's complement)
operators: probably not what you intended.
-=item <> should be quotes
-
-(F) You wrote C<< require <file> >> when you should have written
-C<require 'file'>.
-
=item /%s/ should probably be written as "%s"
(W syntax) You have used a pattern where Perl expected to find a string,
it can reliably handle and C<sleep> probably slept for less time than
requested.
+=item Slurpy parameter not last
+
+(F) In a subroutine signature, you put something after a slurpy (array or
+hash) parameter. The slurpy parameter takes all the available arguments,
+so there can't be any left to fill later parameters.
+
=item Smart matching a non-overloaded object breaks encapsulation
(F) You should not use the C<~~> operator on an object that does not
try explicitly pre-extending the array by assigning $#array = $offset.
See L<perlfunc/splice>.
+=item splice on reference is experimental
+
+(S experimental::autoderef) C<splice> with a scalar argument
+is experimental and may change or be removed in a future
+Perl version. If you want to take the risk of using this
+feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Split loop
(P) The split was looping infinitely. (Obviously, a split shouldn't
instead, which does return. To suppress this warning, put the exec() in
a block by itself.
+=item "state" subroutine %s can't be in a package
+
+(F) Lexically scoped subroutines aren't in a package, so it doesn't make
+sense to try to declare one with a package qualifier on the front.
+
=item "state %s" used in sort comparison
(W syntax) The package variables $a and $b are used for sort comparisons.
The <-- HERE shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
+=item Switch (?(condition)... not terminated in regex; marked by
+S<<-- HERE> in m/%s/
+
+(F) You omitted to close a (?(condition)...) block somewhere
+in the pattern. Add a closing parenthesis in the appropriate
+position. See L<perlre>.
+
=item switching effective %s is not implemented
(F) While under the C<use filetest> pragma, we cannot switch the real
no warnings "experimental::regex_sets";
+=item The signatures feature is experimental
+
+(S experimental::signatures) This warning is emitted if you unwrap a
+subroutine's arguments using a signature. Simply suppress the warning
+if you want to use the feature, but know that in doing so you are taking
+the risk of using an experimental feature which may change or be removed
+in a future Perl version:
+
+ no warnings "experimental::signatures";
+ use feature "signatures";
+ sub foo ($left, $right) { ... }
+
=item The stat preceding %s wasn't an lstat
(F) It makes no sense to test the current stat buffer for symbolic
(F) There has to be at least one argument to syscall() to specify the
system call to call, silly dilly.
+=item Too few arguments for subroutine
+
+(F) A subroutine using a signature received fewer arguments than required
+by the signature. The caller of the subroutine is presumably at fault.
+Inconveniently, this error will be reported at the location of the
+subroutine, not that of the caller.
+
=item Too late for "-%s" option
(X) The #! line (or local equivalent) in a Perl script contains the
(F) The function requires fewer arguments than you specified.
+=item Too many arguments for subroutine
+
+(F) A subroutine using a signature received more arguments than required
+by the signature. The caller of the subroutine is presumably at fault.
+Inconveniently, this error will be reported at the location of the
+subroutine, not that of the caller.
+
=item Too many )'s
(A) You've accidentally run your script through B<csh> instead of Perl.
(F) The regular expression ends with an unbackslashed backslash.
Backslash it. See L<perlre>.
-=item Trailing white-space in a charnames alias definition is deprecated
-
-(D deprecated) You defined a character name which ended in a space
-character. Remove the trailing space(s). Usually these names are
-defined in the C<:alias> import argument to C<use charnames>, but they
-could be defined by a translator installed into C<$^H{charnames}>.
-See L<charnames/CUSTOM ALIASES>.
-
=item Transliteration pattern not terminated
(F) The lexer couldn't find the interior delimiter of a tr/// or tr[][]
(A) You've accidentally run your script through B<csh> instead of Perl.
Check the #! line, or manually feed your script into Perl yourself.
+=item Unescaped left brace in regex is deprecated, passed through in regex;
+marked by <-- HERE in m/%s/
+
+(D deprecated, regexp) You used a literal C<"{"> character in a regular
+expression pattern. You should change to use C<"\{"> instead, because a
+future version of Perl (tentatively v5.26) will consider this to be a
+syntax error. If the pattern delimiters are also braces, any matching
+right brace (C<"}">) should also be escaped to avoid confusing the parser,
+for example,
+
+ qr{abc\{def\}ghi}
+
=item unexec of %s into %s failed!
(F) The unexec() routine failed for some reason. See your local FSF
(S) exit() was called or the script otherwise finished gracefully when
C<PERL_EXIT_WARN> was set in C<PL_exit_flags>.
-=item Unexpected exit failure %u
+=item Unexpected exit failure %d
(S) An uncaught die() was called when C<PERL_EXIT_WARN> was set in
C<PL_exit_flags>.
=item Unicode non-character U+%X is illegal for open interchange
-(S utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
-defined by the Unicode standard to be non-characters. Those are
-legal codepoints, but are reserved for internal use; so, applications
-shouldn't attempt to exchange them. If you know what you are doing
-you can turn off this warning by C<no warnings 'nonchar';>.
+(S 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. An application
+may not be expecting any of these characters at all, and receiving
+them may lead to bugs. If you know what you are doing you can
+turn off this warning by C<no warnings 'nonchar';>.
+
+This is not really a "severe" error, but it is supposed to be
+raised by default even if warnings are not enabled, and currently
+the only way to do that in Perl is to mark it as serious.
=item Unicode surrogate U+%X is illegal in UTF-8
-(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S 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
%d
(F) The Perl parser has no idea what to do with the specified character
-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.
+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 in regex; marked by
S<<-- HERE> in m/%s/
think you didn't do that, check the #! line to see if it's supplying the
bad switch on your behalf.)
+=item unshift on reference is experimental
+
+(S experimental::autoderef) C<unshift> with a scalar argument
+is experimental and may change or be removed in a future
+Perl version. If you want to take the risk of using this
+feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Unsuccessful %s on filename containing newline
(W newline) A file operation was attempted on a filename, and that
You probably meant to use C<$]> instead. C<$[> is the base for indexing
arrays. C<$]> is the Perl version number in decimal.
+=item Use "%s" instead of "%s"
+
+(F) The second listed construct is no longer legal. Use the first one
+instead.
+
=item Useless assignment to a temporary
(W misc) You assigned to an lvalue subroutine, but what
same length as the replacelist. See L<perlop> for more information
about the /d modifier.
-=item Useless use of '\'; doesn't escape metacharacter '%c'
-
-(D deprecated) You wrote a regular expression pattern something like
-one of these:
-
- m{ \x\{FF\} }x
- m{foo\{1,3\}}
- qr(foo\(bar\))
- s[foo\[a-z\]bar][baz]
+=item Useless use of \E
-The interior braces, square brackets, and parentheses are treated as
-metacharacters even though they are backslashed; instead write:
+(W misc) You have a \E in a double-quotish string without a C<\U>,
+C<\L> or C<\Q> preceding it.
- m{ \x{FF} }x
- m{foo{1,3}}
- qr(foo(bar))
- s[foo[a-z]bar][baz]
+=item Useless use of greediness modifier '%c' in regex; marked by S<<-- HERE> in m/%s/
-The backslashes have no effect when a regular expression pattern is
-delimited by C<{}>, C<[]>, or C<()>, which ordinarily are
-metacharacters, and the delimiters are also used, paired, within the
-interior of the pattern. It is planned that a future Perl release will
-change the meaning of constructs like these so that the backslashes
-will have an effect, so remove them from your code.
+(W regexp) You specified something like these:
-=item Useless use of \E
+ qr/a{3}?/
+ qr/b{1,1}+/
-(W misc) You have a \E in a double-quotish string without a C<\U>,
-C<\L> or C<\Q> preceding it.
+The C<"?"> and C<"+"> don't have any effect, as they modify whether to
+match more or fewer when there is a choice, and by specifying to match
+exactly a given numer, there is no room left for a choice.
=item Useless use of %s in void context
=item Use of bare << to mean <<"" is deprecated
(D deprecated) You are now encouraged to use the explicitly quoted
-form if you wish to use an empty line as the terminator of the here-document.
+form if you wish to use an empty line as the terminator of the
+here-document.
=item Use of chdir('') or chdir(undef) as chdir() deprecated
untie a scalar that had had a typeglob assigned to it. If you see this
message, you must be using an older version.
-=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 reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
You need to add either braces or blanks to disambiguate.
-=item Using a hash as a reference is deprecated
-
-(D deprecated) You tried to use a hash as a reference, as in
-C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1
-used to allow this syntax, but shouldn't have. It is now
-deprecated, and will be removed in a future version.
-
-=item Using an array as a reference is deprecated
-
-(D deprecated) You tried to use an array as a reference, as in
-C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.6.1 used to
-allow this syntax, but shouldn't have. It is now deprecated,
-and will be removed in a future version.
-
=item Using just the first character returned by \N{} in character class in
regex; marked by S<<-- HERE> in m/%s/
-(W regexp) 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.
+(W regexp) Named Unicode character escapes C<(\N{...})> may return
+a multi-character sequence. Even though a character class is
+supposed to match just one character of input, perl will match
+the whole thing correctly, except when the class is inverted
+(C<[^...]>), or the escape is the beginning or final end point of
+a range. For these, what should happen isn't clear at all. In
+these circumstances, Perl discards all but the first character
+of the returned sequence, which is not likely what you want.
=item Using !~ with %s doesn't make sense
=item UTF-16 surrogate U+%X
-(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S 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
longer than 1024 characters. The return value has been truncated to
1024 characters.
+=item values on reference is experimental
+
+(S experimental::autoderef) C<values> with a scalar argument
+is experimental and may change or be removed in a future
+Perl version. If you want to take the risk of using this
+feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Variable "%s" is not available
(W closure) During compilation, an inner named subroutine or eval is
}
f()->();
-Here, when the '$a' in the eval is being compiled, f() is not currently being
-executed, so its $a is not available for capture.
+Here, when the '$a' in the eval is being compiled, f() is not currently
+being executed, so its $a is not available for capture.
=item Variable "%s" is not imported%s
=item Variable length lookbehind not implemented in regex m/%s/
(F) Lookbehind is allowed only for subexpressions whose length is fixed and
-known at compile time. See L<perlre>.
+known at compile time. For positive lookbehind, you can use the C<\K>
+regex construct as a way to get the equivalent functionality. See
+L<perlre/(?<=pattern) \K>.
+
+There are non-obvious Unicode rules under C</i> that can match variably,
+but which you might not think could. For example, the substring C<"ss">
+can match the single character LATIN SMALL LETTER SHARP S. There are
+other sequences of ASCII characters that can match single ligature
+characters, such as LATIN SMALL LIGATURE FFI matching C<qr/ffi/i>.
+Starting in Perl v5.16, if you only care about ASCII matches, adding the
+C</aa> modifier to the regex will exclude all these non-obvious matches,
+thus getting rid of this message. You can also say C<S<use re qw(/aa)>>
+to apply C</aa> to all regular expressions compiled within its scope.
+See L<re>.
=item "%s" variable %s masks earlier declaration in same %s
=item Zero length \N{} in regex; marked by S<<-- HERE> in m/%s/
-(F) Named Unicode character escapes C<(\N{...})> may return a zero-length
+(F) Named Unicode character escapes (C<\N{...}>) may return a zero-length
sequence. Such an escape was used in an extended character class, i.e.
C<(?[...])>, which is not permitted. Check that the correct escape has
been used, and the correct charnames handler is in scope. The S<<-- HERE>
=head1 SEE ALSO
-L<warnings>, L<perllexwarn>, L<diagnostics>.
+L<warnings>, L<diagnostics>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff