below.
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__}>
+and B<-W> switches. Warnings may be captured by setting C<$SIG{__WARN__}>
to a reference to a routine that will be called on each warning instead
of printing it. See L<perlvar>.
=item Ambiguous use of %s resolved as %s
-(W ambiguous)(S) You said something that may not be interpreted the way
+(S ambiguous) You said something that may not be interpreted the way
you thought. Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, parenthesis pair or declaration.
=item Ambiguous use of %c resolved as operator %c
-(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
+(S ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
bitwise and, and multiplication) I<and> initial special characters
(denoting hashes, subroutines and typeglobs), and you said something
like C<*foo * foo> that might be interpreted as either of them. We
=item Ambiguous use of %c{%s{...}} resolved to %c%s{...}
-(W ambiguous) You wrote something like C<${foo[2]}> (where foo
-represents the name of a Perl keyword), which might be looking for
-element number 2 of the array named C<@foo>, in which case please write
-C<$foo[2]>, or you might have meant to pass an anonymous arrayref to
-the function named foo, and then do a scalar deref on the value it
-returns. If you meant that, write C<${foo([2])}>.
+(W ambiguous) You wrote something like C<${foo[2]}> (where foo represents
+the name of a Perl keyword), which might be looking for element number
+2 of the array named C<@foo>, in which case please write C<$foo[2]>, or you
+might have meant to pass an anonymous arrayref to the function named
+foo, and then do a scalar deref on the value it returns. If you meant
+that, write C<${foo([2])}>.
In regular expressions, the C<${foo[2]}> syntax is sometimes necessary
to disambiguate between array subscripts and character classes.
-C</$length[2345]/>, for instance, will be interpreted as C<$length>
-followed by the character class C<[2345]>. If an array subscript is what
-you want, you can avoid the warning by changing C</${length[2345]}/>
-to the unsightly C</${\$length[2345]}/>, by renaming your array to
-something that does not coincide with a built-in keyword, or by
-simply turning off warnings with C<no warnings 'ambiguous';>.
+C</$length[2345]/>, for instance, will be interpreted as C<$length> followed
+by the character class C<[2345]>. If an array subscript is what you
+want, you can avoid the warning by changing C</${length[2345]}/> to the
+unsightly C</${\$length[2345]}/>, by renaming your array to something
+that does not coincide with a built-in keyword, or by simply turning
+off warnings with C<no warnings 'ambiguous';>.
=item Ambiguous use of -%s resolved as -&%s()
-(W ambiguous) You wrote something like C<-foo>, which might be the
+(S ambiguous) You wrote something like C<-foo>, which might be the
string C<"-foo">, or a call to the function C<foo>, negated. If you meant
the string, just write C<"-foo">. If you meant the function call,
write C<-foo()>.
-=item Ambiguous use of 's//le...' resolved as 's// le...'; Rewrite as 's//el' if you meant 'use locale rules and evaluate rhs as an expression'. In Perl 5.18, it will be resolved the other way
-
-(W deprecated, ambiguous) You wrote a pattern match with substitution
-immediately followed by "le". In Perl 5.16 and earlier, this is
-resolved as meaning to take the result of the substitution, and see if
-it is stringwise less-than-or-equal-to what follows in the expression.
-Having the "le" immediately following a pattern is deprecated behavior,
-so in Perl 5.18, this expression will be resolved as meaning to do the
-pattern match using the rules of the current locale, and evaluate the
-rhs as an expression when doing the substitution. In 5.14, and 5.16 if
-you want the latter interpretation, you can simply write "el" instead.
-But note that the C</l> modifier should not be used explicitly anyway;
-you should use C<use locale> instead. See L<perllocale>.
-
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
bless $self, "$proto";
+=item Attempt to clear deleted array
+
+(S debugging) An array was assigned to when it was being freed.
+Freed values are not supposed to be visible to Perl code. This
+can also happen if XS code calls C<av_clear> from a custom magic
+callback on the array.
+
=item Attempt to delete disallowed key '%s' from a restricted hash
(F) The failing code attempted to delete from a restricted hash a key
strings. This indicates someone tried to decrement the reference count
of a string that can no longer be found in the table.
-=item Attempt to free temp prematurely
+=item Attempt to free temp prematurely: SV 0x%x
(S debugging) Mortalized values are supposed to be freed by the
free_tmps() routine. This indicates that something else is freeing the
(S internal) The reference counts got screwed up on symbol aliases.
-=item Attempt to free unreferenced scalar
+=item Attempt to free unreferenced scalar: SV 0x%x
(W internal) Perl went to decrement the reference count of a scalar to
see if it would go to 0, and discovered that it had already gone to 0
=item Attempt to set length of freed array
-(W) You tried to set the length of an array which has been freed. You
-can do this by storing a reference to the scalar representing the last index
-of an array and later assigning through that reference. For example
+(W misc) You tried to set the length of an array which has
+been freed. You can do this by storing a reference to the
+scalar representing the last index of an array and later
+assigning through that reference. For example
$r = do {my @a; \$#a};
$$r = 503
The :unique attribute has had no effect since Perl 5.8.8, and
will be removed in a future release of Perl 5.
+=item av_reify called on tied array
+
+(S debugging) This indicates that something went wrong and Perl got I<very>
+confused about C<@_> or C<@DB::args> being tied.
+
=item Bad arg length for %s, is %u, should be %d
(F) You passed a buffer of the wrong size to one of msgctl(), semctl()
=item Bad free() ignored
(S malloc) An internal routine called free() on something that had never
-been malloc()ed in the first place. Mandatory, but can be disabled by
+been malloc()ed in the first place. Mandatory, but can be disabled by
setting environment variable C<PERL_BADFREE> to 0.
This message can be seen quite often with DB_File on systems with "hard"
of Perl. Check the #! line, or manually feed your script into
Perl yourself.
-=item Bad name after %s::
+=item Bad name after %s
(F) You started to name a symbol by using a package prefix, and then
didn't finish the symbol. In particular, you can't interpolate outside
(W portable) Using bit vector sizes larger than 32 is non-portable.
-=item Bizarre copy of %s in %s
+=item Bizarre copy of %s
(P) Perl detected an attempt to copy an internal value that is not
copiable.
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()
(S io) You tried to apply an encoding that did not exist to a filehandle,
either with open() or binmode().
+=item Cannot set tied @DB::args
+
+(F) C<caller> tried to set C<@DB::args>, but found it tied. Tying C<@DB::args>
+is not supported. (Before this error was added, it used to crash.)
+
+=item Cannot tie unreifiable array
+
+(P) You somehow managed to call C<tie> on an array that does not
+keep a reference count on its arguments and cannot be made to
+do so. Such arrays are not even supposed to be accessible to
+Perl code, but are only used internally.
+
=item Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer. The BER compressed
(F) You may have tried to use C<\p> which means a Unicode
property (for example C<\p{Lu}> matches all uppercase
-letters). If you did mean to use a Unicode property, see
+letters). If you did mean to use a Unicode property, see
L<perluniprops/Properties accessible through \p{} and \P{}>
for a complete list of available properties. If you didn't
-mean to use a Unicode property, escape the C<\p>, either by C<\\p>
-(just the C<\p>) or by C<\Q\p> (the rest of the string, or
+mean to use a Unicode property, escape the C<\p>, either by
+C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, or
until C<\E>).
=item Can't fork: %s
=item Can't locate %s
-(F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be
-found. Perl looks for the file in all the locations mentioned in @INC,
-unless the file name included the full path to the file. Perhaps you
-need to set the PERL5LIB or PERL5OPT environment variable to say where
-the extra library is, or maybe the script needs to add the library name
+(F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be found.
+Perl looks for the file in all the locations mentioned in @INC, unless
+the file name included the full path to the file. Perhaps you need
+to set the PERL5LIB or PERL5OPT environment variable to say where the
+extra library is, or maybe the script needs to add the library name
to @INC. Or maybe you just misspelled the name of the file. See
L<perlfunc/require> and L<lib>.
though, because the inner curlies will be considered a block that loops
once. See L<perlfunc/next>.
+=item Can't open %s
+
+(F) You tried to run a perl built with MAD support with
+the PERL_XMLDUMP environment variable set, but the file
+named by that variable could not be opened.
+
=item Can't open %s: %s
(S inplace) The implicit opening of a file through use of the C<< <> >>
filehandle, either implicitly under the C<-n> or C<-p> command-line
-switches, or explicitly, failed for the indicated reason. Usually this
-is because you don't have read permission for a file which you named on
-the command line.
+switches, or explicitly, failed for the indicated reason. Usually
+this is because you don't have read permission for a file which
+you named on the command line.
+
+(F) You tried to call perl with the B<-e> switch, but F</dev/null> (or
+your operating system's equivalent) could not be opened.
=item Can't open a reference
redirection, and couldn't open the pipe into which to send data destined
for stdout.
-=item Can't open perl script%s
+=item Can't open perl script "%s": %s
(F) The script you specified can't be opened for the indicated reason.
(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried
to reopen it to accept binary data. Alas, it failed.
+=item Can't reset %ENV on this system
+
+(F) You called C<reset('E')> or similar, which tried to reset
+all variables in the current package beginning with "E". In
+the main package, that includes %ENV. Resetting %ENV is not
+supported on some systems, notably VMS.
+
=item Can't resolve method "%s" overloading "%s" in package "%s"
(F)(P) Error resolving overloading specified by a method name (as
specialized, however, that they cannot be interconverted. This message
indicates that such a conversion was attempted.
+=item Can't use '%c' after -mname
+
+(F) You tried to call perl with the B<-m> switch, but you put something
+other than "=" after the module name.
+
=item Can't use anonymous symbol table for method lookup
(F) The internal routine that does method lookup was handed a symbol
=item Can't use string ("%s") as %s ref while "strict refs" in use
-(F) Only hard references are allowed by "strict refs". Symbolic
-references are disallowed. See L<perlref>.
+(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<$>
+in a double-quoted string immediately before interpolating a variable,
+for example in C<"user @$twitter_id">, which says to treat the contents
+of C<$twitter_id> as an array reference; use a C<\> to have a literal C<@>
+symbol followed by the contents of C<$twitter_id>: C<"user \@$twitter_id">.
=item Can't use subscript on %s
written as simply itself, perhaps preceded by a backslash for non-word
characters.
+=item Cloning substitution context is unimplemented
+
+(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 %s: Command not found
-(A) You've accidentally run your script through B<csh> instead of Perl.
-Check the #! line, or manually feed your script into Perl yourself.
+(A) You've accidentally run your script through B<csh> or another shell
+shell instead of Perl. Check the #! line, or manually feed your script
+into Perl yourself. The #! line at the top of your file could look like
+
+ #!/usr/bin/perl -w
=item Compilation failed in require
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
+=item Deep recursion on anonymous subroutine
+
=item Deep recursion on subroutine "%s"
(W recursion) This subroutine has called itself (directly or indirectly)
=item Deprecated use of my() in false conditional
-(D deprecated) You used a declaration similar to C<my $x if 0>.
-There has been a long-standing bug in Perl that causes a lexical variable
+(D deprecated) You used a declaration similar to C<my $x if 0>. There
+has been a long-standing bug in Perl that causes a lexical variable
not to be cleared at scope exit when its declaration includes a false
conditional. Some people have exploited this bug to achieve a kind of
-static variable. Since we intend to fix this bug, we don't want people
+static variable. Since we intend to fix this bug, we don't want people
relying on this behavior. You can achieve a similar static effect by
declaring the variable in a separate block outside the function, eg
{ my $x; sub f { return $x++ } }
-Beginning with perl 5.9.4, you can also use C<state> variables to
-have lexicals that are initialized only once (see L<feature>):
+Beginning with perl 5.9.4, you can also use C<state> variables to have
+lexicals that are initialized only once (see L<feature>):
sub f { state $x; return $x++ }
=item Duplicate modifier '%c' after '%c' in %s
-(W) You have applied the same modifier more than once after a type
-in a pack template. See L<perlfunc/pack>.
+(W unpack) You have applied the same modifier more than once after a
+
type in a pack template. See L<perlfunc/pack>.
=item elseif should be elsif
-(S syntax) There is no keyword "elseif" in Perl because Larry thinks it's
-ugly. Your code will be interpreted as an attempt to call a method named
-"elseif" for the class returned by the following block. This is
+(S syntax) There is no keyword "elseif" in Perl because Larry thinks
+it's ugly. Your code will be interpreted as an attempt to call a method
+named "elseif" for the class returned by the following block. This is
unlikely to be what you want.
=item Empty %s
an invalid file specification to Perl, or you've found a case the
conversion routines don't handle. Drat.
-=item %s: Eval-group in insecure regular expression
+=item Eval-group in insecure regular expression
(F) Perl detected tainted data when trying to compile a regular
expression that contains the C<(?{ ... })> zero-width assertion, which
is unsafe. See L<perlre/(?{ code })>, and L<perlsec>.
-=item %s: Eval-group not allowed at runtime, use re 'eval'
+=item Eval-group not allowed at runtime, use re 'eval' in regex m/%s/
(F) Perl tried to compile a regular expression containing the
C<(?{ ... })> zero-width assertion at run time, as it would when the
interpolated string at run time and using that in an eval(). See
L<perlre/(?{ code })>.
-=item %s: Eval-group not allowed, use re 'eval'
+=item Eval-group not allowed, use re 'eval' in regex m/%s/
(F) A regular expression contained the C<(?{ ... })> zero-width
assertion, but that construct is only allowed when the C<use re 'eval'>
=item Filehandle STDIN reopened as %s only for output
(W io) You opened for writing a filehandle that got the same filehandle id
-as STDIN. This occurred because you closed STDIN previously.
+as STDIN. This occurred because you closed STDIN previously.
=item Final $ should be \$ or $name
=item glob failed (%s)
-(W glob) Something went wrong with the external program(s) used
+(S glob) Something went wrong with the external program(s) used
for C<glob> and C<< <*.c> >>. Usually, this means that you supplied a C<glob>
pattern that caused the external program to fail and exit with a
nonzero status. If the message indicates that the abnormal exit
(F) Unlike with "next" or "last", you're not allowed to goto an
unspecified destination. See L<perlfunc/goto>.
+=item Goto undefined subroutine%s
+
+(F) You tried to call a subroutine with C<goto &sub> syntax, but
+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>.
+
=item %s had compilation errors.
(F) The final summary message when a C<perl -c> fails.
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
-=item Having no space between pattern and following word is deprecated
-
-(D syntax)
-
-You had a word that isn't a regex modifier immediately following
-a pattern without an intervening space. If you are trying to use
-the C</le> flags on a substitution, use C</el> instead. Otherwise, add
-white space between the pattern and following word to eliminate
-the warning. As an example of the latter, the two constructs:
-
-
- $a =~ m/$foo/sand $bar
- $a =~ m/$foo/s and $bar
-
-both currently mean the same thing, but it is planned to disallow
-the first form in Perl 5.18. And,
-
- $a =~ m/$foo/and $bar
-
-will be disallowed too.
-
=item Hexadecimal number > 0xffffffff non-portable
(W portable) The hexadecimal number you specified is larger than 2**32-1
(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 Integer overflow in %s number
-(W overflow) The hexadecimal, octal or binary number you have specified
+(S overflow) The hexadecimal, octal or binary number you have specified
either as a literal or as an argument to hex() or oct() is too big for
your architecture, and has been converted to a floating point number.
On a 32-bit architecture the largest hexadecimal, octal or binary number
internally--subject to loss of precision errors in subsequent
operations.
+=item Integer overflow in srand
+
+(S overflow) The number you have passed to srand is too big to fit
+in your architecture's integer representation. The number has been
+replaced with the largest integer supported (0xFFFFFFFF on 32-bit
+architectures). This means you may be getting less randomness than
+you expect, because different random seeds above the maximum will
+return the same sequence of random numbers.
+
=item Integer overflow in version
-(F) Some portion of a version initialization is too large for the
-size of integers for your architecture. This is not a warning
-because there is no rational reason for a version to try and use a
-element larger than typically 2**32. This is usually caused by
-trying to use some odd mathematical operation as a version, like
-100/9.
+=item Integer overflow in version %d
+
+(W overflow) Some portion of a version initialization is too large for
+the size of integers for your architecture. This is not a warning
+because there is no rational reason for a version to try and use an
+element larger than typically 2**32. This is usually caused by trying
+to use some odd mathematical operation as a version, like 100/9.
=item Internal disaster in regex; marked by <-- HERE in m/%s/
=item Internal urp in regex; marked by <-- HERE in m/%s/
-(P) Something went badly awry in the regular expression parser. The
+(P) Something went badly awry in the regular expression parser. The
<-- HERE shows in the regular expression about where the problem was
discovered.
=item Invalid hexadecimal number in \N{U+...}
+=item Invalid hexadecimal number in \N{U+...} in regex; marked by <-- HERE in m/%s/
+
(F) The character constant represented by C<...> is not a valid hexadecimal
number. Either it is empty, or you tried to use a character other than
0 - 9 or A - F, a - f in a hexadecimal number.
+=item Invalid module name %s with -%c option: contains single ':'
+
+(F) The module argument to perl's B<-m> and B<-M> command-line options
+cannot contain single colons in the module name, but only in the
+arguments after "=". In other words, B<-MFoo::Bar=:baz> is ok, but
+B<-MFoo:Bar=baz> is not.
+
=item Invalid mro name: '%s'
(F) You tried to C<mro::set_mro("classname", "foo")> or C<use mro 'foo'>,
the only valid ones supported are C<dfs> and C<c3>, unless you have loaded
a module that is a MRO plugin. See L<mro> and L<perlmroapi>.
+=item Invalid negative number (%s) in chr
+
+(W utf8) You passed a negative number to C<chr>. Negative numbers are
+not valid characters numbers, so it return the Unicode replacement
+character (U+FFFD).
+
+=item invalid option -D%c, use -D'' to see choices
+
+(S debugging) Perl was called with invalid debugger flags. Call perl
+with the B<-D> option with no flags to see the list of acceptable values.
+See also L<perlrun/B<-D>I<letters>>.
+
=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
(F) The range specified in a character class had a minimum character
=item Invalid strict version format (%s)
-(F) A version number did not meet the "strict" criteria for versions.
+(F) A version number did not meet the "strict" criteria for versions.
A "strict" version number is a positive decimal number (integer or
decimal-fraction) without exponentiation or else a dotted-decimal
v-string with a leading 'v' character and at least three components.
=item Invalid version format (%s)
-(F) A version number did not meet the "lax" criteria for versions.
+(F) A version number did not meet the "lax" criteria for versions.
A "lax" version number is a positive decimal number (integer or
decimal-fraction) without exponentiation or else a dotted-decimal
-v-string. If the v-string has fewer than three components, it must
-have a leading 'v' character. Otherwise, the leading 'v' is optional.
-Both decimal and dotted-decimal versions may have a trailing "alpha"
-component separated by an underscore character after a fractional or
-dotted-decimal component. The parenthesized text indicates which
-criteria were not met. See the L<version> module for more details on
-allowed version formats.
+v-string. If the v-string has fewer than three components, it
+must have a leading 'v' character. Otherwise, the leading 'v' is
+optional. Both decimal and dotted-decimal versions may have a
+trailing "alpha" component separated by an underscore character
+after a fractional or dotted-decimal component. The parenthesized
+text indicates which criteria were not met. See the L<version> module
+for more details on allowed version formats.
=item Invalid version object
-(F) The internal structure of the version object was invalid. Perhaps
-the internals were modified directly in some way or an arbitrary reference
-was blessed into the "version" class.
+(F) The internal structure of the version object was invalid.
+Perhaps the internals were modified directly in some way or
+an arbitrary reference was blessed into the "version" class.
=item ioctl is not implemented
(W overload) You tried to overload a constant type the overload package is
unaware of.
-=item junk on end of regexp
+=item Junk on end of regexp in regex m/%s/
(P) The regular expression parser is confused.
to check the return value of your socket() call? See
L<perlfunc/listen>.
+=item List form of piped open not implemented
+
+(F) On some platforms, notably Windows, the three-or-more-arguments
+form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>.
+Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead.
+
=item localtime(%f) too large
(W overflow) You called C<localtime> with a number that was larger
=item Lost precision when %s %f by 1
-(W) The value you attempted to increment or decrement by one is too large
-for the underlying floating point representation to store accurately,
-hence the target of C<++> or C<--> is unchanged. Perl issues this warning
-because it has already switched from integers to floating point when values
-are too large for integers, and now even floating point is insufficient.
-You may wish to switch to using L<Math::BigInt> explicitly.
+(W imprecision) The value you attempted to increment or decrement by one
+is too large for the underlying floating point representation to store
+accurately, hence the target of C<++> or C<--> is unchanged. Perl issues this
+warning because it has already switched from integers to floating point
+when values are too large for integers, and now even floating point is
+insufficient. You may wish to switch to using L<Math::BigInt> explicitly.
-=item lstat() on filehandle %s
+=item lstat() on filehandle%s
(W io) You tried to do an lstat on a filehandle. What did you mean
by that? lstat() makes sense only on filenames. (Perl did a fstat()
instead on the filehandle.)
-=item lvalue attribute cannot be removed after the subroutine has been defined
+=item lvalue attribute %s already-defined subroutine
-(W misc) The lvalue attribute on a Perl subroutine cannot be turned off
-once the subroutine is defined.
+(W misc) Although L<attributes.pm|attributes> allows this, turning the lvalue
+attribute on or off on a Perl subroutine that is already defined
+does not always work properly. It may or may not do what you
+want, depending on what code is inside the subroutine, with exact
+details subject to change between Perl versions. Only do this
+if you really know what you are doing.
=item lvalue attribute ignored after the subroutine has been defined
-(W misc) Making a Perl subroutine an lvalue subroutine after it has been
-defined, whether by declaring the subroutine with an lvalue attribute
-or by using L<attributes.pm|attributes>, is not possible. To make the subroutine an
-lvalue subroutine, add the lvalue attribute to the definition, or put
-the declaration before the definition.
+(W misc) Using the C<:lvalue> declarative syntax to make a Perl
+subroutine an lvalue subroutine after it has been defined is
+not permitted. To make the subroutine an lvalue subroutine,
+add the lvalue attribute to the definition, or put the C<sub
+foo :lvalue;> declaration before the definition.
+
+See also L<attributes.pm|attributes>.
=item Malformed integer in [] in pack
=item Malformed UTF-8 character (%s)
-(S utf8) (F) Perl detected a string that didn't comply with UTF-8
+(S utf8)(F) Perl detected a string that didn't comply with UTF-8
encoding rules, even though it had the UTF8 flag on.
One possible cause is that you set the UTF8 flag yourself for data that
interpreter, especially if the word that is being warned about is
"use" or "my".
-=item % may not be used in pack
+=item '%' may not be used in pack
(F) You can't pack a string by supplying a checksum, because the
checksumming process loses information, and you can't go the other way.
=item Missing braces on \N{}
+=item Missing braces on \N{} in regex; marked by <-- HERE in m/%s/
+
(F) Wrong syntax of character name literal C<\N{charname}> within
double-quotish context. This can also happen when there is a space
(or comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
(S syntax) This is an educated guess made in conjunction with the message
"%s found where operator expected". Often the missing operator is a comma.
-=item Missing right brace on %s
+=item Missing right brace on \%c{} in regex; marked by <-- HERE in m/%s/
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
The traditional one has it followed by a name enclosed in braces,
meaning the character (or sequence of characters) given by that
-name. Thus C<\N{ASTERISK}> is another way of writing C<*>, valid in both
+name. Thus C<\N{ASTERISK}> is another way of writing C<*>, valid in both
double-quoted strings and regular expression patterns. In patterns,
it doesn't have the meaning an unescaped C<*> does.
the same; if a program uses $c only once but also uses any of the others it
will not trigger this warning.
-=item \N in a character class must be a named character: \N{...}
+=item \N in a character class must be a named character: \N{...} in regex; marked by <-- HERE in m/%s/
(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed
character class, for the same reason that C<.> in a character class loses
its specialness: it matches almost everything, which is probably not
what you want.
-=item \N{NAME} must be resolved by the lexer
+=item \N{NAME} must be resolved by the lexer in regex; marked by <-- HERE in m/%s/
(F) When compiling a regex pattern, an unresolved named character or
sequence was encountered. This can happen in any of several ways that
will be another way to do what you want that is, if not secure, at least
securable. See L<perlsec>.
+=item No code specified for -%c
+
+(F) Perl's B<-e> and B<-E> command-line options require an argument. If
+you want to run an empty program, pass the empty string as a separate
+argument or run a program consisting of a single 0 or 1:
+
+ perl -e ""
+ perl -e0
+ perl -e1
+
=item No comma allowed after %s
(F) A list operator that has a filehandle or "indirect object" is
module) didn't define a C<DB::sub> routine to be called at the beginning
of each ordinary subroutine call.
+=item No directory specified for -I
+
+(F) The B<-I> command-line switch requires a directory name as part of the
+I<same> argument. Use B<-Ilib>, for instance. B<-I lib> won't work.
+
=item No error file after 2> or 2>> on command line
(F) An error peculiar to VMS. Perl handles its own command line
(F) C<next::method> found no further instances of this method name
in the remaining packages of the MRO of this class. If you don't want
it throwing an exception, use C<maybe::next::method>
-or C<next::can>. See L<mro>.
+or C<next::can>. See L<mro>.
=item "no" not allowed in expression
(F) Configure didn't find anything resembling the setreuid() call for
your system.
-=item No %s specified for -%c
-
-(F) The indicated command line switch needs a mandatory argument, but
-you haven't specified one.
-
=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
use the ref() function to find out what kind of ref it really was. See
also L<perlref>.
-=item Not a format reference
-
-(F) I'm not sure how you managed to generate a reference to an anonymous
-format, but this indicates you did, and that it didn't exist.
-
=item Not a GLOB reference
(F) Perl was trying to evaluate a reference to a "typeglob" (that is, a
=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.
+(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
a number. This happens, for example with C<\o{}>, with no number between
the braces.
-=item Octal number in vector unsupported
-
-(F) Numbers with a leading C<0> are not currently allowed in vectors.
-The octal number interpretation of such numbers may be supported in a
-future version.
-
=item Octal number > 037777777777 non-portable
(W portable) The octal number you specified is larger than 2**32-1
=item Opening dirhandle %s also as a file
-(W io, deprecated) You used open() to associate a filehandle to
+(D io, deprecated) You used open() to associate a filehandle to
a symbol (glob or scalar) that already holds a dirhandle.
Although legal, this idiom might render your code confusing
and is deprecated.
=item Opening filehandle %s also as a directory
-(W io, deprecated) You used opendir() to associate a dirhandle to
+(D io, deprecated) You used opendir() to associate a dirhandle to
a symbol (glob or scalar) that already holds a filehandle.
Although legal, this idiom might render your code confusing
and is deprecated.
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(W utf8, non_unicode) You performed an operation requiring Unicode
+(S utf8, non_unicode) You performed an operation requiring Unicode
semantics on a code point that is not in Unicode, so what it should do
is not defined. Perl has chosen to have it do nothing, and warn you.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(W utf8, surrogate) You performed an operation requiring Unicode
+(S utf8, surrogate) You performed an operation requiring Unicode
semantics on a Unicode surrogate. Unicode frowns upon the use of
surrogates for anything but storing strings in UTF-16, but semantics
are (reluctantly) defined for the surrogates, and they are to do
(F) You had a template that specified an absolute position outside
the string being unpacked. The string being unpacked was also invalid
-UTF-8. See L<perlfunc/pack>.
+UTF-8. See L<perlfunc/pack>.
+
+=item overload arg '%s' is invalid
+
+(W overload) The L<overload> pragma was passed an argument it did not
+recognize. Did you mistype an operator?
=item Overloaded dereference did not return a reference
platform. Earlier checks mean that it should not be possible to
enter this branch on this platform.
-=item panic: ck_grep
+=item panic: ck_grep, type=%u
(P) Failed an internal consistency check trying to compile a grep.
-=item panic: ck_split
+=item panic: ck_split, type=%u
(P) Failed an internal consistency check trying to compile a split.
-=item panic: corrupt saved stack index
+=item panic: corrupt saved stack index %ld
(P) The savestack was requested to restore more localized values than
there are in the savestack.
(P) The library function frexp() failed, making printf("%f") impossible.
-=item panic: goto
+=item panic: goto, type=%u, ix=%ld
(P) We popped the context stack to a context with the specified label,
and then discovered it wasn't a context we know how to do a goto in.
Most likely the glob contains an object with a reference back to
the glob and a destructor that adds a new object to the glob.
-=item panic: INTERPCASEMOD
+=item panic: INTERPCASEMOD, %s
(P) The lexer got into a bad state at a case modifier.
-=item panic: INTERPCONCAT
+=item panic: INTERPCONCAT, %s
(P) The lexer got into a bad state parsing a string with brackets.
(F) forked child returned an incomprehensible message about its errno.
-=item panic: last
+=item panic: last, type=%u
(P) We popped the context stack to a block context, and then discovered
it wasn't a block context.
(P) A writable lexical variable became read-only somehow within the
scope.
-=item panic: leave_scope inconsistency
+=item panic: leave_scope inconsistency %u
(P) The savestack probably got out of sync. At least, there was an
invalid enum on the top of it.
(P) Failed an internal consistency check while trying to reset all weak
references to an object.
-=item panic: malloc
+=item panic: malloc, %s
(P) Something requested a negative number of bytes of malloc.
(P) Something tried to allocate more memory than possible.
-=item panic: pad_alloc
+=item panic: pad_alloc, %p!=%p
(P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
-=item panic: pad_free curpad
+=item panic: pad_free curpad, %p!=%p
(P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
(P) An invalid scratch pad offset was detected internally.
-=item panic: pad_reset curpad
+=item panic: pad_reset curpad, %p!=%p
(P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
(P) An invalid scratch pad offset was detected internally.
-=item panic: pad_swipe curpad
+=item panic: pad_swipe curpad, %p!=%p
(P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
(P) An invalid scratch pad offset was detected internally.
-=item panic: pp_iter
+=item panic: pp_iter, type=%u
(P) The foreach iterator got called in a non-loop context frame.
(P) The internal pp_match() routine was called with invalid operational
data.
-=item panic: pp_split
+=item panic: pp_split, pm=%p, s=%p
(P) Something terrible went wrong in setting up for the split.
-=item panic: realloc
+=item panic: realloc, %s
(P) Something requested a negative number of bytes of realloc.
(P) The internal sv_replace() function was handed a new SV with a
reference count other than 1.
-=item panic: restartop
+=item panic: restartop in %s
(P) Some internal routine requested a goto (or something like it), and
didn't supply the destination.
-=item panic: return
+=item panic: return, type=%u
(P) We popped the context stack to a subroutine or eval context, and
then discovered it wasn't a subroutine or eval context.
-=item panic: scan_num
+=item panic: scan_num, %s
(P) scan_num() got called on something that wasn't a number.
+=item panic: Sequence (?{...}): no code block found
+
+(P) while compiling a pattern that has embedded (?{}) or (??{}) code
+blocks, perl couldn't locate the code block that should have already been
+seen and compiled by perl before control passed to the regex compiler.
+
=item panic: sv_chop %s
(P) The sv_chop() routine was passed a position that is not within the
scalar's string buffer.
-=item panic: sv_insert
+=item panic: sv_insert, midend=%p, bigend=%p
(P) The sv_insert() routine was told to remove more string than there
was string.
(P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed
to even) byte length.
-=item panic: yylex
+=item panic: yylex, %s
(P) The lexer got into a bad state while processing a case modifier.
conversion functions. This is only a problem when you're using the
'<' or '>' modifiers in (un)pack templates. See L<perlfunc/pack>.
+=item Perl %s required (did you mean %s?)--this is only %s, stopped
+
+(F) The code you are trying to run has asked for a newer version of
+Perl than you are running. Perhaps C<use 5.10> was written instead
+of C<use 5.010> or C<use v5.10>. Without the leading C<v>, the number is
+interpreted as a decimal, with every three digits after the
+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
(F) The module in question uses features of a version of Perl more
=item PERL_SH_DIR too long
-(F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
+(F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
C<sh>-shell in. See "PERL_SH_DIR" in L<perlos2>.
=item PERL_SIGNALS illegal: "%s"
-See L<perlrun/PERL_SIGNALS> for legal values.
+(X) See L<perlrun/PERL_SIGNALS> for legal values.
+
+=item Perls since %s too modern--this is %s, stopped
+
+(F) The code you are trying to run claims it will not run
+on the version of Perl you are using because it is too new.
+Maybe the code needs to be updated, or maybe it is simply
+wrong and the version check should just be removed.
=item perl: warning: Setting locale failed.
=item Prototype after '%c' for %s : %s
-(W illegalproto) A character follows % or @ in a prototype. This is useless,
-since % and @ gobble the rest of the subroutine arguments.
+(W illegalproto) A character follows % or @ in a prototype. This is
+useless, since % and @ gobble the rest of the subroutine arguments.
=item Prototype mismatch: %s vs %s
the desired output is compiled into Perl, which entails some overhead,
which is why it's currently left out of your copy.
+=item Recursive call to Perl_load_module in PerlIO_find_layer
+
+(P) It is currently not permitted to load modules when creating
+a filehandle inside an %INC hook. This can happen with C<open my
+$fh, '<', \$scalar>, which implicitly loads PerlIO::scalar. Try
+loading PerlIO::scalar explicitly first.
+
=item Recursive inheritance detected in package '%s'
(F) While calculating the method resolution order (MRO) of a package, Perl
=item refcnt_inc: fd %d%s
-(P) Perl's I/O implementation failed an internal consistency check. If
+(P) Perl's I/O implementation failed an internal consistency check. If
you see this message, something is very wrong.
=item Reference found where even-sized list expected
(W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
-=item Reference to invalid group 0
+=item Reference to invalid group 0 in regex; marked by <-- HERE in m/%s/
(F) You used C<\g0> or similar in a regular expression. You may refer
to capturing parentheses only with strictly positive integers
(F syntax, regexp) The regular expression pattern had too many occurrences
of the specified modifier. Remove the extraneous ones.
-=item Regexp modifier "%c" may not appear after the "-"
+=item Regexp modifier "%c" may not appear after the "-" in regex; marked by <-- HERE in m/%s/
-(F regexp) Turning off the given modifier has the side effect of turning
-on another one. Perl currently doesn't allow this. Reword the regular
+(F) Turning off the given modifier has the side effect of turning on
+another one. Perl currently doesn't allow this. Reword the regular
expression to use the modifier you want to turn on (and place it before
the minus), instead of the one you want to turn off.
mutually exclusive modifiers. Retain only the modifier that is
supposed to be there.
-=item Regexp out of space
+=item Regexp out of space in regex m/%s/
(P) A "can't happen" error, because safemalloc() should have caught it
earlier.
=item Replacement list is longer than search list
(W misc) You have used a replacement list that is longer than the
-search list. So the additional elements in the replacement list
+search list. So the additional elements in the replacement list
are meaningless.
=item Reversed %s= operator
=item Scalars leaked: %d
-(P) Something went wrong in Perl's internal bookkeeping of scalars:
-not all scalar variables were deallocated by the time Perl exited.
-What this usually indicates is a memory leak, which is of course bad,
-especially if the Perl program is intended to be long-running.
+(W internal) Something went wrong in Perl's internal bookkeeping
+of scalars: not all scalar variables were deallocated by the time
+Perl exited. What this usually indicates is a memory leak, which
+is of course bad, especially if the Perl program is intended to be
+long-running.
=item Scalar value @%s[%s] better written as $%s[%s]
(F) The regular expression expects a mandatory argument following the escape
sequence and this has been omitted or incorrectly written.
-=item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/
+=item Sequence (?#... not terminated in regex m/%s/
(F) A regular expression comment must be terminated by a closing
-parenthesis. Embedded parentheses aren't allowed. The <-- HERE shows in
-the regular expression about where the problem was discovered. See
+parenthesis. Embedded parentheses aren't allowed. See
L<perlre>.
-=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
+=item Sequence (?{...}) not terminated with ')'
-(F) If the contents of a (?{...}) clause contain braces, they
-must balance for Perl to detect the end of the clause properly.
-The <-- HERE shows in the regular expression about where the
-problem was discovered. See L<perlre>.
+(F) The end of the perl code contained within the {...} must be
+followed immediately by a ')'.
=item Z<>500 Server error
=item splice() offset past end of array
(W misc) You attempted to specify an offset that was past the end of
-the array passed to splice(). Splicing will instead commence at the end
-of the array, rather than past it. If this isn't what you want, try
-explicitly pre-extending the array by assigning $#array = $offset. See
-L<perlfunc/splice>.
+the array passed to splice(). Splicing will instead commence at the
+end of the array, rather than past it. If this isn't what you want,
+try explicitly pre-extending the array by assigning $#array = $offset.
=item Split loop
=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 both to
-contain alternation, such as using C<this|that|other>, enclose it in
-clustering parentheses:
+(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
+both to contain alternation, such as using C<this|that|other>, enclose
+it in clustering parentheses:
(?(condition)(?:this|that|other)|else-clause)
-The <-- HERE shows in the regular expression about where the problem was
-discovered. See L<perlre>.
+The <-- HERE shows in the regular expression about where 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
+a number, it can be only a number. The <-- HERE shows in the regular
expression about where the problem was discovered. See L<perlre>.
=item switching effective %s is not implemented
(F) Your machine doesn't implement the umask function and you tried to
use it to restrict permissions for yourself (EXPR & 0700).
-=item Unable to create sub named "%s"
-
-(F) You attempted to create or access a subroutine with an illegal name.
-
=item Unbalanced context: %d more PUSHes than POPs
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many execution contexts were entered and left.
=item Unbalanced saves: %d more saves than restores
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many values were temporarily localized.
=item Unbalanced scopes: %d more ENTERs than LEAVEs
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many blocks were entered and left.
+=item Unbalanced string table refcount: (%d) for "%s"
+
+(W internal) On exit, Perl found some strings remaining in the shared
+string table used for copy on write and for hash keys. The entries
+should have been freed, so this indicates a bug somewhere.
+
=item Unbalanced tmps: %d more allocs than frees
-(W internal) The exit code detected an internal inconsistency in how
+(S internal) The exit code detected an internal inconsistency in how
many mortal scalars were allocated and freed.
=item Undefined format "%s" called
(A) You've accidentally run your script through B<csh> instead of Perl.
Check the #! line, or manually feed your script into Perl yourself.
+=item Unescaped left brace in regex is deprecated, passed through
+
+(D) You used a literal C<"{"> character in a regular expression pattern.
+You should change to use C<"\{"> instead, because a future version of
+Perl (tentatively v5.20) will consider this to be a syntax error. If
+the pattern delimiters are also braces, any matching right brace
+(C<"}">) should also be escaped to avoid confusing the parser, for
+example,
+
+ qr{abc\{def\}ghi}
+
=item unexec of %s into %s failed!
(F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
+=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 Unicode non-character U+%X is illegal for open interchange
-(W utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
+(S utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
defined by the Unicode standard to be non-characters. Those are
legal codepoints, but are reserved for internal use; so, applications
shouldn't attempt to exchange them. If you know what you are doing
(F) There are no byte-swapping functions for a machine with this byte
order.
+=item Unknown error
+
+(P) Perl was about to print an error message in C<$@>, but the C<$@> variable
+did not exist, even after an attempt to create it.
+
=item Unknown open() mode '%s'
(F) The second argument of 3-argument open() is not among the list
(W) You tried to use an unknown subpragma of the "re" pragma.
+=item Unknown regex modifier "%s"
+
+(F) Alphanumerics immediately following the closing delimiter
+of a regular expression pattern are interpreted by Perl as modifier
+flags for the regex. One of the ones you specified is invalid. One way
+this can happen is if you didn't put in white space between the end of
+the regex and a following alphanumeric operator:
+
+ if ($a =~ /foo/and $bar == 3) { ... }
+
+The C<"a"> is a valid modifier flag, but the C<"n"> is not, and raises
+this error. Likely what was meant instead was:
+
+ if ($a =~ /foo/ and $bar == 3) { ... }
+
=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
module (e.g. C<use warnings 'File::Find'>), you must have loaded this
module first.
-=item unmatched [ in regex; marked by <-- HERE in m/%s/
+=item Unmatched [ in regex; marked by <-- HERE in m/%s/
(F) The brackets around a character class must match. If you wish to
include a closing bracket in a character class, backslash it or put it
first. The <-- HERE shows in the regular expression about where the
problem was discovered. See L<perlre>.
-=item unmatched ( in regex; marked by <-- HERE in m/%s/
+=item Unmatched ( in regex; marked by <-- HERE in m/%s/
+
+=item Unmatched ) in regex; marked by <-- HERE in m/%s/
(F) Unbackslashed parentheses must always be balanced in regular
expressions. If you're a vi user, the % key is valuable for finding
=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.
+a regular expression. Fix the pattern and retry.
=item Unterminated <> operator
same length as the replacelist. See L<perlop> for more information
about the /d modifier.
+=item Useless use of \E
+
+(W misc) You have a \E in a double-quotish string without a C<\U>,
+C<\L> or C<\Q> preceding it.
+
=item Useless use of %s in void context
(W void) You did something without a side effect in a context that does
=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 happens to hold a typeglob, which means its filehandle will
-be tied. If you mean to tie a handle, use an explicit * as in
-C<tie *$handle>.
+(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that scalar
+happens to hold a typeglob, which means its filehandle will be tied. If
+you mean to tie a handle, use an explicit * as in C<tie *$handle>.
-This is a long-standing bug that will be removed in Perl 5.16, as
-there is currently no way to tie the scalar itself when it holds
-a typeglob, and no way to untie a scalar that has had a typeglob
-assigned to it.
+This was a long-standing bug that was removed in Perl 5.16, as there was
+no way to tie the scalar itself when it held a typeglob, and no way to
+untie a scalar that had had a typeglob assigned to it. If you see this
+message, you must be using an older version.
=item Use of ?PATTERN? without explicit operator is deprecated
instead, explicitly using the C<m> operator: the question mark delimiter
still invokes match-once behaviour.
-=item Use of qw(...) as parentheses is deprecated
-
-(D deprecated) You have something like C<foreach $x qw(a b c) {...}>,
-using a C<qw(...)> list literal where a parenthesised expression is
-expected. Historically the parser fooled itself into thinking that
-C<qw(...)> literals were always enclosed in parentheses, and as a result
-you could sometimes omit parentheses around them. (You could never do
-the C<foreach qw(a b c) {...}> that you might have expected, though.)
-The parser no longer lies to itself in this way. Wrap the list literal
-in parentheses, like C<foreach $x (qw(a b c)) {...}>.
-
=item Use of reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
=item UTF-16 surrogate U+%X
-(W utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
not considered acceptable. These code points, between U+D800 and
U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl
internally allows all unsigned integer code points (up to the size limit
=item Variable "%s" is not imported%s
-(W misc) With "use strict" in effect, you referred to a global variable
+(S misc) With "use strict" in effect, you referred to a global variable
that you apparently thought was imported from another module, because
something else of the same name (usually a subroutine) is exported by
that module. It usually means you put the wrong funny character on the
front of your variable.
-=item Variable length lookbehind not implemented in m/%s/
+=item Variable length lookbehind not implemented in regex m/%s/
(F) Lookbehind is allowed only for subexpressions whose length is fixed and
known at compile time. See L<perlre>.
reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.
+=item vector argument not supported with alpha versions
+
+(W internal) 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/
(F) You used a verb pattern that requires an argument. Supply an
=item Within []-length '%c' not allowed
-(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
-C<TEMPLATE> always matches the same amount of packed bytes that can be
-determined from the template alone. This is not possible if it contains any
-of the codes @, /, U, u, w or a *-length. Redesign the template.
+(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]>
+only if C<TEMPLATE> always matches the same amount of packed bytes that
+can be determined from the template alone. This is not possible if
+it contains any of the codes @, /, U, u, w or a *-length. Redesign
+the template.
=item write() on closed filehandle %s
https://perl5.git.perl.org / perl5.git / blobdiff