- Malformed integer in [] in unpack
- (F) Between the brackets enclosing a numeric repeat count only digits are
permitted. See "pack" in perlfunc.
- Malformed PERLLIB_PREFIX
- (F) An error peculiar to OS/2. PERLLIB_PREFIX should be of the form
prefix1;prefix2
or
prefix1 prefix2
with nonempty prefix1 and prefix2. If
"prefix1" is indeed a prefix of a
builtin library search path, prefix2 is substituted. The error may
appear if components are not found, or are too long. See
"PERLLIB_PREFIX" in perlos2.
- Malformed prototype for %s: %s
- (F) You tried to use a function with a malformed prototype. The syntax of
function prototypes is given a brief compile-time check for obvious errors
like invalid characters. A more rigorous check is run when the function is
called. Perhaps the function's author was trying to write a subroutine
signature but didn't enable that feature first ("use
feature 'signatures'"), so the signature was instead
interpreted as a bad prototype.
- Malformed UTF-8 character%s
- (S utf8)(F) Perl detected a string that should be UTF-8, but didn't comply
with UTF-8 encoding rules, or represents a code point whose ordinal
integer value doesn't fit into the word size of the current platform
(overflows). Details as to the exact malformation are given in the
variable, %s, part of the message.
One possible cause is that you set the UTF8 flag yourself for
data that you thought to be in UTF-8 but it wasn't (it was for example
legacy 8-bit data). To guard against this, you can use
"Encode::decode('UTF-8', ...)".
If you use the
":encoding(UTF-8)" PerlIO layer for
input, invalid byte sequences are handled gracefully, but if you use
":utf8", the flag is set without
validating the data, possibly resulting in this error message.
See also "Handling Malformed Data" in Encode.
- Malformed UTF-8 returned by \N{%s} immediately after '%s'
- (F) The charnames handler returned malformed UTF-8.
- Malformed UTF-8 string in "%s"
- (F) This message indicates a bug either in the Perl core or in XS code.
Such code was trying to find out if a character, allegedly stored
internally encoded as UTF-8, was of a given type, such as being
punctuation or a digit. But the character was not encoded in legal UTF-8.
The %s is replaced by a string that can be used by
knowledgeable people to determine what the type being checked against was.
Passing malformed strings was deprecated in Perl 5.18, and
became fatal in Perl 5.26.
- Malformed UTF-8 string in '%c' format in unpack
- (F) You tried to unpack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
- Malformed UTF-8 string in pack
- (F) You tried to pack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
- Malformed UTF-8 string in unpack
- (F) You tried to unpack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
- Malformed UTF-16 surrogate
- (F) Perl thought it was reading UTF-16 encoded character data but while
doing it Perl met a malformed Unicode surrogate.
- Mandatory parameter follows optional parameter
- (F) In a subroutine signature, you wrote something like "$a = undef,
$b", making an earlier parameter optional and
a later one mandatory. Parameters are filled from left to right, so it's
impossible for the caller to omit an earlier one and pass a later one. If
you want to act as if the parameters are filled from right to left,
declare the rightmost optional and then shuffle the parameters around in
the subroutine's body.
- Matched non-Unicode code point 0x%X against Unicode property; may not be
portable
- (S non_unicode) Perl allows strings to contain a superset of Unicode code
points; each code point may be as large as what is storable in a signed
integer on your system, but these may not be accepted by other
languages/systems. This message occurs when you matched a string
containing such a code point against a regular expression pattern, and the
code point was matched against a Unicode property,
"\p{...}" or
"\P{...}". Unicode properties are only
defined on Unicode code points, so the result of this match is undefined
by Unicode, but Perl (starting in v5.20) treats non-Unicode code points as
if they were typical unassigned Unicode ones, and matched this one
accordingly. Whether a given property matches these code points or not is
specified in "Properties accessible through \p{} and \P{}" in
perluniprops.
This message is suppressed (unless it has been made fatal) if
it is immaterial to the results of the match if the code point is
Unicode or not. For example, the property
"\p{ASCII_Hex_Digit}" only can match
the 22 characters "[0-9A-Fa-f]", so
obviously all other code points, Unicode or not, won't match it. (And
"\P{ASCII_Hex_Digit}" will match every
code point except these 22.)
Getting this message indicates that the outcome of the match
arguably should have been the opposite of what actually happened. If you
think that is the case, you may wish to make the
"non_unicode" warnings category fatal;
if you agree with Perl's decision, you may wish to turn off this
category.
See "Beyond Unicode code points" in perlunicode for
more information.
- %s matches null string many times in regex; marked by <-- HERE
in m/%s/
- (W regexp) The pattern you've specified would be an infinite loop if the
regular expression engine didn't specifically check for that. The
<-- HERE shows whereabouts in the regular expression the problem
was discovered. See perlre.
- Maximal count of pending signals (%u) exceeded
- (F) Perl aborted due to too high a number of signals pending. This usually
indicates that your operating system tried to deliver signals too fast
(with a very high priority), starving the perl process from resources it
would need to reach a point where it can process signals safely. (See
"Deferred Signals (Safe Signals)" in perlipc.)
- "%s" may clash with future reserved word
- (W) This warning may be due to running a perl5 script through a perl4
interpreter, especially if the word that is being warned about is
"use" or "my".
- '%' may not be used in pack
- (F) You can't pack a string by supplying a checksum, because the
checksumming process loses information, and you can't go the other way.
See "unpack" in perlfunc.
- Method for operation %s not found in package %s during blessing
- (F) An attempt was made to specify an entry in an overloading table that
doesn't resolve to a valid subroutine. See overload.
- Method %s not permitted
- See "500 Server error".
- Might be a runaway multi-line %s string starting on line %d
- (S) An advisory indicating that the previous error may have been caused by
a missing delimiter on a string or pattern, because it eventually ended
earlier on the current line.
- Misplaced _ in number
- (W syntax) An underscore (underbar) in a numeric constant did not separate
two digits.
- Missing argument for %n in %s
- (F) A %n was used in a format string with no
corresponding argument for perl to write the current string length
to.
- Missing argument in %s
- (W missing) You called a function with fewer arguments than other
arguments you supplied indicated would be needed.
Currently only emitted when a printf-type format required more
arguments than were supplied, but might be used in the future for other
cases where we can statically determine that arguments to functions are
missing, e.g. for the "pack" in perlfunc function.
- Missing argument to -%c
- (F) The argument to the indicated command line switch must follow
immediately after the switch, without intervening spaces.
- Missing braces on \N{}
- Missing braces on \N{} in regex; marked by <-- HERE in
m/%s/
- (F) Wrong syntax of character name literal
"\N{charname}" within double-quotish
context. This can also happen when there is a space (or comment) between
the "\N" and the
"{" in a regex with the
"/x" modifier. This modifier does not
change the requirement that the brace immediately follow the
"\N".
- Missing braces on \o{}
- (F) A "\o" must be followed immediately
by a "{" in double-quotish context.
- Missing comma after first argument to %s function
- (F) While certain functions allow you to specify a filehandle or an
"indirect object" before the argument list, this ain't one of
them.
- Missing command in piped open
- (W pipe) You used the "open(FH, "|
command")" or "open(FH,
"command |")" construction, but the command was
missing or blank.
- Missing control char name in \c
- (F) A double-quoted string ended with "\c", without the required
control character name.
- Missing ']' in prototype for %s : %s
- (W illegalproto) A grouping was started with
"[" but never closed with
"]".
- Missing name in "%s sub"
- (F) The syntax for lexically scoped subroutines requires that they have a
name with which they can be found.
- Missing $ on loop variable
- (F) Apparently you've been programming in csh too much. Variables
are always mentioned with the $ in Perl, unlike in the shells, where it
can vary from one line to the next.
- (Missing operator before %s?)
- (S syntax) This is an educated guess made in conjunction with the message
"%s found where operator expected". Often the missing operator
is a comma.
- Missing or undefined argument to %s
- (F) You tried to call require or do with no argument or with an undefined
value as an argument. Require expects either a package name or a
file-specification as an argument; do expects a filename. See
"require EXPR" in perlfunc and "do EXPR" in
perlfunc.
- Missing right brace on \%c{} in regex; marked by <-- HERE in
m/%s/
- (F) Missing right brace in "\x{...}",
"\p{...}",
"\P{...}", or
"\N{...}".
- Missing right brace on \N{}
- Missing right brace on \N{} or unescaped left brace after \N
- (F) "\N" has two meanings.
The traditional one has it followed by a name enclosed in
braces, meaning the character (or sequence of characters) given by that
name. Thus "\N{ASTERISK}" is another
way of writing "*", valid in both
double-quoted strings and regular expression patterns. In patterns, it
doesn't have the meaning an unescaped
"*" does.
Starting in Perl 5.12.0,
"\N" also can have an additional
meaning (only) in patterns, namely to match a non-newline character.
(This is short for "[^\n]", and like
"." but is not affected by the
"/s" regex modifier.)
This can lead to some ambiguities. When
"\N" is not followed immediately by a
left brace, Perl assumes the "[^\n]"
meaning. Also, if the braces form a valid quantifier such as
"\N{3}" or
"\N{5,}", Perl assumes that this means
to match the given quantity of non-newlines (in these examples, 3; and 5
or more, respectively). In all other case, where there is a
"\N{" and a matching
"}", Perl assumes that a character
name is desired.
However, if there is no matching
"}", Perl doesn't know if it was
mistakenly omitted, or if "[^\n]{" was
desired, and raises this error. If you meant the former, add the right
brace; if you meant the latter, escape the brace with a backslash, like
so: "\N\{"
- Missing right curly or square bracket
- (F) The lexer counted more opening curly or square brackets than closing
ones. As a general rule, you'll find it's missing near the place you were
last editing.
- (Missing semicolon on previous line?)
- (S syntax) This is an educated guess made in conjunction with the message
"%s found where operator expected". Don't automatically put a
semicolon on the previous line just because you saw this message.
- Modification of a read-only value attempted
- (F) You tried, directly or indirectly, to change the value of a constant.
You didn't, of course, try "2 = 1", because the compiler catches
that. But an easy way to do the same thing is:
sub mod { $_[0] = 1 }
mod(2);
Another way is to assign to a substr() that's off the
end of the string.
Yet another way is to assign to a
"foreach" loop VAR when
VAR is aliased to a constant in the look LIST:
$x = 1;
foreach my $n ($x, 2) {
$n *= 2; # modifies the $x, but fails on attempt to
} # modify the 2
- Modification of non-creatable array value attempted, %s
- (F) You tried to make an array value spring into existence, and the
subscript was probably negative, even counting from end of the array
backwards.
- Modification of non-creatable hash value attempted, %s
- (P) You tried to make a hash value spring into existence, and it couldn't
be created for some peculiar reason.
- Module name must be constant
- (F) Only a bare module name is allowed as the first argument to a
"use".
- Module name required with -%c option
- (F) The "-M" or
"-m" options say that Perl should load
some module, but you omitted the name of the module. Consult perlrun for
full details about "-M" and
"-m".
- More than one argument to '%s' open
- (F) The "open" function has been asked
to open multiple files. This can happen if you are trying to open a pipe
to a command that takes a list of arguments, but have forgotten to specify
a piped open mode. See "open" in perlfunc for details.
- mprotect for COW string %p %u failed with %d
- (S) You compiled perl with -DPERL_DEBUG_READONLY_COW (see
"Copy on Write" in perlguts), but a shared string buffer could
not be made read-only.
- mprotect for %p %u failed with %d
- (S) You compiled perl with -DPERL_DEBUG_READONLY_OPS (see
perlhacktips), but an op tree could not be made read-only.
- mprotect RW for COW string %p %u failed with %d
- (S) You compiled perl with -DPERL_DEBUG_READONLY_COW (see
"Copy on Write" in perlguts), but a read-only shared string
buffer could not be made mutable.
- mprotect RW for %p %u failed with %d
- (S) You compiled perl with -DPERL_DEBUG_READONLY_OPS (see
perlhacktips), but a read-only op tree could not be made mutable before
freeing the ops.
- msg%s not implemented
- (F) You don't have System V message IPC on your system.
- Multidimensional syntax %s not supported
- (W syntax) Multidimensional arrays aren't written like
$foo[1,2,3]. They're written like
$foo[1][2][3], as in C.
- Multiple slurpy parameters not allowed
- (F) In subroutine signatures, a slurpy parameter
("@" or
"%") must be the last parameter, and
there must not be more than one of them; for example:
sub foo ($a, @b) {} # legal
sub foo ($a, @b, %) {} # invalid
- '/' must follow a numeric type in unpack
- (F) You had an unpack template that contained a '/', but this did not
follow some unpack specification producing a numeric value. See
"pack" in perlfunc.
- %s must not be a named sequence in transliteration operator
- (F) Transliteration ("tr///" and
"y///") transliterates individual
characters. But a named sequence by definition is more than an individual
character, and hence doing this operation on it doesn't make sense.
- "my sub" not yet implemented
- (F) Lexically scoped subroutines are not yet implemented. Don't try that
yet.
- "my" subroutine %s can't be in a package
- (F) Lexically scoped subroutines aren't in a package, so it doesn't make
sense to try to declare one with a package qualifier on the front.
- "my %s" used in sort comparison
- (W syntax) The package variables $a and
$b are used for sort comparisons. You used
$a or $b in as an operand
to the "<=>" or
"cmp" operator inside a sort comparison
block, and the variable had earlier been declared as a lexical variable.
Either qualify the sort variable with the package name, or rename the
lexical variable.
- "my" variable %s can't be in a package
- (F) Lexically scoped variables aren't in a package, so it doesn't make
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
- Name "%s::%s" used only once: possible typo
- (W once) Typographical errors often show up as unique variable names. If
you had a good reason for having a unique name, then just mention it again
somehow to suppress the message. The
"our" declaration is also provided for
this purpose.
NOTE: This warning detects package symbols that have been used
only once. This means lexical variables will never trigger this warning.
It also means that all of the package variables
$c, @c,
%c, as well as *c, &c, sub c{}, c(), and c
(the filehandle or format) are considered the same; if a program uses
$c only once but also uses any of the others it
will not trigger this warning. Symbols beginning with an underscore and
symbols using special identifiers (q.v. perldata) are exempt from this
warning.
- Need exactly 3 octal digits in regex; marked by <-- HERE in
m/%s/
- (F) Within
"(?[ ])", all
constants interpreted as octal need to be exactly 3 digits long. This
helps catch some ambiguities. If your constant is too short, add leading
zeros, like
(?[ [ \078 ] ]) # Syntax error!
(?[ [ \0078 ] ]) # Works
(?[ [ \007 8 ] ]) # Clearer
The maximum number this construct can express is
"\777". If you need a larger one, you
need to use \o{} instead. If you meant two separate things, you need to
separate them:
(?[ [ \7776 ] ]) # Syntax error!
(?[ [ \o{7776} ] ]) # One meaning
(?[ [ \777 6 ] ]) # Another meaning
(?[ [ \777 \006 ] ]) # Still another
- Negative '/' count in unpack
- (F) The length count obtained from a length/code unpack operation was
negative. See "pack" in perlfunc.
- Negative length
- (F) You tried to do a read/write/send/recv operation with a buffer length
that is less than 0. This is difficult to imagine.
- Negative offset to vec in lvalue context
- (F) When "vec" is called in an lvalue
context, the second argument must be greater than or equal to zero.
- Negative repeat count does nothing
- (W numeric) You tried to execute the "x"
repetition operator fewer than 0 times, which doesn't make sense.
- Nested quantifiers in regex; marked by <-- HERE in m/%s/
- (F) You can't quantify a quantifier without intervening parentheses. So
things like ** or +* or ?* are illegal. The <-- HERE shows
whereabouts in the regular expression the problem was discovered.
Note that the minimal matching quantifiers,
"*?",
"+?", and
"??" appear to be nested quantifiers,
but aren't. See perlre.
- %s never introduced
- (S internal) The symbol in question was declared but somehow went out of
scope before it could possibly have been used.
- next::method/next::can/maybe::next::method cannot find enclosing
method
- (F) "next::method" needs to be called
within the context of a real method in a real package, and it could not
find such a context. See mro.
- \N in a character class must be a named character: \N{...} in regex;
marked by <-- HERE in m/%s/
- (F) The new (as of Perl 5.12) meaning of
"\N" as
"[^\n]" is not valid in a bracketed
character class, for the same reason that
"." in a character class loses its
specialness: it matches almost everything, which is probably not what you
want.
- \N{} in inverted character class or as a range end-point is restricted to
one character in regex; marked by <-- HERE in m/%s/
- (F) Named Unicode character escapes
("\N{...}") may return a multi-character
sequence. Even though a character class is supposed to match just one
character of input, perl will match the whole thing correctly, except
under certain conditions. These currently are
- No %s allowed while running setuid
- (F) Certain operations are deemed to be too insecure for a setuid or
setgid script to even be allowed to attempt. Generally speaking there will
be another way to do what you want that is, if not secure, at least
securable. See perlsec.
- No code specified for -%c
- (F) Perl's -e and -E command-line options require an
argument. If you want to run an empty program, pass the empty string as a
separate argument or run a program consisting of a single 0 or 1:
perl -e ""
perl -e0
perl -e1
- No comma allowed after %s
- (F) A list operator that has a filehandle or "indirect object"
is not allowed to have a comma between that and the following arguments.
Otherwise it'd be just another one of the arguments.
One possible cause for this is that you expected to have
imported a constant to your name space with use or import
while no such importing took place, it may for example be that your
operating system does not support that particular constant. Hopefully
you did use an explicit import list for the constants you expect to see;
please see "use" in perlfunc and "import" in
perlfunc. While an explicit import list would probably have caught this
error earlier it naturally does not remedy the fact that your operating
system still does not support that constant. Maybe you have a typo in
the constants of the symbol import list of use or import
or in the constant name at the line where this error was triggered?
- No command into which to pipe on command line
- (F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a '|' at the end of the command line, so it doesn't
know where you want to pipe the output from this command.
- No DB::DB routine defined
- (F) The currently executing code was compiled with the -d switch,
but for some reason the current debugger (e.g. perl5db.pl or a
"Devel::" module) didn't define a
routine to be called at the beginning of each statement.
- No dbm on this machine
- (P) This is counted as an internal error, because every machine should
supply dbm nowadays, because Perl comes with SDBM. See SDBM_File.
- No DB::sub routine defined
- (F) The currently executing code was compiled with the -d switch,
but for some reason the current debugger (e.g. perl5db.pl or a
"Devel::" module) didn't define a
"DB::sub" routine to be called at the
beginning of each ordinary subroutine call.
- No directory specified for -I
- (F) The -I command-line switch requires a directory name as part of
the same argument. Use -Ilib, for instance. -I lib
won't work.
- No error file after 2> or 2>> on command line
- (F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a '2>' or a '2>>' on the command line, but
can't find the name of the file to which to write data destined for
stderr.
- No group ending character '%c' found in template
- (F) A pack or unpack template has an opening '(' or '[' without its
matching counterpart. See "pack" in perlfunc.
- No input file after < on command line
- (F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a '<' on the command line, but can't find the
name of the file from which to read data for stdin.
- No next::method '%s' found for %s
- (F) "next::method" found no further
instances of this method name in the remaining packages of the MRO of this
class. If you don't want it throwing an exception, use
"maybe::next::method" or
"next::can". See mro.
- Non-finite repeat count does nothing
- (W numeric) You tried to execute the "x"
repetition operator "Inf" (or
"-Inf") or
"NaN" times, which doesn't make
sense.
- Non-hex character in regex; marked by <-- HERE in m/%s/
- (F) In a regular expression, there was a non-hexadecimal character where a
hex one was expected, like
(?[ [ \xDG ] ])
(?[ [ \x{DEKA} ] ])
- Non-octal character in regex; marked by <-- HERE in m/%s/
- (F) In a regular expression, there was a non-octal character where an
octal one was expected, like
(?[ [ \o{1278} ] ])
- Non-octal character '%c'. Resolved as "%s"
- (W digit) In parsing an octal numeric constant, a character was
unexpectedly encountered that isn't octal. The resulting value is as
indicated.
- "no" not allowed in expression
- (F) The "no" keyword is recognized and executed at compile time,
and returns no useful value. See perlmod.
- Non-string passed as bitmask
- (W misc) A number has been passed as a bitmask argument to
select(). Use the vec() function to construct the file
descriptor bitmasks for select. See "select" in perlfunc.
- No output file after > on command line
- (F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a lone '>' at the end of the command line, so it
doesn't know where you wanted to redirect stdout.
- No output file after > or >> on command line
- (F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a '>' or a '>>' on the command line, but
can't find the name of the file to which to write data destined for
stdout.
- No package name allowed for subroutine %s in "our"
- No package name allowed for variable %s in "our"
- (F) Fully qualified subroutine and variable names are not allowed in
"our" declarations, because that doesn't make much sense under
existing rules. Such syntax is reserved for future extensions.
- No Perl script found in input
- (F) You called "perl -x", but no line
was found in the file beginning with #! and containing the word
"perl".
- No setregid available
- (F) Configure didn't find anything resembling the setregid() call
for your system.
- No setreuid available
- (F) Configure didn't find anything resembling the setreuid() call
for your system.
- No such class %s
- (F) You provided a class qualifier in a "my", "our" or
"state" declaration, but this class doesn't exist at this point
in your program.
- No such class field "%s" in variable %s of type %s
- (F) You tried to access a key from a hash through the indicated typed
variable but that key is not allowed by the package of the same type. The
indicated package has restricted the set of allowed keys using the fields
pragma.
- No such hook: %s
- (F) You specified a signal hook that was not recognized by Perl.
Currently, Perl accepts "__DIE__" and
"__WARN__" as valid signal hooks.
- No such pipe open
- (P) An error peculiar to VMS. The internal routine my_pclose()
tried to close a pipe which hadn't been opened. This should have been
caught earlier as an attempt to close an unopened filehandle.
- No such signal: SIG%s
- (W signal) You specified a signal name as a subscript to
%SIG that was not recognized. Say
"kill -l" in your shell to see the valid
signal names on your system.
- No Unicode property value wildcard matches:
- (W regexp) You specified a wildcard for a Unicode property value, but
there is no property value in the current Unicode release that matches it.
Check your spelling.
- Not a CODE reference
- (F) Perl was trying to evaluate a reference to a code value (that is, a
subroutine), but found a reference to something else instead. You can use
the ref() function to find out what kind of ref it really was. See
also perlref.
- Not a GLOB reference
- (F) Perl was trying to evaluate a reference to a "typeglob"
(that is, a symbol table entry that looks like
*foo), but found a reference to something else
instead. You can use the ref() function to find out what kind of
ref it really was. See perlref.
- Not a HASH reference
- (F) Perl was trying to evaluate a reference to a hash value, but found a
reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See perlref.
- '#' not allowed immediately following a sigil in a subroutine
signature
- (F) In a subroutine signature definition, a comment following a sigil
("$",
"@" or
"%"), needs to be separated by
whitespace or a comma etc., in particular to avoid confusion with the
$# variable. For example:
# bad
sub f ($# ignore first arg
, $b) {}
# good
sub f ($, # ignore first arg
$b) {}
- Not an ARRAY reference
- (F) Perl was trying to evaluate a reference to an array value, but found a
reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See perlref.
- Not a SCALAR reference
- (F) Perl was trying to evaluate a reference to a scalar value, but found a
reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See perlref.
- Not a subroutine reference
- (F) Perl was trying to evaluate a reference to a code value (that is, a
subroutine), but found a reference to something else instead. You can use
the ref() function to find out what kind of ref it really was. See
also perlref.
- Not a subroutine reference in overload table
- (F) An attempt was made to specify an entry in an overloading table that
doesn't somehow point to a valid subroutine. See overload.
- Not enough arguments for %s
- (F) The function requires more arguments than you specified.
- Not enough format arguments
- (W syntax) A format specified more picture fields than the next line
supplied. See perlform.
- %s: not found
- (A) You've accidentally run your script through the Bourne shell instead
of Perl. Check the #! line, or manually feed your script into Perl
yourself.
- no UTC offset information; assuming local time is UTC
- (S) A warning peculiar to VMS. Perl was unable to find the local timezone
offset, so it's assuming that local system time is equivalent to UTC. If
it's not, define the logical name SYS$TIMEZONE_DIFFERENTIAL to
translate to the number of seconds which need to be added to UTC to get
local time.
- NULL OP IN RUN
- (S debugging) Some internal routine called run() with a null opcode
pointer.
- Null picture in formline
- (F) The first argument to formline must be a valid format picture
specification. It was found to be empty, which probably means you supplied
it an uninitialized value. See perlform.
- Null realloc
- (P) An attempt was made to realloc NULL.
- NULL regexp argument
- (P) The internal pattern matching routines blew it big time.
- NULL regexp parameter
- (P) The internal pattern matching routines are out of their gourd.
- Number too long
- (F) Perl limits the representation of decimal numbers in programs to about
250 characters. You've exceeded that length. Future versions of Perl are
likely to eliminate this arbitrary limitation. In the meantime, try using
scientific notation (e.g. "1e6" instead of
"1_000_000").
- Number with no digits
- (F) Perl was looking for a number but found nothing that looked like a
number. This happens, for example with
"\o{}", with no number between the
braces.
- Octal number ><PHONE_NUMBER>77 non-portable
- (W portable) The octal number you specified is larger than 2**32-1
(4294967295) and therefore non-portable between systems. See perlport for
more on portability concerns.
- Odd name/value argument for subroutine '%s'
- (F) A subroutine using a slurpy hash parameter in its signature received
an odd number of arguments to populate the hash. It requires the arguments
to be paired, with the same number of keys as values. The caller of the
subroutine is presumably at fault.
The message attempts to include the name of the called
subroutine. If the subroutine has been aliased, the subroutine's
original name will be shown, regardless of what name the caller
used.
- Odd number of arguments for overload::constant
- (W overload) The call to overload::constant contained an odd number of
arguments. The arguments should come in pairs.
- Odd number of elements in anonymous hash
- (W misc) You specified an odd number of elements to initialize a hash,
which is odd, because hashes come in key/value pairs.
- Odd number of elements in hash assignment
- (W misc) You specified an odd number of elements to initialize a hash,
which is odd, because hashes come in key/value pairs.
- Offset outside string
- (F)(W layer) You tried to do a read/write/send/recv/seek operation with an
offset pointing outside the buffer. This is difficult to imagine. The sole
exceptions to this are that zero padding will take place when going past
the end of the string when either
"sysread()"ing a file, or when seeking
past the end of a scalar opened for I/O (in anticipation of future reads
and to imitate the behavior with real files).
- Old package separator used in string
- (W syntax) You used the old package separator, "'", in a
variable named inside a double-quoted string; e.g.,
"In $name's house". This is equivalent
to "In $name::s house". If you meant the
former, put a backslash before the apostrophe ("In
$name\'s house").
- %s() on unopened %s
- (W unopened) An I/O operation was attempted on a filehandle that was never
initialized. You need to do an open(), a sysopen(), or a
socket() call, or call a constructor from the FileHandle
package.
- -%s on unopened filehandle %s
- (W unopened) You tried to invoke a file test operator on a filehandle that
isn't open. Check your control flow. See also "-X" in
perlfunc.
- oops: oopsAV
- (S internal) An internal warning that the grammar is screwed up.
- oops: oopsHV
- (S internal) An internal warning that the grammar is screwed up.
- Operand with no preceding operator in regex; marked by <-- HERE
in m/%s/
- (F) You wrote something like
(?[ \p{Digit} \p{Thai} ])
There are two operands, but no operator giving how you want to
combine them.
- Operation "%s": no method found, %s
- (F) An attempt was made to perform an overloaded operation for which no
handler was defined. While some handlers can be autogenerated in terms of
other handlers, there is no default handler for any operation, unless the
"fallback" overloading key is specified
to be true. See overload.
- Operation "%s" returns its argument for non-Unicode code point
0x%X
- (S non_unicode) You performed an operation requiring Unicode rules on a
code point that is not in Unicode, so what it should do is not defined.
Perl has chosen to have it do nothing, and warn you.
If the operation shown is "ToFold", it means that
case-insensitive matching in a regular expression was done on the code
point.
If you know what you are doing you can turn off this warning
by "no warnings 'non_unicode';".
- Operation "%s" returns its argument for UTF-16 surrogate
U+%X
- (S surrogate) You performed an operation requiring Unicode rules on a
Unicode surrogate. Unicode frowns upon the use of surrogates for anything
but storing strings in UTF-16, but rules are (reluctantly) defined for the
surrogates, and they are to do nothing for this operation. Because the use
of surrogates can be dangerous, Perl warns.
If the operation shown is "ToFold", it means that
case-insensitive matching in a regular expression was done on the code
point.
If you know what you are doing you can turn off this warning
by "no warnings 'surrogate';".
- Operator or semicolon missing before %s
- (S ambiguous) You used a variable or subroutine call where the parser was
expecting an operator. The parser has assumed you really meant to use an
operator, but this is highly likely to be incorrect. For example, if you
say "*foo *foo" it will be interpreted as if you said "*foo
* 'foo'".
- Optional parameter lacks default expression
- (F) In a subroutine signature, you wrote something like "$a =",
making a named optional parameter without a default value. A nameless
optional parameter is permitted to have no default value, but a named one
must have a specific default. You probably want "$a =
undef".
- "our" variable %s redeclared
- (W shadow) You seem to have already declared the same global once before
in the current lexical scope.
- Out of memory!
- (X) The malloc() function returned 0, indicating there was
insufficient remaining memory (or virtual memory) to satisfy the request.
Perl has no option but to exit immediately.
At least in Unix you may be able to get past this by
increasing your process datasize limits: in csh/tcsh use
"limit" and
"limit datasize n" (where
"n" is the number of kilobytes) to
check the current limits and change them, and in ksh/bash/zsh use
"ulimit -a" and
"ulimit -d n", respectively.
- Out of memory during %s extend
- (X) An attempt was made to extend an array, a list, or a string beyond the
largest possible memory allocation.
- Out of memory during "large" request for %s
- (F) The malloc() function returned 0, indicating there was
insufficient remaining memory (or virtual memory) to satisfy the request.
However, the request was judged large enough (compile-time default is
64K), so a possibility to shut down by trapping this error is
granted.
- Out of memory during request for %s
- (X)(F) The malloc() function returned 0, indicating there was
insufficient remaining memory (or virtual memory) to satisfy the request.
The request was judged to be small, so the possibility to trap
it depends on the way perl was compiled. By default it is not trappable.
However, if compiled for this, Perl may use the contents of
$^M as an emergency pool after die()ing
with this message. In this case the error is trappable once, and
the error message will include the line and file where the failed
request happened.
- Out of memory during ridiculously large request
- (F) You can't allocate more than 2^31+"small amount" bytes. This
error is most likely to be caused by a typo in the Perl program. e.g.,
$arr[time] instead of
$arr[$time].
- Out of memory for yacc stack
- (F) The yacc parser wanted to grow its stack so it could continue parsing,
but realloc() wouldn't give it more memory, virtual or
otherwise.
- '.' outside of string in pack
- (F) The argument to a '.' in your template tried to move the working
position to before the start of the packed string being built.
- '@' outside of string in unpack
- (F) You had a template that specified an absolute position outside the
string being unpacked. See "pack" in perlfunc.
- '@' outside of string with malformed UTF-8 in unpack
- (F) You had a template that specified an absolute position outside the
string being unpacked. The string being unpacked was also invalid UTF-8.
See "pack" in perlfunc.
- overload arg '%s' is invalid
- (W overload) The overload pragma was passed an argument it did not
recognize. Did you mistype an operator?
- Overloaded dereference did not return a reference
- (F) An object with an overloaded dereference operator was dereferenced,
but the overloaded operation did not return a reference. See
overload.
- Overloaded qr did not return a REGEXP
- (F) An object with a "qr" overload was
used as part of a match, but the overloaded operation didn't return a
compiled regexp. See overload.
- %s package attribute may clash with future reserved word: %s
- (W reserved) A lowercase attribute name was used that had a
package-specific handler. That name might have a meaning to Perl itself
some day, even though it doesn't yet. Perhaps you should use a mixed-case
attribute name, instead. See attributes.
- pack/unpack repeat count overflow
- (F) You can't specify a repeat count so large that it overflows your
signed integers. See "pack" in perlfunc.
- page overflow
- (W io) A single call to write() produced more lines than can fit on
a page. See perlform.
- panic: %s
- (P) An internal error.
- panic: attempt to call %s in %s
- (P) One of the file test operators entered a code branch that calls an ACL
related-function, but that function is not available on this platform.
Earlier checks mean that it should not be possible to enter this branch on
this platform.
- panic: child pseudo-process was never scheduled
- (P) A child pseudo-process in the ithreads implementation on Windows was
not scheduled within the time period allowed and therefore was not able to
initialize properly.
- panic: ck_grep, type=%u
- (P) Failed an internal consistency check trying to compile a grep.
- panic: corrupt saved stack index %ld
- (P) The savestack was requested to restore more localized values than
there are in the savestack.
- panic: del_backref
- (P) Failed an internal consistency check while trying to reset a weak
reference.
- panic: do_subst
- (P) The internal pp_subst() routine was called with invalid
operational data.
- panic: do_trans_%s
- (P) The internal do_trans routines were called with invalid operational
data.
- panic: fold_constants JMPENV_PUSH returned %d
- (P) While attempting folding constants an exception other than an
"eval" failure was caught.
- panic: frexp: %f
- (P) The library function frexp() failed, making
printf("%f") impossible.
- panic: goto, type=%u, ix=%ld
- (P) We popped the context stack to a context with the specified label, and
then discovered it wasn't a context we know how to do a goto in.
- panic: gp_free failed to free glob pointer
- (P) The internal routine used to clear a typeglob's entries tried
repeatedly, but each time something re-created entries in the glob. Most
likely the glob contains an object with a reference back to the glob and a
destructor that adds a new object to the glob.
- panic: INTERPCASEMOD, %s
- (P) The lexer got into a bad state at a case modifier.
- panic: INTERPCONCAT, %s
- (P) The lexer got into a bad state parsing a string with brackets.
- panic: kid popen errno read
- (F) A forked child returned an incomprehensible message about its
errno.
- panic: last, type=%u
- (P) We popped the context stack to a block context, and then discovered it
wasn't a block context.
- panic: leave_scope clearsv
- (P) A writable lexical variable became read-only somehow within the
scope.
- panic: leave_scope inconsistency %u
- (P) The savestack probably got out of sync. At least, there was an invalid
enum on the top of it.
- panic: magic_killbackrefs
- (P) Failed an internal consistency check while trying to reset all weak
references to an object.
- panic: malloc, %s
- (P) Something requested a negative number of bytes of malloc.
- panic: memory wrap
- (P) Something tried to allocate either more memory than possible or a
negative amount.
- panic: pad_alloc, %p!=%p
- (P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
- panic: pad_free curpad, %p!=%p
- (P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
- panic: pad_free po
- (P) A zero scratch pad offset was detected internally. An attempt was made
to free a target that had not been allocated to begin with.
- panic: pad_reset curpad, %p!=%p
- (P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
- panic: pad_sv po
- (P) A zero scratch pad offset was detected internally. Most likely an
operator needed a target but that target had not been allocated for
whatever reason.
- panic: pad_swipe curpad, %p!=%p
- (P) The compiler got confused about which scratch pad it was allocating
and freeing temporaries and lexicals from.
- panic: pad_swipe po
- (P) An invalid scratch pad offset was detected internally.
- panic: pp_iter, type=%u
- (P) The foreach iterator got called in a non-loop context frame.
- panic: pp_match%s
- (P) The internal pp_match() routine was called with invalid
operational data.
- panic: realloc, %s
- (P) Something requested a negative number of bytes of realloc.
- panic: reference miscount on nsv in sv_replace() (%d != 1)
- (P) The internal sv_replace() function was handed a new SV with a
reference count other than 1.
- panic: restartop in %s
- (P) Some internal routine requested a goto (or something like it), and
didn't supply the destination.
- panic: return, type=%u
- (P) We popped the context stack to a subroutine or eval context, and then
discovered it wasn't a subroutine or eval context.
- panic: scan_num, %s
- (P) scan_num() got called on something that wasn't a number.
- panic: Sequence (?{...}): no code block found in regex m/%s/
- (P) While compiling a pattern that has embedded (?{}) or (??{}) code
blocks, perl couldn't locate the code block that should have already been
seen and compiled by perl before control passed to the regex
compiler.
- panic: strxfrm() gets absurd - a => %u, ab => %u
- (P) The interpreter's sanity check of the C function strxfrm()
failed. In your current locale the returned transformation of the string
"ab" is shorter than that of the string "a", which
makes no sense.
- panic: sv_chop %s
- (P) The sv_chop() routine was passed a position that is not within
the scalar's string buffer.
- panic: sv_insert, midend=%p, bigend=%p
- (P) The sv_insert() routine was told to remove more string than
there was string.
- panic: top_env
- (P) The compiler attempted to do a goto, or something weird like
that.
- panic: unimplemented op %s (#%d) called
- (P) The compiler is screwed up and attempted to use an op that isn't
permitted at run time.
- panic: unknown OA_*: %x
- (P) The internal routine that handles arguments to
"&CORE::foo()" subroutine calls was
unable to determine what type of arguments were expected.
- panic: utf16_to_utf8: odd bytelen
- (P) Something tried to call utf16_to_utf8 with an odd (as opposed to even)
byte length.
- panic: utf16_to_utf8_reversed: odd bytelen
- (P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed
to even) byte length.
- panic: yylex, %s
- (P) The lexer got into a bad state while processing a case modifier.
- Parentheses missing around "%s" list
- (W parenthesis) You said something like
my $foo, $bar = @_;
when you meant
my ($foo, $bar) = @_;
Remember that "my", "our",
"local" and "state" bind tighter than comma.
- Parsing code internal error (%s)
- (F) Parsing code supplied by an extension violated the parser's API in a
detectable way.
- Pattern subroutine nesting without pos change exceeded limit in regex
- (F) You used a pattern that uses too many nested subpattern calls without
consuming any text. Restructure the pattern so text is consumed before the
nesting limit is exceeded.
- "-p" destination: %s
- (F) An error occurred during the implicit output invoked by the
"-p" command-line switch. (This output
goes to STDOUT unless you've redirected it with select().)
- Perl API version %s of %s does not match %s
- (F) The XS module in question was compiled against a different
incompatible version of Perl than the one that has loaded the XS
module.
- Perl folding rules are not up-to-date for 0x%X; please use the perlbug
utility to report; in regex; marked by <-- HERE in m/%s/
- (S regexp) You used a regular expression with case-insensitive matching,
and there is a bug in Perl in which the built-in regular expression
folding rules are not accurate. This may lead to incorrect results. Please
report this as a bug to <https://github.com/Perl/perl5/issues>.
- PerlIO layer ':win32' is experimental
- (S experimental::win32_perlio) The
":win32" PerlIO layer is experimental.
If you want to take the risk of using this layer, simply disable this
warning:
no warnings "experimental::win32_perlio";
- Perl_my_%s() not available
- (F) Your platform has very uncommon byte-order and integer size, so it was
not possible to set up some or all fixed-width byte-order conversion
functions. This is only a problem when you're using the '<' or '>'
modifiers in (un)pack templates. See "pack" in perlfunc.
- Perl %s required (did you mean %s?)--this is only %s, stopped
- (F) The code you are trying to run has asked for a newer version of Perl
than you are running. Perhaps "use 5.10"
was written instead of "use 5.010" or
"use v5.10". Without the leading
"v", the number is interpreted as a
decimal, with every three digits after the decimal point representing a
part of the version number. So 5.10 is equivalent to v5.100.
- Perl %s required--this is only %s, stopped
- (F) The module in question uses features of a version of Perl more recent
than the currently running version. How long has it been since you
upgraded, anyway? See "require" in perlfunc.
- PERL_SH_DIR too long
- (F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
"sh"-shell in. See
"PERL_SH_DIR" in perlos2.
- PERL_SIGNALS illegal: "%s"
- (X) See "PERL_SIGNALS" in perlrun for legal values.
- Perls since %s too modern--this is %s, stopped
- (F) The code you are trying to run claims it will not run on the version
of Perl you are using because it is too new. Maybe the code needs to be
updated, or maybe it is simply wrong and the version check should just be
removed.
- perl: warning: Non hex character in '$ENV{PERL_HASH_SEED}', seed only
partially set
- (S) PERL_HASH_SEED should match /^\s*(?:0x)?[0-9a-fA-F]+\s*\z/ but it
contained a non hex character. This could mean you are not using the hash
seed you think you are.
- perl: warning: Setting locale failed.
- (S) The whole warning message will look something like:
perl: warning: Setting locale failed.
perl: warning: Please check that your locale settings:
LC_ALL = "En_US",
LANG = (unset)
are supported and installed on your system.
perl: warning: Falling back to the standard locale ("C").
Exactly what were the failed locale settings varies. In the
above the settings were that the LC_ALL was "En_US" and the
LANG had no value. This error means that Perl detected that you and/or
your operating system supplier and/or system administrator have set up
the so-called locale system but Perl could not use those settings. This
was not dead serious, fortunately: there is a "default locale"
called "C" that Perl can and will use, and the script will be
run. Before you really fix the problem, however, you will get the same
error message each time you run Perl. How to really fix the problem can
be found in perllocale section LOCALE PROBLEMS.
- perl: warning: strange setting in '$ENV{PERL_PERTURB_KEYS}': '%s'
- (S) Perl was run with the environment variable PERL_PERTURB_KEYS defined
but containing an unexpected value. The legal values of this setting are
as follows.
Numeric | String | Result
--------+---------------+-----------------------------------------
0 | NO | Disables key traversal randomization
1 | RANDOM | Enables full key traversal randomization
2 | DETERMINISTIC | Enables repeatable key traversal
| | randomization
Both numeric and string values are accepted, but note that
string values are case sensitive. The default for this setting is
"RANDOM" or 1.
- pid %x not a child
- (W exec) A warning peculiar to VMS. Waitpid() was asked to wait for
a process which isn't a subprocess of the current process. While this is
fine from VMS' perspective, it's probably not what you intended.
- 'P' must have an explicit size in unpack
- (F) The unpack format P must have an explicit size, not
"*".
- POSIX class [:%s:] unknown in regex; marked by <-- HERE in
m/%s/
- (F) The class in the character class [: :] syntax is unknown. The
<-- HERE shows whereabouts in the regular expression the problem
was discovered. Note that the POSIX character classes do not have
the "is" prefix the corresponding C
interfaces have: in other words, it's
"[[:print:]]", not
"isprint". See perlre.
- POSIX getpgrp can't take an argument
- (F) Your system has POSIX getpgrp(), which takes no argument,
unlike the BSD version, which takes a pid.
- POSIX syntax [%c %c] belongs inside character classes%s in regex; marked
by <-- HERE in m/%s/
- (W regexp) Perl thinks that you intended to write a POSIX character class,
but didn't use enough brackets. These POSIX class constructs [: :], [= =],
and [. .] go inside character classes, the [] are part of the
construct, for example:
"qr/[012[:alpha:]345]/". What the
regular expression pattern compiled to is probably not what you were
intending. For example, "qr/[:alpha:]/"
compiles to a regular bracketed character class consisting of the four
characters ":",
"a",
"l",
"h", and
"p". To specify the POSIX class, it
should have been written
"qr/[[:alpha:]]/".
Note that [= =] and [. .] are not currently implemented; they
are simply placeholders for future extensions and will cause fatal
errors. The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See perlre.
If the specification of the class was not completely valid,
the message indicates that.
- POSIX syntax [. .] is reserved for future extensions in regex; marked by
<-- HERE in m/%s/
- (F) Within regular expression character classes ([]) the syntax beginning
with "[." and ending with ".]" is reserved for future
extensions. If you need to represent those character sequences inside a
regular expression character class, just quote the square brackets with
the backslash: "\[." and ".\]". The <-- HERE
shows whereabouts in the regular expression the problem was discovered.
See perlre.
- POSIX syntax [= =] is reserved for future extensions in regex; marked by
<-- HERE in m/%s/
- (F) Within regular expression character classes ([]) the syntax beginning
with "[=" and ending with "=]" is reserved for future
extensions. If you need to represent those character sequences inside a
regular expression character class, just quote the square brackets with
the backslash: "\[=" and "=\]". The <-- HERE
shows whereabouts in the regular expression the problem was discovered.
See perlre.
- Possible attempt to put comments in qw() list
- (W qw) qw() lists contain items separated by whitespace; as with
literal strings, comment characters are not ignored, but are instead
treated as literal data. (You may have used different delimiters than the
parentheses shown here; braces are also frequently used.)
You probably wrote something like this:
@list = qw(
a # a comment
b # another comment
);
when you should have written this:
@list = qw(
a
b
);
If you really want comments, build your list the old-fashioned
way, with quotes and commas:
@list = (
'a', # a comment
'b', # another comment
);
- Possible attempt to separate words with commas
- (W qw) qw() lists contain items separated by whitespace; therefore
commas aren't needed to separate the items. (You may have used different
delimiters than the parentheses shown here; braces are also frequently
used.)
You probably wrote something like this:
qw! a, b, c !;
which puts literal commas into some of the list items. Write
it without commas if you don't want them to appear in your data:
qw! a b c !;
- Possible memory corruption: %s overflowed 3rd argument
- (F) An ioctl() or fcntl() returned more than Perl was
bargaining for. Perl guesses a reasonable buffer size, but puts a sentinel
byte at the end of the buffer just in case. This sentinel byte got
clobbered, and Perl assumes that memory is now corrupted. See
"ioctl" in perlfunc.
- Possible precedence issue with control flow operator
- (W syntax) There is a possible problem with the mixing of a control flow
operator (e.g. "return") and a
low-precedence operator like "or".
Consider:
sub { return $a or $b; }
This is parsed as:
sub { (return $a) or $b; }
Which is effectively just:
sub { return $a; }
Either use parentheses or the high-precedence variant of the
operator.
Note this may be also triggered for constructs like:
sub { 1 if die; }
- Possible precedence problem on bitwise %s operator
- (W precedence) Your program uses a bitwise logical operator in conjunction
with a numeric comparison operator, like this :
if ($x & $y == 0) { ... }
This expression is actually equivalent to
"$x & ($y == 0)", due to the
higher precedence of "==". This is
probably not what you want. (If you really meant to write this, disable
the warning, or, better, put the parentheses explicitly and write
"$x & ($y == 0)").
- Possible unintended interpolation of $\ in regex
- (W ambiguous) You said something like
"m/$\/" in a regex. The regex
"m/foo$\s+bar/m" translates to: match
the word 'foo', the output record separator (see "$\" in
perlvar) and the letter 's' (one time or more) followed by the word 'bar'.
If this is what you intended then you can silence the warning
by using "m/${\}/" (for example:
"m/foo${\}s+bar/").
If instead you intended to match the word 'foo' at the end of
the line followed by whitespace and the word 'bar' on the next line then
you can use "m/$(?)\/" (for example:
"m/foo$(?)\s+bar/").
- Possible unintended interpolation of %s in string
- (W ambiguous) You said something like '@foo' in a double-quoted string but
there was no array @foo in scope at the time. If
you wanted a literal @foo, then write it as \@foo;
otherwise find out what happened to the array you apparently lost track
of.
- Precedence problem: open %s should be open(%s)
- (S precedence) The old irregular construct
open FOO || die;
is now misinterpreted as
open(FOO || die);
because of the strict regularization of Perl 5's grammar into
unary and list operators. (The old open was a little of both.) You must
put parentheses around the filehandle, or use the new "or"
operator instead of "||".
- Premature end of script headers
- See "500 Server error".
- printf() on closed filehandle %s
- (W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
- print() on closed filehandle %s
- (W closed) The filehandle you're printing on got itself closed sometime
before now. Check your control flow.
- Process terminated by SIG%s
- (W) This is a standard message issued by OS/2 applications, while *nix
applications die in silence. It is considered a feature of the OS/2 port.
One can easily disable this by appropriate sighandlers, see
"Signals" in perlipc. See also "Process terminated by
SIGTERM/SIGINT" in perlos2.
- Prototype after '%c' for %s : %s
- (W illegalproto) A character follows % or @ in a prototype. This is
useless, since % and @ gobble the rest of the subroutine arguments.
- Prototype mismatch: %s vs %s
- (S prototype) The subroutine being declared or defined had previously been
declared or defined with a different function prototype.
- Prototype not terminated
- (F) You've omitted the closing parenthesis in a function prototype
definition.
- Prototype '%s' overridden by attribute 'prototype(%s)' in %s
- (W prototype) A prototype was declared in both the parentheses after the
sub name and via the prototype attribute. The prototype in parentheses is
useless, since it will be replaced by the prototype from the attribute
before it's ever used.
- Quantifier follows nothing in regex; marked by <-- HERE in
m/%s/
- (F) You started a regular expression with a quantifier. Backslash it if
you meant it literally. The <-- HERE shows whereabouts in the
regular expression the problem was discovered. See perlre.
- Quantifier in {,} bigger than %d in regex; marked by <-- HERE in
m/%s/
- (F) There is currently a limit to the size of the min and max values of
the {min,max} construct. The <-- HERE shows whereabouts in the
regular expression the problem was discovered. See perlre.
- Quantifier {n,m} with n > m can't match in regex
- Quantifier {n,m} with n > m can't match in regex; marked by
<-- HERE in m/%s/
- (W regexp) Minima should be less than or equal to maxima. If you really
want your regexp to match something 0 times, just put {0}.
- Quantifier unexpected on zero-length expression in regex m/%s/
- (W regexp) You applied a regular expression quantifier in a place where it
makes no sense, such as on a zero-width assertion. Try putting the
quantifier inside the assertion instead. For example, the way to match
"abc" provided that it is followed by three repetitions of
"xyz" is
"/abc(?=(?:xyz){3})/", not
"/abc(?=xyz){3}/".
- Range iterator outside integer range
- (F) One (or both) of the numeric arguments to the range operator
".." are outside the range which can be represented by integers
internally. One possible workaround is to force Perl to use magical string
increment by prepending "0" to your numbers.
- Ranges of ASCII printables should be some subset of "0-9",
"A-Z", or "a-z" in regex; marked by <-- HERE
in m/%s/
- (W regexp) (only under
"use re 'strict'" or
within "(?[...])")
Stricter rules help to find typos and other errors. Perhaps
you didn't even intend a range here, if the
"-" was meant to be some other
character, or should have been escaped (like
"\-"). If you did intend a range, the
one that was used is not portable between ASCII and EBCDIC platforms,
and doesn't have an obvious meaning to a casual reader.
[3-7] # OK; Obvious and portable
[d-g] # OK; Obvious and portable
[A-Y] # OK; Obvious and portable
[A-z] # WRONG; Not portable; not clear what is meant
[a-Z] # WRONG; Not portable; not clear what is meant
[%-.] # WRONG; Not portable; not clear what is meant
[\x41-Z] # WRONG; Not portable; not obvious to non-geek
(You can force portability by specifying a Unicode range,
which means that the endpoints are specified by
"\N{...}", but the meaning may still
not be obvious.) The stricter rules require that ranges that start or
stop with an ASCII character that is not a control have all their
endpoints be the literal character, and not some escape sequence (like
"\x41"), and the ranges must be all
digits, or all uppercase letters, or all lowercase letters.
- Ranges of digits should be from the same group in regex; marked by
<-- HERE in m/%s/
- (W regexp) (only under
"use re 'strict'" or
within "(?[...])")
Stricter rules help to find typos and other errors. You
included a range, and at least one of the end points is a decimal digit.
Under the stricter rules, when this happens, both end points should be
digits in the same group of 10 consecutive digits.
- readdir() attempted on invalid dirhandle %s
- (W io) The dirhandle you're reading from is either closed or not really a
dirhandle. Check your control flow.
- readline() on closed filehandle %s
- (W closed) The filehandle you're reading from got itself closed sometime
before now. Check your control flow.
- read() on closed filehandle %s
- (W closed) You tried to read from a closed filehandle.
- read() on unopened filehandle %s
- (W unopened) You tried to read from a filehandle that was never
opened.
- Reallocation too large: %x
- (F) You can't allocate more than 64K on an MS-DOS machine.
- realloc() of freed memory ignored
- (S malloc) An internal routine called realloc() on something that
had already been freed.
- Recompile perl with -DDEBUGGING to use -D switch
- (S debugging) You can't use the -D option unless the code to
produce the desired output is compiled into Perl, which entails some
overhead, which is why it's currently left out of your copy.
- Recursive call to Perl_load_module in PerlIO_find_layer
- (P) It is currently not permitted to load modules when creating a
filehandle inside an %INC hook. This can happen
with "open my $fh, '<',
\$scalar", which implicitly loads PerlIO::scalar. Try loading
PerlIO::scalar explicitly first.
- Recursive inheritance detected in package '%s'
- (F) While calculating the method resolution order (MRO) of a package, Perl
believes it found an infinite loop in the @ISA
hierarchy. This is a crude check that bails out after 100 levels of
@ISA depth.
- Redundant argument in %s
- (W redundant) You called a function with more arguments than other
arguments you supplied indicated would be needed. Currently only emitted
when a printf-type format required fewer arguments than were supplied, but
might be used in the future for e.g. "pack" in perlfunc.
- refcnt_dec: fd %d%s
- refcnt: fd %d%s
- refcnt_inc: fd %d%s
- (P) Perl's I/O implementation failed an internal consistency check. If you
see this message, something is very wrong.
- Reference found where even-sized list expected
- (W misc) You gave a single reference where Perl was expecting a list with
an even number of elements (for assignment to a hash). This usually means
that you used the anon hash constructor when you meant to use parens. In
any case, a hash requires key/value pairs.
%hash = { one => 1, two => 2, }; # WRONG
%hash = [ qw/ an anon array / ]; # WRONG
%hash = ( one => 1, two => 2, ); # right
%hash = qw( one 1 two 2 ); # also fine
- Reference is already weak
- (W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
- Reference is not weak
- (W misc) You have attempted to unweaken a reference that is not weak.
Doing so has no effect.
- Reference to invalid group 0 in regex; marked by <-- HERE in
m/%s/
- (F) You used "\g0" or similar in a
regular expression. You may refer to capturing parentheses only with
strictly positive integers (normal backreferences) or with strictly
negative integers (relative backreferences). Using 0 does not make
sense.
- Reference to nonexistent group in regex; marked by <-- HERE in
m/%s/
- (F) You used something like "\7" in your
regular expression, but there are not at least seven sets of capturing
parentheses in the expression. If you wanted to have the character with
ordinal 7 inserted into the regular expression, prepend zeroes to make it
three digits long: "\007"
The <-- HERE shows whereabouts in the regular
expression the problem was discovered.
- Reference to nonexistent named group in regex; marked by
<-- HERE in m/%s/
- (F) You used something like "\k'NAME'"
or "\k<NAME>" in your regular
expression, but there is no corresponding named capturing parentheses such
as "(?'NAME'...)" or
"(?<NAME>...)". Check if the name
has been spelled correctly both in the backreference and the declaration.
The <-- HERE shows whereabouts in the regular
expression the problem was discovered.
- Reference to nonexistent or unclosed group in regex; marked by
<-- HERE in m/%s/
- (F) You used something like "\g{-7}" in
your regular expression, but there are not at least seven sets of closed
capturing parentheses in the expression before where the
"\g{-7}" was located.
The <-- HERE shows whereabouts in the regular
expression the problem was discovered.
- regexp memory corruption
- (P) The regular expression engine got confused by what the regular
expression compiler gave it.
- Regexp modifier "/%c" may appear a maximum of twice
- Regexp modifier "%c" may appear a maximum of twice in regex;
marked by <-- HERE in m/%s/
- (F) The regular expression pattern had too many occurrences of the
specified modifier. Remove the extraneous ones.
- Regexp modifier "%c" may not appear after the "-" in
regex; marked by <-- HERE in m/%s/
- (F) Turning off the given modifier has the side effect of turning on
another one. Perl currently doesn't allow this.
- Regexp modifier "/%c" may not appear twice
- Regexp modifier "%c" may not appear twice in regex; marked by
<-- HERE in m/%s/
- (F) The regular expression pattern had too many occurrences of the
specified modifier. Remove the extraneous ones.
- Regexp modifiers "/%c" and "/%c" are mutually
exclusive
- Regexp modifiers "%c" and "%c" are mutually exclusive
in regex; marked by <-- HERE in m/%s/
- (F) The regular expression pattern had more than one of these mutually
exclusive modifiers. Retain only the modifier that is supposed to be
there.
- Regexp out of space in regex m/%s/
- (P) A "can't happen" error, because safemalloc() should
have caught it earlier.
- Repeated format line will never terminate (~~ and @#)
- (F) Your format contains the ~~ repeat-until-blank sequence and a numeric
field that will never go blank so that the repetition never terminates.
You might use ^# instead. See perlform.
- Replacement list is longer than search list
- (W misc) You have used a replacement list that is longer than the search
list. So the additional elements in the replacement list are
meaningless.
- '(*%s' requires a terminating ':' in regex; marked by <-- HERE in
m/%s/
- (F) You used a construct that needs a colon and pattern argument. Supply
these or check that you are using the right construct.
- '%s' resolved to '\o{%s}%d'
- (W misc, regexp) You wrote something like
"\08", or
"\179" in a double-quotish string. All
but the last digit is treated as a single character, specified in octal.
The last digit is the next character in the string. To tell Perl that this
is indeed what you want, you can use the "\o{
}" syntax, or use exactly three digits to specify the octal
for the character.
- Reversed %s= operator
- (W syntax) You wrote your assignment operator backwards. The = must always
come last, to avoid ambiguity with subsequent unary operators.
- rewinddir() attempted on invalid dirhandle %s
- (W io) The dirhandle you tried to do a rewinddir() on is either
closed or not really a dirhandle. Check your control flow.
- Scalars leaked: %d
- (S internal) Something went wrong in Perl's internal bookkeeping of
scalars: not all scalar variables were deallocated by the time Perl
exited. What this usually indicates is a memory leak, which is of course
bad, especially if the Perl program is intended to be long-running.
- Scalar value @%s[%s] better written as $%s[%s]
- (W syntax) You've used an array 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
$foo[&bar] always behaves like a scalar, both
when assigning to it and when evaluating its argument, while
@foo[&bar] behaves like a list when you assign
to it, and provides a list context to its subscript, which can do weird
things if you're expecting only one subscript.
On the other hand, if you were actually hoping to treat the
array element as a list, you need to look into how references work,
because Perl will not magically convert between scalars and lists for
you. See perlref.
- Scalar value @%s{%s} better written as $%s{%s}
- (W syntax) You've used a hash 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
$foo{&bar} always behaves like a scalar, both
when assigning to it and when evaluating its argument, while
@foo{&bar} behaves like a list when you assign
to it, and provides a list context to its subscript, which can do weird
things if you're expecting only one subscript.
On the other hand, if you were actually hoping to treat the
hash element as a list, you need to look into how references work,
because Perl will not magically convert between scalars and lists for
you. See perlref.
- Search pattern not terminated
- (F) The lexer couldn't find the final delimiter of a // or m{} construct.
Remember that bracketing delimiters count nesting level. Missing the
leading "$" from a variable
$m may cause this error.
Note that since Perl 5.10.0 a // can also be the
defined-or construct, not just the empty search pattern.
Therefore code written in Perl 5.10.0 or later that uses the // as the
defined-or can be misparsed by pre-5.10.0 Perls as a
non-terminated search pattern.
- seekdir() attempted on invalid dirhandle %s
- (W io) The dirhandle you are doing a seekdir() on is either closed
or not really a dirhandle. Check your control flow.
- %sseek() on unopened filehandle
- (W unopened) You tried to use the seek() or sysseek()
function on a filehandle that was either never opened or has since been
closed.
- select not implemented
- (F) This machine doesn't implement the select() system call.
- Self-ties of arrays and hashes are not supported
- (F) Self-ties are of arrays and hashes are not supported in the current
implementation.
- Semicolon seems to be missing
- (W semicolon) A nearby syntax error was probably caused by a missing
semicolon, or possibly some other missing operator, such as a comma.
- semi-panic: attempt to dup freed string
- (S internal) The internal newSVsv() routine was called to duplicate
a scalar that had previously been marked as free.
- sem%s not implemented
- (F) You don't have System V semaphore IPC on your system.
- send() on closed socket %s
- (W closed) The socket you're sending to got itself closed sometime before
now. Check your control flow.
- Sequence "\c{" invalid
- (F) These three characters may not appear in sequence in a double-quotish
context. This message is raised only on non-ASCII platforms (a different
error message is output on ASCII ones). If you were intending to specify a
control character with this sequence, you'll have to use a different way
to specify it.
- Sequence (? incomplete in regex; marked by <-- HERE in
m/%s/
- (F) A regular expression ended with an incomplete extension (?. The
<-- HERE shows whereabouts in the regular expression the problem
was discovered. See perlre.
- Sequence (?%c...) not implemented in regex; marked by <-- HERE
in m/%s/
- (F) A proposed regular expression extension has the character reserved but
has not yet been written. The <-- HERE shows whereabouts in the
regular expression the problem was discovered. See perlre.
- Sequence (?%s...) not recognized in regex; marked by <-- HERE in
m/%s/
- (F) You used a regular expression extension that doesn't make sense. The
<-- HERE shows whereabouts in the regular expression the problem
was discovered. This may happen when using the
"(?^...)" construct to tell Perl to use
the default regular expression modifiers, and you redundantly specify a
default modifier. For other causes, see perlre.
- Sequence (?#... not terminated in regex m/%s/
- (F) A regular expression comment must be terminated by a closing
parenthesis. Embedded parentheses aren't allowed. See perlre.
- Sequence (?&... not terminated in regex; marked by <-- HERE
in m/%s/
- (F) A named reference of the form
"(?&...)" was missing the final
closing parenthesis after the name. The <-- HERE shows
whereabouts in the regular expression the problem was discovered.
- Sequence (?%c... not terminated in regex; marked by <-- HERE in
m/%s/
- (F) A named group of the form "(?'...')"
or "(?<...>)" was missing the
final closing quote or angle bracket. The <-- HERE shows
whereabouts in the regular expression the problem was discovered.
- Sequence (?(%c... not terminated in regex; marked by <-- HERE in
m/%s/
- (F) A named reference of the form
"(?('...')...)" or
"(?(<...>)...)" was missing the
final closing quote or angle bracket after the name. The
<-- HERE shows whereabouts in the regular expression the problem
was discovered.
- Sequence (?... not terminated in regex; marked by <-- HERE in
m/%s/
- (F) There was no matching closing parenthesis for the '('. The
<-- HERE shows whereabouts in the regular expression the problem
was discovered.
- Sequence \%s... not terminated in regex; marked by <-- HERE in
m/%s/
- (F) The regular expression expects a mandatory argument following the
escape sequence and this has been omitted or incorrectly written.
- Sequence (?{...}) not terminated with ')'
- (F) The end of the perl code contained within the {...} must be followed
immediately by a ')'.
- Sequence (?P>... not terminated in regex; marked by <-- HERE
in m/%s/
- (F) A named reference of the form
"(?P>...)" was missing the final
closing parenthesis after the name. The <-- HERE shows
whereabouts in the regular expression the problem was discovered.
- Sequence (?P<... not terminated in regex; marked by <-- HERE
in m/%s/
- (F) A named group of the form
"(?P<...>')" was missing the final
closing angle bracket. The <-- HERE shows whereabouts in the
regular expression the problem was discovered.
- Sequence ?P=... not terminated in regex; marked by <-- HERE in
m/%s/
- (F) A named reference of the form
"(?P=...)" was missing the final closing
parenthesis after the name. The <-- HERE shows whereabouts in
the regular expression the problem was discovered.
- Sequence (?R) not terminated in regex m/%s/
- (F) An "(?R)" or
"(?0)" sequence in a regular expression
was missing the final parenthesis.
- 500 Server error
- (A) This is the error message generally seen in a browser window when
trying to run a CGI program (including SSI) over the web. The actual error
text varies widely from server to server. The most frequently-seen
variants are "500 Server error", "Method (something) not
permitted", "Document contains no data", "Premature
end of script headers", and "Did not produce a valid
header".
This is a CGI error, not a Perl error.
You need to make sure your script is executable, is accessible
by the user CGI is running the script under (which is probably not the
user account you tested it under), does not rely on any environment
variables (like PATH) from the user it isn't running under, and isn't in
a location where the CGI server can't find it, basically, more or less.
Please see the following for more information:
http://www.perl.org/CGI_MetaFAQ.html
http://www.htmlhelp.org/faq/cgifaq.html
http://www.w3.org/Security/Faq/
You should also look at perlfaq9.
- setegid() not implemented
- (F) You tried to assign to $), and your operating
system doesn't support the setegid() system call (or equivalent),
or at least Configure didn't think so.
- seteuid() not implemented
- (F) You tried to assign to $>, and your
operating system doesn't support the seteuid() system call (or
equivalent), or at least Configure didn't think so.
- setpgrp can't take arguments
- (F) Your system has the setpgrp() from BSD 4.2, which takes no
arguments, unlike POSIX setpgid(), which takes a process ID and
process group ID.
- setrgid() not implemented
- (F) You tried to assign to $(, and your operating
system doesn't support the setrgid() system call (or equivalent),
or at least Configure didn't think so.
- setruid() not implemented
- (F) You tried to assign to $<, and your
operating system doesn't support the setruid() system call (or
equivalent), or at least Configure didn't think so.
- setsockopt() on closed socket %s
- (W closed) You tried to set a socket option on a closed socket. Did you
forget to check the return value of your socket() call? See
"setsockopt" in perlfunc.
- Setting $/ to a reference to %s is forbidden
- (F) You assigned a reference to a scalar to $/
where the referenced item is not a positive integer. In older perls this
appeared to work the same as setting it to
"undef" but was in fact internally
different, less efficient and with very bad luck could have resulted in
your file being split by a stringified form of the reference.
In Perl 5.20.0 this was changed so that it would be
exactly the same as setting $/ to undef,
with the exception that this warning would be thrown.
You are recommended to change your code to set
$/ to "undef"
explicitly if you wish to slurp the file. As of Perl 5.28 assigning
$/ to a reference to an integer which isn't
positive is a fatal error.
- Setting $/ to %s reference is forbidden
- (F) You tried to assign a reference to a non integer to
$/. In older Perls this would have behaved
similarly to setting it to a reference to a positive integer, where the
integer was the address of the reference. As of Perl 5.20.0 this is a
fatal error, to allow future versions of Perl to use non-integer refs for
more interesting purposes.
- shm%s not implemented
- (F) You don't have System V shared memory IPC on your system.
- !=~ should be !~
- (W syntax) The non-matching operator is !~, not !=~. !=~ will be
interpreted as the != (numeric not equal) and ~ (1's complement)
operators: probably not what you intended.
- /%s/ should probably be written as "%s"
- (W syntax) You have used a pattern where Perl expected to find a string,
as in the first argument to "join". Perl
will treat the true or false result of matching the pattern against
$_ as the string, which is probably not what you
had in mind.
- shutdown() on closed socket %s
- (W closed) You tried to do a shutdown on a closed socket. Seems a bit
superfluous.
- SIG%s handler "%s" not defined
- (W signal) The signal handler named in %SIG
doesn't, in fact, exist. Perhaps you put it into the wrong package?
- Slab leaked from cv %p
- (S) If you see this message, then something is seriously wrong with the
internal bookkeeping of op trees. An op tree needed to be freed after a
compilation error, but could not be found, so it was leaked instead.
- sleep(%u) too large
- (W overflow) You called "sleep" with a
number that was larger than it can reliably handle and
"sleep" probably slept for less time
than requested.
- Slurpy parameter not last
- (F) In a subroutine signature, you put something after a slurpy (array or
hash) parameter. The slurpy parameter takes all the available arguments,
so there can't be any left to fill later parameters.
- Smart matching a non-overloaded object breaks encapsulation
- (F) You should not use the "~~" operator
on an object that does not overload it: Perl refuses to use the object's
underlying structure for the smart match.
- Smartmatch is experimental
- (S experimental::smartmatch) This warning is emitted if you use the
smartmatch ("~~") operator. This is
currently an experimental feature, and its details are subject to change
in future releases of Perl. Particularly, its current behavior is noticed
for being unnecessarily complex and unintuitive, and is very likely to be
overhauled.
- Sorry, hash keys must be smaller than 2**31 bytes
- (F) You tried to create a hash containing a very large key, where
"very large" means that it needs at least 2 gigabytes to store.
Unfortunately, Perl doesn't yet handle such large hash keys. You should
reconsider your design to avoid hashing such a long string directly.
- sort is now a reserved word
- (F) An ancient error message that almost nobody ever runs into anymore.
But before sort was a keyword, people sometimes used it as a
filehandle.
- Source filters apply only to byte streams
- (F) You tried to activate a source filter (usually by loading a source
filter module) within a string passed to
"eval". This is not permitted under the
"unicode_eval" feature. Consider using
"evalbytes" instead. See feature.
- splice() offset past end of array
- (W misc) You attempted to specify an offset that was past the end of the
array passed to splice(). Splicing will instead commence at the end
of the array, rather than past it. If this isn't what you want, try
explicitly pre-extending the array by assigning $#array =
$offset. See "splice" in perlfunc.
- Split loop
- (P) The split was looping infinitely. (Obviously, a split shouldn't
iterate more times than there are characters of input, which is what
happened.) See "split" in perlfunc.
- Statement unlikely to be reached
- (W exec) You did an exec() with some statement after it other than
a die(). This is almost always an error, because exec()
never returns unless there was a failure. You probably wanted to use
system() instead, which does return. To suppress this warning, put
the exec() in a block by itself.
- "state" subroutine %s can't be in a package
- (F) Lexically scoped subroutines aren't in a package, so it doesn't make
sense to try to declare one with a package qualifier on the front.
- "state %s" used in sort comparison
- (W syntax) The package variables $a and
$b are used for sort comparisons. You used
$a or $b in as an operand
to the "<=>" or
"cmp" operator inside a sort comparison
block, and the variable had earlier been declared as a lexical variable.
Either qualify the sort variable with the package name, or rename the
lexical variable.
- "state" variable %s can't be in a package
- (F) Lexically scoped variables aren't in a package, so it doesn't make
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
- stat() on unopened filehandle %s
- (W unopened) You tried to use the stat() function on a filehandle
that was either never opened or has since been closed.
- Strings with code points over 0xFF may not be mapped into in-memory file
handles
- (W utf8) You tried to open a reference to a scalar for read or append
where the scalar contained code points over 0xFF. In-memory files model
on-disk files and can only contain bytes.
- Stub found while resolving method "%s" overloading
"%s" in package "%s"
- (P) Overloading resolution over @ISA tree may be
broken by importation stubs. Stubs should never be implicitly created, but
explicit calls to "can" may break
this.
- Subroutine attributes must come before the signature
- (F) When subroutine signatures are enabled, any subroutine attributes must
come before the signature. Note that this order was the opposite in
versions 5.22..5.26. So:
sub foo :lvalue ($a, $b) { ... } # 5.20 and 5.28 +
sub foo ($a, $b) :lvalue { ... } # 5.22 .. 5.26
- Subroutine "&%s" is not available
- (W closure) During compilation, an inner named subroutine or eval is
attempting to capture an outer lexical subroutine that is not currently
available. This can happen for one of two reasons. First, the lexical
subroutine may be declared in an outer anonymous subroutine that has not
yet been created. (Remember that named subs are created at compile time,
while anonymous subs are created at run-time.)  Conversely, the following won't give a warning since the anonymous
subroutine has by now been created and is live:
sub { my sub a {...} eval 'sub f { \&a }' }->();
The second situation is caused by an eval accessing a lexical
subroutine that has gone out of scope, for example,
sub f {
my sub a {...}
sub { eval '\&a' }
}
f()->();
Here, when the '\&a' in the eval is being compiled, f() is
not currently being executed, so its &a is not available for
capture.
- "%s" subroutine &%s masks earlier declaration in same
%s
- (W shadow) A "my" or "state" subroutine has been
redeclared in the current scope or statement, effectively eliminating all
access to the previous instance. This is almost always a typographical
error. Note that the earlier subroutine will still exist until the end of
the scope or until all closure references to it are destroyed.
- Subroutine %s redefined
- (W redefine) You redefined a subroutine. To suppress this warning, say
{
no warnings 'redefine';
eval "sub name { ... }";
}
- Subroutine "%s" will not stay shared
- (W closure) An inner (nested) named subroutine is referencing a
"my" subroutine defined in an outer named subroutine.
When the inner subroutine is called, it will see the value of
the outer subroutine's lexical subroutine as it was before and during
the *first* call to the outer subroutine; in this case, after the first
call to the outer subroutine is complete, the inner and outer
subroutines will no longer share a common value for the lexical
subroutine. In other words, it will no longer be shared. This will
especially make a difference if the lexical subroutines accesses lexical
variables declared in its surrounding scope.
This problem can usually be solved by making the inner
subroutine anonymous, using the "sub
{}" syntax. When inner anonymous subs that reference lexical
subroutines in outer subroutines are created, they are automatically
rebound to the current values of such lexical subs.
- Substitution loop
- (P) The substitution was looping infinitely. (Obviously, a substitution
shouldn't iterate more times than there are characters of input, which is
what happened.) See the discussion of substitution in "Regexp
Quote-Like Operators" in perlop.
- Substitution pattern not terminated
- (F) The lexer couldn't find the interior delimiter of an s/// or s{}{}
construct. Remember that bracketing delimiters count nesting level.
Missing the leading "$" from variable
$s may cause this error.
- Substitution replacement not terminated
- (F) The lexer couldn't find the final delimiter of an s/// or s{}{}
construct. Remember that bracketing delimiters count nesting level.
Missing the leading "$" from variable
$s may cause this error.
- substr outside of string
- (W substr)(F) You tried to reference a substr() that pointed
outside of a string. That is, the absolute value of the offset was larger
than the length of the string. See "substr" in perlfunc. This
warning is fatal if substr is used in an lvalue context (as the left hand
side of an assignment or as a subroutine argument for example).
- sv_upgrade from type %d down to type %d
- (P) Perl tried to force the upgrade of an SV to a type which was actually
inferior to its current type.
- SWASHNEW didn't return an HV ref
- (P) Something went wrong internally when Perl was trying to look up
Unicode characters.
- Switch (?(condition)... contains too many branches in regex; marked by
<-- HERE in m/%s/
- (F) A (?(condition)if-clause|else-clause) construct can have at most two
branches (the if-clause and the else-clause). If you want one or both to
contain alternation, such as using
"this|that|other", enclose it in
clustering parentheses:
(?(condition)(?:this|that|other)|else-clause)
The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See perlre.
- Switch condition not recognized in regex; marked by <-- HERE in
m/%s/
- (F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition must be one of the following:
(1) (2) ... true if 1st, 2nd, etc., capture matched
(<NAME>) ('NAME') true if named capture matched
(?=...) (?<=...) true if subpattern matches
(?!...) (?<!...) true if subpattern fails to match
(?{ CODE }) true if code returns a true value
(R) true if evaluating inside recursion
(R1) (R2) ... true if directly inside capture group 1, 2, etc.
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See perlre.
- Switch (?(condition)... not terminated in regex; marked by
<-- HERE in m/%s/
- (F) You omitted to close a (?(condition)...) block somewhere in the
pattern. Add a closing parenthesis in the appropriate position. See
perlre.
- switching effective %s is not implemented
- (F) While under the "use filetest"
pragma, we cannot switch the real and effective uids or gids.
- syntax error
- (F) Probably means you had a syntax error. Common reasons include:
A keyword is misspelled.
A semicolon is missing.
A comma is missing.
An opening or closing parenthesis is missing.
An opening or closing brace is missing.
A closing quote is missing.
Often there will be another error message associated with the
syntax error giving more information. (Sometimes it helps to turn on
-w.) The error message itself often tells you where it was in the
line when it decided to give up. Sometimes the actual error is several
tokens before this, because Perl is good at understanding random input.
Occasionally the line number may be misleading, and once in a blue moon
the only way to figure out what's triggering the error is to call
"perl -c" repeatedly, chopping away
half the program each time to see if the error went away. Sort of the
cybernetic version of 20 questions.
- syntax error at line %d: '%s' unexpected
- (A) You've accidentally run your script through the Bourne shell instead
of Perl. Check the #! line, or manually feed your script into Perl
yourself.
- syntax error in file %s at line %d, next 2 tokens "%s"
- (F) This error is likely to occur if you run a perl5 script through a
perl4 interpreter, especially if the next 2 tokens are "use
strict" or "my $var" or "our
$var".
- Syntax error in (?[...]) in regex; marked by <-- HERE in m/%s/
- (F) Perl could not figure out what you meant inside this construct; this
notifies you that it is giving up trying.
- %s syntax OK
- (F) The final summary message when a "perl
-c" succeeds.
- sysread() on closed filehandle %s
- (W closed) You tried to read from a closed filehandle.
- sysread() on unopened filehandle %s
- (W unopened) You tried to read from a filehandle that was never
opened.
- System V %s is not implemented on this machine
- (F) You tried to do something with a function beginning with
"sem", "shm", or "msg" but that System V IPC
is not implemented in your machine. In some machines the functionality can
exist but be unconfigured. Consult your system support.
- syswrite() on closed filehandle %s
- (W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
- "-T" and "-B" not implemented on filehandles
- (F) Perl can't peek at the stdio buffer of filehandles when it doesn't
know about your kind of stdio. You'll have to use a filename instead.
- Target of goto is too deeply nested
- (F) You tried to use "goto" to reach a
label that was too deeply nested for Perl to reach. Perl is doing you a
favor by refusing.
- telldir() attempted on invalid dirhandle %s
- (W io) The dirhandle you tried to telldir() is either closed or not
really a dirhandle. Check your control flow.
- tell() on unopened filehandle
- (W unopened) You tried to use the tell() function on a filehandle
that was either never opened or has since been closed.
- The alpha_assertions feature is experimental
- (S experimental::alpha_assertions) This feature is experimental and its
behavior may change in any future release of perl. See "Extended
Patterns" in perlre.
- The crypt() function is unimplemented due to excessive
paranoia.
- (F) Configure couldn't find the crypt() function on your machine,
probably because your vendor didn't supply it, probably because they think
the U.S. Government thinks it's a secret, or at least that they will
continue to pretend that it is. And if you quote me on that, I will deny
it.
- The experimental declared_refs feature is not enabled
- (F) To declare references to variables, as in "my
\%x", you must first enable the feature:
no warnings "experimental::declared_refs";
use feature "declared_refs";
- The %s function is unimplemented
- (F) The function indicated isn't implemented on this architecture,
according to the probings of Configure.
- The private_use feature is experimental
- (S experimental::private_use) This feature is actually a hook for future
use.
- The regex_sets feature is experimental
- (S experimental::regex_sets) This warning is emitted if you use the syntax
"(?[ ])" in a
regular expression. The details of this feature are subject to change. If
you want to use it, but know that in doing so you are taking the risk of
using an experimental feature which may change in a future Perl version,
you can do this to silence the warning:
no warnings "experimental::regex_sets";
- The script_run feature is experimental
- (S experimental::script_run) This feature is experimental and its behavior
may in any future release of perl. See "Script Runs" in
perlre.
- The signatures feature is experimental
- (S experimental::signatures) This warning is emitted if you unwrap a
subroutine's arguments using a signature. 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::signatures";
use feature "signatures";
sub foo ($left, $right) { ... }
- The stat preceding %s wasn't an lstat
- (F) It makes no sense to test the current stat buffer for symbolic
linkhood if the last stat that wrote to the stat buffer already went past
the symlink to get to the real file. Use an actual filename instead.
- The Unicode property wildcards feature is experimental
- (S experimental::uniprop_wildcards) This feature is experimental and its
behavior may in any future release of perl. See "Wildcards in
Property Values" in perlunicode.
- The 'unique' attribute may only be applied to 'our' variables
- (F) This attribute was never supported on
"my" or
"sub" declarations.
- This Perl can't reset CRTL environ elements (%s)
- This Perl can't set CRTL environ elements (%s=%s)
- (W internal) Warnings peculiar to VMS. You tried to change or delete an
element of the CRTL's internal environ array, but your copy of Perl wasn't
built with a CRTL that contained the setenv() function. You'll need
to rebuild Perl with a CRTL that does, or redefine PERL_ENV_TABLES
(see perlvms) so that the environ array isn't the target of the change to
%ENV which produced the warning.
- This Perl has not been built with support for randomized hash key
traversal but something called Perl_hv_rand_set().
- (F) Something has attempted to use an internal API call which depends on
Perl being compiled with the default support for randomized hash key
traversal, but this Perl has been compiled without it. You should report
this warning to the relevant upstream party, or recompile perl with
default options.
- This use of my() in false conditional is no longer allowed
- (F) You used a declaration similar to "my $x if
0". There has been a long-standing bug in Perl that causes a
lexical variable not to be cleared at scope exit when its declaration
includes a false conditional. Some people have exploited this bug to
achieve a kind of static variable. Since we intend to fix this bug, we
don't want people relying on this behavior. You can achieve a similar
static effect by declaring the variable in a separate block outside the
function, eg
sub f { my $x if 0; return $x++ }
becomes
{ my $x; sub f { return $x++ } }
Beginning with perl 5.10.0, you can also use
"state" variables to have lexicals
that are initialized only once (see feature):
sub f { state $x; return $x++ }
This use of "my()" in a
false conditional was deprecated beginning in Perl 5.10 and became a
fatal error in Perl 5.30.
- times not implemented
- (F) Your version of the C library apparently doesn't do times(). I
suspect you're not running on Unix.
- "-T" is on the #! line, it must also be used on the command
line
- (X) The #! line (or local equivalent) in a Perl script contains the
-T option (or the -t option), but Perl was not invoked with
-T in its command line. This is an error because, by the time Perl
discovers a -T in a script, it's too late to properly taint
everything from the environment. So Perl gives up.
If the Perl script is being executed as a command using the #!
mechanism (or its local equivalent), this error can usually be fixed by
editing the #! line so that the -%c option is a part of Perl's
first argument: e.g. change "perl -n
-%c" to "perl -%c -n".
If the Perl script is being executed as
"perl scriptname", then the -%c
option must appear on the command line: "perl -%c
scriptname".
- To%s: illegal mapping '%s'
- (F) You tried to define a customized To-mapping for lc(), lcfirst,
uc(), or ucfirst() (or their string-inlined versions), but
you specified an illegal mapping. See "User-Defined Character
Properties" in perlunicode.
- Too deeply nested ()-groups
- (F) Your template contains ()-groups with a ridiculously deep nesting
level.
- Too few args to syscall
- (F) There has to be at least one argument to syscall() to specify
the system call to call, silly dilly.
- Too few arguments for subroutine '%s'
- (F) A subroutine using a signature fewer arguments than required by the
signature. The caller of the subroutine is presumably at fault.
The message attempts to include the name of the called
subroutine. If the subroutine has been aliased, the subroutine's
original name will be shown, regardless of what name the caller
used.
- Too late for "-%s" option
- (X) The #! line (or local equivalent) in a Perl script contains the
-M, -m or -C option.
In the case of -M and -m, this is an error
because those options are not intended for use inside scripts. Use the
"use" pragma instead.
The -C option only works if it is specified on the
command line as well (with the same sequence of letters or numbers
following). Either specify this option on the command line, or, if your
system supports it, make your script executable and run it directly
instead of passing it to perl.
- Too late to run %s block
- (W void) A CHECK or INIT block is being defined during run time proper,
when the opportunity to run them has already passed. Perhaps you are
loading a file with "require" or
"do" when you should be using
"use" instead. Or perhaps you should put
the "require" or
"do" inside a BEGIN block.
- Too many args to syscall
- (F) Perl supports a maximum of only 14 args to syscall().
- Too many arguments for %s
- (F) The function requires fewer arguments than you specified.
- Too many arguments for subroutine '%s'
- (F) A subroutine using a signature received more arguments than permitted
by the signature. The caller of the subroutine is presumably at fault.
The message attempts to include the name of the called
subroutine. If the subroutine has been aliased, the subroutine's
original name will be shown, regardless of what name the caller
used.
- Too many nested open parens in regex; marked by <-- HERE in m/%s/
- (F) You have exceeded the number of open
"(" parentheses that haven't been
matched by corresponding closing ones. This limit prevents eating up too
much memory. It is initially set to 1000, but may be changed by setting
"${^RE_COMPILE_RECURSION_LIMIT}" to some
other value. This may need to be done in a BEGIN block before the regular
expression pattern is compiled.
- Too many )'s
- (A) You've accidentally run your script through csh instead of
Perl. Check the #! line, or manually feed your script into Perl
yourself.
- Too many ('s
- (A) You've accidentally run your script through csh instead of
Perl. Check the #! line, or manually feed your script into Perl
yourself.
- Trailing \ in regex m/%s/
- (F) The regular expression ends with an unbackslashed backslash. Backslash
it. See perlre.
- Transliteration pattern not terminated
- (F) The lexer couldn't find the interior delimiter of a tr/// or tr[][] or
y/// or y[][] construct. Missing the leading
"$" from variables
$tr or $y may cause this
error.
- Transliteration replacement not terminated
- (F) The lexer couldn't find the final delimiter of a tr///, tr[][], y///
or y[][] construct.
- '%s' trapped by operation mask
- (F) You tried to use an operator from a Safe compartment in which it's
disallowed. See Safe.
- truncate not implemented
- (F) Your machine doesn't implement a file truncation mechanism that
Configure knows about.
- Type of arg %d to &CORE::%s must be %s
- (F) The subroutine in question in the CORE package requires its argument
to be a hard reference to data of the specified type. Overloading is
ignored, so a reference to an object that is not the specified type, but
nonetheless has overloading to handle it, will still not be accepted.
- Type of arg %d to %s must be %s (not %s)
- (F) This function requires the argument in that position to be of a
certain type. Arrays must be @NAME or
"@{EXPR}". Hashes must be
%NAME or
"%{EXPR}". No implicit dereferencing is
allowed--use the {EXPR} forms as an explicit dereference. See
perlref.
- umask not implemented
- (F) Your machine doesn't implement the umask function and you tried to use
it to restrict permissions for yourself (EXPR & 0700).
- Unbalanced context: %d more PUSHes than POPs
- (S internal) The exit code detected an internal inconsistency in how many
execution contexts were entered and left.
- Unbalanced saves: %d more saves than restores
- (S internal) The exit code detected an internal inconsistency in how many
values were temporarily localized.
- Unbalanced scopes: %d more ENTERs than LEAVEs
- (S internal) The exit code detected an internal inconsistency in how many
blocks were entered and left.
- Unbalanced string table refcount: (%d) for "%s"
- (S internal) On exit, Perl found some strings remaining in the shared
string table used for copy on write and for hash keys. The entries should
have been freed, so this indicates a bug somewhere.
- Unbalanced tmps: %d more allocs than frees
- (S internal) The exit code detected an internal inconsistency in how many
mortal scalars were allocated and freed.
- Undefined format "%s" called
- (F) The format indicated doesn't seem to exist. Perhaps it's really in
another package? See perlform.
- Undefined sort subroutine "%s" called
- (F) The sort comparison routine specified doesn't seem to exist. Perhaps
it's in a different package? See "sort" in perlfunc.
- Undefined subroutine &%s called
- (F) The subroutine indicated hasn't been defined, or if it was, it has
since been undefined.
- Undefined subroutine called
- (F) The anonymous subroutine you're trying to call hasn't been defined, or
if it was, it has since been undefined.
- Undefined subroutine in sort
- (F) The sort comparison routine specified is declared but doesn't seem to
have been defined yet. See "sort" in perlfunc.
- Undefined top format "%s" called
- (F) The format indicated doesn't seem to exist. Perhaps it's really in
another package? See perlform.
- Undefined value assigned to typeglob
- (W misc) An undefined value was assigned to a typeglob, a la
"*foo = undef". This does nothing. It's
possible that you really mean "undef
*foo".
- %s: Undefined variable
- (A) You've accidentally run your script through csh instead of
Perl. Check the #! line, or manually feed your script into Perl
yourself.
- Unescaped left brace in regex is passed through in regex; marked by
<-- HERE in m/%s/
- (W regexp) The simple rule to remember, if you want to match a literal
"{" character (U+007B
"LEFT CURLY BRACKET") in a regular
expression pattern, is to escape each literal instance of it in some way.
Generally easiest is to precede it with a backslash, like
"\{" or enclose it in square brackets
("[{]"). If the pattern delimiters are
also braces, any matching right brace
("}") should also be escaped to avoid
confusing the parser, for example,
qr{abc\{def\}ghi}
Forcing literal "{"
characters to be escaped will enable the Perl language to be extended in
various ways in future releases. To avoid needlessly breaking existing
code, the restriction is is not enforced in contexts where there are
unlikely to ever be extensions that could conflict with the use there of
"{" as a literal. Those that are not
potentially ambiguous do not warn; those that are do raise a
non-deprecation warning.
In this release of Perl, some literal uses of
"{" are fatal, and some still just
deprecated. This is because of an oversight: some uses of a literal
"{" that should have raised a
deprecation warning starting in v5.20 did not warn until v5.26. By
making the already-warned uses fatal now, some of the planned extensions
can be made to the language sooner. The cases which are still allowed
will be fatal in Perl 5.32.
The contexts where no warnings or errors are raised are:
- Unescaped literal '%c' in regex; marked by <-- HERE in m/%s/
- (W regexp) (only under
"use re 'strict'")
Within the scope of
"use re 'strict'" in a
regular expression pattern, you included an unescaped
"}" or
"]" which was interpreted literally.
These two characters are sometimes metacharacters, and sometimes
literals, depending on what precedes them in the pattern. This is unlike
the similar ")" which is always a
metacharacter unless escaped.
This action at a distance, perhaps a large distance, can lead
to Perl silently misinterpreting what you meant, so when you specify
that you want extra checking by
"use re 'strict'", this
warning is generated. If you meant the character as a literal, simply
confirm that to Perl by preceding the character with a backslash, or
make it into a bracketed character class (like
"[}]"). If you meant it as closing a
corresponding "[" or
"{", you'll need to look back through
the pattern to find out why that isn't happening.
- unexec of %s into %s failed!
- (F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
- Unexpected binary operator '%c' with no preceding operand in regex; marked
by <-- HERE in m/%s/
- (F) You had something like this:
(?[ | \p{Digit} ])
where the "|" is a binary
operator with an operand on the right, but no operand on the left.
- Unexpected character in regex; marked by <-- HERE in m/%s/
- (F) You had something like this:
(?[ z ])
Within "(?[ ])", no literal
characters are allowed unless they are within an inner pair of square
brackets, like
(?[ [ z ] ])
Another possibility is that you forgot a backslash. Perl isn't
smart enough to figure out what you really meant.
- Unexpected constant lvalue entersub entry via type/targ %d:%d
- (P) When compiling a subroutine call in lvalue context, Perl failed an
internal consistency check. It encountered a malformed op tree.
- Unexpected exit %u
- (S) exit() was called or the script otherwise finished gracefully
when "PERL_EXIT_WARN" was set in
"PL_exit_flags".
- Unexpected exit failure %d
- (S) An uncaught die() was called when
"PERL_EXIT_WARN" was set in
"PL_exit_flags".
- Unexpected ')' in regex; marked by <-- HERE in m/%s/
- (F) You had something like this:
(?[ ( \p{Digit} + ) ])
The ")" is out-of-place.
Something apparently was supposed to be combined with the digits, or the
"+" shouldn't be there, or something
like that. Perl can't figure out what was intended.
- Unexpected ']' with no following ')' in (?[... in regex; marked by <--
HERE in m/%s/
- (F) While parsing an extended character class a ']' character was
encountered at a point in the definition where the only legal use of ']'
is to close the character class definition as part of a '])', you may have
forgotten the close paren, or otherwise confused the parser.
- Unexpected '(' with no preceding operator in regex; marked by
<-- HERE in m/%s/
- (F) You had something like this:
(?[ \p{Digit} ( \p{Lao} + \p{Thai} ) ])
There should be an operator before the
"(", as there's no indication as to
how the digits are to be combined with the characters in the Lao and
Thai scripts.
- Unicode non-character U+%X is not recommended for open interchange
- (S nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are defined by
the Unicode standard to be non-characters. Those are legal codepoints, but
are reserved for internal use; so, applications shouldn't attempt to
exchange them. An application may not be expecting any of these characters
at all, and receiving them may lead to bugs. If you know what you are
doing you can turn off this warning by "no warnings
'nonchar';".
This is not really a "severe" error, but it is
supposed to be raised by default even if warnings are not enabled, and
currently the only way to do that in Perl is to mark it as serious.
- Unicode property wildcard not terminated
- (F) A Unicode property wildcard looks like a delimited regular expression
pattern (all within the braces of the enclosing
"\p{...}". The closing delimtter to
match the opening one was not found. If the opening one is escaped by
preceding it with a backslash, the closing one must also be so
escaped.
- Unicode surrogate U+%X is illegal in UTF-8
- (S surrogate) You had a UTF-16 surrogate in a context where they are not
considered acceptable. These code points, between U+D800 and U+DFFF
(inclusive), are used by Unicode only for UTF-16. However, Perl internally
allows all unsigned integer code points (up to the size limit available on
your platform), including surrogates. But these can cause problems when
being input or output, which is likely where this message came from. If
you really really know what you are doing you can turn off this warning by
"no warnings 'surrogate';".
- Unknown charname '%s'
- (F) The name you used inside "\N{}" is
unknown to Perl. Check the spelling. You can say
"use charnames ":loose"" to
not have to be so precise about spaces, hyphens, and capitalization on
standard Unicode names. (Any custom aliases that have been created must be
specified exactly, regardless of whether
":loose" is used or not.) This error may
also happen if the "\N{}" is not in the
scope of the corresponding
"use charnames".
- Unknown '(*...)' construct '%s' in regex; marked by <-- HERE in
m/%s/
- (F) The "(*" was followed by something
that the regular expression compiler does not recognize. Check your
spelling.
- Unknown error
- (P) Perl was about to print an error message in
$@, but the $@ variable
did not exist, even after an attempt to create it.
- Unknown locale category %d; can't set it to %s
- (W locale) You used a locale category that perl doesn't recognize, so it
cannot carry out your request. Check that you are using a valid category.
If so, see "Multi-threaded" in perllocale for advice on
reporting this as a bug, and for modifying perl locally to accommodate
your needs.
- Unknown open() mode '%s'
- (F) The second argument of 3-argument open() is not among the list
of valid modes: "<",
">",
">>",
"+<",
"+>",
"+>>",
"-|",
"|-",
"<&",
">&".
- Unknown PerlIO layer "%s"
- (W layer) An attempt was made to push an unknown layer onto the Perl I/O
system. (Layers take care of transforming data between external and
internal representations.) Note that some layers, such as
"mmap", are not supported in all
environments. If your program didn't explicitly request the failing
operation, it may be the result of the value of the environment variable
PERLIO.
- Unknown process %x sent message to prime_env_iter: %s
- (P) An error peculiar to VMS. Perl was reading values for
%ENV before iterating over it, and someone else
stuck a message in the stream of data Perl expected. Someone's very
confused, or perhaps trying to subvert Perl's population of
%ENV for nefarious purposes.
- Unknown regexp modifier "/%s"
- (F) Alphanumerics immediately following the closing delimiter of a regular
expression pattern are interpreted by Perl as modifier flags for the
regex. One of the ones you specified is invalid. One way this can happen
is if you didn't put in white space between the end of the regex and a
following alphanumeric operator:
if ($a =~ /foo/and $bar == 3) { ... }
The "a" is a valid modifier
flag, but the "n" is not, and raises
this error. Likely what was meant instead was:
if ($a =~ /foo/ and $bar == 3) { ... }
- Unknown "re" subpragma '%s' (known ones are: %s)
- (W) You tried to use an unknown subpragma of the "re"
pragma.
- Unknown switch condition (?(...)) in regex; marked by <-- HERE
in m/%s/
- (F) The condition part of a (?(condition)if-clause|else-clause) construct
is not known. The condition must be one of the following:
(1) (2) ... true if 1st, 2nd, etc., capture matched
(<NAME>) ('NAME') true if named capture matched
(?=...) (?<=...) true if subpattern matches
(*pla:...) (*plb:...) true if subpattern matches; also
(*positive_lookahead:...)
(*positive_lookbehind:...)
(*nla:...) (*nlb:...) true if subpattern fails to match; also
(*negative_lookahead:...)
(*negative_lookbehind:...)
(?{ CODE }) true if code returns a true value
(R) true if evaluating inside recursion
(R1) (R2) ... true if directly inside capture group 1, 2,
etc.
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See perlre.
- Unknown Unicode option letter '%c'
- (F) You specified an unknown Unicode option. See perlrun documentation of
the "-C" switch for the list of known
options.
- Unknown Unicode option value %d
- (F) You specified an unknown Unicode option. See perlrun documentation of
the "-C" switch for the list of known
options.
- Unknown verb pattern '%s' in regex; marked by <-- HERE in
m/%s/
- (F) You either made a typo or have incorrectly put a
"*" quantifier after an open brace in
your pattern. Check the pattern and review perlre for details on legal
verb patterns.
- Unknown warnings category '%s'
- (F) An error issued by the "warnings"
pragma. You specified a warnings category that is unknown to perl at this
point.
Note that if you want to enable a warnings category registered
by a module (e.g. "use warnings
'File::Find'"), you must have loaded this module first.
- Unmatched [ in regex; marked by <-- HERE in m/%s/
- (F) The brackets around a character class must match. If you wish to
include a closing bracket in a character class, backslash it or put it
first. The <-- HERE shows whereabouts in the regular expression
the problem was discovered. See perlre.
- Unmatched ( in regex; marked by <-- HERE in m/%s/
- Unmatched ) in regex; marked by <-- HERE in m/%s/
- (F) Unbackslashed parentheses must always be balanced in regular
expressions. If you're a vi user, the % key is valuable for finding the
matching parenthesis. The <-- HERE shows whereabouts in the
regular expression the problem was discovered. See perlre.
- Unmatched right %s bracket
- (F) The lexer counted more closing curly or square brackets than opening
ones, so you're probably missing a matching opening bracket. As a general
rule, you'll find the missing one (so to speak) near the place you were
last editing.
- Unquoted string "%s" may clash with future reserved word
- (W reserved) You used a bareword that might someday be claimed as a
reserved word. It's best to put such a word in quotes, or capitalize it
somehow, or insert an underbar into it. You might also declare it as a
subroutine.
- Unrecognized character %s; marked by <-- HERE after %s near
column %d
- (F) The Perl parser has no idea what to do with the specified character in
your Perl script (or eval) near the specified column. Perhaps you tried to
run a compressed script, a binary program, or a directory as a Perl
program.
- Unrecognized escape \%c in character class in regex; marked by
<-- HERE in m/%s/
- (F) You used a backslash-character combination which is not recognized by
Perl inside character classes. This is a fatal error when the character
class is used within "(?[ ])".
- Unrecognized escape \%c in character class passed through in regex; marked
by <-- HERE in m/%s/
- (W regexp) You used a backslash-character combination which is not
recognized by Perl inside character classes. The character was understood
literally, but this may change in a future version of Perl. The
<-- HERE shows whereabouts in the regular expression the escape
was discovered.
- Unrecognized escape \%c passed through
- (W misc) You used a backslash-character combination which is not
recognized by Perl. The character was understood literally, but this may
change in a future version of Perl.
- Unrecognized escape \%s passed through in regex; marked by
<-- HERE in m/%s/
- (W regexp) You used a backslash-character combination which is not
recognized by Perl. The character(s) were understood literally, but this
may change in a future version of Perl. The <-- HERE shows
whereabouts in the regular expression the escape was discovered.
- Unrecognized signal name "%s"
- (F) You specified a signal name to the kill() function that was not
recognized. Say "kill -l" in your shell
to see the valid signal names on your system.
- Unrecognized switch: -%s (-h will show valid options)
- (F) You specified an illegal option to Perl. Don't do that. (If you think
you didn't do that, check the #! line to see if it's supplying the bad
switch on your behalf.)
 See
"chomp" in perlfunc.
- Unsupported directory function "%s" called
- (F) Your machine doesn't support opendir() and
readdir().
- Unsupported function %s
- (F) This machine doesn't implement the indicated function, apparently. At
least, Configure doesn't think so.
- Unsupported function fork
- (F) Your version of executable does not support forking.
Note that under some systems, like OS/2, there may be
different flavors of Perl executables, some of which may support fork,
some not. Try changing the name you call Perl by to
"perl_",
"perl__", and so on.
- Unsupported script encoding %s
- (F) Your program file begins with a Unicode Byte Order Mark (BOM) which
declares it to be in a Unicode encoding that Perl cannot read.
- Unsupported socket function "%s" called
- (F) Your machine doesn't support the Berkeley socket mechanism, or at
least that's what Configure thought.
- Unterminated '(*...' argument in regex; marked by <-- HERE in
m/%s/
- (F) You used a pattern of the form
"(*...:...)" but did not terminate the
pattern with a ")". Fix the pattern and
retry.
- Unterminated attribute list
- (F) The lexer found something other than a simple identifier at the start
of an attribute, and it wasn't a semicolon or the start of a block.
Perhaps you terminated the parameter list of the previous attribute too
soon. See attributes.
- Unterminated attribute parameter in attribute list
- (F) The lexer saw an opening (left) parenthesis character while parsing an
attribute list, but the matching closing (right) parenthesis character was
not found. You may need to add (or remove) a backslash character to get
your parentheses to balance. See attributes.
- Unterminated compressed integer
- (F) An argument to unpack("w",...) was incompatible with the BER
compressed integer format and could not be converted to an integer. See
"pack" in perlfunc.
- Unterminated '(*...' construct in regex; marked by <-- HERE in
m/%s/
- (F) You used a pattern of the form
"(*...)" but did not terminate the
pattern with a ")". Fix the pattern and
retry.
- Unterminated delimiter for here document
- (F) This message occurs when a here document label has an initial
quotation mark but the final quotation mark is missing. Perhaps you wrote:
<<"foo
instead of:
<<"foo"
- Unterminated \g... pattern in regex; marked by <-- HERE in
m/%s/
- Unterminated \g{...} pattern in regex; marked by <-- HERE in
m/%s/
- (F) In a regular expression, you had a
"\g" that wasn't followed by a proper
group reference. In the case of "\g{",
the closing brace is missing; otherwise the
"\g" must be followed by an integer. Fix
the pattern and retry.
- Unterminated <> operator
- (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".
- Unterminated verb pattern argument in regex; marked by <-- HERE
in m/%s/
- (F) You used a pattern of the form
"(*VERB:ARG)" but did not terminate the
pattern with a ")". Fix the pattern and
retry.
- Unterminated verb pattern in regex; marked by <-- HERE in
m/%s/
- (F) You used a pattern of the form
"(*VERB)" but did not terminate the
pattern with a ")". Fix the pattern and
retry.
- untie attempted while %d inner references still exist
- (W untie) A copy of the object returned from
"tie" (or
"tied") was still valid when
"untie" was called.
- Usage: POSIX::%s(%s)
- (F) You called a POSIX function with incorrect arguments. See
"FUNCTIONS" in POSIX for more information.
- Usage: Win32::%s(%s)
- (F) You called a Win32 function with incorrect arguments. See Win32 for
more information.
- $[ used in %s (did you mean $] ?)
- (W syntax) You used $[ in a comparison, such as:
if ($[ > 5.006) {
...
}
You probably meant to use $] instead.
$[ is the base for indexing arrays.
$] is the Perl version number in decimal.
- Use "%s" instead of "%s"
- (F) The second listed construct is no longer legal. Use the first one
instead.
- Useless assignment to a temporary
- (W misc) You assigned to an lvalue subroutine, but what the subroutine
returned was a temporary scalar about to be discarded, so the assignment
had no effect.
- Useless (?-%s) - don't use /%s modifier in regex; marked by
<-- HERE in m/%s/
- (W regexp) You have used an internal modifier such as (?-o) that has no
meaning unless removed from the entire regexp:
if ($string =~ /(?-o)$pattern/o) { ... }
must be written as
if ($string =~ /$pattern/) { ... }
The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See perlre.
- Useless localization of %s
- (W syntax) The localization of lvalues such as
"local($x=10)" is legal, but in fact the
local() currently has no effect. This may change at some point in
the future, but in the meantime such code is discouraged.
- Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in
m/%s/
- (W regexp) You have used an internal modifier such as (?o) that has no
meaning unless applied to the entire regexp:
if ($string =~ /(?o)$pattern/) { ... }
must be written as
if ($string =~ /$pattern/o) { ... }
The <-- HERE shows whereabouts in the regular
expression the problem was discovered. See perlre.
- Useless use of attribute "const"
- (W misc) The "const" attribute has no
effect except on anonymous closure prototypes. You applied it to a
subroutine via attributes.pm. This is only useful inside an attribute
handler for an anonymous subroutine.
- Useless use of /d modifier in transliteration operator
- (W misc) You have used the /d modifier where the searchlist has the same
length as the replacelist. See perlop for more information about the /d
modifier.
- Useless use of \E
- (W misc) You have a \E in a double-quotish string without a
"\U",
"\L" or
"\Q" preceding it.
- Useless use of greediness modifier '%c' in regex; marked by
<-- HERE in m/%s/
- (W regexp) You specified something like these:
qr/a{3}?/
qr/b{1,1}+/
The "?" and
"+" don't have any effect, as they
modify whether to match more or fewer when there is a choice, and by
specifying to match exactly a given numer, there is no room left for a
choice.
- Useless use of %s in void context
- (W void) You did something without a side effect in a context that does
nothing with the return value, such as a statement that doesn't return a
value from a block, or the left side of a scalar comma operator. Very
often this points not to stupidity on your part, but a failure of Perl to
parse your program the way you thought it would. For example, you'd get
this if you mixed up your C precedence with Python precedence and said
$one, $two = 1, 2;
when you meant to say
($one, $two) = (1, 2);
Another common error is to use ordinary parentheses to
construct a list reference when you should be using square or curly
brackets, for example, if you say
$array = (1,2);
when you should have said
$array = [1,2];
The square brackets explicitly turn a list value into a scalar
value, while parentheses do not. So when a parenthesized list is
evaluated in a scalar context, the comma is treated like C's comma
operator, which throws away the left argument, which is not what you
want. See perlref for more on this.
This warning will not be issued for numerical constants equal
to 0 or 1 since they are often used in statements like
1 while sub_with_side_effects();
String constants that would normally evaluate to 0 or 1 are
warned about.
- Useless use of (?-p) in regex; marked by <-- HERE in m/%s/
- (W regexp) The "p" modifier cannot be
turned off once set. Trying to do so is futile.
- Useless use of "re" pragma
- (W) You did "use re;" without any
arguments. That isn't very useful.
- Useless use of sort in scalar context
- (W void) You used sort in scalar context, as in :
my $x = sort @y;
This is not very useful, and perl currently optimizes this
away.
- Useless use of %s with no values
- (W syntax) You used the push() or unshift() function with no
arguments apart from the array, like
"push(@x)" or
"unshift(@foo)".  It's possible in
principle that push(@tied_array) could have some effect if the array is
tied to a class which implements a PUSH method. If so, you can write it as
"push(@tied_array,())" to avoid this
warning.
- "use" not allowed in expression
- (F) The "use" keyword is recognized and executed at compile
time, and returns no useful value. See perlmod.
- Use of bare << to mean <<"" is forbidden
- (F) You are now required to use the explicitly quoted form if you wish to
use an empty line as the terminator of the here-document.
Use of a bare terminator was deprecated in Perl 5.000, and is
a fatal error as of Perl 5.28.
- Use of /c modifier is meaningless in s///
- (W regexp) You used the /c modifier in a substitution. The /c modifier is
not presently meaningful in substitutions.
- Use of /c modifier is meaningless without /g
- (W regexp) You used the /c modifier with a regex operand, but didn't use
the /g modifier. Currently, /c is meaningful only when /g is used. (This
may change in the future.)
- Use of code point 0x%s is not allowed; the permissible max is 0x%x
- Use of code point 0x%s is not allowed; the permissible max is 0x%x in
regex; marked by <-- HERE in m/%s/
- (F) You used a code point that is not allowed, because it is too large.
Unicode only allows code points up to 0x10FFFF, but Perl allows much
larger ones. Earlier versions of Perl allowed code points above IV_MAX
(0x7FFFFFF on 32-bit platforms, 0x7FFFFFFFFFFFFFFF on 64-bit platforms),
however, this could possibly break the perl interpreter in some
constructs, including causing it to hang in a few cases.
If your code is to run on various platforms, keep in mind that
the upper limit depends on the platform. It is much larger on 64-bit
word sizes than 32-bit ones.
The use of out of range code points was deprecated in Perl
5.24, and became a fatal error in Perl 5.28.
- Use of each() on hash after insertion without resetting hash
iterator results in undefined behavior
- (S internal) The behavior of "each()"
after insertion is undefined; it may skip items, or visit items more than
once. Consider using "keys()" instead of
"each()".
- Use of := for an empty attribute list is not allowed
- (F) The construction "my $x := 42" used
to parse as equivalent to "my $x : = 42"
(applying an empty attribute list to $x). This
construct was deprecated in 5.12.0, and has now been made a syntax error,
so ":=" can be reclaimed as a new
operator in the future.
If you need an empty attribute list, for example in a code
generator, add a space before the
"=".
- Use of %s for non-UTF-8 locale is wrong.  This construct is only valid for
UTF-8 locales, which the current locale isn't. This doesn't make sense.
Perl will continue, assuming a Unicode (UTF-8) locale, but the results are