=item Ambiguous use of %s resolved as %s
-(W ambiguous)(S) You said something that may not be interpreted the way
+(S ambiguous) You said something that may not be interpreted the way
you thought. Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, parenthesis pair or declaration.
=item Ambiguous use of %c resolved as operator %c
-(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
+(S ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
bitwise and, and multiplication) I<and> initial special characters
(denoting hashes, subroutines and typeglobs), and you said something
like C<*foo * foo> that might be interpreted as either of them. We
=item Ambiguous use of -%s resolved as -&%s()
-(W ambiguous) You wrote something like C<-foo>, which might be the
+(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()>.
(D deprecated) Really old Perl let you omit the @ on array names in some
spots. This is now heavily deprecated.
+=item A sequence of multiple spaces in a charnames alias definition is deprecated
+
+(D) You defined a character name which had multiple space characters in
+a row. Change them to single spaces. Usually these names are defined
+in the C<:alias> import argument to C<use charnames>, but they could be
+defined by a translator installed into C<$^H{charnames}>. See
+L<charnames/CUSTOM ALIASES>.
+
=item assertion botched: %s
(X) The malloc package that comes with Perl had an internal failure.
=item Attempt to free unreferenced scalar: SV 0x%x
-(W internal) Perl went to decrement the reference count of a scalar to
+(S internal) Perl went to decrement the reference count of a scalar to
see if it would go to 0, and discovered that it had already gone to 0
earlier, and should have been freed, and in fact, probably was freed.
This could indicate that SvREFCNT_dec() was called too many times, or
=item Attempt to set length of freed array
-(W) You tried to set the length of an array which has been freed. You
-can do this by storing a reference to the scalar representing the last index
-of an array and later assigning through that reference. For example
+(W misc) You tried to set the length of an array which has
+been freed. You can do this by storing a reference to the
+scalar representing the last index of an array and later
+assigning through that reference. For example
$r = do {my @a; \$#a};
$$r = 503
(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\{" instead
+=item "\b{" is deprecated; use "\b\{" or "\b[{]" instead in regex; marked by <-- HERE in m/%s/
-=item "\B{" is deprecated; use "\B\{" instead
+=item "\B{" is deprecated; use "\B\{" or "\B[{]" instead in regex; marked by <-- HERE in m/%s/
(W deprecated, regexp) 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.
+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
=item Can't chdir to %s
-(F) You called C<perl -x/foo/bar>, but C</foo/bar> is not a directory
+(F) You called C<perl -x/foo/bar>, but F</foo/bar> is not a directory
that you can chdir to, possibly because it doesn't exist.
=item Can't check filesystem of script "%s" for nosuid
=item Can't do inplace edit: %s is not a regular file
(S inplace) You tried to use the B<-i> switch on a special file, such as
-a file in /dev, or a FIFO. The file was ignored.
+a file in /dev, a FIFO or an uneditable directory. The file was ignored.
=item Can't do inplace edit on %s: %s
characters and Perl was unable to create a unique filename during
inplace editing with the B<-i> switch. The file was ignored.
-=item Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/
-
-(F) Minima must be less than or equal to maxima. If you really
-want your regexp to match something 0 times, just put {0}. The
-<-- HERE shows in the regular expression about where the problem
-was discovered. See L<perlre>.
-
=item Can't do waitpid with flags
(F) This machine doesn't have either waitpid() or wait4(), so only
=item Code point 0x%X is not Unicode, may not be portable
-=item Code point 0x%X is not Unicode, all \p{} matches fail; all \P{} matches succeed
+=item Code point 0x%X is not Unicode, all \p{} matches fail; all \P{} matches
+succeed
-(W utf8, non_unicode) You had a code point above the Unicode maximum
+(S utf8, 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
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!
+ 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!
+ chr(0x110000) =~ /\P{ASCII_Hex_Digit=True}/ # Succeeds.
+ chr(0x110000) =~ /\P{ASCII_Hex_Digit=False}/ # Also succeeds!
=item %s: Command not found
to check the return value of your socket() call? See
L<perlfunc/connect>.
-=item Constant(%s)%s: %s
+=item Constant(%s): Call to &{$^H{%s}} did not return a defined value
+
+(F) The subroutine registered to handle constant overloading
+(see L<overload>) or a custom charnames handler (see
+L<charnames/CUSTOM TRANSLATORS>) returned an undefined value.
+
+=item Constant(%s): $^H{%s} is not defined
+
+(F) The parser found inconsistencies while attempting to define an
+overloaded constant. Perhaps you forgot to load the corresponding
+L<overload> pragma?.
+
+=item Constant(%s) unknown
(F) The parser found inconsistencies either while attempting to define
an overloaded constant, or when trying to find the character name
specified in the C<\N{...}> escape. Perhaps you forgot to load the
corresponding L<overload> pragma?.
-=item Constant(%s)%s: %s in regex; marked by <-- HERE in m/%s/
-
-(F) The parser found inconsistencies while attempting to find
-the character name specified in the C<\N{...}> escape.
-
=item Constant is not %s reference
(F) A constant value (perhaps declared using the C<use constant> pragma)
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 <-- 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
of the C<....> part.
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
=item %s defines neither package nor VERSION--version check failed
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
-=item Deprecated character in \N{...}; marked by <-- HERE in \N{%s<-- HERE %s
-
-(D deprecated) Just about anything is legal for the C<...> in C<\N{...}>.
-But starting in 5.12, non-reasonable ones that don't look like names
-are deprecated. A reasonable name begins with an alphabetic character
-and continues with any combination of alphanumerics, dashes, spaces,
-parentheses or colons.
-
=item Deprecated use of my() in false conditional
(D deprecated) You used a declaration similar to C<my $x if 0>. There
=item Duplicate modifier '%c' after '%c' in %s
-(W) You have applied the same modifier more than once after a type
-in a pack template. See L<perlfunc/pack>.
+(W unpack) You have applied the same modifier more than once after a
+
type in a pack template. See L<perlfunc/pack>.
=item elseif should be elsif
an invalid file specification to Perl, or you've found a case the
conversion routines don't handle. Drat.
-=item %s: Eval-group in insecure regular expression
+=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
expression that contains the C<(?{ ... })> zero-width assertion, which
is unsafe. See L<perlre/(?{ code })>, and L<perlsec>.
-=item %s: Eval-group not allowed at runtime, use re 'eval'
+=item Eval-group not allowed at runtime, use re 'eval' in regex m/%s/
(F) Perl tried to compile a regular expression containing the
C<(?{ ... })> zero-width assertion at run time, as it would when the
interpolated string at run time and using that in an eval(). See
L<perlre/(?{ code })>.
-=item %s: Eval-group not allowed, use re 'eval'
+=item Eval-group not allowed, use re 'eval' in regex m/%s/
(F) A regular expression contained the C<(?{ ... })> zero-width
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 <-- 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.
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
=item Excessively long <> operator
(W exiting) You are exiting a substitution by unconventional means, such
as a return, a goto, or a loop control statement.
+=item Experimental "%s" subs not enabled
+
+(F) To use lexical subs, you must first enable them:
+
+ no warnings 'experimental::lexical_subs';
+ use feature 'lexical_subs';
+ my sub foo { ... }
+
=item Explicit blessing to '' (assuming package main)
(W misc) You are blessing a reference to a zero length string. This has
(W regexp) 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 "-". Consider quoting the
-"-", "\-". The <-- HERE shows in the regular expression about where the
+"-", "\-". The <-- HERE shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
=item Fatal VMS error (status=%d) at %s, line %d
=item Field too wide in 'u' format in pack
-(W pack) Each line in an uuencoded string start with a length indicator
+(W pack) Each line in an uuencoded string starts with a length indicator
which can't encode values above 63. So there is no point in asking for
a line length bigger than that. Perl will behave as if you specified
C<u63> as the format.
(F) A ()-group started with a count. A count is supposed to follow
something: a template character or a ()-group. See L<perlfunc/pack>.
+=item Group name must start with a non-digit word character in regex; marked by
+<-- 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
+this error is using (?&0) instead of (?0). See L<perlre>.
+
=item %s had compilation errors.
(F) The final summary message when a C<perl -c> fails.
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
+=item -i used with no filenames on the command line, reading from STDIN
+
+(S inplace) The C<-i> option was passed on the command line, indicating
+that the script is intended to edit files inplace, but no files were
+given. This is usually a mistake, since editing STDIN inplace doesn't
+make sense, and can be confusing because it can make perl look like
+it is hanging when it is really just trying to read from STDIN. You
+should either pass a filename to edit, or remove C<-i> from the command
+line. See L<perlrun> for more details.
+
=item Identifier too long
(F) Perl limits identifiers (names for variables, functions, etc.) to
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
+=item Ignoring zero length \N{} in character class in regex; marked by <-- HERE in m/%s/
-(W) Named Unicode character escapes C<(\N{...})> may return a zero-length
+(W regexp) Named Unicode character escapes C<(\N{...})> may return a zero-length
sequence. When such an escape is used in a character class its
behaviour is not well defined. Check that the correct escape has
been used, and the correct charname handler is in scope.
Failure of user callbacks dispatched using the C<G_KEEPERR> flag could
also result in this warning. See L<perlcall/G_KEEPERR>.
-=item Inconsistent hierarchy during C3 merge of class '%s': merging failed on parent '%s'
+=item Inconsistent hierarchy during C3 merge of class '%s': merging failed on
+parent '%s'
(F) The method resolution order (MRO) of the given class is not
C3-consistent, and you have enabled the C3 MRO for this class. See the C3
text. You should check the pattern to ensure that recursive patterns
either consume text or fail.
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
=item Initialization of state variables in list context currently forbidden
=item Integer overflow in %s number
-(W overflow) The hexadecimal, octal or binary number you have specified
+(S overflow) The hexadecimal, octal or binary number you have specified
either as a literal or as an argument to hex() or oct() is too big for
your architecture, and has been converted to a floating point number.
On a 32-bit architecture the largest hexadecimal, octal or binary number
internally--subject to loss of precision errors in subsequent
operations.
+=item Integer overflow in srand
+
+(S overflow) The number you have passed to srand is too big to fit
+in your architecture's integer representation. The number has been
+replaced with the largest integer supported (0xFFFFFFFF on 32-bit
+architectures). This means you may be getting less randomness than
+you expect, because different random seeds above the maximum will
+return the same sequence of random numbers.
+
=item Integer overflow in version
-(F) Some portion of a version initialization is too large for the
-size of integers for your architecture. This is not a warning
-because there is no rational reason for a version to try and use a
-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 Integer overflow in version %d
+
+(W overflow) Some portion of a version initialization is too large for
+the size of integers for your architecture. This is not a warning
+because there is no rational reason for a version to try and use an
+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/
(P) Something went badly wrong in the regular expression parser.
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
=item Internal inconsistency in tracking vforks
=item Internal urp in regex; marked by <-- HERE in m/%s/
(P) Something went badly awry in the regular expression parser. The
-<-- HERE shows in the regular expression about where the problem was
+<-- 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 \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 character in charnames alias definition; marked by <-- 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 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 <-- HERE in
+m/%s/
(W regexp) 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 in the regular expression about where the
+The <-- 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/
+
(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
0 - 9 or A - F, a - f in a hexadecimal number.
the only valid ones supported are C<dfs> and C<c3>, unless you have loaded
a module that is a MRO plugin. See L<mro> and L<perlmroapi>.
+=item Invalid negative number (%s) in chr
+
+(W utf8) You passed a negative number to C<chr>. Negative numbers are
+not valid characters numbers, so it return the Unicode replacement
+character (U+FFFD).
+
=item invalid option -D%c, use -D'' to see choices
-(F) Perl was called with invalid debugger flags. Call perl with
-the B<-D> option with no flags to see the list of acceptable values.
-See also L<< perlrun/B<-D>I<letters> >>.
+(S debugging) Perl was called with invalid debugger flags. Call perl
+with the B<-D> option with no flags to see the list of acceptable values.
+See also L<perlrun/B<-D>I<letters>>.
=item Invalid [] range "%s" in regex; marked by <-- 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 in the regular expression about where the
+up to C<ff>. The <-- HERE shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
=item Invalid range "%s" in transliteration operator
(W overload) You tried to overload a constant type the overload package is
unaware of.
-=item junk on end of regexp
+=item Junk on end of regexp in regex m/%s/
(P) The regular expression parser is confused.
=item Lost precision when %s %f by 1
-(W) The value you attempted to increment or decrement by one is too large
-for the underlying floating point representation to store accurately,
-hence the target of C<++> or C<--> is unchanged. Perl issues this warning
-because it has already switched from integers to floating point when values
-are too large for integers, and now even floating point is insufficient.
-You may wish to switch to using L<Math::BigInt> explicitly.
+(W imprecision) The value you attempted to increment or decrement by one
+is too large for the underlying floating point representation to store
+accurately, hence the target of C<++> or C<--> is unchanged. Perl issues this
+warning because it has already switched from integers to floating point
+when values are too large for integers, and now even floating point is
+insufficient. You may wish to switch to using L<Math::BigInt> explicitly.
=item lstat() on filehandle%s
See also L<Encode/"Handling Malformed Data">.
-=item Malformed UTF-8 returned by \N
+=item Malformed UTF-8 character immediately after '%s'
+
+(F) You said C<use utf8>, but the program file doesn't comply with UTF-8
+encoding rules. The message prints out the properly encoded characters
+just before the first bad one. If C<utf8> warnings are enabled, a
+warning is generated that gives more details about the type of
+malformation.
+
+=item Malformed UTF-8 returned by \N{%s} immediately after '%s'
(F) The charnames handler returned malformed UTF-8.
(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
-shows in the regular expression about where the problem was discovered.
+shows whereabouts in the regular expression the problem was discovered.
See L<perlre>.
=item Maximal count of pending signals (%u) exceeded
=item Missing braces on \N{}
+=item Missing braces on \N{} in regex; marked by <-- 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
(or comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
(F) A double-quoted string ended with "\c", without the required control
character name.
-=item Missing name in "my sub"
+=item Missing name in "%s sub"
(F) The reserved syntax for lexically scoped subroutines requires that
they have a name with which they can be found.
(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 %s
+=item Missing right brace on \%c{} in regex; marked by <-- HERE in m/%s/
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
the same; if a program uses $c only once but also uses any of the others it
will not trigger this warning.
-=item \N in a character class must be a named character: \N{...}
+=item \N in a character class must be a named character: \N{...} in regex;
+marked by <-- 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.
-=item \N{NAME} must be resolved by the lexer
+=item \N{NAME} must be resolved by the lexer in regex; marked by <-- 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
=item Nested quantifiers in regex; marked by <-- HERE in m/%s/
(F) You can't quantify a quantifier without intervening parentheses.
-So things like ** or +* or ?* are illegal. The <-- HERE shows in the
-regular expression about where the problem was discovered.
+So things like ** or +* or ?* are illegal. The <-- HERE shows
+whereabouts in the regular expression the problem was discovered.
Note that the minimal matching quantifiers, C<*?>, C<+?>, and
C<??> appear to be nested quantifiers, but aren't. See L<perlre>.
a number. This happens, for example with C<\o{}>, with no number between
the braces.
+=item "my %s" used in sort comparison
+
+(W syntax) The package variables $a and $b are used for sort comparisons.
+You used $a or $b in as an operand to the C<< <=> >> or C<cmp> operator inside a
+sort comparison block, and the variable had earlier been declared as a
+lexical variable. Either qualify the sort variable with the package
+name, or rename the lexical variable.
+
=item Octal number > 037777777777 non-portable
(W portable) The octal number you specified is larger than 2**32-1
(W unopened) You tried to invoke a file test operator on a filehandle
that isn't open. Check your control flow. See also L<perlfunc/-X>.
+=item Strings with code points over 0xFF may not be mapped into in-memory file handles
+
+(W utf8) You tried to open a reference to a scalar for read or append
+where the scalar contained code points over 0xFF. In-memory files
+model on-disk files and can only contain bytes.
+
=item oops: oopsAV
(S internal) An internal warning that the grammar is screwed up.
=item Opening dirhandle %s also as a file
-(W io, deprecated) You used open() to associate a filehandle to
+(D io, deprecated) You used open() to associate a filehandle to
a symbol (glob or scalar) that already holds a dirhandle.
Although legal, this idiom might render your code confusing
and is deprecated.
=item Opening filehandle %s also as a directory
-(W io, deprecated) You used opendir() to associate a dirhandle to
+(D io, deprecated) You used opendir() to associate a dirhandle to
a symbol (glob or scalar) that already holds a filehandle.
Although legal, this idiom might render your code confusing
and is deprecated.
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(W utf8, non_unicode) You performed an operation requiring Unicode
+(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.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(W utf8, surrogate) You performed an operation requiring Unicode
+(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
platform. Earlier checks mean that it should not be possible to
enter this branch on this platform.
+=item panic: child pseudo-process was never scheduled
+
+(P) A child pseudo-process in the ithreads implementation on Windows
+was not scheduled within the time period allowed and therefore was not
+able to initialize properly.
+
=item panic: ck_grep, type=%u
(P) Failed an internal consistency check trying to compile a grep.
(P) scan_num() got called on something that wasn't a number.
+=item panic: Sequence (?{...}): no code block found
+
+(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.
+
=item panic: sv_chop %s
(P) The sv_chop() routine was passed a position that is not within the
(P) The lexer got into a bad state while processing a case modifier.
-=item Parsing code internal error (%s)
-
-(F) Parsing code supplied by an extension violated the parser's API in
-a detectable way.
-
-=item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
-
-(F) You used a pattern that uses too many nested subpattern calls without
-consuming any text. Restructure the pattern so text is consumed before
-the nesting limit is exceeded.
-
-The <-- HERE shows in the regular expression about where the problem was
-discovered.
-
=item Parentheses missing around "%s" list
(W parenthesis) You said something like
Remember that "my", "our", "local" and "state" bind tighter than comma.
+=item Parsing code internal error (%s)
+
+(F) Parsing code supplied by an extension violated the parser's API in
+a detectable way.
+
+=item Passing malformed UTF-8 to "%s" is deprecated
+
+(D deprecated, utf8) This message indicates a bug either in the Perl
+core or in XS code. Such code was trying to find out if a character,
+allegedly stored internally encoded as UTF-8, was of a given type, such
+as being punctuation or a digit. But the character was not encoded in
+legal UTF-8. The C<%s> is replaced by a string that can be used by
+knowledgeable people to determine what the type being checked against
+was. If C<utf8> warnings are enabled, a further message is raised,
+giving details of the malformation.
+
+=item Pattern subroutine nesting without pos change exceeded limit in regex;
+marked by <-- HERE in m/%s/
+
+(F) You used a pattern that uses too many nested subpattern calls without
+consuming any text. Restructure the pattern so text is consumed before
+the nesting limit is exceeded.
+
+The <-- HERE shows whereabouts in the regular expression the problem was
+discovered.
+
=item C<-p> destination: %s
(F) An error occurred during the implicit output invoked by the C<-p>
"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
+=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/
-(W regex, deprecated) You used a regular expression with
+(W regexp, deprecated) You used a regular expression with
case-insensitive matching, and there is a bug in Perl in which the
built-in regular expression folding rules are not accurate. This may
lead to incorrect results. Please report this as a bug using the
=item PERL_SIGNALS illegal: "%s"
-See L<perlrun/PERL_SIGNALS> for legal values.
+
(X) See L<perlrun/PERL_SIGNALS> for legal values.
=item Perls since %s too modern--this is %s, stopped
time you run Perl. How to really fix the problem can be found in
L<perllocale> section B<LOCALE PROBLEMS>.
+=item perl: warning: Non hex character in '$ENV{PERL_HASH_SEED}', seed only
+partially set
+
+(W) PERL_HASH_SEED should match /^\s*(?:0x)?[0-9a-fA-F]+\s*\z/ but it
+contained a non hex character. This could mean your hash randomization
+is not being set correctly.
+
=item pid %x not a child
(W exec) A warning peculiar to VMS. Waitpid() was asked to wait for a
=item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
(F) The class in the character class [: :] syntax is unknown. The <-- HERE
-shows in the regular expression about where the problem was discovered.
+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:]]>,
not C<isprint>. See L<perlre>.
(F) Your system has POSIX getpgrp(), which takes no argument, unlike
the BSD version, which takes a pid.
-=item POSIX syntax [%s] belongs inside character classes in regex; marked by <-- HERE in m/%s/
+=item POSIX syntax [%c %c] belongs inside character classes in regex; marked by
+<-- 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 in the regular expression about
-
where the problem was discovered. See L<perlre>.
+implemented; they are simply placeholders for future extensions and
+will cause fatal errors. The <-- 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/
+=item POSIX syntax [. .] is reserved for future extensions in regex; marked by
+<-- HERE in m/%s/
-(F regexp) 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 in the regular expression
-
about where the problem was discovered. See L<perlre>.
+(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
+problem was discovered. See L<perlre>.
-=item POSIX syntax [= =] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
+=item POSIX syntax [= =] is reserved for future extensions in regex; marked by
+<-- 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 in the regular expression about where the
+and "=\]". The <-- HERE shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
=item Possible attempt to put comments in qw() list
=item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
(F) You started a regular expression with a quantifier. Backslash it if
-you meant it literally. The <-- HERE shows in the regular expression
-
about where the problem was discovered. See L<perlre>.
+you meant it literally. The <-- 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/
(F) There is currently a limit to the size of the min and max values of
-the {min,max} construct. The <-- HERE shows in the regular expression
-
about where the problem was discovered. See L<perlre>.
+the {min,max} construct. The <-- HERE shows whereabouts in the regular
+
expression the problem was discovered. See L<perlre>.
-=item Quantifier unexpected on zero-length expression; marked by <-- HERE in m/%s/
+=item Quantifier unexpected on zero-length expression in regex; marked by <--
+HERE in m/%s/
(W regexp) You applied a regular expression quantifier in a place where
it makes no sense, such as on a zero-width assertion. Try putting the
"abc" provided that it is followed by three repetitions of "xyz" is
C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
+=item Quantifier {n,m} with n > m can't match in regex; marked by <-- 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}.
+
=item Range iterator outside integer range
(F) One (or both) of the numeric arguments to the range operator ".."
=item Recompile perl with B<-D>DEBUGGING to use B<-D> switch
-(F debugging) You can't use the B<-D> option unless the code to produce
+(S debugging) You can't use the B<-D> option unless the code to produce
the desired output is compiled into Perl, which entails some overhead,
which is why it's currently left out of your copy.
(W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
-=item Reference to invalid group 0
+=item Reference to invalid group 0 in regex; marked by <-- 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
you wanted to have the character with ordinal 7 inserted into the regular
expression, prepend zeroes to make it three digits long: C<\007>
-The <-- HERE shows in the regular expression about where the problem was
+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/
such as C<(?'NAME'...)> or C<< (?<NAME>...) >>. Check if the name has been
spelled correctly both in the backreference and the declaration.
-The <-- HERE shows in the regular expression about where the problem was
+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 <-- 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
expression before where the C<\g{-7}> was located.
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered.
=item regexp memory corruption
(F syntax, regexp) 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 "-"
+=item Regexp modifier "%c" may not appear after the "-" in regex; marked by <--
+HERE in m/%s/
-(F regexp) Turning off the given modifier has the side effect of turning
-on another one. Perl currently doesn't allow this. Reword the regular
+(F) Turning off the given modifier has the side effect of turning on
+another one. Perl currently doesn't allow this. Reword the regular
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.
mutually exclusive modifiers. Retain only the modifier that is
supposed to be there.
-=item Regexp out of space
+=item Regexp out of space in regex m/%s/
(P) A "can't happen" error, because safemalloc() should have caught it
earlier.
search list. So the additional elements in the replacement list
are meaningless.
+=item '%s' resolved to '\o{%s}%d'
+
+(W misc, regexp) You wrote something like C<\08>, or C<\179> in a
+double-quotish string. All but the last digit is treated as a single
+character, specified in octal. The last digit is the next character in
+the string. To tell Perl that this is indeed what you want, you can use
+the C<\o{ }> syntax, or use exactly three digits to specify the octal
+for the character.
+
=item Reversed %s= operator
(W syntax) You wrote your assignment operator backwards. The = must
=item Scalars leaked: %d
-(P) Something went wrong in Perl's internal bookkeeping of scalars:
-not all scalar variables were deallocated by the time Perl exited.
-What this usually indicates is a memory leak, which is of course bad,
-especially if the Perl program is intended to be long-running.
+(S internal) Something went wrong in Perl's internal bookkeeping
+of scalars: not all scalar variables were deallocated by the time
+Perl exited. What this usually indicates is a memory leak, which
+is of course bad, especially if the Perl program is intended to be
+long-running.
=item Scalar value @%s[%s] better written as $%s[%s]
=item Sequence (? incomplete in regex; marked by <-- HERE in m/%s/
(F) A regular expression ended with an incomplete extension (?. The
-<-- HERE shows in the regular expression about where the problem was
+<-- 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/
(F) A proposed regular expression extension has the character reserved
-but has not yet been written. The <-- HERE shows in the regular
-
expression about where the problem was discovered. See L<perlre>.
+but has not yet been written. The <-- 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/
(F) You used a regular expression extension that doesn't make sense. The
-<-- HERE shows in the regular expression about where the problem was
+<-- HERE shows whereabouts in the regular expression the problem was
discovered. This happens when using the C<(?^...)> construct to tell
Perl to use the default regular expression modifiers, and you
redundantly specify a default modifier. For other
(F) The regular expression expects a mandatory argument following the escape
sequence and this has been omitted or incorrectly written.
-=item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/
+=item Sequence (?#... not terminated in regex m/%s/
(F) A regular expression comment must be terminated by a closing
-parenthesis. Embedded parentheses aren't allowed. The <-- HERE shows in
-the regular expression about where the problem was discovered. See
+parenthesis. Embedded parentheses aren't allowed. See
L<perlre>.
-=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
-
-(F) If the contents of a (?{...}) clause contain braces, they
-must balance for Perl to detect the end of the clause properly.
-The <-- HERE shows in the regular expression about where the
-problem was discovered. See L<perlre>.
-
=item Sequence (?{...}) not terminated with ')'
-(F) If the contents of a (?{...}) clause contain braces, they must balance
-for Perl to detect the end of the clause properly. The <-- HERE shows in
-the regular expression about where the problem was discovered. See
-L<perlre>.
+(F) The end of the perl code contained within the {...} must be
+followed immediately by a ')'.
=item Z<>500 Server error
(W signal) The signal handler named in %SIG doesn't, in fact, exist.
Perhaps you put it into the wrong package?
+=item Slab leaked from cv %p
+
+(S) If you see this message, then something is seriously wrong with the
+internal bookkeeping of op trees. An op tree needed to be freed after
+a compilation error, but could not be found, so it was leaked instead.
+
+=item sleep(%u) too large
+
+(W overflow) You called C<sleep> with a number that was larger than
+it can reliably handle and C<sleep> probably slept for less time than
+requested.
+
=item Smart matching a non-overloaded object breaks encapsulation
(F) You should not use the C<~~> operator on an object that does not
=item Sort subroutine didn't return single value
-(F) A sort comparison subroutine may not return a list value with more
-
or less than one element. See L<perlfunc/sort>.
+(F) A sort comparison subroutine written in XS must return exactly one
+
item. See L<perlfunc/sort>.
=item Source filters apply only to byte streams
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
+=item "state %s" used in sort comparison
+
+(W syntax) The package variables $a and $b are used for sort comparisons.
+You used $a or $b in as an operand to the C<< <=> >> or C<cmp> operator inside a
+sort comparison block, and the variable had earlier been declared as a
+lexical variable. Either qualify the sort variable with the package
+name, or rename the lexical variable.
+
=item stat() on unopened filehandle %s
(W unopened) You tried to use the stat() function on a filehandle that
stubs. Stubs should never be implicitly created, but explicit calls to
C<can> may break this.
+=item Subroutine "&%s" is not available
+
+(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,
+
+ sub { my sub a {...} sub f { \&a } }
+
+At the time that f is created, it can't capture the current the "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,
+
+ sub f {
+ my sub a {...}
+ sub { eval '\&a' }
+ }
+ 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.
+
+=item "%s" subroutine &%s masks earlier declaration in same %s
+
+(W misc) A "my" or "state" subroutine has been redeclared in the
+current scope or statement, effectively eliminating all access to
+the previous instance. This is almost always a typographical error.
+Note that the earlier subroutine will still exist until the end of
+the scope or until all closure references to it are destroyed.
+
=item Subroutine %s redefined
(W redefine) You redefined a subroutine. To suppress this warning, say
(P) Perl tried to force the upgrade of an SV to a type which was actually
inferior to its current type.
-=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
+=item Switch (?(condition)... contains too many branches in regex; marked by
+<-- 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 in the regular expression about where the problem
+The <-- 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/
(F) If the argument to the (?(...)if-clause|else-clause) construct is
-a number, it can be only a number. The <-- HERE shows in the regular
-
expression about where the problem was discovered. See L<perlre>.
+a number, it can be only a number. The <-- HERE shows whereabouts in
+
the regular expression the problem was discovered. See L<perlre>.
=item switching effective %s is not implemented
This is to prevent the problem of one module changing the array base out
from under another module inadvertently. See L<perlvar/$[> and L<arybase>.
-=item The crypt() function is unimplemented due to excessive paranoia
+=item The crypt() function is unimplemented due to excessive paranoia.
(F) Configure couldn't find the crypt() function on your machine,
probably because your vendor didn't supply it, probably because they
will continue to pretend that it is. And if you quote me on that, I
will deny it.
+=item The lexical_subs feature is experimental
+
+(S experimental::lexical_subs) This warning is emitted if you
+declare a sub with C<my> or C<state>. Simply suppress the warning
+if you want to use the feature, but know that in doing so you
+are taking the risk of using an experimental feature which may
+change or be removed in a future Perl version:
+
+ no warnings "experimental::lexical_subs";
+ use feature "lexical_subs";
+ my sub foo { ... }
+
=item The %s function is unimplemented
(F) The function indicated isn't implemented on this architecture, according
(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) 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[][]
(F) Your machine doesn't implement the umask function and you tried to
use it to restrict permissions for yourself (EXPR & 0700).
-=item Unable to create sub named "%s"
-
-(F) You attempted to create or access a subroutine with an illegal name.
-
=item Unbalanced context: %d more PUSHes than POPs
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many execution contexts were entered and left.
=item Unbalanced saves: %d more saves than restores
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many values were temporarily localized.
=item Unbalanced scopes: %d more ENTERs than LEAVEs
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many blocks were entered and left.
=item Unbalanced string table refcount: (%d) for "%s"
-(W internal) On exit, Perl found some strings remaining in the shared
+(S internal) On exit, Perl found some strings remaining in the shared
string table used for copy on write and for hash keys. The entries
should have been freed, so this indicates a bug somewhere.
=item Unbalanced tmps: %d more allocs than frees
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many mortal scalars were allocated and freed.
=item Undefined format "%s" called
(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
-
-(D) 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.20) 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
=item Unicode non-character U+%X is illegal for open interchange
-(W utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
+(S utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
defined by the Unicode standard to be non-characters. Those are
legal codepoints, but are reserved for internal use; so, applications
shouldn't attempt to exchange them. If you know what you are doing
=item Unicode surrogate U+%X is illegal in UTF-8
-(W utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S utf8, 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
(F) There are no byte-swapping functions for a machine with this byte
order.
+=item Unknown charname '%s'
+
+(F) The name you used inside C<\N{}> is unknown to Perl. Check the
+spelling. You can say C<use charnames ":loose"> to not have to be
+so precise about spaces, hyphens, and capitalization on standard Unicode
+names. (Any custom aliases that have been created must be specified
+exactly, regardless of whether C<:loose> is used or not.) This error may
+also happen if the C<\N{}> is not in the scope of the corresponding
+C<S<use charnames>>.
+
=item Unknown error
(P) Perl was about to print an error message in C<$@>, but the C<$@> variable
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
-The <-- HERE shows in the regular expression about where the problem was
+The <-- HERE shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
=item Unknown Unicode option letter '%c'
module (e.g. C<use warnings 'File::Find'>), you must have loaded this
module first.
-=item unmatched [ in regex; marked by <-- HERE in m/%s/
+=item Unmatched [ in regex; marked by <-- 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 in the regular expression about where the
+first. The <-- 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 <-- HERE in m/%s/
+
+=item Unmatched ) in regex; marked by <-- 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 in the regular expression
-
about where the problem was discovered. See L<perlre>.
+the matching parenthesis. The <-- HERE shows whereabouts in the
+
regular expression the problem was discovered. See L<perlre>.
=item Unmatched right %s bracket
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 passed through in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%c in character class passed through in regex;
+marked by <-- 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 in the regular expression about where the
+The <-- HERE shows whereabouts in the regular expression the
escape was discovered.
=item Unrecognized escape \%c passed through
(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 in
-the regular expression about where the escape was discovered.
+this may change in a future version of Perl. The <-- HERE shows
+whereabouts in the regular expression the escape was discovered.
=item Unrecognized signal name "%s"
compressed integer format and could not be converted to an integer.
See L<perlfunc/pack>.
+=item Unterminated delimiter for here document
+
+(F) This message occurs when a here document label has an initial
+quotation mark but the final quotation mark is missing. Perhaps
+you wrote:
+
+ <<"foo
+
+instead of:
+
+ <<"foo"
+
=item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
(F) You missed a close brace on a \g{..} pattern (group reference) in
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 <-- 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:
if ($string =~ /$pattern/) { ... }
-The <-- HERE shows in the regular expression about
-
where the problem was discovered. See L<perlre>.
+The <-- HERE shows whereabouts in the regular expression the problem was
+discovered. See L<perlre>.
=item Useless localization of %s
if ($string =~ /$pattern/o) { ... }
-The <-- HERE shows in the regular expression about
-
where the problem was discovered. See L<perlre>.
+The <-- HERE shows whereabouts in the regular expression the problem was
+discovered. See L<perlre>.
=item Useless use of /d modifier in transliteration operator
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]
+
+The interior braces, square brackets, and parentheses are treated as
+metacharacters even though they are backslashed; instead write:
+
+ m{ \x{FF} }x
+ m{foo{1,3}}
+ qr(foo(bar))
+ s[foo[a-z]bar][baz]
+
+The backslashes have no effect when a regular expression pattern is
+delimitted 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.
+
=item Useless use of \E
(W misc) You have a \E in a double-quotish string without a C<\U>,
it already went past any symlink you are presumably trying to look for.
The operation returned C<undef>. Use a filename instead.
+=item Use of my $_ is deprecated
+
+(D deprecated) Lexical $_ is deprecated because of
+its confusing side-effects. Consider using C<local $_>
+instead. See the explanation under L<perlvar/$_>.
+
=item Use of %s on a handle without * is deprecated
(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that scalar
however, because you can overload the numification and stringification
operators and then you presumably know what you are doing.
-=item Use of reserved word "%s" is deprecated
+=item Use of state $_ is deprecated
-(D deprecated) The indicated bareword is a reserved word. Future
-versions of perl may use it as a keyword, so you're better off either
-explicitly quoting the word in a manner appropriate for its context of
-use, or using a different name altogether. The warning can be
-suppressed for subroutine names by either adding a C<&> prefix, or using
-a package qualifier, e.g. C<&our()>, or C<Foo::our()>.
+(D deprecated) Lexical $_ is deprecated because of
+its confusing side-effects. Consider using C<local $_>
+instead. See the explanation under L<perlvar/$_>.
=item Use of tainted arguments in %s is deprecated
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
+=item Using just the first character returned by \N{} in character class in
+regex; marked by <-- HERE in m/%s/
-(W) A charnames handler may return a sequence of more than one character.
-Currently all but the first one are discarded when used in a regular
-expression pattern bracketed character class.
+(W regexp) A charnames handler may return a sequence of more than one
+character. Currently all but the first one are discarded when used in
+a regular expression pattern bracketed character class.
=item Using !~ with %s doesn't make sense
=item UTF-16 surrogate U+%X
-(W utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S utf8, 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
=item Variable "%s" is not imported%s
-(W misc) With "use strict" in effect, you referred to a global variable
+(S misc) With "use strict" in effect, you referred to a global variable
that you apparently thought was imported from another module, because
something else of the same name (usually a subroutine) is exported by
that module. It usually means you put the wrong funny character on the
front of your variable.
-=item Variable length lookbehind not implemented in m/%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>.
current scope or statement, effectively eliminating all access to the
previous instance. This is almost always a typographical error. Note
that the earlier variable will still exist until the end of the scope
-or until all closure referents to it are destroyed.
+or until all closure references to it are destroyed.
=item Variable syntax
=item vector argument not supported with alpha versions
-(W internal) The %vd (s)printf format does not support version objects
+(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 <-- 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 <-- 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.
https://perl5.git.perl.org / perl5.git / blobdiff