If a message can be controlled by the C<warnings> pragma, its warning
category is included with the classification letter in the description
-below.
+below. E.g. C<(W closed)> means a warning in the C<closed> category.
Optional warnings are enabled by using the C<warnings> pragma or the B<-w>
and B<-W> switches. Warnings may be captured by setting C<$SIG{__WARN__}>
(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.
(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.
+(W 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
(P) Perl detected an attempt to copy an internal value that is not
copiable.
+=item Bizarre SvTYPE [%d]
+
+(P) When starting a new thread or return values from a thread, Perl
+encountered an invalid data type.
+
=item Buffer overflow in prime_env_iter: %s
(W internal) A warning peculiar to VMS. While Perl was preparing to
iterate over %ENV, it encountered a logical name or symbol definition
which was too long, so it was truncated to the string shown.
-=item Bizarre SvTYPE [%d]
-
-(P) When starting a new thread or return values from a thread, Perl
-encountered an invalid data type.
-
=item Callback called exit
(F) A subroutine invoked from an external package via call_sv()
=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
(F) You used C<\p{}> or C<\P{}> but the character property by that name
could not be found. Maybe you misspelled the name of the property?
See L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available properties.
+for a complete list of available official properties.
=item Can't find label %s
you tried to jump out of a sort() block or subroutine, which is a no-no.
See L<perlfunc/goto>.
+=item Can't goto subroutine from an eval-%s
+
+(F) The "goto subroutine" call can't be used to jump out of an eval
+"string" or block.
+
=item Can't goto subroutine from a sort sub (or similar callback)
(F) The "goto subroutine" call can't be used to jump out of the
comparison sub for a sort(), or from a similar callback (such
as the reduce() function in List::Util).
-=item Can't goto subroutine from an eval-%s
-
-(F) The "goto subroutine" call can't be used to jump out of an eval
-"string" or block.
-
=item Can't goto subroutine outside a subroutine
(F) The deeply magical "goto subroutine" call can only replace one
(F) List assignment to %ENV is not supported on some systems, notably
VMS.
+=item Can't make loaded symbols global on this platform while loading %s
+
+(W) A module passed the flag 0x01 to DynaLoader::dl_load_file() to request
+that symbols from the stated file are made available globally within the
+process, but that functionality is not available on this platform. Whilst
+the module likely will still work, this may prevent the perl interpreter
+from loading other XS-based extensions which need to link directly to
+functions defined in the C or XS code in the stated file.
+
=item Can't modify %s in %s
(F) You aren't allowed to assign to the item indicated, or otherwise try
=item Character following "\c" must be ASCII
(F)(W 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 5.18. In the
-cases where it isn't fatal, the character this evaluates to is
+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.
-Note that non-alphabetic ASCII characters are discouraged here as well.
+Note that non-alphabetic ASCII characters are discouraged here as well,
+and using non-printable ones will be deprecated starting in v5.18.
=item Character in 'C' format wrapped in pack
If you actually want to pack Unicode codepoints, use the C<"U"> format
instead.
-=item Character in 'W' format wrapped in pack
-
-(W pack) You said
-
- pack("U0W", $x)
-
-where $x is either less than 0 or more than 255. However, C<U0>-mode
-expects all values to fall in the interval [0, 255], so Perl behaved
-as if you meant:
-
- pack("U0W", $x & 255)
-
=item Character in 'c' format wrapped in pack
(W pack) You said
unpack("H", "\x{a1}")
+=item Character in 'W' format wrapped in pack
+
+(W pack) You said
+
+ pack("U0W", $x)
+
+where $x is either less than 0 or more than 255. However, C<U0>-mode
+expects all values to fall in the interval [0, 255], so Perl behaved
+as if you meant:
+
+ pack("U0W", $x & 255)
+
=item Character(s) in '%c' format wrapped in pack
(W pack) You tried something like
(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.18. Just use a
+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"
(F) Creating a new thread inside the C<s///> operator is not supported.
-=item close() on unopened filehandle %s
-
-(W unopened) You tried to close a filehandle that was never opened.
-
=item closedir() attempted on invalid dirhandle %s
(W io) The dirhandle you tried to close is either closed or not really
a dirhandle. Check your control flow.
+=item close() on unopened filehandle %s
+
+(W unopened) You tried to close a filehandle that was never opened.
+
=item Closure prototype called
(F) If a closure has attributes, the subroutine passed to an attribute
(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, 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
+=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
of U+10FFFF.
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 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?.
+(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)%s: %s in regex; marked by <-- HERE in m/%s/
+=item Constant(%s): $^H{%s} is not defined
-(F) The parser found inconsistencies while attempting to find
-the character name specified in the C<\N{...}> escape.
+(F) The parser found inconsistencies while attempting to define an
+overloaded constant. Perhaps you forgot to load the corresponding
+L<overload> pragma?.
=item Constant is not %s reference
for inlining. See L<perlsub/"Constant Functions"> for commentary and
workarounds.
+=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 Copy method did not return a reference
(F) The method which overloads "=" is buggy. See
(F) The CORE:: namespace is reserved for Perl keywords.
+=item Corrupted regexp opcode %d > %d
+
+(P) This is either an error in Perl, or, if you're using
+one, your L<custom regular expression engine|perlreapi>. If not the
+latter, report the problem through the L<perlbug> utility.
+
=item corrupted regexp pointers
(P) The regular expression engine got confused by what the regular
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
=item %s does not define %s::VERSION--version check failed
(F) You said something like "use Module 42" but the Module did not
-define a C<$VERSION.>
+define a C<$VERSION>.
=item '/' does not take a repeat count
named "elseif" for the class returned by the following block. This is
unlikely to be what you want.
-=item Empty %s
+=item Empty \%c{} in regex; marked by <-- 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 <-- 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 Expecting close bracket in regex; marked by <-- HERE in m/%s/
+
+(F) You wrote something like
+
+ (?13
+
+to denote a capturing group of the form
+L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>,
+but omitted the C<")">.
+
=item Experimental "%s" subs not enabled
(F) To use lexical subs, you must first enable them:
(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.
forget to check the return value of your socket() call? See
L<perlfunc/getsockopt>.
+=item given is experimental
+
+(S experimental::smartmatch) C<given> depends on smartmatch, which
+is experimental, so its behavior may change or even be removed
+in any future release of perl. See the explanation under
+L<perlsyn/Experimental Details on given and when>.
+
=item Global symbol "%s" requires explicit package name
(F) You've said "use strict" or "use strict vars", which indicates
the indicated subroutine hasn't been defined, or if it was, it
has since been undefined.
-=item ()-group starts with a count
-
-(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/
+=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 ()-group starts with a count
+
+(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 %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.
(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/
+
+(F) You wrote something like
+
+ (?+foo)
+
+The C<"+"> is valid only when followed by digits, indicating a
+capturing group. See
+L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>.
+
=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 Inconsistent hierarchy during C3 merge of class '%s': merging failed on parent '%s'
+=item Incomplete expression within '(?[ ])' in regex; marked by <-- 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
+too many or few operands for the number of operators. Perl is not smart
+enough to give you a more precise indication as to what is wrong.
+
+=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
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/
+
+(D regexp, deprecated) 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.
+
=item Integer overflow in format string for %s
(F) The indexes and widths specified in the format string of C<printf()>
=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 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 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/
+=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
(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>>.
+See also L<perlrun/-Dletters>.
=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
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/
+
+(D regexp, deprecated) 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.
+
=item ioctl is not implemented
(F) Your machine apparently doesn't implement ioctl(), which is pretty
(W overload) You tried to overload a constant type the overload package is
unaware of.
+=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 in place, but no files were
+given. This is usually a mistake, since editing STDIN in place 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 Junk on end of regexp in regex m/%s/
(P) The regular expression parser is confused.
warning is generated that gives more details about the type of
malformation.
-=item Malformed UTF-8 returned by \N
+=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
(F) Lexically scoped subroutines are not yet implemented. Don't try
that yet.
+=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 "my" variable %s can't be in a package
(F) Lexically scoped variables aren't in a package, so it doesn't make
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{...} in regex; marked by <-- HERE in m/%s/
+=item Need exactly 3 octal digits 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.
+(F) Within S<C<(?[ ])>>, all constants interpreted as octal need to be
+exactly 3 digits long. This helps catch some ambiguities. If your
+constant is too short, add leading zeros, like
-=item \N{NAME} must be resolved by the lexer in regex; marked by <-- HERE in m/%s/
+ (?[ [ \078 ] ]) # Syntax error!
+ (?[ [ \0078 ] ]) # Works
+ (?[ [ \007 8 ] ]) # Clearer
-(F) When compiling a regex pattern, an unresolved named character or
-sequence was encountered. This can happen in any of several ways that
-bypass the lexer, such as using single-quotish context, or an extra
-backslash in double-quotish:
+The maximum number this construct can express is C<\777>. If you
+need a larger one, you need to use L<\o{}|perlrebackslash/Octal escapes> instead. If you meant
+two separate things, you need to separate them:
- $re = '\N{SPACE}'; # Wrong!
- $re = "\\N{SPACE}"; # Wrong!
- /$re/;
-
-Instead, use double-quotes with a single backslash:
-
- $re = "\N{SPACE}"; # ok
- /$re/;
-
-The lexer can be bypassed as well by creating the pattern from smaller
-components:
-
- $re = '\N';
- /${re}{SPACE}/; # Wrong!
-
-It's not a good idea to split a construct in the middle like this, and it
-doesn't work here. Instead use the solution above.
-
-Finally, the message also can happen under the C</x> regex modifier when the
-C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
-
- /\N {SPACE}/x; # Wrong!
- /\N{SPACE}/x; # ok
+ (?[ [ \7776 ] ]) # Syntax error!
+ (?[ [ \o{7776} ] ]) # One meaning
+ (?[ [ \777 6 ] ]) # Another meaning
+ (?[ [ \777 \006 ] ]) # Still another
=item Negative '/' count in unpack
=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>.
real method in a real package, and it could not find such a context.
See L<mro>.
+=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 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
+bypass the lexer, such as using single-quotish context, or an extra
+backslash in double-quotish:
+
+ $re = '\N{SPACE}'; # Wrong!
+ $re = "\\N{SPACE}"; # Wrong!
+ /$re/;
+
+Instead, use double-quotes with a single backslash:
+
+ $re = "\N{SPACE}"; # ok
+ /$re/;
+
+The lexer can be bypassed as well by creating the pattern from smaller
+components:
+
+ $re = '\N';
+ /${re}{SPACE}/; # Wrong!
+
+It's not a good idea to split a construct in the middle like this, and
+it doesn't work here. Instead use the solution above.
+
+Finally, the message also can happen under the C</x> regex modifier when the
+C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
+
+ /\N {SPACE}/x; # Wrong!
+ /\N{SPACE}/x; # ok
+
=item No %s allowed while running setuid
(F) Certain operations are deemed to be too insecure for a setuid or
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/
+
+(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/
+
+(F) In a regular expression, there was a non-octal character where
+an octal one was expected, like
+
+ (?[ [ \o{1278} ] ])
+
+=item Non-octal character '%c'. Resolved as "%s"
+
+(W digit) In parsing an octal numeric constant, a character was
+unexpectedly encountered that isn't octal. The resulting value
+is as indicated.
+
=item "no" not allowed in expression
(F) The "no" keyword is recognized and executed at compile time, and
returns no useful value. See L<perlmod>.
+=item Non-string passed as bitmask
+
+(W misc) A number has been passed as a bitmask argument to select().
+Use the vec() function to construct the file descriptor bitmasks for
+select. See L<perlfunc/select>.
+
=item No output file after > on command line
(F) An error peculiar to VMS. Perl handles its own command line
(F) Configure didn't find anything resembling the setreuid() call for
your system.
+=item No such class %s
+
+(F) You provided a class qualifier in a "my", "our" or "state"
+declaration, but this class doesn't exist at this point in your program.
+
=item No such class field "%s" in variable %s of type %s
(F) You tried to access a key from a hash through the indicated typed
The indicated package has restricted the set of allowed keys using the
L<fields> pragma.
-=item No such class %s
-
-(F) You provided a class qualifier in a "my", "our" or "state"
-declaration, but this class doesn't exist at this point in your program.
-
=item No such hook: %s
(F) You specified a signal hook that was not recognized by Perl.
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/
+
+(F) C<(?[...])> cannot be used within the scope of a C<S<use locale>> or with
+an C</l> regular expression modifier, as that would require deferring
+to run-time the calculation of what it should evaluate to, and it is
+regex compile-time only.
+
=item no UTC offset information; assuming local time is UTC
(S) A warning peculiar to VMS. Perl was unable to find the local
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
-=item Non-octal character '%c'. Resolved as "%s"
-
-(W digit) In parsing an octal numeric constant, a character was
-unexpectedly encountered that isn't octal. The resulting value
-is as indicated.
-
-=item Non-string passed as bitmask
-
-(W misc) A number has been passed as a bitmask argument to select().
-Use the vec() function to construct the file descriptor bitmasks for
-select. See L<perlfunc/select>.
-
=item Null filename used
(F) You can't require the null filename, especially because on many
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
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/
+
+(F) You wrote something like
+
+ (?[ \p{Digit} \p{Thai} ])
+
+There are two operands, but no operator giving how you want to combine
+them.
+
=item Operation "%s": no method found, %s
(F) An attempt was made to perform an overloaded operation for which no
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: strxfrm() gets absurd - a => %u, ab => %u
+
+(P) The interpreter's sanity check of the C function strxfrm() failed.
+In your current locale the returned transformation of the string "ab"
+is shorter than that of the string "a", which makes no sense.
+
=item panic: sv_chop %s
(P) The sv_chop() routine was passed a position that is not within the
(P) The sv_insert() routine was told to remove more string than there
was string.
-=item panic: strxfrm() gets absurd - a => %u, ab => %u
-
-(P) The interpreter's sanity check of the C function strxfrm() failed.
-In your current locale the returned transformation of the string "ab" is
-shorter than that of the string "a", which makes no sense.
-
=item panic: top_env
(P) The compiler attempted to do a goto, or something weird like that.
(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
+(D 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
-"perlbug" utility. (This message is marked deprecated, so that it by
+built-in regular expression folding rules are not accurate. This
+may lead to incorrect results. Please report this as a bug using the
+L<perlbug> utility. (This message is marked deprecated, so that it by
default will be turned-on.)
=item Perl_my_%s() not available
Maybe the code needs to be updated, or maybe it is simply
wrong and the version check should just be removed.
+=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 you are not using the
+hash seed you think you are.
+
=item perl: warning: Setting locale failed.
(S) The whole warning message will look something like:
time you run Perl. How to really fix the problem can be found in
L<perllocale> section B<LOCALE PROBLEMS>.
+=item perl: warning: strange setting in '$ENV{PERL_PERTURB_KEYS}': '%s'
+
+(W) Perl was run with the environment variable PERL_PERTURB_KEYS defined
+but containing an unexpected value. The legal values of this setting
+are as follows.
+
+ Numeric | String | Result
+ --------+---------------+-----------------------------------------
+ 0 | NO | Disables key traversal randomization
+ 1 | RANDOM | Enables full key traversal randomization
+ 2 | DETERMINISTIC | Enables repeatable key traversal randomization
+
+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 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
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/
+
+(F) The named property which you specified via C<\p> or C<\P> is not one
+known to Perl. Perhaps you misspelled the name? See
+L<perluniprops/Properties accessible through \p{} and \P{}>
+for a complete list of available official
+properties. If it is a L<user-defined property|perlunicode/User-Defined Character Properties>
+it must have been defined by the time the regular expression is
+compiled.
+
=item Prototype after '%c' for %s : %s
(W illegalproto) A character follows % or @ in a prototype. This is
=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 {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/
+
+(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 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
-
-(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.
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 "-" in regex; marked by <-- HERE in m/%s/
+=item Regexp modifier "%c" may not appear after the "-" in regex; marked by <--
+HERE in m/%s/
(F) Turning off the given modifier has the side effect of turning on
another one. Perl currently doesn't allow this. Reword the regular
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 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
causes, see L<perlre>.
-=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
-
-(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 m/%s/
(F) A regular expression comment must be terminated by a closing
parenthesis. Embedded parentheses aren't allowed. See
L<perlre>.
+=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
+
+(F) The regular expression expects a mandatory argument following the escape
+sequence and this has been omitted or incorrectly written.
+
=item Sequence (?{...}) not terminated with ')'
(F) The end of the perl code contained within the {...} must be
followed immediately by a ')'.
-=item Z<>500 Server error
-
-See Server error.
-
-=item Server error
+=item Server error (a.k.a. "500 Server error")
(A) This is the error message generally seen in a browser window
when trying to run a CGI program (including SSI) over the web. The
=item Smart matching a non-overloaded object breaks encapsulation
(F) You should not use the C<~~> operator on an object that does not
-overload it: Perl refuses to use the object's underlying structure for
-the smart match.
+overload it: Perl refuses to use the object's underlying structure
+for the smart match.
+
+=item Smartmatch is experimental
+
+(S experimental::smartmatch) This warning is emitted if you
+use the smartmatch (C<~~>) operator. This is currently an experimental
+feature, and its details are subject to change in future releases of
+Perl. Particularly, its current behavior is noticed for being
+unnecessarily complex and unintuitive, and is very likely to be
+overhauled.
=item sort is now a reserved word
=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
instead, which does return. To suppress this warning, put the exec() in
a block by itself.
-=item "state" variable %s can't be in a package
-
-(F) Lexically scoped variables aren't in a package, so it doesn't make
-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.
lexical variable. Either qualify the sort variable with the package
name, or rename the lexical variable.
+=item "state" variable %s can't be in a package
+
+(F) Lexically scoped variables aren't in a package, so it doesn't make
+sense to try to declare one with a package qualifier on the front. Use
+local() if you want to localize a package variable.
+
=item stat() on unopened filehandle %s
(W unopened) You tried to use the stat() function on a filehandle that
was either never opened or has since been closed.
+=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 Stub found while resolving method "%s" overloading "%s" in package "%s"
(P) Overloading resolution over @ISA tree may be broken by importation
(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
a perl4 interpreter, especially if the next 2 tokens are "use strict"
or "my $var" or "our $var".
+=item Syntax error in (?[...]) in regex m/%s/
+
+(F) Perl could not figure out what you meant inside this construct; this
+notifies you that it is giving up trying.
+
=item sysread() on closed filehandle %s
(W closed) You tried to read from a closed filehandle.
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
=item The %s function is unimplemented
-(F) The function indicated isn't implemented on this architecture, according
-to the probings of Configure.
+(F) The function indicated isn't implemented on this architecture,
+according to the probings of Configure.
+
+=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 regex_sets feature is experimental
+
+(S experimental::regex_sets) This warning is emitted if you
+use the syntax S<C<(?[ ])>> in a regular expression.
+The details of this feature are subject to change.
+if you want to use it, but know that in doing so you
+are taking the risk of using an experimental feature which may
+change in a future Perl version, you can do this to silence the
+warning:
+
+ no warnings "experimental::regex_sets";
=item The stat preceding %s wasn't an lstat
target of the change to
%ENV which produced the warning.
+=item This Perl has not been built with support for randomized hash key traversal but something called Perl_hv_rand_set().
+
+(F) Something has attempted to use an internal API call which
+depends on Perl being compiled with the default support for randomized hash
+key traversal, but this Perl has been compiled without it. You should
+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.
(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[][]
(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
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/
+
+(F) You had something like this:
+
+ (?[ | \p{Digit} ])
+
+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/
+
+(F) You had something like this:
+
+ (?[ z ])
+
+Within C<(?[ ])>, no literal characters are allowed unless they are
+within an inner pair of square brackets, like
+
+ (?[ [ z ] ])
+
+Another possibility is that you forgot a backslash. Perl isn't smart
+enough to figure out what you really meant.
+
=item Unexpected constant lvalue entersub entry via type/targ %d:%d
(P) When compiling a subroutine call in lvalue context, Perl failed an
internal consistency check. It encountered a malformed op tree.
+=item Unexpected ')' in regex; marked by <-- HERE in m/%s/
+
+(F) You had something like this:
+
+ (?[ ( \p{Digit} + ) ])
+
+The C<")"> is out-of-place. Something apparently was supposed to
+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/
+
+(F) You had something like this:
+
+ (?[ \p{Digit} ( \p{Lao} + \p{Thai} ) ])
+
+There should be an operator before the C<"(">, as there's
+no indication as to how the digits are to be combined
+with the characters in the Lao and Thai scripts.
+
=item Unicode non-character U+%X is illegal for open interchange
(S utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
came from. If you really really know what you are doing you can turn
off this warning by C<no warnings 'surrogate';>.
-=item Unknown BYTEORDER
-
-(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
data Perl expected. Someone's very confused, or perhaps trying to
subvert Perl's population of %ENV for nefarious purposes.
-=item Unknown "re" subpragma '%s' (known ones are: %s)
-
-(W) You tried to use an unknown subpragma of the "re" pragma.
-
=item Unknown regex modifier "%s"
(F) Alphanumerics immediately following the closing delimiter
if ($a =~ /foo/ and $bar == 3) { ... }
+=item Unknown "re" subpragma '%s' (known ones are: %s)
+
+(W) You tried to use an unknown subpragma of the "re" pragma.
+
=item Unknown switch condition (?(%s in regex; marked by <-- HERE in m/%s/
(F) The condition part of a (?(condition)if-clause|else-clause) construct
(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 POSIX class in regex; marked by <-- HERE in m/%s/
+
+(F) You had something like this:
+
+ (?[ [:digit: ])
+
+That should be written:
+
+ (?[ [:digit:] ])
+
+=item Unmatched '%c' in POSIX class in regex; marked by <-- HERE in m/%s/
+
+(F) You had something like this:
+
+ (?[ [:alnum] ])
+
+There should be a second C<":">, like this:
+
+ (?[ [:alnum:] ])
+
=item Unmatched [ in regex; marked by <-- 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/
(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 in regex; marked by <-- 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/
(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"
<<"foo"
+=item Unterminated \g... pattern in regex; marked by <-- HERE in m/%s/
+
=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
-a regular expression. Fix the pattern and retry.
+(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
+missing; otherwise the C<\g> must be followed by an integer. Fix the
+pattern and retry.
=item Unterminated <> operator
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
+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.
+
=item Useless use of \E
(W misc) You have a \E in a double-quotish string without a C<\U>,
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/
+
+(W regexp) The C<p> modifier cannot be turned off once set. Trying to do
+so is futile.
+
=item Useless use of "re" pragma
(W) You did C<use re;> without any arguments. That isn't very useful.
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
+=item Use of each() on hash after insertion without resetting hash iterator results in undefined behavior
+
+(S internal) The behavior of C<each()> after insertion is undefined; it may
+skip items, or visit items more than once. Consider using C<keys()> instead
+of C<each()>.
+
=item Use of := for an empty attribute list is not allowed
(F) The construction C<my $x := 42> used to parse as equivalent to
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 experimental
+
+(S experimental::lexical_topic) Lexical $_ is an experimental feature and
+its behavior may change or even be removed in any future release of perl.
+See the explanation under L<perlvar/$_>.
+
=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 state $_ is experimental
+
+(S experimental::lexical_topic) Lexical $_ is an experimental feature and
+its behavior may change or even be removed in any future release of perl.
+See the explanation under L<perlvar/$_>.
+
=item Use of tainted arguments in %s is deprecated
(W taint, deprecated) You have supplied C<system()> or C<exec()> with multiple
the name of the variable (if any) that was undefined. In some cases
it cannot do this, so it also tells you what operation you used the
undefined value in. Note, however, that perl optimizes your program
-anid the operation displayed in the warning may not necessarily appear
+and the operation displayed in the warning may not necessarily appear
literally in your program. For example, C<"that $foo"> is usually
optimized into C<"that " . $foo>, and the warning will refer to the
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/
+
+(F) In a regular expression, you said something like
+
+ (?[ [ \xBEEF ] ])
+
+Perl isn't sure if you meant this
+
+ (?[ [ \x{BEEF} ] ])
+
+or if you meant this
+
+ (?[ [ \x{BE} E F ] ])
+
+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
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
(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.
So put in parentheses to say what you really mean.
+=item when is experimental
+
+(S experimental::smartmatch) C<when> depends on smartmatch, which is
+experimental. Additionally, it has several special cases that may
+not be immediately obvious, and their behavior may change or
+even be removed in any future release of perl. See the explanation
+under L<perlsyn/Experimental Details on given and when>.
+
=item Wide character in %s
(S utf8) Perl met a wide character (>255) when it wasn't expecting
=item %s "\x%X" does not map to Unicode
-(F) When reading in different encodings Perl tries to map everything
-into Unicode characters. The bytes you read in are not legal in
-this encoding, for example
+(F) When reading in different encodings, Perl tries to map
+everything into Unicode characters. The bytes you read in
+are not legal in this encoding. For example
utf8 "\xE4" does not map to Unicode
=item Your random numbers are not that random
-(F) When trying to initialise the random seed for hashes, Perl could
+(F) When trying to initialize the random seed for hashes, Perl could
not get any randomness out of your system. This usually indicates
Something Very Wrong.
https://perl5.git.perl.org / perl5.git / blobdiff