you thought. Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, parenthesis pair or declaration.
+=item Ambiguous use of -%s resolved as -&%s()
+
+(S ambiguous) You wrote something like C<-foo>, which might be the
+string C<"-foo">, or a call to the function C<foo>, negated. If you meant
+the string, just write C<"-foo">. If you meant the function call,
+write C<-foo()>.
+
=item Ambiguous use of %c resolved as operator %c
(S ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
that does not coincide with a built-in keyword, or by simply turning
off warnings with C<no warnings 'ambiguous';>.
-=item Ambiguous use of -%s resolved as -&%s()
-
-(S ambiguous) You wrote something like C<-foo>, which might be the
-string C<"-foo">, or a call to the function C<foo>, negated. If you meant
-the string, just write C<"-foo">. If you meant the function call,
-write C<-foo()>.
-
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
didn't explicitly request the failing operation, it may be the
result of the value of the environment variable PERLIO.
-=item Argument "%s" treated as 0 in increment (++)
-
-(W numeric) The indicated string was fed as an argument to the C<++>
-operator which expects either a number or a string matching
-C</^[a-zA-Z]*[0-9]*\z/>. See L<perlop/Auto-increment and
-Auto-decrement> for details.
-
-=item Array @%s missing the @ in argument %d of %s()
-
-(D deprecated) Really old Perl let you omit the @ on array names in some
-spots. This is now heavily deprecated.
-
-=item A sequence of multiple spaces in a charnames alias definition is deprecated
+=item charnames alias definitions may not contain a sequence of multiple spaces
-(D deprecated) You defined a character name which had multiple space
+(F) You defined a character name which had multiple space
characters in a row. Change them to single spaces. Usually these
names are defined in the C<:alias> import argument to C<use charnames>, but
they could be defined by a translator installed into C<$^H{charnames}>.
See L<charnames/CUSTOM ALIASES>.
+=item charnames alias definitions may not contain trailing white-space
+
+(F) You defined a character name which ended in a space
+character. Remove the trailing space(s). Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>.
+See L<charnames/CUSTOM ALIASES>.
+
=item assertion botched: %s
(X) The malloc package that comes with Perl had an internal failure.
-=item Assertion failed: file "%s"
+=item Assertion %s failed: file "%s", line %d
(X) A general assertion failed. The file in question must be examined.
must either both be scalars or both be lists. Otherwise Perl won't
know which context to supply to the right side.
-=item A thread exited while %d threads were running
-
-(W threads)(S) When using threaded Perl, a thread (not necessarily
-the main thread) exited while there were still other threads running.
-Usually it's a good idea first to collect the return values of the
-created threads by joining them, and only then to exit from the main
-thread. See L<threads>.
-
=item Attempt to access disallowed key '%s' in a restricted hash
(F) The failing code has attempted to get or set a key which is not in
mortalized when it shouldn't have been, or that memory has been
corrupted.
-=item Attempt to join self
-
-(F) You tried to join a thread from within itself, which is an
-impossible task. You may be joining the wrong thread, or you may need
-to move the join() to some other thread.
-
=item Attempt to pack pointer to temporary value
(W pack) You tried to pass a temporary value (like the result of a
obsolete, has had no effect since 5005 threads were removed, and
will be removed in a future release of Perl 5.
+=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
(D deprecated) You have used the attributes pragma to modify
be guaranteed (due to the errors), and since subsequent code likely
depends on its correct operation, Perl just gave up.
-=item \1 better written as $1
+=item \%d better written as $%d
(W syntax) Outside of patterns, backreferences live on as variables.
The use of backslashes is grandfathered on the right-hand side of a
(W unopened) You tried binmode() on a filehandle that was never opened.
Check your control flow and number of arguments.
-=item "\b{" is deprecated; use "\b\{" or "\b[{]" instead in regex; marked by <-- HERE in m/%s/
-
-=item "\B{" is deprecated; use "\B\{" or "\B[{]" instead in regex; marked by <-- HERE in m/%s/
-
-(D deprecated) Use of an unescaped "{" immediately following
-a C<\b> or C<\B> is now deprecated so as to reserve its use for Perl
-itself in a future release. You can either precede the brace
-with a backslash, or enclose it in square brackets; the latter
-is the way to go if the pattern delimiters are C<{}>.
-
=item Bit vector size > 32 non-portable
(W portable) Using bit vector sizes larger than 32 is non-portable.
function correctly, you may put an ampersand before the name to avoid
the warning. See L<perlsub>.
+=item Calling POSIX::%s() is deprecated
+
+(D deprecated) You called a function whose use is deprecated. See
+the function's name in L<POSIX> for details.
+
=item Cannot compress integer in pack
(F) An argument to pack("w",...) was too large to compress. The BER
though, because the inner curlies will be considered a block that loops
once. See L<perlfunc/next>.
-=item Can't open %s
-
-(F) You tried to run a perl built with MAD support with
-the PERL_XMLDUMP environment variable set, but the file
-named by that variable could not be opened.
-
=item Can't open %s: %s
(S inplace) The implicit opening of a file through use of the C<< <> >>
(F) You tried to call perl with the B<-m> switch, but you put something
other than "=" after the module name.
+=item Can't use a hash as a reference
+
+(F) You tried to use a hash as a reference, as in
+C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1
+used to allow this syntax, but shouldn't have.
+
+=item Can't use an array as a reference
+
+(F) You tried to use an array as a reference, as in
+C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.6.1 used to
+allow this syntax, but shouldn't have.
+
=item Can't use anonymous symbol table for method lookup
(F) The internal routine that does method lookup was handed a symbol
byte-order at the same time, so this combination of modifiers is not
allowed. See L<perlfunc/pack>.
+=item Can't use 'defined(@array)' (Maybe you should just omit the defined()?)
+
+(F) defined() is not useful on arrays because it
+checks for an undefined I<scalar> value. If you want to see if the
+array is empty, just use C<if (@array) { # not empty }> for example.
+
+=item Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)
+
+(F) C<defined()> is not usually right on hashes.
+
+Although C<defined %hash> is false on a plain not-yet-used hash, it
+becomes true in several non-obvious circumstances, including iterators,
+weak references, stash names, even remaining true after C<undef %hash>.
+These things make C<defined %hash> fairly useless in practice, so it now
+generates a fatal error.
+
+If a check for non-empty is what you wanted then just put it in boolean
+context (see L<perldata/Scalar values>):
+
+ if (%hash) {
+ # not empty
+ }
+
+If you had C<defined %Foo::Bar::QUUX> to check whether such a package
+variable exists then that's never really been reliable, and isn't
+a good way to enquire about the features of a package, or whether
+it's loaded, etc.
+
=item Can't use %s for loop variable
(F) Only a simple scalar variable may be used as a loop variable on a
with an assignment operator, which implies modifying the value itself.
Perhaps you need to copy the value to a temporary, and repeat that.
-=item Character following "\c" must be ASCII
+=item Character following "\c" must be printable ASCII
-(F)(D deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
-It is planned to make this fatal in all instances in Perl v5.20. In
-the cases where it isn't fatal, the character this evaluates to is
-derived by exclusive or'ing the code point of this character with 0x40.
+(F) In C<\cI<X>>, I<X> must be a printable (non-control) ASCII character.
-Note that non-alphabetic ASCII characters are discouraged here as well,
-and using non-printable ones will be deprecated starting in v5.18.
+Note that ASCII characters that don't map to control characters are
+discouraged, and will generate the warning (when enabled)
+L</""\c%c" is more clearly written simply as "%s"">.
=item Character in 'C' format wrapped in pack
unpack("s", "\x{f3}b")
-=item "\c{" is deprecated and is more clearly written as ";"
-
-(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
-to specify non-printable characters. You used it with a "{" which
-evaluates to ";", which is printable. It is planned to remove the
-ability to specify a semi-colon this way in Perl 5.20. Just use a
-semi-colon or a backslash-semi-colon without the "\c".
-
=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
(F) You had a (sub-)template that ends with a '/'. There must be
another template code following the slash. See L<perlfunc/pack>.
-=item Code point 0x%X is not Unicode, all \p{} matches fail; all \P{} matches
-succeed
-
=item Code point 0x%X is not Unicode, may not be portable
-(S utf8, non_unicode) You had a code point above the Unicode maximum
+(S non_unicode) You had a code point above the Unicode maximum
of U+10FFFF.
Perl allows strings to contain a superset of Unicode code points, up
but not higher. Code points above 0xFFFF_FFFF require larger than a
32 bit word.
-None of the Unicode or Perl-defined properties will match a non-Unicode
-code point. For example,
-
- chr(0x7FF_FFFF) =~ /\p{Any}/
-
-will not match, because the code point is not in Unicode. But
-
- chr(0x7FF_FFFF) =~ /\P{Any}/
-
-will match.
-
-This may be counterintuitive at times, as both these fail:
-
- chr(0x110000) =~ /\p{ASCII_Hex_Digit=True}/ # Fails.
- chr(0x110000) =~ /\p{ASCII_Hex_Digit=False}/ # Also fails!
-
-and both these succeed:
-
- chr(0x110000) =~ /\P{ASCII_Hex_Digit=True}/ # Succeeds.
- chr(0x110000) =~ /\P{ASCII_Hex_Digit=False}/ # Also succeeds!
-
=item %s: Command not found
(A) You've accidentally run your script through B<csh> or another shell
-shell instead of Perl. Check the #! line, or manually feed your script
+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
that it is simpler or backtracks less. (See L<perlfaq2> for information
on I<Mastering Regular Expressions>.)
-=item cond_broadcast() called on unlocked variable
-
-(W threads) Within a thread-enabled program, you tried to
-call cond_broadcast() on a variable which wasn't locked.
-The cond_broadcast() function is used to wake up another thread
-that is waiting in a cond_wait(). To ensure that the signal isn't
-sent before the other thread has a chance to enter the wait, it
-is usual for the signaling thread first to wait for a lock on
-variable. This lock attempt will only succeed after the other
-thread has entered cond_wait() and thus relinquished the lock.
-
-=item cond_signal() called on unlocked variable
-
-(W threads) Within a thread-enabled program, you tried to
-call cond_signal() on a variable which wasn't locked. The
-cond_signal() function is used to wake up another thread that
-is waiting in a cond_wait(). To ensure that the signal isn't
-sent before the other thread has a chance to enter the wait, it
-is usual for the signaling thread first to wait for a lock on
-variable. This lock attempt will only succeed after the other
-thread has entered cond_wait() and thus relinquished the lock.
-
=item connect() on closed socket %s
(W closed) You tried to do a connect on a closed socket. Did you forget
(F) The parser found inconsistencies while attempting to define an
overloaded constant. Perhaps you forgot to load the corresponding
-L<overload> pragma?.
+L<overload> pragma?
=item Constant is not %s reference
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
+=for comment
+The following are used in lib/diagnostics.t for testing two =items that
+share the same description. Changes here need to be propagated to there
+
=item Deep recursion on anonymous subroutine
=item Deep recursion on subroutine "%s"
This threshold can be changed from 100, by recompiling the F<perl> binary,
setting the C pre-processor macro C<PERL_SUB_DEPTH_WARN> to the desired value.
-=item defined(@array) is deprecated
-
-(D deprecated) defined() is not usually useful on arrays because it
-checks for an undefined I<scalar> value. If you want to see if the
-array is empty, just use C<if (@array) { # not empty }> for example.
-
-=item defined(%hash) is deprecated
-
-(D deprecated) C<defined()> is not usually right on hashes and has been
-discouraged since 5.004.
-
-Although C<defined %hash> is false on a plain not-yet-used hash, it
-becomes true in several non-obvious circumstances, including iterators,
-weak references, stash names, even remaining true after C<undef %hash>.
-These things make C<defined %hash> fairly useless in practice.
-
-If a check for non-empty is what you wanted then just put it in boolean
-context (see L<perldata/Scalar values>):
-
- if (%hash) {
- # not empty
- }
-
-If you had C<defined %Foo::Bar::QUUX> to check whether such a package
-variable exists then that's never really been reliable, and isn't
-a good way to enquire about the features of a package, or whether
-it's loaded, etc.
-
-
-=item (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in
-m/%s/
+=item (?(DEFINE)....) does not allow branches in regex; marked by
+S<<-- HERE> in m/%s/
(F) You used something like C<(?(DEFINE)...|..)> which is illegal. The
most likely cause of this error is that you left out a parenthesis inside
=item delete argument is not a HASH or ARRAY element or slice
-(F) The argument to delete() must be either a hash or array element,
+(F) The argument to C<delete> must be either a hash or array element,
such as:
$foo{$bar}
{ my $x; sub f { return $x++ } }
-Beginning with perl 5.9.4, you can also use C<state> variables to have
+Beginning with perl 5.10.0, you can also use C<state> variables to have
lexicals that are initialized only once (see L<feature>):
sub f { state $x; return $x++ }
(F) You cannot put a repeat count of any kind right after the '/' code.
See L<perlfunc/pack>.
+=item Don't know how to get file name
+
+(P) C<PerlIO_getname>, a perl internal I/O function specific to VMS, was
+somehow called on another platform. This should not happen.
+
=item Don't know how to handle magic of type \%o
(P) The internal handling of magical variables has been cursed.
(W unpack) You have applied the same modifier more than once after a
type in a pack template. See L<perlfunc/pack>.
+=item each on reference is experimental
+
+(S experimental::autoderef) C<each> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item elseif should be elsif
(S syntax) There is no keyword "elseif" in Perl because Larry thinks
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 <-- 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
an invalid file specification to Perl, or you've found a case the
conversion routines don't handle. Drat.
-=item Escape literal pattern white space under /x
-
-(D deprecated) You compiled a regular expression pattern with C</x> to
-ignore white space, and you used, as a literal, one of the characters
-that Perl plans to eventually treat as white space. The character must
-be escaped somehow, or it will work differently on a future Perl that
-does treat it as white space. The easiest way is to insert a backslash
-immediately before it, or to enclose it with square brackets. This
-change is to bring Perl into conformance with Unicode recommendations.
-Here are the five characters that generate this warning:
-U+0085 NEXT LINE,
-U+200E LEFT-TO-RIGHT MARK,
-U+200F RIGHT-TO-LEFT MARK,
-U+2028 LINE SEPARATOR,
-and
-U+2029 PARAGRAPH SEPARATOR.
-
=item Eval-group in insecure regular expression
(F) Perl detected tainted data when trying to compile a regular
assertion, but that construct is only allowed when the C<use re 'eval'>
pragma is in effect. See L<perlre/(?{ code })>.
-=item EVAL without pos change exceeded limit in regex; marked by <-- HERE in
-m/%s/
+=item EVAL without pos change exceeded limit in regex; marked by
+S<<-- HERE> in m/%s/
(F) You used a pattern that nested too many EVAL calls without consuming
any text. Restructure the pattern so that text is consumed.
=item exists argument is not a HASH or ARRAY element or a subroutine
-(F) The argument to exists() must be a hash or array element or a
+(F) The argument to C<exists> must be a hash or array element or a
subroutine with an ampersand, such as:
$foo{$bar}
=item exists argument is not a subroutine name
-(F) The argument to exists() for C<exists &sub> must be a subroutine
-name, and not a subroutine call. C<exists &sub()> will generate this
-error.
+(F) The argument to C<exists> for C<exists &sub> must be a subroutine name,
+and not a subroutine call. C<exists &sub()> will generate this error.
=item Exiting eval via %s
(W exiting) You are exiting a substitution by unconventional means, such
as a return, a goto, or a loop control statement.
-=item Expecting close bracket in regex; marked by <-- HERE in m/%s/
+=item Expecting close bracket in regex; marked by S<<-- HERE> in m/%s/
(F) You wrote something like
L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>,
but omitted the C<")">.
-=item Expecting '(?flags:(?[...' in regex; marked by <-- HERE in m/%s/
+=item Expecting '(?flags:(?[...' in regex; marked by S<<-- HERE> in m/%s/
(F) The C<(?[...])> extended character class regular expression construct
only allows character classes (including character class escapes like
have some other C<(?...)> construct inside your character class. See
L<perlrecharclass/Extended Bracketed Character Classes>.
+=item Experimental subroutine signatures not enabled
+
+(F) To use subroutine signatures, you must first enable them:
+
+ no warnings "experimental::signatures";
+ use feature "signatures";
+ sub foo ($left, $right) { ... }
+
=item Experimental "%s" subs not enabled
(F) To use lexical subs, you must first enable them:
CHECK, INIT, or END subroutine. Processing of the remainder of the
queue of such routines has been prematurely ended.
-=item False [] range "%s" in regex; marked by <-- HERE in m/%s/
+=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
character, not another character class like C<\d> or C<[:alpha:]>. The "-"
in your false range is interpreted as a literal "-". In a C<(?[...])>
construct, this is an error, rather than a warning. Consider quoting
-the "-", "\-". The <-- HERE shows whereabouts in the regular expression
+the "-", "\-". The S<<-- HERE> shows whereabouts in the regular expression
the problem was discovered. See L<perlre>.
=item Fatal VMS error (status=%d) at %s, line %d
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=item gmtime(%f) failed
+
+(W overflow) You called C<gmtime> with a number that it could not handle:
+too large, too small, or NaN. The returned value is C<undef>.
+
=item gmtime(%f) too large
(W overflow) You called C<gmtime> with a number that was larger than
has since been undefined.
=item Group name must start with a non-digit word character in regex; marked by
-<-- HERE in m/%s/
+S<<-- HERE> in m/%s/
(F) Group names must follow the rules for perl identifiers, meaning
they must start with a non-digit word character. A common cause of
to have existed already, but for some reason it didn't, and had to be
created on an emergency basis to prevent a core dump.
-=item Hash %%s missing the % in argument %d of %s()
-
-(D deprecated) Really old Perl let you omit the % on hash names in some
-spots. This is now heavily deprecated.
-
=item %s has too many errors
(F) The parser has given up trying to parse the program after 10 errors.
names (like C<$A::B>). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
-=item Ignoring zero length \N{} in character class in regex; marked by <-- HERE in m/%s/
+=item Ignoring zero length \N{} in character class in regex; marked by
+S<<-- HERE> in m/%s/
(W regexp) Named Unicode character escapes C<(\N{...})> may return a
zero-length sequence. When such an escape is used in a character class
(W illegalproto) An illegal character was found in a prototype declaration.
Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
+Perhaps you were trying to write a subroutine signature but didn't enable
+that feature first (C<use feature 'signatures'>), so your signature was
+instead interpreted as a bad prototype.
=item Illegal declaration of anonymous subroutine
(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 pattern in regex; marked by <-- HERE in m/%s/
+=item Illegal pattern in regex; marked by S<<-- HERE> in m/%s/
(F) You wrote something like
capturing group. See
L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>.
+=item Illegal suidscript
+
+(F) The script run under suidperl was somehow illegal.
+
=item Illegal switch in PERL5OPT: -%c
(X) The PERL5OPT environment variable may only be used to set the
Failure of user callbacks dispatched using the C<G_KEEPERR> flag could
also result in this warning. See L<perlcall/G_KEEPERR>.
-=item Incomplete expression within '(?[ ])' in regex; marked by <-- HERE in m/%s/
+=item Incomplete expression within '(?[ ])' in regex; marked by S<<-- HERE>
+in m/%s/
(F) There was a syntax error within the C<(?[ ])>. This can happen if the
expression inside the construct was completely empty, or if there are
context. Constructions such as C<state (@a) = foo()> will be
supported in a future perl release.
+=item %%s[%s] in scalar context better written as $%s[%s]
+
+(W syntax) In scalar context, you've used an array index/value slice
+(indicated by %) to select a single element of an array. Generally
+it's better to ask for a scalar value (indicated by $). The difference
+is that C<$foo[&bar]> always behaves like a scalar, both in the value it
+returns and when evaluating its argument, while C<%foo[&bar]> provides
+a list context to its subscript, which can do weird things if you're
+expecting only one subscript. When called in list context, it also
+returns the index (what C<&bar> returns) in addition to the value.
+
+=item %%s{%s} in scalar context better written as $%s{%s}
+
+(W syntax) In scalar context, you've used a hash key/value slice
+(indicated by %) to select a single element of a hash. Generally it's
+better to ask for a scalar value (indicated by $). The difference
+is that C<$foo{&bar}> always behaves like a scalar, both in the value
+it returns and when evaluating its argument, while C<@foo{&bar}> and
+provides a list context to its subscript, which can do weird things
+if you're expecting only one subscript. When called in list context,
+it also returns the key in addition to the value.
+
=item Insecure dependency in %s
(F) You tried to do something that the tainting mechanism didn't like.
function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
-=item In '(?...)', splitting the initial '(?' is deprecated in regex; marked by <-- HERE in m/%s/
+=item In '(?...)', the '(' and '?' must be adjacent in regex;
+marked by S<<-- HERE> in m/%s/
-(D regexp, deprecated) The two-character sequence C<"(?"> in
+(F) The two-character sequence C<"(?"> in
this context in a regular expression pattern should be an
indivisible token, with nothing intervening between the C<"(">
-and the C<"?">, but you separated them. Due to an accident of
-implementation, this prohibition was not enforced, but we do
-plan to forbid it in a future Perl version. This message
-serves as giving you fair warning of this pending change.
+and the C<"?">, but you separated them.
=item Integer overflow in format string for %s
element larger than typically 2**32. This is usually caused by trying
to use some odd mathematical operation as a version, like 100/9.
-=item Internal disaster in regex; marked by <-- HERE in m/%s/
+=item Internal disaster in regex; marked by S<<-- HERE> in m/%s/
(P) Something went badly wrong in the regular expression parser.
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item Internal inconsistency in tracking vforks
message, then an XS module tried to call that routine with one such
reserved format.
-=item Internal urp in regex; marked by <-- HERE in m/%s/
+=item Internal urp in regex; marked by S<<-- HERE> in m/%s/
(P) Something went badly awry in the regular expression parser. The
-<-- HERE shows whereabouts in the regular expression the problem was
+S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item %s (...) interpreted as function
(F) The indicated attributes for a subroutine or variable were not
recognized by Perl or by a user-supplied handler. See L<attributes>.
-=item Invalid character in charnames alias definition; marked by <-- HERE in '%s
+=item Invalid character in charnames alias definition; marked by
+S<<-- HERE> in '%s
(F) You tried to create a custom alias for a character name, with
the C<:alias> option to C<use charnames> and the specified character in
the indicated name isn't valid. See L<charnames/CUSTOM ALIASES>.
-=item Invalid character in \N{...}; marked by <-- HERE in \N{%s}
-
-(F) Only certain characters are valid for character names. The
-indicated one isn't. See L<charnames/CUSTOM ALIASES>.
-
=item Invalid \0 character in %s for %s: %s\0%s
(W syscalls) Embedded \0 characters in pathnames or other system call
arguments produce a warning as of 5.20. The parts after the \0 were
formerly ignored by system calls.
+=item Invalid character in \N{...}; marked by S<<-- HERE> in \N{%s}
+
+(F) Only certain characters are valid for character names. The
+indicated one isn't. See L<charnames/CUSTOM ALIASES>.
+
=item Invalid conversion in %s: "%s"
(W printf) Perl does not understand the given format conversion. See
L<perlfunc/sprintf>.
-=item Invalid escape in the specified encoding in regex; marked by <-- HERE in
-m/%s/
+=item Invalid escape in the specified encoding in regex; marked by
+S<<-- HERE> in m/%s/
-(W regexp) The numeric escape (for example C<\xHH>) of value < 256
+(W regexp)(F) The numeric escape (for example C<\xHH>) of value < 256
didn't correspond to a single character through the conversion
from the encoding specified by the encoding pragma.
-The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead.
-The <-- HERE shows whereabouts in the regular expression the
+The escape was replaced with REPLACEMENT CHARACTER (U+FFFD)
+instead, except within S<C<(?[ ])>>, where it is a fatal error.
+The S<<-- HERE> shows whereabouts in the regular expression the
escape was discovered.
=item Invalid hexadecimal number in \N{U+...}
-=item Invalid hexadecimal number in \N{U+...} in regex; marked by <-- HERE in
-m/%s/
+=item Invalid hexadecimal number in \N{U+...} in regex; marked by
+S<<-- HERE> in m/%s/
(F) The character constant represented by C<...> is not a valid hexadecimal
number. Either it is empty, or you tried to use a character other than
with the B<-D> option with no flags to see the list of acceptable values.
See also L<perlrun/-Dletters>.
-=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
+=item Invalid [] range "%s" in regex; marked by S<<-- HERE> in m/%s/
(F) The range specified in a character class had a minimum character
greater than the maximum character. One possibility is that you forgot the
C<{}> from your ending C<\x{}> - C<\x> without the curly braces can go only
-up to C<ff>. The <-- HERE shows whereabouts in the regular expression the
+up to C<ff>. The S<<-- HERE> shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
=item Invalid range "%s" in transliteration operator
Perhaps the internals were modified directly in some way or
an arbitrary reference was blessed into the "version" class.
-=item In '(*VERB...)', splitting the initial '(*' is deprecated in regex; marked by <-- HERE in m/%s/
+=item In '(*VERB...)', the '(' and '*' must be adjacent in regex;
+marked by S<<-- HERE> in m/%s/
-(D regexp, deprecated) The two-character sequence C<"(*"> in
+(F) The two-character sequence C<"(*"> in
this context in a regular expression pattern should be an
indivisible token, with nothing intervening between the C<"(">
-and the C<"*">, but you separated them. Due to an accident of
-implementation, this prohibition was not enforced, but we do
-plan to forbid it in a future Perl version. This message
-serves as giving you fair warning of this pending change.
+and the C<"*">, but you separated them.
=item ioctl is not implemented
=item $* is no longer supported
(D deprecated, syntax) The special variable C<$*>, deprecated in older
-perls, has been removed as of 5.9.0 and is no longer supported. In
+perls, has been removed as of 5.10.0 and is no longer supported. In
previous versions of perl the use of C<$*> enabled or disabled multi-line
matching within a string.
=item $# is no longer supported
(D deprecated, syntax) The special variable C<$#>, deprecated in older
-perls, has been removed as of 5.9.3 and is no longer supported. You
+perls, has been removed as of 5.10.0 and is no longer supported. You
should use the printf/sprintf functions instead.
=item '%s' is not a code reference
(P) The regular expression parser is confused.
+=item keys on reference is experimental
+
+(S experimental::autoderef) C<keys> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Label not found for "last %s"
(F) You named a loop to break out of, but you're not currently in a loop
form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>.
Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead.
+=item localtime(%f) failed
+
+(W overflow) You called C<localtime> with a number that it could not handle:
+too large, too small, or NaN. The returned value is C<undef>.
+
=item localtime(%f) too large
(W overflow) You called C<localtime> with a number that was larger
syntax of function prototypes is given a brief compile-time check for
obvious errors like invalid characters. A more rigorous check is run
when the function is called.
+Perhaps the function's author was trying to write a subroutine signature
+but didn't enable that feature first (C<use feature 'signatures'>),
+so the signature was instead interpreted as a bad prototype.
=item Malformed UTF-8 character (%s)
(F) Perl thought it was reading UTF-16 encoded character data but while
doing it Perl met a malformed Unicode surrogate.
-=item %s matches null string many times in regex; marked by <-- HERE in m/%s/
+=item Mandatory parameter follows optional parameter
+
+(F) In a subroutine signature, you wrote something like "$a = undef,
+$b", making an earlier parameter optional and a later one mandatory.
+Parameters are filled from left to right, so it's impossible for the
+caller to omit an earlier one and pass a later one. If you want to act
+as if the parameters are filled from right to left, declare the rightmost
+optional and then shuffle the parameters around in the subroutine's body.
+
+=item Matched non-Unicode code point 0x%X against Unicode property; may
+not be portable
+
+(S non_unicode) Perl allows strings to contain a superset of
+Unicode code points; each code point may be as large as what is storable
+in an unsigned integer on your system, but these may not be accepted by
+other languages/systems. This message occurs when you matched a string
+containing such a code point against a regular expression pattern, and
+the code point was matched against a Unicode property, C<\p{...}> or
+C<\P{...}>. Unicode properties are only defined on Unicode code points,
+so the result of this match is undefined by Unicode, but Perl (starting
+in v5.20) treats non-Unicode code points as if they were typical
+unassigned Unicode ones, and matched this one accordingly. Whether a
+given property matches these code points or not is specified in
+L<perluniprops/Properties accessible through \p{} and \P{}>.
+
+This message is suppressed (unless it has been made fatal) if it is
+immaterial to the results of the match if the code point is Unicode or
+not. For example, the property C<\p{ASCII_Hex_Digit}> only can match
+the 22 characters C<[0-9A-Fa-f]>, so obviously all other code points,
+Unicode or not, won't match it. (And C<\P{ASCII_Hex_Digit}> will match
+every code point except these 22.)
+
+Getting this message indicates that the outcome of the match arguably
+should have been the opposite of what actually happened. If you think
+that is the case, you may wish to make the C<non_unicode> warnings
+category fatal; if you agree with Perl's decision, you may wish to turn
+off this category.
+
+See L<perlunicode/Beyond Unicode code points> for more information.
+
+=item %s matches null string many times in regex; marked by S<<-- HERE> in
+m/%s/
(W regexp) The pattern you've specified would be an infinite loop if the
-regular expression engine didn't specifically check for that. The <-- HERE
+regular expression engine didn't specifically check for that. The S<<-- HERE>
shows whereabouts in the regular expression the problem was discovered.
See L<perlre>.
=item Missing braces on \N{}
-=item Missing braces on \N{} in regex; marked by <-- HERE in m/%s/
+=item Missing braces on \N{} in regex; marked by S<<-- HERE> in m/%s/
(F) Wrong syntax of character name literal C<\N{charname}> within
double-quotish context. This can also happen when there is a space
(F) A double-quoted string ended with "\c", without the required control
character name.
+=item Missing ']' in prototype for %s : %s
+
+(W illegalproto) A grouping was started with C<[> but never closed with C<]>.
+
=item Missing name in "%s sub"
-(F) The reserved syntax for lexically scoped subroutines requires that
+(F) The syntax for lexically scoped subroutines requires that
they have a name with which they can be found.
=item Missing $ on loop variable
are always mentioned with the $ in Perl, unlike in the shells, where it
can vary from one line to the next.
-=item Missing ']' in prototype for %s : %s
-
-(W illegalproto) A grouping was started with C<[> but never closed with
-C<]>.
-
=item (Missing operator before %s?)
(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 right brace on \%c{} in regex; marked by <-- HERE in m/%s/
+=item Missing right brace on \%c{} in regex; marked by S<<-- HERE> in m/%s/
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
list of arguments, but have forgotten to specify a piped open mode.
See L<perlfunc/open> for details.
+=item mprotect for COW string %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_COW (see
+L<perlguts/"Copy on Write">), but a shared string buffer
+could not be made read-only.
+
=item mprotect for %p %u failed with %d
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see L<perlhacktips>),
+but an op tree could not be made read-only.
+
+=item mprotect RW for COW string %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_COW (see
+L<perlguts/"Copy on Write">), but a read-only shared string
+buffer could not be made mutable.
+
=item mprotect RW for %p %u failed with %d
(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see
-L<perlhacktips>), but an op tree could not be made read-only, or a
-read-only op tree could not be made mutable before freeing the ops.
+L<perlhacktips>), but a read-only op tree could not be made
+mutable before freeing the ops.
=item msg%s not implemented
=item Name "%s::%s" used only once: possible typo
-(W once) Typographical errors often show up as unique variable names.
-If you had a good reason for having a unique name, then just mention it
-again somehow to suppress the message. The C<our> declaration is provided
-for this purpose.
+(W once) Typographical errors often show up as unique variable
+names. If you had a good reason for having a unique name, then
+just mention it again somehow to suppress the message. The C<our>
+declaration is also provided for this purpose.
-NOTE: This warning detects symbols that have been used only once so $c, @c,
-%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
-the same; if a program uses $c only once but also uses any of the others it
-will not trigger this warning. Symbols beginning with an underscore and
-symbols using special identifiers (q.v. L<perldata>) are exempt from this
-warning.
+NOTE: This warning detects package symbols that have been used only
+once. This means lexical variables will never trigger this warning.
+It also means that all of the package variables $c, @c, %c, as well
+as *c, &c, sub c{}, c(), and c (the filehandle or
+format) are considered the same; if a program uses $c only once
+but also uses any of the others it will not trigger this warning.
+Symbols beginning with an underscore and symbols using special
+identifiers (q.v. L<perldata>) are exempt from this warning.
-=item Need exactly 3 octal digits in regex; marked by <-- HERE in m/%s/
+=item Need exactly 3 octal digits in regex; marked by S<<-- HERE> in m/%s/
(F) Within S<C<(?[ ])>>, all constants interpreted as octal need to be
exactly 3 digits long. This helps catch some ambiguities. If your
(F) When C<vec> is called in an lvalue context, the second argument must be
greater than or equal to zero.
-=item Nested quantifiers in regex; marked by <-- HERE in m/%s/
+=item Nested quantifiers in regex; marked by S<<-- HERE> in m/%s/
(F) You can't quantify a quantifier without intervening parentheses.
-So things like ** or +* or ?* are illegal. The <-- HERE shows
+So things like ** or +* or ?* are illegal. The S<<-- HERE> shows
whereabouts in the regular expression the problem was discovered.
Note that the minimal matching quantifiers, C<*?>, C<+?>, and
See L<mro>.
=item \N in a character class must be a named character: \N{...} in regex;
-marked by <-- HERE in m/%s/
+marked by S<<-- HERE> in m/%s/
+
+(F) The new (as of Perl 5.12) meaning of C<\N> as C<[^\n]> is not valid in a
+bracketed character class, for the same reason that C<.> in a character
+class loses its specialness: it matches almost everything, which is
+probably not what you want.
+
+=item \N{} in character class restricted to one character in regex; marked
+by S<<-- HERE> in m/%s/
-(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in
-a bracketed character class, for the same reason that C<.> in
-a character class loses its specialness: it matches almost
-everything, which is probably not what you want.
+(F) Named Unicode character escapes C<(\N{...})> may return a
+multi-character sequence. Such an escape may not be used in
+a character class, because character classes always match one
+character of input. Check that the correct escape has been used,
+and the correct charname handler is in scope. The S<<-- HERE> shows
+whereabouts in the regular expression the problem was discovered.
-=item \N{NAME} must be resolved by the lexer in regex; marked by <-- HERE in m/%s/
+=item \N{NAME} must be resolved by the lexer in regex; marked by
+S<<-- HERE> in m/%s/
(F) When compiling a regex pattern, an unresolved named character or
sequence was encountered. This can happen in any of several ways that
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
it throwing an exception, use C<maybe::next::method>
or C<next::can>. See L<mro>.
-=item Non-hex character in regex; marked by <-- HERE in m/%s/
+=item Non-hex character in regex; marked by S<<-- HERE> in m/%s/
(F) In a regular expression, there was a non-hexadecimal character where
a hex one was expected, like
(?[ [ \xDG ] ])
(?[ [ \x{DEKA} ] ])
-=item Non-octal character in regex; marked by <-- HERE in m/%s/
+=item Non-octal character in regex; marked by S<<-- HERE> in m/%s/
(F) In a regular expression, there was a non-octal character where
an octal one was expected, like
of Perl. Check the #! line, or manually feed your script into Perl
yourself.
-=item (?[...]) not valid in locale in regex; marked by <-- HERE in m/%s/
+=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
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
+=item Odd name/value argument for subroutine
+
+(F) A subroutine using a slurpy hash parameter in its signature
+received an odd number of arguments to populate the hash. It requires
+the arguments to be paired, with the same number of keys as values.
+The caller of the subroutine is presumably at fault. Inconveniently,
+this error will be reported at the location of the subroutine, not that
+of the caller.
+
=item Odd number of arguments for overload::constant
(W overload) The call to overload::constant contained an odd number of
Although legal, this idiom might render your code confusing
and is deprecated.
-=item Operand with no preceding operator in regex; marked by <-- HERE in m/%s/
+=item Operand with no preceding operator in regex; marked by S<<-- HERE> in
+m/%s/
(F) You wrote something like
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(S utf8, non_unicode) You performed an operation requiring Unicode
-semantics on a code point that is not in Unicode, so what it should do
-is not defined. Perl has chosen to have it do nothing, and warn you.
+(S non_unicode) You performed an operation requiring Unicode semantics
+on a code point that is not in Unicode, so what it should do is not
+defined. Perl has chosen to have it do nothing, and warn you.
If the operation shown is "ToFold", it means that case-insensitive
matching in a regular expression was done on the code point.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(S utf8, surrogate) You performed an operation requiring Unicode
-semantics on a Unicode surrogate. Unicode frowns upon the use of
-surrogates for anything but storing strings in UTF-16, but semantics
-are (reluctantly) defined for the surrogates, and they are to do
-nothing for this operation. Because the use of surrogates can be
-dangerous, Perl warns.
+(S surrogate) You performed an operation requiring Unicode
+semantics on a Unicode surrogate. Unicode frowns upon the use
+of surrogates for anything but storing strings in UTF-16, but
+semantics are (reluctantly) defined for the surrogates, and
+they are to do nothing for this operation. Because the use of
+surrogates can be dangerous, Perl warns.
If the operation shown is "ToFold", it means that case-insensitive
matching in a regular expression was done on the code point.
example, if you say "*foo *foo" it will be interpreted as if you said
"*foo * 'foo'".
+=item Optional parameter lacks default expression
+
+(F) In a subroutine signature, you wrote something like "$a =", making a
+named optional parameter without a default value. A nameless optional
+parameter is permitted to have no default value, but a named one must
+have a specific default. You probably want "$a = undef".
+
=item "our" variable %s redeclared
(W misc) You seem to have already declared the same global once before
=item panic: kid popen errno read
-(F) forked child returned an incomprehensible message about its errno.
+(F) A forked child returned an incomprehensible message about its errno.
=item panic: last, type=%u
=item panic: memory wrap
-(P) Something tried to allocate more memory than possible.
+(P) Something tried to allocate either more memory than possible or a
+negative amount.
=item panic: pad_alloc, %p!=%p
(P) scan_num() got called on something that wasn't a number.
-=item panic: Sequence (?{...}): no code block found
+=item panic: Sequence (?{...}): no code block found in regex m/%s/
-(P) while compiling a pattern that has embedded (?{}) or (??{}) code
+(P) While compiling a pattern that has embedded (?{}) or (??{}) code
blocks, perl couldn't locate the code block that should have already been
seen and compiled by perl before control passed to the regex compiler.
"Can't locate object method \"%s\" via package \"%s\"". It often means
that a method requires a package that has not been loaded.
-=item Perl folding rules are not up-to-date for 0x%X; please use the perlbug
-utility to report; in regex; marked by <-- HERE in m/%s/
+=item Perl folding rules are not up-to-date for 0x%X; please use the perlbug
+utility to report; in regex; marked by S<<-- HERE> in m/%s/
(S regexp) You used a regular expression with case-insensitive matching,
and there is a bug in Perl in which the built-in regular expression
Both numeric and string values are accepted, but note that string values are
case sensitive. The default for this setting is "RANDOM" or 1.
+=item PerlIO layer ':win32' is experimental
+
+(S experimental::win32_perlio) The C<:win32> PerlIO layer is
+experimental. If you want to take the risk of using this layer,
+simply disable this warning:
+
+ no warnings "experimental::win32_perlio";
+
=item pid %x not a child
(W exec) A warning peculiar to VMS. Waitpid() was asked to wait for a
(F) The unpack format P must have an explicit size, not "*".
-=item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
+=item pop on reference is experimental
-(F) The class in the character class [: :] syntax is unknown. The <-- HERE
+(S experimental::autoderef) C<pop> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
+=item POSIX class [:%s:] unknown in regex; marked by S<< <-- HERE in m/%s/ >>
+
+(F) The class in the character class [: :] syntax is unknown. The S<<-- HERE>
shows whereabouts in the regular expression the problem was discovered.
Note that the POSIX character classes do B<not> have the C<is> prefix
the corresponding C interfaces have: in other words, it's C<[[:print:]]>,
the BSD version, which takes a pid.
=item POSIX syntax [%c %c] belongs inside character classes in regex; marked by
-<-- HERE in m/%s/
+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
implemented; they are simply placeholders for future extensions and
-will cause fatal errors. The <-- HERE shows whereabouts in the regular
+will cause fatal errors. The S<<-- HERE> shows whereabouts in the regular
expression the problem was discovered. See L<perlre>.
=item POSIX syntax [. .] is reserved for future extensions in regex; marked by
-<-- HERE in m/%s/
+S<<-- HERE> in m/%s/
(F) Within regular expression character classes ([]) the syntax beginning
with "[." and ending with ".]" is reserved for future extensions. If you
need to represent those character sequences inside a regular expression
character class, just quote the square brackets with the backslash: "\[."
-and ".\]". The <-- HERE shows whereabouts in the regular expression the
+and ".\]". The S<<-- HERE> shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
=item POSIX syntax [= =] is reserved for future extensions in regex; marked by
-<-- HERE in m/%s/
+S<<-- HERE> in m/%s/
(F) Within regular expression character classes ([]) the syntax beginning
with "[=" and ending with "=]" is reserved for future extensions. If you
need to represent those character sequences inside a regular expression
character class, just quote the square brackets with the backslash: "\[="
-and "=\]". The <-- HERE shows whereabouts in the regular expression the
+and "=\]". The S<<-- HERE> shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
=item Possible attempt to put comments in qw() list
end of the buffer just in case. This sentinel byte got clobbered, and
Perl assumes that memory is now corrupted. See L<perlfunc/ioctl>.
-=item Possible precedence problem on bitwise %c operator
-
-(W precedence) Your program uses a bitwise logical operator in conjunction
-with a numeric comparison operator, like this :
-
- if ($x & $y == 0) { ... }
-
-This expression is actually equivalent to C<$x & ($y == 0)>, due to the
-higher precedence of C<==>. This is probably not what you want. (If you
-really meant to write this, disable the warning, or, better, put the
-parentheses explicitly and write C<$x & ($y == 0)>).
-
=item Possible precedence issue with control flow operator
(W syntax) There is a possible problem with the mixing of a control
sub { 1 if die; }
+=item Possible precedence problem on bitwise %c operator
+
+(W precedence) Your program uses a bitwise logical operator in conjunction
+with a numeric comparison operator, like this :
+
+ if ($x & $y == 0) { ... }
+
+This expression is actually equivalent to C<$x & ($y == 0)>, due to the
+higher precedence of C<==>. This is probably not what you want. (If you
+really meant to write this, disable the warning, or, better, put the
+parentheses explicitly and write C<$x & ($y == 0)>).
+
=item Possible unintended interpolation of $\ in regex
(W ambiguous) You said something like C<m/$\/> in a regex.
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
+=item Postfix dereference is experimental
+
+(S experimental::postderef) This warning is emitted if you use
+the experimental postfix dereference syntax. 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::postderef";
+ use feature "postderef", "postderef_qq";
+ $ref->$*;
+ $aref->@*;
+ $aref->@[@indices];
+ ... etc ...
+
=item Precedence problem: open %s should be open(%s)
(S precedence) The old irregular construct
L<perlipc/"Signals">. See also "Process terminated by SIGTERM/SIGINT"
in L<perlos2>.
-=item Property '%s' is unknown in regex; marked by <-- HERE in m/%s/
+=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
(F) You've omitted the closing parenthesis in a function prototype
definition.
+=item Prototype '%s' overridden by attribute 'prototype(%s)' in %s
+
+(W prototype) A prototype was declared in both the parentheses after
+the sub name and via the prototype attribute. The prototype in
+parentheses is useless, since it will be replaced by the prototype
+from the attribute before it's ever used.
+
=item \p{} uses Unicode rules, not locale rules
(W) You compiled a regular expression that contained a Unicode property
case of that character is not in Latin1, in that locale it doesn't
change when upper cased.
-=item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
+=item push on reference is experimental
+
+(S experimental::autoderef) C<push> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
+=item Quantifier follows nothing in regex; marked by S<< <-- HERE in m/%s/ >>
(F) You started a regular expression with a quantifier. Backslash it if
-you meant it literally. The <-- HERE shows whereabouts in the regular
+you meant it literally. The S<<-- HERE> shows whereabouts in the regular
expression the problem was discovered. See L<perlre>.
-=item Quantifier in {,} bigger than %d in regex; marked by <-- HERE in m/%s/
+=item Quantifier in {,} bigger than %d in regex; marked by S<<-- HERE> in
+m/%s/
(F) There is currently a limit to the size of the min and max values of
-the {min,max} construct. The <-- HERE shows whereabouts in the regular
+the {min,max} construct. The S<<-- HERE> shows whereabouts in the regular
expression the problem was discovered. See L<perlre>.
=item Quantifier {n,m} with n > m can't match in regex
-=item Quantifier {n,m} with n > m can't match in regex; marked by <-- HERE in m/%s/
+=item Quantifier {n,m} with n > m can't match in regex; marked by
+S<<-- HERE> in m/%s/
(W regexp) Minima should be less than or equal to maxima. If you really
want your regexp to match something 0 times, just put {0}.
(W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
-=item Reference to invalid group 0 in regex; marked by <-- HERE in m/%s/
+=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
to capturing parentheses only with strictly positive integers
(normal backreferences) or with strictly negative integers (relative
backreferences). Using 0 does not make sense.
-=item Reference to nonexistent group in regex; marked by <-- HERE in m/%s/
+=item Reference to nonexistent group in regex; marked by S<<-- HERE> in
+m/%s/
(F) You used something like C<\7> in your regular expression, but there are
not at least seven sets of capturing parentheses in the expression. If
The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
-=item Reference to nonexistent named group in regex; marked by <-- HERE in m/%s/
+=item Reference to nonexistent named group in regex; marked by S<<-- HERE>
+in m/%s/
(F) You used something like C<\k'NAME'> or C<< \k<NAME> >> in your regular
expression, but there is no corresponding named capturing parentheses
The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
-=item Reference to nonexistent or unclosed group in regex; marked by <-- HERE
-in m/%s/
+=item Reference to nonexistent or unclosed group in regex; marked by
+S<<-- HERE> in m/%s/
(F) You used something like C<\g{-7}> in your regular expression, but there
are not at least seven sets of closed capturing parentheses in the
=item Regexp modifier "/%c" may appear a maximum of twice
-=item Regexp modifier "/%c" may not appear twice
+=item Regexp modifier "%c" may appear a maximum of twice in regex; marked
+by S<<-- HERE> in m/%s/
-(F syntax, regexp) The regular expression pattern had too many occurrences
+(F) The regular expression pattern had too many occurrences
of the specified modifier. Remove the extraneous ones.
=item Regexp modifier "%c" may not appear after the "-" in regex; marked by <--
expression to use the modifier you want to turn on (and place it before
the minus), instead of the one you want to turn off.
+=item Regexp modifier "/%c" may not appear twice
+
+=item Regexp modifier "%c" may not appear twice in regex; marked by <--
+HERE in m/%s/
+
+(F) The regular expression pattern had too many occurrences
+of the specified modifier. Remove the extraneous ones.
+
=item Regexp modifiers "/%c" and "/%c" are mutually exclusive
-(F syntax, regexp) The regular expression pattern had more than one of these
+=item Regexp modifiers "%c" and "%c" are mutually exclusive in regex;
+marked by S<<-- HERE> in m/%s/
+
+(F) The regular expression pattern had more than one of these
mutually exclusive modifiers. Retain only the modifier that is
supposed to be there.
=item rewinddir() attempted on invalid dirhandle %s
-(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
-really a dirhandle. Check your control flow.
+(W io) The dirhandle you tried to do a rewinddir() on is either closed
+or not really a dirhandle. Check your control flow.
=item Scalars leaked: %d
not magically convert between scalars and lists for you. See
L<perlref>.
-=item Scalar value %%s[%s] better written as $%s[%s]
-
-(W syntax) In scalar context, you've used an array index/value slice
-(indicated by %) to select a single element of an array. Generally
-it's better to ask for a scalar value (indicated by $). The difference
-is that C<$foo[&bar]> always behaves like a scalar, both in the value it
-returns and when evaluating its argument, while C<%foo[&bar]> provides
-a list context to its subscript, which can do weird things if you're
-expecting only one subscript. When called in list context, it also
-returns the index (what C<&bar> returns) in addition to the value.
-
-=item Scalar value %%s{%s} better written as $%s{%s}
-
-(W syntax) In scalar context, you've used a hash key/value slice
-(indicated by %) to select a single element of a hash. Generally it's
-better to ask for a scalar value (indicated by $). The difference
-is that C<$foo{&bar}> always behaves like a scalar, both in the value
-it returns and when evaluating its argument, while C<@foo{&bar}> and
-provides a list context to its subscript, which can do weird things
-if you're expecting only one subscript. When called in list context,
-it also returns the key in addition to the value.
-
=item Search pattern not terminated
(F) The lexer couldn't find the final delimiter of a // or m{}
construct. Remember that bracketing delimiters count nesting level.
Missing the leading C<$> from a variable C<$m> may cause this error.
-Note that since Perl 5.9.0 a // can also be the I<defined-or>
+Note that since Perl 5.10.0 a // can also be the I<defined-or>
construct, not just the empty search pattern. Therefore code written
-in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
-misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
+in Perl 5.10.0 or later that uses the // as the I<defined-or> can be
+misparsed by pre-5.10.0 Perls as a non-terminated search pattern.
=item Search pattern not terminated or ternary operator parsed as search pattern
(W closed) The socket you're sending to got itself closed sometime
before now. Check your control flow.
-=item Sequence (? incomplete in regex; marked by <-- HERE in m/%s/
+=item Sequence (? incomplete in regex; marked by S<<-- HERE> in m/%s/
(F) A regular expression ended with an incomplete extension (?. The
-<-- HERE shows whereabouts in the regular expression the problem was
+S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
-=item Sequence (?%s...) not implemented in regex; marked by <-- HERE in m/%s/
+=item Sequence (?%c...) not implemented in regex; marked by S<<-- HERE> in
+m/%s/
(F) A proposed regular expression extension has the character reserved
-but has not yet been written. The <-- HERE shows whereabouts in the
+but has not yet been written. The S<<-- HERE> shows whereabouts in the
regular expression the problem was discovered. See L<perlre>.
-=item Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/
+=item Sequence (?%s...) not recognized in regex; marked by S<<-- HERE> in
+m/%s/
-(F) You used a regular expression extension that doesn't make sense. The
-<-- HERE shows whereabouts in the regular expression the problem was
-discovered. This happens when using the C<(?^...)> construct to tell
+(F) You used a regular expression extension that doesn't make sense.
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
+discovered. This may happen when using the C<(?^...)> construct to tell
Perl to use the default regular expression modifiers, and you
redundantly specify a default modifier. For other
causes, see L<perlre>.
parenthesis. Embedded parentheses aren't allowed. See
L<perlre>.
-=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
+=item Sequence (?&... not terminated in regex; marked by S<<-- HERE> in
+m/%s/
+
+(F) A named reference of the form C<(?&...)> was missing the final
+closing parenthesis after the name. The S<<-- HERE> shows whereabouts
+in the regular expression the problem was discovered.
+
+=item Sequence (?%c... not terminated in regex; marked by S<<-- HERE>
+in m/%s/
+
+(F) A named group of the form C<(?'...')> or C<< (?<...>) >> was missing the final
+closing quote or angle bracket. The S<<-- HERE> shows whereabouts in the
+regular expression the problem was discovered.
+
+=item Sequence (?(%c... not terminated in regex; marked by S<<-- HERE>
+in m/%s/
+
+(F) A named reference of the form C<(?('...')...)> or C<< (?(<...>)...) >> was
+missing the final closing quote or angle bracket after the name. 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 regular expression expects a mandatory argument following the escape
sequence and this has been omitted or incorrectly written.
(F) The end of the perl code contained within the {...} must be
followed immediately by a ')'.
+=item Sequence ?P=... not terminated in regex; marked by S<<-- HERE> in
+m/%s/
+
+(F) A named reference of the form C<(?P=...)> was missing the final
+closing parenthesis after the name. The S<<-- HERE> shows whereabouts
+in the regular expression the problem was discovered.
+
+=item Sequence (?R) not terminated in regex 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")
(A) This is the error message generally seen in a browser window
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
+=item Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef
+
+(W deprecated) You assigned a reference to a scalar to C<$/> where the
+referenced item is not a positive integer. In older perls this B<appeared>
+to work the same as setting it to C<undef> but was in fact internally
+different, less efficient and with very bad luck could have resulted in
+your file being split by a stringified form of the reference.
+
+In Perl 5.20.0 this was changed so that it would be B<exactly> the same as
+setting C<$/> to undef, with the exception that this warning would be
+thrown.
+
+You are recommended to change your code to set C<$/> to C<undef> explicitly
+if you wish to slurp the file. In future versions of Perl assigning
+a reference to will throw a fatal error.
+
+=item Setting $/ to %s reference is forbidden
+
+(F) You tried to assign a reference to a non integer to C<$/>. In older
+Perls this would have behaved similarly to setting it to a reference to
+a positive integer, where the integer was the address of the reference.
+As of Perl 5.20.0 this is a fatal error, to allow future versions of Perl
+to use non-integer refs for more interesting purposes.
+
+=item shift on reference is experimental
+
+(S experimental::autoderef) C<shift> with a scalar argument is experimental
+and may change or be removed in a future Perl version. If you want to
+take the risk of using this feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
interpreted as the != (numeric not equal) and ~ (1's complement)
operators: probably not what you intended.
-=item <> should be quotes
+=item <> at require-statement should be quotes
(F) You wrote C<< require <file> >> when you should have written
C<require 'file'>.
it can reliably handle and C<sleep> probably slept for less time than
requested.
+=item Slurpy parameter not last
+
+(F) In a subroutine signature, you put something after a slurpy (array or
+hash) parameter. The slurpy parameter takes all the available arguments,
+so there can't be any left to fill later parameters.
+
=item Smart matching a non-overloaded object breaks encapsulation
(F) You should not use the C<~~> operator on an object that does not
try explicitly pre-extending the array by assigning $#array = $offset.
See L<perlfunc/splice>.
+=item splice on reference is experimental
+
+(S experimental::autoderef) C<splice> with a scalar argument
+is experimental and may change or be removed in a future
+Perl version. If you want to take the risk of using this
+feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Split loop
(P) The split was looping infinitely. (Obviously, a split shouldn't
(W closure) During compilation, an inner named subroutine or eval is
attempting to capture an outer lexical subroutine that is not currently
available. This can happen for one of two reasons. First, the lexical
-subroutine may be declared in an outer anonymous subroutine that has not
-yet been created. (Remember that named subs are created at compile time,
-while anonymous subs are created at run-time.) For example,
+subroutine may be declared in an outer anonymous subroutine that has
+not yet been created. (Remember that named subs are created at compile
+time, while anonymous subs are created at run-time.) For example,
sub { my sub a {...} sub f { \&a } }
-At the time that f is created, it can't capture the current the "a" sub,
+At the time that f is created, it can't capture the current "a" sub,
since the anonymous subroutine hasn't been created yet. Conversely, the
following won't give a warning since the anonymous subroutine has by now
been created and is live:
sub { my sub a {...} eval 'sub f { \&a }' }->();
-The second situation is caused by an eval accessing a variable that has
-gone out of scope, for example,
+The second situation is caused by an eval accessing a lexical subroutine
+that has gone out of scope, for example,
sub f {
my sub a {...}
Unicode characters.
=item Switch (?(condition)... contains too many branches in regex; marked by
-<-- HERE in m/%s/
+S<<-- HERE> in m/%s/
(F) A (?(condition)if-clause|else-clause) construct can have at most
two branches (the if-clause and the else-clause). If you want one or
(?(condition)(?:this|that|other)|else-clause)
-The <-- HERE shows whereabouts in the regular expression the problem
+The S<<-- HERE> shows whereabouts in the regular expression the problem
was discovered. See L<perlre>.
-=item Switch condition not recognized in regex; marked by <-- HERE in m/%s/
+=item Switch condition not recognized in regex; marked by S<<-- HERE> in
+m/%s/
+
+(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
-(F) If the argument to the (?(...)if-clause|else-clause) construct is
-a number, it can be only a number. The <-- HERE shows whereabouts in
-the regular expression the problem was discovered. See L<perlre>.
+The <-- HERE shows whereabouts in the regular expression the problem was
+discovered. See L<perlre>.
=item switching effective %s is not implemented
(F) While under the C<use filetest> pragma, we cannot switch the real
and effective uids or gids.
-=item %s syntax OK
-
-(F) The final summary message when a C<perl -c> succeeds.
-
=item syntax error
(F) Probably means you had a syntax error. Common reasons include:
(F) Perl could not figure out what you meant inside this construct; this
notifies you that it is giving up trying.
+=item %s syntax OK
+
+(F) The final summary message when a C<perl -c> succeeds.
+
=item sysread() on closed filehandle %s
(W closed) You tried to read from a closed filehandle.
will continue to pretend that it is. And if you quote me on that, I
will deny it.
-=item The %s feature is experimental
-
-(S experimental) This warning is emitted if you enable an experimental
-feature via C<use feature>. 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::lexical_subs";
- use feature "lexical_subs";
-
=item The %s function is unimplemented
(F) The function indicated isn't implemented on this architecture,
no warnings "experimental::regex_sets";
+=item The signatures feature is experimental
+
+(S experimental::signatures) This warning is emitted if you unwrap a
+subroutine's arguments using a signature. Simply suppress the warning
+if you want to use the feature, but know that in doing so you are taking
+the risk of using an experimental feature which may change or be removed
+in a future Perl version:
+
+ no warnings "experimental::signatures";
+ use feature "signatures";
+ sub foo ($left, $right) { ... }
+
=item The stat preceding %s wasn't an lstat
(F) It makes no sense to test the current stat buffer for symbolic
report this warning to the relevant upstream party, or recompile perl
with default options.
-=item thread failed to start: %s
-
-(W threads)(S) The entry point function of threads->create() failed for some reason.
-
=item times not implemented
(F) Your version of the C library apparently doesn't do times(). I
(F) There has to be at least one argument to syscall() to specify the
system call to call, silly dilly.
+=item Too few arguments for subroutine
+
+(F) A subroutine using a signature received fewer arguments than required
+by the signature. The caller of the subroutine is presumably at fault.
+Inconveniently, this error will be reported at the location of the
+subroutine, not that of the caller.
+
=item Too late for "-%s" option
(X) The #! line (or local equivalent) in a Perl script contains the
(F) The function requires fewer arguments than you specified.
+=item Too many arguments for subroutine
+
+(F) A subroutine using a signature received more arguments than required
+by the signature. The caller of the subroutine is presumably at fault.
+Inconveniently, this error will be reported at the location of the
+subroutine, not that of the caller.
+
=item Too many )'s
(A) You've accidentally run your script through B<csh> instead of Perl.
(F) The regular expression ends with an unbackslashed backslash.
Backslash it. See L<perlre>.
-=item Trailing white-space in a charnames alias definition is deprecated
-
-(D deprecated) You defined a character name which ended in a space
-character. Remove the trailing space(s). Usually these names are
-defined in the C<:alias> import argument to C<use charnames>, but they
-could be defined by a translator installed into C<$^H{charnames}>.
-See L<charnames/CUSTOM ALIASES>.
-
=item Transliteration pattern not terminated
(F) The lexer couldn't find the interior delimiter of a tr/// or tr[][]
(A) You've accidentally run your script through B<csh> instead of Perl.
Check the #! line, or manually feed your script into Perl yourself.
+=item Unescaped left brace in regex is deprecated, passed through in regex;
+marked by <-- HERE in m/%s/
+
+(D deprecated, regexp) You used a literal C<"{"> character in a regular
+expression pattern. You should change to use C<"\{"> instead, because a future
+version of Perl (tentatively v5.26) will consider this to be a syntax error. If
+the pattern delimiters are also braces, any matching right brace
+(C<"}">) should also be escaped to avoid confusing the parser, for
+example,
+
+ qr{abc\{def\}ghi}
+
=item unexec of %s into %s failed!
(F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
-=item Unexpected binary operator '%c' with no preceding operand in regex; marked by <-- HERE in m/%s/
+=item Unexpected binary operator '%c' with no preceding operand in regex;
+marked by S<<-- HERE> in m/%s/
(F) You had something like this:
where the C<"|"> is a binary operator with an operand on the right, but
no operand on the left.
-=item Unexpected character in regex; marked by <-- HERE in m/%s/
+=item Unexpected character in regex; marked by S<<-- HERE> in m/%s/
(F) You had something like this:
(S) exit() was called or the script otherwise finished gracefully when
C<PERL_EXIT_WARN> was set in C<PL_exit_flags>.
-=item Unexpected exit failure %u
+=item Unexpected exit failure %d
(S) An uncaught die() was called when C<PERL_EXIT_WARN> was set in
C<PL_exit_flags>.
-=item Unexpected ')' in regex; marked by <-- HERE in m/%s/
+=item Unexpected ')' in regex; marked by S<<-- HERE> in m/%s/
(F) You had something like this:
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 preceding operator in regex; marked by <-- HERE in m/%s/
+=item Unexpected '(' with no preceding operator in regex; marked by
+S<<-- HERE> in m/%s/
(F) You had something like this:
=item Unicode non-character U+%X is illegal for open interchange
-(S utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
+(S nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
defined by the Unicode standard to be non-characters. Those are
legal codepoints, but are reserved for internal use; so, applications
-shouldn't attempt to exchange them. If you know what you are doing
+shouldn't attempt to exchange them. An application may not be
+expecting any of these characters at all, and receiving them
+may lead to bugs. If you know what you are doing
you can turn off this warning by C<no warnings 'nonchar';>.
+This is not really a "serious" error, but it is supposed to be raised
+by default even if warnings are not enabled, and currently the only
+way to do that in Perl is to mark it as serious.
+
=item Unicode surrogate U+%X is illegal in UTF-8
-(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S surrogate) You had a UTF-16 surrogate in a context where they are
not considered acceptable. These code points, between U+D800 and
U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl
internally allows all unsigned integer code points (up to the size limit
(W) You tried to use an unknown subpragma of the "re" pragma.
-=item Unknown switch condition (?(...)) in regex; marked by <-- HERE in m/%s/
+=item Unknown switch condition (?(...)) in regex; marked by S<<-- HERE> in
+m/%s/
(F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition must be one of the following:
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
-=item Unknown verb pattern '%s' in regex; marked by <-- HERE in m/%s/
+=item Unknown verb pattern '%s' in regex; marked by S<<-- HERE> in m/%s/
(F) You either made a typo or have incorrectly put a C<*> quantifier
after an open brace in your pattern. Check the pattern and review
module (e.g. C<use warnings 'File::Find'>), you must have loaded this
module first.
-=item Unmatched '[' in POSIX class in regex; marked by <-- HERE in m/%s/
+=item Unmatched '[' in POSIX class in regex; marked by S<<-- HERE> in m/%s/
(F) You had something like this:
(?[ [:digit:] ])
-=item Unmatched '%c' in POSIX class in regex; marked by <-- HERE in m/%s/
+=item Unmatched '%c' in POSIX class in regex; marked by S<<-- HERE> in
+m/%s/
(F) You had something like this:
(?[ [:alnum:] ])
-=item Unmatched [ in regex; marked by <-- HERE in m/%s/
+=item Unmatched [ in regex; marked by S<<-- HERE> in m/%s/
(F) The brackets around a character class must match. If you wish to
include a closing bracket in a character class, backslash it or put it
-first. The <-- HERE shows whereabouts in the regular expression the
+first. The S<<-- HERE> shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
-=item Unmatched ( in regex; marked by <-- HERE in m/%s/
+=item Unmatched ( in regex; marked by S<<-- HERE> in m/%s/
-=item Unmatched ) in regex; marked by <-- HERE in m/%s/
+=item Unmatched ) in regex; marked by S<<-- HERE> in m/%s/
(F) Unbackslashed parentheses must always be balanced in regular
expressions. If you're a vi user, the % key is valuable for finding
-the matching parenthesis. The <-- HERE shows whereabouts in the
+the matching parenthesis. The S<<-- HERE> shows whereabouts in the
regular expression the problem was discovered. See L<perlre>.
=item Unmatched right %s bracket
somehow, or insert an underbar into it. You might also declare it as a
subroutine.
-=item Unrecognized character %s; marked by <-- HERE after %s near column %d
+=item Unrecognized character %s; marked by S<<-- HERE> after %s near column
+%d
(F) The Perl parser has no idea what to do with the specified character
-in your Perl script (or eval) near the specified column. Perhaps you tried
-to run a compressed script, a binary program, or a directory as a Perl program.
+in your Perl script (or eval) near the specified column. Perhaps you
+tried to run a compressed script, a binary program, or a directory as
+a Perl program.
-=item Unrecognized escape \%c in character class in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%c in character class in regex; marked by
+S<<-- HERE> in m/%s/
(F) You used a backslash-character combination which is not
recognized by Perl inside character classes. This is a fatal
error when the character class is used within C<(?[ ])>.
=item Unrecognized escape \%c in character class passed through in regex;
-marked by <-- HERE in m/%s/
+marked by S<<-- HERE> in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl inside character classes. The character was
understood literally, but this may change in a future version of Perl.
-The <-- HERE shows whereabouts in the regular expression the
+The S<<-- HERE> shows whereabouts in the regular expression the
escape was discovered.
=item Unrecognized escape \%c passed through
recognized by Perl. The character was understood literally, but this may
change in a future version of Perl.
-=item Unrecognized escape \%s passed through in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%s passed through in regex; marked by
+S<<-- HERE> in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl. The character(s) were understood literally, but
-this may change in a future version of Perl. The <-- HERE shows
+this may change in a future version of Perl. The S<<-- HERE> shows
whereabouts in the regular expression the escape was discovered.
=item Unrecognized signal name "%s"
think you didn't do that, check the #! line to see if it's supplying the
bad switch on your behalf.)
+=item unshift on reference is experimental
+
+(S experimental::autoderef) C<unshift> with a scalar argument
+is experimental and may change or be removed in a future
+Perl version. If you want to take the risk of using this
+feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Unsuccessful %s on filename containing newline
(W newline) A file operation was attempted on a filename, and that
<<"foo"
-=item Unterminated \g... pattern in regex; marked by <-- HERE in m/%s/
+=item Unterminated \g... pattern in regex; marked by S<<-- HERE> in m/%s/
-=item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
+=item Unterminated \g{...} pattern in regex; marked by S<<-- HERE> in m/%s/
(F) In a regular expression, you had a C<\g> that wasn't followed by a
proper group reference. In the case of C<\g{>, the closing brace is
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
-=item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/
+=item Unterminated verb pattern argument in regex; marked by S<<-- HERE> in
+m/%s/
(F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate
the pattern with a C<)>. Fix the pattern and retry.
-=item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
+=item Unterminated verb pattern in regex; marked by S<<-- HERE> in m/%s/
(F) You used a pattern of the form C<(*VERB)> but did not terminate
the pattern with a C<)>. Fix the pattern and retry.
You probably meant to use C<$]> instead. C<$[> is the base for indexing
arrays. C<$]> is the Perl version number in decimal.
+=item Use "%s" instead of "%s"
+
+(F) The second listed construct is no longer legal. Use the first one
+instead.
+
=item Useless assignment to a temporary
(W misc) You assigned to an lvalue subroutine, but what
the subroutine returned was a temporary scalar about to
be discarded, so the assignment had no effect.
-=item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in
-m/%s/
+=item Useless (?-%s) - don't use /%s modifier in regex; marked by
+S<<-- HERE> in m/%s/
(W regexp) You have used an internal modifier such as (?-o) that has no
meaning unless removed from the entire regexp:
but in fact the local() currently has no effect. This may change at
some point in the future, but in the meantime such code is discouraged.
-=item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
+=item Useless (?%s) - use /%s modifier in regex; marked by S<<-- HERE> in
+m/%s/
(W regexp) You have used an internal modifier such as (?o) that has no
meaning unless applied to the entire regexp:
same length as the replacelist. See L<perlop> for more information
about the /d modifier.
-=item Useless use of '\'; doesn't escape metacharacter '%c'
-
-(D deprecated) You wrote a regular expression pattern something like
-one of these:
-
- m{ \x\{FF\} }x
- m{foo\{1,3\}}
- qr(foo\(bar\))
- s[foo\[a-z\]bar][baz]
+=item Useless use of \E
-The interior braces, square brackets, and parentheses are treated as
-metacharacters even though they are backslashed; instead write:
+(W misc) You have a \E in a double-quotish string without a C<\U>,
+C<\L> or C<\Q> preceding it.
- m{ \x{FF} }x
- m{foo{1,3}}
- qr(foo(bar))
- s[foo[a-z]bar][baz]
+=item Useless use of greediness modifier '%c' in regex; marked by S<<-- HERE> in m/%s/
-The backslashes have no effect when a regular expression pattern is
-delimited by C<{}>, C<[]>, or C<()>, which ordinarily are
-metacharacters, and the delimiters are also used, paired, within the
-interior of the pattern. It is planned that a future Perl release will
-change the meaning of constructs like these so that the backslashes
-will have an effect, so remove them from your code.
+(W regexp) You specified something like these:
-=item Useless use of \E
+ qr/a{3}?/
+ qr/b{1,1}+/
-(W misc) You have a \E in a double-quotish string without a C<\U>,
-C<\L> or C<\Q> preceding it.
+The C<"?"> and C<"+"> don't have any effect, as they modify whether to
+match more or fewer when there is a choice, and by specifying to match
+exactly a given numer, there is no room left for a choice.
=item Useless use of %s in void context
String constants that would normally evaluate to 0 or 1 are warned
about.
-=item Useless use of (?-p) in regex; marked by <-- HERE in m/%s/
+=item Useless use of (?-p) in regex; marked by S<<-- HERE> in m/%s/
(W regexp) The C<p> modifier cannot be turned off once set. Trying to do
so is futile.
=item Use of bare << to mean <<"" is deprecated
(D deprecated) You are now encouraged to use the explicitly quoted
-form if you wish to use an empty line as the terminator of the here-document.
-
-=item Use of comma-less variable list is deprecated
-
-(D deprecated) The values you give to a format should be
-separated by commas, not just aligned on a line.
+form if you wish to use an empty line as the terminator of the
+here-document.
=item Use of chdir('') or chdir(undef) as chdir() deprecated
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
+
+(D deprecated) The values you give to a format should be
+separated by commas, not just aligned on a line.
+
=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;
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
+
+(D deprecated) Using literal control characters in the source to refer
+to the ^FOO variables, like C<$^X> and C<${^GLOBAL_PHASE}> is now
+deprecated. This only affects code like C<$\cT>, where \cT is a control in
+the source code: C<${"\cT"}> and C<$^T> remain valid.
+
=item Use of -l on filehandle%s
(W io) A filehandle represents an opened file, and when you opened the file
untie a scalar that had had a typeglob assigned to it. If you see this
message, you must be using an older version.
-=item Use of ?PATTERN? without explicit operator is deprecated
-
-(D deprecated) You have written something like C<?\w?>, for a regular
-expression that matches only once. Starting this term directly with
-the question mark delimiter is now deprecated, so that the question mark
-will be available for use in new operators in the future. Write C<m?\w?>
-instead, explicitly using the C<m> operator: the question mark delimiter
-still invokes match-once behaviour.
-
=item Use of reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
C<concatenation (.)> operator, even though there is no C<.> in
your program.
-=item Use \x{...} for more than two hex characters in regex; marked by <-- HERE in m/%s/
+=item Use \x{...} for more than two hex characters in regex; marked by
+S<<-- HERE> in m/%s/
(F) In a regular expression, you said something like
You need to add either braces or blanks to disambiguate.
-=item Using a hash as a reference is deprecated
-
-(D deprecated) You tried to use a hash as a reference, as in
-C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1
-used to allow this syntax, but shouldn't have. It is now
-deprecated, and will be removed in a future version.
-
-=item Using an array as a reference is deprecated
-
-(D deprecated) You tried to use an array as a reference, as in
-C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.6.1 used to
-allow this syntax, but shouldn't have. It is now deprecated,
-and will be removed in a future version.
-
=item Using just the first character returned by \N{} in character class in
-regex; marked by <-- HERE in m/%s/
+regex; marked by S<<-- HERE> in m/%s/
(W regexp) A charnames handler may return a sequence of more than one
character. Currently all but the first one are discarded when used in
=item UTF-16 surrogate U+%X
-(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S surrogate) You had a UTF-16 surrogate in a context where they are
not considered acceptable. These code points, between U+D800 and
U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl
internally allows all unsigned integer code points (up to the size limit
longer than 1024 characters. The return value has been truncated to
1024 characters.
+=item values on reference is experimental
+
+(S experimental::autoderef) C<values> with a scalar argument
+is experimental and may change or be removed in a future
+Perl version. If you want to take the risk of using this
+feature, simply disable this warning:
+
+ no warnings "experimental::autoderef";
+
=item Variable "%s" is not available
(W closure) During compilation, an inner named subroutine or eval is
}
f()->();
-Here, when the '$a' in the eval is being compiled, f() is not currently being
-executed, so its $a is not available for capture.
+Here, when the '$a' in the eval is being compiled, f() is not currently
+being executed, so its $a is not available for capture.
=item Variable "%s" is not imported%s
=item Variable length lookbehind not implemented in regex m/%s/
(F) Lookbehind is allowed only for subexpressions whose length is fixed and
-known at compile time. See L<perlre>.
+known at compile time. For positive lookbehind, you can use the C<\K>
+regex construct as a way to get the equivalent functionality. See
+L<perlre/(?<=pattern) \K>.
+
+There are non-obvious Unicode rules under C</i> that can match variably,
+but which you might not think could. For example, the substring C<"ss">
+can match the single character LATIN SMALL LETTER SHARP S. There are
+other sequences of ASCII characters that can match single ligature
+characters, such as LATIN SMALL LIGATURE FFI matching C<qr/ffi/i>.
+Starting in Perl v5.16, if you only care about ASCII matches, adding the
+C</aa> modifier to the regex will exclude all these non-obvious matches,
+thus getting rid of this message. You can also say C<S<use re qw(/aa)>>
+to apply C</aa> to all regular expressions compiled within its scope.
+See L<re>.
=item "%s" variable %s masks earlier declaration in same %s
(S printf) The %vd (s)printf format does not support version objects
with alpha parts.
-=item Verb pattern '%s' has a mandatory argument in regex; marked by <-- HERE
-in m/%s/
+=item Verb pattern '%s' has a mandatory argument in regex; marked by
+S<<-- HERE> in m/%s/
(F) You used a verb pattern that requires an argument. Supply an
argument or check that you are using the right verb.
-=item Verb pattern '%s' may not have an argument in regex; marked by <-- HERE
-in m/%s/
+=item Verb pattern '%s' may not have an argument in regex; marked by
+S<<-- HERE> in m/%s/
(F) You used a verb pattern that is not allowed an argument. Remove the
argument or check that you are using the right verb.
not get any randomness out of your system. This usually indicates
Something Very Wrong.
+=item Zero length \N{} in regex; marked by S<<-- HERE> in m/%s/
+
+(F) Named Unicode character escapes C<(\N{...})> may return a zero-length
+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.
+
=back
=head1 SEE ALSO
-L<warnings>, L<perllexwarn>, L<diagnostics>.
+L<warnings>, L<diagnostics>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff