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
the string, just write C<"-foo">. If you meant the function call,
write C<-foo()>.
+=item Ambiguous use of 's//le...' resolved as 's// le...'; Rewrite as 's//el' if you meant 'use locale rules and evaluate rhs as an expression'. In Perl 5.16, it will be resolved the other way
+
+(W deprecated, ambiguous) You wrote a pattern match with substitution
+immediately followed by "le". In Perl 5.14 and earlier, this is
+resolved as meaning to take the result of the substitution, and see if
+it is stringwise less-than-or-equal-to what follows in the expression.
+Having the "le" immediately following a pattern is deprecated behavior,
+so in Perl 5.16, this expression will be resolved as meaning to do the
+pattern match using the rules of the current locale, and evaluate the
+rhs as an expression when doing the substitution. In 5.14, if you want
+the latter interpretation, you can simply write "el" instead.
+
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
you meant to do. See L<perlfunc/grep> and L<perlfunc/map> for
alternatives.
-=item Args must match #! line
-
-(F) The setuid emulator requires that the arguments Perl was invoked
-with match the arguments specified on the #! line. Since some systems
-impose a one-argument limit on the #! line, try combining switches;
-for example, turn C<-w -U> into C<-wU>.
-
=item Arg too short for msgsnd
(F) msgsnd() requires a string at least as long as sizeof(long).
print q(The character '(' starts a side comment.);
-If you're getting this error from a here-document, you may have included
-unseen whitespace before or after your closing tag. A good programmer's
-editor will have a way to help you find these characters.
+If you're getting this error from a here-document, you may have
+included unseen whitespace before or after your closing tag or there
+may not be a linebreak after it. A good programmer's editor will have
+a way to help you find these characters (or lack of characters). See
+L<perlop> for the full details on here-documents.
=item Can't find Unicode property definition "%s"
=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.
+(W utf8, 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
(D syntax)
-You had a word that isn't a regex modifier immediately following a pattern
-without an intervening space. For example, the two constructs:
+You had a word that isn't a regex modifier immediately following a
+pattern without an intervening space. If you are trying to use the C</le>
+flags on a substitution, use C</el> instead. Otherwise, add white space
+between the pattern and following word to eliminate the warning. As an
+example of the latter, the two constructs:
$a =~ m/$foo/sand $bar
$a =~ m/$foo/s and $bar
supplied (or potentially supplied) by the user. The script must set
the path to a known value, using trustworthy data. See L<perlsec>.
+=item Insecure user-defined property %s
+
+(F) Perl detected tainted data when trying to compile a regular
+expression that contains a call to a user-defined character property
+function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
+See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
+
+
=item Integer overflow in format string for %s
(F) The indexes and widths specified in the format string of C<printf()>
=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
+(using L<lex_stuff_pvn|perlapi/lex_stuff_pvn> 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.
module) didn't define a C<DB::sub> routine to be called at the beginning
of each ordinary subroutine call.
-=item No B<-e> allowed in setuid scripts
-
-(F) A setuid script can't be specified by the user.
-
=item No error file after 2> or 2>> on command line
(F) An error peculiar to VMS. Perl handles its own command line
redirection, and found a '<' on the command line, but can't find the
name of the file from which to read data for stdin.
-=item No #! line
-
-(F) The setuid emulator requires that scripts have a well-formed #! line
-even on machines that don't support the #! construct.
-
=item No next::method '%s' found for %s
(F) C<next::method> found no further instances of this method name
a reference to something else instead. You can use the ref() function
to find out what kind of ref it really was. See L<perlref>.
-=item Not a perl script
+=item Not an unblessed ARRAY reference
-(F) The setuid emulator requires that scripts have a well-formed #! line
-even on machines that don't support the #! construct. The line must
-mention perl.
+(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
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(W) You performed an operation requiring Unicode semantics on a code
+(W utf8, non_unicode) 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.
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';>.
+C<no warnings 'non_unicode';>.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(W) You performed an operation requiring Unicode semantics on a Unicode
+(W utf8, surrogate) 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
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';>.
+C<no warnings 'surrogate';>.
=item Operator or semicolon missing before %s
likely the glob contains an object with a reference back to the glob and a
destructor that adds a new object to the glob.
-=item panic: hfreeentries failed to free hash
-
-(P) The internal routine used to clear a hash's entries tried repeatedly,
-but each time something added more entries to the hash. Most likely the hash
-contains an object with a reference back to the hash and a destructor that
-adds a new object to the hash.
-
=item panic: INTERPCASEMOD
(P) The lexer got into a bad state at a case modifier.
"Can't locate object method \"%s\" via package \"%s\"". It often means
that a method requires a package that has not been loaded.
+=item Perl folding rules are not up-to-date for 0x%x; please use the perlbug utility to report
+
+(W regex, deprecated) You used a regular expression with
+case-insensitive matching, and there is a bug in Perl in which the
+built-in regular expression folding rules are not accurate. This may
+lead to incorrect results. Please report this as a bug using the
+"perlbug" utility. (This message is marked deprecated, so that it by
+default will be turned-on.)
+
=item Perl_my_%s() not available
(F) Your platform has very uncommon byte-order and integer size,
believes it found an infinite loop in the C<@ISA> hierarchy. This is a
crude check that bails out after 100 levels of C<@ISA> depth.
+=item refcnt_dec: fd %d%s
+
+=item refcnt: fd %d%s
+
+=item refcnt_inc: fd %d%s
+
+(P) Perl's I/O implementation failed an internal consistency check. If
+you see this message, something is very wrong.
+
=item Reference found where even-sized list expected
(W misc) You gave a single reference where Perl was expecting a list
(P) The regular expression engine got confused by what the regular
expression compiler gave it.
+=item Regexp modifier "/%c" may appear a maximum of twice
+
+=item Regexp modifier "/%c" may not appear twice
+
+(F syntax, regexp) The regular expression pattern had too many occurrences
+of the specified modifier. Remove the extraneous ones.
+
+=item Regexp modifier "%c" may not appear after the "-"
+
+(F regexp) Turning off the given modifier has the side effect of turning
+on another one. Perl currently doesn't allow this. Reword the regular
+expression to use the modifier you want to turn on (and place it before
+the minus), instead of the one you want to turn off.
+
+=item Regexp modifiers "/%c" and "/%c" are mutually exclusive
+
+(F syntax, regexp) The regular expression pattern had more than one of these
+mutually exclusive modifiers. Retain only the modifier that is
+supposed to be there.
+
=item Regexp out of space
(P) A "can't happen" error, because safemalloc() should have caught it
<-- HERE shows in the regular expression about where the problem was
discovered. This happens when using the C<(?^...)> construct to tell
Perl to use the default regular expression modifiers, and you
-redundantly specify a default modifier; or having a modifier that can't
-be turned off (such as C<"p"> or C<"l">) after a minus; or specifying
-more than one of the C<"d">, C<"l">, or C<"u"> modifiers. For other
+redundantly specify a default modifier. For other
causes, see L<perlre>.
=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
-=item Setuid/gid script is writable by world
-
-(F) The setuid emulator won't run a script that is writable by the
-world, because the world might have written on it already.
-
-=item Setuid script not plain file
-
-(F) The setuid emulator won't run a script that isn't read from a file,
-but from a socket, a pipe or another device.
-
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
%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
+=item Type of argument to %s must be unblessed 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.
+(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
=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
+(W utf8, nonchar) 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';>.
+off this warning by C<no warnings 'nonchar';>.
+
+=item Unicode surrogate U+%X is illegal in UTF-8
+
+(W utf8, surrogate) 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 'surrogate';>.
=item Unknown BYTEORDER
=item Use of inherited AUTOLOAD for non-method %s() is deprecated
-(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
-are looked up as methods (using the C<@ISA> hierarchy) even when the
-subroutines to be autoloaded were called as plain functions (e.g.
-C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or C<<
-$obj->bar() >>).
+(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD>
+subroutines are looked up as methods (using the C<@ISA> hierarchy)
+even when the subroutines to be autoloaded were called as plain
+functions (e.g. C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or
+C<< $obj->bar() >>).
This bug will be rectified in future by using method lookup only for
methods' C<AUTOLOAD>s. However, there is a significant base of existing
generally because there's a better way to do it, and also because the
old way has bad side effects.
+=item Use of -l on filehandle %s
+
+(W io) A filehandle represents an opened file, and when you opened the file
+it already went past any symlink you are presumably trying to look for.
+The operation returned C<undef>. Use a filename instead.
+
=item Use of %s on a handle without * is deprecated
(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that
a typeglob, and no way to untie a scalar that has had a typeglob
assigned to it.
-=item Use of -l on filehandle %s
-
-(W io) A filehandle represents an opened file, and when you opened the file
-it already went past any symlink you are presumably trying to look for.
-The operation returned C<undef>. Use a filename instead.
-
-=item Use of "package" with no arguments is deprecated
-
-(D deprecated) You used the C<package> keyword without specifying a package
-name. So no namespace is current at all. Using this can cause many
-otherwise reasonable constructs to fail in baffling ways. C<use strict;>
-instead.
-
=item Use of ?PATTERN? without explicit operator is deprecated
(D deprecated) You have written something like C<?\w?>, for a regular
If you really do mean it, explicitly numify your reference, like so:
C<$array[0+$ref]>. This warning is not given for overloaded objects,
-either, because you can overload the numification and stringification
+however, because you can overload the numification and stringification
operators and then you presumably know what you are doing.
=item Use of reserved word "%s" is deprecated
allow this syntax, but shouldn't have. It is now deprecated, and will be
removed in a future version.
-=item Using !~ with %s doesn't make sense
-
-(F) Using the C<!~> operator with C<s///r>, C<tr///r> or C<y///r> is
-currently reserved for future use, as the exact behaviour has not
-been decided. (Simply returning the boolean opposite of the
-modified string is usually not particularly useful.)
-
=item Using just the first character returned by \N{} in character class
(W) A charnames handler may return a sequence of more than one character.
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{}
+=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.)
-(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 User-defined case-mapping '%s' is deprecated
-=item Unicode surrogate U+%X is illegal in UTF-8
+(W deprecated) You defined a function, such as C<ToLower> that overrides
+the standard case mapping, such as C<lc()> gives. This feature is being
+deprecated due to its many issues, as documented in
+L<perlunicode/User-Defined Case Mappings (for serious hackers only)>.
+It is planned to remove this feature in Perl 5.16. A CPAN module
+providing improved functionality is being prepared.
=item UTF-16 surrogate U+%X
-(W utf8) You had a UTF-16 surrogate in a context where they are
+(W utf8, surrogate) 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';>.
+off this warning by C<no warnings 'surrogate';>.
=item Value of %s can be "0"; test with defined()
=item "%s" variable %s masks earlier declaration in same %s
-(W misc) A "my", "our" or "state" variable has been redeclared in the current
-scope or statement, effectively eliminating all access to the previous
-instance. This is almost always a typographical error. Note that the
-earlier variable will still exist until the end of the scope or until
-all closure referents to it are destroyed.
+(W misc) A "my", "our" or "state" variable has been redeclared in the
+current scope or statement, effectively eliminating all access to the
+previous instance. This is almost always a typographical error. Note
+that the earlier variable will still exist until the end of the scope
+or until all closure referents to it are destroyed.
=item Variable syntax
(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
C<TEMPLATE> always matches the same amount of packed bytes that can be
-determined from the template alone. This is not possible if it contains an
+determined from the template alone. This is not possible if it contains any
of the codes @, /, U, u, w or a *-length. Redesign the template.
=item write() on closed filehandle %s
https://perl5.git.perl.org / perl5.git / blobdiff