perldiag - various Perl diagnostics
These messages are classified as follows (listed in
increasing order of desperation):
(W) A warning (optional).
(D) A deprecation (optional).
(S) A severe warning (default).
(F) A fatal error (trappable).
(P) An internal error you should never see (trappable).
(X) A very fatal error (nontrappable).
(A) An alien error message (not generated by Perl).
The majority of messages from the first three classifications
above (W, D & S) can be controlled using the "warnings"
pragma.
If a message can be controlled by the "warnings" pragma,
its warning category is included with the classification
letter in the description below.
Optional warnings are enabled by using the "warnings"
pragma or the -w and -W switches. Warnings may be captured
by setting $SIG{__WARN__} to a reference to a routine that
will be called on each warning instead of printing it.
See perlvar.
Default warnings are always enabled unless they are
explicitly disabled with the "warnings" pragma or the -X
switch.
Trappable errors may be trapped using the eval operator.
See "eval" in perlfunc. In almost all cases, warnings may
be selectively disabled or promoted to fatal errors using
the "warnings" pragma. See warnings.
The messages are in alphabetical order, without regard to
upper or lower-case. Some of these messages are generic.
Spots that vary are denoted with a %s or other printfstyle
escape. These escapes are ignored by the alphabetical
order, as are all characters other than letters. To
look up your message, just ignore anything that is not a
letter.
accept() on closed socket %s
(W closed) You tried to do an accept on a closed
socket. Did you forget to check the return value of
your socket() call? See "accept" in perlfunc.
Allocation too large: %lx
(X) You can't allocate more than 64K on an MS-DOS
machine.
'!' allowed only after types %s
(F) The '!' is allowed in pack() or unpack() only
after certain types. See "pack" in perlfunc.
Ambiguous call resolved as CORE::%s(), qualify as such or
use &
(W ambiguous) A subroutine you have declared has the
same name as a Perl keyword, and you have used the
name without qualification for calling one or the
other. Perl decided to call the builtin because the
subroutine is not imported.
To force interpretation as a subroutine call, either
put an ampersand before the subroutine name, or qualify
the name with its package. Alternatively, you can
import the subroutine (or pretend that it's imported
with the "use subs" pragma).
To silently interpret it as the Perl operator, use the
"CORE::" prefix on the operator (e.g. "CORE::log($x)")
or declare the subroutine to be an object method (see
"Subroutine Attributes" in perlsub or attributes).
Ambiguous range in transliteration operator
(F) You wrote something like "tr/a-z-0//" which
doesn't mean anything at all. To include a "-" character
in a transliteration, put it either first or
last. (In the past, "tr/a-z-0//" was synonymous with
"tr/a-y//", which was probably not what you would have
expected.)
Ambiguous use of %s resolved as %s
(W ambiguous)(S) 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.
'|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command
line redirection, and found that STDIN was a
pipe, and that you also tried to redirect STDIN using
'<'. Only one STDIN stream to a customer, please.
'|' and '>' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command
line redirection, and thinks you tried to redirect
stdout both to a file and into a pipe to another
command. You need to choose one or the other, though
nothing's stopping you from piping into a program or
Perl script which 'splits' output into two streams,
such as
open(OUT,">$ARGV[0]") or die "Can't write to
$ARGV[0]: $!";
while (<STDIN>) {
print;
print OUT;
}
close OUT;
Applying %s to %s will act on scalar(%s)
(W misc) The pattern match ("//"), substitution
("s///"), and transliteration ("tr///") operators work
on scalar values. If you apply one of them to an
array or a hash, it will convert the array or hash to
a scalar value -- the length of an array, or the population
info of a hash -- and then work on that scalar
value. This is probably not what you meant to do.
See "grep" in perlfunc and "map" in perlfunc for
alternatives.
Args must match #! line
(F) The setuid emulator requires that the arguments
Perl was invoked with match the arguments specified on
the #! line. Since some systems impose a one-argument
limit on the #! line, try combining switches; for
example, turn "-w -U" into "-wU".
Arg too short for msgsnd
(F) msgsnd() requires a string at least as long as
sizeof(long).
%s argument is not a HASH or ARRAY element
(F) The argument to exists() must be a hash or array
element, such as:
$foo{$bar}
$ref->{"susie"}[12]
%s argument is not a HASH or ARRAY element or slice
(F) The argument to delete() must be either a hash or
array element, such as:
$foo{$bar}
$ref->{"susie"}[12]
or a hash or array slice, such as:
@foo[$bar, $baz, $xyzzy]
@{$ref->[12]}{"susie", "queue"}
%s argument is not a subroutine name
(F) The argument to exists() for "exists &sub" must be
a subroutine name, and not a subroutine call. "exists
&sub()" will generate this error.
Argument "%s" isn't numeric%s
(W numeric) The indicated string was fed as an argument
to an operator that expected a numeric value
instead. If you're fortunate the message will identify
which operator was so unfortunate.
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.
Array @%s missing the @ in argument %d of %s()
(D deprecated) Really old Perl let you omit the @ on
array names in some spots. This is now heavily deprecated.
assertion botched: %s
(P) The malloc package that comes with Perl had an
internal failure.
Assertion failed: file "%s"
(P) A general assertion failed. The file in question
must be examined.
Assignment to both a list and a scalar
(F) If you assign to a conditional operator, the 2nd
and 3rd arguments must either both be scalars or both
be lists. Otherwise Perl won't know which context to
supply to the right side.
A thread exited while %d threads were running
(W) 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
thread. See threads.
Attempt to access disallowed key '%s' in a restricted hash
(F) The failing code has attempted to get or set a key
which is not in the current set of allowed keys of a
restricted hash.
Attempt to bless into a reference
(F) The CLASSNAME argument to the bless() operator is
expected to be the name of the package to bless the
resulting object into. You've supplied instead a reference
to something: perhaps you wrote
bless $self, $proto;
when you intended
bless $self, ref($proto) || $proto;
If you actually want to bless into the stringified
version of the reference supplied, you need to
stringify it yourself, for example by:
bless $self, "$proto";
Attempt to delete disallowed key '%s' from a restricted
hash
(F) The failing code attempted to delete from a
restricted hash a key which is not in its key set.
Attempt to delete readonly key '%s' from a restricted hash
(F) The failing code attempted to delete a key whose
value has been declared readonly from a restricted
hash.
Attempt to free non-arena SV: 0x%lx
(P internal) All SV objects are supposed to be allocated
from arenas that will be garbage collected on
exit. An SV was discovered to be outside any of those
arenas.
Attempt to free nonexistent shared string
(P internal) Perl maintains a reference counted internal
table of strings to optimize the storage and
access of hash keys and other strings. This indicates
someone tried to decrement the reference count of a
string that can no longer be found in the table.
Attempt to free temp prematurely
(W debugging) Mortalized values are supposed to be
freed by the free_tmps() routine. This indicates that
something else is freeing the SV before the
free_tmps() routine gets a chance, which means that
the free_tmps() routine will be freeing an unreferenced
scalar when it does try to free it.
Attempt to free unreferenced glob pointers
(P internal) The reference counts got screwed up on
symbol aliases.
Attempt to free unreferenced scalar
(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 earlier, and
should have been freed, and in fact, probably was
freed. This could indicate that SvREFCNT_dec() was
called too many times, or that SvREFCNT_inc() was
called too few times, or that the SV was mortalized
when it shouldn't have been, or that memory has been
corrupted.
Attempt to join self
(F) You tried to join a thread from within itself,
which is an impossible task. You may be joining the
wrong thread, or you may need to move the join() to
some other thread.
Attempt to pack pointer to temporary value
(W pack) You tried to pass a temporary value (like the
result of a function, or a computed expression) to the
"p" pack() template. This means the result contains a
pointer to a location that could become invalid anytime,
even before the end of the current statement.
Use literals or global values as arguments to the "p"
pack() template to avoid this warning.
Attempt to use reference as lvalue in substr
(W substr) You supplied a reference as the first argument
to substr() used as an lvalue, which is pretty
strange. Perhaps you forgot to dereference it first.
See "substr" in perlfunc.
Bad arg length for %s, is %d, should be %s
(F) You passed a buffer of the wrong size to one of
msgctl(), semctl() or shmctl(). In C parlance, the
correct sizes are, respectively,
sizeof(struct msqid_ds *), sizeof(struct semid_ds *),
and sizeof(struct shmid_ds *).
Bad evalled substitution pattern
(F) You've used the "/e" switch to evaluate the
replacement for a substitution, but perl found a syntax
error in the code to evaluate, most likely an
unexpected right brace '}'.
Bad filehandle: %s
(F) A symbol was passed to something wanting a filehandle,
but the symbol has no filehandle associated
with it. Perhaps you didn't do an open(), or did it
in another package.
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 setting environment
variable "PERL_BADFREE" to 0.
This message can be seen quite often with DB_File on
systems with "hard" dynamic linking, like "AIX" and
"OS/2". It is a bug of "Berkeley DB" which is left
unnoticed if "DB" uses forgiving system malloc().
Bad hash
(P) One of the internal hash routines was passed a
null HV pointer.
Bad index while coercing array into hash
(F) The index looked up in the hash found as the 0'th
element of a pseudo-hash is not legal. Index values
must be at 1 or greater. See perlref.
Badly placed ()'s
(A) You've accidentally run your script through csh
instead of Perl. Check the #! line, or manually feed
your script into Perl yourself.
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 of quotes, so
$var = 'myvar';
$sym = mypack::$var;
is not the same as
$var = 'myvar';
$sym = "mypack::$var";
Bad realloc() ignored
(S malloc) An internal routine called realloc() on
something that had never been malloc()ed in the first
place. Mandatory, but can be disabled by setting environment
variable "PERL_BADFREE" to 1.
Bad symbol for array
(P) An internal request asked to add an array entry to
something that wasn't a symbol table entry.
Bad symbol for filehandle
(P) An internal request asked to add a filehandle
entry to something that wasn't a symbol table entry.
Bad symbol for hash
(P) An internal request asked to add a hash entry to
something that wasn't a symbol table entry.
Bareword found in conditional
(W bareword) The compiler found a bareword where it
expected a conditional, which often indicates that an
|| or && was parsed as part of the last argument of
the previous construct, for example:
open FOO || die;
It may also indicate a misspelled constant that has
been interpreted as a bareword:
use constant TYPO => 1;
if (TYOP) { print "foo" }
The "strict" pragma is useful in avoiding such errors.
Bareword "%s" not allowed while "strict subs" in use
(F) With "strict subs" in use, a bareword is only
allowed as a subroutine identifier, in curly brackets
or to the left of the "=>" symbol. Perhaps you need
to predeclare a subroutine?
Bareword "%s" refers to nonexistent package
(W bareword) You used a qualified bareword of the form
"Foo::", but the compiler saw no other uses of that
namespace before that point. Perhaps you need to predeclare
a package?
BEGIN failed--compilation aborted
(F) An untrapped exception was raised while executing
a BEGIN subroutine. Compilation stops immediately and
the interpreter is exited.
BEGIN not safe after errors--compilation aborted
(F) Perl found a "BEGIN {}" subroutine (or a "use"
directive, which implies a "BEGIN {}") after one or
more compilation errors had already occurred. Since
the intended environment for the "BEGIN {}" could not
be guaranteed (due to the errors), and since subsequent
code likely depends on its correct operation,
Perl just gave up.
1 better written as $1
(W syntax) Outside of patterns, backreferences live on
as variables. The use of backslashes is grandfathered
on the right-hand side of a substitution, but stylistically
it's better to use the variable form because
other Perl programmers will expect it, and it works
better if there are more than 9 backreferences.
Binary number > 0b11111111111111111111111111111111 nonportable
(W portable) The binary number you specified is larger
than 2**32-1 (4294967295) and therefore non-portable
between systems. See perlport for more on portability
concerns.
bind() on closed socket %s
(W closed) You tried to do a bind on a closed socket.
Did you forget to check the return value of your
socket() call? See "bind" in perlfunc.
binmode() on closed filehandle %s
(W unopened) You tried binmode() on a filehandle that
was never opened. Check you control flow and number
of arguments.
Bit vector size > 32 non-portable
(W portable) Using bit vector sizes larger than 32 is
non-portable.
Bizarre copy of %s in %s
(P) Perl detected an attempt to copy an internal value
that is not copyable.
Buffer overflow in prime_env_iter: %s
(W internal) A warning peculiar to VMS. While Perl
was preparing to iterate over %ENV, it encountered a
logical name or symbol definition which was too long,
so it was truncated to the string shown.
Callback called exit
(F) A subroutine invoked from an external package via
call_sv() exited by calling exit.
%s() called too early to check prototype
(W prototype) You've called a function that has a prototype
before the parser saw a definition or declaration
for it, and Perl could not check that the call
conforms to the prototype. You need to either add an
early prototype declaration for the subroutine in
question, or move the subroutine definition ahead of
the call to get proper prototype checking. Alternatively,
if you are certain that you're calling the
function correctly, you may put an ampersand before
the name to avoid the warning. See perlsub.
Cannot compress integer in pack
(F) An argument to pack("w",...) was too large to compress.
The BER compressed integer format can only be
used with positive integers, and you attempted to compress
Infinity or a very large number (> 1e308). See
"pack" in perlfunc.
Cannot compress negative numbers in pack
(F) An argument to pack("w",...) was negative. The
BER compressed integer format can only be used with
positive integers. See "pack" in perlfunc.
Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer.
The BER compressed integer format can only be used
with positive integers, and you attempted to compress
something else. See "pack" in perlfunc.
Can't bless non-reference value
(F) Only hard references may be blessed. This is how
Perl "enforces" encapsulation of objects. See perlobj.
Can't call method "%s" in empty package "%s"
(F) You called a method correctly, and it correctly
indicated a package functioning as a class, but that
package doesn't have ANYTHING defined in it, let alone
methods. See perlobj.
Can't call method "%s" on an undefined value
(F) You used the syntax of a method call, but the slot
filled by the object reference or package name contains
an undefined value. Something like this will
reproduce the error:
$BADREF = undef;
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
Can't call method "%s" on unblessed reference
(F) A method call must know in what package it's supposed
to run. It ordinarily finds this out from the
object reference you supply, but you didn't supply an
object reference in this case. A reference isn't an
object reference until it has been blessed. See perlobj.
Can't call method "%s" without a package or object reference
(F) You used the syntax of a method call, but the slot
filled by the object reference or package name contains
an expression that returns a defined value which
is neither an object reference nor a package name.
Something like this will reproduce the error:
$BADREF = 42;
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
Can't chdir to %s
(F) You called "perl -x/foo/bar", but "/foo/bar" is
not a directory that you can chdir to, possibly
because it doesn't exist.
Can't check filesystem of script "%s" for nosuid
(P) For some reason you can't check the filesystem of
the script for nosuid.
Can't coerce array into hash
(F) You used an array where a hash was expected, but
the array has no information on how to map from keys
to array indices. You can do that only with arrays
that have a hash reference at index 0.
Can't coerce %s to integer in %s
(F) Certain types of SVs, in particular real symbol
table entries (typeglobs), can't be forced to stop
being what they are. So you can't say things like:
*foo += 1;
You CAN say
$foo = *foo;
$foo += 1;
but then $foo no longer contains a glob.
Can't coerce %s to number in %s
(F) Certain types of SVs, in particular real symbol
table entries (typeglobs), can't be forced to stop
being what they are.
Can't coerce %s to string in %s
(F) Certain types of SVs, in particular real symbol
table entries (typeglobs), can't be forced to stop
being what they are.
Can't create pipe mailbox
(P) An error peculiar to VMS. The process is suffering
from exhausted quotas or other plumbing problems.
Can't declare class for non-scalar %s in "%s"
(F) Currently, only scalar variables can be declared
with a specific class qualifier in a "my" or "our"
declaration. The semantics may be extended for other
types of variables in future.
Can't declare %s in "%s"
(F) Only scalar, array, and hash variables may be
declared as "my" or "our" variables. They must have
ordinary identifiers as names.
Can't do inplace edit: %s is not a regular file
(S inplace) You tried to use the -i switch on a special
file, such as a file in /dev, or a FIFO. The
file was ignored.
Can't do inplace edit on %s: %s
(S inplace) The creation of the new file failed for
the indicated reason.
Can't do inplace edit without backup
(F) You're on a system such as MS-DOS that gets confused
if you try reading from a deleted (but still
opened) file. You have to say "-i.bak", or some such.
Can't do inplace edit: %s would not be unique
(S inplace) Your filesystem does not support filenames
longer than 14 characters and Perl was unable to create
a unique filename during inplace editing with the
-i switch. The file was ignored.
Can't do {n,m} with n > m in regex; marked by <-- HERE in
m/%s/
(F) Minima must be less than or equal to maxima. If
you really want your regexp to match something 0
times, just put {0}. The <-- HERE shows in the regular
expression about where the problem was discovered. See
perlre.
Can't do setegid!
(P) The setegid() call failed for some reason in the
setuid emulator of suidperl.
Can't do seteuid!
(P) The setuid emulator of suidperl failed for some
reason.
Can't do setuid
(F) This typically means that ordinary perl tried to
exec suidperl to do setuid emulation, but couldn't
exec it. It looks for a name of the form sperl5.000
in the same directory that the perl executable resides
under the name perl5.000, typically /usr/local/bin on
Unix machines. If the file is there, check the execute
permissions. If it isn't, ask your sysadmin why
he and/or she removed it.
Can't do waitpid with flags
(F) This machine doesn't have either waitpid() or
wait4(), so only waitpid() without flags is emulated.
Can't emulate -%s on #! line
(F) The #! line specifies a switch that doesn't make
sense at this point. For example, it'd be kind of
silly to put a -x on the #! line.
Can't exec "%s": %s
(W exec) A system(), exec(), or piped open call could
not execute the named program for the indicated reason.
Typical reasons include: the permissions were
wrong on the file, the file wasn't found in
$ENV{PATH}, the executable in question was compiled
for another architecture, or the #! line in a script
points to an interpreter that can't be run for similar
reasons. (Or maybe your system doesn't support #! at
all.)
Can't exec %s
(F) Perl was trying to execute the indicated program
for you because that's what the #! line said. If
that's not what you wanted, you may need to mention
"perl" on the #! line somewhere.
Can't execute %s
(F) You used the -S switch, but the copies of the
script to execute found in the PATH did not have correct
permissions.
Can't find an opnumber for "%s"
(F) A string of a form "CORE::word" was given to pro-
totype(), but there is no builtin with the name
"word".
Can't find %s character property "%s"
(F) You used "{}"
or "P{}" but the character property
by that name could not be found. Maybe you misspelled
the name of the property (remember that the
names of character properties consist only of alphanumeric
characters), or maybe you forgot the "Is" or
"In" prefix?
Can't find label %s
(F) You said to goto a label that isn't mentioned anywhere
that it's possible for us to go to. See "goto"
in perlfunc.
Can't find %s on PATH
(F) You used the -S switch, but the script to execute
could not be found in the PATH.
Can't find %s on PATH, '.' not in PATH
(F) You used the -S switch, but the script to execute
could not be found in the PATH, or at least not with
the correct permissions. The script exists in the
current directory, but PATH prohibits running it.
Can't find %s property definition %s
(F) You may have tried to use ""
which means a Unicode
property (for example "{Lu}"
is all uppercase
letters). If you did mean to use a Unicode property,
see perlunicode for the list of known properties. If
you didn't mean to use a Unicode property, escape the
"",
either by "\p" (just the "")
or by "Q"
(the rest of the string, until possible "
Can't find string terminator %s anywhere before EOF
(F) Perl strings can stretch over multiple lines.
This message means that the closing delimiter was
omitted. Because bracketed quotes count nesting levels,
the following is missing its final parenthesis:
print q(The character '(' starts a side comment.);
If you're getting this error from a here-document, you
may have included unseen whitespace before or after
your closing tag. A good programmer's editor will have
a way to help you find these characters.
Can't fork
(F) A fatal error occurred while trying to fork while
opening a pipeline.
Can't get filespec - stale stat buffer?
(S) A warning peculiar to VMS. This arises because of
the difference between access checks under VMS and
under the Unix model Perl assumes. Under VMS, access
checks are done by filename, rather than by bits in
the stat buffer, so that ACLs and other protections
can be taken into account. Unfortunately, Perl
assumes that the stat buffer contains all the necessary
information, and passes it, instead of the filespec,
to the access checking routine. It will try to
retrieve the filespec using the device name and FID
present in the stat buffer, but this works only if you
haven't made a subsequent call to the CRTL stat() routine,
because the device name is overwritten with each
call. If this warning appears, the name lookup
failed, and the access checking routine gave up and
returned FALSE, just to be conservative. (Note: The
access checking routine knows about the Perl "stat"
operator and file tests, so you shouldn't ever see
this warning in response to a Perl command; it arises
only if some internal code takes stat buffers
lightly.)
Can't get pipe mailbox device name
(P) An error peculiar to VMS. After creating a mailbox
to act as a pipe, Perl can't retrieve its name for
later use.
Can't get SYSGEN parameter value for MAXBUF
(P) An error peculiar to VMS. Perl asked $GETSYI how
big you want your mailbox buffers to be, and didn't
get an answer.
Can't "goto" into the middle of a foreach loop
(F) A "goto" statement was executed to jump into the
middle of a foreach loop. You can't get there from
here. See "goto" in perlfunc.
Can't "goto" out of a pseudo block
(F) A "goto" statement was executed to jump out of
what might look like a block, except that it isn't a
proper block. This usually occurs if you tried to
jump out of a sort() block or subroutine, which is a
no-no. See "goto" in perlfunc.
Can't goto subroutine from an eval-string
(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.)
Can't goto subroutine outside a subroutine
(F) The deeply magical "goto subroutine" call can only
replace one subroutine call for another. It can't
manufacture one out of whole cloth. In general you
should be calling it out of only an AUTOLOAD routine
anyway. See "goto" in perlfunc.
Can't ignore signal CHLD, forcing to default
(W signal) Perl has detected that it is being run with
the SIGCHLD signal (sometimes known as SIGCLD) disabled.
Since disabling this signal will interfere
with proper determination of exit status of child processes,
Perl has reset the signal to its default
value. This situation typically indicates that the
parent program under which Perl may be running (e.g.
cron) is being very careless.
Can't "last" outside a loop block
(F) A "last" statement was executed to break out of
the current block, except that there's this itty bitty
problem called there isn't a current block. Note that
an "if" or "else" block doesn't count as a "loopish"
block, as doesn't a block given to sort(), map() or
grep(). You can usually double the curlies to get the
same effect though, because the inner curlies will be
considered a block that loops once. See "last" in
perlfunc.
Can't localize lexical variable %s
(F) You used local on a variable name that was previously
declared as a lexical variable using "my". This
is not allowed. If you want to localize a package
variable of the same name, qualify it with the package
name.
Can't localize pseudo-hash element
(F) You said something like "local $ar->{'key'}",
where $ar is a reference to a pseudo-hash. That
hasn't been implemented yet, but you can get a similar
effect by localizing the corresponding array element
directly -- "local $ar->[$ar->[0]{'key'}]".
Can't localize through a reference
(F) You said something like "local $$ref", which Perl
can't currently handle, because when it goes to
restore the old value of whatever $ref pointed to
after the scope of the local() is finished, it can't
be sure that $ref will still be a reference.
Can't locate %s
(F) You said to "do" (or "require", or "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 "require"
in perlfunc and lib.
Can't locate auto/%s.al in @INC
(F) A function (or method) was called in a package
which allows autoload, but there is no function to
autoload. Most probable causes are a misprint in a
function/method name or a failure to "AutoSplit" the
file, say, by doing "make install".
Can't locate object method "%s" via package "%s"
(F) You called a method correctly, and it correctly
indicated a package functioning as a class, but that
package doesn't define that particular method, nor
does any of its base classes. See perlobj.
Can't locate package %s for @%s::ISA
(W syntax) The @ISA array contained the name of
another package that doesn't seem to exist.
Can't locate PerlIO%s
(F) You tried to use in open() a PerlIO layer that
does not exist, e.g. open(FH, ">:nosuchlayer", "somefile").
Can't make list assignment to ENV on this system
(F) List assignment to %ENV is not supported on some
systems, notably VMS.
Can't modify %s in %s
(F) You aren't allowed to assign to the item indicated,
or otherwise try to change it, such as with an
auto-increment.
Can't modify nonexistent substring
(P) The internal routine that does assignment to a
substr() was handed a NULL.
Can't modify non-lvalue subroutine call
(F) Subroutines meant to be used in lvalue context
should be declared as such, see "Lvalue subroutines"
in perlsub.
Can't msgrcv to read-only var
(F) The target of a msgrcv must be modifiable to be
used as a receive buffer.
Can't "next" outside a loop block
(F) A "next" statement was executed to reiterate the
current block, but there isn't a current block. Note
that an "if" or "else" block doesn't count as a "loopish"
block, as doesn't a block given to sort(), map()
or grep(). You can usually double the curlies to get
the same effect though, because the inner curlies will
be considered a block that loops once. See "next" in
perlfunc.
Can't open %s: %s
(S inplace) The implicit opening of a file through use
of the "<>" filehandle, either implicitly under the
"-n" or "-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.
Can't open a reference
(W io) You tried to open a scalar reference for reading
or writing, using the 3-arg open() syntax :
open FH, '>', $ref;
but your version of perl is compiled without perlio,
and this form of open is not supported.
Can't open bidirectional pipe
(W pipe) You tried to say "open(CMD, "|cmd|")", which
is not supported. You can try any of several modules
in the Perl library to do this, such as IPC::Open2.
Alternately, direct the pipe's output to a file using
">", and then read it in under a different file handle.
Can't open error file %s as stderr
(F) An error peculiar to VMS. Perl does its own command
line redirection, and couldn't open the file
specified after '2>' or '2>>' on the command line for
writing.
Can't open input file %s as stdin
(F) An error peculiar to VMS. Perl does its own command
line redirection, and couldn't open the file
specified after '<' on the command line for reading.
Can't open output file %s as stdout
(F) An error peculiar to VMS. Perl does its own command
line redirection, and couldn't open the file
specified after '>' or '>>' on the command line for
writing.
Can't open output pipe (name: %s)
(P) An error peculiar to VMS. Perl does its own
command line redirection, and couldn't open the pipe
into which to send data destined for stdout.
Can't open perl script%s
(F) The script you specified can't be opened for the
indicated reason.
Can't read CRTL environ
(S) A warning peculiar to VMS. Perl tried to read an
element of %ENV from the CRTL's internal environment
array and discovered the array was missing. You need
to figure out where your CRTL misplaced its environ or
define PERL_ENV_TABLES (see perlvms) so that environ
is not searched.
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 "sort { &func } @x"
instead of "sort func @x".
Can't "redo" outside a loop block
(F) A "redo" statement was executed to restart the
current block, but there isn't a current block. Note
that an "if" or "else" block doesn't count as a "loopish"
block, as doesn't a block given to sort(), map()
or grep(). You can usually double the curlies to get
the same effect though, because the inner curlies will
be considered a block that loops once. See "redo" in
perlfunc.
Can't remove %s: %s, skipping file
(S inplace) You requested an inplace edit without creating
a backup file. Perl was unable to remove the
original file to replace it with the modified file.
The file was left unmodified.
Can't rename %s to %s: %s, skipping file
(S inplace) The rename done by the -i switch failed
for some reason, probably because you don't have write
permission to the directory.
Can't reopen input pipe (name: %s) in binary mode
(P) An error peculiar to VMS. Perl thought stdin was
a pipe, and tried to reopen it to accept binary data.
Alas, it failed.
Can't resolve method `%s' overloading `%s' in package `%s'
(F|P) Error resolving overloading specified by a
method name (as opposed to a subroutine reference): no
such method callable via the package. If method name
is "???", this is an internal error.
Can't reswap uid and euid
(P) The setreuid() call failed for some reason in the
setuid emulator of suidperl.
Can't return %s from lvalue subroutine
(F) Perl detected an attempt to return illegal lvalues
(such as temporary or readonly values) from a subroutine
used as an lvalue. This is not allowed.
Can't return outside a subroutine
(F) The return statement was executed in mainline
code, that is, where there was no subroutine call to
return out of. See perlsub.
Can't return %s to lvalue scalar context
(F) You tried to return a complete array or hash from
an lvalue subroutine, but you called the subroutine in
a way that made Perl think you meant to return only
one value. You probably meant to write parentheses
around the call to the subroutine, which tell Perl
that the call should be in list context.
Can't stat script "%s"
(P) For some reason you can't fstat() the script even
though you have it open already. Bizarre.
Can't swap uid and euid
(P) The setreuid() call failed for some reason in the
setuid emulator of suidperl.
Can't take log of %g
(F) For ordinary real numbers, you can't take the logarithm
of a negative number or zero. There's a
Math::Complex package that comes standard with Perl,
though, if you really want to do that for the negative
numbers.
Can't take sqrt of %g
(F) For ordinary real numbers, you can't take the
square root of a negative number. There's a
Math::Complex package that comes standard with Perl,
though, if you really want to do that.
Can't undef active subroutine
(F) You can't undefine a routine that's currently running.
You can, however, redefine it while it's running,
and you can even undef the redefined subroutine
while the old routine is running. Go figure.
Can't unshift
(F) You tried to unshift an "unreal" array that can't
be unshifted, such as the main Perl stack.
Can't upgrade that kind of scalar
(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.
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.
Can't use anonymous symbol table for method lookup
(P) The internal routine that does method lookup was
handed a symbol table that doesn't have a name. Symbol
tables can become anonymous for example by
undefining stashes: "undef %Some::Package::".
Can't use an undefined value as %s reference
(F) A value used as either a hard reference or a symbolic
reference must be a defined value. This helps
to delurk some insidious errors.
Can't use bareword ("%s") as %s ref while "strict refs" in
use
(F) Only hard references are allowed by "strict refs".
Symbolic references are disallowed. See perlref.
Can't use %! because Errno.pm is not available
(F) The first time the %! hash is used, perl automatically
loads the Errno.pm module. The Errno module is
expected to tie the %! hash to provide symbolic names
for $! errno values.
Can't use %s for loop variable
(F) Only a simple scalar variable may be used as a
loop variable on a foreach.
Can't use global %s in "my"
(F) You tried to declare a magical variable as a lexical
variable. This is not allowed, because the magic
can be tied to only one location (namely the global
variable) and it would be incredibly confusing to have
variables in your program that looked like magical
variables but weren't.
Can't use "my %s" in sort comparison
(F) The global variables $a and $b are reserved for
sort comparisons. You mentioned $a or $b in the same
line as the <=> or cmp operator, and the variable had
earlier been declared as a lexical variable. Either
qualify the sort variable with the package name, or
rename the lexical variable.
Can't use %s ref as %s ref
(F) You've mixed up your reference types. You have to
dereference a reference of the type needed. You can
use the ref() function to test the type of the reference,
if need be.
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 perlref.
Can't use subscript on %s
(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.
Can't use c to mean $%c in expression
(W syntax) In an ordinary expression, backslash is a
unary operator that creates a reference to its argument.
The use of backslash to indicate a backreference
to a matched substring is valid only as part of a
regular expression pattern. Trying to do this in
ordinary Perl code produces a value that prints out
looking like SCALAR(0xdecaf). Use the $1 form
instead.
Can't weaken a nonreference
(F) You attempted to weaken something that was not a
reference. Only references can be weakened.
Can't x= to read-only value
(F) You tried to repeat a constant value (often the
undefined value) with an assignment operator, which
implies modifying the value itself. Perhaps you need
to copy the value to a temporary, and repeat that.
Character in "C" format wrapped in pack
(W pack) You said
pack("C", $x)
where $x is either less than 0 or more than 255; the
"C" format is only for encoding native operating system
characters (ASCII, EBCDIC, and so on) and not for
Unicode characters, so Perl behaved as if you meant
pack("C", $x & 255)
If you actually want to pack Unicode codepoints, use
the "U" format instead.
Character in "c" format wrapped in pack
(W pack) You said
pack("c", $x)
where $x is either less than -128 or more than 127;
the "c" format is only for encoding native operating
system characters (ASCII, EBCDIC, and so on) and not
for Unicode characters, so Perl behaved as if you
meant
pack("c", $x & 255);
If you actually want to pack Unicode codepoints, use
the "U" format instead.
close() on unopened filehandle %s
(W unopened) You tried to close a filehandle that was
never opened.
Code missing after '/'
(F) You had a (sub-)template that ends with a '/'.
There must be another template code following the
slash. See "pack" in perlfunc.
%s: Command not found
(A) You've accidentally run your script through csh
instead of Perl. Check the #! line, or manually feed
your script into Perl yourself.
Compilation failed in require
(F) Perl could not compile a file specified in a
"require" statement. Perl uses this generic message
when none of the errors that it encountered were
severe enough to halt compilation immediately.
Complex regular subexpression recursion limit (%d)
exceeded
(W regexp) The regular expression engine uses recursion
in complex situations where back-tracking is
required. Recursion depth is limited to 32766, or
perhaps less in architectures where the stack cannot
grow arbitrarily. ("Simple" and "medium" situations
are handled without recursion and are not subject to a
limit.) Try shortening the string under examination;
looping in Perl code (e.g. with "while") rather than
in the regular expression engine; or rewriting the
regular expression so that it is simpler or backtracks
less. (See perlfaq2 for information on Mastering Reg-
ular Expressions.)
cond_broadcast() called on unlocked variable
(W threads) Within a thread-enabled program, you tried
to call cond_broadcast() on a variable which wasn't
locked. The cond_broadcast() function is used to wake
up another thread that is waiting in a cond_wait(). To
ensure that the signal isn't sent before the other
thread has a chance to enter the wait, it is usual for
the signaling thread to first wait for a lock on variable.
This lock attempt will only succeed after the
other thread has entered cond_wait() and thus relinquished
the lock.
cond_signal() called on unlocked variable
(W threads) Within a thread-enabled program, you tried
to call cond_signal() on a variable which wasn't
locked. The cond_signal() function is used to wake up
another thread that is waiting in a cond_wait(). To
ensure that the signal isn't sent before the other
thread has a chance to enter the wait, it is usual for
the signaling thread to first wait for a lock on variable.
This lock attempt will only succeed after the
other thread has entered cond_wait() and thus relinquished
the lock.
connect() on closed socket %s
(W closed) You tried to do a connect on a closed
socket. Did you forget to check the return value of
your socket() call? See "connect" in perlfunc.
Constant(%s)%s: %s
(F) The parser found inconsistencies either while
attempting to define an overloaded constant, or when
trying to find the character name specified in the
".}" escape. Perhaps you forgot to load the corresponding
"overload" or "charnames" pragma? See
charnames and overload.
Constant is not %s reference
(F) A constant value (perhaps declared using the "use
constant" pragma) is being dereferenced, but it
amounts to the wrong type of reference. The message
indicates the type of reference that was expected.
This usually indicates a syntax error in dereferencing
the constant value. See "Constant Functions" in perlsub
and constant.
Constant subroutine %s redefined
(S) You redefined a subroutine which had previously
been eligible for inlining. See "Constant Functions"
in perlsub for commentary and workarounds.
Constant subroutine %s undefined
(W misc) You undefined a subroutine which had previously
been eligible for inlining. See "Constant Functions"
in perlsub for commentary and workarounds.
Copy method did not return a reference
(F) The method which overloads "=" is buggy. See "Copy
Constructor" in overload.
CORE::%s is not a keyword
(F) The CORE:: namespace is reserved for Perl keywords.
corrupted regexp pointers
(P) The regular expression engine got confused by what
the regular expression compiler gave it.
corrupted regexp program
(P) The regular expression engine got passed a regexp
program without a valid magic number.
Corrupt malloc ptr 0x%lx at 0x%lx
(P) The malloc package that comes with Perl had an
internal failure.
Count after length/code in unpack
(F) You had an unpack template indicating a countedlength
string, but you have also specified an explicit
size for the string. See "pack" in perlfunc.
Deep recursion on subroutine "%s"
(W recursion) This subroutine has called itself
(directly or indirectly) 100 times more than it has
returned. This probably indicates an infinite recursion,
unless you're writing strange benchmark programs,
in which case it indicates something else.
defined(@array) is deprecated
(D deprecated) defined() is not usually useful on
arrays because it checks for an undefined scalar
value. If you want to see if the array is empty, just
use "if (@array) { # not empty }" for example.
defined(%hash) is deprecated
(D deprecated) defined() is not usually useful on
hashes because it checks for an undefined scalar
value. If you want to see if the hash is empty, just
use "if (%hash) { # not empty }" for example.
%s defines neither package nor VERSION--version check
failed
(F) You said something like "use Module 42" but in the
Module file there are neither package declarations nor
a $VERSION.
Delimiter for here document is too long
(F) In a here document construct like "<<FOO", the
label "FOO" is too long for Perl to handle. You have
to be seriously twisted to write code that triggers
this error.
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.
Did not produce a valid header
See Server error.
%s did not return a true value
(F) A required (or used) file must return a true value
to indicate that it compiled correctly and ran its
initialization code correctly. It's traditional to
end such a file with a "1;", though any true value
would do. See "require" in perlfunc.
(Did you mean &%s instead?)
(W) You probably referred to an imported subroutine
&FOO as $FOO or some such.
(Did you mean "local" instead of "our"?)
(W misc) Remember that "our" does not localize the
declared global variable. You have declared it again
in the same lexical scope, which seems superfluous.
(Did you mean $ or @ instead of %?)
(W) You probably said %hash{$key} when you meant
$hash{$key} or @hash{@keys}. On the other hand, maybe
you just meant %hash and got carried away.
Died
(F) You passed die() an empty string (the equivalent
of "die """) or you called it with no args and both $@
and $_ were empty.
Document contains no data
See Server error.
%s does not define %s::VERSION--version check failed
(F) You said something like "use Module 42" but the
Module did not define a "$VERSION."
'/' does not take a repeat count
(F) You cannot put a repeat count of any kind right
after the '/' code. See "pack" in perlfunc.
Don't know how to handle magic of type '%s'
(P) The internal handling of magical variables has
been cursed.
do_study: out of memory
(P) This should have been caught by safemalloc()
instead.
(Do you need to predeclare %s?)
(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 something
that isn't defined yet, you don't actually have to
define the subroutine or package before the current
location. You can use an empty "sub foo;" or "package
FOO;" to enter a "forward" declaration.
dump() better written as CORE::dump()
(W misc) You used the obsolescent "dump()" built-in
function, without fully qualifying it as
"CORE::dump()". Maybe it's a typo. See "dump" in
perlfunc.
Duplicate free() ignored
(S malloc) An internal routine called free() on something
that had already been freed.
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 unlikely to be what you want.
Empty %s
(F) ""
and "P" are used to introduce a named Unicode
property, as described in perlunicode and perlre.
You used ""
or "P" in a regular expression without
specifying the property name.
entering effective %s failed
(F) While under the "use filetest" pragma, switching
the real and effective uids or gids failed.
Error converting file specification %s
(F) An error peculiar to VMS. Because Perl may have
to deal with file specifications in either VMS or Unix
syntax, it converts them to a single form when it must
operate on them directly. Either you've passed an
invalid file specification to Perl, or you've found a
case the conversion routines don't handle. Drat.
%s: Eval-group in insecure regular expression
(F) Perl detected tainted data when trying to compile
a regular expression that contains the "(?{ ... })"
zero-width assertion, which is unsafe. See "(?{ code
})" in perlre, and perlsec.
%s: Eval-group not allowed at run time
(F) Perl tried to compile a regular expression
containing the "(?{ ... })" zero-width assertion at
run time, as it would when the pattern contains interpolated
values. Since that is a security risk, it is
not allowed. If you insist, you may still do this by
explicitly building the pattern from an interpolated
string at run time and using that in an eval(). See
"(?{ code })" in perlre.
%s: Eval-group not allowed, use re 'eval'
(F) A regular expression contained the "(?{ ... })"
zero-width assertion, but that construct is only
|
