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[...]
+
+=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
because other Perl programmers will expect it, and it works better if
there are more than 9 backreferences.
-=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 Binary number > 0b11111111111111111111111111111111 non-portable
(W portable) The binary number you specified is larger than 2**32-1
(W unopened) You tried binmode() on a filehandle that was never opened.
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
(W portable) Using bit vector sizes larger than 32 is non-portable.
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)
=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.
(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
=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
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
https://perl5.git.perl.org / perl5.git / blobdiff