(W) A warning (optional).
(D) A deprecation (optional).
- (S) A severe warning (default).
+ (S) A severe warning (enabled by default).
(F) A fatal error (trappable).
(P) An internal error you should never see (trappable).
(X) A very fatal error (nontrappable).
to a reference to a routine that will be called on each warning instead
of printing it. See L<perlvar>.
-Default warnings are always enabled unless they are explicitly disabled
+Severe warnings are always enabled, unless they are explicitly disabled
with the C<warnings> pragma or the B<-X> switch.
Trappable errors may be trapped using the eval operator. See
(F) msgsnd() requires a string at least as long as sizeof(long).
-=item %s argument is not a HASH or ARRAY element
+=item %s argument is not a HASH or ARRAY element or a subroutine
-(F) The argument to exists() must be a hash or array element, such as:
+(F) The argument to exists() must be a hash or array element or a
+subroutine with an ampersand, such as:
$foo{$bar}
$ref->{"susie"}[12]
+ &do_something
=item %s argument is not a HASH or ARRAY element or slice
literals or global values as arguments to the "p" pack() template to
avoid this warning.
+=item Attempt to reload %s aborted.
+
+(F) You tried to load a file with C<use> or C<require> that failed to
+compile once already. Perl will not try to compile this file again
+unless you delete its entry from %INC. See L<perlfunc/require> and
+L<perlvar/%INC>.
+
=item Attempt to set length of freed array
(W) You tried to set the length of an array which has been freed. You
(P) An internal request asked to add an array entry to something that
wasn't a symbol table entry.
+=item Bad symbol for dirhandle
+
+(P) An internal request asked to add a dirhandle entry to something
+that wasn't a symbol table entry.
+
+
=item Bad symbol for filehandle
(P) An internal request asked to add a filehandle entry to something
(F) An argument to pack("w",...) was negative. The BER compressed integer
format can only be used with positive integers. See L<perlfunc/pack>.
+=item Cannot convert a reference to %s to typeglob
+
+(F) You manipulated Perl's symbol table directly, stored a reference in it,
+then tried to access that symbol via conventional Perl syntax. The access
+triggers Perl to autovivify that typeglob, but it there is no legal conversion
+from that type of reference to a typeglob.
+
+=item Cannot copy to %s in %s
+
+(P) Perl detected an attempt to copy a value to an internal type that cannot
+be directly assigned not.
+
=item Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer. The BER compressed
(F) Only hard references may be blessed. This is how Perl "enforces"
encapsulation of objects. See L<perlobj>.
+=item Can't "break" in a loop topicalizer
+
+(F) You called C<break>, but you're in a C<foreach> block rather than
+a C<given> block. You probably meant to use C<next> or C<last>.
+
+=item Can't "break" outside a given block
+
+(F) You called C<break>, but you're not inside a C<given> block.
+
=item Can't call method "%s" in empty package "%s"
(F) You called a method correctly, and it correctly indicated a package
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are.
+=item Can't "continue" outside a when block
+
+(F) You called C<continue>, but you're not inside a C<when>
+or C<default> block.
+
=item Can't create pipe mailbox
(P) An error peculiar to VMS. The process is suffering from exhausted
=item Can't declare class for non-scalar %s in "%s"
(F) Currently, only scalar variables can be declared with a specific
-class qualifier in a "my" or "our" declaration. The semantics may be
+class qualifier in a "my", "our" or "state" declaration. The semantics may be
extended for other types of variables in future.
=item Can't declare %s in "%s"
-(F) Only scalar, array, and hash variables may be declared as "my" or
-"our" variables. They must have ordinary identifiers as names.
+(F) Only scalar, array, and hash variables may be declared as "my", "our" or
+"state" variables. They must have ordinary identifiers as names.
=item Can't do inplace edit: %s is not a regular file
found in the PATH, or at least not with the correct permissions. The
script exists in the current directory, but PATH prohibits running it.
-=item Can't find %s property definition %s
-
-(F) You may have tried to use C<\p> which means a Unicode property (for
-example C<\p{Lu}> is all uppercase letters). If you did mean to use a
-Unicode property, see L<perlunicode> for the list of known properties.
-If you didn't mean to use a Unicode property, escape the C<\p>, either
-by C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, until
-possible C<\E>).
-
=item Can't find string terminator %s anywhere before EOF
(F) Perl strings can stretch over multiple lines. This message means
unseen whitespace before or after your closing tag. A good programmer's
editor will have a way to help you find these characters.
+=item Can't find Unicode property definition "%s"
+
+(F) You may have tried to use C<\p> which means a Unicode property (for
+example C<\p{Lu}> is all uppercase letters). If you did mean to use a
+Unicode property, see L<perlunicode> for the list of known properties.
+If you didn't mean to use a Unicode property, escape the C<\p>, either
+by C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, until
+possible C<\E>).
+
=item Can't fork
(F) A fatal error occurred while trying to fork while opening a
inner curlies will be considered a block that loops once. See
L<perlfunc/last>.
+=item Can't linearize anonymous symbol table
+
+(F) Perl tried to calculate the method resolution order (MRO) of a
+package, but failed because the package stash has no name.
+
=item Can't load '%s' for module %s
(F) The module you tried to load failed to load a dynamic extension. This
=item Can't localize lexical variable %s
(F) You used local on a variable name that was previously declared as a
-lexical variable using "my". This is not allowed. If you want to
+lexical variable using "my" or "state". This is not allowed. If you want to
localize a package variable of the same name, qualify it with the
package name.
(F) You tried to unshift an "unreal" array that can't be unshifted, such
as the main Perl stack.
-=item Can't upgrade that kind of scalar
+=item Can't upgrade %s (%d) to %d
(P) The internal sv_upgrade routine adds "members" to an SV, making it
into a more specialized kind of SV. The top several SV types are so
specialized, however, that they cannot be interconverted. This message
indicates that such a conversion was attempted.
-=item Can't upgrade to undef
-
-(P) The undefined SV is the bottom of the totem pole, in the scheme of
-upgradability. Upgrading to undef indicates an error in the code
-calling sv_upgrade.
-
=item Can't use anonymous symbol table for method lookup
(F) The internal routine that does method lookup was handed a symbol
(F) Only a simple scalar variable may be used as a loop variable on a
foreach.
-=item Can't use global %s in "my"
+=item Can't use global %s in "%s"
(F) You tried to declare a magical variable as a lexical variable. This
is not allowed, because the magic can be tied to only one location
(F) The compiler tried to interpret a bracketed expression as a
subscript. But to the left of the brackets was an expression that
-didn't look like an array reference, or anything else subscriptable.
+didn't look like a hash or array reference, or anything else subscriptable.
=item Can't use \%c to mean $%c in expression
value that prints out looking like SCALAR(0xdecaf). Use the $1 form
instead.
+=item Can't use "when" outside a topicalizer
+
+(F) You have used a when() block that is neither inside a C<foreach>
+loop nor a C<given> block. (Note that this error is issued on exit
+from the C<when> block, so you won't get the error if the match fails,
+or if you use an explicit C<continue>.)
+
=item Can't weaken a nonreference
(F) You attempted to weaken something that was not a reference. Only
unpack("H", "\x{2a1}")
-where the format expects to process a byte (a character with a value
+where the format expects to process a byte (a character with a value
below 256), but a higher value was provided instead. Perl uses the value
modulus 256 instead, as if you had provided:
pack("u", "\x{1f3}b")
-where the format expects to process a sequence of bytes (character with a
-value below 256), but some of the characters had a higher value. Perl
+where the format expects to process a sequence of bytes (character with a
+value below 256), but some of the characters had a higher value. Perl
uses the character values modulus 256 instead, as if you had provided:
pack("u", "\x{f3}b")
unpack("s", "\x{1f3}b")
-where the format expects to process a sequence of bytes (character with a
-value below 256), but some of the characters had a higher value. Perl
+where the format expects to process a sequence of bytes (character with a
+value below 256), but some of the characters had a higher value. Perl
uses the character values modulus 256 instead, as if you had provided:
unpack("s", "\x{f3}b")
(W unopened) You tried to close a filehandle that was never opened.
+=item closedir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to close is either closed or not really
+a dirhandle. Check your control flow.
+
=item Code missing after '/'
(F) You had a (sub-)template that ends with a '/'. There must be another
corresponding C<overload> or C<charnames> pragma? See L<charnames> and
L<overload>.
+=item Constant(%s)%s: %s in regex; marked by <-- HERE in m/%s/
+
+(F) The parser found inconsistencies while attempting to find
+the character name specified in the C<\N{...}> escape. Perhaps you
+forgot to load the corresponding C<charnames> pragma?
+See L<charnames>.
+
+
=item Constant is not %s reference
(F) A constant value (perhaps declared using the C<use constant> pragma)
static variable. Since we intend to fix this bug, we don't want people
relying on this behavior. You can achieve a similar static effect by
declaring the variable in a separate block outside the function, eg
-
+
sub f { my $x if 0; return $x++ }
becomes
{ my $x; sub f { return $x++ } }
+Beginning with perl 5.9.4, you can also use C<state> variables to
+have lexicals that are initialized only once (see L<feature>):
+
+ sub f { state $x; return $x++ }
+
=item DESTROY created new reference to dead object '%s'
(F) A DESTROY() method created a new reference to the object which is
(W misc) You used the obsolescent C<dump()> built-in function, without fully
qualifying it as C<CORE::dump()>. Maybe it's a typo. See L<perlfunc/dump>.
+=item dump is not supported
+
+(F) Your machine doesn't support dump/undump.
+
=item Duplicate free() ignored
(S malloc) An internal routine called free() on something that had
assertion, but that construct is only allowed when the C<use re 'eval'>
pragma is in effect. See L<perlre/(?{ code })>.
+=item EVAL without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern that nested too many EVAL calls without consuming
+any text. Restructure the pattern so that text is consumed.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
=item Excessively long <> operator
(F) The contents of a <> operator may not exceed the maximum size of a
=item %s failed--call queue aborted
-(F) An untrapped exception was raised while executing a CHECK, INIT, or
-END subroutine. Processing of the remainder of the queue of such
-routines has been prematurely ended.
+(F) An untrapped exception was raised while executing a UNITCHECK,
+CHECK, INIT, or END subroutine. Processing of the remainder of the
+queue of such routines has been prematurely ended.
=item False [] range "%s" in regex; marked by <-- HERE in m/%s/
(F) Your machine apparently doesn't implement fcntl(). What is this, a
PDP-11 or something?
+=item FETCHSIZE returned a negative value
+
+(F) A tied array claimed to have a negative number of elements, which
+is not possible.
+
=item Field too wide in 'u' format in pack
(W pack) Each line in an uuencoded string start with a length indicator
=item Global symbol "%s" requires explicit package name
-(F) You've said "use strict vars", which indicates that all variables
-must either be lexically scoped (using "my"), declared beforehand using
-"our", or explicitly qualified to say which package the global variable
-is in (using "::").
+(F) You've said "use strict" or "use strict vars", which indicates
+that all variables must either be lexically scoped (using "my" or "state"),
+declared beforehand using "our", or explicitly qualified to say
+which package the global variable is in (using "::").
=item glob failed (%s)
names (like C<$A::B>). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
+=item Ignoring %s in character class in regex; marked by <-- HERE in m/%s/
+
+(W) Named Unicode character escapes (\N{...}) may return multi-char
+or zero length sequences. When such an escape is used in a character class
+its behaviour is not well defined. Check that the correct escape has
+been used, and the correct charname handler is in scope.
+
=item Illegal binary digit %s
(F) You used a digit other than 0 or 1 in a binary number.
=item Illegal switch in PERL5OPT: %s
(X) The PERL5OPT environment variable may only be used to set the
-following switches: B<-[CDIMUdmtwA]>.
+following switches: B<-[CDIMUdmtw]>.
=item Ill-formed CRTL environ value "%s"
didn't see the expected delimiter between key and value, so the line was
ignored.
-=item Impossible to activate assertion call
-
-(W assertions) You're calling an assertion function in a block that is
-not under the control of the C<assertions> pragma.
-
=item (in cleanup) %s
(W misc) This prefix usually indicates that a DESTROY() method raised
Failure of user callbacks dispatched using the C<G_KEEPERR> flag could
also result in this warning. See L<perlcall/G_KEEPERR>.
+=item Inconsistent hierarchy during C3 merge of class '%s': merging failed on parent '%s'
+
+(F) The method resolution order (MRO) of the given class is not
+C3-consistent, and you have enabled the C3 MRO for this class. See the C3
+documentation in L<mro> for more information.
+
=item In EBCDIC the v-string components cannot exceed 2147483647
(F) An error peculiar to EBCDIC. Internally, v-strings are stored as
Unicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC
encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
+=item Infinite recursion in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern that references itself without consuming any input
+text. You should check the pattern to ensure that recursive patterns
+either consume text or fail.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
+=item Initialization of state variables in list context currently forbidden
+
+(F) Currently the implementation of "state" only permits the initialization
+of scalar variables in scalar context. Re-write C<state ($a) = 42> as
+C<state $a = 42> to change from list to scalar context. Constructions such
+as C<state (@a) = foo()> will be supported in a future perl release.
+
=item Insecure dependency in %s
(F) You tried to do something that the tainting mechanism didn't like.
internally--subject to loss of precision errors in subsequent
operations.
+=item Integer overflow in format string for %s
+
+(F) The indexes and widths specified in the format string of C<printf()>
+or C<sprintf()> are too large. The numbers must not overflow the size of
+integers for your architecture.
+
=item Integer overflow in version
(F) Some portion of a version initialization is too large for the
(W printf) Perl does not understand the given format conversion. See
L<perlfunc/sprintf>.
+=item Invalid escape in the specified encoding in regex; marked by <-- HERE in m/%s/
+
+(W regexp) The numeric escape (for example C<\xHH>) of value < 256
+didn't correspond to a single character through the conversion
+from the encoding specified by the encoding pragma.
+The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead.
+The <-- HERE shows in the regular expression about where the
+escape was discovered.
+
+=item Invalid mro name: '%s'
+
+(F) You tried to C<mro::set_mro("classname", "foo")>
+or C<use mro 'foo'>, where C<foo> is not a valid method resolution order (MRO).
+(Currently, the only valid ones are C<dfs> and C<c3>). See L<mro>.
+
=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
(F) The range specified in a character class had a minimum character
=item $* is no longer supported
-(D deprecated) The special variable C<$*>, deprecated in older perls, has
+(S deprecated, syntax) The special variable C<$*>, deprecated in older perls, has
been removed as of 5.9.0 and is no longer supported. You should use the
C<//m> and C<//s> regexp modifiers instead.
=item $# is no longer supported
-(D deprecated) The special variable C<$#>, deprecated in older perls, has
+(S deprecated, syntax) The special variable C<$#>, deprecated in older perls, has
been removed as of 5.9.3 and is no longer supported. You should use the
printf/sprintf functions instead.
to check the return value of your socket() call? See
L<perlfunc/listen>.
-=item Lookbehind longer than %d not implemented in regex; marked by <-- HERE in m/%s/
+=item Lookbehind longer than %d not implemented in regex m/%s/
(F) There is currently a limit on the length of string which lookbehind can
-handle. This restriction may be eased in a future release. The <-- HERE
-shows in the regular expression about where the problem was discovered.
+handle. This restriction may be eased in a future release.
+
+=item Lost precision when %s %f by 1
+
+(W) The value you attempted to increment or decrement by one is too large
+for the underlying floating point representation to store accurately,
+hence the target of C<++> or C<--> is unchanged. Perl issues this warning
+because it has already switched from integers to floating point when values
+are too large for integers, and now even floating point is insufficient.
+You may wish to switch to using L<Math::BigInt> explicitly.
=item lstat() on filehandle %s
=item Malformed UTF-8 character (%s)
-(W utf8) Perl detected something that didn't comply with UTF-8 encoding rules.
+(S utf8) (F) Perl detected a string that didn't comply with UTF-8
+encoding rules, even though it had the UTF8 flag on.
+
+One possible cause is that you set the UTF8 flag yourself for data that
+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_utf8.
+
+If you use the C<:encoding(UTF-8)> PerlIO layer for input, invalid byte
+sequences are handled gracefully, but if you use C<:utf8>, the flag is
+set without validating the data, possibly resulting in this error
+message.
-One possible cause is that you read in data that you thought to be in
-UTF-8 but it wasn't (it was for example legacy 8-bit data). Another
-possibility is careless use of utf8::upgrade().
+See also L<Encode/"Handling Malformed Data">.
=item Malformed UTF-16 surrogate
(F) You tried to unpack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
+=item Maximal count of pending signals (%s) exceeded
+
+(F) Perl aborted due to a too important 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 L<perlipc/"Deferred Signals (Safe Signals)">.)
+
=item %s matches null string many times in regex; marked by <-- HERE in m/%s/
(W regexp) The pattern you've specified would be an infinite loop if the
(F) Lexically scoped subroutines are not yet implemented. Don't try
that yet.
-=item "my" variable %s can't be in a package
+=item "%s" 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
(S internal) The symbol in question was declared but somehow went out of
scope before it could possibly have been used.
+=item next::method/next::can/maybe::next::method cannot find enclosing method
+
+(F) C<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 L<mro>.
+
=item No %s allowed while running setuid
(F) Certain operations are deemed to be too insecure for a setuid or
(F) The setuid emulator requires that scripts have a well-formed #! line
even on machines that don't support the #! construct.
+=item No next::method '%s' found for %s
+
+(F) C<next::method> found no further instances of this method name
+in the remaining packages of the MRO of this class. If you don't want
+it throwing an exception, use C<maybe::next::method>
+or C<next::can>. See L<mro>.
+
=item "no" not allowed in expression
(F) The "no" keyword is recognized and executed at compile time, and
=item No such class %s
-(F) You provided a class qualifier in a "my" or "our" declaration, but
+(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.
=item No such pipe open
=item Offset outside string
-(F) You tried to do a read/write/send/recv operation with an offset
-pointing outside the buffer. This is difficult to imagine. The sole
-exception to this is that C<sysread()>ing past the buffer will extend
-the buffer and zero pad the new area.
+(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
+C<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 behaviour
+with real files).
=item %s() on unopened %s
(S internal) An internal warning that the grammar is screwed up.
+=item Opening dirhandle %s also as a file
+
+(W io deprecated) You used open() to associate a filehandle to
+a symbol (glob or scalar) that already holds a dirhandle.
+Although legal, this idiom might render your code confusing
+and is deprecated.
+
+=item Opening filehandle %s also as a directory
+
+(W io deprecated) You used opendir() to associate a dirhandle to
+a symbol (glob or scalar) that already holds a filehandle.
+Although legal, this idiom might render your code confusing
+and is deprecated.
+
=item Operation "%s": no method found, %s
(F) An attempt was made to perform an overloaded operation for which no
(P) An internal error.
+=item panic: attempt to call %s in %s
+
+(P) One of the file test operators entered a code branch that calls
+an ACL related-function, but that function is not available on this
+platform. Earlier checks mean that it should not be possible to
+enter this branch on this platform.
+
=item panic: ck_grep
(P) Failed an internal consistency check trying to compile a grep.
(P) The internal do_trans routines were called with invalid operational
data.
+=item panic: fold_constants JMPENV_PUSH returned %d
+
+(P) While attempting folding constants an exception other than an C<eval>
+failure was caught.
+
=item panic: frexp
(P) The library function frexp() failed, making printf("%f") impossible.
(P) We popped the context stack to a context with the specified label,
and then discovered it wasn't a context we know how to do a goto in.
+=item panic: hfreeentries failed to free hash
+
+(P) The internal routine used to clear a hashes entries tried repeatedly,
+but each time something added more entries to the hash. Most likely the hash
+contains an object with a reference back to the hash and a destructor that
+adds a new object to the hash.
+
=item panic: INTERPCASEMOD
(P) The lexer got into a bad state at a case modifier.
(P) Something tried to allocate more memory than possible.
-=item panic: null array
-
-(P) One of the internal array routines was passed a null AV pointer.
-
=item panic: pad_alloc
(P) The compiler got confused about which scratch pad it was allocating
(P) scan_num() got called on something that wasn't a number.
+=item panic: sv_chop %s
+
+(P) The sv_chop() routine was passed a position that is not within the
+scalar's string buffer.
+
=item panic: sv_insert
(P) The sv_insert() routine was told to remove more string than there
(P) The lexer got into a bad state while processing a case modifier.
+=item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
+
+(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.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
=item Parentheses missing around "%s" list
(W parenthesis) You said something like
my ($foo, $bar) = @_;
-Remember that "my", "our", and "local" bind tighter than comma.
+Remember that "my", "our", "local" and "state" bind tighter than comma.
=item C<-p> destination: %s
(F) The unpack format P must have an explicit size, not "*".
-=item B<-P> not allowed for setuid/setgid script
-
-(F) The script would have to be opened by the C preprocessor by name,
-which provides a race condition that breaks security.
-
=item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
(F) The class in the character class [: :] syntax is unknown. The <-- HERE
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
+=item Possible unintended interpolation of $\ in regex
+
+(W ambiguous) You said something like C<m/$\/> in a regex.
+The regex C<m/foo$\s+bar/m> translates to: match the word 'foo', the output
+record separartor (see L<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
+C<m/${\}/> (for example: C<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
+C<m/$(?)\/> (for example: C<m/foo$(?)\s+bar/>).
+
=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
(D deprecated) You have written something like this:
L<perlipc/"Signals">. See also "Process terminated by SIGTERM/SIGINT"
in L<perlos2>.
+=item Prototype after '%c' for %s : %s
+
+(W syntax) A character follows % or @ in a prototype. This is useless,
+since % and @ gobble the rest of the subroutine arguments.
+
=item Prototype mismatch: %s vs %s
(S prototype) The subroutine being declared or defined had previously been
One possible workaround is to force Perl to use magical string increment
by prepending "0" to your numbers.
+=item readdir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you're reading from is either closed or not really
+a dirhandle. Check your control flow.
+
=item readline() on closed filehandle %s
(W closed) The filehandle you're reading from got itself closed sometime
=item Recursive inheritance detected in package '%s'
-(F) More than 100 levels of inheritance were used. Probably indicates
-an unintended loop in your inheritance hierarchy.
+(F) While calculating the method resolution order (MRO) of a package, Perl
+believes it found an infinite loop in the C<@ISA> hierarchy. This is a
+crude check that bails out after 100 levels of C<@ISA> depth.
=item Recursive inheritance detected while looking for method %s
(W internal) The internal sv_replace() function was handed a new SV with
a reference count of other than 1.
+=item Reference to invalid group 0
+
+(F) You used C<\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), but using 0 does not make sense.
+
=item Reference to nonexistent group in regex; marked by <-- HERE in m/%s/
(F) You used something like C<\7> in your regular expression, but there are
The <-- HERE shows in the regular expression about where the problem was
discovered.
+=item Reference to nonexistent or unclosed group in regex; marked by <-- HERE in m/%s/
+
+(F) You used something like C<\g{-7}> in your regular expression, but there are
+not at least seven sets of closed capturing parentheses in the expression before
+where the C<\g{-7}> was located.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
+=item Reference to nonexistent named group in regex; marked by <-- HERE in m/%s/
+
+(F) You used something like C<\k'NAME'> or C<< \k<NAME> >> in your regular
+expression, but there is no corresponding named capturing parentheses such
+as C<(?'NAME'...)> or C<(?<NAME>...). Check if the name has been spelled
+correctly both in the backreference and the declaration.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
+=item (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in m/%s/
+
+(F) You used something like C<(?(DEFINE)...|..)> which is illegal. The
+most likely cause of this error is that you left out a parenthesis inside
+of the C<....> part.
+
+The <-- HERE shows in the regular expression about where the problem was
+discovered.
+
=item regexp memory corruption
(P) The regular expression engine got confused by what the regular
(W syntax) You wrote your assignment operator backwards. The = must
always comes last, to avoid ambiguity with subsequent unary operators.
+=item rewinddir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
+really a dirhandle. Check your control flow.
+
=item Runaway format
(F) Your format contained the ~~ repeat-until-blank sequence, but it
(W unopened) You tried to use the seek() or sysseek() function on a
filehandle that was either never opened or has since been closed.
+=item seekdir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you are doing a seekdir() on is either closed or not
+really a dirhandle. Check your control flow.
+
=item select not implemented
(F) This machine doesn't implement the select() system call.
<-- HERE shows in the regular expression about where the problem was
discovered. See L<perlre>.
+=item 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.
+
=item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/
(F) A regular expression comment must be terminated by a closing
(P) The substitution was looping infinitely. (Obviously, a substitution
shouldn't iterate more times than there are characters of input, which
is what happened.) See the discussion of substitution in
-L<perlop/"Quote and Quote-like Operators">.
+L<perlop/"Regexp Quote-Like Operators">.
=item Substitution pattern not terminated
(W unopened) You tried to use the tell() function on a filehandle that
was either never opened or has since been closed.
+=item telldir() attempted on invalid dirhandle %s
+
+(W io) The dirhandle you tried to telldir() is either closed or not really
+a dirhandle. Check your control flow.
+
=item That use of $[ is unsupported
(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
=item The 'unique' attribute may only be applied to 'our' variables
-(F) Currently this attribute is not supported on C<my> or C<sub>
-declarations. See L<perlfunc/our>.
+(F) This attribute was never supported on C<my> or C<sub> declarations.
=item This Perl can't reset CRTL environ elements (%s)
=item Too deeply nested ()-groups
-(F) Your template contains ()-groups with a ridiculously deep nesting level.
+(F) Your template contains ()-groups with a ridiculously deep nesting level.
=item Too few args to syscall
Note that if you want to enable a warnings category registered by a module
(e.g. C<use warnings 'File::Find'>), you must have imported this module
+
+=item Unknown verb pattern '%s' in regex; marked by <-- HERE in m/%s/
+
+(F) You either made a typo or have incorrectly put a C<*> quantifier
+after an open brace in your pattern. Check the pattern and review
+L<perlre> for details on legal verb patterns.
+
first.
=item unmatched [ in regex; marked by <-- HERE in m/%s/
somehow, or insert an underbar into it. You might also declare it as a
subroutine.
-=item Unrecognized character %s
+=item Unrecognized character %s in column %d
(F) The Perl parser has no idea what to do with the specified character
-in your Perl script (or eval). Perhaps you tried to run a compressed
-script, a binary program, or a directory as a Perl program.
+in your Perl script (or eval) at the specified column. Perhaps you tried
+to run a compressed script, a binary program, or a directory as a Perl program.
-=item /%s/: Unrecognized escape \\%c in character class passed through
+=item 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.
+The <-- HERE shows in the regular expression about where the
+escape was discovered.
=item Unrecognized escape \\%c passed through
(W misc) You used a backslash-character combination which is not
-recognized by Perl.
+recognized by Perl. The character was understood literally.
=item Unrecognized escape \\%c passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
-recognized by Perl. This combination appears in an interpolated variable or
-a C<'>-delimited regular expression. The character was understood
-literally. The <-- HERE shows in the regular expression about where the
+recognized by Perl. The character was understood literally.
+The <-- HERE shows in the regular expression about where the
escape was discovered.
=item Unrecognized signal name "%s"
compressed integer format and could not be converted to an integer.
See L<perlfunc/pack>.
+=item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*VERB)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
+=item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
+=item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
+
+(F) You missed a close brace on a \g{..} pattern (group reference) in
+a regular expression. Fix the pattern and retry.
+
=item Unterminated <> operator
(F) The lexer saw a left angle bracket in a place where it was expecting
This warning will not be issued for numerical constants equal to 0 or 1
since they are often used in statements like
- 1 while sub_with_side_effects() ;
+ 1 while sub_with_side_effects();
String constants that would normally evaluate to 0 or 1 are warned
about.
=item Use of bare << to mean <<"" is deprecated
-(D deprecated) You are now encouraged to use the explicitly quoted form
-if you wish to use an empty line as the terminator of the here-document.
+(D deprecated, W syntax) You are now encouraged to use the explicitly quoted
+form if you wish to use an empty line as the terminator of the here-document.
+
+=item Use of comma-less variable list is deprecated
+
+(D deprecated, W syntax) The values you give to a format should be
+separated by commas, not just aligned on a line.
=item Use of chdir('') or chdir(undef) as chdir() deprecated
=item Use of implicit split to @_ is deprecated
-(D deprecated) It makes a lot of work for the compiler when you clobber
-a subroutine's argument list, so it's better if you assign the results
+(D deprecated, W syntax) It makes a lot of work for the compiler when you
+clobber a subroutine's argument list, so it's better if you assign the results
of a split() explicitly to an array (or list).
=item Use of inherited AUTOLOAD for non-method %s() is deprecated
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
either, because you can overload the numification and stringification
-operators and then you assumedly know what you are doing.
+operators and then you assumably know what you are doing.
=item Use of reserved word "%s" is deprecated
that module. It usually means you put the wrong funny character on the
front of your variable.
-=item Variable length lookbehind not implemented in regex; marked by <-- HERE in m/%s/
+=item Variable length lookbehind not implemented in m/%s/
(F) Lookbehind is allowed only for subexpressions whose length is fixed and
-known at compile time. The <-- HERE shows in the regular expression about
-where the problem was discovered. See L<perlre>.
+known at compile time. See L<perlre>.
=item "%s" variable %s masks earlier declaration in same %s
-(W misc) A "my" or "our" variable has been redeclared in the current
+(W misc) A "my", "our" or "state" variable 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 variable will still exist until the end of the scope or until
reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.
+=item Verb pattern '%s' has a mandatory argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a verb pattern that requires an argument. Supply an argument
+or check that you are using the right verb.
+
+=item Verb pattern '%s' may not have an argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a verb pattern that is not allowed an argument. Remove the
+argument or check that you are using the right verb.
+
=item Version number must be a constant number
(P) The attempt to translate a C<use Module n.n LIST> statement into
its equivalent C<BEGIN> block found an internal inconsistency with
the version number.
-=item v-string in use/require is non-portable
+=item Version string '%s' contains invalid data; ignoring: '%s'
-(W portable) The use of v-strings is non-portable to older, pre-5.6, Perls.
-If you want your scripts to be backward portable, use the floating
-point version number: for example, instead of C<use 5.6.1> say
-C<use 5.006_001>. This of course won't help: the older Perls
-won't suddenly start understanding newer features, but at least
-they will show a sensible error message indicating the required
-minimum version.
+(W misc) The version string contains invalid characters at the end, which
+are being ignored.
=item Warning: something's wrong
(W) You passed warn() an empty string (the equivalent of C<warn "">) or
-you called it with no args and C<$_> was empty.
+you called it with no args and C<$@> was empty.
=item Warning: unable to close filehandle %s properly
=back
+=head1 SEE ALSO
+
+L<warnings>, L<perllexwarn>.
+
=cut
https://perl5.git.perl.org / perl5.git / blobdiff