=item Ambiguous use of %c resolved as operator %c
(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
-bitwise and, and multpication), and you said something like C<*foo *
-foo> that might be interpreted as either of them. We assumed you
-meant the infix operator, but please try to make it more clear -- in
-the example given, you might write C<*foo * foo()> if you really meant
-to multiply a glob by the result of calling a function.
+bitwise and, and multiplication) I<and> initial special characters
+(denoting hashes, subroutines and typeglobs), and you said something
+like C<*foo * foo> that might be interpreted as either of them. We
+assumed you meant the infix operator, but please try to make it more
+clear -- in the example given, you might write C<*foo * foo()> if you
+really meant to multiply a glob by the result of calling a function.
=item Ambiguous use of %c{%s} resolved to %c%s
function, write C<@{foo()}> ... or you could just not have a variable
and a function with the same name, and save yourself a lot of trouble.
-=item Ambiguous use of %c{%s%s} resolved to %c%s%s
+=item Ambiguous use of %c{%s[...]} resolved to %c%s[...]
-(W ambiguous) You wrote something like C<${foo[2]}>, which might be
-looking for element number 2 of the array named C<@foo>, in which case
-please write C<$foo[2]>, or you might have meant to pass an anonymous
-arrayref to the function named foo, then do a scalar deref on the
-value it returns. If you meant that, write C<${foo([2])}>.
+=item Ambiguous use of %c{%s{...}} resolved to %c%s{...}
+
+(W ambiguous) You wrote something like C<${foo[2]}> (where foo
+represents the name of a Perl keyword), which might be looking for
+element number 2 of the array named C<@foo>, in which case please write
+C<$foo[2]>, or you might have meant to pass an anonymous arrayref to
+the function named foo, and then do a scalar deref on the value it
+returns. If you meant that, write C<${foo([2])}>.
+
+In regular expressions, the C<${foo[2]}> syntax is sometimes necessary
+to disambiguate between array subscripts and character classes.
+C</$length[2345]/>, for instance, will be interpreted as C<$length>
+followed by the character class C<[2345]>. If an array subscript is what
+you want, you can avoid the warning by changing C</${length[2345]}/>
+to the unsightly C</${\$length[2345]}/>, by renaming your array to
+something that does not coincide with a built-in keyword, or by
+simply turning off warnings with C<no warnings 'ambiguous';>.
=item Ambiguous use of -%s resolved as -&%s()
(W ambiguous) You wrote something like C<-foo>, which might be the
-string C<"-foo"> (outside of C<use strict 'subs'>), or a call to the
-function C<foo>, negated. If you meant the string, just write
-C<"-foo">, and please use strict. If you meant the function call,
+string C<"-foo">, or a call to the function C<foo>, negated. If you meant
+the string, just write C<"-foo">. If you meant the function call,
write C<-foo()>.
=item '|' and '<' may not both be specified on command line
you meant to do. See L<perlfunc/grep> and L<perlfunc/map> for
alternatives.
-=item Args must match #! line
-
-(F) The setuid emulator requires that the arguments Perl was invoked
-with match the arguments specified on the #! line. Since some systems
-impose a one-argument limit on the #! line, try combining switches;
-for example, turn C<-w -U> into C<-wU>.
-
=item Arg too short for msgsnd
(F) msgsnd() requires a string at least as long as sizeof(long).
(W threads)(S) When using threaded Perl, a thread (not necessarily the main
thread) exited while there were still other threads running.
-Usually it's a good idea to first collect the return values of the
-created threads by joining them, and only then exit from the main
+Usually it's a good idea first to collect the return values of the
+created threads by joining them, and only then to exit from the main
thread. See L<threads>.
=item Attempt to access disallowed key '%s' in a restricted hash
=item Attempt to free nonexistent shared string
-(P internal) Perl maintains a reference counted internal table of
+(P internal) Perl maintains a reference-counted internal table of
strings to optimize the storage and access of hash keys and other
strings. This indicates someone tried to decrement the reference count
of a string that can no longer be found in the table.
=item Attribute "locked" is deprecated
-(D deprecated) You have used the attributes pragam to modify the "locked"
+(D deprecated) You have used the attributes pragma to modify the "locked"
attribute on a code reference. The :locked attribute is obsolete, has had no
-effect since 5005 threads were removed, and will be removed in the next major
+effect since 5005 threads were removed, and will be removed in a future
release of Perl 5.
=item Attribute "unique" is deprecated
-(D deprecated) You have used the attributes pragam to modify the "unique"
+(D deprecated) You have used the attributes pragma to modify the "unique"
attribute on an array, hash or scalar reference. The :unique attribute has
-had no effect since Perl 5.8.8, and will be removed in the next major
-release of Perl 5.
+had no effect since Perl 5.8.8, and will be removed in a future release
+of Perl 5.
=item Bad arg length for %s, is %u, should be %d
(S malloc) An internal routine called realloc() on something that had
never been malloc()ed in the first place. Mandatory, but can be disabled
-by setting environment variable C<PERL_BADFREE> to 1.
+by setting
the environment variable C<PERL_BADFREE> to 1.
=item Bad symbol for array
=item binmode() on closed filehandle %s
(W unopened) You tried binmode() on a filehandle that was never opened.
-Check you control flow and number of arguments.
+Check your control flow and number of arguments.
+
+=item "\b{" is deprecated; use "\b\{" instead
+
+=item "\B{" is deprecated; use "\B\{" instead
+
+(W deprecated, regexp) Use of an unescaped "{" immediately following a
+C<\b> or C<\B> is now deprecated so as to reserve its use for Perl
+itself in a future release.
=item Bit vector size > 32 non-portable
=item Bizarre copy of %s in %s
(P) Perl detected an attempt to copy an internal value that is not
-copyable.
+copiable.
=item Buffer overflow in prime_env_iter: %s
=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.
+be directly assigned to.
=item Cannot find encoding "%s"
(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
-functioning as a class, but that package doesn't have ANYTHING defined
-in it, let alone methods. See L<perlobj>.
-
=item Can't call method "%s" on an undefined value
(F) You used the syntax of a method call, but the slot filled by the
(P) For some reason you can't check the filesystem of the script for
nosuid.
-=item Can't coerce array into hash
-
-(F) You used an array where a hash was expected, but the array has no
-information on how to map from keys to array indices. You can do that
-only with arrays that have a hash reference at index 0.
-
-=item Can't coerce %s to integer in %s
+=item Can't coerce %s to %s in %s
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are. So you can't
but then $foo no longer contains a glob.
-=item Can't coerce %s to number in %s
-
-(F) Certain types of SVs, in particular real symbol table entries
-(typeglobs), can't be forced to stop being what they are.
-
-=item Can't coerce %s to string in %s
-
-(F) Certain types of SVs, in particular real symbol table entries
-(typeglobs), can't be forced to stop being what they are.
-
=item Can't "continue" outside a when block
(F) You called C<continue>, but you're not inside a C<when>
(P) An error peculiar to VMS. The process is suffering from exhausted
quotas or other plumbing problems.
-=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", "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", "our" or
=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}> matches all uppercase letters). If you did mean to use a
-Unicode property, see
+(F) You may have tried to use C<\p> which means a Unicode
+property (for example C<\p{Lu}> matches all uppercase
+letters). If you did mean to use a Unicode property, see
L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available 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>).
+for a complete list of available 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, or
+until C<\E>).
=item Can't fork: %s
the stat buffer, so that ACLs and other protections can be taken into
account. Unfortunately, Perl assumes that the stat buffer contains all
the necessary information, and passes it, instead of the filespec, to
-the access checking routine. It will try to retrieve the filespec using
+the access-checking routine. It will try to retrieve the filespec using
the device name and FID present in the stat buffer, but this works only
if you haven't made a subsequent call to the CRTL stat() routine,
because the device name is overwritten with each call. If this warning
-appears, the name lookup failed, and the access checking routine gave up
-and returned FALSE, just to be conservative. (Note: The access checking
+appears, the name lookup failed, and the access-checking routine gave up
+and returned FALSE, just to be conservative. (Note: The access-checking
routine knows about the Perl C<stat> operator and file tests, so you
shouldn't ever see this warning in response to a Perl command; it arises
only if some internal code takes stat buffers lightly.)
=item Can't modify non-lvalue subroutine call
(F) Subroutines meant to be used in lvalue context should be declared as
-such
, see L<perlsub/"Lvalue subroutines">.
+such
. See L<perlsub/"Lvalue subroutines">.
=item Can't msgrcv to read-only var
=item Can't open a reference
(W io) You tried to open a scalar reference for reading or writing,
-using the 3-arg open() syntax :
+using the 3-arg open() syntax:
open FH, '>', $ref;
(F|P) Error resolving overloading specified by a method name (as opposed
to a subroutine reference): no such method callable via the package. If
-method name is C<???>, this is an internal error.
+the method name is C<???>, this is an internal error.
=item Can't return %s from lvalue subroutine
however, redefine it while it's running, and you can even undef the
redefined subroutine while the old routine is running. Go figure.
-=item Can't unshift
-
-(F) You tried to unshift an "unreal" array that can't be unshifted, such
-as the main Perl stack.
-
=item Can't upgrade %s (%d) to %d
(P) The internal sv_upgrade routine adds "members" to an SV, making it
unpack("s", "\x{f3}b")
+=item "\c{" is deprecated and is more clearly written as ";"
+
+(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
+to specify non-printable characters. You used it with a "{" which
+evaluates to ";", which is printable. It is planned to remove the
+ability to specify a semi-colon this way in Perl 5.16. Just use a
+semi-colon or a backslash-semi-colon without the "\c".
+
+=item "\c%c" is more clearly written simply as "%s"
+
+(W syntax) The C<\cI<X>> construct is intended to be a way to specify
+non-printable characters. You used it for a printable one, which is better
+written as simply itself, perhaps preceded by a backslash for non-word
+characters.
+
=item close() on unopened filehandle %s
(W unopened) You tried to close a filehandle that was never opened.
(W threads) Within a thread-enabled program, you tried to call
cond_broadcast() on a variable which wasn't locked. The cond_broadcast()
-function is used to wake up another thread that is waiting in a
+function is used to wake up another thread that is waiting in a
cond_wait(). To ensure that the signal isn't sent before the other thread
-has a chance to enter the wait, it is usual for the signaling thread to
-first wait for a lock on variable. This lock attempt will only succeed
+has a chance to enter the wait, it is usual for the signaling thread
+first to wait for a lock on variable. This lock attempt will only succeed
after the other thread has entered cond_wait() and thus relinquished the
lock.
(W threads) Within a thread-enabled program, you tried to call
cond_signal() on a variable which wasn't locked. The cond_signal()
-function is used to wake up another thread that is waiting in a
+function is used to wake up another thread that is waiting in a
cond_wait(). To ensure that the signal isn't sent before the other thread
-has a chance to enter the wait, it is usual for the signaling thread to
-first wait for a lock on variable. This lock attempt will only succeed
+has a chance to enter the wait, it is usual for the signaling thread
+first to wait for a lock on variable. This lock attempt will only succeed
after the other thread has entered cond_wait() and thus relinquished the
lock.
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
-=item "\c{" is deprecated and is more clearly written as ";"
-
-(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
-to specify non-printable characters. You used it with a "{" which
-evaluates to ";", which is printable. It is planned to remove the
-ability to specify a semi-colon this way in Perl 5.16. Just use a
-semi-colon or a backslash-semi-colon without the "\c".
-
-=item "\c%c" is more clearly written simply as "%s"
-
-(W syntax) The C<\cI<X>> construct is intended to be a way to specify
-non-printable characters. You used it for a printable one, which is better
-written as simply itself, perhaps preceded by a backslash for non-word
-characters.
-
=item Deep recursion on subroutine "%s"
(W recursion) This subroutine has called itself (directly or indirectly)
checks for an undefined I<scalar> value. If you want to see if the hash
is empty, just use C<if (%hash) { # not empty }> for example.
+=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 %s defines neither package nor VERSION--version check failed
(F) You said something like "use Module 42" but in the Module file
=item Deprecated character in \N{...}; marked by <-- HERE in \N{%s<-- HERE %s
(D deprecated) Just about anything is legal for the C<...> in C<\N{...}>.
-But starting in 5.12, non-reasonable ones that don't look like names are
-deprecated. A reasonable name begins with an alphabetic character and
-continues with any combination of alphanumerics, dashes, spaces, parentheses or
-colons.
+But starting in 5.12, non-reasonable ones that don't look like names
+are deprecated. A reasonable name begins with an alphabetic character
+and continues with any combination of alphanumerics, dashes, spaces,
+parentheses or colons.
=item Deprecated use of my() in false conditional
=item Died
(F) You passed die() an empty string (the equivalent of C<die "">) or
-you called it with no args and both C<$@> and C<$_> were empty.
+you called it with no args and C<$@> was empty.
=item Document contains no data
(F) Perl tried to compile a regular expression containing the
C<(?{ ... })> zero-width assertion at run time, as it would when the
-pattern contains interpolated values. Since that is a security risk, it
-is not allowed. If you insist, you may still do this by explicitly
-building the pattern from an interpolated string at run time and using
-that in an eval(). See L<perlre/(?{ code })>.
+pattern contains interpolated values. Since that is a security risk,
+it is not allowed. If you insist, you may still do this by using the
+C<re 'eval'> pragma or by explicitly building the pattern from an
+interpolated string at run time and using that in an eval(). See
+L<perlre/(?{ code })>.
=item %s: Eval-group not allowed, use re 'eval'
=item exec? I'm not *that* kind of operating system
-(F) The C<exec> function is not implemented in MacPerl. See L<perlport>.
+(F) The C<exec> function is not implemented on some systems, e.g., Symbian
+OS. See L<perlport>.
=item Execution of %s aborted due to compilation errors.
(W pack) Each line in an uuencoded string start with a length indicator
which can't encode values above 63. So there is no point in asking for
a line length bigger than that. Perl will behave as if you specified
-C<u63> as format.
+C<u63> as the format.
=item Filehandle %s opened only for input
(W io) You tried to read from a filehandle opened only for writing, If
you intended it to be a read/write filehandle, you needed to open it
-with "+<" or "+>" or "+>>" instead of with "<" or nothing. If you
-intended only to read from the file, use "<". See L<perlfunc/open>.
-Another possibility is that you attempted to open filedescriptor 0
-(also known as STDIN) for output (maybe you closed STDIN earlier?).
+with "+<" or "+>" or "+>>" instead of with ">". If you intended only to
+read from the file, use "<". See L<perlfunc/open>. Another possibility
+is that you attempted to open filedescriptor 0 (also known as STDIN) for
+output (maybe you closed STDIN earlier?).
=item Filehandle %s reopened as %s only for input
=item gmtime(%f) too large
-(W overflow) You called C<gmtime> with an number that was larger than
+(W overflow) You called C<gmtime> with a number that was larger than
it can reliably handle and C<gmtime> probably returned the wrong
date. This warning is also triggered with nan (the special
not-a-number value).
=item gmtime(%f) too small
-(W overflow) You called C<gmtime> with an number that was smaller than
+(W overflow) You called C<gmtime> with a number that was smaller than
it can reliably handle and C<gmtime> probably returned the wrong
date. This warning is also triggered with nan (the special
not-a-number value).
=item ()-group starts with a count
-(F) A ()-group started with a count. A count is
-supposed to follow something: a template character or a ()-group.
- See L<perlfunc/pack>.
+(F) A ()-group started with a count. A count is supposed to follow
+something: a template character or a ()-group. See L<perlfunc/pack>.
=item %s had compilation errors.
$a =~ m/$foo/sand $bar
$a =~ m/$foo/s and $bar
-both currently mean the same thing, but it is planned to disallow the first form
-in Perl 5.16. And,
+both currently mean the same thing, but it is planned to disallow the first
+form in Perl 5.16. And,
$a =~ m/$foo/and $bar
=item Illegal character in prototype for %s : %s
(W illegalproto) An illegal character was found in a prototype declaration.
-Legal characters in prototypes are $, @, %, *, ;, [, ], &, and \.
+Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
=item Illegal declaration of anonymous subroutine
supplied (or potentially supplied) by the user. The script must set
the path to a known value, using trustworthy data. See L<perlsec>.
+=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 %s number
(W overflow) The hexadecimal, octal or binary number you have specified
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
The <-- HERE shows in the regular expression about where the
escape was discovered.
+=item Invalid hexadecimal number in \N{U+...}
+
+(F) The character constant represented by C<...> is not a valid hexadecimal
+number. Either it is empty, or you tried to use a character other than
+0 - 9 or A - F, a - f in a hexadecimal number.
+
=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>.
+(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 supported are C<dfs> and C<c3>, unless you have loaded
+a module that is a MRO plugin. See L<mro> and L<perlmroapi>.
=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
=item Invalid separator character %s in PerlIO layer specification %s
-(W layer) When pushing layers onto the Perl I/O system, something other than a
-colon or whitespace was seen between the elements of a layer list.
+(W layer) When pushing layers onto the Perl I/O system, something other
+than a colon or whitespace was seen between the elements of a layer list.
If the previous attribute had a parenthesised parameter list, perhaps that
list was terminated too soon.
(F) A version number did not meet the "lax" criteria for versions.
A "lax" version number is a positive decimal number (integer or
decimal-fraction) without exponentiation or else a dotted-decimal
-v-string. If the v-string has less than three components, it must have a
-leading 'v' character. Otherwise, the leading 'v' is optional. Both
-decimal and dotted-decimal versions may have a trailing "alpha"
+v-string. If the v-string has fewer than three components, it must
+have a leading 'v' character. Otherwise, the leading 'v' is optional.
+Both decimal and dotted-decimal versions may have a trailing "alpha"
component separated by an underscore character after a fractional or
dotted-decimal component. The parenthesized text indicates which
criteria were not met. See the L<version> module for more details on
=item ioctl() on unopened %s
(W unopened) You tried ioctl() on a filehandle that was never opened.
-Check you control flow and number of arguments.
+Check your control flow and number of arguments.
=item IO layers (like '%s') unavailable
(F) Your Perl has not been configured to have PerlIO, and therefore
-you cannot use IO layers. To have PerlIO Perl must be configured
+you cannot use IO layers. To have PerlIO, Perl must be configured
with 'useperlio'.
=item IO::Socket::atmark not implemented on this architecture
(F) Your machine doesn't implement the sockatmark() functionality,
-neither as a system call or an ioctl call (SIOCATMARK).
+neither as a system call nor an ioctl call (SIOCATMARK).
=item $* is no longer supported
-(D deprecated, syntax) The special variable C<$*>, deprecated in older perls, has
-been removed as of 5.9.0 and is no longer supported. In previous versions of perl the use of
-C<$*> enabled or disabled multi-line matching within a string.
+(D deprecated, syntax) The special variable C<$*>, deprecated in older
+perls, has been removed as of 5.9.0 and is no longer supported. In
+previous versions of perl the use of C<$*> enabled or disabled multi-line
+matching within a string.
Instead of using C<$*> you should use the C</m> (and maybe C</s>) regexp
-modifiers. (In older versions: when C<$*> was set to a true value then all regular
-expressions behaved as if they were written using C</m>.)
+modifiers. You can enable C</m> for a lexical scope (even a whole file)
+with C<use re '/m'>. (In older versions: when C<$*> was set to a true value
+then all regular expressions behaved as if they were written using C</m>.)
=item $# is no longer supported
-(D 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.
+(D 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.
=item `%s' is not a code reference
=item Lexing code attempted to stuff non-Latin-1 character into Latin-1 input
(F) An extension is attempting to insert text into the current parse
-(using L<lex_stuff_pvn_flags|perlapi/lex_stuff_pvn_flags> or similar), but
-tried to insert a character that couldn't be part of the current input.
-This is an inherent pitfall of the stuffing mechanism, and one of the
-reasons to avoid it. Where it is necessary to stuff, stuffing only
-plain ASCII is recommended.
+(using L<lex_stuff_pvn_flags|perlapi/lex_stuff_pvn_flags> or similar), but tried to insert a character
+that couldn't be part of the current input. This is an inherent pitfall
+of the stuffing mechanism, and one of the reasons to avoid it. Where it
+is necessary to stuff, stuffing only plain ASCII is recommended.
=item Lexing code internal error (%s)
=item localtime(%f) too large
-(W overflow) You called C<localtime> with an number that was larger
+(W overflow) You called C<localtime> with a number that was larger
than it can reliably handle and C<localtime> probably returned the
wrong date. This warning is also triggered with nan (the special
not-a-number value).
=item localtime(%f) too small
-(W overflow) You called C<localtime> with an number that was smaller
+(W overflow) You called C<localtime> with a number that was smaller
than it can reliably handle and C<localtime> probably returned the
wrong date. This warning is also triggered with nan (the special
not-a-number value).
values cannot be returned in subroutines used in lvalue context. See
L<perlsub/"Lvalue subroutines">.
-=item Malformed integer in [] in pack
+=item Malformed integer in [] in pack
-(F) Between the brackets enclosing a numeric repeat count only digits
+(F) Between the brackets enclosing a numeric repeat count only digits
are permitted. See L<perlfunc/pack>.
=item Malformed integer in [] in unpack
-(F) Between the brackets enclosing a numeric repeat count only digits
+(F) Between the brackets enclosing a numeric repeat count only digits
are permitted. See L<perlfunc/pack>.
=item Malformed PERLLIB_PREFIX
See also L<Encode/"Handling Malformed Data">.
-=item 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.
-
=item Malformed UTF-8 returned by \N
(F) The charnames handler returned malformed UTF-8.
-=item Malformed UTF-8 string in pack
+=item Malformed UTF-8 string in '%c' format in unpack
-(F) You tried to pack something that didn't comply with UTF-8 encoding
+(F) You tried to unpack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
-=item Malformed UTF-8 string in unpack
+=item Malformed UTF-8 string in pack
-(F) You tried to unpack something that didn't comply with UTF-8 encoding
+(F) You tried to pack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
-=item Malformed UTF-8 string in '%c' format in unpack
+=item Malformed UTF-8 string in unpack
(F) You tried to unpack something that didn't comply with UTF-8 encoding
rules and perl was unable to guess how to make more progress.
-=item Maximal count of pending signals (%u) exceeded
+=item Malformed UTF-16 surrogate
-(F) Perl aborted due to a too high 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)">.)
+(F) Perl thought it was reading UTF-16 encoded character data but while
+doing it Perl met a malformed Unicode surrogate.
=item %s matches null string many times in regex; marked by <-- HERE in m/%s/
shows in the regular expression about where the problem was discovered.
See L<perlre>.
+=item 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 L<perlipc/"Deferred Signals (Safe Signals)">.)
+
=item "%s" may clash with future reserved word
(W) This warning may be due to running a perl5 script through a perl4
=item Missing braces on \N{}
(F) Wrong syntax of character name literal C<\N{charname}> within
-double-quotish context. This can also happen when there is a space (or
-comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
-This modifier does not change the requirement that the brace immediately follow
-the C<\N>.
+double-quotish context. This can also happen when there is a space
+(or comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
+This modifier does not change the requirement that the brace immediately
+follow the C<\N>.
=item Missing braces on \o{}
=item Missing right brace on \N{} or unescaped left brace after \N
-(F)
-C<\N> has two meanings.
+(F) C<\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 C<\N{ASTERISK}> is another way of writing C<*>, valid in both
-double-quoted strings and regular expression patterns. In patterns, it doesn't
-have the meaning an unescaped C<*> does.
+The traditional one has it followed by a name enclosed in braces,
+meaning the character (or sequence of characters) given by that
+name. Thus C<\N{ASTERISK}> is another way of writing C<*>, valid in both
+double-quoted strings and regular expression patterns. In patterns,
+it doesn't have the meaning an unescaped C<*> does.
-Starting in Perl 5.12.0, C<\N> also can have an additional meaning (only) in
-patterns, namely to match a non-newline character. (This is short for
-C<[^\n]>, and like C<.> but is not affected by the C</s> regex modifier.)
+Starting in Perl 5.12.0, C<\N> also can have an additional meaning (only)
+in patterns, namely to match a non-newline character. (This is short
+for C<[^\n]>, and like C<.> but is not affected by the C</s> regex modifier.)
-This can lead to some ambiguities. When C<\N> is not followed immediately by a
-left brace, Perl assumes the C<[^\n]> meaning. Also, if
-the braces form a valid quantifier such as C<\N{3}> or C<\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 C<\N{>
-and a matching C<}>, Perl assumes that a character name is desired.
+This can lead to some ambiguities. When C<\N> is not followed immediately
+by a left brace, Perl assumes the C<[^\n]> meaning. Also, if the braces
+form a valid quantifier such as C<\N{3}> or C<\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
+C<\N{> and a matching C<}>, Perl assumes that a character name is desired.
-However, if there is no matching C<}>, Perl doesn't know if it was mistakenly
-omitted, or if C<[^\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: C<\N\{>
+However, if there is no matching C<}>, Perl doesn't know if it was
+mistakenly omitted, or if C<[^\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: C<\N\{>
=item Missing right curly or square bracket
(F) Lexically scoped subroutines are not yet implemented. Don't try
that yet.
-=item "%s" variable %s can't be in a package
+=item "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.
+=item 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 C<our> declaration is
+provided for this purpose.
+
+NOTE: This warning detects symbols that have been used only once so $c, @c,
+%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
+the same; if a program uses $c only once but also uses any of the others it
+will not trigger this warning.
+
=item \N in a character class must be a named character: \N{...}
(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed
-character class, for the same reason that C<.> in a character class loses its
-specialness: it matches almost everything, which is probably not what you want.
+character class, for the same reason that C<.> in a character class loses
+its specialness: it matches almost everything, which is probably not
+what you want.
=item \N{NAME} must be resolved by the lexer
-(F) When compiling a regex pattern, an unresolved named character or sequence
-was encountered. This can happen in any of several ways that bypass the lexer,
-such as using single-quotish context, or an extra backslash in double quotish:
+(F) When compiling a regex pattern, an unresolved named character or
+sequence was encountered. This can happen in any of several ways that
+bypass the lexer, such as using single-quotish context, or an extra
+backslash in double-quotish:
$re = '\N{SPACE}'; # Wrong!
$re = "\\N{SPACE}"; # Wrong!
/\N {SPACE}/x; # Wrong!
/\N{SPACE}/x; # ok
-=item 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 C<our> declaration is
-provided for this purpose.
-
-NOTE: This warning detects symbols that have been used only once so $c, @c,
-%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
-the same; if a program uses $c only once but also uses any of the others it
-will not trigger this warning.
-
-=item Invalid hexadecimal number in \N{U+...}
-
-(F) The character constant represented by C<...> is not a valid hexadecimal
-number. Either it is empty, or you tried to use a character other than 0 - 9
-or A - F, a - f in a hexadecimal number.
-
=item Negative '/' count in unpack
(F) The length count obtained from a length/code unpack operation was
constant to your name space with B<use> or B<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
+explicit import list for the constants you expect to see; please see
L<perlfunc/use> and L<perlfunc/import>. 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
=item No DB::DB routine defined
(F) The currently executing code was compiled with the B<-d> switch, but
-for some reason the
current debugger (e.g. F<perl5db.pl> or a C<Devel::>
+for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
module) didn't define a routine to be called at the beginning of each
statement.
module) didn't define a C<DB::sub> routine to be called at the beginning
of each ordinary subroutine call.
-=item No B<-e> allowed in setuid scripts
-
-(F) A setuid script can't be specified by the user.
-
=item 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 '<' on the command line, but can't find the
name of the file from which to read data for stdin.
-=item No #! line
-
-(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
(F) The indicated command line switch needs a mandatory argument, but
you haven't specified one.
+
=item No such class field "%s" in variable %s of type %s
(F) You tried to access a key from a hash through the indicated typed variable
=item 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.
+(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 hook: %s
-(F) You specified a signal hook that was not recognized by Perl. Currently, Perl
-accepts C<__DIE__> and C<__WARN__> as valid signal hooks
+(F) You specified a signal hook that was not recognized by Perl.
+Currently, Perl accepts C<__DIE__> and C<__WARN__> as valid signal hooks.
=item No such pipe open
a reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See L<perlref>.
-=item Not a perl script
-
-(F) The setuid emulator requires that scripts have a well-formed #! line
-even on machines that don't support the #! construct. The line must
-mention perl.
-
=item Not a SCALAR reference
(F) Perl was trying to evaluate a reference to a scalar value, but found
=item 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.
+(W digit) In parsing an octal numeric constant, a character was
+unexpectedly encountered that isn't octal. The resulting value is as
+indicated.
=item Non-string passed as bitmask
(W misc) A number has been passed as a bitmask argument to select().
Use the vec() function to construct the file descriptor bitmasks for
-select. See L<perlfunc/select>
+select. See L<perlfunc/select>.
=item Null filename used
=item Number with no digits
-(F) Perl was looking for a number but found nothing that looked like a number.
-This happens, for example with C<\o{}>, with no number between the braces.
+(F) Perl was looking for a number but found nothing that looked like
+a number. This happens, for example with C<\o{}>, with no number between
+the braces.
=item Octal number in vector unsupported
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
-See also L<perlport> for writing portable code.
-
=item Odd number of arguments for overload::constant
(W overload) The call to overload::constant contained an odd number of
(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
-C<fallback> overloading key is specified to be true. See L<overload>.
+the C<fallback> overloading key is specified to be true. See L<overload>.
-=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
+=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(W) You performed an operation requiring Unicode semantics on a Unicode
-surrogate. Unicode frowns upon the use of surrogates for anything but
-storing strings in UTF-16, but semantics 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.
+(W) You performed an operation requiring Unicode semantics 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
C<no warnings 'utf8';>.
-=item Operation "%s" returns its argument for non-Unicode code point 0x%X
+=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(W) You performed an operation requiring Unicode semantics 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.
+(W) You performed an operation requiring Unicode semantics on a Unicode
+surrogate. Unicode frowns upon the use of surrogates for anything but
+storing strings in UTF-16, but semantics 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.
some day, even though it doesn't yet. Perhaps you should use a
mixed-case attribute name, instead. See L<attributes>.
-=item \p{} uses Unicode rules, not locale rules
-
-(W) You compiled a regular expression that contained a Unicode property
-match (C<\p> or C<\P>), but the regular expression is also being told to
-use the run-time locale, not Unicode. Instead, use a POSIX character
-class, which should know about the locale's rules.
-(See L<perlrecharclass/POSIX Character Classes>.)
-
-Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of
-Unicode, some properties will give results that are not valid for that
-subset.
-
-Here are a couple of examples to help you see what's going on. If the
-locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK
-CAPITAL LETTER CHI". But in Unicode that code point means the
-"MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode
-meaning. That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]>
-should. Only in the Latin1 locale are all the characters in the same
-positions as they are in Unicode. But, even here, some properties give
-incorrect results. An example is C<\p{Changes_When_Uppercased}> which
-is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper
-case of that character is not in Latin1, in that locale it doesn't
-change when upper cased.
-
=item pack/unpack repeat count overflow
(F) You can't specify a repeat count so large that it overflows your
=item panic: hfreeentries failed to free hash
-(P) The internal routine used to clear a hashes entries tried repeatedly,
+(P) The internal routine used to clear a hash's 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: unimplemented op %s (#%d) called
-(P) The compiler is screwed up and attempted to use an op that isn't permitted
-at run time.
+(P) The compiler is screwed up and attempted to use an op that isn't
+permitted at run time.
=item panic: utf16_to_utf8: odd bytelen
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, 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
+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
L<perllocale> section B<LOCALE PROBLEMS>.
=item pid %x not a child
really meant to write this, disable the warning, or, better, put the
parentheses explicitly and write C<$x & ($y == 0)>).
-=item Possible unintended interpolation of %s in string
-
-(W ambiguous) You said something like `@foo' in a double-quoted string
-but there was no array C<@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.
-
=item Possible unintended interpolation of $\ in regex
(W ambiguous) You said something like C<m/$\/> in a regex.
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 Possible unintended interpolation of %s in string
+
+(W ambiguous) You said something like `@foo' in a double-quoted string
+but there was no array C<@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.
+
=item Precedence problem: open %s should be open(%s)
(S precedence) The old irregular construct
(F) You've omitted the closing parenthesis in a function prototype
definition.
+=item \p{} uses Unicode rules, not locale rules
+
+(W) You compiled a regular expression that contained a Unicode property
+match (C<\p> or C<\P>), but the regular expression is also being told to
+use the run-time locale, not Unicode. Instead, use a POSIX character
+class, which should know about the locale's rules.
+(See L<perlrecharclass/POSIX Character Classes>.)
+
+Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of
+Unicode, some properties will give results that are not valid for that
+subset.
+
+Here are a couple of examples to help you see what's going on. If the
+locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK
+CAPITAL LETTER CHI". But in Unicode that code point means the
+"MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode
+meaning. That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]>
+should. Only in the Latin1 locale are all the characters in the same
+positions as they are in Unicode. But, even here, some properties give
+incorrect results. An example is C<\p{Changes_When_Uppercased}> which
+is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper
+case of that character is not in Latin1, in that locale it doesn't
+change when upper cased.
+
=item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
(F) You started a regular expression with a quantifier. Backslash it if you
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
+=item refcnt: fd %d%s
-(F) More than 100 levels of inheritance were encountered while invoking
-a method. Probably indicates an unintended loop in your inheritance
-hierarchy.
+(P) Perl's I/O implementation failed an internal consistency check. If
+you see this message, something is very wrong.
=item Reference found where even-sized list expected
=item Reference miscount in sv_replace()
(W internal) The internal sv_replace() function was handed a new SV with
-a reference count of other than 1.
+a reference count 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.
+backreferences). 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
-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: C<\007>
-
-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.
+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: C<\007>
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.
+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/
+=item Reference to nonexistent or unclosed group 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.
+(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 Reversed %s= operator
(W syntax) You wrote your assignment operator backwards. The = must
-always comes last, to avoid ambiguity with subsequent unary operators.
+always come last, to avoid ambiguity with subsequent unary operators.
=item rewinddir() attempted on invalid dirhandle %s
parsed. One way to disambiguate the parsing is to put parentheses around
the conditional expression, i.e. C<(foo) ? 0 : 1>.
-=item %sseek() on unopened filehandle
-
-(W unopened) You tried to use the seek() or sysseek() function on a
-filehandle that was either never opened or has since been closed.
-
=item seekdir() attempted on invalid dirhandle %s
(W io) The dirhandle you are doing a seekdir() on is either closed or not
really a dirhandle. Check your control flow.
+=item %sseek() on unopened filehandle
+
+(W unopened) You tried to use the seek() or sysseek() function on a
+filehandle that was either never opened or has since been closed.
+
=item select not implemented
(F) This machine doesn't implement the select() system call.
=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
-(F) If the contents of a (?{...}) clause contains braces, they must balance
-for Perl to properly detect the end of the clause. The <-- HERE shows in
+(F) If the contents of a (?{...}) clause contain braces, they must balance
+for Perl to detect the end of the clause properly. The <-- HERE shows in
the regular expression about where the problem was discovered. See
L<perlre>.
-=item "500 Server error"
+=item Z<>500 Server error
See Server error.
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
-=item Setuid/gid script is writable by world
-
-(F) The setuid emulator won't run a script that is writable by the
-world, because the world might have written on it already.
-
-=item Setuid script not plain file
-
-(F) The setuid emulator won't run a script that isn't read from a file,
-but from a socket, a pipe or another device.
-
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
instead, which does return. To suppress this warning, put the exec() in
a block by itself.
+=item "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.
+
=item stat() on unopened filehandle %s
(W unopened) You tried to use the stat() function on a filehandle that
=item sv_upgrade from type %d down to type %d
-(P) Perl tried to force the upgrade an SV to a type which was actually
+(P) Perl tried to force the upgrade of an SV to a type which was actually
inferior to its current type.
=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
=item Switch condition not recognized in regex; marked by <-- HERE in m/%s/
-(F) If the argument to the (?(...)if-clause|else-clause) construct is a
-number, it can be only a number. The <-- HERE shows in the regular expression
-about where the problem was discovered. See L<perlre>.
+(F) If the argument to the (?(...)if-clause|else-clause) construct is
+a number, it can be only a number. The <-- HERE shows in the regular
+
expression about where the problem was discovered. See L<perlre>.
=item switching effective %s is not implemented
(F) While under the C<use filetest> pragma, we cannot switch the real
and effective uids or gids.
-=item %s syntax
+=item %s syntax OK
(F) The final summary message when a C<perl -c> succeeds.
(F) You tried to use C<goto> to reach a label that was too deeply nested
for Perl to reach. Perl is doing you a favor by refusing.
-=item 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.
-
=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 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.
+
=item That use of $[ is unsupported
(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
them. If you know what you are doing you can turn
off this warning by C<no warnings 'utf8';>.
+=item Unicode surrogate U+%X is illegal in UTF-8
+
+(W utf8) 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 C<no warnings 'utf8';>.
+
=item Unknown BYTEORDER
(F) There are no byte-swapping functions for a machine with this byte
=item Unknown switch condition (?(%s 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 may be lookahead or lookbehind (the condition
-is true if the lookahead or lookbehind is true), a (?{...}) construct (the
-condition is true if the code evaluates to a true value), or a number (the
-condition is true if the set of capturing parentheses named by the number
-matched).
+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 in the regular expression about where the problem was
discovered. See L<perlre>.
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
-=item Unknown warnings category '%s'
-
-(F) An error issued by the C<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. 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 Unknown warnings category '%s'
+
+(F) An error issued by the C<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. C<use warnings 'File::Find'>), you must have loaded this
+module first.
=item unmatched [ in regex; marked by <-- HERE in m/%s/
recognized by Perl. The character was understood literally, but this may
change in a future version of Perl.
-=item Unrecognized escape \%c passed through in regex; marked by <-- HERE in m/%s/
+=item 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 was understood literally, but this may
+recognized by Perl. The character(s) were understood literally, but this may
change in a future version of Perl.
The <-- HERE shows in the regular expression about where the
escape was discovered.
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
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=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 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 untie attempted while %d inner references still exist
(W untie) A copy of the object returned from C<tie> (or C<tied>) was
If you need an empty attribute list, for example in a code generator, add
a space before the C<=>.
-=item Use of ?PATTERN? without explicit operator is deprecated
-
-(D deprecated) You have written something like C<?\w?>, for a regular
-expression that matches only once. Starting this term directly with
-the question mark delimiter is now deprecated, so that the question mark
-will be available for use in new operators in the future. Write C<m?\w?>
-instead, explicitly using the C<m> operator: the question mark delimiter
-still invokes match-once behaviour.
-
=item Use of freed value in iteration
(F) Perhaps you modified the iterated array within the loop?
=item Use of inherited AUTOLOAD for non-method %s() is deprecated
-(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
-are looked up as methods (using the C<@ISA> hierarchy) even when the
-subroutines to be autoloaded were called as plain functions (e.g.
-C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or C<<
-$obj->bar() >>).
+(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD>
+subroutines are looked up as methods (using the C<@ISA> hierarchy)
+even when the subroutines to be autoloaded were called as plain
+functions (e.g. C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or
+C<< $obj->bar() >>).
This bug will be rectified in future by using method lookup only for
methods' C<AUTOLOAD>s. However, there is a significant base of existing
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=item Use of -l on filehandle %s
+
+(W io) A filehandle represents an opened file, and when you opened the file
+it already went past any symlink you are presumably trying to look for.
+The operation returned C<undef>. Use a filename instead.
+
=item Use of %s on a handle without * is deprecated
(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that
a typeglob, and no way to untie a scalar that has had a typeglob
assigned to it.
-=item Use of -l on filehandle %s
-
-(W io) A filehandle represents an opened file, and when you opened the file
-it already went past any symlink you are presumably trying to look for.
-The operation returned C<undef>. Use a filename instead.
-
-=item Use of "package" with no arguments is deprecated
+=item Use of ?PATTERN? without explicit operator is deprecated
-(D deprecated) You used the C<package> keyword without specifying a package
-name. So no namespace is current at all. Using this can cause many
-otherwise reasonable constructs to fail in baffling ways. C<use strict;>
-instead.
+(D deprecated) You have written something like C<?\w?>, for a regular
+expression that matches only once. Starting this term directly with
+the question mark delimiter is now deprecated, so that the question mark
+will be available for use in new operators in the future. Write C<m?\w?>
+instead, explicitly using the C<m> operator: the question mark delimiter
+still invokes match-once behaviour.
=item Use of qw(...) as parentheses 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
+however, because you can overload the numification and stringification
operators and then you presumably know what you are doing.
=item Use of reserved word "%s" is deprecated
allow this syntax, but shouldn't have. It is now deprecated, and will be
removed in a future version.
-=item Using !~ with %s doesn't make sense
-
-(F) Using the C<!~> operator with C<s///r>, C<tr///r> or C<y///r> is
-currently reserved for future use, as the exact behaviour has not
-been decided. (Simply returning the boolean opposite of the
-modified string is usually not particularly useful.)
-
=item Using just the first character returned by \N{} in character class
(W) A charnames handler may return a sequence of more than one character.
=item Using just the first characters returned by \N{}
-(W) A charnames handler may return a sequence of characters. There is a finite
-limit as to the number of characters that can be used, which this sequence
-exceeded. In the message, the characters in the sequence are separated by
-dots, and each is shown by its ordinal in hex. Anything to the left of the
-C<HERE> was retained; anything to the right was discarded.
+(W) A charnames handler may return a sequence of characters. There is a
+finite limit as to the number of characters that can be used, which this
+sequence exceeded. In the message, the characters in the sequence are
+separated by dots, and each is shown by its ordinal in hex. Anything to
+the left of the C<HERE> was retained; anything to the right was discarded.
-=item Unicode surrogate U+%X is illegal in UTF-8
+=item Using !~ with %s doesn't make sense
+
+(F) Using the C<!~> operator with C<s///r>, C<tr///r> or C<y///r> is
+currently reserved for future use, as the exact behaviour has not
+been decided. (Simply returning the boolean opposite of the
+modified string is usually not particularly useful.)
=item UTF-16 surrogate U+%X
=item "%s" variable %s masks earlier declaration in same %s
-(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
-all closure referents to it are destroyed.
+(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 all closure referents to it are destroyed.
=item Variable syntax
(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
C<TEMPLATE> always matches the same amount of packed bytes that can be
-determined from the template alone. This is not possible if it contains an
+determined from the template alone. This is not possible if it contains any
of the codes @, /, U, u, w or a *-length. Redesign the template.
=item write() on closed filehandle %s
https://perl5.git.perl.org / perl5.git / blobdiff