(F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only
after certain types. See L<perlfunc/pack>.
+=item alpha->numify() is lossy
+
+(W numeric) An alpha version can not be numified without losing
+information.
+
=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
(W ambiguous) A subroutine you have declared has the same name as a Perl
C</^[a-zA-Z]*[0-9]*\z/>. See L<perlop/Auto-increment and
Auto-decrement> for details.
+=item Array passed to stat will be coerced to a scalar%s
+
+(W syntax) You called stat() on an array, but the array will be
+coerced to a scalar - the number of elements in the array.
+
=item assertion botched: %s
(X) The malloc package that comes with Perl had an internal failure.
must either both be scalars or both be lists. Otherwise Perl won't
know which context to supply to the right side.
+=item Assuming NOT a POSIX class since %s in regex; marked by S<<-- HERE> in m/%s/
+
+(W regexp) You had something like these:
+
+ [[:alnum]]
+ [[:digit:xyz]
+
+They look like they might have been meant to be the POSIX classes
+C<[:alnum:]> or C<[:digit:]>. If so, they should be written:
+
+ [[:alnum:]]
+ [[:digit:]xyz]
+
+Since these aren't legal POSIX class specifications, but are legal
+bracketed character classes, Perl treats them as the latter. In the
+first example, it matches the characters C<":">, C<"[">, C<"a">, C<"l">,
+C<"m">, C<"n">, and C<"u">.
+
+If these weren't meant to be POSIX classes, this warning message is
+spurious, and can be suppressed by reordering things, such as
+
+ [[al:num]]
+
+or
+
+ [[:munla]]
+
=item <> at require-statement should be quotes
(F) You wrote C<< require <file> >> when you should have written
The C<strict> pragma is useful in avoiding such errors.
+=item Bareword in require contains "%s"
+
+=item Bareword in require maps to empty filename
+
+=item Bareword in require maps to disallowed filename "%s"
+
+
+(F) The bareword form of require has been invoked with a filename which could
+not have been generated by a valid bareword permitted by the parser. You
+shouldn't be able to get this error from Perl code, but XS code may throw it
+if it passes an invalid module name to C<Perl_load_module>.
+
+=item Bareword in require must not start with a double-colon: "%s"
+
+(F) In C<require Bare::Word>, the bareword is not allowed to start with a
+double-colon. Write C<require ::Foo::Bar> as C<require Foo::Bar> instead.
+
=item Bareword "%s" not allowed while "strict subs" in use
(F) With "strict subs" in use, a bareword is only allowed as a
do so. Such arrays are not even supposed to be accessible to
Perl code, but are only used internally.
+=item Cannot yet reorder sv_catpvfn() arguments from va_list
+
+(F) Some XS code tried to use C<sv_catpvfn()> or a related function with a
+format string that specifies explicit indexes for some of the elements, and
+using a C-style variable-argument list (a C<va_list>). This is not currently
+supported. XS authors wanting to do this must instead construct a C array of
+C<SV*> scalars containing the arguments.
+
=item Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer. The BER compressed
(F) A string of a form C<CORE::word> was given to prototype(), but there
is no builtin with the name C<word>.
-=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?
-See L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available official properties.
-
=item Can't find label %s
(F) You said to goto a label that isn't mentioned anywhere that it'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}> matches all uppercase
-letters). If you did mean to use a Unicode property, see
+=item Can't find Unicode property definition "%s" in regex; marked by <-- HERE in m/%s/
+
+(F) The named property which you specified via C<\p> or C<\P> is not one
+known to Perl. Perhaps you misspelled the name? 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, or
+for a complete list of available official
+properties. If it is a
+L<user-defined property|perlunicode/User-Defined Character Properties>
+it must have been defined by the time the regular expression is
+matched.
+
+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
(P) The internal routine that does assignment to a substr() was handed
a NULL.
-=item Can't modify non-lvalue subroutine call
+=item Can't modify non-lvalue subroutine call of &%s
(F) Subroutines meant to be used in lvalue context should be declared as
such. See L<perlsub/"Lvalue subroutines">.
or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
searched.
+=item Can't redeclare "%s" in "%s"
+
+(F) A "my", "our" or "state" declaration was found within another declaration,
+such as C<my ($x, my($y), $z)> or C<our (my $x)>.
+
=item Can't "redo" outside a loop block
(F) A "redo" statement was executed to restart the current block, but
discouraged, and will generate the warning (when enabled)
L</""\c%c" is more clearly written simply as "%s"">.
+=item Character following \%c must be '{' or a single-character Unicode property name in regex; marked by <-- HERE in m/%s/
+
+(F) (In the above the C<%c> is replaced by either C<p> or C<P>.) You
+specified something that isn't a legal Unicode property name. Most
+Unicode properties are specified by C<\p{...}>. But if the name is a
+single character one, the braces may be omitted.
+
=item Character in 'C' format wrapped in pack
(W pack) You said
could be defined by a translator installed into C<$^H{charnames}>.
See L<charnames/CUSTOM ALIASES>.
-=item \C is deprecated in regex; marked by S<<-- HERE> in m/%s/
+=item chdir() on unopened filehandle %s
-(D deprecated, regexp) The \C character class is deprecated, and will
-become a compile-time error in a future release of perl (tentatively
-v5.24). This construct allows you to match a single byte of what makes
-up a multi-byte single UTF8 character, and breaks encapsulation. It is
-currently also very buggy. If you really need to process the individual
-bytes, you probably want to convert your string to one where each
-underlying byte is stored as a character, with utf8::encode().
+(W unopened) You tried chdir() on a filehandle that was never opened.
=item "\c%c" is more clearly written simply as "%s"
handler is the prototype that is cloned when a new closure is created.
This subroutine cannot be called.
+=item \C no longer supported in regex; marked by S<<-- HERE> in m/%s/
+
+(F) The \C character class used to allow a match of single byte
+within a multi-byte utf-8 character, but was removed in v5.24 as
+it broke encapsulation and its implementation was extremely buggy.
+If you really need to process the individual bytes, you probably
+want to convert your string to one where each underlying byte is
+stored as a character, with utf8::encode().
+
=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, and not portable
+
+(S non_unicode) You had a code point that has never been in any
+standard, so it is likely that languages other than Perl will NOT
+understand it. At one time, it was legal in some standards to have code
+points up to 0x7FFF_FFFF, but not higher, and this code point is higher.
+
+Acceptance of these code points is a Perl extension, and you should
+expect that nothing other than Perl can handle them; Perl itself on
+EBCDIC platforms before v5.24 does not handle them.
+
+Code points above 0xFFFF_FFFF require larger than a 32 bit word.
+
+Perl also makes no guarantees that the representation of these code
+points won't change at some point in the future, say when machines
+become available that have larger than a 64-bit word. At that time,
+files written by an older Perl would require conversion before being
+readable by a newer Perl.
+
=item Code point 0x%X is not Unicode, may not be portable
(S non_unicode) 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.
+Perl allows strings to contain a superset of Unicode code points, but
+these may not be accepted by other languages/systems. Further, even if
+these languages/systems accept these large code points, they may have
+chosen a different representation for them than the UTF-8-like one that
+Perl has, which would mean files are not exchangeable between them and
+Perl.
+
+On EBCDIC platforms, code points above 0x3FFF_FFFF have a different
+representation in Perl v5.24 than before, so any file containing these
+that was written before that version will require conversion before
+being readable by a later Perl.
=item %s: Command not found
(W unpack) You have applied the same modifier more than once after a
type in a pack template. See L<perlfunc/pack>.
-=item each on reference is experimental
-
-(S experimental::autoderef) C<each> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item elseif should be elsif
(S syntax) There is no keyword "elseif" in Perl because Larry thinks
named "elseif" for the class returned by the following block. This is
unlikely to be what you want.
+=item Empty \%c in regex; marked by S<<-- HERE> in m/%s/
+
=item Empty \%c{} in regex; marked by S<<-- HERE> in m/%s/
(F) C<\p> and C<\P> are used to introduce a named Unicode property, as
use feature "refaliasing";
\$x = \$y;
+=item Experimental %s on scalar is now forbidden
+
+(F) An experimental feature added in Perl 5.14 allowed C<each>, C<keys>,
+C<push>, C<pop>, C<shift>, C<splice>, C<unshift>, and C<values> to be called with a
+scalar argument. This experiment is considered unsuccessful, and
+has been removed. The C<postderef> feature may meet your needs better.
+
=item Experimental subroutine signatures not enabled
(F) To use subroutine signatures, you must first enable them:
CHECK, INIT, or END subroutine. Processing of the remainder of the
queue of such routines has been prematurely ended.
+=item Failed to close in-place edit file %s: %s
+
+(F) Closing an output file from in-place editing, as with the C<-i>
+command-line switch, failed.
+
=item False [] range "%s" in regex; marked by S<<-- HERE> in m/%s/
(W regexp)(F) A character class range must start and end at a literal
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
-=item Having more than one /%c regexp modifier is deprecated
-
-(D deprecated, regexp) You used the indicated regular expression pattern
-modifier at least twice in a string of modifiers. It is deprecated to
-do this with this particular modifier, to allow future extensions to the
-Perl language.
-
=item Hexadecimal float: exponent overflow
(W overflow) The hexadecimal floating point has a larger exponent
(W overflow) The hexadecimal floating point has a smaller exponent
than the floating point supports.
-=item Hexadecimal float: internal error
+=item Hexadecimal float: internal error (%s)
(F) Something went horribly bad in hexadecimal float handling.
(X) The PERL5OPT environment variable may only be used to set the
following switches: B<-[CDIMUdmtw]>.
+=item Illegal user-defined property name
+
+(F) You specified a Unicode-like property name in a regular expression
+pattern (using C<\p{}> or C<\P{}>) that Perl knows isn't an official
+Unicode property, and was likely meant to be a user-defined property
+name, but it can't be one of those, as they must begin with either C<In>
+or C<Is>. Check the spelling. See also
+L</Can't find Unicode property definition "%s">.
+
=item Ill-formed CRTL environ value "%s"
(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's
C3-consistent, and you have enabled the C3 MRO for this class. See the C3
documentation in L<mro> for more information.
-=item In EBCDIC the v-string components cannot exceed 2147483647
-
-(F) An error peculiar to EBCDIC. Internally, v-strings are stored as
-Unicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC
-encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
-
=item Infinite recursion in regex
(F) You used a pattern that references itself without consuming any input
not valid character numbers, so it returns the Unicode replacement
character (U+FFFD).
+=item Invalid number '%s' for -C option.
+
+(F) You supplied a number to the -C option that either has extra leading
+zeroes or overflows perl's unsigned integer representation.
+
=item invalid option -D%c, use -D'' to see choices
(S debugging) Perl was called with invalid debugger flags. Call perl
Perl. The current valid ones are given in
L<perlrebackslash/\b{}, \b, \B{}, \B>.
+=item %s() is deprecated on :utf8 handles
+
+(W deprecated) The sysread(), recv(), syswrite() and send() operators are
+deprecated on handles that have the C<:utf8> layer, either explicitly, or
+implicitly, eg., with the C<:encoding(UTF-16LE)> layer.
+
+Both sysread() and recv() currently use only the C<:utf8> flag for the stream,
+ignoring the actual layers. Since sysread() and recv() do no UTF-8
+validation they can end up creating invalidly encoded scalars.
+
+Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise ignoring
+any layers. If the flag is set, both write the value UTF-8 encoded, even if
+the layer is some different encoding, such as the example above.
+
+Ideally, all of these operators would completely ignore the C<:utf8> state,
+working only with bytes, but this would result in silently breaking existing
+code. To avoid this a future version of perl will throw an exception when
+any of sysread(), recv(), syswrite() or send() are called on handle with the
+C<:utf8> layer.
+
=item "%s" is more clearly written simply as "%s" in regex; marked by S<<-- HERE> in m/%s/
(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
(P) The regular expression parser is confused.
-=item keys on reference is experimental
-
-(S experimental::autoderef) C<keys> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Label not found for "last %s"
(F) You named a loop to break out of, but you're not currently in a loop
=item Locale '%s' may not work well.%s
(W locale) You are using the named locale, which is a non-UTF-8 one, and
-which Perl has determined is not fully compatible with Perl. The second
-C<%s> gives a reason.
+which perl has determined is not fully compatible with what it can
+handle. The second C<%s> gives a reason.
By far the most common reason is that the locale has characters in it
that are represented by more than one byte. The only such locales that
follow some unpack specification producing a numeric value.
See L<perlfunc/pack>.
+=item %s must not be a named sequence in transliteration operator
+
+(F) Transliteration (C<tr///> and C<y///>) transliterates individual
+characters. But a named sequence by definition is more than an
+individual charater, and hence doing this operation on it doesn't make
+sense.
+
=item "my sub" not yet implemented
(F) Lexically scoped subroutines are not yet implemented. Don't try
will be another way to do what you want that is, if not secure, at least
securable. See L<perlsec>.
-=item NO-BREAK SPACE in a charnames alias definition is deprecated
-
-(D deprecated) You defined a character name which contained a no-break
-space character. Change it to a regular space. Usually these names are
-defined in the C<:alias> import argument to C<use charnames>, but they
-could be defined by a translator installed into C<$^H{charnames}>. See
-L<charnames/CUSTOM ALIASES>.
-
=item No code specified for -%c
(F) Perl's B<-e> and B<-E> command-line options require an argument. If
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 an unblessed ARRAY reference
-
-(F) You passed a reference to a blessed array to C<push>, C<shift> or
-another array function. These only accept unblessed array references
-or arrays beginning explicitly with C<@>.
-
=item Not a SCALAR reference
(F) Perl was trying to evaluate a reference to a scalar value, but found
(W unopened) You tried to invoke a file test operator on a filehandle
that isn't open. Check your control flow. See also L<perlfunc/-X>.
+=item Only one /x regex modifier is allowed
+
+=item Only one /x regex modifier is allowed in regex; marked by <-- HERE in m/%s/
+
+(F) You used the C</x> regular expression pattern modifier at least
+twice in a string of modifiers. It is illegal to do this with, to allow
+future extensions to the Perl language.
+
=item oops: oopsAV
(S internal) An internal warning that the grammar is screwed up.
(P) Failed an internal consistency check while trying to reset a weak
reference.
-=item panic: die %s
-
-(P) We popped the context stack to an eval context, and then discovered
-it wasn't an eval context.
-
=item panic: do_subst
(P) The internal pp_subst() routine was called with invalid operational
(F) The unpack format P must have an explicit size, not "*".
-=item pop on reference is experimental
-
-(S experimental::autoderef) C<pop> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item POSIX class [:%s:] unknown in regex; marked by S<<-- HERE> in m/%s/
(F) The class in the character class [: :] syntax is unknown. The S<<-- HERE>
(F) Your system has POSIX getpgrp(), which takes no argument, unlike
the BSD version, which takes a pid.
-=item POSIX syntax [%c %c] belongs inside character classes in regex; marked by
+=item POSIX syntax [%c %c] belongs inside character classes%s in regex; marked by
S<<-- HERE> in m/%s/
-(W regexp) The character class constructs [: :], [= =], and [. .] go
-I<inside> character classes, the [] are part of the construct, for example:
-/[012[:alpha:]345]/. Note that [= =] and [. .] are not currently
+(W regexp) Perl thinks that you intended to write a POSIX character
+class, but didn't use enough brackets. These POSIX class constructs [:
+:], [= =], and [. .] go I<inside> character classes, the [] are part of
+the construct, for example: C<qr/[012[:alpha:]345]/>. What the regular
+expression pattern compiled to is probably not what you were intending.
+For example, C<qr/[:alpha:]/> compiles to a regular bracketed character
+class consisting of the four characters C<":">, C<"a">, C<"l">,
+C<"h">, and C<"p">. To specify the POSIX class, it should have been
+written C<qr/[[:alpha:]]/>.
+
+Note that [= =] and [. .] are not currently
implemented; they are simply placeholders for future extensions and
will cause fatal errors. The S<<-- HERE> shows whereabouts in the regular
expression the problem was discovered. See L<perlre>.
+If the specification of the class was not completely valid, the message
+indicates that.
+
=item POSIX syntax [. .] is reserved for future extensions in regex; marked by
S<<-- HERE> in m/%s/
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
-=item Postfix dereference is experimental
-
-(S experimental::postderef) This warning is emitted if you use
-the experimental postfix dereference syntax. Simply suppress the
-warning if you want to use the feature, but know that in doing
-so you are taking the risk of using an experimental feature which
-may change or be removed in a future Perl version:
-
- no warnings "experimental::postderef";
- use feature "postderef", "postderef_qq";
- $ref->$*;
- $aref->@*;
- $aref->@[@indices];
- ... etc ...
-
=item Precedence problem: open %s should be open(%s)
(S precedence) The old irregular construct
L<perlipc/"Signals">. See also "Process terminated by SIGTERM/SIGINT"
in L<perlos2>.
-=item Property '%s' is unknown in regex; marked by S<<-- HERE> in m/%s/
-
-(F) The named property which you specified via C<\p> or C<\P> is not one
-known to Perl. Perhaps you misspelled the name? See
-L<perluniprops/Properties accessible through \p{} and \P{}>
-for a complete list of available official
-properties. If it is a L<user-defined property|perlunicode/User-Defined Character Properties>
-it must have been defined by the time the regular expression is
-compiled.
-
=item Prototype after '%c' for %s : %s
(W illegalproto) A character follows % or @ in a prototype. This is
parentheses is useless, since it will be replaced by the prototype
from the attribute before it's ever used.
-=item push on reference is experimental
-
-(S experimental::autoderef) C<push> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Quantifier follows nothing in regex; marked by S<<-- HERE> in m/%s/
(F) You started a regular expression with a quantifier. Backslash it if
S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
+=item Sequence (?... not terminated in regex; marked by S<<-- HERE> in
+m/%s/
+
+(F) There was no matching closing parenthesis for the '('. The
+S<<-- HERE> shows whereabouts in the regular expression the problem was
+discovered.
+
=item Sequence \%s... not terminated in regex; marked by S<<-- HERE> in
m/%s/
(F) The end of the perl code contained within the {...} must be
followed immediately by a ')'.
+=item Sequence (?PE<gt>... not terminated in regex; marked by S<<-- HERE> in m/%s/
+
+(F) A named reference of the form C<(?PE<gt>...)> was missing the final
+closing parenthesis after the name. The S<<-- HERE> shows whereabouts
+in the regular expression the problem was discovered.
+
+=item Sequence (?PE<lt>... not terminated in regex; marked by S<<-- HERE> in m/%s/
+
+(F) A named group of the form C<(?PE<lt>...E<gt>')> was missing the final
+closing angle bracket. The S<<-- HERE> shows whereabouts in the
+regular expression the problem was discovered.
+
=item Sequence ?P=... not terminated in regex; marked by S<<-- HERE> in
m/%s/
As of Perl 5.20.0 this is a fatal error, to allow future versions of Perl
to use non-integer refs for more interesting purposes.
-=item shift on reference is experimental
-
-(S experimental::autoderef) C<shift> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
(F) An ancient error message that almost nobody ever runs into anymore.
But before sort was a keyword, people sometimes used it as a filehandle.
-=item Sort subroutine didn't return single value
-
-(F) A sort comparison subroutine written in XS must return exactly one
-item. See L<perlfunc/sort>.
-
=item Source filters apply only to byte streams
(F) You tried to activate a source filter (usually by loading a
try explicitly pre-extending the array by assigning $#array = $offset.
See L<perlfunc/splice>.
-=item splice on reference is experimental
-
-(S experimental::autoderef) C<splice> with a scalar argument
-is experimental and may change or be removed in a future
-Perl version. If you want to take the risk of using this
-feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Split loop
(P) The split was looping infinitely. (Obviously, a split shouldn't
%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 unblessed hashref or arrayref
-
-(F) You called C<keys>, C<values> or C<each> with a scalar argument that
-was not a reference to an unblessed hash or array.
-
=item umask not implemented
(F) Your machine doesn't implement the umask function and you tried to
(A) You've accidentally run your script through B<csh> instead of Perl.
Check the #! line, or manually feed your script into Perl yourself.
-=item Unescaped left brace in regex is deprecated, passed through in regex;
+=item Unescaped left brace in regex is illegal in regex;
marked by S<<-- HERE> in m/%s/
-(D deprecated, regexp) You used a literal C<"{"> character in a regular
-expression pattern. You should change to use C<"\{"> instead, because a
-future version of Perl (tentatively v5.26) will consider this to be a
-syntax error. If the pattern delimiters are also braces, any matching
+(F) You used a literal C<"{"> character in a regular
+expression pattern. You should change to use C<"\{"> or C<[{]> instead.
+If the pattern delimiters are also braces, any matching
right brace (C<"}">) should also be escaped to avoid confusing the parser,
for example,
qr{abc\{def\}ghi}
+This restriction is not enforced if the C<"{"> is the first character in
+the pattern; nor is a warning generated for this case, as there are no
+current plans to forbid it.
+
=item unexec of %s into %s failed!
(F) The unexec() routine failed for some reason. See your local FSF
no indication as to how the digits are to be combined
with the characters in the Lao and Thai scripts.
-=item Unicode non-character U+%X is illegal for open interchange
+=item Unicode non-character U+%X is not recommended for open interchange
(S nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
defined by the Unicode standard to be non-characters. Those
came from. If you really really know what you are doing you can turn
off this warning by C<no warnings 'surrogate';>.
+=item Unknown charname '' is deprecated
+
+(D deprecated) You had a C<\N{}> with nothing between the braces. This
+usage is deprecated, and will be made a syntax error in a future Perl
+version.
+
=item Unknown charname '%s'
(F) The name you used inside C<\N{}> is unknown to Perl. Check the
module (e.g. C<use warnings 'File::Find'>), you must have loaded this
module first.
-=item Unmatched '[' in POSIX class in regex; marked by S<<-- HERE> in m/%s/
-
-(F) You had something like this:
-
- (?[ [:digit: ])
-
-That should be written:
-
- (?[ [:digit:] ])
-
-=item Unmatched '%c' in POSIX class in regex; marked by S<<-- HERE> in
-m/%s/
-
-(F) You had something like this:
-
- (?[ [:alnum] ])
-
-There should be a second C<":">, like this:
-
- (?[ [:alnum:] ])
-
=item Unmatched [ in regex; marked by S<<-- HERE> in m/%s/
(F) The brackets around a character class must match. If you wish to
think you didn't do that, check the #! line to see if it's supplying the
bad switch on your behalf.)
-=item unshift on reference is experimental
-
-(S experimental::autoderef) C<unshift> with a scalar argument
-is experimental and may change or be removed in a future
-Perl version. If you want to take the risk of using this
-feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Unsuccessful %s on filename containing newline
(W newline) A file operation was attempted on a filename, and that
=item Useless use of attribute "const"
-(W misc) The "const" attribute has no effect except
+(W misc) The C<const> attribute has no effect except
on anonymous closure prototypes. You applied it to
a subroutine via L<attributes.pm|attributes>. This is only useful
inside an attribute handler for an anonymous subroutine.
form if you wish to use an empty line as the terminator of the
here-document.
-=item Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale
-
-(W locale) You are matching a regular expression using locale rules,
-and a Unicode boundary is being matched, but the locale is not a Unicode
-one. This doesn't make sense. Perl will continue, assuming a Unicode
-(UTF-8) locale, but the results could well be wrong except if the locale
-happens to be ISO-8859-1 (Latin1) where this message is spurious and can
-be ignored.
-
-=item Use of chdir('') or chdir(undef) as chdir() deprecated
-
-(D deprecated) chdir() with no arguments is documented to change to
-$ENV{HOME} or $ENV{LOGDIR}. chdir(undef) and chdir('') share this
-behavior, but that has been deprecated. In future versions they
-will simply fail.
-
-Be careful to check that what you pass to chdir() is defined and not
-blank, else you might find yourself in your home directory.
-
=item Use of /c modifier is meaningless in s///
(W regexp) You used the /c modifier in a substitution. The /c
use the /g modifier. Currently, /c is meaningful only when /g is
used. (This may change in the future.)
+=item Use of code point 0x%s is deprecated; the permissible max is 0x%s
+
+(D deprecated) You used a code point that will not be allowed in a
+future perl version, because it is too large. Unicode only allows code
+points up to 0x10FFFF, but Perl allows much larger ones. However, the
+largest possible ones break the perl interpreter in some constructs,
+including causing it to hang in a few cases. The known problem areas
+are in C<tr///>, regular expression pattern matching using quantifiers,
+and as the upper limits in loops.
+
+If your code is to run on various platforms, keep in mind that the upper
+limit depends on the platform. It is much larger on 64-bit word sizes
+than 32-bit ones.
+
=item Use of comma-less variable list is deprecated
(D deprecated) The values you give to a format should be
If you need an empty attribute list, for example in a code generator, add
a space before the C<=>.
+=item Use of %s for non-UTF-8 locale is wrong. Assuming a UTF-8 locale
+
+(W locale) You are matching a regular expression using locale rules,
+and the specified construct was encountered. This construct is only
+valid for UTF-8 locales, which the current locale isn't. This doesn't
+make sense. Perl will continue, assuming a Unicode (UTF-8) locale, but
+the results are likely to be wrong.
+
=item Use of freed value in iteration
(F) Perhaps you modified the iterated array within the loop?
generally because there's a better way to do it, and also because the
old way has bad side effects.
-=item Use of literal control characters in variable names is deprecated
-
-=item Use of literal non-graphic characters in variable names is deprecated
-
-(D deprecated) Using literal non-graphic (including control)
-characters in the source to refer to the ^FOO variables, like C<$^X> and
-C<${^GLOBAL_PHASE}> is now deprecated. (We use C<^X> and C<^G> here for
-legibility. They actually represent the non-printable control
-characters, code points 0x18 and 0x07, respectively; C<^A> would mean
-the control character whose code point is 0x01.) This only affects
-code like C<$\cT>, where C<\cT> is a control in the source code; C<${"\cT"}> and
-C<$^T> remain valid. Things that are non-controls and also not graphic
-are NO-BREAK SPACE and SOFT HYPHEN, which were previously only allowed
-for historical reasons.
-
=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 my $_ is experimental
-
-(S experimental::lexical_topic) Lexical $_ is an experimental feature and
-its behavior may change or even be removed in any future release of perl.
-See the explanation under L<perlvar/$_>.
-
=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
its behavior may change or even be removed in any future release of perl.
See the explanation under L<perlvar/$_>.
+=item Use of strings with code points over 0xFF as arguments to %s
+operator is deprecated
+
+(D deprecated) You tried to use one of the string bitwise operators
+(C<&> or C<|> or C<^> or C<~>) on a string containing a code point over
+0xFF. The string bitwise operators treat their operands as strings of
+bytes, and values beyond 0xFF are nonsensical in this context.
+
=item Use of tainted arguments in %s is deprecated
(W taint, deprecated) You have supplied C<system()> or C<exec()> with multiple
longer than 1024 characters. The return value has been truncated to
1024 characters.
-=item values on reference is experimental
-
-(S experimental::autoderef) C<values> with a scalar argument
-is experimental and may change or be removed in a future
-Perl version. If you want to take the risk of using this
-feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Variable "%s" is not available
(W closure) During compilation, an inner named subroutine or eval is
=item Warning: unable to close filehandle %s properly: %s
-(S io) An error occurred when Perl implicitly closed a filehandle. This
-usually indicates your file system ran out of disk space.
+(S io) There were errors during the implicit close() done on a filehandle
+when its reference count reached zero while it was still open, e.g.:
+
+ {
+ open my $fh, '>', $file or die "open: '$file': $!\n";
+ print $fh $data or die "print: $!";
+ } # implicit close here
+
+Because various errors may only be detected by close() (e.g. buffering could
+allow the C<print> in this example to return true even when the disk is full),
+it is dangerous to ignore its result. So when it happens implicitly, perl will
+signal errors by warning.
+
+B<Prior to version 5.22.0, perl ignored such errors>, so the common idiom shown
+above was liable to cause B<silent data loss>.
=item Warning: Use of "%s" without parentheses is ambiguous
(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8
one), a multi-byte character was encountered. Perl considers this
-character to be the specified Unicode code point. Combining non-UTF8
+character to be the specified Unicode code point. Combining non-UTF-8
locales and Unicode is dangerous. Almost certainly some characters
will have two different representations. For example, in the ISO 8859-7
(Greek) locale, the code point 0xC3 represents a Capital Gamma. But so
it contains any of the codes @, /, U, u, w or a *-length. Redesign
the template.
+=item %s() with negative argument
+
+(S misc) Certain operations make no sense with negative arguments.
+Warning is given and the operation is not done.
+
=item write() on closed filehandle %s
(W closed) The filehandle you're writing to got itself closed sometime
(F) Named Unicode character escapes (C<\N{...}>) may return a zero-length
sequence. Such an escape was used in an extended character class, i.e.
-C<(?[...])>, which is not permitted. Check that the correct escape has
-been used, and the correct charnames handler is in scope. The S<<-- HERE>
-shows whereabouts in the regular expression the problem was discovered.
+C<(?[...])>, or under C<use re 'strict'>, which is not permitted. Check
+that the correct escape has been used, and the correct charnames handler
+is in scope. The S<<-- HERE> shows whereabouts in the regular
+expression the problem was discovered.
=back
https://perl5.git.perl.org / perl5.git / blobdiff