used as an lvalue, which is pretty strange. Perhaps you forgot to
dereference it first. See L<perlfunc/substr>.
-=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 Perl 5.28.
-
=item Attribute prototype(%s) discards earlier prototype attribute in same sub
(W misc) A sub was declared as sub foo : prototype(A) : prototype(B) {}, for
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, 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 Perl 5.28.
-
=item av_reify called on tied array
(S debugging) This indicates that something went wrong and Perl got I<very>
(F) You passed an invalid number (like an infinity or not-a-number) to C<chr>.
+=item Cannot complete in-place edit of %s: %s
+
+(F) Your perl script appears to have changed directory while
+performing an in-place edit of a file specified by a relative path,
+and your system doesn't include the directory relative POSIX functions
+needed to handle that.
+
=item Cannot compress %f in pack
(F) You tried compressing an infinity or not-a-number as an unsigned
(S io) You tried to apply an encoding that did not exist to a filehandle,
either with open() or binmode().
+=item Cannot open %s as a dirhandle: it is already open as a filehandle
+
+(F) You tried to use opendir() to associate a dirhandle to a symbol (glob
+or scalar) that already holds a filehandle. Since this idiom might render
+your code confusing, it was deprecated in Perl 5.10. As of Perl 5.28, it
+is a fatal error.
+
+=item Cannot open %s as a filehandle: it is already open as a dirhandle
+
+(F) You tried to use open() to associate a filehandle to a symbol (glob
+or scalar) that already holds a dirhandle. Since this idiom might render
+your code confusing, it was deprecated in Perl 5.10. As of Perl 5.28, it
+is a fatal error.
+
=item Cannot pack %f with '%c'
(F) You tried converting an infinity or not-a-number to an integer,
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
=item Can't modify non-lvalue subroutine call of &%s
+=item Can't modify non-lvalue subroutine call of &%s in %s
+
(F) Subroutines meant to be used in lvalue context should be declared as
such. See L<perlsub/"Lvalue subroutines">.
=item Can't rename %s to %s: %s, skipping file
-(S inplace) The rename done by the B<-i> switch failed for some reason,
+(F) The rename done by the B<-i> switch failed for some reason,
probably because you don't have write permission to the directory.
+=item Can't rename in-place work file '%s' to '%s': %s
+
+(F) When closed implicitly, the temporary file for in-place editing
+couldn't be renamed to the original filename.
+
=item Can't reopen input pipe (name: %s) in binary mode
(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried
value that prints out looking like SCALAR(0xdecaf). Use the $1 form
instead.
+=item Can't unweaken a nonreference
+
+(F) You attempted to unweaken something that was not a reference. Only
+references can be unweakened.
+
=item Can't weaken a nonreference
(F) You attempted to weaken something that was not a reference. Only
unpack("s", "\x{f3}b")
-=item charnames alias definitions may not contain a sequence of multiple spaces
+=item charnames alias definitions may not contain a sequence of multiple
+spaces; marked by S<<-- HERE> in %s
(F) You defined a character name which had multiple space characters
in a row. Change them to single spaces. Usually these names are
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
+=item charnames alias definitions may not contain trailing white-space;
+marked by S<<-- HERE> in %s
(F) You defined a character name which ended in a space
character. Remove the trailing space(s). Usually these names are
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
(F) You said something like "use Module 42" but in the Module file
there are neither package declarations nor a C<$VERSION>.
-=item delete argument is index/value array slice, use array slice
-
-(F) You used index/value array slice syntax (C<%array[...]>) as
-the argument to C<delete>. You probably meant C<@array[...]> with
-an @ symbol instead.
-
-=item delete argument is key/value hash slice, use hash slice
-
-(F) You used key/value hash slice syntax (C<%hash{...}>) as the argument to
-C<delete>. You probably meant C<@hash{...}> with an @ symbol instead.
-
=item delete argument is not a HASH or ARRAY element or slice
(F) The argument to C<delete> must be either a hash or array element,
@foo[$bar, $baz, $xyzzy]
@{$ref->[12]}{"susie", "queue"}
+or a hash key/value or array index/value slice, such as:
+
+ %foo[$bar, $baz, $xyzzy]
+ %{$ref->[12]}{"susie", "queue"}
+
=item Delimiter for here document is too long
(F) In a here document construct like C<<<FOO>, the label C<FOO> is too
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
(F) You cannot put a repeat count of any kind right after the '/' code.
See L<perlfunc/pack>.
+=item do "%s" failed, '.' is no longer in @INC; did you mean do "./%s"?
+
+(D deprecated) Previously C< do "somefile"; > would search the current
+directory for the specified file. Since perl v5.26.0, F<.> has been
+removed from C<@INC> by default, so this is no longer true. To search the
+current directory (and only the current directory) you can write
+C< do "./somefile"; >.
+
=item Don't know how to get file name
(P) C<PerlIO_getname>, a perl internal I/O function specific to VMS, was
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
-(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>.
+(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.8.0, and this
+will not be available in Perl 5.30.
+
+See L<perlfunc/dump>.
=item dump is not supported
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
+=item ${^ENCODING} is no longer supported
-(D deprecated) The special variable C<${^ENCODING}>, formerly used to implement
+(F) 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.
+Setting it to anything other than C<undef> is a fatal error as of Perl
+5.28.
=item entering effective %s failed
(F) The C<exec> function is not implemented on some systems, e.g., Symbian
OS. See L<perlport>.
-=item Execution of %s aborted due to compilation errors.
+=item %sExecution of %s aborted due to compilation errors.
(F) The final summary message when a Perl compilation fails.
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
+=item Failed to close in-place work file %s: %s
(F) Closing an output file from in-place editing, as with the C<-i>
command-line switch, failed.
class its behavior is not well defined. Check that the correct
escape has been used, and the correct charname handler is in scope.
-=item Illegal binary digit %s
+=item Illegal binary digit '%c'
(F) You used a digit other than 0 or 1 in a binary number.
reason, your version of Perl appears to have been built without
this support. Talk to your Perl administrator.
+=item Illegal operator following parameter in a subroutine signature
+
+(F) A parameter in a subroutine signature, was followed by something
+other than C<=> introducing a default, C<,> or C<)>.
+
+ use feature 'signatures';
+ sub foo ($=1) {} # legal
+ sub foo ($a = 1) {} # legal
+ sub foo ($a += 1) {} # illegal
+ sub foo ($a == 1) {} # illegal
+
=item Illegal character following sigil in a subroutine signature
(F) A parameter in a subroutine signature contained an unexpected character
(F) The number of bits in vec() (the third argument) must be a power of
two from 1 to 32 (or 64, if your platform supports that).
-=item Illegal octal digit %s
+=item Illegal octal digit '%c'
(F) You used an 8 or 9 in an octal number.
text. You should check the pattern to ensure that recursive patterns
either consume text or fail.
-=item Initialization of state variables in list context currently forbidden
+=item Infinite recursion via empty pattern
-(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.
+(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 Initialization of state variables in list currently forbidden
+
+(F) C<state> only permits initializing a single variable, specified
+without parentheses. So C<state $a = 42> and C<state @a = qw(a b c)> are
+allowed, but not C<state ($a) = 42> or C<(state $a) = 42>. To initialize
+more than one C<state> variable, initialize them one at a time.
=item %%s[%s] in scalar context better written as $%s[%s]
Perl. The current valid ones are given in
L<perlrebackslash/\b{}, \b, \B{}, \B>.
-=item %s() is deprecated on :utf8 handles
+=item %s() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30
(D deprecated) The sysread(), recv(), syswrite() and send() operators are
deprecated on handles that have the C<:utf8> layer, either explicitly, or
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.
+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; marked by S<<-- HERE> in m/%s/
(W 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.
+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.
+
+=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
+previous versions of perl the use of C<$*> enabled or disabled multi-line
+matching within a string.
+
+Instead of using C<$*> you should use the C</m> (and maybe C</s>) regexp
+modifiers. You can enable C</m> for a lexical scope (even a whole file)
+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>.)
+
+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
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.
+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 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
-set without validating the data, possibly resulting in this error
-message.
+sequences are handled gracefully, but if you use C<:utf8>, the flag is set
+without validating the data, possibly resulting in this error message.
See also L<Encode/"Handling Malformed Data">.
-=item Malformed UTF-8 character immediately after '%s'
-
-(F) You said C<use utf8>, but the program file doesn't comply with UTF-8
-encoding rules. The message prints out the properly encoded characters
-just before the first bad one. If C<utf8> warnings are enabled, a
-warning is generated that gives more details about the type of
-malformation.
-
=item Malformed UTF-8 returned by \N{%s} immediately after '%s'
(F) The charnames handler returned malformed UTF-8.
+=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-8 string in '%c' format in unpack
(F) You tried to unpack something that didn't comply with UTF-8 encoding
(W syntax) An underscore (underbar) in a numeric constant did not
separate two digits.
+=item Missing argument for %n in %s
+
+(F) A C<%n> was used in a format string with no corresponding argument for
+perl to write the current string length to.
+
=item Missing argument in %s
(W missing) You called a function with fewer arguments than other
redirection, and found a '>' or a '>>' on the command line, but can't
find the name of the file to which to write data destined for stdout.
+=item No package name allowed for subroutine %s in "our"
+
=item No package name allowed for variable %s in "our"
-(F) Fully qualified variable names are not allowed in "our"
-declarations, because that doesn't make much sense under existing
-rules. Such syntax is reserved for future extensions.
+(F) Fully qualified subroutine and variable names are not allowed in "our"
+declarations, because that doesn't make much sense under existing rules.
+Such syntax is reserved for future extensions.
=item No Perl script found in input
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
-=item Odd name/value argument for subroutine
+=item Odd name/value argument for subroutine '%s'
(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.
+
+The message attempts to include the name of the called subroutine. If the
+subroutine has been aliased, the subroutine's original name will be shown,
+regardless of what name the caller used.
=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. 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 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. 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 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/
(W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
+=item Reference is not weak
+
+(W misc) You have attempted to unweaken a reference that is not weak.
+Doing so has no effect.
+
=item Reference to invalid group 0 in regex; marked by S<<-- HERE> in m/%s/
(F) You used C<\g0> or similar in a regular expression. You may refer
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. This will be fatal in Perl 5.28
+=item Setting $/ to a reference to %s is forbidden
-(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>
-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.
+(F) 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.
+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 Perl 5.28 assigning C<$/> to a
-reference to an integer which isn't positive will throw a fatal error.
+You are recommended to change your code to set C<$/> to C<undef> explicitly if
+you wish to slurp the file. As of Perl 5.28 assigning C<$/> to a reference
+to an integer which isn't positive is a fatal error.
=item Setting $/ to %s reference is forbidden
unnecessarily complex and unintuitive, and is very likely to be
overhauled.
+=item Sorry, hash keys must be smaller than 2**31 bytes
+
+(F) You tried to create a hash containing a very large key, where "very
+large" means that it needs at least 2 gigabytes to store. Unfortunately,
+Perl doesn't yet handle such large hash keys. You should
+reconsider your design to avoid hashing such a long string directly.
+
=item sort is now a reserved word
(F) An ancient error message that almost nobody ever runs into anymore.
(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
+=item Too few arguments for subroutine '%s'
-(F) A subroutine using a signature received too few arguments than
-required by the signature. The caller of the subroutine is presumably
-at fault.
+(F) A subroutine using a signature fewer arguments than required by the
+signature. The caller of the subroutine is presumably at fault.
+
+The message attempts to include the name of the called subroutine. If
+the subroutine has been aliased, the subroutine's original name will be
+shown, regardless of what name the caller used.
=item Too late for "-%s" option
(F) The function requires fewer arguments than you specified.
-=item Too many arguments for subroutine
+=item Too many arguments for subroutine '%s'
-(F) A subroutine using a signature received too many arguments than
-required by the signature. The caller of the subroutine is presumably
-at fault.
+(F) A subroutine using a signature received more arguments than permitted
+by the signature. The caller of the subroutine is presumably at fault.
+The message attempts to include the name of the called subroutine. If the
+subroutine has been aliased, the subroutine's original name will be shown,
+regardless of what name the caller used.
=item Too many )'s
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
data Perl expected. Someone's very confused, or perhaps trying to
subvert Perl's population of %ENV for nefarious purposes.
-=item Unknown regex modifier "%s"
+=item Unknown regexp modifier "/%s"
(F) Alphanumerics immediately following the closing delimiter
of a regular expression pattern are interpreted by Perl as modifier
(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. Its use will be fatal in Perl 5.28
+=item Use of bare << to mean <<"" is forbidden
-(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.
+(F) You are now required to use the explicitly quoted form if you wish
+to use an empty line as the terminator of the here-document.
-Use of a bare terminator was deprecated in Perl 5.000, and
-will be a fatal error in Perl 5.28.
+Use of a bare terminator was deprecated in Perl 5.000, and is a fatal
+error as of 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 code point 0x%s is deprecated; the permissible max is 0x%s. This will be fatal in Perl 5.28
+=item Use of code point 0x%s is not allowed; the permissible max is 0x%s.
-(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.
+(F) You used a code point that is not allowed, because it is too large.
+Unicode only allows code points up to 0x10FFFF, but Perl allows much
+larger ones. Earlier versions of Perl allowed code points above IV_MAX
+(0x7FFFFFF on 32-bit platforms, 0x7FFFFFFFFFFFFFFF on 64-bit platforms),
+however, this could possibly break the perl interpreter in some constructs,
+including causing it to hang in a few cases.
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.
+became a fatal error in Perl 5.28.
=item Use of each() on hash after insertion without resetting hash iterator results in undefined behavior
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
operator. Since C<split> always tries to match the pattern
repeatedly, the C</g> has no effect.
-=item Use of "goto" to jump into a construct is deprecated. Its use will be fatal in Perl 5.28
+=item Use of "goto" to jump into a construct is deprecated
(D deprecated) Using C<goto> to jump from an outer scope into an inner
scope is deprecated and should be avoided.
-This was deprecated in Perl 5.12, and will be a fatal error in Perl 5.28.
-
-=item Use of inherited AUTOLOAD for non-method %s() is deprecated. This will be fatal in Perl 5.28
+This was deprecated in Perl 5.12.
-(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD>
-subroutines are looked up as methods (using the C<@ISA> hierarchy)
-even when the subroutines to be autoloaded were called as plain
-functions (e.g. C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or
-C<< $obj->bar() >>).
+=item Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed
-This bug will be rectified in future by using method lookup only for
-methods' C<AUTOLOAD>s. However, there is a significant base of existing
-code that may be using the old behavior. So, as an interim step, Perl
-currently issues an optional warning when non-methods use inherited
-C<AUTOLOAD>s.
+(F) As an accidental feature, C<AUTOLOAD> subroutines were looked up as
+methods (using the C<@ISA> hierarchy), even when the subroutines to be
+autoloaded were called as plain functions (e.g. C<Foo::bar()>), not as
+methods (e.g. C<< Foo->bar() >> or C<< $obj->bar() >>).
-The simple rule is: Inheritance will not work when autoloading
-non-methods. The simple fix for old code is: In any module that used
-to depend on inheriting C<AUTOLOAD> for non-methods from a base class
-named C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during
-startup.
-
-In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);>
-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.
+This was deprecated in Perl 5.004, and was made fatal in Perl 5.28.
=item Use of %s in printf format not supported
however, because you can overload the numification and stringification
operators and then you presumably know what you are doing.
-=item Use of state $_ is experimental
+=item Use of strings with code points over 0xFF as arguments to %s
+operator is not allowed
-(S experimental::lexical_topic) Lexical $_ is an experimental feature and
-its behavior may change or even be removed in any future release of perl.
-See the explanation under L<perlvar/$_>.
+(F) 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.
-=item Use of strings with code points over 0xFF as arguments to %s
-operator is deprecated
+This became fatal in Perl 5.28.
+
+=item Use of strings with code points over 0xFF as arguments to C<vec>
+is deprecated. This will be a fatal error in Perl 5.32
+
+(D deprecated) You tried to use L<C<vec>|perlfunc/vec EXPR,OFFSET,BITS>
+on a string containing a code point over 0xFF, which is nonsensical here.
-(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.32.
=item Use of tainted arguments in %s is deprecated
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 v5.30
+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
regex construct as a way to get the equivalent functionality. See
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">
-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)>>
+Starting in Perl 5.18, 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. Here's a complete list of the current ones
+affecting ASCII characters:
+
+ ASCII
+ sequence Matches single letter under /i
+ FF U+FB00 LATIN SMALL LIGATURE FF
+ FFI U+FB03 LATIN SMALL LIGATURE FFI
+ FFL U+FB04 LATIN SMALL LIGATURE FFL
+ FI U+FB01 LATIN SMALL LIGATURE FI
+ FL U+FB02 LATIN SMALL LIGATURE FL
+ SS U+00DF LATIN SMALL LETTER SHARP S
+ U+1E9E LATIN CAPITAL LETTER SHARP S
+ ST U+FB06 LATIN SMALL LIGATURE ST
+ U+FB05 LATIN SMALL LIGATURE LONG S T
+
+This list is subject to change, but is quite unlikely to.
+Each ASCII sequence can be any combination of upper- and lowercase.
+
+You can avoid this by using a bracketed character class in the
+lookbehind assertion, like
+
+ (?<![sS]t)
+ (?<![fF]f[iI])
+
+This fools Perl into not matching the ligatures.
+
+Another option for Perls starting with 5.16, if you only care about
+ASCII matches, is to add the C</aa> modifier to the regex. This will
+exclude all these non-obvious matches, thus getting rid of this message.
+You can also say
+
+ use if $] ge 5.016, re => '/aa';
+
to apply C</aa> to all regular expressions compiled within its scope.
See L<re>.
https://perl5.git.perl.org / perl5.git / blobdiff