(X) You can't allocate more than 64K on an MS-DOS machine.
-=item '!' allowed only after types %s
+=item '%c' allowed only after types %s
-(F) The '!' is allowed in pack() or unpack() only after certain types.
-See L<perlfunc/pack>.
+(F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only
+
after certain types. See L<perlfunc/pack>.
=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
that expected a numeric value instead. If you're fortunate the message
will identify which operator was so unfortunate.
+=item Argument list not closed for PerlIO layer "%s"
+
+(W layer) When pushing a layer with arguments onto the Perl I/O system you
+forgot the ) that closes the argument list. (Layers take care of transforming
+data between external and internal representations.) Perl stopped parsing
+the layer list at this point and did not attempt to push this layer.
+If your program didn't explicitly request the failing operation, it may be
+the result of the value of the environment variable PERLIO.
+
=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 thread exited while %d threads were running
-(W) When using threaded Perl, a thread (not necessarily the main
+(W threads)(S) When using threaded Perl, a thread (not necessarily the main
thread) exited while there were still other threads running.
Usually it's a good idea to first collect the return values of the
created threads by joining them, and only then exit from the main
literals or global values as arguments to the "p" pack() template to
avoid this warning.
+=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
+
+ $r = do {my @a; \$#a};
+ $$r = 503
+
=item Attempt to use reference as lvalue in substr
(W substr) You supplied a reference as the first argument to substr()
(P) An internal request asked to add an array entry to something that
wasn't a symbol table entry.
+=item Bad symbol for dirhandle
+
+(P) An internal request asked to add a dirhandle entry to something
+that wasn't a symbol table entry.
+
+
=item Bad symbol for filehandle
(P) An internal request asked to add a filehandle entry to something
(F) An argument to pack("w",...) was negative. The BER compressed integer
format can only be used with positive integers. See L<perlfunc/pack>.
+=item Cannot convert a reference to %s to typeglob
+
+(F) You manipulated Perl's symbol table directly, stored a reference in it,
+then tried to access that symbol via conventional Perl syntax. The access
+triggers Perl to autovivify that typeglob, but it there is no legal conversion
+from that type of reference to a typeglob.
+
=item Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer. The BER compressed
(F) Only hard references may be blessed. This is how Perl "enforces"
encapsulation of objects. See L<perlobj>.
+=item Can't "break" in a loop topicalizer
+
+(F) You called C<break>, but you're in a C<foreach> block rather than
+a C<given> block. You probably meant to use C<next> or C<last>.
+
+=item Can't "break" outside a given block
+
+(F) You called C<break>, but you're not inside a C<given> block.
+
=item Can't call method "%s" in empty package "%s"
(F) You called a method correctly, and it correctly indicated a package
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are.
+=item Can't "continue" outside a when block
+
+(F) You called C<continue>, but you're not inside a C<when>
+or C<default> block.
+
=item Can't create pipe mailbox
(P) An error peculiar to VMS. The process is suffering from exhausted
point. For example, it'd be kind of silly to put a B<-x> on the #!
line.
+=item Can't %s %s-endian %ss on this platform
+
+(F) Your platform's byte-order is neither big-endian nor little-endian,
+or it has a very strange pointer size. Packing and unpacking big- or
+little-endian floating point values and pointers may not be possible.
+See L<perlfunc/pack>.
+
=item Can't exec "%s": %s
(W exec) A system(), exec(), or piped open call could not execute the
found in the PATH, or at least not with the correct permissions. The
script exists in the current directory, but PATH prohibits running it.
-=item Can't find %s property definition %s
-
-(F) You may have tried to use C<\p> which means a Unicode property (for
-example C<\p{Lu}> is all uppercase letters). If you did mean to use a
-Unicode property, see L<perlunicode> for the list of known 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, until
-possible C<\E>).
-
=item Can't find string terminator %s anywhere before EOF
(F) Perl strings can stretch over multiple lines. This message means
unseen whitespace before or after your closing tag. A good programmer's
editor will have a way to help you find these characters.
+=item Can't find Unicode property definition "%s"
+
+(F) You may have tried to use C<\p> which means a Unicode property (for
+example C<\p{Lu}> is all uppercase letters). If you did mean to use a
+Unicode property, see L<perlunicode> for the list of known 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, until
+possible C<\E>).
+
=item Can't fork
(F) A fatal error occurred while trying to fork while opening a
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-string
+=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". (You can use it to jump out of an eval {BLOCK}, but you
-probably don't want to.)
+"string" or block.
=item Can't goto subroutine outside a subroutine
inner curlies will be considered a block that loops once. See
L<perlfunc/last>.
+=item Can't load '%s' for module %s
+
+(F) The module you tried to load failed to load a dynamic extension. This
+may either mean that you upgraded your version of perl to one that is
+incompatible with your old dynamic extensions (which is known to happen
+between major versions of perl), or (more likely) that your dynamic
+extension was built against an older version of the library that is
+installed on your system. You may need to rebuild your old dynamic
+extensions.
+
=item Can't localize lexical variable %s
(F) You used local on a variable name that was previously declared as a
are a misprint in a function/method name or a failure to C<AutoSplit>
the file, say, by doing C<make install>.
+=item Can't locate loadable object for module %s in @INC
+
+(F) The module you loaded is trying to load an external library, like
+for example, C<foo.so> or C<bar.dll>, but the L<DynaLoader> module was
+unable to locate this library. See L<DynaLoader>.
+
=item Can't locate object method "%s" via package "%s"
(F) You called a method correctly, and it correctly indicated a package
redirection, and couldn't open the pipe into which to send data destined
for stdout.
-=item Can't open perl script%s: %s
+=item Can't open perl script%s
(F) The script you specified can't be opened for the indicated reason.
-=item Can't provide tied hash usage; use keys(%hash) to test if empty
-
-(F) When a hash is evaluated in scalar context, bucket usage is
-returned if the hash is populated, and false is returned if the hash
-is empty. Bucket usage is not currently available for tied hashes.
-To test if a hash is empty or populated, use keys(%hash) in scalar
-context instead.
+If you're debugging a script that uses #!, and normally relies on the
+shell's $PATH search, the -S option causes perl to do that search, so
+you don't have to type the path or C<`which $scriptname`>.
=item Can't read CRTL environ
or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
searched.
-=item Can't redefine active sort subroutine %s
-
-(F) Perl optimizes the internal handling of sort subroutines and keeps
-pointers into them. You tried to redefine one such sort subroutine when
-it was currently active, which is not allowed. If you really want to do
-this, you should write C<sort { &func } @x> instead of C<sort func @x>.
-
=item Can't "redo" outside a loop block
(F) A "redo" statement was executed to restart the current block, but
(F) You tried to unshift an "unreal" array that can't be unshifted, such
as the main Perl stack.
-=item Can't upgrade that kind of scalar
+=item Can't upgrade %s (%d) to %d
(P) The internal sv_upgrade routine adds "members" to an SV, making it
into a more specialized kind of SV. The top several SV types are so
specialized, however, that they cannot be interconverted. This message
indicates that such a conversion was attempted.
-=item Can't upgrade to undef
-
-(P) The undefined SV is the bottom of the totem pole, in the scheme of
-upgradability. Upgrading to undef indicates an error in the code
-calling sv_upgrade.
-
=item Can't use anonymous symbol table for method lookup
(F) The internal routine that does method lookup was handed a symbol
Errno.pm module. The Errno module is expected to tie the %! hash to
provide symbolic names for C<$!> errno values.
+=item Can't use both '<' and '>' after type '%c' in %s
+
+(F) A type cannot be forced to have both big-endian and little-endian
+byte-order at the same time, so this combination of modifiers is not
+allowed. See L<perlfunc/pack>.
+
=item Can't use %s for loop variable
(F) Only a simple scalar variable may be used as a loop variable on a
have variables in your program that looked like magical variables but
weren't.
+=item Can't use '%c' in a group with different byte-order in %s
+
+(F) You attempted to force a different byte-order on a type
+that is already inside a group with a byte-order modifier.
+For example you cannot force little-endianness on a type that
+is inside a big-endian group.
+
=item Can't use "my %s" in sort comparison
(F) The global variables $a and $b are reserved for sort comparisons.
(F) The compiler tried to interpret a bracketed expression as a
subscript. But to the left of the brackets was an expression that
-didn't look like an array reference, or anything else subscriptable.
+didn't look like a hash or array reference, or anything else subscriptable.
=item Can't use \%c to mean $%c in expression
value that prints out looking like SCALAR(0xdecaf). Use the $1 form
instead.
+=item Can't use "when" outside a topicalizer
+
+(F) You have used a when() block that is neither inside a C<foreach>
+loop nor a C<given> block. (Note that this error is issued on exit
+from the C<when> block, so you won't get the error if the match fails,
+or if you use an explicit C<continue>.)
+
=item Can't weaken a nonreference
(F) You attempted to weaken something that was not a reference. Only
with an assignment operator, which implies modifying the value itself.
Perhaps you need to copy the value to a temporary, and repeat that.
-=item Character in "C" format wrapped in pack
+=item Character in 'C' format wrapped in pack
(W pack) You said
If you actually want to pack Unicode codepoints, use the C<"U"> format
instead.
-=item Character in "c" format wrapped in pack
+=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
If you actually want to pack Unicode codepoints, use the C<"U"> format
instead.
+=item Character in '%c' format wrapped in unpack
+
+(W unpack) You tried something like
+
+ unpack("H", "\x{2a1}")
+
+where the format expects to process a byte (a character with a value
+below 256), but a higher value was provided instead. Perl uses the value
+modulus 256 instead, as if you had provided:
+
+ unpack("H", "\x{a1}")
+
+=item Character(s) in '%c' format wrapped in pack
+
+(W pack) You tried something like
+
+ pack("u", "\x{1f3}b")
+
+where the format expects to process a sequence of bytes (character with a
+value below 256), but some of the characters had a higher value. Perl
+uses the character values modulus 256 instead, as if you had provided:
+
+ pack("u", "\x{f3}b")
+
+=item Character(s) in '%c' format wrapped in unpack
+
+(W unpack) You tried something like
+
+ unpack("s", "\x{1f3}b")
+
+where the format expects to process a sequence of bytes (character with a
+value below 256), but some of the characters had a higher value. Perl
+uses the character values modulus 256 instead, as if you had provided:
+
+ unpack("s", "\x{f3}b")
+
=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 Code missing after '/'
(F) You had a (sub-)template that ends with a '/'. There must be another
corresponding C<overload> or C<charnames> pragma? See L<charnames> and
L<overload>.
+=item Constant(%s)%s: %s in regex; marked by <-- HERE in m/%s/
+
+(F) The parser found inconsistencies while attempting to find
+the character name specified in the C<\N{...}> escape. Perhaps you
+forgot to load the corresponding C<charnames> pragma?
+See L<charnames>.
+
+
=item Constant is not %s reference
(F) A constant value (perhaps declared using the C<use constant> pragma)
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
+=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
+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
+relying on this behavior. You can achieve a similar static effect by
+declaring the variable in a separate block outside the function, eg
+
+ sub f { my $x if 0; return $x++ }
+
+becomes
+
+ { 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>):
+
+ sub f { state $x; return $x++ }
+
+=item DESTROY created new reference to dead object '%s'
+
+(F) A DESTROY() method created a new reference to the object which is
+just being DESTROYed. Perl is confused, and prefers to abort rather than
+to create a dangling reference.
+
=item Did not produce a valid header
See Server error.
=item (Do you need to predeclare %s?)
-(S) This is an educated guess made in conjunction with the message "%s
-found where operator expected". It often means a subroutine or module
+(S syntax) This is an educated guess made in conjunction with the message
+"%s found where operator expected". It often means a subroutine or module
name is being referenced that hasn't been declared yet. This may be
because of ordering problems in your file, or because of a missing
"sub", "package", "require", or "use" statement. If you're referencing
(W misc) You used the obsolescent C<dump()> built-in function, without fully
qualifying it as C<CORE::dump()>. Maybe it's a typo. See L<perlfunc/dump>.
+=item dump is not supported
+
+(F) Your machine doesn't support dump/undump.
+
=item Duplicate free() ignored
(S malloc) An internal routine called free() on something that had
already been freed.
+=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>.
+
=item elseif should be elsif
-(S) 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
+(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.
(F) While under the C<use filetest> pragma, switching the real and
effective uids or gids failed.
+=item %ENV is aliased to %s
+
+(F) You're running under taint mode, and the C<%ENV> variable has been
+aliased to another hash, so it doesn't reflect anymore the state of the
+program's environment. This is potentially insecure.
+
=item Error converting file specification %s
(F) An error peculiar to VMS. Because Perl may have to deal with file
(F) Your machine apparently doesn't implement fcntl(). What is this, a
PDP-11 or something?
+=item Field too wide in 'u' format in pack
+
+(W pack) Each line in an uuencoded string start with a length indicator
+which can't encode values above 63. So there is no point in asking for
+a line length bigger than that. Perl will behave as if you specified
+C<u63> as format.
+
=item Filehandle %s opened only for input
(W io) You tried to write on a read-only filehandle. If you intended
=item Filehandle %s reopened as %s only for input
(W io) You opened for reading a filehandle that got the same filehandle id
-as STDOUT or STDERR. This occured because you closed STDOUT or STDERR
+as STDOUT or STDERR. This occurred because you closed STDOUT or STDERR
previously.
=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 occured because you closed STDIN previously.
+as STDIN. This occurred because you closed STDIN previously.
=item Final $ should be \$ or $name
=item %s found where operator expected
-(S) The Perl lexer knows whether to expect a term or an operator. If it
-sees what it knows to be a term when it was expecting to see an
+(S syntax) The Perl lexer knows whether to expect a term or an operator.
+If it sees what it knows to be a term when it was expecting to see an
operator, it gives you this warning. Usually it indicates that an
operator or delimiter was omitted, such as a semicolon.
names (like C<$A::B>). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
+=item Ignoring %s in character class in regex; marked by <-- HERE in m/%s/
+
+(W) Named unicode character escapes (\N{...}) may return multi-char
+or zero length sequences. 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
(F) You used a digit other than 0 or 1 in a binary number.
(F) When using the C<sub> keyword to construct an anonymous subroutine,
you must always specify a block of code. See L<perlsub>.
+=item Illegal declaration of subroutine %s
+
+(F) A subroutine was not declared correctly. See L<perlsub>.
+
=item Illegal division by zero
(F) You tried to divide a number by 0. Either something was wrong in
=item Illegal switch in PERL5OPT: %s
(X) The PERL5OPT environment variable may only be used to set the
-following switches: B<-[DIMUdmtw]>.
+following switches: B<-[CDIMUdmtwA]>.
=item Ill-formed CRTL environ value "%s"
(F) You can't use system(), exec(), or a piped open in a setuid or
setgid script if C<$ENV{PATH}> contains a directory that is writable by
-the world. See L<perlsec>.
+the world. Also, the PATH must not contain any relative directory.
+See L<perlsec>.
=item Insecure $ENV{%s} while running %s
internally--subject to loss of precision errors in subsequent
operations.
+=item Integer overflow in format string for %s
+
+(F) The indexes and widths specified in the format string of C<printf()>
+or C<sprintf()> are too large. The numbers must not overflow the size of
+integers for your architecture.
+
=item Integer overflow in version
(F) Some portion of a version initialization is too large for the
parenthesised parameter list, perhaps that list was terminated too soon.
See L<attributes>.
+=item Invalid separator character %s in PerlIO layer specification %s
+
+(W layer) When pushing layers onto the Perl I/O system, something other than a
+colon or whitespace was seen between the elements of a layer list.
+If the previous attribute had a parenthesised parameter list, perhaps that
+list was terminated too soon.
+
=item Invalid type '%s' in %s
(F) The given character is not a valid pack or unpack type.
(W unopened) You tried ioctl() on a filehandle that was never opened.
Check you control flow and number of arguments.
+=item IO layers (like "%s") unavailable
+
+(F) Your Perl has not been configured to have PerlIO, and therefore
+you cannot use IO layers. To have PerlIO Perl must be configured
+with 'useperlio'.
+
=item IO::Socket::atmark not implemented on this architecture
(F) Your machine doesn't implement the sockatmark() functionality,
neither as a system call or an ioctl call (SIOCATMARK).
+=item $* is no longer supported
+
+(D deprecated) The special variable C<$*>, deprecated in older perls, has
+been removed as of 5.9.0 and is no longer supported. You should use the
+C<//m> and C<//s> regexp modifiers instead.
+
+=item $# is no longer supported
+
+(D deprecated) The special variable C<$#>, deprecated in older perls, has
+been removed as of 5.9.3 and is no longer supported. You should use the
+printf/sprintf functions instead.
+
=item `%s' is not a code reference
(W overload) The second (fourth, sixth, ...) argument of overload::constant
=item length/code after end of string in unpack
-(F) While unpacking, the string buffer was alread used up when an unpack
+(F) While unpacking, the string buffer was already used up when an unpack
length/code combination tried to obtain more data. This results in
an undefined value for the length. See L<perlfunc/pack>.
=item Malformed UTF-8 character (%s)
-Perl detected something that didn't comply with UTF-8 encoding rules.
+(S utf8) (F) Perl detected something that didn't comply with UTF-8
+encoding rules.
One possible cause is that you read in data that you thought to be in
UTF-8 but it wasn't (it was for example legacy 8-bit data). Another
Perl thought it was reading UTF-16 encoded character data but while
doing it Perl met a malformed Unicode surrogate.
+=item Malformed UTF-8 string in pack
+
+(F) You tried to pack something that didn't comply with UTF-8 encoding
+rules and perl was unable to guess how to make more progress.
+
+=item Malformed UTF-8 string in unpack
+
+(F) You tried to unpack something that didn't comply with UTF-8 encoding
+rules and perl was unable to guess how to make more progress.
+
+=item Malformed UTF-8 string in '%c' format in unpack
+
+(F) You tried to unpack something that didn't comply with UTF-8 encoding
+rules and perl was unable to guess how to make more progress.
+
=item %s matches null string many times in regex; marked by <-- HERE in m/%s/
(W regexp) The pattern you've specified would be an infinite loop if the
(W syntax) An underscore (underbar) in a numeric constant did not
separate two digits.
+=item Missing argument to -%c
+
+(F) The argument to the indicated command line switch must follow
+immediately after the switch, without intervening spaces.
+
=item Missing %sbrace%s on \N{}
(F) Wrong syntax of character name literal C<\N{charname}> within
=item (Missing operator before %s?)
-(S) This is an educated guess made in conjunction with the message "%s
-found where operator expected". Often the missing operator is a comma.
+(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 semicolon on previous line?)
-(S) This is an educated guess made in conjunction with the message "%s
-found where operator expected". Don't automatically put a semicolon on
+(S syntax) This is an educated guess made in conjunction with the message
+"%s found where operator expected". Don't automatically put a semicolon on
the previous line just because you saw this message.
=item Modification of a read-only value attempted
(W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
They're written like C<$foo[1][2][3]>, as in C.
-=item '/' must be followed by 'a*', 'A*' or 'Z*'
-
-(F) You had a pack template indicating a counted-length string,
-Currently the only things that can have their length counted are a*, A*
-or Z*. See L<perlfunc/pack>.
-
=item '/' must follow a numeric type in unpack
(F) You had an unpack template that contained a '/', but this did not
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 Negative '/' count in unpack
(F) The length count obtained from a length/code unpack operation was
=item No DB::DB routine defined
(F) The currently executing code was compiled with the B<-d> switch, but
-for some reason the perl5db.pl file (or some facsimile thereof) didn't
-define a routine to be called at the beginning of each statement. Which
-is odd, because the file should have been required automatically, and
-should have blown up the require if it didn't parse right.
+for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
+module) didn't define a routine to be called at the beginning of each
+statement.
=item No dbm on this machine
(P) This is counted as an internal error, because every machine should
supply dbm nowadays, because Perl comes with SDBM. See L<SDBM_File>.
-=item No DBsub routine
+=item No DB::sub routine defined
-(F) The currently executing code was compiled with the B<-d> switch,
-but for some reason the perl5db.pl file (or some facsimile thereof)
-didn't define a DB::sub routine to be called at the beginning of each
-ordinary subroutine call.
+(F) The currently executing code was compiled with the B<-d> switch, but
+for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
+module) didn't define a C<DB::sub> routine to be called at the beginning
+of each ordinary subroutine call.
=item No B<-e> allowed in setuid scripts
(F) Configure didn't find anything resembling the setreuid() call for
your system.
-=item No space allowed after -%c
-
-(F) The argument to the indicated command line switch must follow
-immediately after the switch, without intervening spaces.
-
=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 variable
+but that key is not allowed by the package of the same type. 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" or "our" declaration, but
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
+=item Non-string passed as bitmask
+
+(W misc) A number has been passed as a bitmask argument to select().
+Use the vec() function to construct the file descriptor bitmasks for
+select. See L<perlfunc/select>
+
=item Null filename used
(F) You can't require the null filename, especially because on many
(S internal) An internal warning that the grammar is screwed up.
-=item Operation `%s': no method found, %s
+=item Operation "%s": no method found, %s
(F) An attempt was made to perform an overloaded operation for which no
handler was defined. While some handlers can be autogenerated in terms
the current limits and change them, and in ksh/bash/zsh use C<ulimit -a>
and C<ulimit -d n>, respectively.
+=item Out of memory during %s extend
+
+(X) An attempt was made to extend an array, a list, or a string beyond
+the largest possible memory allocation.
+
=item Out of memory during "large" request for %s
(F) The malloc() function returned 0, indicating there was insufficient
parsing, but realloc() wouldn't give it more memory, virtual or
otherwise.
+=item '.' outside of string in pack
+
+(F) The argument to a '.' in your template tried to move the working
+position to before the start of the packed string being built.
+
=item '@' outside of string in unpack
(F) You had a template that specified an absolute position outside
the string being unpacked. See L<perlfunc/pack>.
+=item '@' outside of string with malformed UTF-8 in unpack
+
+(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>.
+
=item %s package attribute may clash with future reserved word: %s
(W reserved) A lowercase attribute name was used that had a
(P) An internal error.
+=item panic: attempt to call %s in %s
+
+(P) One of the file test operators entered a code branch that calls
+an ACL related-function, but that function is not available on this
+platform. Earlier checks mean that it should not be possible to
+enter this branch on this platform.
+
=item panic: ck_grep
(P) Failed an internal consistency check trying to compile a grep.
(P) Failed an internal consistency check while trying to reset a weak
reference.
+=item panic: Devel::DProf inconsistent subroutine return
+
+(P) Devel::DProf called a subroutine that exited using goto(LABEL),
+last(LABEL) or next(LABEL). Leaving that way a subroutine called from
+an XSUB will lead very probably to a crash of the interpreter. This is
+a bug that will hopefully one day get fixed.
+
=item panic: die %s
(P) We popped the context stack to an eval context, and then discovered
(P) The internal do_trans routines were called with invalid operational
data.
+=item panic: fold_constants JMPENV_PUSH returned %d
+
+(P) While attempting folding constants an exception other than an C<eval>
+failure was caught.
+
=item panic: frexp
(P) The library function frexp() failed, making printf("%f") impossible.
(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.
+=item panic: hfreeentries failed to free hash
+
+(P) The internal routine used to clear a hashes entries tried repeatedly,
+but each time something added more entries to the hash. Most likely the hash
+contains an object with a reference back to the hash and a destructor that
+adds a new object to the hash.
+
=item panic: INTERPCASEMOD
(P) The lexer got into a bad state at a case modifier.
(P) Something requested a negative number of bytes of malloc.
-=item panic: mapstart
-
-(P) The compiler is screwed up with respect to the map() function.
+=item panic: memory wrap
-=item panic: null array
-
-(P) One of the internal array routines was passed a null AV pointer.
+(P) Something tried to allocate more memory than possible.
=item panic: pad_alloc
(P) The compiler attempted to do a goto, or something weird like that.
+=item panic: unimplemented op %s (#%d) called
+
+(P) The compiler is screwed up and attempted to use an op that isn't permitted
+at run time.
+
=item panic: utf16_to_utf8: odd bytelen
(P) Something tried to call utf16_to_utf8 with an odd (as opposed
"Can't locate object method \"%s\" via package \"%s\"". It often means
that a method requires a package that has not been loaded.
-=item perlio: argument list not closed for layer "%s"
+=item Perl_my_%s() not available
-(W layer) When pushing a layer with arguments onto the Perl I/O system you
-forgot the ) that closes the argument list. (Layers take care of transforming
-data between external and internal representations.) Perl stopped parsing
-the layer list at this point and did not attempt to push this layer.
-If your program didn't explicitly request the failing operation, it may be
-the result of the value of the environment variable PERLIO.
-
-=item perlio: invalid separator character %s in layer specification list %s
-
-(W layer) When pushing layers onto the Perl I/O system, something other than a
-colon or whitespace was seen between the elements of a layer list.
-If the previous attribute had a parenthesised parameter list, perhaps that
-list was terminated too soon.
-
-=item perlio: unknown layer "%s"
-
-(W layer) An attempt was made to push an unknown layer onto the Perl I/O
-system. (Layers take care of transforming data between external and
-internal representations.) Note that some layers, such as C<mmap>,
-are not supported in all environments. If your program didn't
-explicitly request the failing operation, it may be the result of the
-value of the environment variable PERLIO.
+(F) Your platform has very uncommon byte-order and integer size,
+so it was not possible to set up some or all fixed-width byte-order
+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--this is only version %s, stopped
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
-=item Possible Y2K bug: %s
-
-(W y2k) You are concatenating the number 19 with another number, which
-could be a potential Year 2000 problem.
-
=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
(D deprecated) You have written something like this:
One possible workaround is to force Perl to use magical string increment
by prepending "0" to your numbers.
+=item readdir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you're reading from is either closed or not really
+a dirhandle. Check your control flow.
+
=item readline() on closed filehandle %s
(W closed) The filehandle you're reading from got itself closed sometime
(P) A "can't happen" error, because safemalloc() should have caught it
earlier.
+=item Repeated format line will never terminate (~~ and @# incompatible)
+
+(F) Your format contains the ~~ repeat-until-blank sequence and a
+numeric field that will never go blank so that the repetition never
+terminates. You might use ^# instead. See L<perlform>.
+
=item Reversed %s= operator
(W syntax) You wrote your assignment operator backwards. The = must
always comes last, to avoid ambiguity with subsequent unary operators.
+=item rewinddir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
+really a dirhandle. Check your control flow.
+
=item Runaway format
(F) Your format contained the ~~ repeat-until-blank sequence, but it
in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
+=item Search pattern not terminated or ternary operator parsed as search pattern
+
+(F) The lexer couldn't find the final delimiter of a C<?PATTERN?>
+construct.
+
+The question mark is also used as part of the ternary operator (as in
+C<foo ? 0 : 1>) leading to some ambiguous constructions being wrongly
+parsed. One way to disambiguate the parsing is to put parentheses around
+the conditional expression, i.e. C<(foo) ? 0 : 1>.
+
=item %sseek() on unopened filehandle
(W unopened) You tried to use the seek() or sysseek() function on a
filehandle that was either never opened or has since been closed.
+=item seekdir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you are doing a seekdir() on is either closed or not
+really a dirhandle. Check your control flow.
+
=item select not implemented
(F) This machine doesn't implement the select() system call.
(F) The setuid emulator won't run a script that is writable by the
world, because the world might have written on it already.
+=item Setuid script not plain file
+
+(F) The setuid emulator won't run a script that isn't read from a file,
+but from a socket, a pipe or another device.
+
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
+=item !=~ should be !~
+
+(W syntax) The non-matching operator is !~, not !=~. !=~ will be
+interpreted as the != (numeric not equal) and ~ (1's complement)
+operators: probably not what you intended.
+
=item <> should be quotes
(F) You wrote C<< require <file> >> when you should have written
iterate more times than there are characters of input, which is what
happened.) See L<perlfunc/split>.
+=item State variable %s will be reinitialized
+
+(W misc) You're declaring a C<state> variable inside a list. The list
+assignment will be treated by perl as a regular assignment, which means
+that the C<state> variable will be reinitialized each time the statement
+is run. The solution to have it initialized only once is to write the
+assignment on its own line, as in:
+
+ state $var = 42;
+
=item Statement unlikely to be reached
(W exec) You did an exec() with some statement after it other than a
(W unopened) You tried to use the stat() function on a filehandle that
was either never opened or has since been closed.
-=item Stub found while resolving method `%s' overloading %s
+=item Stub found while resolving method "%s" overloading "%s"
(P) Overloading resolution over @ISA tree may be broken by importation
stubs. Stubs should never be implicitly created, but explicit calls to
(P) The substitution was looping infinitely. (Obviously, a substitution
shouldn't iterate more times than there are characters of input, which
is what happened.) See the discussion of substitution in
-L<perlop/"Quote and Quote-like Operators">.
+L<perlop/"Regexp Quote-Like Operators">.
=item Substitution pattern not terminated
(F) Your Perl was compiled with B<-D>SETUID_SCRIPTS_ARE_SECURE_NOW, but
a version of the setuid emulator somehow got run anyway.
+=item sv_upgrade from type %d down to type %d
+
+(P) Perl tried to force the upgrade an SV to a type which was actually
+inferior to its current type.
+
=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
(F) A (?(condition)if-clause|else-clause) construct can have at most two
(W unopened) You tried to use the tell() function on a filehandle that
was either never opened or has since been closed.
+=item telldir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to telldir() is either closed or not really
+a dirhandle. Check your control flow.
+
=item That use of $[ is unsupported
(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
past the symlink to get to the real file. Use an actual filename
instead.
+=item The 'unique' attribute may only be applied to 'our' variables
+
+(F) This attribute was never supported on C<my> or C<sub> declarations.
+
=item This Perl can't reset CRTL environ elements (%s)
=item This Perl can't set CRTL environ elements (%s=%s)
=item thread failed to start: %s
-(F) The entry point function of threads->create() failed for some reason.
-
-=item Tied variable freed while still in use
-
-(F) An access method for a tied variable (e.g. FETCH) did something to
-free the variable. Since continuing the current operation is likely
-to result in a coredump, Perl is bailing out instead.
+(W threads)(S) The entry point function of threads->create() failed for some reason.
=item times not implemented
(F) Your version of the C library apparently doesn't do times(). I
suspect you're not running on Unix.
+=item "-T" is on the #! line, it must also be used on the command line
+
+(X) The #! line (or local equivalent) in a Perl script contains the
+B<-T> option, but Perl was not invoked with B<-T> in its command line.
+This is an error because, by the time Perl discovers a B<-T> in a
+script, it's too late to properly taint everything from the environment.
+So Perl gives up.
+
+If the Perl script is being executed as a command using the #!
+mechanism (or its local equivalent), this error can usually be fixed by
+editing the #! line so that the B<-T> option is a part of Perl's first
+argument: e.g. change C<perl -n -T> to C<perl -T -n>.
+
+If the Perl script is being executed as C<perl scriptname>, then the
+B<-T> option must appear on the command line: C<perl -T scriptname>.
+
=item To%s: illegal mapping '%s'
(F) You tried to define a customized To-mapping for lc(), lcfirst,
=item Too late for "-%s" option
(X) The #! line (or local equivalent) in a Perl script contains the
-B<-M> or B<-m> option. This is an error because B<-M> and B<-m> options
+B<-M>, B<-m> or B<-C> option. This is an error because those options
are not intended for use inside scripts. Use the C<use> pragma instead.
-=item Too late for "B<-T>" option
-
-(X) The #! line (or local equivalent) in a Perl script contains the
-B<-T> option, but Perl was not invoked with B<-T> in its command line.
-This is an error because, by the time Perl discovers a B<-T> in a
-script, it's too late to properly taint everything from the environment.
-So Perl gives up.
-
-If the Perl script is being executed as a command using the #!
-mechanism (or its local equivalent), this error can usually be fixed by
-editing the #! line so that the B<-T> option is a part of Perl's first
-argument: e.g. change C<perl -n -T> to C<perl -T -n>.
-
-If the Perl script is being executed as C<perl scriptname>, then the
-B<-T> option must appear on the command line: C<perl -T scriptname>.
-
=item Too late to run %s block
(W void) A CHECK or INIT block is being defined during run time proper,
=item Transliteration replacement not terminated
-(F) The lexer couldn't find the final delimiter of a tr/// or tr[][]
-construct.
+(F) The lexer couldn't find the final delimiter of a tr///, tr[][],
+y/// or y[][] construct.
=item '%s' trapped by operation mask
of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
C<< +> >>, C<<< +>> >>>, C<-|>, C<|->, C<< <& >>, C<< >& >>.
+=item Unknown PerlIO layer "%s"
+
+(W layer) An attempt was made to push an unknown layer onto the Perl I/O
+system. (Layers take care of transforming data between external and
+internal representations.) Note that some layers, such as C<mmap>,
+are not supported in all environments. If your program didn't
+explicitly request the failing operation, it may be the result of the
+value of the environment variable PERLIO.
+
=item Unknown process %x sent message to prime_env_iter: %s
(P) An error peculiar to VMS. Perl was reading values for %ENV before
of Perl executables, some of which may support fork, some not. Try
changing the name you call Perl by to C<perl_>, C<perl__>, and so on.
-=item Unsupported script encoding
+=item Unsupported script encoding %s
(F) Your program file begins with a Unicode Byte Order Mark (BOM) which
-declares it to be in a Unicode encoding that Perl cannot yet read.
+declares it to be in a Unicode encoding that Perl cannot read.
=item Unsupported socket function "%s" called
(W untie) A copy of the object returned from C<tie> (or C<tied>) was
still valid when C<untie> was called.
+=item Usage: POSIX::%s(%s)
+
+(F) You called a POSIX function with incorrect arguments.
+See L<POSIX/FUNCTIONS> for more information.
+
+=item Usage: Win32::%s(%s)
+
+(F) You called a Win32 function with incorrect arguments.
+See L<Win32> for more information.
+
=item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/
(W regexp) You have used an internal modifier such as (?-o) that has no
The <-- HERE shows in the regular expression about
where the problem was discovered. See L<perlre>.
+=item Useless localization of %s
+
+(W syntax) The localization of lvalues such as C<local($x=10)> is
+legal, but in fact the local() currently has no effect. This may change at
+some point in the future, but in the meantime such code is discouraged.
+
=item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
(W regexp) You have used an internal modifier such as (?o) that has no
The <-- HERE shows in the regular expression about
where the problem was discovered. See L<perlre>.
-=item Useless localization of %s
-
-(W syntax) The localization of lvalues such as C<local($x=10)> is
-legal, but in fact the local() currently has no effect. This may change at
-some point in the future, but in the meantime such code is discouraged.
-
=item Useless use of %s in void context
(W void) You did something without a side effect in a context that does
This warning will not be issued for numerical constants equal to 0 or 1
since they are often used in statements like
- 1 while sub_with_side_effects() ;
+ 1 while sub_with_side_effects();
String constants that would normally evaluate to 0 or 1 are warned
about.
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
-=item Use of freed value in iteration (perhaps you modified the iterated array within the loop?)
+=item Use of freed value in iteration
-(F) This is typically caused by code like the following:
+(F) Perhaps you modified the iterated array within the loop?
+This error is typically caused by code like the following:
@a = (3,4);
@a = () for (1,2,@a);
(F) You attempted to use a feature of printf that is accessible from
only C. This usually means there's a better way to do it in Perl.
-=item Use of $* is deprecated
-
-(D deprecated) This variable magically turned on multi-line pattern
-matching, both for you and for any luckless subroutine that you happen
-to call. You should use the new C<//m> and C<//s> modifiers now to do
-that without the dangerous action-at-a-distance effects of C<$*>.
-
-=item Use of $# is deprecated
-
-(D deprecated) This was an ill-advised attempt to emulate a poorly
-defined B<awk> feature. Use an explicit printf() or sprintf() instead.
-
=item Use of %s is deprecated
(D deprecated) The construct indicated is no longer recommended for use,
defined. It was interpreted as a "" or a 0, but maybe it was a mistake.
To suppress this warning assign a defined value to your variables.
-To help you figure out what was undefined, perl tells you what operation
-you used the undefined value in. Note, however, that perl optimizes your
-program 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.
+To help you figure out what was undefined, perl will try to tell you 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 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 Using a hash as a reference is deprecated
longer than 1024 characters. The return value has been truncated to
1024 characters.
+=item Variable "%s" is not available
+
+(W closure) During compilation, an inner named subroutine or eval is
+attempting to capture an outer lexical that is not currently available.
+This can happen for one of two reasons. First, the outer lexical may be
+declared in an outer anonymous subroutine that has not yet been created.
+(Remember that named subs are created at compile time, while anonymous
+subs are created at run-time.) For example,
+
+ sub { my $a; sub f { $a } }
+
+At the time that f is created, it can't capture the current value of $a,
+since the anonymous subroutine hasn't been created yet. Conversely,
+the following won't give a warning since the anonymous subroutine has by
+now been created and is live:
+
+ sub { my $a; eval 'sub f { $a }' }->();
+
+The second situation is caused by an eval accessing a variable that has
+gone out of scope, for example,
+
+ sub f {
+ my $a;
+ sub { eval '$a' }
+ }
+ f()->();
+
+Here, when the '$a' in the eval is being compiled, f() is not currently being
+executed, so its $a is not available for capture.
+
=item Variable "%s" is not imported%s
(F) While "use strict" in effect, you referred to a global variable that
earlier variable will still exist until the end of the scope or until
all closure referents to it are destroyed.
-=item Variable "%s" may be unavailable
-
-(W closure) An inner (nested) I<anonymous> subroutine is inside a
-I<named> subroutine, and outside that is another subroutine; and the
-anonymous (innermost) subroutine is referencing a lexical variable
-defined in the outermost subroutine. For example:
-
- sub outermost { my $a; sub middle { sub { $a } } }
-
-If the anonymous subroutine is called or referenced (directly or
-indirectly) from the outermost subroutine, it will share the variable as
-you would expect. But if the anonymous subroutine is called or
-referenced when the outermost subroutine is not active, it will see the
-value of the shared variable as it was before and during the *first*
-call to the outermost subroutine, which is probably not what you want.
-
-In these circumstances, it is usually best to make the middle subroutine
-anonymous, using the C<sub {}> syntax. Perl has specific support for
-shared variables in nested anonymous subroutines; a named subroutine in
-between interferes with this feature.
-
=item Variable syntax
(A) You've accidentally run your script through B<csh> instead
=item Variable "%s" will not stay shared
(W closure) An inner (nested) I<named> subroutine is referencing a
-lexical variable defined in an outer subroutine.
+lexical variable defined in an outer named subroutine.
-When the inner subroutine is called, it will probably see the value of
+When the inner subroutine is called, it will see the value of
the outer subroutine's variable as it was before and during the *first*
call to the outer subroutine; in this case, after the first call to the
outer subroutine is complete, the inner and outer subroutines will no
longer share a common value for the variable. In other words, the
variable will no longer be shared.
-Furthermore, if the outer subroutine is anonymous and references a
-lexical variable outside itself, then the outer and inner subroutines
-will I<never> share the given variable.
-
This problem can usually be solved by making the inner subroutine
anonymous, using the C<sub {}> syntax. When inner anonymous subs that
-reference variables in outer subroutines are called or referenced, they
+reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.
=item Version number must be a constant number
its equivalent C<BEGIN> block found an internal inconsistency with
the version number.
+=item Version string '%s' contains invalid data; ignoring: '%s'
+
+(W misc) The version string contains invalid characters at the end, which
+are being ignored.
+
=item v-string in use/require is non-portable
(W portable) The use of v-strings is non-portable to older, pre-5.6, Perls.
=item Wide character in %s
(W utf8) Perl met a wide character (>255) when it wasn't expecting
-one. This warning is by default on for I/O (like print) but can be
-turned off by C<no warnings 'utf8';>. You are supposed to explicitly
-mark the filehandle with an encoding, see L<open> and L<perlfunc/binmode>.
+one. This warning is by default on for I/O (like print). The easiest
+way to quiet this warning is simply to add the C<:utf8> layer to the
+output, e.g. C<binmode STDOUT, ':utf8'>. Another way to turn off the
+warning is to add C<no warnings 'utf8';> but that is often closer to
+cheating. In general, you are supposed to explicitly mark the
+filehandle with an encoding, see L<open> and L<perlfunc/binmode>.
=item Within []-length '%c' not allowed
(W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
+=item %s "\x%s" does not map to Unicode
+
+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
+
+if you try to read in the a-diaereses Latin-1 as UTF-8.
+
=item 'X' outside of string
(F) You had a (un)pack template that specified a relative position before
(F) You had a pack template that specified a relative position after
the end of the string being unpacked. See L<perlfunc/pack>.
-=item Xsub "%s" called in sort
-
-(F) The use of an external subroutine as a sort comparison is not yet
-supported.
-
-=item Xsub called in sort
-
-(F) The use of an external subroutine as a sort comparison is not yet
-supported.
-
=item YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!
(F) And you probably never will, because you probably don't have the
assignment is executed, which is probably not what you want. (If it IS
what you want, put an & in front.)
+=item Your random numbers are not that random
+
+(F) When trying to initialise the random seed for hashes, Perl could
+not get any randomness out of your system. This usually indicates
+Something Very Wrong.
+
=back
=cut
https://perl5.git.perl.org / perl5.git / blobdiff