function correctly, you may put an ampersand before the name to avoid
the warning. See L<perlsub>.
+=item Calling POSIX::%s() is deprecated
+
+(D deprecated) You called a function whose use is deprecated. See
+the function's name in L<POSIX> for details.
+
=item Cannot compress integer in pack
(F) An argument to pack("w",...) was too large to compress. The BER
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
+=item Character following "\c" must be printable ASCII
-(F)(D 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 v5.20. In
+(F)(D deprecated, syntax) In C<\cI<X>>, I<X> must be a printable
+(non-control) ASCII character. This is fatal starting in v5.20 for
+non-ASCII characters, and it is planned to make this fatal in all
+instances in Perl v5.22. 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,
-and using non-printable ones will be deprecated starting in v5.18.
+Note that ASCII characters that don't map to control characters are
+discouraged here as well, and will generate the warning (when enabled)
+L</""\c%c" is more clearly written simply as "%s"">.
=item Character in 'C' format wrapped in pack
unpack("s", "\x{f3}b")
-=item "\c{" is deprecated and is more clearly written as ";"
-
-(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
-to specify non-printable characters. You used it with a "{" which
-evaluates to ";", which is printable. It is planned to remove the
-ability to specify a semi-colon this way in Perl 5.20. Just use a
-semi-colon or a backslash-semi-colon without the "\c".
-
=item "\c%c" is more clearly written simply as "%s"
(W syntax) The C<\cI<X>> construct is intended to be a way to specify
=item %s: Command not found
(A) You've accidentally run your script through B<csh> or another shell
-shell instead of Perl. Check the #! line, or manually feed your script
+instead of Perl. Check the #! line, or manually feed your script
into Perl yourself. The #! line at the top of your file could look like
#!/usr/bin/perl -w
(F) The parser found inconsistencies while attempting to define an
overloaded constant. Perhaps you forgot to load the corresponding
-L<overload> pragma?.
+L<overload> pragma?
=item Constant is not %s reference
{ my $x; sub f { return $x++ } }
-Beginning with perl 5.9.4, you can also use C<state> variables to have
+Beginning with perl 5.10.0, you can also use C<state> variables to have
lexicals that are initialized only once (see L<feature>):
sub f { state $x; return $x++ }
(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
have some other C<(?...)> construct inside your character class. See
L<perlrecharclass/Extended Bracketed Character Classes>.
+=item Experimental subroutine signatures not enabled
+
+(F) To use subroutine signatures, you must first enable them:
+
+ no warnings "experimental::signatures";
+ use feature "signatures";
+ sub foo ($left, $right) { ... }
+
=item Experimental "%s" subs not enabled
(F) To use lexical subs, you must first enable them:
(W illegalproto) An illegal character was found in a prototype declaration.
Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
+Perhaps you were trying to write a subroutine signature but didn't enable
+that feature first (C<use feature 'signatures'>), so your signature was
+instead interpreted as a bad prototype.
=item Illegal declaration of anonymous subroutine
=item Invalid escape in the specified encoding in regex; marked by
S<<-- HERE> in m/%s/
-(W regexp) The numeric escape (for example C<\xHH>) of value < 256
+(W regexp)(F) The numeric escape (for example C<\xHH>) of value < 256
didn't correspond to a single character through the conversion
from the encoding specified by the encoding pragma.
-The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead.
+The escape was replaced with REPLACEMENT CHARACTER (U+FFFD)
+instead, except within S<C<(?[ ])>>, where it is a fatal error.
The S<<-- HERE> shows whereabouts in the regular expression the
escape was discovered.
=item $* is no longer supported
(D deprecated, syntax) The special variable C<$*>, deprecated in older
-perls, has been removed as of 5.9.0 and is no longer supported. In
+perls, has been removed as of 5.10.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
(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
+perls, has been removed as of 5.10.0 and is no longer supported. You
should use the printf/sprintf functions instead.
=item '%s' is not a code reference
(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
syntax of function prototypes is given a brief compile-time check for
obvious errors like invalid characters. A more rigorous check is run
when the function is called.
+Perhaps the function's author was trying to write a subroutine signature
+but didn't enable that feature first (C<use feature 'signatures'>),
+so the signature was instead interpreted as a bad prototype.
=item Malformed UTF-8 character (%s)
(F) Perl thought it was reading UTF-16 encoded character data but while
doing it Perl met a malformed Unicode surrogate.
+=item Mandatory parameter follows optional parameter
+
+(F) In a subroutine signature, you wrote something like "$a = undef,
+$b", making an earlier parameter optional and a later one mandatory.
+Parameters are filled from left to right, so it's impossible for the
+caller to omit an earlier one and pass a later one. If you want to act
+as if the parameters are filled from right to left, declare the rightmost
+optional and then shuffle the parameters around in the subroutine's body.
+
=item Matched non-Unicode code point 0x%X against Unicode property; may
not be portable
list of arguments, but have forgotten to specify a piped open mode.
See L<perlfunc/open> for details.
+=item mprotect for COW string %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_COW (see
+L<perlguts/"Copy on Write">), but a shared string buffer
+could not be made read-only.
+
=item mprotect for %p %u failed with %d
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see L<perlhacktips>),
+but an op tree could not be made read-only.
+
+=item mprotect RW for COW string %p %u failed with %d
+
+(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_COW (see
+L<perlguts/"Copy on Write">), but a read-only shared string
+buffer could not be made mutable.
+
=item mprotect RW for %p %u failed with %d
(S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see
-L<perlhacktips>), but an op tree could not be made read-only, or a
-read-only op tree could not be made mutable before freeing the ops.
+L<perlhacktips>), but a read-only op tree could not be made
+mutable before freeing the ops.
=item msg%s not implemented
(W once) Typographical errors often show up as unique variable
names. If you had a good reason for having a unique name, then
just mention it again somehow to suppress the message. The C<our>
-declaration is provided for this purpose.
+declaration is also provided for this purpose.
-NOTE: This warning detects symbols that have been used only once
-so $c, @c, %c, *c, &c, sub c{}, c(), and c (the filehandle or
+NOTE: This warning detects package symbols that have been used only
+once. This means lexical variables will never trigger this warning.
+It also means that all of the package variables $c, @c, %c, as well
+as *c, &c, sub c{}, c(), and c (the filehandle or
format) are considered the same; if a program uses $c only once
but also uses any of the others it will not trigger this warning.
Symbols beginning with an underscore and symbols using special
(4294967295) and therefore non-portable between systems. See
L<perlport> for more on portability concerns.
+=item Odd name/value argument for subroutine
+
+(F) A subroutine using a slurpy hash parameter in its signature
+received an odd number of arguments to populate the hash. It requires
+the arguments to be paired, with the same number of keys as values.
+The caller of the subroutine is presumably at fault. Inconveniently,
+this error will be reported at the location of the subroutine, not that
+of the caller.
+
=item Odd number of arguments for overload::constant
(W overload) The call to overload::constant contained an odd number of
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(S 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.
+(S 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.
If the operation shown is "ToFold", it means that case-insensitive
matching in a regular expression was done on the code point.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
-(S 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 the use of surrogates can be
-dangerous, Perl warns.
+(S 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 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.
example, if you say "*foo *foo" it will be interpreted as if you said
"*foo * 'foo'".
+=item Optional parameter lacks default expression
+
+(F) In a subroutine signature, you wrote something like "$a =", making a
+named optional parameter without a default value. A nameless optional
+parameter is permitted to have no default value, but a named one must
+have a specific default. You probably want "$a = undef".
+
=item "our" variable %s redeclared
(W misc) You seem to have already declared the same global once before
(F) The unpack format P must have an explicit size, not "*".
-=item POSIX class [:%s:] unknown in regex; marked by S<<-- HERE> in m/%s/
+=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>
shows whereabouts in the regular expression the problem was discovered.
case of that character is not in Latin1, in that locale it doesn't
change when upper cased.
-=item Quantifier follows nothing in regex; marked by S<<-- HERE> in m/%s/
+=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
you meant it literally. The S<<-- HERE> shows whereabouts in the regular
=item rewinddir() attempted on invalid dirhandle %s
-(W io) The dirhandle you tried to do a rewinddir() on is either closed or not
-really a dirhandle. Check your control flow.
+(W io) The dirhandle you tried to do a rewinddir() on is either closed
+or not really a dirhandle. Check your control flow.
=item Scalars leaked: %d
construct. Remember that bracketing delimiters count nesting level.
Missing the leading C<$> from a variable C<$m> may cause this error.
-Note that since Perl 5.9.0 a // can also be the I<defined-or>
+Note that since Perl 5.10.0 a // can also be the I<defined-or>
construct, not just the empty search pattern. Therefore code written
-in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
-misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
+in Perl 5.10.0 or later that uses the // as the I<defined-or> can be
+misparsed by pre-5.10.0 Perls as a non-terminated search pattern.
=item Search pattern not terminated or ternary operator parsed as search pattern
forget to check the return value of your socket() call? See
L<perlfunc/setsockopt>.
+=item Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef
+
+(W deprecated) You assigned a reference to a scalar to C<$/> where the
+referenced item is not a positive integer. In older perls this B<appeared>
+to work the same as setting it to C<undef> but was in fact internally
+different, less efficient and with very bad luck could have resulted in
+your file being split by a stringified form of the reference.
+
+In Perl 5.20.0 this was changed so that it would be B<exactly> the same as
+setting C<$/> to undef, with the exception that this warning would be
+thrown.
+
+You are recommended to change your code to set C<$/> to C<undef> explicitly
+if you wish to slurp the file. In future versions of Perl assigning
+a reference to will throw a fatal error.
+
+=item Setting $/ to %s reference is forbidden
+
+(F) You tried to assign a reference to a non integer to C<$/>. In older
+Perls this would have behaved similarly to setting it to a reference to
+a positive integer, where the integer was the address of the reference.
+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.
it can reliably handle and C<sleep> probably slept for less time than
requested.
+=item Slurpy parameter not last
+
+(F) In a subroutine signature, you put something after a slurpy (array or
+hash) parameter. The slurpy parameter takes all the available arguments,
+so there can't be any left to fill later parameters.
+
=item Smart matching a non-overloaded object breaks encapsulation
(F) You should not use the C<~~> operator on an object that does not
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
no warnings "experimental::regex_sets";
+=item The signatures feature is experimental
+
+(S experimental::signatures) This warning is emitted if you unwrap a
+subroutine's arguments using a signature. 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::signatures";
+ use feature "signatures";
+ sub foo ($left, $right) { ... }
+
=item The stat preceding %s wasn't an lstat
(F) It makes no sense to test the current stat buffer for symbolic
(F) There has to be at least one argument to syscall() to specify the
system call to call, silly dilly.
+=item Too few arguments for subroutine
+
+(F) A subroutine using a signature received fewer arguments than required
+by the signature. The caller of the subroutine is presumably at fault.
+Inconveniently, this error will be reported at the location of the
+subroutine, not that of the caller.
+
=item Too late for "-%s" option
(X) The #! line (or local equivalent) in a Perl script contains the
(F) The function requires fewer arguments than you specified.
+=item Too many arguments for subroutine
+
+(F) A subroutine using a signature received more arguments than required
+by the signature. The caller of the subroutine is presumably at fault.
+Inconveniently, this error will be reported at the location of the
+subroutine, not that of the caller.
+
=item Too many )'s
(A) You've accidentally run your script through B<csh> instead of Perl.
=item Unicode non-character U+%X is illegal for open interchange
-(S utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
+(S 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
=item Unicode surrogate U+%X is illegal in UTF-8
-(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S 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
%d
(F) The Perl parser has no idea what to do with the specified character
-in your Perl script (or eval) near the specified column. Perhaps you tried
-to run a compressed script, a binary program, or a directory as a Perl program.
+in your Perl script (or eval) near the specified column. Perhaps you
+tried to run a compressed script, a binary program, or a directory as
+a Perl program.
=item Unrecognized escape \%c in character class in regex; marked by
S<<-- HERE> in m/%s/
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
You probably meant to use C<$]> instead. C<$[> is the base for indexing
arrays. C<$]> is the Perl version number in decimal.
+=item Use "%s" instead of "%s"
+
+(F) The second listed construct is no longer legal. Use the first one
+instead.
+
=item Useless assignment to a temporary
(W misc) You assigned to an lvalue subroutine, but what
=item Use of bare << to mean <<"" is deprecated
(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.
+form if you wish to use an empty line as the terminator of the
+here-document.
=item Use of chdir('') or chdir(undef) as chdir() deprecated
(D deprecated) You tried to use a hash as a reference, as in
C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1
-used to allow this syntax, but shouldn't have. It is now
+used to allow this syntax, but shouldn't have. It is now
deprecated, and will be removed in a future version.
=item Using an array as a reference is deprecated
=item UTF-16 surrogate U+%X
-(S utf8, surrogate) You had a UTF-16 surrogate in a context where they are
+(S 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
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
}
f()->();
-Here, when the '$a' in the eval is being compiled, f() is not currently being
-executed, so its $a is not available for capture.
+Here, when the '$a' in the eval is being compiled, f() is not currently
+being executed, so its $a is not available for capture.
=item Variable "%s" is not imported%s
=head1 SEE ALSO
-L<warnings>, L<perllexwarn>, L<diagnostics>.
+L<warnings>, L<diagnostics>.
=cut