(F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only
after certain types. See L<perlfunc/pack>.
+=item alpha->numify() is lossy
+
+(W numeric) An alpha version can not be numified without losing
+information.
+
=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
(W ambiguous) A subroutine you have declared has the same name as a Perl
C</^[a-zA-Z]*[0-9]*\z/>. See L<perlop/Auto-increment and
Auto-decrement> for details.
+=item Array passed to stat will be coerced to a scalar%s
+
+(W syntax) You called stat() on an array, but the array will be
+coerced to a scalar - the number of elements in the array.
+
+=item A signature parameter must start with '$', '@' or '%'
+
+(F) Each subroutine signature parameter declaration must start with a valid
+sigil; for example:
+
+ sub foo ($a, $, $b = 1, @c) {}
+
+=item A slurpy parameter may not have a default value
+
+(F) Only scalar subroutine signature parameters may have a default value;
+for example:
+
+ sub foo ($a = 1) {} # legal
+ sub foo (@a = (1)) {} # invalid
+ sub foo (%a = (a => b)) {} # invalid
+
=item assertion botched: %s
(X) The malloc package that comes with Perl had an internal failure.
must either both be scalars or both be lists. Otherwise Perl won't
know which context to supply to the right side.
+=item Assuming NOT a POSIX class since %s in regex; marked by S<<-- HERE> in m/%s/
+
+(W regexp) You had something like these:
+
+ [[:alnum]]
+ [[:digit:xyz]
+
+They look like they might have been meant to be the POSIX classes
+C<[:alnum:]> or C<[:digit:]>. If so, they should be written:
+
+ [[:alnum:]]
+ [[:digit:]xyz]
+
+Since these aren't legal POSIX class specifications, but are legal
+bracketed character classes, Perl treats them as the latter. In the
+first example, it matches the characters C<":">, C<"[">, C<"a">, C<"l">,
+C<"m">, C<"n">, and C<"u">.
+
+If these weren't meant to be POSIX classes, this warning message is
+spurious, and can be suppressed by reordering things, such as
+
+ [[al:num]]
+
+or
+
+ [[:munla]]
+
=item <> at require-statement should be quotes
(F) You wrote C<< require <file> >> when you should have written
used as an lvalue, which is pretty strange. Perhaps you forgot to
dereference it first. See L<perlfunc/substr>.
-=item Attribute "locked" is deprecated
+=item Attribute "locked" is deprecated, and will disappear in Perl 5.28
(D deprecated) You have used the attributes pragma to modify the
"locked" attribute on a code reference. The :locked attribute is
obsolete, has had no effect since 5005 threads were removed, and
-will be removed in a future release of Perl 5.
+will be removed in a Perl 5.28.
=item Attribute prototype(%s) discards earlier prototype attribute in same sub
example. Since each sub can only have one prototype, the earlier
declaration(s) are discarded while the last one is applied.
-=item Attribute "unique" is deprecated
+=item Attribute "unique" is deprecated, and will disappear in Perl 5.28
(D deprecated) You have used the attributes pragma to modify
the "unique" attribute on an array, hash or scalar reference.
The :unique attribute has had no effect since Perl 5.8.8, and
-will be removed in a future release of Perl 5.
+will be removed in a Perl 5.28.
=item av_reify called on tied array
The C<strict> pragma is useful in avoiding such errors.
+=item Bareword in require contains "%s"
+
+=item Bareword in require maps to disallowed filename "%s"
+
+=item Bareword in require maps to empty filename
+
+(F) The bareword form of require has been invoked with a filename which could
+not have been generated by a valid bareword permitted by the parser. You
+shouldn't be able to get this error from Perl code, but XS code may throw it
+if it passes an invalid module name to C<Perl_load_module>.
+
+=item Bareword in require must not start with a double-colon: "%s"
+
+(F) In C<require Bare::Word>, the bareword is not allowed to start with a
+double-colon. Write C<require ::Foo::Bar> as C<require Foo::Bar> instead.
+
=item Bareword "%s" not allowed while "strict subs" in use
(F) With "strict subs" in use, a bareword is only allowed as a
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>.
(F) Some XS code tried to use C<sv_catpvfn()> or a related function with a
format string that specifies explicit indexes for some of the elements, and
-using a C-style variable-argument list (a C<va_list>). This is not currently
-supported. XS authors wanting to do this must instead construct a C array of
-C<SV*> scalars containing the arguments.
+using a C-style variable-argument list (a C<va_list>). This is not currently
+supported. XS authors wanting to do this must instead construct a C array
+of C<SV*> scalars containing the arguments.
=item Can only compress unsigned integers in pack
issued on exit from the C<default> block, so you won't get the
error if you use an explicit C<continue>.)
+=item Can't determine class of operator %s, assuming BASEOP
+
+(S) This warning indicates something wrong in the internals of perl.
+Perl was trying to find the class (e.g. LISTOP) of a particular OP,
+and was unable to do so. This is likely to be due to a bug in the perl
+internals, or due to a bug in XS code which manipulates perl optrees.
+
=item Can't do inplace edit: %s is not a regular file
(S inplace) You tried to use the B<-i> switch on a special file, such as
(F) A string of a form C<CORE::word> was given to prototype(), but there
is no builtin with the name C<word>.
-=item Can't find %s character property "%s"
-
-(F) You used C<\p{}> or C<\P{}> but the character property by that name
-could not be found. Maybe you misspelled the name of the property?
-See L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available official properties.
-
=item Can't find label %s
(F) You said to goto a label that isn't mentioned anywhere that it's
=item Can't find Unicode property definition "%s"
-(F) You may have tried to use C<\p> which means a Unicode
-property (for example C<\p{Lu}> matches all uppercase
-letters). If you did mean to use a Unicode property, see
+=item Can't find Unicode property definition "%s" in regex; marked by <-- HERE in m/%s/
+
+(F) The named property which you specified via C<\p> or C<\P> is not one
+known to Perl. Perhaps you misspelled the name? See
L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available properties. If you didn't
-mean to use a Unicode property, escape the C<\p>, either by
-C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, or
+for a complete list of available official
+properties. If it is a
+L<user-defined property|perlunicode/User-Defined Character Properties>
+it must have been defined by the time the regular expression is
+matched.
+
+If you didn't mean to use a Unicode property, escape the C<\p>, either
+by C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, or
until C<\E>).
=item Can't fork: %s
(P) The internal routine that does assignment to a substr() was handed
a NULL.
-=item Can't modify non-lvalue subroutine call
+=item Can't modify non-lvalue subroutine call of &%s
(F) Subroutines meant to be used in lvalue context should be declared as
such. See L<perlsub/"Lvalue subroutines">.
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"">.
+L</""\c%c" is more clearly written simply as "%s". This will be a fatal error in Perl 5.28">.
+
+=item Character following \%c must be '{' or a single-character Unicode property name in regex; marked by <-- HERE in m/%s/
+
+(F) (In the above the C<%c> is replaced by either C<p> or C<P>.) You
+specified something that isn't a legal Unicode property name. Most
+Unicode properties are specified by C<\p{...}>. But if the name is a
+single character one, the braces may be omitted.
=item Character in 'C' format wrapped in pack
(W unopened) You tried chdir() on a filehandle that was never opened.
-=item \C no longer supported in regex; marked by S<<-- HERE> in m/%s/
+=item "\c%c" is more clearly written simply as "%s". This will be a fatal error in Perl 5.28
-(F) The \C character class used to allow a match of single byte within a
-multi-byte utf-8 character, but was removed in v5.24 as it broke
-encapsulation and its implementation was extremely 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().
+(D deprecated, 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. Doing it the way you did is
+not portable between ASCII and EBCDIC platforms.
-=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. Doing it the way you did is not portable
-between ASCII and EBCDIC platforms.
+This usage is going to result in a fatal error in Perl 5.28.
=item Cloning substitution context is unimplemented
handler is the prototype that is cloned when a new closure is created.
This subroutine cannot be called.
+=item \C no longer supported in regex; marked by S<<-- HERE> in m/%s/
+
+(F) The \C character class used to allow a match of single byte
+within a multi-byte utf-8 character, but was removed in v5.24 as
+it broke encapsulation and its implementation was extremely 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 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, and not portable
+
+(S non_unicode) You had a code point that has never been in any
+standard, so it is likely that languages other than Perl will NOT
+understand it. At one time, it was legal in some standards to have code
+points up to 0x7FFF_FFFF, but not higher, and this code point is higher.
+
+Acceptance of these code points is a Perl extension, and you should
+expect that nothing other than Perl can handle them; Perl itself on
+EBCDIC platforms before v5.24 does not handle them.
+
+Code points above 0xFFFF_FFFF require larger than a 32 bit word.
+
+Perl also makes no guarantees that the representation of these code
+points won't change at some point in the future, say when machines
+become available that have larger than a 64-bit word. At that time,
+files written by an older Perl would require conversion before being
+readable by a newer Perl.
+
=item Code point 0x%X is not Unicode, may not be portable
(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
-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.
+Perl allows strings to contain a superset of Unicode code points, but
+these may not be accepted by other languages/systems. Further, even if
+these languages/systems accept these large code points, they may have
+chosen a different representation for them than the UTF-8-like one that
+Perl has, which would mean files are not exchangeable between them and
+Perl.
+
+On EBCDIC platforms, code points above 0x3FFF_FFFF have a different
+representation in Perl v5.24 than before, so any file containing these
+that was written before that version will require conversion before
+being readable by a later Perl.
=item %s: Command not found
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
+ #!/usr/bin/perl
+
+=item %s: command not found
+
+(A) You've accidentally run your script through B<bash> or another 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
+
+ #!/usr/bin/perl
+
+=item %s: command not found: %s
+
+(A) You've accidentally run your script through B<zsh> or another 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
+
+ #!/usr/bin/perl
=item Compilation failed in require
See L<perlsub/"Constant Functions"> and L<constant>.
=item Constants from lexical variables potentially modified elsewhere are
-deprecated
+deprecated. This will not be allowed in Perl 5.32
(D deprecated) You wrote something like
the variable itself, rather than its value, so future changes to the
variable are reflected in the subroutine's return value.
-This usage is deprecated, because the behavior is likely to change
-in a future version of Perl.
+This usage is deprecated, and will no longer be allowed in Perl 5.32,
+making it possible to change the behavior in the future.
If you intended for the subroutine to be eligible for inlining, then
make sure the variable is not referenced elsewhere, possibly by
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
+=item Declaring references is experimental
+
+(S experimental::declared_refs) This warning is emitted if you use
+a reference constructor on the right-hand side of C<my>, C<state>, C<our>, or
+C<local>. 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::declared_refs";
+ use feature "declared_refs";
+ $fooref = my \$foo;
+
=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
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
-=item Deprecated use of my() in false conditional
+=item Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30
(D deprecated) You used a declaration similar to C<my $x if 0>. There
has been a long-standing bug in Perl that causes a lexical variable
sub f { state $x; return $x++ }
+This use of C<my()> in a false conditional has been deprecated since
+Perl 5.10, and it will become a fatal error in Perl 5.30.
+
=item DESTROY created new reference to dead object '%s'
(F) A DESTROY() method created a new reference to the object which is
=item Did not produce a valid header
-See Server error.
+See L</500 Server error>.
=item %s did not return a true value
=item Document contains no data
-See Server error.
+See L</500 Server error>.
=item %s does not define %s::VERSION--version check failed
subroutine or package before the current location. You can use an empty
"sub foo;" or "package FOO;" to enter a "forward" declaration.
-=item dump() better written as CORE::dump()
+=item dump() better written as CORE::dump(). dump() will no longer be available in Perl 5.30
+
+(D deprecated, misc) You used the obsolescent C<dump()> built-in function,
+without fully qualifying it as C<CORE::dump()>. Maybe it's a typo.
+
+Use of a unqualified C<dump()> was deprecated in Perl 5.30, and this
+will not be available in Perl 5.30.
-(W misc) You used the obsolescent C<dump()> built-in function, without fully
-qualifying it as C<CORE::dump()>. Maybe it's a typo. See L<perlfunc/dump>.
+See L<perlfunc/dump>.
=item dump is not supported
named "elseif" for the class returned by the following block. This is
unlikely to be what you want.
+=item Empty \%c in regex; marked by S<<-- HERE> in m/%s/
+
=item Empty \%c{} in regex; marked by S<<-- HERE> in m/%s/
(F) C<\p> and C<\P> are used to introduce a named Unicode property, as
described in L<perlunicode> and L<perlre>. You used C<\p> or C<\P> in
a regular expression without specifying the property name.
+=item ${^ENCODING} is no longer supported. Its use will be fatal in Perl 5.28
+
+(D deprecated) The special variable C<${^ENCODING}>, formerly used to implement
+the C<encoding> pragma, is no longer supported as of Perl 5.26.0.
+
+Setting this variable will become a fatal error in Perl 5.28.
+
=item entering effective %s failed
(F) While under the C<use filetest> pragma, switching the real and
use feature "refaliasing";
\$x = \$y;
+=item Experimental %s on scalar is now forbidden
+
+(F) An experimental feature added in Perl 5.14 allowed C<each>, C<keys>,
+C<push>, C<pop>, C<shift>, C<splice>, C<unshift>, and C<values> to be called with a
+scalar argument. This experiment is considered unsuccessful, and
+has been removed. The C<postderef> feature may meet your needs better.
+
=item Experimental subroutine signatures not enabled
(F) To use subroutine signatures, you must first enable them:
use feature "signatures";
sub foo ($left, $right) { ... }
-=item Experimental %s on scalar is now forbidden
-
-(F) An experimental feature added in Perl 5.14 allowed C<each>, C<keys>,
-C<push>, C<pop>, C<shift>, C<splice>, C<unshift>, and C<values> to be called
-with a scalar argument. This experiment is considered unsuccessful, and has
-been removed. The C<postderef> feature may meet your needs better.
-
-=item Experimental "%s" subs not enabled
-
-(F) To use lexical subs, you must first enable them:
-
- no warnings 'experimental::lexical_subs';
- use feature 'lexical_subs';
- my sub foo { ... }
-
=item Explicit blessing to '' (assuming package main)
(W misc) You are blessing a reference to a zero length string. This has
CHECK, INIT, or END subroutine. Processing of the remainder of the
queue of such routines has been prematurely ended.
+=item Failed to close in-place edit file %s: %s
+
+(F) Closing an output file from in-place editing, as with the C<-i>
+command-line switch, failed.
+
=item False [] range "%s" in regex; marked by S<<-- HERE> in m/%s/
(W regexp)(F) A character class range must start and end at a literal
a line length bigger than that. Perl will behave as if you specified
C<u63> as the format.
+=item File::Glob::glob() will disappear in perl 5.30. Use File::Glob::bsd_glob() instead.
+
+(D deprecated) C<< File::Glob >> has a function called C<< glob >>, which
+just calls C<< bsd_glob >>. However, its prototype is different from the
+prototype of C<< CORE::glob >>, and hence, C<< File::Glob::glob >> should
+not be used.
+
+C<< File::Glob::glob() >> was deprecated in perl 5.8.0. A deprecation
+message was issued from perl 5.26.0 onwards, and the function will
+disappear in perl 5.30.0.
+
+Code using C<< File::Glob::glob() >> should call
+C<< File::Glob::bsd_glob() >> instead.
+
=item Filehandle %s opened only for input
(W io) You tried to write on a read-only filehandle. If you intended
(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
=item Hexadecimal float: exponent underflow
(W overflow) The hexadecimal floating point has a smaller exponent
-than the floating point supports.
+than the floating point supports. With the IEEE 754 floating point,
+this may also mean that the subnormals (formerly known as denormals)
+are being used, which may or may not be an error.
=item Hexadecimal float: internal error (%s)
=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
-when Perl was built using standard options. For some reason, your
-version of Perl appears to have been built without this support. Talk
-to your Perl administrator.
+(F) Perl normally treats carriage returns in the program text as
+it would any other whitespace, which means you should never see
+this error when Perl was built using standard options. For some
+reason, your version of Perl appears to have been built without
+this support. Talk to your Perl administrator.
+
+=item Illegal character following sigil in a subroutine signature
+
+(F) A parameter in a subroutine signature contained an unexpected character
+following the C<$>, C<@> or C<%> sigil character. Normally the sigil
+should be followed by the variable name or C<=> etc. Perhaps you are
+trying use a prototype while in the scope of C<use feature 'signatures'>?
+For example:
+
+ sub foo ($$) {} # legal - a prototype
+
+ use feature 'signatures;
+ sub foo ($$) {} # illegal - was expecting a signature
+ sub foo ($a, $b)
+ :prototype($$) {} # legal
+
=item Illegal character in prototype for %s : %s
(X) The PERL5OPT environment variable may only be used to set the
following switches: B<-[CDIMUdmtw]>.
+=item Illegal user-defined property name
+
+(F) You specified a Unicode-like property name in a regular expression
+pattern (using C<\p{}> or C<\P{}>) that Perl knows isn't an official
+Unicode property, and was likely meant to be a user-defined property
+name, but it can't be one of those, as they must begin with either C<In>
+or C<Is>. Check the spelling. See also
+L</Can't find Unicode property definition "%s">.
+
=item Ill-formed CRTL environ value "%s"
(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's
C3-consistent, and you have enabled the C3 MRO for this class. See the C3
documentation in L<mro> for more information.
-=item In EBCDIC the v-string components cannot exceed 2147483647
+=item Indentation on line %d of here-doc doesn't match delimiter
-(F) An error peculiar to EBCDIC. Internally, v-strings are stored as
-Unicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC
-encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
+(F) You have an indented here-document where one or more of its lines
+have whitespace at the beginning that does not match the closing
+delimiter.
+
+For example, line 2 below is wrong because it does not have at least
+2 spaces, but lines 1 and 3 are fine because they have at least 2:
+
+ if ($something) {
+ print <<~EOF;
+ Line 1
+ Line 2 not
+ Line 3
+ EOF
+ }
+
+Note that tabs and spaces are compared strictly, meaning 1 tab will
+not match 8 spaces.
=item Infinite recursion in regex
=item Initialization of state variables in list context currently forbidden
-(F) Currently the implementation of "state" only permits the
-initialization of scalar variables in scalar context. Re-write
-C<state ($a) = 42> as C<state $a = 42> to change from list to scalar
-context. Constructions such as C<state (@a) = foo()> will be
-supported in a future perl release.
+(F) C<state> only permits initializing a single scalar variable, in scalar
+context. So C<state $a = 42> is allowed, but not C<state ($a) = 42>. To apply
+state semantics to a hash or array, store a hash or array reference in a
+scalar variable.
=item %%s[%s] in scalar context better written as $%s[%s]
if you're expecting only one subscript. When called in list context,
it also returns the key in addition to the value.
-=item %s() is deprecated on :utf8 handles
-
-(W deprecated) The sysread(), recv(), syswrite() and send() operators
-are deprecated on handles that have the C<:utf8> layer, either
-explicitly, or implicitly, eg., with the C<:encoding(UTF-16LE)> layer.
-
-Both sysread() and recv() currently use only the C<:utf8> flag for the
-stream, ignoring the actual layers. Since sysread() and recv() do no
-UTF-8 validation they can end up creating invalidly encoded scalars.
-
-Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise
-ignoring any layers. If the flag is set, both write the value UTF-8
-encoded, even if the layer is some different encoding, such as the
-example above.
-
-Ideally, all of these operators would completely ignore the C<:utf8>
-state, working only with bytes, but this would result in silently
-breaking existing code. To avoid this a future version of perl will
-throw an exception when any of sysread(), recv(), syswrite() or send()
-are called on handle with the C<:utf8> layer.
-
=item Insecure dependency in %s
(F) You tried to do something that the tainting mechanism didn't like.
not valid character numbers, so it returns the Unicode replacement
character (U+FFFD).
+=item Invalid number '%s' for -C option.
+
+(F) You supplied a number to the -C option that either has extra leading
+zeroes or overflows perl's unsigned integer representation.
+
=item invalid option -D%c, use -D'' to see choices
(S debugging) Perl was called with invalid debugger flags. Call perl
Perl. The current valid ones are given in
L<perlrebackslash/\b{}, \b, \B{}, \B>.
-=item "%s" is more clearly written simply as "%s" in regex; marked by S<<-- HERE> in m/%s/
+=item %s() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30
-(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+(D deprecated) The sysread(), recv(), syswrite() and send() operators are
+deprecated on handles that have the C<:utf8> layer, either explicitly, or
+implicitly, eg., with the C<:encoding(UTF-16LE)> layer.
+
+Both sysread() and recv() currently use only the C<:utf8> flag for the stream,
+ignoring the actual layers. Since sysread() and recv() do no UTF-8
+validation they can end up creating invalidly encoded scalars.
+
+Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise ignoring
+any layers. If the flag is set, both write the value UTF-8 encoded, even if
+the layer is some different encoding, such as the example above.
+
+Ideally, all of these operators would completely ignore the C<:utf8> state,
+working only with bytes, but this would result in silently breaking existing
+code.
+
+In Perl 5.30, it will no longer be possible to use sysread(), recv(),
+syswrite() or send() to read or send bytes from/to :utf8 handles.
+
+=item "%s" is more clearly written simply as "%s" in regex. This will be a fatal error in Perl 5.28; marked by S<<-- HERE> in m/%s/
+
+(W deprecated, regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
You specified a character that has the given plainer way of writing it,
and which is also portable to platforms running with different character
-sets.
+sets. This usage is deprecated, and will be a fatal error in Perl 5.28.
-=item $* is no longer supported
+=item $* is no longer supported. Its use will be fatal in Perl 5.30
(D deprecated, syntax) The special variable C<$*>, deprecated in older
perls, has been removed as of 5.10.0 and is no longer supported. In
with C<use re '/m'>. (In older versions: when C<$*> was set to a true value
then all regular expressions behaved as if they were written using C</m>.)
-=item $# is no longer supported
+Use of this variable will be a fatal error in Perl 5.30.
+
+=item $# is no longer supported. Its use will be fatal in Perl 5.30
(D deprecated, syntax) The special variable C<$#>, deprecated in older
perls, has been removed as of 5.10.0 and is no longer supported. You
should use the printf/sprintf functions instead.
+Use of this variable will be a fatal error in Perl 5.30.
+
=item '%s' is not a code reference
(W overload) The second (fourth, sixth, ...) argument of
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)
+=item Malformed UTF-8 character%s
-(S utf8)(F) Perl detected a string that didn't comply with UTF-8
-encoding rules, even though it had the UTF8 flag on.
+(S utf8)(F) Perl detected a string that should be UTF-8, but didn't
+comply with UTF-8 encoding rules, or represents a code point whose
+ordinal integer value doesn't fit into the word size of the current
+platform (overflows). Details as to the exact malformation are given in
+the variable, C<%s>, part of the message.
One possible cause is that you set the UTF8 flag yourself for data that
you thought to be in UTF-8 but it wasn't (it was for example legacy
-8-bit data). To guard against this, you can use Encode::decode_utf8.
+8-bit data). To guard against this, you can use C<Encode::decode('UTF-8', ...)>.
If you use the C<:encoding(UTF-8)> PerlIO layer for input, invalid byte
sequences are handled gracefully, but if you use C<:utf8>, the flag is
(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 Malformed UTF-8 string in "%s"
+
+(F) This message indicates a bug either in the Perl core or in XS
+code. Such code was trying to find out if a character, allegedly
+stored internally encoded as UTF-8, was of a given type, such as
+being punctuation or a digit. But the character was not encoded
+in legal UTF-8. The C<%s> is replaced by a string that can be used
+by knowledgeable people to determine what the type being checked
+against was.
+
+Passing malformed strings was deprecated in Perl 5.18, and
+became fatal in Perl 5.26.
+
=item Malformed UTF-16 surrogate
(F) Perl thought it was reading UTF-16 encoded character data but while
=item Method %s not permitted
-See Server error.
+See L</500 Server error>.
=item Might be a runaway multi-line %s string starting on line %d
(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
+=item Missing or undefined argument to %s
-(F) You tried to call require with no argument or with an undefined
+(F) You tried to call require or do 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>.
+file-specification as an argument; do expects a filename. See
+L<perlfunc/require EXPR> and L<perlfunc/do EXPR>.
=item Missing right brace on \%c{} in regex; marked by S<<-- HERE> in m/%s/
(W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
They're written like C<$foo[1][2][3]>, as in C.
+=item Multiple slurpy parameters not allowed
+
+(F) In subroutine signatures, a slurpy parameter (C<@> or C<%>) must be
+the last parameter, and there must not be more than one of them; for
+example:
+
+ sub foo ($a, @b) {} # legal
+ sub foo ($a, @b, %) {} # invalid
+
=item '/' must follow a numeric type in unpack
(F) You had an unpack template that contained a '/', but this did not
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
reference to something else instead. You can use the ref() function to
find out what kind of ref it really was. See L<perlref>.
+=item '#' not allowed immediately following a sigil in a subroutine signature
+
+(F) In a subroutine signature definition, a comment following a sigil
+(C<$>, C<@> or C<%>), needs to be separated by whitespace or a commma etc., in
+particular to avoid confusion with the C<$#> variable. For example:
+
+ # bad
+ sub f ($# ignore first arg
+ , $b) {}
+ # good
+ sub f ($, # ignore first arg
+ $b) {}
+
=item Not an ARRAY reference
(F) Perl was trying to evaluate a reference to an array value, but found
a reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See L<perlref>.
-=item Not an unblessed ARRAY reference
-
-(F) You passed a reference to a blessed array to C<push>, C<shift> or
-another array function. These only accept unblessed array references
-or arrays beginning explicitly with C<@>.
-
=item Not a SCALAR reference
(F) Perl was trying to evaluate a reference to a scalar value, but found
(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.
+The caller of the subroutine is presumably at fault.
=item Odd number of arguments for overload::constant
(S internal) An internal warning that the grammar is screwed up.
-=item Opening dirhandle %s also as a file
+=item Opening dirhandle %s also as a file. This will be a fatal error in Perl 5.28
(D 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.
+and this was deprecated in Perl 5.10. In Perl 5.28, this
+will be a fatal error.
-=item Opening filehandle %s also as a directory
+=item Opening filehandle %s also as a directory. This will be a fatal error in Perl 5.28
(D 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.
+and this was deprecated in Perl 5.10. In Perl 5.28, this
+will be a fatal error.
=item Operand with no preceding operator in regex; marked by S<<-- HERE> in
m/%s/
(P) Failed an internal consistency check trying to compile a grep.
-=item panic: ck_split, type=%u
-
-(P) Failed an internal consistency check trying to compile a split.
-
=item panic: corrupt saved stack index %ld
(P) The savestack was requested to restore more localized values than
(P) Failed an internal consistency check while trying to reset a weak
reference.
-=item panic: die %s
-
-(P) We popped the context stack to an eval context, and then discovered
-it wasn't an eval context.
-
=item panic: do_subst
(P) The internal pp_subst() routine was called with invalid operational
(P) The internal pp_match() routine was called with invalid operational
data.
-=item panic: pp_split, pm=%p, s=%p
-
-(P) Something terrible went wrong in setting up for the split.
-
=item panic: realloc, %s
(P) Something requested a negative number of bytes of realloc.
(P) The compiler is screwed up and attempted to use an op that isn't
permitted at run time.
+=item panic: unknown OA_*: %x
+
+(P) The internal routine that handles arguments to C<&CORE::foo()>
+subroutine calls was unable to determine what type of arguments
+were expected.
+
=item panic: utf16_to_utf8: odd bytelen
(P) Something tried to call utf16_to_utf8 with an odd (as opposed
(F) Parsing code supplied by an extension violated the parser's API in
a detectable way.
-=item Passing malformed UTF-8 to "%s" is deprecated
-
-(D deprecated, utf8) This message indicates a bug either in the Perl
-core or in XS code. Such code was trying to find out if a character,
-allegedly stored internally encoded as UTF-8, was of a given type, such
-as being punctuation or a digit. But the character was not encoded in
-legal UTF-8. The C<%s> is replaced by a string that can be used by
-knowledgeable people to determine what the type being checked against
-was. If C<utf8> warnings are enabled, a further message is raised,
-giving details of the malformation.
-
=item Pattern subroutine nesting without pos change exceeded limit in regex
(F) You used a pattern that uses too many nested subpattern calls without
(F) Your system has POSIX getpgrp(), which takes no argument, unlike
the BSD version, which takes a pid.
-=item POSIX syntax [%c %c] belongs inside character classes in regex; marked by
+=item POSIX syntax [%c %c] belongs inside character classes%s in regex; marked by
S<<-- HERE> in m/%s/
-(W regexp) The character class constructs [: :], [= =], and [. .] go
-I<inside> character classes, the [] are part of the construct, for example:
-/[012[:alpha:]345]/. Note that [= =] and [. .] are not currently
+(W regexp) Perl thinks that you intended to write a POSIX character
+class, but didn't use enough brackets. These POSIX class constructs [:
+:], [= =], and [. .] go I<inside> character classes, the [] are part of
+the construct, for example: C<qr/[012[:alpha:]345]/>. What the regular
+expression pattern compiled to is probably not what you were intending.
+For example, C<qr/[:alpha:]/> compiles to a regular bracketed character
+class consisting of the four characters C<":">, C<"a">, C<"l">,
+C<"h">, and C<"p">. To specify the POSIX class, it should have been
+written C<qr/[[:alpha:]]/>.
+
+Note that [= =] and [. .] are not currently
implemented; they are simply placeholders for future extensions and
will cause fatal errors. The S<<-- HERE> shows whereabouts in the regular
expression the problem was discovered. See L<perlre>.
+If the specification of the class was not completely valid, the message
+indicates that.
+
=item POSIX syntax [. .] is reserved for future extensions in regex; marked by
S<<-- HERE> in m/%s/
=item Premature end of script headers
-See Server error.
+See L</500 Server error>.
=item printf() on closed filehandle %s
L<perlipc/"Signals">. See also "Process terminated by SIGTERM/SIGINT"
in L<perlos2>.
-=item Property '%s' is unknown in regex; marked by S<<-- HERE> in m/%s/
-
-(F) The named property which you specified via C<\p> or C<\P> is not one
-known to Perl. Perhaps you misspelled the name? See
-L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available official
-properties. If it is a L<user-defined property|perlunicode/User-Defined Character Properties>
-it must have been defined by the time the regular expression is
-compiled.
-
=item Prototype after '%c' for %s : %s
(W illegalproto) A character follows % or @ in a prototype. This is
S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
+=item Sequence (?... not terminated in regex; marked by S<<-- HERE> in
+m/%s/
+
+(F) There was no matching closing parenthesis for the '('. The
+S<<-- HERE> shows whereabouts in the regular expression the problem was
+discovered.
+
=item Sequence \%s... not terminated in regex; marked by S<<-- HERE> in
m/%s/
(F) The end of the perl code contained within the {...} must be
followed immediately by a ')'.
+=item Sequence (?PE<gt>... not terminated in regex; marked by S<<-- HERE> in m/%s/
+
+(F) A named reference of the form C<(?PE<gt>...)> was missing the final
+closing parenthesis after the name. The S<<-- HERE> shows whereabouts
+in the regular expression the problem was discovered.
+
+=item Sequence (?PE<lt>... not terminated in regex; marked by S<<-- HERE> in m/%s/
+
+(F) A named group of the form C<(?PE<lt>...E<gt>')> was missing the final
+closing angle bracket. The S<<-- HERE> shows whereabouts in the
+regular expression the problem was discovered.
+
=item Sequence ?P=... not terminated in regex; marked by S<<-- HERE> in
m/%s/
(F) An C<(?R)> or C<(?0)> sequence in a regular expression was missing the
final parenthesis.
-=item Server error (a.k.a. "500 Server error")
+=item Z<>500 Server error
(A) This is the error message generally seen in a browser window
when trying to run a CGI program (including SSI) over the web. The
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
-=item Setting ${^ENCODING} is deprecated
-
-(D deprecated) You assigned a non-C<undef> value to C<${^ENCODING}>.
-This is deprecated; see C<L<perlvar/${^ENCODING}>> for details.
-
-=item Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef
+=item Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef. This will be fatal in Perl 5.28
(D 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>
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.
+if you wish to slurp the file. In Perl 5.28 assigning C<$/> to a
+reference to an integer which isn't positive will throw a fatal error.
=item Setting $/ to %s reference is forbidden
will continue to pretend that it is. And if you quote me on that, I
will deny it.
-=item The %s function is unimplemented
+=item The experimental declared_refs feature is not enabled
-(F) The function indicated isn't implemented on this architecture,
-according to the probings of Configure.
+(F) To declare references to variables, as in C<my \%x>, you must first enable
+the feature:
-=item The lexical_subs feature is experimental
+ no warnings "experimental::declared_refs";
+ use feature "declared_refs";
-(S experimental::lexical_subs) This warning is emitted if you
-declare a sub with C<my> or C<state>. 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:
+=item The %s function is unimplemented
- no warnings "experimental::lexical_subs";
- use feature "lexical_subs";
- my sub foo { ... }
+(F) The function indicated isn't implemented on this architecture,
+according to the probings of Configure.
=item The regex_sets feature is experimental
=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.
+(F) A subroutine using a signature received too few arguments than
+required by the signature. The caller of the subroutine is presumably
+at fault.
=item Too late for "-%s" option
=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.
+(F) A subroutine using a signature received too many arguments than
+required by the signature. The caller of the subroutine is presumably
+at fault.
+
=item Too many )'s
(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;
+=item Unescaped left brace in regex is deprecated here (and will be fatal in Perl 5.30), passed through in regex; marked by S<<-- HERE> in m/%s/
+
+(D deprecated, regexp) The simple rule to remember, if you want to
+match a literal C<{> character (U+007B C<LEFT CURLY BRACKET>) in a
+regular expression pattern, is to escape each literal instance of it in
+some way. Generally easiest is to precede it with a backslash, like
+C<\{> or enclose it in square brackets (C<[{]>). 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}
+
+Forcing literal C<{> characters to be escaped will enable the Perl
+language to be extended in various ways in future releases. To avoid
+needlessly breaking existing code, the restriction is is not enforced in
+contexts where there are unlikely to ever be extensions that could
+conflict with the use there of C<{> as a literal.
+
+In this release of Perl, some literal uses of C<{> are fatal, and some
+still just deprecated. This is because of an oversight: some uses of a
+literal C<{> that should have raised a deprecation warning starting in
+v5.20 did not warn until v5.26. By making the already-warned uses fatal
+now, some of the planned extensions can be made to the language sooner.
+The cases which are still allowed will be fatal in Perl 5.30.
+
+The contexts where no warnings or errors are raised are:
+
+=over 4
+
+=item *
+
+as the first character in a pattern, or following C<^> indicating to
+anchor the match to the beginning of a line.
+
+=item *
+
+as the first character following a C<|> indicating alternation.
+
+=item *
+
+as the first character in a parenthesized grouping like
+
+ /foo({bar)/
+ /foo(?:{bar)/
+
+=item *
+
+as the first character following a quantifier
+
+ /\s*{/
+
+=back
+
+=for comment
+The text of the message above is duplicated below to allow splain (and
+'use diagnostics') to work. Since one is fatal, and one not, they can't
+be combined as one message. And since the non-fatal one is temporary,
+there's no real need to enhance perldiag to handle this transient case.
+
+=item Unescaped left brace in regex is illegal here in regex;
marked by S<<-- 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,
+(F) The simple rule to remember, if you want to
+match a literal C<"{"> character (U+007B C<LEFT CURLY BRACKET>) in a
+regular expression pattern, is to escape each literal instance of it in
+some way. Generally easiest is to precede it with a backslash, like
+C<"\{"> or enclose it in square brackets (C<"[{]">). 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}
+
+Forcing literal C<"{"> characters to be escaped will enable the Perl
+language to be extended in various ways in future releases. To avoid
+needlessly breaking existing code, the restriction is is not enforced in
+contexts where there are unlikely to ever be extensions that could
+conflict with the use there of C<"{"> as a literal.
+
+In this release of Perl, some literal uses of C<"{"> are fatal, and some
+still just deprecated. This is because of an oversight: some uses of a
+literal C<"{"> that should have raised a deprecation warning starting in
+v5.20 did not warn until v5.26. By making the already-warned uses fatal
+now, some of the planned extensions can be made to the language sooner.
+
+The contexts where no warnings or errors are raised are:
+
+=over 4
+
+=item *
+
+as the first character in a pattern, or following C<"^"> indicating to
+anchor the match to the beginning of a line.
+
+=item *
+
+as the first character following a C<"|"> indicating alternation.
+
+=item *
+
+as the first character in a parenthesized grouping like
+
+ /foo({bar)/
+ /foo(?:{bar)/
+
+=item *
+
+as the first character following a quantifier
+
+ /\s*{/
+
+=back
+
+=item Unescaped literal '%c' in regex; marked by <-- HERE in m/%s/
- qr{abc\{def\}ghi}
+(W regexp) (only under C<S<use re 'strict'>>)
+
+Within the scope of C<S<use re 'strict'>> in a regular expression
+pattern, you included an unescaped C<}> or C<]> which was interpreted
+literally. These two characters are sometimes metacharacters, and
+sometimes literals, depending on what precedes them in the
+pattern. This is unlike the similar C<)> which is always a
+metacharacter unless escaped.
+
+This action at a distance, perhaps a large distance, can lead to Perl
+silently misinterpreting what you meant, so when you specify that you
+want extra checking by C<S<use re 'strict'>>, this warning is generated.
+If you meant the character as a literal, simply confirm that to Perl by
+preceding the character with a backslash, or make it into a bracketed
+character class (like C<[}]>). If you meant it as closing a
+corresponding C<[> or C<{>, you'll need to look back through the pattern
+to find out why that isn't happening.
=item unexec of %s into %s failed!
also happen if the C<\N{}> is not in the scope of the corresponding
C<S<use charnames>>.
+=item Unknown charname '' is deprecated. Its use will be fatal in Perl 5.28
+
+(D deprecated) You had a C<\N{}> with nothing between the braces. This
+usage was deprecated in Perl 5.24, and will be made a syntax error in
+in Perl 5.28.
+
=item Unknown error
(P) Perl was about to print an error message in C<$@>, but the C<$@> variable
module (e.g. C<use warnings 'File::Find'>), you must have loaded this
module first.
-=item Unmatched '[' in POSIX class in regex; marked by S<<-- HERE> in m/%s/
-
-(F) You had something like this:
-
- (?[ [:digit: ])
-
-That should be written:
-
- (?[ [:digit:] ])
-
-=item Unmatched '%c' in POSIX class in regex; marked by S<<-- HERE> in
-m/%s/
-
-(F) You had something like this:
-
- (?[ [:alnum] ])
-
-There should be a second C<":">, like this:
-
- (?[ [:alnum:] ])
-
=item Unmatched [ in regex; marked by S<<-- HERE> in m/%s/
(F) The brackets around a character class must match. If you wish to
(D deprecated) The C<$[> variable (index of the first element in an array)
is deprecated. See L<perlvar/"$[">.
-=item Use of bare << to mean <<"" is deprecated
+=item Use of bare << to mean <<"" is deprecated. Its use will be fatal in Perl 5.28
(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.
-=item Use of %s for non-UTF-8 locale is wrong. Assuming a UTF-8 locale
-
-(W locale) You are matching a regular expression using locale rules,
-and the specified construct was encountered. This construct is only
-valid for UTF-8 locales, which the current locale isn't. This doesn't
-make sense. Perl will continue, assuming a Unicode (UTF-8) locale, but
-the results are likely to be wrong.
+Use of a bare terminator was deprecated in Perl 5.000, and
+will be a fatal error in Perl 5.28.
=item Use of /c modifier is meaningless in s///
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
-=item Use of comma-less variable list is deprecated
+=item Use of code point 0x%s is deprecated; the permissible max is 0x%s. This will be fatal in Perl 5.28
+
+(D deprecated) You used a code point that will not be allowed in a
+future perl version, because it is too large. Unicode only allows code
+points up to 0x10FFFF, but Perl allows much larger ones. However, the
+largest possible ones break the perl interpreter in some constructs,
+including causing it to hang in a few cases. The known problem areas
+are in C<tr///>, regular expression pattern matching using quantifiers,
+as quote delimiters in C<qI<X>...I<X>> (where I<X> is the C<chr()> of a large
+code point), and as the upper limits in loops.
+There may be other breakages as well. If you get this warning, and
+things aren't working correctly, you probably have found one of these.
+
+If your code is to run on various platforms, keep in mind that the upper
+limit depends on the platform. It is much larger on 64-bit word sizes
+than 32-bit ones.
+
+The use of out of range code points was deprecated in Perl 5.24, and
+it will be a fatal error in Perl 5.28.
+
+=item Use of comma-less variable list is deprecated. Its use will be fatal in Perl 5.28
(D deprecated) The values you give to a format should be
separated by commas, not just aligned on a line.
+This usage will be fatal in Perl 5.28.
+
=item Use of each() on hash after insertion without resetting hash iterator results in undefined behavior
(S internal) The behavior of C<each()> after insertion is undefined;
it may skip items, or visit items more than once. Consider using
C<keys()> instead of C<each()>.
+=item Infinite recursion via empty pattern
+
+(F) You tried to use the empty pattern inside of a regex code block,
+for instance C</(?{ s!!! })/>, which resulted in re-executing
+the same pattern, which is an infinite loop which is broken by
+throwing an exception.
+
=item Use of := for an empty attribute list is not allowed
(F) The construction C<my $x := 42> used to parse as equivalent to
If you need an empty attribute list, for example in a code generator, add
a space before the C<=>.
+=item Use of %s for non-UTF-8 locale is wrong. Assuming a UTF-8 locale
+
+(W locale) You are matching a regular expression using locale rules,
+and the specified construct was encountered. This construct is only
+valid for UTF-8 locales, which the current locale isn't. This doesn't
+make sense. Perl will continue, assuming a Unicode (UTF-8) locale, but
+the results are likely to be wrong.
+
=item Use of freed value in iteration
(F) Perhaps you modified the iterated array within the loop?
reference-counting of iterated items, hence deleting such an item in the
middle of an iteration causes Perl to see a freed value.
-=item Use of *glob{FILEHANDLE} is deprecated
-
-(D deprecated) You are now encouraged to use the shorter *glob{IO} form
-to access the filehandle slot within a typeglob.
-
=item Use of /g modifier is meaningless in split
(W regexp) You used the /g modifier on the pattern for a C<split>
(D deprecated) Using C<goto> to jump from an outer scope into an inner
scope is deprecated and should be avoided.
-=item Use of inherited AUTOLOAD for non-method %s() is deprecated
+This was deprecated in Perl 5.12.
+
+=item Use of inherited AUTOLOAD for non-method %s() is deprecated. This will be fatal in Perl 5.28
(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD>
subroutines are looked up as methods (using the C<@ISA> hierarchy)
you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
C<use AutoLoader 'AUTOLOAD';>.
+This feature was deprecated in Perl 5.004, and will be fatal in Perl 5.28.
+
=item Use of %s in printf format not supported
(F) You attempted to use a feature of printf that is accessible from
only C. This usually means there's a better way to do it in Perl.
-=item Use of %s is deprecated
-
-(D deprecated) The construct indicated is no longer recommended for use,
-generally because there's a better way to do it, and also because the
-old way has bad side effects.
-
-=item Use of literal control characters in variable names is deprecated
-
-=item Use of literal non-graphic characters in variable names is deprecated
-
-(D deprecated) Using literal non-graphic (including control)
-characters in the source to refer to the ^FOO variables, like C<$^X> and
-C<${^GLOBAL_PHASE}> is now deprecated. (We use C<^X> and C<^G> here for
-legibility. They actually represent the non-printable control
-characters, code points 0x18 and 0x07, respectively; C<^A> would mean
-the control character whose code point is 0x01.) This only affects
-code like C<$\cT>, where C<\cT> is a control in the source code; C<${"\cT"}> and
-C<$^T> remain valid. Things that are non-controls and also not graphic
-are NO-BREAK SPACE and SOFT HYPHEN, which were previously only allowed
-for historical reasons.
-
=item Use of -l on filehandle%s
(W io) A filehandle represents an opened file, and when you opened the file
it already went past any symlink you are presumably trying to look for.
The operation returned C<undef>. Use a filename instead.
-=item Use of %s on a handle without * is deprecated
-
-(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that 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 was a long-standing bug that was removed in Perl 5.16, as there was
-no way to tie the scalar itself when it held a typeglob, and no way to
-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 reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
its behavior may change or even be removed in any future release of perl.
See the explanation under L<perlvar/$_>.
+=item Use of strings with code points over 0xFF as arguments to %s
+operator is deprecated. This will be a fatal error in Perl 5.28
+
+(D deprecated) You tried to use one of the string bitwise operators
+(C<&> or C<|> or C<^> or C<~>) on a string containing a code point over
+0xFF. The string bitwise operators treat their operands as strings of
+bytes, and values beyond 0xFF are nonsensical in this context.
+
+Such usage will be a fatal error in Perl 5.28.
+
=item Use of tainted arguments in %s is deprecated
(W taint, deprecated) You have supplied C<system()> or C<exec()> with multiple
but will become a fatal error in a future version of perl. Untaint your
arguments. See L<perlsec>.
+=item Use of unassigned code point or non-standalone grapheme for a
+delimiter will be a fatal error starting in Perl 5.30
+
+(D deprecated)
+A grapheme is what appears to a native-speaker of a language to be a
+character. In Unicode (and hence Perl) a grapheme may actually be
+several adjacent characters that together form a complete grapheme. For
+example, there can be a base character, like "R" and an accent, like a
+circumflex "^", that appear when displayed to be a single character with
+the circumflex hovering over the "R". Perl currently allows things like
+that circumflex to be delimiters of strings, patterns, I<etc>. When
+displayed, the circumflex would look like it belongs to the character
+just to the left of it. In order to move the language to be able to
+accept graphemes as delimiters, we have to deprecate the use of
+delimiters which aren't graphemes by themselves. Also, a delimiter must
+already be assigned (or known to be never going to be assigned) to try
+to future-proof code, for otherwise code that works today would fail to
+compile if the currently unassigned delimiter ends up being something
+that isn't a stand-alone grapheme. Because Unicode is never going to
+assign
+L<non-character code points|perlunicode/Noncharacter code points>, nor
+L<code points that are above the legal Unicode maximum|
+perlunicode/Beyond Unicode code points>, those can be delimiters, and
+their use won't raise this warning.
+
=item Use of uninitialized value%s
(W uninitialized) An undefined value was used as if it were already
(F) Lookbehind is allowed only for subexpressions whose length is fixed and
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>.
+L<(?<=pattern) and \K in perlre|perlre/\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">
(F) You used a verb pattern that is not allowed an argument. Remove the
argument or check that you are using the right verb.
+=item Version control conflict marker
+
+(F) The parser found a line starting with C<E<lt><<<<<<>,
+C<E<gt>E<gt>E<gt>E<gt>E<gt>E<gt>E<gt>>, or C<=======>. These may be left by a
+version control system to mark conflicts after a failed merge operation.
+
=item Version number must be a constant number
(P) The attempt to translate a C<use Module n.n LIST> statement into
=item Warning: unable to close filehandle %s properly: %s
-(S io) An error occurred when Perl implicitly closed a filehandle. This
-usually indicates your file system ran out of disk space.
+(S io) There were errors during the implicit close() done on a filehandle
+when its reference count reached zero while it was still open, e.g.:
+
+ {
+ open my $fh, '>', $file or die "open: '$file': $!\n";
+ print $fh $data or die "print: $!";
+ } # implicit close here
+
+Because various errors may only be detected by close() (e.g. buffering could
+allow the C<print> in this example to return true even when the disk is full),
+it is dangerous to ignore its result. So when it happens implicitly, perl
+will signal errors by warning.
+
+B<Prior to version 5.22.0, perl ignored such errors>, so the common idiom shown
+above was liable to cause B<silent data loss>.
=item Warning: Use of "%s" without parentheses is ambiguous
with your single-byte locale (or perhaps you thought you had a UTF-8
locale, but Perl disagrees).
-=item %s() with negative argument
-
-(S misc) Certain operations make no sense with negative arguments.
-Warning is given and the operation is not done.
-
=item Within []-length '%c' not allowed
(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]>
it contains any of the codes @, /, U, u, w or a *-length. Redesign
the template.
+=item %s() with negative argument
+
+(S misc) Certain operations make no sense with negative arguments.
+Warning is given and the operation is not done.
+
=item write() on closed filehandle %s
(W closed) The filehandle you're writing to got itself closed sometime
(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>
-shows whereabouts in the regular expression the problem was discovered.
+C<(?[...])>, or under C<use re 'strict'>, which is not permitted. Check
+that the correct escape has been used, and the correct charnames handler
+is in scope. The S<<-- HERE> shows whereabouts in the regular
+expression the problem was discovered.
=back
https://perl5.git.perl.org / perl5.git / blobdiff