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
(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
+the variable, 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.
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).
(P) An internal request asked to add a dirhandle entry to something
that wasn't a symbol table entry.
-
=item Bad symbol for filehandle
(P) An internal request asked to add a filehandle entry to something
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
forgot to load the corresponding C<charnames> pragma?
See L<charnames>.
-
=item Constant is not %s reference
(F) A constant value (perhaps declared using the C<use constant> pragma)
(F) The method which overloads "=" is buggy. See
L<overload/Copy Constructor>.
+=item &CORE::%s cannot be called directly
+
+(F) You tried to call a subroutine in the C<CORE::> namespace
+with C<&foo> syntax or through a reference. Most subroutines
+in this package cannot yet be called that way, but must be
+called as barewords. Something like this will work:
+
+ BEGIN { *shove = \&CORE::push; }
+ shove @array, 1,2,3; # pushes on to @array
+
=item CORE::%s is not a keyword
(F) The CORE:: namespace is reserved for Perl keywords.
=item defined(%hash) is deprecated
-(D deprecated) defined() is not usually useful on hashes because it
-checks for an undefined I<scalar> value. If you want to see if the hash
-is empty, just use C<if (%hash) { # not empty }> for example.
+(D deprecated) C<defined()> is not usually right on hashes and has been
+discouraged since 5.004.
+
+Although C<defined %hash> is false on a plain not-yet-used hash, it
+becomes true in several non-obvious circumstances, including iterators,
+weak references, stash names, even remaining true after C<undef %hash>.
+These things make C<defined %hash> fairly useless in practice.
+
+If a check for non-empty is what you wanted then just put it in boolean
+context (see L<perldata/Scalar values>):
+
+ if (%hash) {
+ # not empty
+ }
+
+If you had C<defined %Foo::Bar::QUUX> to check whether such a package
+variable exists then that's never really been reliable, and isn't
+a good way to enquire about the features of a package, or whether
+it's loaded, etc.
+
=item (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in m/%s/
(W overflow) You called C<gmtime> with a number that was larger than
it can reliably handle and C<gmtime> probably returned the wrong
-date. This warning is also triggered with nan (the special
+date. This warning is also triggered with NaN (the special
not-a-number value).
=item gmtime(%f) too small
(W overflow) You called C<gmtime> with a number that was smaller than
it can reliably handle and C<gmtime> probably returned the wrong
-date. This warning is also triggered with nan (the special
+date. This warning is also triggered with NaN (the special
not-a-number value).
=item Got an error from DosAllocMem
(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
binary number. Interpretation of the binary number stopped before the
offending digit.
+=item Illegal character after '_' in prototype for %s : %s
+
+(W illegalproto) An illegal character was found in a prototype declaration.
+Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
+
=item Illegal character \%o (carriage return)
(F) Perl normally treats carriage returns in the program text as it
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.
(W overflow) You called C<localtime> with a number that was larger
than it can reliably handle and C<localtime> probably returned the
-wrong date. This warning is also triggered with nan (the special
+wrong date. This warning is also triggered with NaN (the special
not-a-number value).
=item localtime(%f) too small
(W overflow) You called C<localtime> with a number that was smaller
than it can reliably handle and C<localtime> probably returned the
-wrong date. This warning is also triggered with nan (the special
+wrong date. This warning is also triggered with NaN (the special
not-a-number value).
=item Lookbehind longer than %d not implemented in regex m/%s/
by that? lstat() makes sense only on filenames. (Perl did a fstat()
instead on the filehandle.)
-=item lvalue attribute ignored after the subroutine has been defined
+=item lvalue attribute cannot be removed after the subroutine has been defined
-(W misc) Making a subroutine an lvalue subroutine after it has been defined
-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.
+(W misc) The lvalue attribute on a Perl subroutine cannot be turned off
+once the subroutine is defined.
-=item Lvalue subs returning %s not implemented yet
+=item lvalue attribute ignored after the subroutine has been defined
-(F) Due to limitations in the current implementation, array and hash
-values cannot be returned in subroutines used in lvalue context. See
-L<perlsub/"Lvalue subroutines">.
+(W misc) Making a Perl subroutine an lvalue subroutine after it has been
+defined, whether by declaring the subroutine with an lvalue attribute
+or by using L<attributes.pm|attributes>, 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 Malformed integer in [] in pack
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.
Occasionally the line number may be misleading, and once in a blue moon
the only way to figure out what's triggering the error is to call
C<perl -c> repeatedly, chopping away half the program each time to see
-if the error went away. Sort of the cybernetic version of S<20
-questions>.
+if the error went away. Sort of the cybernetic version of S<20 questions>.
=item syntax error at line %d: `%s' unexpected
%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
after an open brace in your pattern. Check the pattern and review
L<perlre> for details on legal verb patterns.
-first.
-
=item Unknown warnings category '%s'
(F) An error issued by the C<warnings> pragma. You specified a warnings
category that is unknown to perl at this point.
-Note that if you want to enable a warnings category registered by a module
-(e.g. C<use warnings 'File::Find'>), you must have imported this module
+Note that if you want to enable a warnings category registered by a
+module (e.g. C<use warnings 'File::Find'>), you must have loaded this
+module first.
=item unmatched [ in regex; marked by <-- HERE in m/%s/
compressed integer format and could not be converted to an integer.
See L<perlfunc/pack>.
-=item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
-
-(F) You used a pattern of the form C<(*VERB)> but did not terminate
-the pattern with a C<)>. Fix the pattern and retry.
-
-=item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/
-
-(F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate
-the pattern with a C<)>. Fix the pattern and retry.
-
=item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
(F) You missed a close brace on a \g{..} pattern (group reference) in
not finding it. Chances are you left some needed parentheses out
earlier in the line, and you really meant a "less than".
+=item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
+=item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
+
+(F) You used a pattern of the form C<(*VERB)> but did not terminate
+the pattern with a C<)>. Fix the pattern and retry.
+
=item untie attempted while %d inner references still exist
(W untie) A copy of the object returned from C<tie> (or C<tied>) was
(F) You called a Win32 function with incorrect arguments.
See L<Win32> for more information.
+=item Useless assignment to a temporary
+
+(W misc) You assigned to an lvalue subroutine, but what
+the subroutine returned was a temporary scalar about to
+be discarded, so the assignment had no effect.
+
=item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/
(W regexp) You have used an internal modifier such as (?-o) that has no
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
(F) Perhaps you modified the iterated array within the loop?
=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
+=item Use of ?PATTERN? without explicit operator 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.
+(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 qw(...) as parentheses is deprecated
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{}
-
-(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 Using !~ with %s doesn't make sense
-=item Unicode surrogate U+%X is illegal in UTF-8
+(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 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
=head1 SEE ALSO
-L<warnings>, L<perllexwarn>.
+L<warnings>, L<perllexwarn>, L<diagnostics>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff