(X) You can't allocate more than 64K on an MS-DOS machine.
-=item '%c' allowed only after types %s
+=item '%c' allowed only after types %s in %s
(F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only
after certain types. See L<perlfunc/pack>.
(F) msgsnd() requires a string at least as long as sizeof(long).
-=item %s argument is not a HASH or ARRAY element or a subroutine
-
-(F) The argument to exists() must be a hash or array element or a
-subroutine with an ampersand, such as:
-
- $foo{$bar}
- $ref->{"susie"}[12]
- &do_something
-
-=item %s argument is not a HASH or ARRAY element or slice
-
-(F) The argument to delete() must be either a hash or array element,
-such as:
-
- $foo{$bar}
- $ref->{"susie"}[12]
-
-or a hash or array slice, such as:
-
- @foo[$bar, $baz, $xyzzy]
- @{$ref->[12]}{"susie", "queue"}
-
-=item %s argument is not a subroutine name
-
-(F) The argument to exists() for C<exists &sub> must be a subroutine
-name, and not a subroutine call. C<exists &sub()> will generate this
-error.
-
=item Argument "%s" isn't numeric%s
(W numeric) The indicated string was fed as an argument to an operator
didn't explicitly request the failing operation, it may be the
result of the value of the environment variable PERLIO.
+=item Argument "%s" treated as 0 in increment (++)
+
+(W numeric) The indicated string was fed as an argument to the C<++>
+operator which expects either a number or a string matching
+C</^[a-zA-Z]*[0-9]*\z/>. See L<perlop/Auto-increment and
+Auto-decrement> for details.
+
=item Array @%s missing the @ in argument %d of %s()
(D deprecated) Really old Perl let you omit the @ on array names in some
=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>.
+(D deprecated) 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
(F) The failing code has attempted to get or set a key which is not in
the current set of allowed keys of a restricted hash.
+=item Attempt to bless into a freed package
+
+(F) You wrote C<bless $foo> with one argument after somehow causing
+the current package to be freed. Perl cannot figure out what to
+do, so it throws up in hands in despair.
+
=item Attempt to bless into a reference
(F) The CLASSNAME argument to the bless() operator is expected to be
=item "\B{" is deprecated; use "\B\{" or "\B[{]" instead in regex; marked by <-- HERE in m/%s/
-(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<{}>.
+(D deprecated) Use of an unescaped "{" immediately following
+a C<\b> or C<\B> is now deprecated so as to reserve its use for Perl
+itself in a future release. You can either precede the brace
+with a backslash, or enclose it in square brackets; the latter
+is the way to go if the pattern delimiters are C<{}>.
=item Bit vector size > 32 non-portable
(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 returning 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()
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
+=item Can't call mro_isa_changed_in() on anonymous symbol table
+
+(P) Perl got confused as to whether a hash was a plain hash or a
+symbol table hash when trying to update @ISA caches.
+
+=item Can't call mro_method_changed_in() on anonymous symbol table
+
+(F) An XS module tried to call C<mro_method_changed_in> on a hash that was
+not attached to the symbol table.
+
=item Can't chdir to %s
(F) You called C<perl -x/foo/bar>, but F</foo/bar> is not a directory
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
=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
+(S) 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
=item Can't use string ("%s") as %s ref while "strict refs" in use
+=item Can't use string ("%s"...) as %s ref while "strict refs" in use
+
(F) You've told Perl to dereference a string, something which
C<use strict> blocks to prevent it happening accidentally. See
L<perlref/"Symbolic references">. This can be triggered by an C<@> or C<$>
=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
+(F)(D deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
+It is planned to make this fatal in all instances in Perl v5.20. In
+the cases where it isn't fatal, the character this evaluates to is
derived by exclusive or'ing the code point of this character with 0x40.
-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, may not be portable
+
(S utf8, non_unicode) You had a code point above the Unicode maximum
of U+10FFFF.
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 is not %s reference
(F) A constant value (perhaps declared using the C<use constant> pragma)
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
(P) The malloc package that comes with Perl had an internal failure.
-=item Corrupted regexp opcode %d > %d
-
-(F)
-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 Count after length/code in unpack
(F) You had an unpack template indicating a counted-length string, but
(F) You said something like "use Module 42" but in the Module file
there are neither package declarations nor a C<$VERSION>.
+=item delete argument is index/value array slice, use array slice
+
+(F) You used index/value array slice syntax (C<%array[...]>) as
+the argument to C<delete>. You probably meant C<@array[...]> with
+an @ symbol instead.
+
+=item delete argument is key/value hash slice, use hash slice
+
+(F) You used key/value hash slice syntax (C<%hash{...}>) as the argument to
+C<delete>. You probably meant C<@hash{...}> with an @ symbol instead.
+
+=item delete argument is not a HASH or ARRAY element or slice
+
+(F) The argument to C<delete> must be either a hash or array element,
+such as:
+
+ $foo{$bar}
+ $ref->{"susie"}[12]
+
+or a hash or array slice, such as:
+
+ @foo[$bar, $baz, $xyzzy]
+ @{$ref->[12]}{"susie", "queue"}
+
=item Delimiter for here document is too long
(F) In a here document construct like C<<<FOO>, the label C<FOO> is too
(F) You cannot put a repeat count of any kind right after the '/' code.
See L<perlfunc/pack>.
-=item Don't know how to handle magic of type '%s'
+=item Don't know how to handle magic of type \%o
(P) The internal handling of magical variables has been cursed.
(F) The final summary message when a Perl compilation fails.
+=item exists argument is not a HASH or ARRAY element or a subroutine
+
+(F) The argument to C<exists> must be a hash or array element or a
+subroutine with an ampersand, such as:
+
+ $foo{$bar}
+ $ref->{"susie"}[12]
+ &do_something
+
+=item exists argument is not a subroutine name
+
+(F) The argument to C<exists> for C<exists &sub> must be a subroutine name,
+and not a subroutine call. C<exists &sub()> will generate this error.
+
=item Exiting eval via %s
(W exiting) You are exiting an eval by unconventional means, such as a
=item Expecting close bracket in regex; marked by <-- HERE in m/%s/
-(F)
-You wrote something like
+(F) You wrote something like
(?13
L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>,
but omitted the C<")">.
+=item Expecting '(?flags:(?[...' in regex; marked by <-- HERE in m/%s/
+
+(F) The C<(?[...])> extended character class regular expression construct
+only allows character classes (including character class escapes like
+C<\d>), operators, and parentheses. The one exception is C<(?flags:...)>
+containing at least one flag and exactly one C<(?[...])> construct.
+This allows a regular expression containing just C<(?[...])> to be
+interpolated. If you see this error message, then you probably
+have some other C<(?...)> construct inside your character class. See
+L<perlrecharclass/Extended Bracketed Character Classes>.
+
=item Experimental "%s" subs not enabled
(F) To use lexical subs, you must first enable them:
=item False [] range "%s" in regex; marked by <-- HERE in m/%s/
-(W regexp) A character class range must start and end at a literal
+(W regexp)(F) A character class range must start and end at a literal
character, not another character class like C<\d> or C<[:alpha:]>. The "-"
-in your false range is interpreted as a literal "-". Consider quoting the
-"-", "\-". The <-- HERE shows whereabouts in the regular expression the
-problem was discovered. See L<perlre>.
+in your false range is interpreted as a literal "-". In a C<(?[...])>
+construct, this is an error, rather than a warning. Consider quoting
+the "-", "\-". The <-- HERE shows whereabouts in the regular expression
+the problem was discovered. See L<perlre>.
=item Fatal VMS error (status=%d) at %s, line %d
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/
(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>.
+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.
(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
=item Ignoring zero length \N{} in character class in regex; marked by <-- HERE in m/%s/
-(W regexp) Named Unicode character escapes C<(\N{...})> may return a zero-length
-sequence. When such an escape is used in a character class its
-behaviour is not well defined. Check that the correct escape has
+(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.
=item Illegal binary digit %s
=item Illegal character after '_' in prototype for %s : %s
-(W illegalproto) An illegal character was found in a prototype declaration.
-Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
+(W illegalproto) An illegal character was found in a prototype
+declaration. The '_' in a prototype must be followed by a ';',
+indicating the rest of the parameters are optional, or one of '@'
+or '%', since those two will accept 0 or more final parameters.
=item Illegal character \%o (carriage return)
=item Illegal pattern in regex; marked by <-- HERE in m/%s/
-(F)
-You wrote something like
+(F) You wrote something like
(?+foo)
=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
+(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.
Unicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC
encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
-=item Infinite recursion in regex; marked by <-- HERE in m/%s/
+=item Infinite recursion in regex
(F) You used a pattern that references itself without consuming any input
text. You should check the pattern to ensure that recursive patterns
either consume text or fail.
-The <-- HERE shows whereabouts in the regular expression the problem was
-discovered.
-
=item Initialization of state variables in list context currently forbidden
(F) Currently the implementation of "state" only permits the
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()>
Perl is making a guess and treating this C<exec> as a request to
terminate the Perl script and execute the specified command.
+=item internal %<num>p might conflict with future printf extensions
+
+(S internal) Perl's internal routine that handles C<printf> and C<sprintf>
+formatting follows a slightly different set of rules when called from
+C or XS code. Specifically, formats consisting of digits followed
+by "p" (e.g., "%7p") are reserved for future use. If you see this
+message, then an XS module tried to call that routine with one such
+reserved format.
+
=item Internal urp in regex; marked by <-- HERE in m/%s/
(P) Something went badly awry in the regular expression parser. The
(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 [] range "%*.*s" in regex; marked by <-- HERE in m/%s/
-
-(F)
-You wrote something like
+=item Invalid character in charnames alias definition; marked by <-- HERE in '%s
- [z-a]
+(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>.
-in a regular expression pattern. Ranges must be specified with the
-lowest code point first. Instead write
+=item Invalid \0 character in %s for %s: %s\0%s
- [a-z]
+(W syscalls) Embedded \0 characters in pathnames or other system call
+arguments produce a warning as of 5.20. The parts after the \0 were
+formerly ignored by system calls.
=item Invalid character in \N{...}; marked by <-- 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
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.
length/code combination tried to obtain more data. This results in
an undefined value for the length. See L<perlfunc/pack>.
-=item length() used on %s
+=item length() used on %s (did you mean "scalar(%s)"?)
(W syntax) You used length() on either an array or a hash when you
probably wanted a count of the items.
See also L<attributes.pm|attributes>.
+=item Magical list constants are not supported
+
+(F) You assigned a magical array to a stash element, and then tried
+to use the subroutine from the same slot. You are asking Perl to do
+something it cannot do, details subject to change between Perl versions.
+
=item Malformed integer in [] in pack
(F) Between the brackets enclosing a numeric repeat count only digits
are always mentioned with the $ in Perl, unlike in the shells, where it
can vary from one line to the next.
+=item Missing ']' in prototype for %s : %s
+
+(W illegalproto) A grouping was started with C<[> but never closed with
+C<]>.
+
=item (Missing operator before %s?)
(S syntax) This is an educated guess made in conjunction with the message
list of arguments, but have forgotten to specify a piped open mode.
See L<perlfunc/open> for details.
+=item mprotect for %p %u failed with %d
+
+=item mprotect RW for %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see
+L<perlhacktips>), but an op tree could not be made read-only, or a
+read-only op tree could not be made mutable before freeing the ops.
+
=item msg%s not implemented
(F) You don't have System V message IPC on your system.
(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
(W once) Typographical errors often show up as unique variable names.
If you had a good reason for having a unique name, then just mention it
-again somehow to suppress the message. The C<our> declaration is
-provided for this purpose.
+again somehow to suppress the message. The C<our> declaration is provided
+for this purpose.
NOTE: This warning detects symbols that have been used only once so $c, @c,
%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
the same; if a program uses $c only once but also uses any of the others it
-will not trigger this warning.
-
-=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
+will not trigger this warning. Symbols beginning with an underscore and
+symbols using special identifiers (q.v. L<perldata>) are exempt from this
+warning.
=item Need exactly 3 octal digits in regex; marked by <-- HERE in m/%s/
(?[ [ \007 8 ] ]) # Clearer
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
+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:
(?[ [ \7776 ] ]) # Syntax error!
(?[ [ \o{7776} ] ]) # One meaning
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 "no" not allowed in expression
+=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-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 '%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-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-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 (?[...]) 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 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
(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 Operand with no preceding operator in regex; marked by <-- HERE in m/%s/
-(F)
-You wrote something like
+(F) You wrote something like
(?[ \p{Digit} \p{Thai} ])
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.
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/
+=item Pattern subroutine nesting without pos change exceeded limit in regex
(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>
=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/
-(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
-L<perlbug> utility. (This message is marked deprecated, so that it by
-default will be turned-on.)
+(S regexp) You used a regular expression with case-insensitive matching,
+and there is a bug in Perl in which the built-in regular expression
+folding rules are not accurate. This may lead to incorrect results.
+Please report this as a bug using the L<perlbug> utility.
=item Perl_my_%s() not available
decimal point representing a part of the version number. So 5.10
is equivalent to v5.100.
-=item Perl %s required--this is only version %s, stopped
+=item Perl %s required--this is only %s, stopped
(F) The module in question uses features of a version of Perl more
recent than the currently running version. How long has it been since
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
+
+(S) 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: Non hex character in '$ENV{PERL_HASH_SEED}', seed only
-partially set
+=item perl: warning: strange setting in '$ENV{PERL_PERTURB_KEYS}': '%s'
+
+(S) 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.
-(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.
+ 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
end of the buffer just in case. This sentinel byte got clobbered, and
Perl assumes that memory is now corrupted. See L<perlfunc/ioctl>.
+=item Possible precedence issue with control flow operator
+
+(W syntax) There is a possible problem with the mixing of a control
+flow operator (e.g. C<return>) and a low-precedence operator like
+C<or>. Consider:
+
+ sub { return $a or $b; }
+
+This is parsed as:
+
+ sub { (return $a) or $b; }
+
+Which is effectively just:
+
+ sub { return $a; }
+
+Either use parentheses or the high-precedence variant of the operator.
+
+Note this may be also triggered for constructs like:
+
+ sub { 1 if die; }
+
=item Possible precedence problem on bitwise %c operator
(W precedence) Your program uses a bitwise logical operator in conjunction
=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
+(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>
+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.
the {min,max} construct. The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See L<perlre>.
+=item Quantifier {n,m} with n > m can't match in regex
+
+=item Quantifier {n,m} with n > m can't match in regex; marked by <-- HERE in m/%s/
+
+(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/
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 ".."
(P) A "can't happen" error, because safemalloc() should have caught it
earlier.
-=item Repeated format line will never terminate (~~ and @# incompatible)
+=item Repeated format line will never terminate (~~ and @#)
(F) Your format contains the ~~ repeat-until-blank sequence and a
numeric field that will never go blank so that the repetition never
not magically convert between scalars and lists for you. See
L<perlref>.
+=item Scalar value %%s[%s] better written as $%s[%s]
+
+(W syntax) In scalar context, you've used an array index/value slice
+(indicated by %) to select a single element of an array. Generally
+it's better to ask for a scalar value (indicated by $). The difference
+is that C<$foo[&bar]> always behaves like a scalar, both in the value it
+returns and when evaluating its argument, while C<%foo[&bar]> provides
+a list context to its subscript, which can do weird things if you're
+expecting only one subscript. When called in list context, it also
+returns the index (what C<&bar> returns) in addition to the value.
+
+=item Scalar value %%s{%s} better written as $%s{%s}
+
+(W syntax) In scalar context, you've used a hash key/value slice
+(indicated by %) to select a single element of a hash. Generally it's
+better to ask for a scalar value (indicated by $). The difference
+is that C<$foo{&bar}> always behaves like a scalar, both in the value
+it returns and when evaluating its argument, while C<@foo{&bar}> and
+provides a list context to its subscript, which can do weird things
+if you're expecting only one subscript. When called in list context,
+it also returns the key in addition to the value.
+
=item Search pattern not terminated
(F) The lexer couldn't find the final delimiter of a // or m{}
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
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 SWASHNEW didn't return an HV ref
+
+(P) Something went wrong internally when Perl was trying to look up
+Unicode characters.
+
=item Switch (?(condition)... contains too many branches in regex; marked by
<-- HERE in m/%s/
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.
(W unopened) You tried to read from a filehandle that was never opened.
-=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 System V %s is not implemented on this machine
(F) You tried to do something with a function beginning with "sem",
will continue to pretend that it is. And if you quote me on that, I
will deny it.
+=item The %s feature is experimental
+
+(S experimental) This warning is emitted if you enable an experimental
+feature via C<use feature>. Simply suppress the warning if you want
+to use the feature, but know that in doing so you are taking the risk
+of using an experimental feature which may change or be removed in a
+future Perl version:
+
+ no warnings "experimental::lexical_subs";
+ use feature "lexical_subs";
+
+=item The %s function is unimplemented
+
+(F) The function indicated isn't implemented on this architecture,
+according to the probings of Configure.
+
=item The lexical_subs feature is experimental
(S experimental::lexical_subs) This warning is emitted if you
no warnings "experimental::regex_sets";
-=item The %s function is unimplemented
-
-(F) The function indicated isn't implemented on this architecture, according
-to the probings of Configure.
-
=item The stat preceding %s wasn't an lstat
(F) It makes no sense to test the current stat buffer for symbolic
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.
=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}>.
+(D deprecated) You defined a character name which ended in a space
+character. Remove the trailing space(s). Usually these names are
+defined in the C<:alias> import argument to C<use charnames>, but they
+could be defined by a translator installed into C<$^H{charnames}>.
See L<charnames/CUSTOM ALIASES>.
=item Transliteration pattern not terminated
(F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
-=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 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 binary operator '%c' with no preceding operand in regex; marked by <-- HERE in m/%s/
-(F)
-You had something like this:
+(F) You had something like this:
(?[ | \p{Digit} ])
=item Unexpected character in regex; marked by <-- HERE in m/%s/
-(F)
-You had something like this:
+(F) You had something like this:
(?[ z ])
(P) When compiling a subroutine call in lvalue context, Perl failed an
internal consistency check. It encountered a malformed op tree.
+=item Unexpected exit %u
+
+(S) exit() was called or the script otherwise finished gracefully when
+C<PERL_EXIT_WARN> was set in C<PL_exit_flags>.
+
+=item Unexpected exit failure %u
+
+(S) An uncaught die() was called when C<PERL_EXIT_WARN> was set in
+C<PL_exit_flags>.
+
+=item Unexpected ')' in regex; marked by <-- HERE in m/%s/
+
+(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 switch condition (?(%s in regex; marked by <-- HERE in m/%s/
+=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 (?(...)) in regex; marked by <-- HERE in m/%s/
(F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition must be one of the following:
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
-=item Unknown Unicode option value %x
+=item Unknown Unicode option value %d
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
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/
-You had something like this:
+(F) You had something like this:
(?[ [:alnum] ])
first. The <-- HERE shows whereabouts in the regular expression the
problem was discovered. See L<perlre>.
-=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 ( in regex; marked by <-- HERE in m/%s/
=item Unmatched ) 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<(?[ ])>.
+(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/
<<"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
You probably meant to use C<$]> instead. C<$[> is the base for indexing
arrays. C<$]> is the Perl version number in decimal.
-=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 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 Useless assignment to a temporary
(W misc) You assigned to an lvalue subroutine, but what
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
+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
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.
This is not very useful, and perl currently optimizes this away.
-=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 %s with no values
(W syntax) You used the push() or unshift() function with no arguments
if the array is tied to a class which implements a PUSH method. If so,
you can write it as C<push(@tied_array,())> to avoid this warning.
-=item Useless (%s%c) - %suse /%c modifier in regex; marked by <-- HERE in m/%s/
-
-(W regexp)
-The C</g> and C</o> regular expression modifiers are global and can't be
-turned off once set; hence things like C<(?g)> or C<(?-o:)> do nothing.
-
-=item Useless (%sc) - %suse /gc modifier in regex; marked by <-- HERE in m/%s/
-
-(W regexp)
-The C</c> regular expression modifier is global, can't be turned off
-once set, and doesn't do anything without the C</g> modifier being
-specified as well; hence things like C<(?c)> or C<(?-c:)> do nothing,
-nor do thing like C<(?gc)> nor C<(?-gc:)> .
-
=item "use" not allowed in expression
(F) The "use" keyword is recognized and executed at compile time, and
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
generally because there's a better way to do it, and also because the
old way has bad side effects.
-=item Use of -l on filehandle %s
+=item Use of -l on filehandle%s
(W io) A filehandle represents an opened file, and when you opened the file
it already went past any symlink you are presumably trying to look for.
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
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
+(S utf8) 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