=item Assigning non-zero to $[ is no longer possible
-(F) When the "array_base" feature is disabled (e.g., under C<use v5.16;>)
+(F) When the "array_base" feature is disabled
+(e.g., and under C<use v5.16;>, and as of Perl 5.30)
the special variable C<$[>, which is deprecated, is now a fixed zero value.
=item Assignment to both a list and a scalar
(F) You wrote C<bless $foo> with one argument after somehow causing
the current package to be freed. Perl cannot figure out what to
-do, so it throws up in hands in despair.
+do, so it throws up its hands in despair.
=item Attempt to bless into a reference
do so. Such arrays are not even supposed to be accessible to
Perl code, but are only used internally.
-=item Cannot yet reorder sv_catpvfn() arguments from va_list
+=item Cannot yet reorder sv_vcatpvfn() arguments from va_list
-(F) Some XS code tried to use C<sv_catpvfn()> or a related function with a
+(F) Some XS code tried to use C<sv_vcatpvfn()> 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
(S inplace) The creation of the new file failed for the indicated
reason.
-=item Can't do inplace edit without backup
-
-(F) You're on a system such as MS-DOS that gets confused if you try
-reading from a deleted (but still opened) file. You have to say
-C<-i.bak>, or some such.
-
=item Can't do inplace edit: %s would not be unique
(S inplace) Your filesystem does not support filenames longer than 14
(P) An error peculiar to VMS. Perl asked $GETSYI how big you want your
mailbox buffers to be, and didn't get an answer.
+=item Can't "goto" into a binary or list expression
+
+(F) A "goto" statement was executed to jump into the middle of a binary
+or list expression. You can't get there from here. The reason for this
+restriction is that the interpreter would get confused as to how many
+arguments there are, resulting in stack corruption or crashes. This
+error occurs in cases such as these:
+
+ goto F;
+ print do { F: }; # Can't jump into the arguments to print
+
+ goto G;
+ $x + do { G: $y }; # How is + supposed to get its first operand?
+
+=item Can't "goto" into a "given" block
+
+(F) A "goto" statement was executed to jump into the middle of a C<given>
+block. You can't get there from here. See L<perlfunc/goto>.
+
=item Can't "goto" into the middle of a foreach loop
(F) A "goto" statement was executed to jump into the middle of a foreach
file. Perl was unable to remove the original file to replace it with
the modified file. The file was left unmodified.
-=item Can't rename %s to %s: %s, skipping file
-
-(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 rename %s to %s: %s, skipping file
+
+(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 reopen input pipe (name: %s) in binary mode
(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried
however, redefine it while it's running, and you can even undef the
redefined subroutine while the old routine is running. Go figure.
+=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 upgrade %s (%d) to %d
(P) The internal sv_upgrade routine adds "members" to an SV, making it
(P) The parser got confused when trying to parse a C<foreach> loop.
-=item Can't use global %s in "%s"
+=item Can't use global %s in %s
(F) You tried to declare a magical variable as a lexical variable. This
is not allowed, because the magic can be tied to only one location
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
usually indicates a syntax error in dereferencing the constant value.
See L<perlsub/"Constant Functions"> and L<constant>.
-=item Constants from lexical variables potentially modified elsewhere are
-deprecated. This will not be allowed in Perl 5.32
+=item Constants from lexical variables potentially modified elsewhere are no longer permitted
-(D deprecated) You wrote something like
+(F) You wrote something like
my $var;
$sub = sub () { $var };
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, and will no longer be allowed in Perl 5.32,
+This usage was deprecated, and as of Perl 5.32 is no longer allowed,
making it possible to change the behavior in the future.
If you intended for the subroutine to be eligible for inlining, then
=item (Did you mean "local" instead of "our"?)
-(W misc) Remember that "our" does not localize the declared global
+(W shadow) Remember that "our" does not localize the declared global
variable. You have declared it again in the same lexical scope, which
seems superfluous.
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(). 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.
+=item dump() must be written as CORE::dump() as of Perl 5.30
-Use of a unqualified C<dump()> was deprecated in Perl 5.8.0, and this
-will not be available in Perl 5.30.
+(F) You used the obsolete C<dump()> built-in function. That was deprecated in
+Perl 5.8.0. As of Perl 5.30 it must be written in fully qualified format:
+C<CORE::dump()>.
See L<perlfunc/dump>.
=item Empty \%c in regex; marked by S<<-- HERE> in m/%s/
+=item Empty \%c{}
+
=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.
+(F) You used something like C<\b{}>, C<\B{}>, C<\o{}>, C<\p>, C<\P>, or
+C<\x> without specifying anything for it to operate on.
+
+Unfortunately, for backwards compatibility reasons, an empty C<\x> is
+legal outside S<C<use re 'strict'>> and expands to a NUL character.
+
+=item Empty (?) without any modifiers in regex; marked by <-- HERE in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>>)
+C<(?)> does nothing, so perhaps this is a typo.
=item ${^ENCODING} is no longer supported
L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>,
but omitted the C<")">.
+=item Expecting close paren for nested extended charclass in regex; marked
+by <-- HERE in m/%s/
+
+(F) While parsing a nested extended character class like:
+
+ (?[ ... (?flags:(?[ ... ])) ... ])
+ ^
+
+we expected to see a close paren ')' (marked by ^) but did not.
+
+=item Expecting close paren for wrapper for nested extended charclass in
+regex; marked by <-- HERE in m/%s/
+
+(F) While parsing a nested extended character class like:
+
+ (?[ ... (?flags:(?[ ... ])) ... ])
+ ^
+
+we expected to see a close paren ')' (marked by ^) but did not.
+
=item Expecting '(?flags:(?[...' in regex; marked by S<<-- HERE> in m/%s/
(F) The C<(?[...])> extended character class regular expression construct
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
(W digit) You may have tried to use an 8 or 9 in an octal number.
Interpretation of the octal number stopped before the 8 or 9.
+=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 pattern in regex; marked by S<<-- HERE> in m/%s/
(F) You wrote something like
intervening between the C<"("> and the C<"?">, but you separated them
with whitespace.
+=item In '(*...)', the '(' and '*' must be adjacent in regex;
+marked by S<<-- HERE> in m/%s/
+
+(F) The two-character sequence C<"(*"> in this context in a regular
+expression pattern should be an indivisible token, with nothing
+intervening between the C<"("> and the C<"*">, but you separated them.
+Fix the pattern and retry.
+
=item Invalid %s attribute: %s
(F) The indicated attribute for a subroutine or variable was not recognized
=item In '(*VERB...)', the '(' and '*' must be adjacent in regex;
marked by S<<-- HERE> in m/%s/
-(F) The two-character sequence C<"(*"> in
-this context in a regular expression pattern should be an
-indivisible token, with nothing intervening between the C<"(">
-and the C<"*">, but you separated them.
+(F) The two-character sequence C<"(*"> in this context in a regular
+expression pattern should be an indivisible token, with nothing
+intervening between the C<"("> and the C<"*">, but you separated them.
=item ioctl is not implemented
Perl. The current valid ones are given in
L<perlrebackslash/\b{}, \b, \B{}, \B>.
-=item %s() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30
+=item %s() isn't allowed on :utf8 handles
-(D deprecated) The sysread(), recv(), syswrite() and send() operators are
-deprecated on handles that have the C<:utf8> layer, either explicitly, or
+(F) The sysread(), recv(), syswrite() and send() operators are
+not allowed 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
+Previously sysread() and recv() currently use only the C<:utf8> flag for the stream,
+ignoring the actual layers. Since sysread() and recv() did 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
+Similarly, syswrite() and send() used only the C<:utf8> flag, otherwise ignoring
+any layers. If the flag is set, both wrote 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; 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.
-=item $* is no longer supported. Its use will be fatal in Perl 5.30
+=item $* is no longer supported as of 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
+(F) The special variable C<$*>, deprecated in older perls, was removed in
+5.10.0, is no longer supported and is a fatal error as of Perl 5.30. In
previous versions of perl the use of C<$*> enabled or disabled multi-line
matching within a string.
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
+=item $# is no longer supported as of 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
+(F) The special variable C<$#>, deprecated in older perls, was removed as of
+5.10.0, is no longer supported and is a fatal error as of Perl 5.30. 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
(P) The regular expression parser is confused.
+=item \K not permitted in lookahead/lookbehind in regex; marked by <-- HERE in m/%s/
+
+(F) Your regular expression used C<\K> in a lookhead or lookbehind
+assertion, which isn't permitted.
+
=item Label not found for "last %s"
(F) You named a loop to break out of, but you're not currently in a loop
form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>.
Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead.
+=item Literal vertical space in [] is illegal except under /x in regex;
+marked by S<<-- HERE> in m/%s/
+
+(F) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Likely you forgot the C</x> modifier or there was a typo in the pattern.
+For example, did you really mean to match a form-feed? If so, all the
+ASCII vertical space control characters are representable by escape
+sequences which won't present such a jarring appearance as your pattern
+does when displayed.
+
+ \r carriage return
+ \f form feed
+ \n line feed
+ \cK vertical tab
+
=item %s: loadable library and perl binaries are mismatched (got handshake key %p, needed %p)
(P) A dynamic loading library C<.so> or C<.dll> was being loaded into the
said library was compiled against. Reinstalling the XS module will
likely fix this error.
+=item Locale '%s' contains (at least) the following characters which
+have unexpected meanings: %s The Perl program will use the expected
+meanings
+
+(W locale) You are using the named UTF-8 locale. UTF-8 locales are
+expected to have very particular behavior, which most do. This message
+arises when perl found some departures from the expectations, and is
+notifying you that the expected behavior overrides these differences.
+In some cases the differences are caused by the locale definition being
+defective, but the most common causes of this warning are when there are
+ambiguities and conflicts in following the Standard, and the locale has
+chosen an approach that differs from Perl's.
+
+One of these is because that, contrary to the claims, Unicode is not
+completely locale insensitive. Turkish and some related languages
+have two types of C<"I"> characters. One is dotted in both upper- and
+lowercase, and the other is dotless in both cases. Unicode allows a
+locale to use either the Turkish rules, or the rules used in all other
+instances, where there is only one type of C<"I">, which is dotless in
+the uppercase, and dotted in the lower. The perl core does not (yet)
+handle the Turkish case, and this message warns you of that. Instead,
+the L<Unicode::Casing> module allows you to mostly implement the Turkish
+casing rules.
+
+The other common cause is for the characters
+
+ $ + < = > ^ ` | ~
+
+These are probematic. The C standard says that these should be
+considered punctuation in the C locale (and the POSIX standard defers to
+the C standard), and Unicode is generally considered a superset of
+the C locale. But Unicode has added an extra category, "Symbol", and
+classifies these particular characters as being symbols. Most UTF-8
+locales have them treated as punctuation, so that L<ispunct(2)> returns
+non-zero for them. But a few locales have it return 0. Perl takes
+the first approach, not using C<ispunct()> at all (see L<Note [5] in
+perlrecharclass|perlrecharclass/[5]>), and this message is raised to notify you that you
+are getting Perl's approach, not the locale's.
+
=item Locale '%s' may not work well.%s
(W locale) You are using the named locale, which is a non-UTF-8 one, and
(S non_unicode) Perl allows strings to contain a superset of
Unicode code points; each code point may be as large as what is storable
-in an unsigned integer on your system, but these may not be accepted by
+in a signed integer on your system, but these may not be accepted by
other languages/systems. This message occurs when you matched a string
containing such a code point against a regular expression pattern, and
the code point was matched against a Unicode property, C<\p{...}> or
(F) Transliteration (C<tr///> and C<y///>) transliterates individual
characters. But a named sequence by definition is more than an
-individual charater, and hence doing this operation on it doesn't make
+individual character, and hence doing this operation on it doesn't make
sense.
=item "my sub" not yet implemented
class loses its specialness: it matches almost everything, which is
probably not what you want.
-=item \N{} in inverted character class or as a range end-point is restricted to one character in regex; marked by <-- HERE in m/%s/
+=item \N{} here is restricted to one character in regex; marked by <-- HERE in m/%s/
(F) Named Unicode character escapes (C<\N{...}>) may return a
multi-character sequence. Even though a character class is
supposed to match just one character of input, perl will match the
-whole thing correctly, except when the class is inverted (C<[^...]>),
-or the escape is the beginning or final end point of a range. The
-mathematically logical behavior for what matches when inverting
-is very different from what people expect, so we have decided to
-forbid it. Similarly unclear is what should be generated when the
-C<\N{...}> is used as one of the end points of the range, such as in
-
- [\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
-
-What is meant here is unclear, as the C<\N{...}> escape is a sequence
-of code points, so this is made an error.
+whole thing correctly, except under certain conditions. These currently
+are
-=item \N{NAME} must be resolved by the lexer in regex; marked by
-S<<-- HERE> in m/%s/
+=over 4
-(F) When compiling a regex pattern, an unresolved named character or
-sequence was encountered. This can happen in any of several ways that
-bypass the lexer, such as using single-quotish context, or an extra
-backslash in double-quotish:
+=item When the class is inverted (C<[^...]>)
- $re = '\N{SPACE}'; # Wrong!
- $re = "\\N{SPACE}"; # Wrong!
- /$re/;
+The mathematically logical behavior for what matches when inverting
+is very different from what people expect, so we have decided to
+forbid it.
-Instead, use double-quotes with a single backslash:
+=item The escape is the beginning or final end point of a range
- $re = "\N{SPACE}"; # ok
- /$re/;
+Similarly unclear is what should be generated when the
+C<\N{...}> is used as one of the end points of the range, such as in
-The lexer can be bypassed as well by creating the pattern from smaller
-components:
+ [\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
- $re = '\N';
- /${re}{SPACE}/; # Wrong!
+What is meant here is unclear, as the C<\N{...}> escape is a sequence
+of code points, so this is made an error.
-It's not a good idea to split a construct in the middle like this, and
-it doesn't work here. Instead use the solution above.
+=item In a regex set
-Finally, the message also can happen under the C</x> regex modifier when the
-C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
+The syntax S<C<(?[ ])>> in a regular expression yields a list of
+single code points, none can be a sequence.
- /\N {SPACE}/x; # Wrong!
- /\N{SPACE}/x; # ok
+=back
=item No %s allowed while running setuid
module) didn't define a C<DB::sub> routine to be called at the beginning
of each ordinary subroutine call.
+=item No digits found for %s literal
+
+(F) No hexadecimal digits were found following C<0x> or no binary digits
+were found following C<0b>.
+
=item No directory specified for -I
(F) The B<-I> command-line switch requires a directory name as part of the
not recognized. Say C<kill -l> in your shell to see the valid signal
names on your system.
+=item No Unicode property value wildcard matches:
+
+(W regexp) You specified a wildcard for a Unicode property value, but
+there is no property value in the current Unicode release that matches
+it. Check your spelling.
+
=item Not a CODE reference
(F) Perl was trying to evaluate a reference to a code value (that is, a
=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
+(C<$>, C<@> or C<%>), needs to be separated by whitespace or a comma etc., in
particular to avoid confusion with the C<$#> variable. For example:
# bad
of Perl. Check the #! line, or manually feed your script into Perl
yourself.
-=item (?[...]) not valid in locale in regex; marked by S<<-- HERE> in m/%s/
-
-(F) C<(?[...])> cannot be used within the scope of a C<S<use locale>> or with
-an C</l> regular expression modifier, as that would require deferring
-to run-time the calculation of what it should evaluate to, and it is
-regex compile-time only.
-
=item no UTC offset information; assuming local time is UTC
(S) A warning peculiar to VMS. Perl was unable to find the local
a number. This happens, for example with C<\o{}>, with no number between
the braces.
+=item Numeric format result too large
+
+(F) The length of the result of a numeric format supplied to sprintf()
+or printf() would have been too large for the underlying C function to
+report. This limit is typically 2GB.
+
=item Octal number > 037777777777 non-portable
(W portable) The octal number you specified is larger than 2**32-1
=item "our" variable %s redeclared
-(W misc) You seem to have already declared the same global once before
+(W shadow) You seem to have already declared the same global once before
in the current lexical scope.
=item Out of memory!
search list. So the additional elements in the replacement list
are meaningless.
+=item '(*%s' requires a terminating ':' in regex; marked by <-- HERE in m/%s/
+
+(F) You used a construct that needs a colon and pattern argument.
+Supply these or check that you are using the right construct.
+
=item '%s' resolved to '\o{%s}%d'
(W misc, regexp) You wrote something like C<\08>, or C<\179> in a
in a location where the CGI server can't find it, basically, more or
less. Please see the following for more information:
- http://www.perl.org/CGI_MetaFAQ.html
+ https://www.perl.org/CGI_MetaFAQ.html
http://www.htmlhelp.org/faq/cgifaq.html
http://www.w3.org/Security/Faq/
stubs. Stubs should never be implicitly created, but explicit calls to
C<can> may break this.
+=item Subroutine attributes must come before the signature
+
+(F) When subroutine signatures are enabled, any subroutine attributes must
+come before the signature. Note that this order was the opposite in
+versions 5.22..5.26. So:
+
+ sub foo :lvalue ($a, $b) { ... } # 5.20 and 5.28 +
+ sub foo ($a, $b) :lvalue { ... } # 5.22 .. 5.26
+
=item Subroutine "&%s" is not available
(W closure) During compilation, an inner named subroutine or eval is
=item "%s" subroutine &%s masks earlier declaration in same %s
-(W misc) A "my" or "state" subroutine has been redeclared in the
+(W shadow) A "my" or "state" subroutine has been redeclared in the
current scope or statement, effectively eliminating all access to
the previous instance. This is almost always a typographical error.
Note that the earlier subroutine will still exist until the end of
a perl4 interpreter, especially if the next 2 tokens are "use strict"
or "my $var" or "our $var".
-=item Syntax error in (?[...]) in regex m/%s/
+=item Syntax error in (?[...]) in regex; marked by <-- HERE in m/%s/
(F) Perl could not figure out what you meant inside this construct; this
notifies you that it is giving up trying.
(W unopened) You tried to use the tell() function on a filehandle that
was either never opened or has since been closed.
-=item That use of $[ is unsupported
-
-(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
-as a compiler directive. You may say only one of
+=item The alpha_assertions feature is experimental
- $[ = 0;
- $[ = 1;
- ...
- local $[ = 0;
- local $[ = 1;
- ...
-
-This is to prevent the problem of one module changing the array base out
-from under another module inadvertently. See L<perlvar/$[> and L<arybase>.
-
-=item The bitwise feature is experimental
-
-(S experimental::bitwise) This warning is emitted if you use bitwise
-operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled.
-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::bitwise";
- use feature "bitwise";
- $x |.= $y;
+(S experimental::alpha_assertions) This feature is experimental
+and its behavior may change in any future release of perl. See
+L<perlre/Extended Patterns>.
=item The crypt() function is unimplemented due to excessive paranoia.
(F) The function indicated isn't implemented on this architecture,
according to the probings of Configure.
+=item The private_use feature is experimental
+
+(S experimental::private_use) This feature is actually a hook for future
+use.
+
=item The regex_sets feature is experimental
(S experimental::regex_sets) This warning is emitted if you
use the syntax S<C<(?[ ])>> in a regular expression.
The details of this feature are subject to change.
-if you want to use it, but know that in doing so you
+If you want to use it, but know that in doing so you
are taking the risk of using an experimental feature which may
change in a future Perl version, you can do this to silence the
warning:
no warnings "experimental::regex_sets";
+=item The script_run feature is experimental
+
+(S experimental::script_run) This feature is experimental
+and its behavior may in any future release of perl. See
+L<perlre/Script Runs>.
+
=item The signatures feature is experimental
(S experimental::signatures) This warning is emitted if you unwrap a
past the symlink to get to the real file. Use an actual filename
instead.
+=item The Unicode property wildcards feature is experimental
+
+(S experimental::uniprop_wildcards) This feature is experimental
+and its behavior may in any future release of perl. See
+L<perlunicode/Wildcards in Property Values>.
+
=item The 'unique' attribute may only be applied to 'our' variables
(F) This attribute was never supported on C<my> or C<sub> declarations.
report this warning to the relevant upstream party, or recompile perl
with default options.
+=item This use of my() in false conditional is no longer allowed
+
+(F) 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
+not to be cleared at scope exit when its declaration includes a false
+conditional. Some people have exploited this bug to achieve a kind of
+static variable. Since we intend to fix this bug, we don't want people
+relying on this behavior. You can achieve a similar static effect by
+declaring the variable in a separate block outside the function, eg
+
+ sub f { my $x if 0; return $x++ }
+
+becomes
+
+ { my $x; sub f { return $x++ } }
+
+Beginning with perl 5.10.0, you can also use C<state> variables to have
+lexicals that are initialized only once (see L<feature>):
+
+ sub f { state $x; return $x++ }
+
+This use of C<my()> in a false conditional was deprecated beginning in
+Perl 5.10 and became a fatal error in Perl 5.30.
+
=item times not implemented
(F) Your version of the C library apparently doesn't do times(). I
subroutine has been aliased, the subroutine's original name will be shown,
regardless of what name the caller used.
+=item Too many nested open parens in regex; marked by <-- HERE in m/%s/
+
+(F) You have exceeded the number of open C<"("> parentheses that haven't
+been matched by corresponding closing ones. This limit prevents eating
+up too much memory. It is initially set to 1000, but may be changed by
+setting C<${^RE_COMPILE_RECURSION_LIMIT}> to some other value. This may
+need to be done in a BEGIN block before the regular expression pattern
+is compiled.
+
=item Too many )'s
(A) You've accidentally run your script through B<csh> instead of Perl.
(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 here (and will be fatal in Perl 5.30), passed through in regex; marked by S<<-- HERE> in m/%s/
+=item Unescaped left brace in regex is passed through in regex; marked by S<<-- HERE> in m/%s/
+
+(W 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. Those that are
+not potentially ambiguous do not warn; those that are do raise a
+non-deprecation warning.
+
+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.32.
+
+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 deprecated, and one not, khw
+thinks they can't be combined as one message.
+
+=item Unescaped left brace in regex is deprecated here (and will be fatal in Perl 5.32), 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
+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
+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
+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.
+conflict with the use there of C<"{"> as a literal. Those that are
+not potentially ambiguous do not warn; those that are do raise a
+non-deprecation warning.
-In this release of Perl, some literal uses of C<{> are fatal, and some
+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
+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 cases which are still allowed will be fatal in Perl 5.32.
The contexts where no warnings or errors are raised are:
=item *
-as the first character in a pattern, or following C<^> indicating to
+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.
+as the first character following a C<"|"> indicating alternation.
=item *
=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.
+be combined as one message. Perhaps perldiag could be enhanced to
+handle this case.
=item Unescaped left brace in regex is illegal here in regex;
marked by S<<-- HERE> in m/%s/
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.
+conflict with the use there of C<"{"> as a literal. Those that are
+not potentially ambiguous do not warn; those that are do raise a
+non-deprecation warning.
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.32.
The contexts where no warnings or errors are raised are:
be combined with the digits, or the C<"+"> shouldn't be there, or
something like that. Perl can't figure out what was intended.
+=item Unexpected ']' with no following ')' in (?[... in regex; marked by
+<-- HERE in m/%s/
+
+(F) While parsing an extended character class a ']' character was
+encountered at a point in the definition where the only legal use of
+']' is to close the character class definition as part of a '])', you
+may have forgotten the close paren, or otherwise confused the parser.
+
=item Unexpected '(' with no preceding operator in regex; marked by
S<<-- HERE> in m/%s/
raised by default even if warnings are not enabled, and currently
the only way to do that in Perl is to mark it as serious.
+=item Unicode property wildcard not terminated
+
+(F) A Unicode property wildcard looks like a delimited regular
+expression pattern (all within the braces of the enclosing C<\p{...}>.
+The closing delimtter to match the opening one was not found. If the
+opening one is escaped by preceding it with a backslash, the closing one
+must also be so escaped.
+
=item Unicode surrogate U+%X is illegal in UTF-8
(S surrogate) You had a UTF-16 surrogate in a context where they are
also happen if the C<\N{}> is not in the scope of the corresponding
C<S<use charnames>>.
+=item Unknown '(*...)' construct '%s' in regex; marked by <-- HERE in m/%s/
+
+(F) The C<(*> was followed by something that the regular expression
+compiler does not recognize. Check your spelling.
+
=item Unknown error
(P) Perl was about to print an error message in C<$@>, but the C<$@> variable
did not exist, even after an attempt to create it.
+=item Unknown locale category %d; can't set it to %s
+
+(W locale) You used a locale category that perl doesn't recognize, so it
+cannot carry out your request. Check that you are using a valid
+category. If so, see L<perllocale/Multi-threaded> for advice on
+reporting this as a bug, and for modifying perl locally to accommodate
+your needs.
+
=item Unknown open() mode '%s'
(F) The second argument of 3-argument open() is not among the list
(F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition must be one of the following:
- (1) (2) ... true if 1st, 2nd, etc., capture matched
- (<NAME>) ('NAME') true if named capture matched
- (?=...) (?<=...) true if subpattern matches
- (?!...) (?<!...) true if subpattern fails to match
- (?{ CODE }) true if code returns a true value
- (R) true if evaluating inside recursion
- (R1) (R2) ... true if directly inside capture group 1, 2, etc.
- (R&NAME) true if directly inside named capture
- (DEFINE) always false; for defining named subpatterns
+ (1) (2) ... true if 1st, 2nd, etc., capture matched
+ (<NAME>) ('NAME') true if named capture matched
+ (?=...) (?<=...) true if subpattern matches
+ (*pla:...) (*plb:...) true if subpattern matches; also
+ (*positive_lookahead:...)
+ (*positive_lookbehind:...)
+ (*nla:...) (*nlb:...) true if subpattern fails to match; also
+ (*negative_lookahead:...)
+ (*negative_lookbehind:...)
+ (?{ CODE }) true if code returns a true value
+ (R) true if evaluating inside recursion
+ (R1) (R2) ... true if directly inside capture group 1, 2,
+ etc.
+ (R&NAME) true if directly inside named capture
+ (DEFINE) always false; for defining named subpatterns
The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
(F) Your machine doesn't support the Berkeley socket mechanism, or at
least that's what Configure thought.
+=item Unterminated '(*...' argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*...:...)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
=item Unterminated attribute list
(F) The lexer found something other than a simple identifier at the
compressed integer format and could not be converted to an integer.
See L<perlfunc/pack>.
+=item Unterminated '(*...' construct in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*...)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
=item Unterminated delimiter for here document
(F) This message occurs when a here document label has an initial
(F) The "use" keyword is recognized and executed at compile time, and
returns no useful value. See L<perlmod>.
-=item Use of assignment to $[ is deprecated
-
-(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 forbidden
(F) You are now required to use the explicitly quoted form if you wish
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 not allowed; the permissible max is 0x%s.
+=item Use of code point 0x%s is not allowed; the permissible max is 0x%x
+
+=item Use of code point 0x%s is not allowed; the permissible max is 0x%x
+in regex; marked by <-- HERE in m/%s/
(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
This was deprecated in Perl 5.12.
+=item Use of '%s' in \p{} or \P{} is deprecated because: %s
+
+(D deprecated) Certain properties are deprecated by Unicode, and may
+eventually be removed from the Standard, at which time Perl will follow
+along. In the meantime, this message is raised to notify you.
+
=item Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed
(F) As an accidental feature, C<AUTOLOAD> subroutines were looked up as
operators treat their operands as strings of bytes, and values beyond
0xFF are nonsensical in this context.
-This became fatal in Perl 5.28.
+Certain instances became fatal in Perl 5.28; others in perl 5.32.
-=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
+=item Use of strings with code points over 0xFF as arguments to vec is forbidden
-(D deprecated) You tried to use L<C<vec>|perlfunc/vec EXPR,OFFSET,BITS>
+(F) 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.
-Such usage will be a fatal error in Perl 5.32.
+This became fatal 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 5.30
+delimiter is not allowed
-(D deprecated)
+(F)
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
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
+accept graphemes as delimiters, we cannot allow 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
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.
+their use is legal.
=item Use of uninitialized value%s
(W regexp) You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a
portion of a regular expression where the character set modifiers C</a>
or C</aa> are in effect. These two modifiers indicate an ASCII
-interpretation, and this doesn't make sense for a Unicode defintion.
+interpretation, and this doesn't make sense for a Unicode definition.
The generated regular expression will compile so that the boundary uses
all of Unicode. No other portion of the regular expression is affected.
=item Variable length lookbehind not implemented in regex m/%s/
-(F) Lookbehind is allowed only for subexpressions whose length is fixed and
+(F) B<This message no longer should be raised as of Perl 5.30.> It is
+retained in this document as a convenience for people using an earlier
+Perl version.
+
+In Perl 5.30 and earlier, 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<(?<=pattern) and \K in perlre|perlre/\K>.
=item "%s" variable %s masks earlier declaration in same %s
-(W misc) A "my", "our" or "state" variable has been redeclared in the
+(W shadow) A "my", "our" or "state" variable has been redeclared in the
current scope or statement, effectively eliminating all access to the
previous instance. This is almost always a typographical error. Note
that the earlier variable will still exist until the end of the scope
=item Wide character in %s
-(S utf8) Perl met a wide character (>255) when it wasn't expecting
-one. This warning is by default on for I/O (like print). The easiest
-way to quiet this warning is simply to add the C<:utf8> layer to the
-output, e.g. C<binmode STDOUT, ':utf8'>. Another way to turn off the
-warning is to add C<no warnings 'utf8';> but that is often closer to
+(S utf8) Perl met a wide character (ordinal >255) when it wasn't
+expecting one. This warning is by default on for I/O (like print).
+
+If this warning does come from I/O, the easiest
+way to quiet it is simply to add the C<:utf8> layer, I<e.g.>,
+S<C<binmode STDOUT, ':utf8'>>. Another way to turn off the warning is
+to add S<C<no warnings 'utf8';>> but that is often closer to
cheating. In general, you are supposed to explicitly mark the
filehandle with an encoding, see L<open> and L<perlfunc/binmode>.
+If the warning comes from other than I/O, this diagnostic probably
+indicates that incorrect results are being obtained. You should examine
+your code to determine how a wide character is getting to an operation
+that doesn't handle them.
+
=item Wide character (U+%X) in %s
(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8
(F) And you probably never will, because you probably don't have the
sources to your kernel, and your vendor probably doesn't give a rip
-about what you want. Your best bet is to put a setuid C wrapper around
-your script.
+about what you want. There is a vulnerability anywhere that you have a
+set-id script, and to close it you need to remove the set-id bit from
+the script that you're attempting to run. To actually run the script
+set-id, your best bet is to put a set-id C wrapper around your script.
=item You need to quote "%s"
https://perl5.git.perl.org / perl5.git / blobdiff