=head1 NAME
perldiag - various Perl diagnostics
=head1 DESCRIPTION
These messages are classified as follows (listed in increasing order of
desperation):
(W) A warning (optional).
(D) A deprecation (enabled by default).
(S) A severe warning (enabled by 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 C pragma.
If a message can be controlled by the C pragma, its warning
category is included with the classification letter in the description
below. E.g. C means a warning in the C category.
Optional warnings are enabled by using the C pragma or the B
and B switches. Warnings may be captured by setting C
to a reference to a routine that will be called on each warning instead
of printing it. See L.
Severe warnings are always enabled, unless they are explicitly disabled
with the C pragma or the B switch.
Trappable errors may be trapped using the eval operator. See
L. In almost all cases, warnings may be selectively
disabled or promoted to fatal errors using the C pragma.
See L.
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 printf-style 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.
=over 4
=item __CLASS__ is experimental
(S experimental::class) This warning is emitted if you use the C<__class__>
keyword of C. This keyword is currently
experimental and its behaviour may change in future releases of Perl.
=item 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
L.
=item ADJUST is experimental
(S experimental::class) This warning is emitted if you use the C
keyword of C. This keyword is currently
experimental and its behaviour may change in future releases of Perl.
=item Aliasing via reference is experimental
(S experimental::refaliasing) This warning is emitted if you use
a reference constructor on the left-hand side of an assignment to
alias one variable to another. Simply suppress the warning if you
want to use the feature, but know that in doing so you are taking
the risk of using an experimental feature which may change or be
removed in a future Perl version:
no warnings "experimental::refaliasing";
use feature "refaliasing";
\$x = \$y;
=item all is experimental
(S experimental::keyword_all) This warning is emitted if you use the
C keyword of C. This keyword is currently
experimental and its behaviour may change in future releases of Perl.
=item '%c' allowed only after types %s in %s
(F) The modifiers '!', '' are allowed in pack() or unpack() only
after certain types. See L.
=item alpha->numify() is lossy
(W numeric) An alpha version can not be numified without losing
information.
=item 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 C pragma).
To silently interpret it as the Perl operator, use the C<:> prefix
on the operator (e.g. C<:log>) or declare the subroutine
to be an object method (see L or
L).
=item Ambiguous range in transliteration operator
(F) You wrote something like C, negated. If you meant
the string, just write C. If you meant the function call,
write C.
=item Ambiguous use of %c resolved as operator %c
(S ambiguous) C, C, and C are both infix operators (modulus,
bitwise and, and multiplication) I initial special characters
(denoting hashes, subroutines and typeglobs), and you said something
like C that might be interpreted as either of them. We
assumed you meant the infix operator, but please try to make it more
clear -- in the example given, you might write C if you
really meant to multiply a glob by the result of calling a function.
=item Ambiguous use of %c{%s} resolved to %c%s
(W ambiguous) You wrote something like C, which might be
asking for the variable C, or it might be calling a function
named foo, and dereferencing it as an array reference. If you wanted
the variable, you can just write C. If you wanted to call the
function, write C ... or you could just not have a variable
and a function with the same name, and save yourself a lot of trouble.
=item Ambiguous use of %c{%s[...]} resolved to %c%s[...]
=item Ambiguous use of %c{%s{...}} resolved to %c%s{...}
(W ambiguous) You wrote something like C (where foo represents
the name of a Perl keyword), which might be looking for element number
2 of the array named C, in which case please write C, or you
might have meant to pass an anonymous arrayref to the function named
foo, and then do a scalar deref on the value it returns. If you meant
that, write C.
In regular expressions, the C syntax is sometimes necessary
to disambiguate between array subscripts and character classes.
C$length[2345]/>, for instance, will be interpreted as C followed
by the character class C. If an array subscript is what you
want, you can avoid the warning by changing C${length[2345]}/> to the
unsightly C${\$length[2345]}/>, by renaming your array to something
that does not coincide with a built-in keyword, or by simply turning
off warnings with C.
=item '|' 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 () {
print;
print OUT;
}
close OUT;
=item any is experimental
(S experimental::keyword_any) This warning is emitted if you use the
C keyword of C. This keyword is currently
experimental and its behaviour may change in future releases of Perl.
=item Applying %s to %s will act on scalar(%s)
(W misc) The pattern match (C/>), substitution (C and L for
alternatives.
=item Arg too short for msgsnd
(F) msgsnd() requires a string at least as long as sizeof(long).
=item 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.
Note that for the C and C (infinity and not-a-number) the
definition of "numeric" is somewhat unusual: the strings themselves
(like "Inf") are considered numeric, and anything following them is
considered non-numeric.
=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 Argument "%s" treated as 0 in increment (++)
(W numeric) The indicated string was fed as an argument to the C
operator which expects either a number or a string matching
C^[a-zA-Z]*[0-9]*\z/>. See L for details.
=item Array passed to stat will be coerced to a scalar%s
(W syntax) You called stat() on an array, but the array will be
coerced to a scalar - the number of elements in the array.
=item A signature parameter must start with '$', '@' or '%'
(F) Each subroutine signature parameter declaration must start with a valid
sigil; for example:
sub foo ($x, $, $y = 1, @z) {}
=item A slurpy parameter may not have a default value
(F) Only scalar subroutine signature parameters may have a default value;
for example:
sub foo ($x = 1) {} # legal
sub foo (@x = (1)) {} # invalid
sub foo (%x = (a => b)) {} # invalid
=item assertion botched: %s
(X) The malloc package that comes with Perl had an internal failure.
=item Assertion %s failed: file "%s", line %d
(X) A general assertion failed. The file in question must be examined.
=item Assigned value is not a reference
(F) You tried to assign something that was not a reference to an lvalue
reference (e.g., C). If you meant to make $x an alias to $y, use
C.
=item Assigned value is not %s reference
(F) You tried to assign a reference to a reference constructor, but the
two references were not of the same type. You cannot alias a scalar to
an array, or an array to a hash; the two types must match.
\$x = \@y; # error
\@x = \%y; # error
$y = [];
\$x = $y; # error; did you mean \$y?
=item Assigning non-zero to $[ is no longer possible
(F) When the "array_base" feature is disabled
(e.g., and under C, and as of Perl 5.30)
the special variable C, which is deprecated, is now a fixed zero value.
=item 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.
=item Assuming NOT a POSIX class since %s in regex; marked by S in m/%s/
(W regexp) You had something like these:
[[:alnum]]
[[:digit:xyz]
They look like they might have been meant to be the POSIX classes
C or C. If so, they should be written:
[[:alnum:]]
[[:digit:]xyz]
Since these aren't legal POSIX class specifications, but are legal
bracketed character classes, Perl treats them as the latter. In the
first example, it matches the characters C, C, C, C,
C, C, and C.
If these weren't meant to be POSIX classes, this warning message is
spurious, and can be suppressed by reordering things, such as
[[al:num]]
or
[[:munla]]
=item at require-statement should be quotes
(F) You wrote C >> when you should have written
C.
=item 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.
=item Attempt to bless into a freed package
(F) You wrote C with one argument after somehow causing
the current package to be freed. Perl cannot figure out what to
do, so it throws up its hands in despair.
=item Attempt to bless into a class
(F) You are attempting to call C with a package name that is a
new-style C. This is not necessary, as instances created by the
constructor are already in the correct class. Instances cannot be created
by other means, such as C.
=item 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";
=item Attempt to clear deleted array
(S debugging) An array was assigned to when it was being freed.
Freed values are not supposed to be visible to Perl code. This
can also happen if XS code calls C from a custom magic
callback on the array.
=item Attempt to delete disallowed key '%s' from a restricted hash
(F) The failing code attempted to delete from a restricted hash a key
which is not in its key set.
=item 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.
=item Attempt to free non-arena SV: 0x%x
(S 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.
=item Attempt to free nonexistent shared string '%s'%s
(S 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.
=item Attempt to free temp prematurely: SV 0x%x
(S debugging) Mortalized values are supposed to be freed by the
free_tmps() routine. This indicates that something else is freeing the
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.
=item Attempt to free unreferenced glob pointers
(S internal) The reference counts got screwed up on symbol aliases.
=item Attempt to free unreferenced scalar: SV 0x%x
(S 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.
=item 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.
=item Attempt to reload %s aborted.
(F) You tried to load a file with C or C that failed to
compile once already. Perl will not try to compile this file again
unless you delete its entry from %INC. See L and
L.
=item Attempt to set length of freed array
(W misc) You tried to set the length of an array which has
been freed. You can do this by storing a reference to the
scalar representing the last index of an array and later
assigning through that reference. For example
$r = do {my @a; \$#a};
$$r = 503
=item 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 L.
=item Attribute prototype(%s) discards earlier prototype attribute in same sub
(W misc) A sub was declared as sub foo : prototype(A) : prototype(B) {}, for
example. Since each sub can only have one prototype, the earlier
declaration(s) are discarded while the last one is applied.
=item av_reify called on tied array
(S debugging) This indicates that something went wrong and Perl got I
confused about C or C being tied.
=item Bad arg length for %s, is %u, should be %d
(F) You passed a buffer of the wrong size to one of msgctl(), semctl()
or shmctl(). In C parlance, the correct sizes are, respectively,
S, S, and
S.
=item Bad evalled substitution pattern
(F) You've used the C 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 '}'.
=item 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.
=item Bad free() ignored
(S malloc) An internal routine called free() on something that had never
been malloc()ed in the first place. Mandatory, but can be disabled by
setting environment variable C to 0.
This message can be seen quite often with DB_File on systems with "hard"
dynamic linking, like C and C. It is a bug of C
which is left unnoticed if C uses I system malloc().
=item Bad infix plugin result (%zd) - did not consume entire identifier
(F) A plugin using the C mechanism to parse an infix
keyword consumed part of a named identifier operator name but did not
consume all of it. This is not permitted as it leads to fragile parsing
results.
=item Badly placed ()'s
(A) You've accidentally run your script through B instead
of Perl. Check the #! line, or manually feed your script into
Perl yourself.
=item Bad name after %s
(F) You started to name a symbol by using a package prefix, and then
didn't finish the symbol. In particular, you can't interpolate outside
of quotes, so
$var = 'myvar';
$sym = mypack::$var;
is not the same as
$var = 'myvar';
$sym = "mypack::$var";
=item Bad plugin affecting keyword '%s'
(F) An extension using the keyword plugin mechanism violated the
plugin API.
=item 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 the environment variable C to 1.
=item Bad symbol for %s
(P) An internal request asked to add an entry of the named type to something that
wasn't a symbol table entry.
=item Bad symbol for scalar
(P) An internal request asked to add a scalar entry to something that
wasn't a symbol table entry.
=item 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 C pragma is useful in avoiding such errors.
=item Bareword in require contains "%s"
=item Bareword in require maps to disallowed filename "%s"
=item Bareword in require maps to empty filename
(F) The bareword form of require has been invoked with a filename which could
not have been generated by a valid bareword permitted by the parser. You
shouldn't be able to get this error from Perl code, but XS code may throw it
if it passes an invalid module name to C.
=item Bareword in require must not start with a double-colon: "%s"
(F) In C, the bareword is not allowed to start with a
double-colon. Write C as C instead.
=item 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?
=item Bareword "%s" refers to nonexistent package
(W bareword) You used a qualified bareword of the form C<:>, but the
compiler saw no other uses of that namespace before that point. Perhaps
you need to predeclare a package?
=item Bareword filehandle "%s" not allowed under 'no feature "bareword_filehandles"'
(F) You attempted to use a bareword filehandle with the
C feature disabled.
Only the built-in handles C, C, C, C,
C and C can be used with the C
feature disabled.
=item BEGIN failed--compilation aborted
(F) An untrapped exception was raised while executing a BEGIN
subroutine. Compilation stops immediately and the interpreter is
exited.
=item BEGIN not safe after errors--compilation aborted
(F) Perl found a C subroutine (or a C directive, which
implies a C) after one or more compilation errors had already
occurred. Since the intended environment for the C could not
be guaranteed (due to the errors), and since subsequent code likely
depends on its correct operation, Perl just gave up.
=item \%d better written as $%d
(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.
=item Binary number > 0b11111111111111111111111111111111 non-portable
(W portable) The binary number you specified is larger than 2**32-1
(4294967295) and therefore non-portable between systems. See
L for more on portability concerns.
=item 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 L.
=item binmode() on closed filehandle %s
(W unopened) You tried binmode() on a filehandle that was never opened.
Check your control flow and number of arguments.
=item Bit vector size > 32 non-portable
(W portable) Using bit vector sizes larger than 32 is non-portable.
=item Bizarre copy of %s
(P) Perl detected an attempt to copy an internal value that is not
copiable.
=item Bizarre SvTYPE [%d]
(P) When starting a new thread or returning values from a thread, Perl
encountered an invalid data type.
=item Both or neither range ends should be Unicode in regex; marked by
S in m/%s/
(W regexp) (only under C> or within C)
In a bracketed character class in a regular expression pattern, you
had a range which has exactly one end of it specified using C, and
the other end is specified using a non-portable mechanism. Perl treats
the range as a Unicode range, that is, all the characters in it are
considered to be the Unicode characters, and which may be different code
points on some platforms Perl runs on. For example, C
is treated as if you had instead said C, that is it
matches the characters whose code points in Unicode are 6, 7, and 8.
But that C might indicate that you meant something different, so
the warning gets raised.
=item Buffer overflow in prime_env_iter: %s
(W internal) A warning peculiar to VMS. While Perl was preparing to
iterate over %ENV, it encountered a logical name or symbol definition
which was too long, so it was truncated to the string shown.
=item Built-in function '%s' is experimental
(S experimental::builtin) A call is being made to a function in the
C<:> namespace, which is currently experimental. The existence
or nature of the function may be subject to change in a future version
of Perl.
=item builtin::import can only be called at compile time
(F) The C method of the C package was invoked when no code
is currently being compiled. Since this method is used to introduce new
lexical subroutines into the scope currently being compiled, this is not
going to have any effect.
=item builtin::inf not implemented
(F) Your machine doesn't support infinity as a numeric value (probably because
it's a VAX).
=item builtin::nan not implemented
(F) Your machine doesn't support NaN ("not a number") as a numeric value
(probably because it's a VAX).
=item Builtin version bundle "%s" is not supported by Perl
(F) You attempted to C for a version number that is either
older than 5.39 (when the ability was added), or newer than the current perl
version.
=item Callback called exit
(F) A subroutine invoked from an external package via call_sv()
exited by calling exit.
=item %s() attempted on invalid dirhandle %s
(W io) You called readdir(), telldir(), seekdir(), rewinddir() or
closedir() on a handle that has not been opened, or is now closed. A
handle must be successfully opened with opendir() to be used with
these functions. Check your control flow.
=item %s() attempted on handle %s opened with open()
(W io) You called readdir(), telldir(), seekdir(), rewinddir() or
closedir() on a handle that was opened with open(). If you want to
use these functions to traverse the contents of a directory, you need
to open the handle with opendir().
=item %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 L.
=item Cannot apply a :writer attribute to a non-scalar field
(F) An attempt was made to use the C<:writer> attribute on a field that is
not a scalar (i.e. an array or hash). At the present version, these are only
permitted on scalar fields. You will have to manually create a writer
accessor method yourself.
=item Cannot assign :param(%s) to field %s because that name is already in use
(F) An attempt was made to apply a parameter name to a field, when the name
is already being used by another field in the same class, or one of its
parent classes. This would cause a name clash so is not allowed.
=item Cannot chr %f
(F) You passed an invalid number (like an infinity or not-a-number) to C.
=item Cannot complete in-place edit of %s: %s
(F) Your perl script appears to have changed directory while
performing an in-place edit of a file specified by a relative path,
and your system doesn't include the directory relative POSIX functions
needed to handle that.
=item Cannot compress %f in pack
(F) You tried compressing an infinity or not-a-number as an unsigned
integer with BER, which makes no sense.
=item 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 a very large number (> 1e308).
See L.
=item 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 L.
=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 there is
no legal conversion from that type of reference to a typeglob.
=item Cannot copy to %s
(P) Perl detected an attempt to copy a value to an internal type that cannot
be directly assigned to.
=item Cannot create class %s as it already has a non-empty @ISA
(F) An attempt was made to create a class out of a package that already has
an C array, and the array is not empty. This is not permitted, as it
would lead to a class with inconsistent inheritance.
=item Cannot create an object of incomplete class "%s"
(F) An attempt was made to create an object of a class where the start
of the class definition has been seen, but the class has not been
completed.
This can happen for a failed eval, or if you attempt to create an
object at compile time before the class is complete:
eval "class Foo {"; Foo->new; # error
class Bar { BEGIN { Bar->new } }; # error
=item Cannot find encoding "%s"
(S io) You tried to apply an encoding that did not exist to a filehandle,
either with open() or binmode().
=item Cannot invoke a method of "%s" on an instance of "%s"
(F) You tried to directly call a C subroutine of one class by passing
in a value that is an instance of a different class. This is not permitted,
as the method would not have access to the correct instance fields.
=item Cannot invoke method on a non-instance
(F) You tried to directly call a C subroutine of a class by passing
in a value that is not an instance of that class. This is not permitted, as
the method would not then have access to its instance fields.
=item Cannot open %s as a dirhandle: it is already open as a filehandle
(F) You tried to use opendir() to associate a dirhandle to a symbol (glob
or scalar) that already holds a filehandle. Since this idiom might render
your code confusing, it was deprecated in Perl 5.10. As of Perl 5.28, it
is a fatal error.
=item Cannot open %s as a filehandle: it is already open as a dirhandle
(F) You tried to use open() to associate a filehandle to a symbol (glob
or scalar) that already holds a dirhandle. Since this idiom might render
your code confusing, it was deprecated in Perl 5.10. As of Perl 5.28, it
is a fatal error.
=item Cannot '%s' outside of a 'class'
(F) You attempted to use one of the keywords that only makes sense inside
a C definition, at a location that is not inside such a class.
=item Cannot pack %f with '%c'
(F) You tried converting an infinity or not-a-number to an integer,
which makes no sense.
=item Cannot printf %f with '%c'
(F) You tried printing an infinity or not-a-number as a character (%c),
which makes no sense. Maybe you meant '%s', or just stringifying it?
=item Cannot reopen existing class "%s"
(F) You tried to begin a C definition for a class that already exists.
A class may only have one definition block.
=item Cannot set tied @DB::args
(F) C tried to set C, but found it tied. Tying C
is not supported. (Before this error was added, it used to crash.)
=item Cannot tie unreifiable array
(P) You somehow managed to call C on an array that does not
keep a reference count on its arguments and cannot be made to
do so. Such arrays are not even supposed to be accessible to
Perl code, but are only used internally.
=item Cannot use __CLASS__ outside of a method or field initializer expression
(F) A C<__class__> expression yields the class name of the object instance
executing the current method, and therefore it can only be placed inside an
actual method (or method-like expression, such as a field initializer
expression).
=item Cannot yet reorder sv_vcatpvfn() arguments from va_list
(F) Some XS code tried to use C or a related function with a
format string that specifies explicit indexes for some of the elements, and
using a C-style variable-argument list (a C). This is not currently
supported. XS authors wanting to do this must instead construct a C array
of C scalars containing the arguments.
=item 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 L.
=item Can't "%s" out of a "defer" block
(F) An attempt was made to jump out of the scope of a C block by using
a control-flow statement such as C, C or a loop control. This is
not permitted.
=item Can't "%s" out of a "finally" block
(F) Similar to above, but involving a C block at the end of a
C/C construction rather than a C block.
=item Can't bless an object reference
(F) You attempted to call C on a value that already refers to a real
object instance.
=item Can't bless non-reference value
(F) Only hard references may be blessed. This is how Perl "enforces"
encapsulation of objects. See L.
=item Can't "break" in a loop topicalizer
(F) You called C, but you're in a C block rather than
a C block. You probably meant to use C or C.
=item Can't "break" outside a given block
(F) You called C, but you're not inside a C block.
=item Can't call destructor for 0x%p in global destruction
(S) This should not happen. Internals code has set up a destructor
using C or C which is firing
during global destruction. Please attempt to reduce the code that triggers
this warning down to a small an example as possible and then report the
problem to L
=item 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);
=item 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 L.
=item 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);
=item Can't call mro_isa_changed_in() on anonymous symbol table
(P) Perl got confused as to whether a hash was a plain hash or a
symbol table hash when trying to update @ISA caches.
=item Can't call mro_method_changed_in() on anonymous symbol table
(F) An XS module tried to call C on a hash that was
not attached to the symbol table.
=item Can't chdir to %s
(F) You called C, but F is not a directory
that you can chdir to, possibly because it doesn't exist.
=item Can't coerce %s to %s 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.
=item Can't "continue" outside a when block
(F) You called C, but you're not inside a C
or C block.
=item can't convert empty path
(F) On Cygwin, you called a path conversion function with an empty path.
Only non-empty paths are legal.
=item Can't create pipe mailbox
(P) An error peculiar to VMS. The process is suffering from exhausted
quotas or other plumbing problems.
=item Can't declare %s in "%s"
(F) Only scalar, array, and hash variables may be declared as "my", "our" or
"state" variables. They must have ordinary identifiers as names.
=item Can't "default" outside a topicalizer
(F) You have used a C block that is neither inside a
C loop nor a C block. (Note that this error is
issued on exit from the C block, so you won't get the
error if you use an explicit C.)
=item Can't determine class of operator %s, assuming BASEOP
(S) This warning indicates something wrong in the internals of perl.
Perl was trying to find the class (e.g. LISTOP) of a particular OP,
and was unable to do so. This is likely to be due to a bug in the perl
internals, or due to a bug in XS code which manipulates perl optrees.
=item Can't do inplace edit: %s is not a regular file
(S inplace) You tried to use the B switch on a special file, such as
a file in /dev, a FIFO or an uneditable directory. The file was ignored.
=item Can't do inplace edit on %s: %s
(S inplace) The creation of the new file failed for the indicated
reason.
=item 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 B switch. The file was ignored.
=item Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".
(W locale) You are 1) running under "C"; 2) the current
locale is not a UTF-8 one; 3) you tried to do the designated case-change
operation on the specified Unicode character; and 4) the result of this
operation would mix Unicode and locale rules, which likely conflict.
Mixing of different rule types is forbidden, so the operation was not
done; instead the result is the indicated value, which is the best
available that uses entirely Unicode rules. That turns out to almost
always be the original character, unchanged.
It is generally a bad idea to mix non-UTF-8 locales and Unicode, and
this issue is one of the reasons why. This warning is raised when
Unicode rules would normally cause the result of this operation to
contain a character that is in the range specified by the locale,
0..255, and hence is subject to the locale's rules, not Unicode's.
If you are using locale purely for its characteristics related to things
like its numeric and time formatting (and not C), consider
using a restricted form of the locale pragma (see L) like "S>".
Note that failed case-changing operations done as a result of
case-insensitive C regular expression matching will show up in this
warning as having the C operation (as that is what the regular
expression engine calls behind the scenes.)
=item Can't do waitpid with flags
(F) This machine doesn't have either waitpid() or wait4(), so only
waitpid() without flags is emulated.
=item 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 B 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.
=item 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
C, 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.)
=item 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.
=item Can't execute %s
(F) You used the B switch, but the copies of the script to execute
found in the PATH did not have correct permissions.
=item Can't find an opnumber for "%s"
(F) A string of a form C<:word> was given to prototype(), but there
is no builtin with the name C.
=item 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 L.
=item Can't find %s on PATH
(F) You used the B switch, but the script to execute could not be
found in the PATH.
=item Can't find %s on PATH, '.' not in PATH
(F) You used the B 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.
=item 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 or there
may not be a linebreak after it. A good programmer's editor will have
a way to help you find these characters (or lack of characters). See
L for the full details on here-documents.
=item Can't find Unicode property definition "%s"
=item Can't find Unicode property definition "%s" in regex; marked by or C is not one
known to Perl. Perhaps you misspelled the name? See
L
for a complete list of available official
properties. If it is a
L
it must have been defined by the time the regular expression is
matched.
If you didn't mean to use a Unicode property, escape the C, either
by C (just the C) or by C (the rest of the string, or
until C).
=item Can't fork: %s
(F) A fatal error occurred while trying to fork while opening a
pipeline.
=item Can't fork, trying again in 5 seconds
(W pipe) A fork in a piped open failed with EAGAIN and will be retried
after five seconds.
=item 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 C 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.)
=item 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.
=item 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.
=item Can't "goto" into a binary or list expression
(F) A "goto" statement was executed to jump into the middle of a binary
or list expression. You can't get there from here. The reason for this
restriction is that the interpreter would get confused as to how many
arguments there are, resulting in stack corruption or crashes. This
error occurs in cases such as these:
goto F;
print do { F: }; # Can't jump into the arguments to print
goto G;
$x + do { G: $y }; # How is + supposed to get its first operand?
=item Can't "goto" into a "defer" block
(F) A C statement was executed to jump into the scope of a C
block. This is not permitted.
=item Can't "goto" into a "given" block
(F) A "goto" statement was executed to jump into the middle of a C
block. You can't get there from here. See L.
=item 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 L.
=item 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 L.
=item Can't goto subroutine from an eval-%s
(F) The "goto subroutine" call can't be used to jump out of an eval
"string" or block.
=item Can't goto subroutine from a sort sub (or similar callback)
(F) The "goto subroutine" call can't be used to jump out of the
comparison sub for a sort(), or from a similar callback (such
as the reduce() function in List::Util).
=item Can't goto subroutine 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 L.
=item 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.
=item Can't kill a non-numeric process ID
(F) Process identifiers must be (signed) integers. It is a fatal error to
attempt to kill() an undefined, empty-string or otherwise non-numeric
process identifier.
=item 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
L.
=item Can't linearize anonymous symbol table
(F) Perl tried to calculate the method resolution order (MRO) of a
package, but failed because the package stash has no name.
=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
lexical variable using "my" or "state". This is not allowed. If you
want to localize a package variable of the same name, qualify it with
the package name.
=item Can't localize through a reference
(F) You said something like C, 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.
=item Can't locate %s
(F) You said to C (or C, or C) a file that couldn't be found.
Perl looks for the file in all the locations mentioned in @INC, unless
the file name included the full path to the file. Perhaps you need
to set the PERL5LIB or PERL5OPT environment variable to say where the
extra library is, or maybe the script needs to add the library name
to @INC. Or maybe you just misspelled the name of the file. See
L and L.
=item 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 C
the file, say, by doing C.
=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, F or F, but the L module was
unable to locate this library. See L.
=item 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 L.
=item Can't locate object method "%s" via package "%s" (perhaps you forgot
to load "%s"?)
(F) You called a method on a class that did not exist, and the method
could not be found in UNIVERSAL. This often means that a method
requires a package that has not been loaded.
=item Can't locate object method "INC", nor "INCDIR" nor string overload via package "%s" %s in @INC
(F) You pushed an object, either directly or via an array reference hook,
into C, but the object doesn't support any known hook methods, nor
a string overload and is also not a blessed CODE reference. In short the
C function does not know what to do with the object.
See also L.
=item Attempt to call undefined %s method with arguments ("%s"%s)
via package "%s" (Perhaps you forgot to load the package?)
(D deprecated::missing_import_called_with_args) You called the
C or C method of a class that has no import method
defined in its inheritance graph, and passed an argument to the method.
This is very often the sign of a misspelled package name in a use or
require statement that has silently succeded due to a case insensitive
file system.
Another common reason this may happen is when mistakenly attempting to
import or unimport a symbol from a class definition or package which
does not use C or otherwise define its own C or
C method.
=item 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.
=item 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").
=item Can't make list assignment to %ENV on this system
(F) List assignment to %ENV is not supported on some systems, notably
VMS.
=item Can't make loaded symbols global on this platform while loading %s
(S) A module passed the flag 0x01 to DynaLoader::dl_load_file() to request
that symbols from the stated file are made available globally within the
process, but that functionality is not available on this platform. Whilst
the module likely will still work, this may prevent the perl interpreter
from loading other XS-based extensions which need to link directly to
functions defined in the C or XS code in the stated file.
=item Can't modify %s in %s
(F) You aren't allowed to assign to the item indicated, or otherwise try
to change it, such as with an auto-increment.
=item Can't modify non-lvalue subroutine call of &%s
=item Can't modify non-lvalue subroutine call of &%s in %s
(F) Subroutines meant to be used in lvalue context should be declared as
such. See L.
=item Can't modify reference to %s in %s assignment
(F) Only a limited number of constructs can be used as the argument to a
reference constructor on the left-hand side of an assignment, and what
you used was not one of them. See L.
=item Can't modify reference to localized parenthesized array in list
assignment
(F) Assigning to C or C is not supported, as
it is not clear exactly what it should do. If you meant to make @array
refer to some other array, use C. If you want to
make the elements of @array aliases of the scalars referenced on the
right-hand side, use C.
=item Can't modify reference to parenthesized hash in list assignment
(F) Assigning to C is not supported. If you meant to make %hash
refer to some other hash, use C. If you want to
make the elements of %hash into aliases of the scalars referenced on the
right-hand side, use a hash slice: C.
=item Can't msgrcv to read-only var
(F) The target of a msgrcv must be modifiable to be used as a receive
buffer.
=item 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 L.
=item Can't open %s: %s
(S inplace) The implicit opening of a file through use of the C >>
filehandle, either implicitly under the C or C command-line
switches, or explicitly, failed for the indicated reason. Usually
this is because you don't have read permission for a file which
you named on the command line.
(F) You tried to call perl with the B switch, but F (or
your operating system's equivalent) could not be opened.
=item 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.
=item Can't open bidirectional pipe
(W pipe) You tried to say C, 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.
=item 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.
=item 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 '' or '>>' on
the command line for writing.
=item 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.
=item Can't open perl script "%s": %s
(F) The script you specified can't be opened for the indicated reason.
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.
=item 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 F (see L) so that environ is not
searched.
=item Can't redeclare "%s" in "%s"
(F) A "my", "our" or "state" declaration was found within another declaration,
such as C or C.
=item 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 L.
=item 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.
=item Can't rename in-place work file '%s' to '%s': %s
(F) When closed implicitly, the temporary file for in-place editing
couldn't be renamed to the original filename.
=item Can't rename %s to %s: %s, skipping file
(F) The rename done by the B switch failed for some reason,
probably because you don't have write permission to the directory.
=item 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.
=item Can't represent character for Ox%X on this platform
(F) There is a hard limit to how big a character code point can be due
to the fundamental properties of UTF-8, especially on EBCDIC
platforms. The given code point exceeds that. The only work-around is
to not use such a large code point.
=item Can't reset %ENV on this system
(F) You called C or similar, which tried to reset
all variables in the current package beginning with "E". In
the main package, that includes %ENV. Resetting %ENV is not
supported on some systems, notably VMS.
=item Can't resolve method "%s" overloading "%s" in package "%s"
(F)(P) Error resolving overloading specified by a method name (as
opposed to a subroutine reference): no such method callable via the
package. If the method name is C??>, this is an internal error.
=item 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.
=item 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 L.
=item 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.
=item 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.
=item 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.
=item 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.
=item Can't unweaken a nonreference
(F) You attempted to unweaken something that was not a reference. Only
references can be unweakened.
=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 use '%c' after -mname
(F) You tried to call perl with the B switch, but you put something
other than "=" after the module name.
=item Can't use a hash as a reference
(F) You tried to use a hash as a reference, as in
C{"bar"} >> or C{"hello"} >>. Versions of perl
[23] >> or C[99] >>. Versions of perl .
=item 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.
=item 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 L.
=item Can't use %! because Errno.pm is not available
(F) The first time the C hash is used, perl automatically loads the
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 '' 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.
=item Can't use 'defined(@array)' (Maybe you should just omit the defined()?)
(F) defined() is not useful on arrays because it
checks for an undefined I value. If you want to see if the
array is empty, just use C for example.
=item Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)
(F) C is not usually right on hashes.
Although C is false on a plain not-yet-used hash, it
becomes true in several non-obvious circumstances, including iterators,
weak references, stash names, even remaining true after C.
These things make C fairly useless in practice, so it now
generates a fatal error.
If a check for non-empty is what you wanted then just put it in boolean
context (see L):
if (%hash) {
# not empty
}
If you had C to check whether such a package
variable exists then that's never really been reliable, and isn't
a good way to enquire about the features of a package, or whether
it's loaded, etc.
=item Can't use %s for loop variable
(P) The parser got confused when trying to parse a C loop.
=item Can't use global %s in %s
(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.
=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.
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.
=item 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.
=item Can't use string ("%s") as %s ref while "strict refs" in use
=item Can't use string ("%s"...) as %s ref while "strict refs" in use
(F) You've told Perl to dereference a string, something which
C blocks to prevent it happening accidentally. See
L. This can be triggered by an C or C
in a double-quoted string immediately before interpolating a variable,
for example in C, which says to treat the contents
of C as an array reference; use a C to have a literal C
symbol followed by the contents of C: C.
=item 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 a hash or array reference, or anything else subscriptable.
=item 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.
=item Can't weaken a nonreference
(F) You attempted to weaken something that was not a reference. Only
references can be weakened.
=item Can't "when" outside a topicalizer
(F) You have used a when() block that is neither inside a C
loop nor a C block. (Note that this error is issued on exit
from the C block, so you won't get the error if the match fails,
or if you use an explicit C.)
=item 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.
=item catch block requires a (VAR)
(F) You tried to use the C and C syntax of C
but did not include the error variable in the C block. The
parenthesized variable name is not optional, unlike in some other forms of
syntax you may be familiar with from CPAN modules or other languages.
The required syntax is
try { ... }
catch ($var) { ... }
=item Changing use VERSION while another use VERSION is in scope is now deprecated
(W deprecated) Once you have a C statement in scope, any
C statement that requests a different version is now deprecated,
due to the increasing complexity of swapping from one prevailing version to
another.
It is suggested that you do not try to mix multiple different version
declarations within the same file as it leads to complex behaviours about the
visibility of features and builtin functions, as well as confusing human
readers.
If it is essential to have different C declarations in different
regions of the same file, you should surround each one by its own enclosing
scope so the two do not mix.
{
use v5.20;
...
}
{
use v5.36;
...
}
=item Character following "\c" must be printable ASCII
(F) In C>, I must be a printable (non-control) ASCII character.
Note that ASCII characters that don't map to control characters are
discouraged, and will generate the warning (when enabled)
L""\c%c" is more clearly written simply as "%s"">.
=item Character following \%c must be '{' or a single-character Unicode property name in regex; marked by is replaced by either C or C
.) You
specified something that isn't a legal Unicode property name. Most
Unicode properties are specified by C. But if the name is a
single character one, the braces may be omitted.
=item 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 C format
instead.
=item 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 C 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 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-mode
expects all values to fall in the interval [0, 255], so Perl behaved
as if you meant:
pack("U0W", $x & 255)
=item Character(s) in '%c' format wrapped in pack
(W pack) You tried something like
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 charnames alias definitions may not contain a sequence of multiple
spaces; marked by S in %s
(F) You defined a character name which had multiple space characters
in a row. Change them to single spaces. Usually these names are
defined in the C<:alias> import argument to C, but they
could be defined by a translator installed into C. See
L.
=item chdir() on unopened filehandle %s
(W unopened) You tried chdir() on a filehandle that was never opened.
=item "\c%c" is more clearly written simply as "%s"
(W syntax) The C> construct is intended to be a way to specify
non-printable characters. You used it for a printable one, which
is better written as simply itself, perhaps preceded by a backslash
for non-word characters. Doing it the way you did is not portable
between ASCII and EBCDIC platforms.
=item Class already has a superclass, cannot add another
(F) You attempted to specify a second superclass for a C by using
the C<:isa> attribute, when one is already specified. Unlike classes
whose instances are created with C, classes created via the
C keyword cannot have more than one superclass.
=item Class attribute %s requires a value
(F) You specified an attribute for a class that would require a value to
be passed in parentheses, but did not provide one. Remember that
whitespace is B permitted between the attribute name and its value;
you must write this as
class Example::Class :attr(VALUE) ...
=item class is experimental
(S experimental::class) This warning is emitted if you use the C
keyword of C. This keyword is currently
experimental and its behaviour may change in future releases of Perl.
=item Class :isa attribute requires a class but "%s" is not one
(F) When creating a subclass using the C C<:isa> attribute, the
named superclass must also be a real class created using the C
keyword.
=item Cloning substitution context is unimplemented
(F) Creating a new thread inside the C.
=item Code point 0x%X is not Unicode, and not portable
(S non_unicode portable) You had a code point that has never been in any
standard, so it is likely that languages other than Perl will NOT
understand it. This code point also will not fit in a 32-bit word on
ASCII platforms and therefore is non-portable between systems.
At one time, it was legal in some standards to have code points up to
0x7FFF_FFFF, but not higher, and this code point is higher.
Acceptance of these code points is a Perl extension, and you should
expect that nothing other than Perl can handle them; Perl itself on
EBCDIC platforms before v5.24 does not handle them.
Perl also makes no guarantees that the representation of these code
points won't change at some point in the future, say when machines
become available that have larger than a 64-bit word. At that time,
files containing any of these, written by an older Perl might require
conversion before being readable by a newer Perl.
=item Code point 0x%X is not Unicode, may not be portable
(S non_unicode) You had a code point above the Unicode maximum
of U+10FFFF.
Perl allows strings to contain a superset of Unicode code points, but
these may not be accepted by other languages/systems. Further, even if
these languages/systems accept these large code points, they may have
chosen a different representation for them than the UTF-8-like one that
Perl has, which would mean files are not exchangeable between them and
Perl.
On EBCDIC platforms, code points above 0x3FFF_FFFF have a different
representation in Perl v5.24 than before, so any file containing these
that was written before that version will require conversion before
being readable by a later Perl.
=item %s: Command not found
(A) You've accidentally run your script through B or another shell
instead of Perl. Check the #! line, or manually feed your script into
Perl yourself. The #! line at the top of your file could look like
#!/usr/bin/perl
=item %s: command not found
(A) You've accidentally run your script through B or another shell
instead of Perl. Check the #! line, or manually feed your script into
Perl yourself. The #! line at the top of your file could look like
#!/usr/bin/perl
=item %s: command not found: %s
(A) You've accidentally run your script through B or another shell
instead of Perl. Check the #! line, or manually feed your script into
Perl yourself. The #! line at the top of your file could look like
#!/usr/bin/perl
=item Compilation failed in require
(F) Perl could not compile a file specified in a C statement.
Perl uses this generic message when none of the errors that it
encountered were severe enough to halt compilation immediately.
=item 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
L.
=item Constant(%s): Call to &{$^H{%s}} did not return a defined value
(F) The subroutine registered to handle constant overloading
(see L) or a custom charnames handler (see
L) returned an undefined value.
=item Constant(%s): $^H{%s} is not defined
(F) The parser found inconsistencies while attempting to define an
overloaded constant. Perhaps you forgot to load the corresponding
L pragma?
=item Constant is not %s reference
(F) A constant value (perhaps declared using the C 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 L and L.
=item Constants from lexical variables potentially modified elsewhere are no longer permitted
(F) You wrote something like
my $var;
$sub = sub () { $var };
but $var is referenced elsewhere and could be modified after the C
expression is evaluated. Either it is explicitly modified elsewhere
(C) or it is passed to a subroutine or to an operator like
C or C, which may or may not modify the variable.
Traditionally, Perl has captured the value of the variable at that
point and turned the subroutine into a constant eligible for inlining.
In those cases where the variable can be modified elsewhere, this
breaks the behavior of closures, in which the subroutine captures
the variable itself, rather than its value, so future changes to the
variable are reflected in the subroutine's return value.
This usage was deprecated, and as of Perl 5.32 is no longer allowed,
making it possible to change the behavior in the future.
If you intended for the subroutine to be eligible for inlining, then
make sure the variable is not referenced elsewhere, possibly by
copying it:
my $var2 = $var;
$sub = sub () { $var2 };
If you do want this subroutine to be a closure that reflects future
changes to the variable that it closes over, add an explicit C:
my $var;
$sub = sub () { return $var };
=item Constant subroutine %s redefined
(W redefine)(S) You redefined a subroutine which had previously
been eligible for inlining. See L
for commentary and workarounds.
=item Constant subroutine %s undefined
(W misc) You undefined a subroutine which had previously been eligible
for inlining. See L for commentary and
workarounds.
=item Constant(%s) unknown
(F) The parser found inconsistencies either while attempting
to define an overloaded constant, or when trying to find the
character name specified in the C escape. Perhaps you
forgot to load the corresponding L pragma?
=item :const is not permitted on named subroutines
(F) The "const" attribute causes an anonymous subroutine to be run and
its value captured at the time that it is cloned. Named subroutines are
not cloned like this, so the attribute does not make sense on them.
=item Copy method did not return a reference
(F) The method which overloads "=" is buggy. See
L.
=item &CORE::%s cannot be called directly
(F) You tried to call a subroutine in the C<:> namespace
with C syntax or through a reference. Some subroutines
in this package cannot yet be called that way, but must be
called as barewords. Something like this will work:
BEGIN { *shove = \&CORE::push; }
shove @array, 1,2,3; # pushes on to @array
=item CORE::%s is not a keyword
(F) The CORE:: namespace is reserved for Perl keywords.
=item Corrupted regexp opcode %d > %d
(P) This is either an error in Perl, or, if you're using
one, your L. If not the
latter, report the problem to L.
=item corrupted regexp pointers
(P) The regular expression engine got confused by what the regular
expression compiler gave it.
=item corrupted regexp program
(P) The regular expression engine got passed a regexp program without a
valid magic number.
=item Corrupt malloc ptr 0x%x at 0x%x
(P) The malloc package that comes with Perl had an internal failure.
=item Count after length/code in unpack
(F) You had an unpack template indicating a counted-length string, but
you have also specified an explicit size for the string. See
L.
=item Declaring references is experimental
(S experimental::declared_refs) This warning is emitted if you use
a reference constructor on the right-hand side of C, C, C, or
C. Simply suppress the warning if you want to use the feature, but
know that in doing so you are taking the risk of using an experimental
feature which may change or be removed in a future Perl version:
no warnings "experimental::declared_refs";
use feature "declared_refs";
$fooref = my \$foo;
=for comment
The following are used in lib/diagnostics.t for testing two =items that
share the same description. Changes here need to be propagated to there
=item Deep recursion on anonymous subroutine
=item 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.
This threshold can be changed from 100, by recompiling the F binary,
setting the C pre-processor macro C to the desired value.
=item (?(DEFINE)....) does not allow branches in regex; marked by
S in m/%s/
(F) You used something like C which is illegal. The
most likely cause of this error is that you left out a parenthesis inside
of the C<....> part.
The S shows whereabouts in the regular expression the problem was
discovered.
=item %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 C.
=item delete argument is not a HASH or ARRAY element or slice
(F) The argument to C 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"}
or a hash key/value or array index/value slice, such as:
%foo[$bar, $baz, $xyzzy]
$ref->[12]->%{"susie", "queue"}
=item Delimiter for here document is too long
(F) In a here document construct like C, the label C is too
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
=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 L500 Server error>.
=item %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 L.
=item (Did you mean &%s instead?)
(W misc) You probably referred to an imported subroutine &FOO as $FOO or
some such.
=item (Did you mean "local" instead of "our"?)
(W shadow) Remember that "our" does not localize the declared global
variable. You have declared it again in the same lexical scope, which
seems superfluous.
=item (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.
=item Died
(F) You passed die() an empty string (the equivalent of C) or
you called it with no args and C was empty.
=item Document contains no data
See L500 Server error>.
=item %s does not define %s::VERSION--version check failed
(F) You said something like "use Module 42" but the Module did not
define a C.
=item '/' does not take a repeat count in %s
(F) You cannot put a repeat count of any kind right after the '/' code.
See L.
=item do "%s" failed, '.' is no longer in @INC; did you mean do "./%s"?
(D deprecated::dot_in_inc) Previously C would search
the current directory for the specified file. Since perl v5.26.0, F<.>
has been removed from C by default, so this is no longer true. To
search the current directory (and only the current directory) you can
write C.
=item '%s' does not appear to be an imported builtin function
(F) An attempt was made to remove a previously-imported lexical from
L by using the C method (likely via C
syntax), but the requested function has not been imported into the current
scope.
=item Don't know how to get file name
(P) C, a perl internal I/O function specific to VMS, was
somehow called on another platform. This should not happen.
=item Don't know how to handle magic of type \%o
(P) The internal handling of magical variables has been cursed.
=item Downgrading a use VERSION declaration to below v5.11 is not permitted
(F) A C statement that requests a version below v5.11
(when the effects of C would be disabled) has been found
after a previous declaration of one having a larger number (which would
have enabled these effects). Because of a change to the way that
C interacts with the strictness flags, this is no longer
supported.
=item (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.
=item dump() must be written as CORE::dump() as of Perl 5.30
(F) You used the obsolete C built-in function. That was deprecated in
Perl 5.8.0. As of Perl 5.30 it must be written in fully qualified format:
C<:dump>.
See L.
=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 unpack) You have applied the same modifier more than once after a
type in a pack template. See L.
=item each on anonymous %s will always start from the beginning
(W syntax) You called L on an anonymous hash or
array. Since a new hash or array is created each time, each() will
restart iterating over your hash or array every time.
=item elseif should be elsif
(S syntax) There is no keyword "elseif" in Perl because Larry thinks
it's ugly. Your code will be interpreted as an attempt to call a method
named "elseif" for the class returned by the following block. This is
unlikely to be what you want.
=item Empty \%c in regex; marked by S in m/%s/
=item Empty \%c{}
=item Empty \%c{} in regex; marked by S in m/%s/
(F) You used something like C, C, C, C, C, or
C without specifying anything for it to operate on.
Unfortunately, for backwards compatibility reasons, an empty C is
legal outside S> and expands to a NUL character.
=item Empty (?) without any modifiers in regex; marked by >)
C does nothing, so perhaps this is a typo.
=item ${^ENCODING} is no longer supported
(F) The special variable C, formerly used to implement
the C pragma, is no longer supported as of Perl 5.26.0.
Setting it to anything other than C is a fatal error as of Perl
5.28.
=item ${^HOOK}{%s} may only be a CODE reference or undef
(F) You attempted to assign something other than undef or a CODE ref to
C. Hooks may only be CODE refs. See L for
details.
=item Attempt to set unknown hook '%s' in %{^HOOK}
(F) You attempted to assign something other than undef or a CODE ref to
C. Hooks may only be CODE refs. See L for
details.
=item entering effective %s failed
(F) While under the C 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 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
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.
=item error creating/fetching widecharmap entry for 0x%X
(P) A failure happened when folding a character for a regex trie.
=item Error %s in expansion of %s
(F) An error was encountered in handling a user-defined property
(L). These are
programmer written subroutines, hence subject to errors that may
prevent them from compiling or running. The calls to these subs are
C'd, and if there is a failure, this message is raised, using the
contents of C from the failed C.
Another possibility is that tainted data was encountered somewhere in
the chain of expanding the property. If so, the message wording will
indicate that this is the problem. See L.
=item Eval-group in insecure regular expression
(F) Perl detected tainted data when trying to compile a regular
expression that contains the C zero-width assertion, which
is unsafe. See L, and L.
=item Eval-group not allowed at runtime, use re 'eval' in regex m/%s/
(F) Perl tried to compile a regular expression containing the
C zero-width assertion at run time, as it would when the
pattern contains interpolated values. Since that is a security risk,
it is not allowed. If you insist, you may still do this by using the
C pragma or by explicitly building the pattern from an
interpolated string at run time and using that in an eval(). See
L.
=item Eval-group not allowed, use re 'eval' in regex m/%s/
(F) A regular expression contained the C zero-width
assertion, but that construct is only allowed when the C
pragma is in effect. See L.
=item EVAL without pos change exceeded limit in regex; marked by
S in m/%s/
(F) You used a pattern that nested too many EVAL calls without consuming
any text. Restructure the pattern so that text is consumed.
The S shows whereabouts in the regular expression the problem was
discovered.
=item Excessively long operator
(F) The contents of a operator may not exceed the maximum size of a
Perl identifier. If you're just trying to glob a long list of
filenames, try using the glob() operator, or put the filenames into a
variable and glob that.
=item exec? I'm not *that* kind of operating system
(F) The C function is not implemented on some systems, e.g.
Catamount. See L.
=item %sExecution of %s aborted due to compilation errors.
(F) The final summary message when a Perl compilation fails.
=item Execution of %s aborted due to compilation errors.
(F) The final summary message when a Perl compilation fails.
=item exists argument is not a HASH or ARRAY element or a subroutine
(F) The argument to C must be a hash or array element or a
subroutine with an ampersand, such as:
$foo{$bar}
$ref->{"susie"}[12]
&do_something
=item exists argument is not a subroutine name
(F) The argument to C for C must be a subroutine name,
and not a subroutine call. C will generate this error.
=item Exiting eval via %s
(W exiting) You are exiting an eval by unconventional means, such as a
goto, or a loop control statement.
=item Exiting format via %s
(W exiting) You are exiting a format by unconventional means, such as a
goto, or a loop control statement.
=item Exiting pseudo-block via %s
(W exiting) You are exiting a rather special block construct (like a
sort block or subroutine) by unconventional means, such as a goto, or a
loop control statement. See L.
=item Exiting subroutine via %s
(W exiting) You are exiting a subroutine by unconventional means, such
as a goto, or a loop control statement.
=item Exiting substitution via %s
(W exiting) You are exiting a substitution by unconventional means, such
as a return, a goto, or a loop control statement.
=item Expected %s reference in export_lexically
(F) The type of a reference given to L did not
match the sigil of the preceding name, or the value was not a reference at
all.
=item Expecting close bracket in regex; marked by S in m/%s/
(F) You wrote something like
(?13
to denote a capturing group of the form
L)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>,
but omitted the C.
=item Expecting interpolated extended charclass in regex; marked by , C,
C, C, C, C, C, and C to be called with a
scalar argument. This experiment is considered unsuccessful, and
has been removed. The C feature may meet your needs better.
=item Experimental subroutine signatures not enabled
(F) To use subroutine signatures, you must first enable them:
use feature "signatures";
sub foo ($left, $right) { ... }
=item Explicit blessing to '' (assuming package main)
(W misc) You are blessing a reference to a zero length string. This has
the effect of blessing the reference into the package main. This is
usually not what you want. Consider providing a default target package,
e.g. bless($ref, $p || 'MyPackage');
=item export_lexically can only be called at compile time
(F) L was called at runtime. Because it creates
new names in the lexical scope currently being compiled, it can only be
called from code inside C block in that scope.
=item %s: Expression syntax
(A) You've accidentally run your script through B instead of Perl.
Check the #! line, or manually feed your script into Perl yourself.
=item %s failed--call queue aborted
(F) An untrapped exception was raised while executing a UNITCHECK,
CHECK, INIT, or END subroutine. Processing of the remainder of the
queue of such routines has been prematurely ended.
=item Failed to close in-place work file %s: %s
(F) Closing an output file from in-place editing, as with the C
command-line switch, failed.
=item Failed to create a fake bit bucket
(F) You tried to call perl with the B switch, but you're on a Cray system
and perl's F emulation was unable to create an empty temporary file.
=item False [] range "%s" in regex; marked by S in m/%s/
(W regexp)(F) A character class range must start and end at a literal
character, not another character class like C or C. The "-"
in your false range is interpreted as a literal "-". In a C
construct, this is an error, rather than a warning. Consider escaping
the "-" as "\-". The S shows whereabouts in the regular expression
the problem was discovered. See L.
=item Fatal VMS error (status=%d) at %s, line %d
(P) An error peculiar to VMS. Something untoward happened in a VMS
system service or RTL routine; Perl's exit status should provide more
details. The filename in "at %s" and the line number in "line %d" tell
you which section of the Perl source code is distressed.
=item fcntl is not implemented
(F) Your machine apparently doesn't implement fcntl(). What is this, a
PDP-11 or something?
=item FETCHSIZE returned a negative value
(F) A tied array claimed to have a negative number of elements, which
is not possible.
=item Field already has a parameter name, cannot add another
(F) A field may have at most one application of the C<:param> attribute to
assign a parameter name to it; once applied a second one is not allowed.
=item Field attribute %s requires a value
(F) You specified an attribute for a field that would require a value to
be passed in parentheses, but did not provide one. Remember that
whitespace is B permitted between the attribute name and its value;
you must write this as
field $var :attr(VALUE) ...
=item field is experimental
(S experimental::class) This warning is emitted if you use the C
keyword of C. This keyword is currently
experimental and its behaviour may change in future releases of Perl.
=item Field %s is not accessible outside a method
(F) An attempt was made to access a field variable of a class from code
that does not appear inside the body of a C subroutine. This is not
permitted, as only methods will have access to the fields of an instance.
=item Field %s of "%s" is not accessible in a method of "%s"
(F) An attempt was made to access a field variable of a class, from a
method of another class nested inside the one that actually defined it.
This is not permitted, as only methods defined by a given class are
permitted to access fields of that class.
=item Field too wide in 'u' format in pack
(W pack) Each line in an uuencoded string starts with a length indicator
which can't encode values above 63. So there is no point in asking for
a line length bigger than that. Perl will behave as if you specified
C as the format.
=item Filehandle %s opened only for input
(W io) You tried to write on a read-only filehandle. If you intended
it to be a read-write filehandle, you needed to open it with "+" or "+>>" instead of with "" or ">>". See L.
=item Filehandle %s opened only for output
(W io) You tried to read from a filehandle opened only for writing, If
you intended it to be a read/write filehandle, you needed to open it
with "+" or "+>>" instead of with ">". If you intended only to
read from the file, use ". Another possibility
is that you attempted to open filedescriptor 0 (also known as STDIN) for
output (maybe you closed STDIN earlier?).
=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 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 occurred because you closed STDIN previously.
=item Filehandle STD%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 occurred because you closed the handle previously.
=item Final $ should be \$ or $name
(F) You must now decide whether the final $ in a string was meant to be
a literal dollar sign, or was meant to introduce a variable name that
happens to be missing. So you have to put either the backslash or the
name.
=item defer is experimental
(S experimental::defer) The C block modifier is experimental. If you
want to use the feature, disable the warning with
C, but know that in doing so you are taking
the risk that your code may break in a future Perl version.
=item flock() on closed filehandle %s
(W closed) The filehandle you're attempting to flock() got itself closed
some time before now. Check your control flow. flock() operates on
filehandles. Are you attempting to call flock() on a dirhandle by the
same name?
=item Forked open '%s' not meaningful in
(S inplace) You had C or C in C and tried to use C
>> to read from it.
Previously this would fork and produce a confusing error message.
=item Format not terminated
(F) A format must be terminated by a line with a solitary dot. Perl got
to the end of your file without finding such a line.
=item Format %s redefined
(W redefine) You redefined a format. To suppress this warning, say
{
no warnings 'redefine';
eval "format NAME =...";
}
=item Found = in conditional, should be ==
(W syntax) You said
if ($foo = 123)
when you meant
if ($foo == 123)
(or something like that).
=item %s found where operator expected
(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.
=item gdbm store returned %d, errno %d, key "%s"
(S) A warning from the GDBM_File extension that a store failed.
=item gethostent not implemented
(F) Your C library apparently doesn't implement gethostent(), probably
because if it did, it'd feel morally obligated to return every hostname
on the Internet.
=item get%sname() on closed socket %s
(W closed) You tried to get a socket or peer socket name on a closed
socket. Did you forget to check the return value of your socket() call?
=item getpwnam returned invalid UIC %#o for user "%s"
(S) A warning peculiar to VMS. The call to C underlying the
C operator returned an invalid UIC.
=item getsockopt() on closed socket %s
(W closed) You tried to get a socket option on a closed socket. Did you
forget to check the return value of your socket() call? See
L.
=item get_layers: unknown argument '%s'
(F) You called PerlIO::get_layers() with an unknown argument. Legal
arguments are provided in key/value pairs, with the keys being one
of C or C, followed by a boolean.
=item Global symbol "%s" requires explicit package name (did you forget to
declare "my %s"?)
(F) You've said "use strict" or "use strict vars", which indicates
that all variables must either be lexically scoped (using "my" or "state"),
declared beforehand using "our", or explicitly qualified to say
which package the global variable is in (using "::").
=item glob failed (%s)
(S glob) Something went wrong with the external program(s) used
for C and C >>. Usually, this means that you supplied a C
pattern that caused the external program to fail and exit with a
nonzero status. If the message indicates that the abnormal exit
resulted in a coredump, this may also mean that your csh (C shell)
is broken. If so, you should change all of the csh-related variables
in config.sh: If you have tcsh, make the variables refer to it as
if it were csh (e.g. C); otherwise, make them
all empty (except that C should be C) so that Perl will
think csh is missing. In either case, after editing config.sh, run
C<.> and rebuild Perl.
=item Glob not terminated
(F) The lexer saw a left angle bracket in a place where it was expecting
a term, so it's looking for the corresponding right angle bracket, and
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
=item gmtime(%f) failed
(W overflow) You called C with a number that it could not handle:
too large, too small, or NaN. The returned value is C.
=item gmtime(%f) too large
(W overflow) You called C with a number that was larger than
it can reliably handle and C probably returned the wrong
date. This warning is also triggered with NaN (the special
not-a-number value).
=item gmtime(%f) too small
(W overflow) You called C with a number that was smaller than
it can reliably handle and C probably returned the wrong date.
=item Got an error from DosAllocMem
(P) An error peculiar to OS/2. Most probably you're using an obsolete
version of Perl, and this should not happen anyway.
=item goto must have label
(F) Unlike with "next" or "last", you're not allowed to goto an
unspecified destination. See L.
=item Goto undefined subroutine%s
(F) You tried to call a subroutine with C syntax, but
the indicated subroutine hasn't been defined, or if it was, it
has since been undefined.
=item Group name must start with a non-digit word character in regex; marked by
S in m/%s/
(F) Group names must follow the rules for perl identifiers, meaning
they must start with a non-digit word character. A common cause of
this error is using (?&0) instead of (?0). See L.
=item ()-group starts with a count
(F) A ()-group started with a count. A count is supposed to follow
something: a template character or a ()-group. See L.
=item %s had compilation errors.
(F) The final summary message when a C fails.
=item Had to create %s unexpectedly
(S internal) A routine asked for a symbol from a symbol table that ought
to have existed already, but for some reason it didn't, and had to be
created on an emergency basis to prevent a core dump.
=item %s has too many errors
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
=item Hexadecimal float: exponent overflow
(W overflow) The hexadecimal floating point has a larger exponent
than the floating point supports.
=item Hexadecimal float: exponent underflow
(W overflow) The hexadecimal floating point has a smaller exponent
than the floating point supports. With the IEEE 754 floating point,
this may also mean that the subnormals (formerly known as denormals)
are being used, which may or may not be an error.
=item Hexadecimal float: internal error (%s)
(F) Something went horribly bad in hexadecimal float handling.
=item Hexadecimal float: mantissa overflow
(W overflow) The hexadecimal floating point literal had more bits in
the mantissa (the part between the 0x and the exponent, also known as
the fraction or the significand) than the floating point supports.
=item Hexadecimal float: precision loss
(W overflow) The hexadecimal floating point had internally more
digits than could be output. This can be caused by unsupported
long double formats, or by 64-bit integers not being available
(needed to retrieve the digits under some configurations).
=item Hexadecimal float: unsupported long double format
(F) You have configured Perl to use long doubles but
the internals of the long double format are unknown;
therefore the hexadecimal float output is impossible.
=item Hexadecimal number > 0xffffffff non-portable
(W portable) The hexadecimal number you specified is larger than 2**32-1
(4294967295) and therefore non-portable between systems. See
L for more on portability concerns.
=item Identifier too long
(F) Perl limits identifiers (names for variables, functions, etc.) to
about 250 characters for simple names, and somewhat more for compound
names (like C). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
=item Ignoring zero length \N{} in character class in regex; marked by
S in m/%s/
(W regexp) Named Unicode character escapes (C) may return a
zero-length sequence. When such an escape is used in a character
class its behavior is not well defined. Check that the correct
escape has been used, and the correct charname handler is in scope.
=item Illegal %s digit '%c' ignored
(W digit) Here C is one of "binary", "octal", or "hex".
You may have tried to use a digit other than one that is legal for the
given type, such as only 0 and 1 for binary. For octals, this is raised
only if the illegal character is an '8' or '9'. For hex, 'A' - 'F' and
'a' - 'f' are legal.
Interpretation of the number stopped just before the offending digit or
character.
=item Illegal binary digit '%c'
(F) You used a digit other than 0 or 1 in a binary number.
=item Illegal character after '_' in prototype for %s : %s
(W illegalproto) An illegal character was found in a prototype
declaration. The '_' in a prototype must be followed by a ';',
indicating the rest of the parameters are optional, or one of '@'
or '%', since those two will accept 0 or more final parameters.
=item Illegal character following sigil in a subroutine signature
(F) A parameter in a subroutine signature contained an unexpected character
following the C, C or C sigil character. Normally the sigil
should be followed by the variable name or C etc. Perhaps you are
trying to use a prototype while in the scope of C?
For example:
sub foo ($$) {} # legal - a prototype
use feature 'signatures;
sub foo ($$) {} # illegal - was expecting a signature
sub foo ($x, $y)
:prototype($$) {} # legal
=item Illegal character in prototype for %s : %s
(W illegalproto) An illegal character was found in a prototype declaration.
Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
Perhaps you were trying to write a subroutine signature but didn't enable
that feature first (C), so your signature was
instead interpreted as a bad prototype.
=item Illegal declaration of anonymous subroutine
(F) When using the C keyword to construct an anonymous subroutine,
you must always specify a block of code. See L.
=item Illegal declaration of subroutine %s
(F) A subroutine was not declared correctly. See L.
=item Illegal division by zero
(F) You tried to divide a number by 0. Either something was wrong in
your logic, or you need to put a conditional in to guard against
meaningless input.
=item Illegal modulus zero
(F) You tried to divide a number by 0 to get the remainder. Most
numbers don't take to this kindly.
=item Illegal number of bits in vec
(F) The number of bits in vec() (the third argument) must be a power of
two from 1 to 32 (or 64, if your platform supports that).
=item Illegal octal digit '%c'
(F) You used an 8 or 9 in an octal number.
=item Illegal operator following parameter in a subroutine signature
(F) A parameter in a subroutine signature, was followed by something
other than C introducing a default, C or C.
use feature 'signatures';
sub foo ($=1) {} # legal
sub foo ($x = 1) {} # legal
sub foo ($x += 1) {} # illegal
sub foo ($x == 1) {} # illegal
=item Illegal pattern in regex; marked by S in m/%s/
(F) You wrote something like
(?+foo)
The C is valid only when followed by digits, indicating a
capturing group. See
L)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>.
=item Illegal suidscript
(F) The script run under suidperl was somehow illegal.
=item Illegal switch in PERL5OPT: -%c
(X) The PERL5OPT environment variable may only be used to set the
following switches: B.
=item Illegal user-defined property name
(F) You specified a Unicode-like property name in a regular expression
pattern (using C or C) that Perl knows isn't an official
Unicode property, and was likely meant to be a user-defined property
name, but it can't be one of those, as they must begin with either C
or C. Check the spelling. See also
L.
=item Ill-formed CRTL environ value "%s"
(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's
internal environ array, and encountered an element without the C
delimiter used to separate keys from values. The element is ignored.
=item Ill-formed message in prime_env_iter: |%s|
(W internal) A warning peculiar to VMS. Perl tried to read a logical
name or CLI symbol definition when preparing to iterate over %ENV, and
didn't see the expected delimiter between key and value, so the line was
ignored.
=item (in cleanup) %s
(W misc) This prefix usually indicates that a DESTROY() method raised
the indicated exception. Since destructors are usually called by the
system at arbitrary points during execution, and often a vast number of
times, the warning is issued only once for any number of failures that
would otherwise result in the same message being repeated.
Failure of user callbacks dispatched using the C flag could
also result in this warning. See L.
=item Implicit use of @_ in %s with signatured subroutine is experimental
(S experimental::args_array_with_signatures) An expression that implicitly
involves the C arguments array was found in a subroutine that uses a
signature. This is experimental because the interaction between the
arguments array and parameter handling via signatures is not guaranteed
to remain stable in any future version of Perl, and such code should be
avoided.
=item Incomplete expression within '(?[ ])' in regex; marked by S
in m/%s/
(F) There was a syntax error within the C. This can happen if the
expression inside the construct was completely empty, or if there are
too many or few operands for the number of operators. Perl is not smart
enough to give you a more precise indication as to what is wrong.
=item Inconsistent hierarchy during C3 merge of class '%s': merging failed on
parent '%s'
(F) The method resolution order (MRO) of the given class is not
C3-consistent, and you have enabled the C3 MRO for this class. See the C3
documentation in L for more information.
=item Indentation on line %d of here-doc doesn't match delimiter
(F) You have an indented here-document where one or more of its lines
have whitespace at the beginning that does not match the closing
delimiter.
For example, line 2 below is wrong because it does not have at least
2 spaces, but lines 1 and 3 are fine because they have at least 2:
if ($something) {
print ) can depend on the definitions of other user-defined
properties. If the chain of dependencies leads back to this property,
infinite recursion would occur, were it not for the check that raised
this error.
Restructure your property definitions to avoid this.
=item Infinite recursion via empty pattern
(F) You tried to use the empty pattern inside of a regex code block,
for instance C(?{ s!!! })/>, which resulted in re-executing
the same pattern, which is an infinite loop which is broken by
throwing an exception.
=item Initialization of state variables in list currently forbidden
(F) C only permits initializing a single variable, specified
without parentheses. So C and C are
allowed, but not C or C. To initialize
more than one C variable, initialize them one at a time.
=item %%s[%s] in scalar context better written as $%s[%s]
(W syntax) In scalar context, you've used an array index/value slice
(indicated by %) to select a single element of an array. Generally
it's better to ask for a scalar value (indicated by $). The difference
is that C always behaves like a scalar, both in the value it
returns and when evaluating its argument, while C provides
a list context to its subscript, which can do weird things if you're
expecting only one subscript. When called in list context, it also
returns the index (what C returns) in addition to the value.
=item %%s{%s} in scalar context better written as $%s{%s}
(W syntax) In scalar context, you've used a hash key/value slice
(indicated by %) to select a single element of a hash. Generally it's
better to ask for a scalar value (indicated by $). The difference
is that C always behaves like a scalar, both in the value
it returns and when evaluating its argument, while C and
provides a list context to its subscript, which can do weird things
if you're expecting only one subscript. When called in list context,
it also returns the key in addition to the value.
=item Insecure dependency in %s
(F) You tried to do something that the tainting mechanism didn't like.
The tainting mechanism is turned on when you're running setuid or
setgid, or when you specify B to turn it on explicitly. The
tainting mechanism labels all data that's derived directly or indirectly
from the user, who is considered to be unworthy of your trust. If any
such data is used in a "dangerous" operation, you get this error. See
L