desperation):
(W) A warning (optional).
- (D) A deprecation (optional).
+ (D) A deprecation (enabled by default).
(S) A severe warning (enabled by default).
(F) A fatal error (trappable).
(P) An internal error you should never see (trappable).
(W misc) The pattern match (C<//>), substitution (C<s///>), and
transliteration (C<tr///>) operators work on scalar values. If you apply
one of them to an array or a hash, it will convert the array or hash to
-a scalar value -- the length of an array, or the population info of a
-hash -- and then work on that scalar value. This is probably not what
+a scalar value (the length of an array, or the population info of a
+hash) and then work on that scalar value. This is probably not what
you meant to do. See L<perlfunc/grep> and L<perlfunc/map> for
alternatives.
$var = 'myvar';
$sym = "mypack::$var";
+=item Bad plugin affecting keyword '%s'
+
+(F) An extension using the keyword plugin mechanism violated the
+plugin API.
+
=item Bad realloc() ignored
(S malloc) An internal routine called realloc() on something that had
(P) Perl detected an attempt to copy a value to an internal type that cannot
be directly assigned not.
+=item Cannot find encoding "%s"
+
+(S io) You tried to apply an encoding that did not exist to a filehandle,
+either with open() or binmode().
+
=item Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer. The BER compressed
=item Can't find %s character property "%s"
(F) You used C<\p{}> or C<\P{}> but the character property by that name
-could not be found. Maybe you misspelled the name of the property
-(remember that the names of character properties consist only of
-alphanumeric characters), or maybe you forgot the C<Is> or C<In> prefix?
+could not be found. Maybe you misspelled the name of the property?
+See L<perluniprops/Properties accessible through \p{} and \P{}>
+for a complete list of available properties.
=item Can't find label %s
=item Can't find Unicode property definition "%s"
(F) You may have tried to use C<\p> which means a Unicode property (for
-example C<\p{Lu}> is all uppercase letters). If you did mean to use a
-Unicode property, see L<perlunicode> for the list of known properties.
+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 example you cannot force little-endianness on a type that
is inside a big-endian group.
-=item Can't use keyword '%s' as a label
-
-(F) You attempted to use a reserved keyword, such as C<print> or C<BEGIN>,
-as a statement label. This is disallowed since Perl 5.11.0.
-
=item Can't use "my %s" in sort comparison
(F) The global variables $a and $b are reserved for sort comparisons.
with an assignment operator, which implies modifying the value itself.
Perhaps you need to copy the value to a temporary, and repeat that.
+=item Character following "\\c" must be ASCII
+
+(F) In C<\cI<X>>, I<X> must be an ASCII character.
+
=item Character in 'C' format wrapped in pack
(W pack) You said
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
+=item \\c%c" more clearly written simply as "%c
+
+(D deprecated) 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.
+
=item Deep recursion on subroutine "%s"
(W recursion) This subroutine has called itself (directly or indirectly)
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
+=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.
+
=item Deprecated use of my() in false conditional
(D deprecated) You used a declaration similar to C<my $x if 0>.
=item (Did you mean &%s instead?)
-(W) You probably referred to an imported subroutine &FOO as $FOO or some
-such.
+(W misc) You probably referred to an imported subroutine &FOO as $FOO or
+some such.
=item (Did you mean "local" instead of "our"?)
See Server error.
+=item Dot after %s literal is deprecated concatenation
+
+(D deprecated, syntax) You had something like 0x123.456 in your code.
+This is currently
+parsed as the hexadecimal number 0x123 concatenated with the decimal
+number 456, not the fraction 0x123 + 0x456/0x1000 -- we only support decimal
+fractions. If you meant it to be a fraction, you'll need to use
+Math::BigFloat's from_hex (or friends). If you meant it to be
+concatenation, just put spaces around the dot to make it clearer. In
+5.14.0, we expect to change this to mean a hex fraction. (Of course,
+everything above applies to octal and binary constants, too.)
+
=item %s does not define %s::VERSION--version check failed
(F) You said something like "use Module 42" but the Module did not
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=item gmtime(%.0f) too large
+
+(W overflow) You called C<gmtime> with an 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(%.0f) too small
+
+(W overflow) You called C<gmtime> with an 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 Got an error from DosAllocMem
(P) An error peculiar to OS/2. Most probably you're using an obsolete
names (like C<$A::B>). You've exceeded Perl's limits. Future versions
of Perl are likely to eliminate these arbitrary limitations.
-=item Ignoring %s in character class in regex; marked by <-- HERE in m/%s/
+=item Ignoring zero length \N{} in character class
-(W) Named Unicode character escapes (\N{...}) may return multi-char
-or zero length sequences. When such an escape is used in a character class
+(W) Named Unicode character escapes (\N{...}) may return a
+zero length sequence. When such an escape is used in a character class
its behaviour is not well defined. Check that the correct escape has
been used, and the correct charname handler is in scope.
=item Illegal character in prototype for %s : %s
-(W syntax) An illegal character was found in a prototype declaration. Legal
-characters in prototypes are $, @, %, *, ;, [, ], &, and \.
+(W illegalproto) An illegal character was found in a prototype declaration.
+Legal characters in prototypes are $, @, %, *, ;, [, ], &, and \.
=item Illegal declaration of anonymous subroutine
=item $* is no longer supported
-(S deprecated, syntax) The special variable C<$*>, deprecated in older perls, has
+(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.
=item $# is no longer supported
-(S deprecated, syntax) The special variable C<$#>, deprecated in older perls, has
+(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.
length/code combination tried to obtain more data. This results in
an undefined value for the length. See L<perlfunc/pack>.
+=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.
+
+=item Lexing code internal error (%s)
+
+(F) Lexing code supplied by an extension violated the lexer's API in a
+detectable way.
+
=item listen() on closed socket %s
(W closed) You tried to do a listen on a closed socket. Did you forget
to check the return value of your socket() call? See
L<perlfunc/listen>.
+=item localtime(%.0f) too large
+
+(W overflow) You called C<localtime> with an 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(%.0f) too small
+
+(W overflow) You called C<localtime> with an 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).
+
=item Lookbehind longer than %d not implemented in regex m/%s/
(F) There is currently a limit on the length of string which lookbehind can
by that? lstat() makes sense only on filenames. (Perl did a fstat()
instead on the filehandle.)
+=item lvalue attribute ignored after the subroutine has been defined
+
+(W misc) Making a subroutine an lvalue subroutine after it has been defined
+by declaring the subroutine with a lvalue attribute is not
+possible. To make the the subroutine a lvalue subroutine add the
+lvalue attribute to the definition, or put the the declaration before
+the definition.
+
=item Lvalue subs returning %s not implemented yet
(F) Due to limitations in the current implementation, array and hash
(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
(F) You tried to pack something that didn't comply with UTF-8 encoding
(W syntax) An underscore (underbar) in a numeric constant did not
separate two digits.
+=item Missing argument in %s
+
+(W uninitialized) A printf-type format required more arguments than were
+supplied.
+
=item Missing argument to -%c
(F) The argument to the indicated command line switch must follow
immediately after the switch, without intervening spaces.
-=item Missing %sbrace%s on \N{}
+=item Missing braces on \N{}
(F) Wrong syntax of character name literal C<\N{charname}> within
-double-quotish context.
+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 comma after first argument to %s function
=item Missing right brace on %s
-(F) Missing right brace in C<\x{...}>, C<\p{...}> or C<\P{...}>.
+(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
+
+=item Missing right brace on \\N{} or unescaped left brace after \\N
+
+(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.
+
+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.
+
+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
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
+=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.
+
+=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:
+
+ $re = '\N{SPACE}'; # Wrong!
+ $re = "\\N{SPACE}"; # Wrong!
+ /$re/;
+
+Instead, use double-quotes with a single backslash:
+
+ $re = "\N{SPACE}"; # ok
+ /$re/;
+
+The lexer can be bypassed as well by creating the pattern from smaller
+components:
+
+ $re = '\N';
+ /${re}{SPACE}/; # Wrong!
+
+It's not a good idea to split a construct in the middle like this, and it
+doesn't work here. Instead use the solution above.
+
+Finally, the message also can happen under the C</x> regex modifier when the
+C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
+
+ /\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.
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
the string being unpacked. The string being unpacked was also invalid
UTF-8. See L<perlfunc/pack>.
+=item Overloaded dereference did not return a reference
+
+(F) An object with an overloaded dereference operator was dereferenced,
+but the overloaded operation did not return a reference. See
+L<overload>.
+
+=item Overloaded qr did not return a REGEXP
+
+(F) An object with a C<qr> overload was used as part of a match, but the
+overloaded operation didn't return a compiled regexp. See L<overload>.
+
=item %s package attribute may clash with future reserved word: %s
(W reserved) A lowercase attribute name was used that had a
(P) Something tried to call utf16_to_utf8 with an odd (as opposed
to even) byte length.
+=item panic: utf16_to_utf8_reversed: odd bytelen
+
+(P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed
+to even) byte length.
+
=item panic: yylex
(P) The lexer got into a bad state while processing a case modifier.
=item Prototype after '%c' for %s : %s
-(W syntax) A character follows % or @ in a prototype. This is useless,
+(W illegalproto) A character follows % or @ in a prototype. This is useless,
since % and @ gobble the rest of the subroutine arguments.
=item Prototype mismatch: %s vs %s
(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
really a dirhandle. Check your control flow.
-=item Runaway format
-
-(F) Your format contained the ~~ repeat-until-blank sequence, but it
-produced 200 lines at once, and the 200th line looked exactly like the
-199th line. Apparently you didn't arrange for the arguments to exhaust
-themselves, either by using ^ instead of @ (for scalar variables), or by
-shifting or popping (for array variables). See L<perlform>.
-
=item Scalars leaked: %d
(P) Something went wrong in Perl's internal bookkeeping of scalars:
(W utf8) Certain codepoints, such as U+FFFE and U+FFFF, are defined by the
Unicode standard to be non-characters. Those are legal codepoints, but are
reserved for internal use; so, applications shouldn't attempt to exchange
-them. If you know what you are doing you can turn off this warning by
-C<no warnings 'utf8';>.
+them. In some cases, this message is also given if you use a codepoint that
+isn't in Unicode--that is it is above the legal maximum of U+10FFFF. These
+aren't legal at all in Unicode, so they are illegal for interchange, but can be
+used internally in a Perl program. If you know what you are doing you can turn
+off this warning by C<no warnings 'utf8';>.
=item Unknown BYTEORDER
(W regexp) You used a backslash-character combination which is not
recognized by Perl inside character classes. The character was
-understood literally.
+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.
=item Unrecognized escape \\%c passed through
(W misc) You used a backslash-character combination which is not
-recognized by Perl. The character was understood literally.
+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/
(W regexp) You used a backslash-character combination which is not
-recognized by Perl. The character was understood literally.
+recognized by Perl. The character was 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.
=item Use of bare << to mean <<"" is deprecated
-(D deprecated, W syntax) You are now encouraged to use the explicitly quoted
+(D deprecated) You are now encouraged to use the explicitly quoted
form if you wish to use an empty line as the terminator of the here-document.
=item Use of comma-less variable list is deprecated
-(D deprecated, W syntax) The values you give to a format should be
+(D deprecated) The values you give to a format should be
separated by commas, not just aligned on a line.
=item Use of chdir('') or chdir(undef) as chdir() deprecated
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
+=item Use of := for an empty attribute list is deprecated
+
+(D deprecated) The construction C<my $x := 42> currently
+parses correctly in perl, being equivalent to C<my $x : = 42>
+(applying an empty attribute list to C<$x>). This useless
+construct is now deprecated, so C<:=> can be reclaimed as a new
+operator in the future.
+
=item Use of freed value in iteration
(F) Perhaps you modified the iterated array within the loop?
operator. Since C<split> always tries to match the pattern
repeatedly, the C</g> has no effect.
+=item Use of "goto" to jump into a construct is deprecated
+
+(D deprecated) Using C<goto> to jump from an outer scope into an inner
+scope is deprecated and should be avoided.
+
=item Use of inherited AUTOLOAD for non-method %s() is deprecated
(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
allow this syntax, but shouldn't have. It is now deprecated, and will be
removed in a future version.
+=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.
+Currently all but the first one are discarded when used in a regular
+expression pattern bracketed character class.
+
+=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.
+
=item UTF-16 surrogate %s
-(W utf8) You tried to generate half of an UTF-16 surrogate by
+(W utf8) You tried to generate half of a UTF-16 surrogate by
requesting a Unicode character between the code points 0xD800 and
0xDFFF (inclusive). That range is reserved exclusively for the use of
UTF-16 encoding (by having two 16-bit UCS-2 characters); but Perl
encodes its characters in UTF-8, so what you got is a very illegal
-character. If you really know what you are doing you can turn off
+character. If you really really know what you are doing you can turn off
this warning by C<no warnings 'utf8';>.
=item Value of %s can be "0"; test with defined()
=item Variable "%s" is not imported%s
-(F) While "use strict" in effect, you referred to a global variable that
-you apparently thought was imported from another module, because
+(W misc) With "use strict" in effect, you referred to a global variable
+that you apparently thought was imported from another module, because
something else of the same name (usually a subroutine) is exported by
that module. It usually means you put the wrong funny character on the
front of your variable.
projects / p5sagit/p5-mst-13.2.git / blobdiff