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
you thought. Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, parenthesis pair or declaration.
+=item Ambiguous use of %c resolved as operator %c
+
+(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
+bitwise and, and multpication), and you said something like C<*foo *
+foo> that might be interpreted as either of them. We assumed you
+meant the infix operator, but please try to make it more clear -- in
+the example given, you might write C<*foo * foo()> if you really meant
+to multiply a glob by the result of calling a function.
+
+=item Ambiguous use of %c{%s} resolved to %c%s
+
+(W ambiguous) You wrote something like C<@{foo}>, which might be
+asking for the variable C<@foo>, or it might be calling a function
+named foo, and dereferencing it as an array reference. If you wanted
+the varable, you can just write C<@foo>. If you wanted to call the
+function, write C<@{foo()}> ... or you could just not have a variable
+and a function with the same name, and save yourself a lot of trouble.
+
+=item Ambiguous use of %c{%s%s} resolved to %c%s%s
+
+(W ambiguous) You wrote something like C<${foo[2]}>, which might be
+looking for element number 2 of the array named C<@foo>, in which case
+please write C<$foo[2]>, or you might have meant to pass an anonymous
+arrayref to the function named foo, then do a scalar deref on the
+value it returns. If you meant that, write C<${foo([2])}>.
+
+=item Ambiguous use of -%s resolved as -&%s()
+
+(W ambiguous) You wrote something like C<-foo>, which might be the
+string C<"-foo"> (outside of C<use strict 'subs'>), or a call to the
+function C<foo>, negated. If you meant the string, just write
+C<"-foo">, and please use strict. If you meant the function call,
+write C<-foo()>.
+
=item '|' and '<' may not both be specified on command line
(F) An error peculiar to VMS. Perl does its own command line
(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,
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 ASCII
(F) In C<\cI<X>>, I<X> must be an ASCII character.
(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
(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 "%c
+=item "\c%c" more clearly written simply as "%s"
(D deprecated) The C<\cI<X>> construct is intended to be a way to specify
non-printable characters. You used it for a printable one, which is better
-written as simply itself.
+written as simply itself, perhaps preceded by a backslash for non-word
+characters. This message may not remain as Deprecated beyond 5.13.
=item Deep recursion on subroutine "%s"
long for Perl to handle. You have to be seriously twisted to write code
that triggers this error.
-=item Deprecated character in \\N{...}; marked by <-- HERE in \\N{%s<-- HERE %s
+=item Deprecated character in \N{...}; marked by <-- HERE in \N{%s<-- HERE %s
(D deprecated) Just about anything is legal for the C<...> in C<\N{...}>.
But starting in 5.12, non-reasonable ones that don't look like names are
See Server error.
-=item Dot after %s literal is concatenation
-
-(D) You had something like 0x123.456 in your code. This is currently
-parsed as the hexadecimal number 0x123 concatenated with the decimal
-number 456, not 0x123 + 0x456/0x1000 -- we only support decimal
-decimal points. If you meant it to be a fraction, you'll need to use
-Math::BigFloat's from_hex (or friends). If you meant it to be
-concatenation, just put spaces around the dot to make it clearer. In
-5.14.0, we expect to change this to mean a hex fraction. (Of course,
-everything above applies to octal and binary constants, too.)
-
=item %s does not define %s::VERSION--version check failed
(F) You said something like "use Module 42" but the Module did not
"-", "\-". The <-- HERE shows in the regular expression about where the
problem was discovered. See L<perlre>.
-=item Fatal VMS error at %s, line %d
+=item Fatal VMS error (status=%d) at %s, line %d
(P) An error peculiar to VMS. Something untoward happened in a VMS
system service or RTL routine; Perl's exit status should provide more
(F) The parser has given up trying to parse the program after 10 errors.
Further error messages would likely be uninformative.
+=item Having no space between pattern and following word is deprecated
+
+(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:
+
+ $a =~ m/$foo/sand $bar
+ $a =~ m/$foo/s and $bar
+
+both currently mean the same thing, but it is planned to disallow the first form
+in Perl 5.16. And,
+
+ $a =~ m/$foo/and $bar
+
+will be disallowed too.
+
=item Hexadecimal number > 0xffffffff non-portable
(W portable) The hexadecimal number you specified is larger than 2**32-1
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"
If the previous attribute had a parenthesised parameter list, perhaps that
list was terminated too soon.
+=item Invalid strict version format (%s)
+
+(F) A version number did not meet the "strict" criteria for versions.
+A "strict" version number is a positive decimal number (integer or
+decimal-fraction) without exponentiation or else a dotted-decimal
+v-string with a leading 'v' character and at least three components.
+The parenthesized text indicates which criteria were not met.
+See the L<version> module for more details on allowed version formats.
+
=item Invalid type '%s' in %s
(F) The given character is not a valid pack or unpack type.
(W) The given character is not a valid pack or unpack type but used to be
silently ignored.
-=item Invalid version format (multiple underscores)
+=item Invalid version format (%s)
-(F) Versions may contain at most a single underscore, which signals
-that the version is a beta release. See L<version> for the allowed
-version formats.
+(F) A version number did not meet the "lax" criteria for versions.
+A "lax" version number is a positive decimal number (integer or
+decimal-fraction) without exponentiation or else a dotted-decimal
+v-string. If the v-string has less than three components, it must have a
+leading 'v' character. Otherwise, the leading 'v' is optional. Both
+decimal and dotted-decimal versions may have a trailing "alpha"
+component separated by an underscore character after a fractional or
+dotted-decimal component. The parenthesized text indicates which
+criteria were not met. See the L<version> module for more details on
+allowed version formats.
-=item Invalid version format (underscores before decimal)
+=item Invalid version object
-(F) Versions may not contain decimals after the optional underscore.
-See L<version> for the allowed version formats.
+(F) The internal structure of the version object was invalid. Perhaps
+the internals were modified directly in some way or an arbitrary reference
+was blessed into the "version" class.
=item ioctl is not implemented
=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
This modifier does not change the requirement that the brace immediately follow
the C<\N>.
+=item Missing braces on \o{}
+
+(F) A C<\o> must be followed immediately by a C<{> in double-quotish context.
+
=item Missing comma after first argument to %s function
(F) While certain functions allow you to specify a filehandle or an
(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
-=item Missing right brace on \\N{} or unescaped left brace after \\N
+=item Missing right brace on \N{} or unescaped left brace after \N
(F)
C<\N> has two meanings.
sense to try to declare one with a package qualifier on the front. Use
local() if you want to localize a package variable.
-=item \\N in a character class must be a named character: \\N{...}
+=item \N in a character class must be a named character: \N{...}
(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed
character class, for the same reason that C<.> in a character class loses its
specialness: it matches almost everything, which is probably not what you want.
-=item \\N{NAME} must be resolved by the lexer
+=item \N{NAME} must be resolved by the lexer
(F) When compiling a regex pattern, an unresolved named character or sequence
was encountered. This can happen in any of several ways that bypass the lexer,
the same; if a program uses $c only once but also uses any of the others it
will not trigger this warning.
-=item Invalid hexadecimal number in \\N{U+...}
+=item Invalid hexadecimal number in \N{U+...}
(F) The character constant represented by C<...> is not a valid hexadecimal
number. Either it is empty, or you tried to use a character other than 0 - 9
(F) The indicated command line switch needs a mandatory argument, but
you haven't specified one.
-
=item No such class field "%s" in variable %s of type %s
(F) You tried to access a key from a hash through the indicated typed variable
F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
need to be added to UTC to get local time.
+=item Non-octal character '%c'. Resolved as "%s"
+
+(W digit) In parsing an octal numeric constant, a character was unexpectedly
+encountered that isn't octal. The resulting value is as indicated.
+
=item Non-string passed as bitmask
(W misc) A number has been passed as a bitmask argument to select().
the meantime, try using scientific notation (e.g. "1e6" instead of
"1_000_000").
+=item Number with no digits
+
+(F) Perl was looking for a number but found nothing that looked like a number.
+This happens, for example with C<\o{}>, with no number between the braces.
+
=item Octal number in vector unsupported
(F) Numbers with a leading C<0> are not currently allowed in vectors.
=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.
(P) The lexer got into a bad state while processing a case modifier.
+=item Parsing code internal error (%s)
+
+(F) Parsing code supplied by an extension violated the parser's API in
+a detectable way.
+
=item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
(F) You used a pattern that uses too many nested subpattern calls without
(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.
(F) You used something like C<\7> in your regular expression, but there are
not at least seven sets of capturing parentheses in the expression. If you
-wanted to have the character with value 7 inserted into the regular expression,
-prepend a zero to make the number at least two digits: C<\07>
+wanted to have the character with ordinal 7 inserted into the regular expression,
+prepend zeroes to make it three digits long: C<\007>
The <-- HERE shows in the regular expression about where the problem was
discovered.
(F) You used a regular expression extension that doesn't make sense. The
<-- HERE shows in the regular expression about where the problem was
-discovered. See L<perlre>.
+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
+causes, see L<perlre>.
-=item Sequence \\%s... not terminated in regex; marked by <-- HERE in m/%s/
+=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
(F) The regular expression expects a mandatory argument following the escape
sequence and this has been omitted or incorrectly written.
=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 0x%x is illegal for 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
=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 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'
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 passed through in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%c in character class passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl inside character classes. The character was
The <-- HERE shows in the regular expression about where the
escape was discovered.
-=item Unrecognized escape \\%c passed through
+=item Unrecognized escape \%c passed through
(W misc) You used a backslash-character combination which is not
recognized by Perl. The character was understood literally, but this may
change in a future version of Perl.
-=item Unrecognized escape \\%c passed through in regex; marked by <-- HERE in m/%s/
+=item Unrecognized escape \%c passed through in regex; marked by <-- HERE in m/%s/
(W regexp) You used a backslash-character combination which is not
recognized by Perl. The character was understood literally, but this may
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
you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
C<use AutoLoader 'AUTOLOAD';>.
-=item Use of octal value above 377 is deprecated
-
-(D deprecated, W regexp) There is a constant in the regular expression whose
-value is interpeted by Perl as octal and larger than 377 (255 decimal, 0xFF
-hex). Perl may take this to mean different things depending on the rest of
-the regular expression. If you meant such an octal value, convert it to
-hexadecimal and use C<\xHH> or C<\x{HH}> instead. If you meant to have
-part of it mean a backreference, use C<\g> for that. See L<perlre>.
-
=item Use of %s in printf format not supported
(F) You attempted to use a feature of printf that is accessible from
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
otherwise reasonable constructs to fail in baffling ways. C<use strict;>
instead.
+=item Use of qw(...) as parentheses is deprecated
+
+(D deprecated) You have something like C<foreach $x qw(a b c) {...}>,
+using a C<qw(...)> list literal where a parenthesised expression is
+expected. Historically the parser fooled itself into thinking that
+C<qw(...)> literals were always enclosed in parentheses, and as a result
+you could sometimes omit parentheses around them. (You could never do
+the C<foreach qw(a b c) {...}> that you might have expected, though.)
+The parser no longer lies to itself in this way. Wrap the list literal
+in parentheses, like C<foreach $x (qw(a b c)) {...}>.
+
=item Use of reference "%s" as array index
(W misc) You tried to use a reference as an array index; this probably
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 UTF-16 surrogate 0x%x
(W utf8) You tried to generate half of a UTF-16 surrogate by
requesting a Unicode character between the code points 0xD800 and
=item %s "\x%s" 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