to check the return value of your socket() call? See
L<perlfunc/accept>.
-=item Allocation too large: %lx
+=item Allocation too large: %x
(X) You can't allocate more than 64K on an MS-DOS machine.
to be an object method (see L<perlsub/"Subroutine Attributes"> or
L<attributes>).
+=item Ambiguous overloaded argument to %s resolved as %s
+
+(W ambiguous) You called C<keys>, C<values> or C<each> on an object that had
+overloading of C<%{}> or C<@{}> or both. In such a case, the object is
+dereferenced according to its overloading, not its underlying reference type.
+The warning is issued when C<%{}> overloading exists on a blessed arrayref,
+when C<@{}> overloading exists on a blessed hashref, or when both overloadings
+are defined (in which case C<%{}> is used). You can force the interpretation
+of the object by explicitly dereferencing it as an array or hash instead of
+passing the object itself to C<keys>, C<values> or C<each>.
+
=item Ambiguous range in transliteration operator
(F) You wrote something like C<tr/a-z-0//> which doesn't mean anything at
(F) The failing code attempted to delete a key whose value has been
declared readonly from a restricted hash.
-=item Attempt to free non-arena SV: 0x%lx
+=item Attempt to free non-arena SV: 0x%x
(P internal) All SV objects are supposed to be allocated from arenas
that will be garbage collected on exit. An SV was discovered to be
had no effect since Perl 5.8.8, and will be removed in the next major
release of Perl 5.
-=item Bad arg length for %s, is %d, should be %d
+=item Bad arg length for %s, is %u, should be %d
(F) You passed a buffer of the wrong size to one of msgctl(), semctl()
or shmctl(). In C parlance, the correct sizes are, respectively,
=item Character following "\c" must be ASCII
-(F) In C<\cI<X>>, I<X> must be an ASCII character.
+(F|W deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
+It is planned to make this fatal in all instances in Perl 5.16. In the
+cases where it isn't fatal, the character this evaluates to is
+derived by exclusive or'ing the code point of this character with 0x40.
+
+Note that non-alphabetic ASCII characters are discouraged here as well.
=item Character in 'C' format wrapped in pack
(W io) The dirhandle you tried to close is either closed or not really
a dirhandle. Check your control flow.
+=item Closure prototype called
+
+(F) If a closure has attributes, the subroutine passed to an attribute
+handler is the prototype that is cloned when a new closure is created.
+This subroutine cannot be called.
+
=item Code missing after '/'
(F) You had a (sub-)template that ends with a '/'. There must be another
template code following the slash. See L<perlfunc/pack>.
+=item Code point 0x%X is not Unicode, may not be portable
+
+=item Code point 0x%X is not Unicode, no properties match it; all inverse properties do
+
+(W utf8) You had a code point above the Unicode maximum of U+10FFFF.
+
+Perl allows strings to contain a superset of Unicode code
+points, up to the limit of what is storable in an unsigned integer on
+your system, but these may not be accepted by other languages/systems.
+At one time, it was legal in some standards to have code points up to
+0x7FFF_FFFF, but not higher. Code points above 0xFFFF_FFFF require
+larger than a 32 bit word.
+
+None of the Unicode or Perl-defined properties will match a non-Unicode
+code point. For example,
+
+ chr(0x7FF_FFFF) =~ /\p{Any}/
+
+will not match, because the code point is not in Unicode. But
+
+ chr(0x7FF_FFFF) =~ /\P{Any}/
+
+will match.
+
=item %s: Command not found
(A) You've accidentally run your script through B<csh> instead of Perl.
(P) The regular expression engine got passed a regexp program without a
valid magic number.
-=item Corrupt malloc ptr 0x%lx at 0x%lx
+=item Corrupt malloc ptr 0x%x at 0x%x
(P) The malloc package that comes with Perl had an internal failure.
you have also specified an explicit size for the string. See
L<perlfunc/pack>.
-=item "\c%c" more clearly written simply as "%s"
+=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".
-(D deprecated) The C<\cI<X>> construct is intended to be a way to specify
+=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. This message may not remain as Deprecated beyond 5.13.
+characters.
=item Deep recursion on subroutine "%s"
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
+=item gmtime(%f) 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
+=item gmtime(%f) 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
binary number. Interpretation of the binary number stopped before the
offending digit.
-=item Illegal character %s (carriage return)
+=item Illegal character \%o (carriage return)
(F) Perl normally treats carriage returns in the program text as it
would any other whitespace, which means you should never see this error
=item Invalid %s attribute: %s
-The indicated attribute for a subroutine or variable was not recognized
+(F) The indicated attribute for a subroutine or variable was not recognized
by Perl or by a user-supplied handler. See L<attributes>.
=item Invalid %s attributes: %s
-The indicated attributes for a subroutine or variable were not
+(F) The indicated attributes for a subroutine or variable were not
recognized by Perl or by a user-supplied handler. See L<attributes>.
=item Invalid conversion in %s: "%s"
to check the return value of your socket() call? See
L<perlfunc/listen>.
-=item localtime(%.0f) too large
+=item localtime(%f) 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
+=item localtime(%f) 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
=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
+by declaring the subroutine with an lvalue attribute is not
+possible. To make the subroutine an lvalue subroutine add the
+lvalue attribute to the definition, or put the declaration before
the definition.
=item Lvalue subs returning %s not implemented yet
(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 (%d) exceeded
+=item Maximal count of pending signals (%u) exceeded
(F) Perl aborted due to a too high number of signals pending. This
usually indicates that your operating system tried to deliver signals
=item Offset outside string
-(F, W layer) You tried to do a read/write/send/recv/seek operation
+(F|W layer) You tried to do a read/write/send/recv/seek operation
with an offset pointing outside the buffer. This is difficult to
imagine. The sole exceptions to this are that zero padding will
take place when going past the end of the string when either
=item Opening dirhandle %s also as a file
-(W io deprecated) You used open() to associate a filehandle to
+(W io, deprecated) You used open() to associate a filehandle to
a symbol (glob or scalar) that already holds a dirhandle.
Although legal, this idiom might render your code confusing
and is deprecated.
=item Opening filehandle %s also as a directory
-(W io deprecated) You used opendir() to associate a dirhandle to
+(W io, deprecated) You used opendir() to associate a dirhandle to
a symbol (glob or scalar) that already holds a filehandle.
Although legal, this idiom might render your code confusing
and is deprecated.
of other handlers, there is no default handler for any operation, unless
C<fallback> overloading key is specified to be true. See L<overload>.
+=item Operation "%s" returns its argument for UTF-16 surrogate U+%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.
+
+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
+
+(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 Operator or semicolon missing before %s
(S ambiguous) You used a variable or subroutine call where the parser
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
(W unopened) You tried to read from a filehandle that was never opened.
-=item Reallocation too large: %lx
+=item Reallocation too large: %x
(F) You can't allocate more than 64K on an MS-DOS machine.
the regular expression about where the problem was discovered. See
L<perlre>.
-=item 500 Server error
+=item "500 Server error"
See Server error.
=item Server error
-This is the error message generally seen in a browser window when trying
+(A) This is the error message generally seen in a browser window when trying
to run a CGI program (including SSI) over the web. The actual error text
varies widely from server to server. The most frequently-seen variants
are "500 Server error", "Method (something) not permitted", "Document
=item The %s function is unimplemented
-The function indicated isn't implemented on this architecture, according
+(F) The function indicated isn't implemented on this architecture, according
to the probings of Configure.
=item The stat preceding %s wasn't an lstat
%NAME or C<%{EXPR}>. No implicit dereferencing is allowed--use the
{EXPR} forms as an explicit dereference. See L<perlref>.
+=item Type of argument to %s must be hashref or arrayref
+
+(F) You called C<keys>, C<values> or C<each> with an argument that was
+expected to be a reference to a hash or a reference to an array.
+
=item umask not implemented
(F) Your machine doesn't implement the umask function and you tried to
(F) The unexec() routine failed for some reason. See your local FSF
representative, who probably put it there in the first place.
-=item Unicode non-character %s is illegal for interchange
+=item Unicode non-character U+%X is illegal for open interchange
(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. 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
+them. If you know what you are doing you can turn
off this warning by C<no warnings 'utf8';>.
=item Unknown BYTEORDER
=item Unknown "re" subpragma '%s' (known ones are: %s)
-You tried to use an unknown subpragma of the "re" pragma.
+(W) You tried to use an unknown subpragma of the "re" pragma.
-=item Unknown switch condition (?(%.2s in regex; marked by <-- HERE in m/%s/
+=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
=item Unknown Unicode option letter '%c'
-You specified an unknown Unicode option. See L<perlrun> documentation
+
(F) You specified an unknown Unicode option. See L<perlrun> documentation
of the C<-C> switch for the list of known options.
=item Unknown Unicode option value %x
-You specified an unknown Unicode option. See L<perlrun> documentation
+
(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'
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
+=item Use of := for an empty attribute list is not allowed
+
+(F) The construction C<my $x := 42> used to parse as equivalent to
+C<my $x : = 42> (applying an empty attribute list to C<$x>).
+This construct was deprecated in 5.12.0, and has now been made a syntax
+error, so C<:=> can be reclaimed as a new operator in the future.
-(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.
+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
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=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
+scalar happens to hold a typeglob, which means its filehandle will
+be tied. If you mean to tie a handle, use an explicit * as in
+C<tie *$handle>.
+
+This is a long-standing bug that will be removed in Perl 5.16, as
+there is currently no way to tie the scalar itself when it holds
+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
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
either, because you can overload the numification and stringification
-operators and then you assumably know what you are doing.
+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.
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
+=item Unicode surrogate U+%X is illegal in UTF-8
-(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 really know what you are doing you can turn off
-this warning by C<no warnings 'utf8';>.
+=item UTF-16 surrogate U+%X
+
+(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 Value of %s can be "0"; test with defined()
(W closed) The filehandle you're writing to got itself closed sometime
before now. Check your control flow.
-=item %s "\x%s" does not map to Unicode
+=item %s "\x%X" does not map to Unicode
-When reading in different encodings Perl tries to map everything
+(F) When reading in different encodings Perl tries to map everything
into Unicode characters. The bytes you read in are not legal in
this encoding, for example
https://perl5.git.perl.org / perl5.git / blobdiff