that expected a numeric value instead. If you're fortunate the message
will identify which operator was so unfortunate.
+Note that for the C<Inf> and C<NaN> (infinity and not-a-number) the
+definition of "numeric" is somewhat unusual: the strings themselves
+(like "Inf") are considered numeric, and anything following them is
+considered non-numeric.
+
=item Argument list not closed for PerlIO layer "%s"
(W layer) When pushing a layer with arguments onto the Perl I/O
(P) When starting a new thread or returning values from a thread, Perl
encountered an invalid data type.
+=item Both or neither range ends should be Unicode in regex; marked by
+S<<-- HERE> in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+In a bracketed character class in a regular expression pattern, you
+had a range which has exactly one end of it specified using C<\N{}>, and
+the other end is specified using a non-portable mechanism. Perl treats
+the range as a Unicode range, that is, all the characters in it are
+considered to be the Unicode characters, and which may be different code
+points on some platforms Perl runs on. For example, C<[\N{U+06}-\x08]>
+is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it
+matches the characters whose code points in Unicode are 6, 7, and 8.
+But that C<\x08> might indicate that you meant something different, so
+the warning gets raised.
+
=item Buffer overflow in prime_env_iter: %s
(W internal) A warning peculiar to VMS. While Perl was preparing to
do so. Such arrays are not even supposed to be accessible to
Perl code, but are only used internally.
+=item Cannot yet reorder sv_catpvfn() arguments from va_list
+
+(F) Some XS code tried to use C<sv_catpvfn()> or a related function with a
+format string that specifies explicit indexes for some of the elements, and
+using a C-style variable-argument list (a C<va_list>). This is not currently
+supported. XS authors wanting to do this must instead construct a C array of
+C<SV*> scalars containing the arguments.
+
=item Can only compress unsigned integers in pack
(F) An argument to pack("w",...) was not an integer. The BER compressed
or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
searched.
+=item Can't redeclare "%s" in "%s"
+
+(F) A "my", "our" or "state" declaration was found within another declaration,
+such as C<my ($x, my($y), $z)> or C<our (my $x)>.
+
=item Can't "redo" outside a loop block
(F) A "redo" statement was executed to restart the current block, but
could be defined by a translator installed into C<$^H{charnames}>.
See L<charnames/CUSTOM ALIASES>.
-=item \C is deprecated in regex; marked by <-- HERE in m/%s/
+=item chdir() on unopened filehandle %s
-(D deprecated, regexp) The \C character class is deprecated, and will
-become a compile-time error in a future release of perl (tentatively
-v5.24). This construct allows you to match a single byte of what makes
-up a multi-byte single UTF8 character, and breaks encapsulation. It is
-currently also very buggy. If you really need to process the individual
-bytes, you probably want to convert your string to one where each
-underlying byte is stored as a character, with utf8::encode().
+(W unopened) You tried chdir() on a filehandle that was never opened.
+
+=item \C no longer supported in regex; marked by S<<-- HERE> in m/%s/
+
+(F) The \C character class used to allow a match of single byte within a
+multi-byte utf-8 character, but was removed in v5.24 as it broke
+encapsulation and its implementation was extremely buggy. If you really
+need to process the individual bytes, you probably want to convert your
+string to one where each underlying byte is stored as a character, with
+utf8::encode().
=item "\c%c" is more clearly written simply as "%s"
(F) The parser found inconsistencies either while attempting
to define an overloaded constant, or when trying to find the
character name specified in the C<\N{...}> escape. Perhaps you
-forgot to load the corresponding L<overload> pragma?.
+forgot to load the corresponding L<overload> pragma?
+
+=item :const is experimental
+
+(S experimental::const_attr) The "const" attribute is experimental.
+If you want to use the feature, disable the warning with C<no warnings
+'experimental::const_attr'>, but know that in doing so you are taking
+the risk that your code may break in a future Perl version.
+
+=item :const is not permitted on named subroutines
+
+(F) The "const" attribute causes an anonymous subroutine to be run and
+its value captured at the time that it is cloned. Named subroutines are
+not cloned like this, so the attribute does not make sense on them.
=item Copy method did not return a reference
most likely cause of this error is that you left out a parenthesis inside
of the C<....> part.
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item %s defines neither package nor VERSION--version check failed
(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
(F) You used a pattern that nested too many EVAL calls without consuming
any text. Restructure the pattern so that text is consumed.
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item Excessively long <> operator
use feature "signatures";
sub foo ($left, $right) { ... }
+=item Experimental %s on scalar is now forbidden
+
+(F) An experimental feature added in Perl 5.14 allowed C<each>, C<keys>,
+C<push>, C<pop>, C<shift>, C<splice>, C<unshift>, and C<values> to be called
+with a scalar argument. This experiment is considered unsuccessful, and has
+been removed. The C<postderef> feature may meet your needs better.
+
=item Experimental "%s" subs not enabled
(F) To use lexical subs, you must first enable them:
(W overflow) The hexadecimal floating point has a smaller exponent
than the floating point supports.
-=item Hexadecimal float: internal error
+=item Hexadecimal float: internal error (%s)
(F) Something went horribly bad in hexadecimal float handling.
if you're expecting only one subscript. When called in list context,
it also returns the key in addition to the value.
+=item %s() is deprecated on :utf8 handles
+
+(W deprecated) The sysread(), recv(), syswrite() and send() operators
+are deprecated on handles that have the C<:utf8> layer, either
+explicitly, or implicitly, eg., with the C<:encoding(UTF-16LE)> layer.
+
+Both sysread() and recv() currently use only the C<:utf8> flag for the
+stream, ignoring the actual layers. Since sysread() and recv() do no
+UTF-8 validation they can end up creating invalidly encoded scalars.
+
+Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise
+ignoring any layers. If the flag is set, both write the value UTF-8
+encoded, even if the layer is some different encoding, such as the
+example above.
+
+Ideally, all of these operators would completely ignore the C<:utf8>
+state, working only with bytes, but this would result in silently
+breaking existing code. To avoid this a future version of perl will
+throw an exception when any of sysread(), recv(), syswrite() or send()
+are called on handle with the C<:utf8> layer.
+
=item Insecure dependency in %s
(F) You tried to do something that the tainting mechanism didn't like.
with the B<-D> option with no flags to see the list of acceptable values.
See also L<perlrun/-Dletters>.
+=item Invalid quantifier in {,} in regex; marked by S<<-- HERE> in m/%s/
+
+(F) The pattern looks like a {min,max} quantifier, but the min or max
+could not be parsed as a valid number - either it has leading zeroes,
+or it represents too big a number to cope with. The S<<-- HERE> shows
+where in the regular expression the problem was discovered. See L<perlre>.
+
=item Invalid [] range "%s" in regex; marked by S<<-- HERE> in m/%s/
(F) The range specified in a character class had a minimum character
(F) Your machine doesn't implement the sockatmark() functionality,
neither as a system call nor an ioctl call (SIOCATMARK).
+=item '%s' is an unknown bound type in regex; marked by S<<-- HERE> in m/%s/
+
+(F) You used C<\b{...}> or C<\B{...}> and the C<...> is not known to
+Perl. The current valid ones are given in
+L<perlrebackslash/\b{}, \b, \B{}, \B>.
+
+=item "%s" is more clearly written simply as "%s" in regex; marked by S<<-- HERE> in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+You specified a character that has the given plainer way of writing it,
+and which is also portable to platforms running with different character
+sets.
+
=item $* is no longer supported
(D deprecated, syntax) The special variable C<$*>, deprecated in older
(P) The regular expression parser is confused.
-=item keys on reference is experimental
-
-(S experimental::autoderef) C<keys> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Label not found for "last %s"
(F) You named a loop to break out of, but you're not currently in a loop
=item Locale '%s' may not work well.%s
(W locale) You are using the named locale, which is a non-UTF-8 one, and
-which Perl has determined is not fully compatible with Perl. The second
-C<%s> gives a reason.
+which perl has determined is not fully compatible with what it can
+handle. The second C<%s> gives a reason.
By far the most common reason is that the locale has characters in it
that are represented by more than one byte. The only such locales that
class loses its specialness: it matches almost everything, which is
probably not what you want.
-=item \N{} in inverted character class or as a range end-point is restricted to one character in regex; marked
-by S<<-- HERE> in m/%s/
+=item \N{} in inverted character class or as a range end-point is restricted to one character in regex; marked by <-- HERE in m/%s/
(F) Named Unicode character escapes (C<\N{...}>) may return a
multi-character sequence. Even though a character class is
(F) Fully qualified variable names are not allowed in "our"
declarations, because that doesn't make much sense under existing
-semantics. Such syntax is reserved for future extensions.
+rules. Such syntax is reserved for future extensions.
=item No Perl script found in input
=item Operation "%s" returns its argument for non-Unicode code point 0x%X
-(S non_unicode) You performed an operation requiring Unicode semantics
+(S non_unicode) You performed an operation requiring Unicode rules
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.
=item Operation "%s" returns its argument for UTF-16 surrogate U+%X
(S surrogate) You performed an operation requiring Unicode
-semantics on a Unicode surrogate. Unicode frowns upon the use
+rules 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
+rules 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.
(F) The unpack format P must have an explicit size, not "*".
-=item pop on reference is experimental
-
-(S experimental::autoderef) C<pop> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
-=item POSIX class [:%s:] unknown in regex; marked by S<< <-- HERE in m/%s/ >>
+=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.
sub { 1 if die; }
-=item Possible precedence problem on bitwise %c operator
+=item Possible precedence problem on bitwise %s operator
(W precedence) Your program uses a bitwise logical operator in conjunction
with a numeric comparison operator, like this :
literal @foo, then write it as \@foo; otherwise find out what happened
to the array you apparently lost track of.
-=item Postfix dereference is experimental
-
-(S experimental::postderef) This warning is emitted if you use
-the experimental postfix dereference syntax. Simply suppress the
-warning if you want to use the feature, but know that in doing
-so you are taking the risk of using an experimental feature which
-may change or be removed in a future Perl version:
-
- no warnings "experimental::postderef";
- use feature "postderef", "postderef_qq";
- $ref->$*;
- $aref->@*;
- $aref->@[@indices];
- ... etc ...
-
=item Precedence problem: open %s should be open(%s)
(S precedence) The old irregular construct
parentheses is useless, since it will be replaced by the prototype
from the attribute before it's ever used.
-=item push on reference is experimental
-
-(S experimental::autoderef) C<push> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
-=item Quantifier follows nothing in regex; marked by S<< <-- HERE in m/%s/ >>
+=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
expression the problem was discovered. See L<perlre>.
-=item Quantifier in {,} bigger than %d in regex; marked by S<<-- HERE> in
-m/%s/
+=item Quantifier in {,} bigger than %d in regex; marked by S<<-- HERE> in m/%s/
(F) There is currently a limit to the size of the min and max values of
the {min,max} construct. The S<<-- HERE> shows whereabouts in the regular
One possible workaround is to force Perl to use magical string increment
by prepending "0" to your numbers.
+=item Ranges of ASCII printables should be some subset of "0-9", "A-Z", or
+"a-z" in regex; marked by S<<-- HERE> in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Stricter rules help to find typos and other errors. Perhaps you didn't
+even intend a range here, if the C<"-"> was meant to be some other
+character, or should have been escaped (like C<"\-">). If you did
+intend a range, the one that was used is not portable between ASCII and
+EBCDIC platforms, and doesn't have an obvious meaning to a casual
+reader.
+
+ [3-7] # OK; Obvious and portable
+ [d-g] # OK; Obvious and portable
+ [A-Y] # OK; Obvious and portable
+ [A-z] # WRONG; Not portable; not clear what is meant
+ [a-Z] # WRONG; Not portable; not clear what is meant
+ [%-.] # WRONG; Not portable; not clear what is meant
+ [\x41-Z] # WRONG; Not portable; not obvious to non-geek
+
+(You can force portability by specifying a Unicode range, which means that
+the endpoints are specified by
+L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may
+still not be obvious.)
+The stricter rules require that ranges that start or stop with an ASCII
+character that is not a control have all their endpoints be the literal
+character, and not some escape sequence (like C<"\x41">), and the ranges
+must be all digits, or all uppercase letters, or all lowercase letters.
+
+=item Ranges of digits should be from the same group in regex; marked by
+S<<-- HERE> in m/%s/
+
+(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>)
+
+Stricter rules help to find typos and other errors. You included a
+range, and at least one of the end points is a decimal digit. Under the
+stricter rules, when this happens, both end points should be digits in
+the same group of 10 consecutive digits.
+
=item readdir() attempted on invalid dirhandle %s
(W io) The dirhandle you're reading from is either closed or not really
you 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 whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item Reference to nonexistent named group in regex; marked by S<<-- HERE>
such as C<(?'NAME'...)> or C<< (?<NAME>...) >>. Check if the name has been
spelled correctly both in the backreference and the declaration.
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item Reference to nonexistent or unclosed group in regex; marked by
are not at least seven sets of closed capturing parentheses in the
expression before where the C<\g{-7}> was located.
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered.
=item regexp memory corruption
As of Perl 5.20.0 this is a fatal error, to allow future versions of Perl
to use non-integer refs for more interesting purposes.
-=item shift on reference is experimental
-
-(S experimental::autoderef) C<shift> with a scalar argument is experimental
-and may change or be removed in a future Perl version. If you want to
-take the risk of using this feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
(F) An ancient error message that almost nobody ever runs into anymore.
But before sort was a keyword, people sometimes used it as a filehandle.
-=item Sort subroutine didn't return single value
-
-(F) A sort comparison subroutine written in XS must return exactly one
-item. See L<perlfunc/sort>.
-
=item Source filters apply only to byte streams
(F) You tried to activate a source filter (usually by loading a
try explicitly pre-extending the array by assigning $#array = $offset.
See L<perlfunc/splice>.
-=item splice on reference is experimental
-
-(S experimental::autoderef) C<splice> with a scalar argument
-is experimental and may change or be removed in a future
-Perl version. If you want to take the risk of using this
-feature, simply disable this warning:
-
- no warnings "experimental::autoderef";
-
=item Split loop
(P) The split was looping infinitely. (Obviously, a split shouldn't
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
=item Switch (?(condition)... not terminated in regex; marked by
This is to prevent the problem of one module changing the array base out
from under another module inadvertently. See L<perlvar/$[> and L<arybase>.
+=item The bitwise feature is experimental
+
+(S experimental::bitwise) This warning is emitted if you use bitwise
+operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled.
+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::bitwise";
+ use feature "bitwise";
+ $x |.= $y;
+
=item The crypt() function is unimplemented due to excessive paranoia.
(F) Configure couldn't find the crypt() function on your machine,
%NAME or C<%{EXPR}>. No implicit dereferencing is allowed--use the
{EXPR} forms as an explicit dereference. See L<perlref>.
-=item Type of argument to %s must be unblessed hashref or arrayref
-
-(F) You called C<keys>, C<values> or C<each> with a scalar argument that
-was not a reference to an unblessed hash or array.
-
=item umask not implemented
(F) Your machine doesn't implement the umask function and you tried to
Check the #! line, or manually feed your script into Perl yourself.
=item Unescaped left brace in regex is deprecated, passed through in regex;
-marked by <-- HERE in m/%s/
+marked by S<<-- HERE> in m/%s/
(D deprecated, regexp) You used a literal C<"{"> character in a regular
expression pattern. You should change to use C<"\{"> instead, because a
no indication as to how the digits are to be combined
with the characters in the Lao and Thai scripts.
-=item Unicode non-character U+%X is illegal for open interchange
+=item Unicode non-character U+%X is not recommended for open interchange
(S nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
defined by the Unicode standard to be non-characters. Those
(R&NAME) true if directly inside named capture
(DEFINE) always false; for defining named subpatterns
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
=item Unknown Unicode option letter '%c'
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
if ($string =~ /$pattern/) { ... }
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
=item Useless localization of %s
if ($string =~ /$pattern/o) { ... }
-The <-- HERE shows whereabouts in the regular expression the problem was
+The S<<-- HERE> shows whereabouts in the regular expression the problem was
discovered. See L<perlre>.
+=item Useless use of attribute "const"
+
+(W misc) The "const" attribute has no effect except
+on anonymous closure prototypes. You applied it to
+a subroutine via L<attributes.pm|attributes>. This is only useful
+inside an attribute handler for an anonymous subroutine.
+
=item Useless use of /d modifier in transliteration operator
(W misc) You have used the /d modifier where the searchlist has the
String constants that would normally evaluate to 0 or 1 are warned
about.
-=item Unusual use of %s in void context
-
-(W void_unusual) Similar to the "Useless use of %s in void context"
-warning, but only turned on by the top-level "pedantic" warning
-category, used for e.g. C<grep> in void context, which may indicate a
-bug, but could also just be someone using C<grep> for its side-effects
-as a loop.
-
-Enabled as part of "extra" warnings, not in the "all" category. See
-L<warnings> for details
-
=item Useless use of (?-p) in regex; marked by S<<-- HERE> in m/%s/
(W regexp) The C<p> modifier cannot be turned off once set. Trying to do
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) chdir() with no arguments is documented to change to
-$ENV{HOME} or $ENV{LOGDIR}. chdir(undef) and chdir('') share this
-behavior, but that has been deprecated. In future versions they
-will simply fail.
+=item Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale
-Be careful to check that what you pass to chdir() is defined and not
-blank, else you might find yourself in your home directory.
+(W locale) You are matching a regular expression using locale rules,
+and a Unicode boundary is being matched, but the locale is not a Unicode
+one. This doesn't make sense. Perl will continue, assuming a Unicode
+(UTF-8) locale, but the results could well be wrong except if the locale
+happens to be ISO-8859-1 (Latin1) where this message is spurious and can
+be ignored.
=item Use of /c modifier is meaningless in s///
C<concatenation (.)> operator, even though there is no C<.> in
your program.
+=item "use re 'strict'" is experimental
+
+(S experimental::re_strict) The things that are different when a regular
+expression pattern is compiled under C<'strict'> are subject to change
+in future Perl releases in incompatible ways. This means that a pattern
+that compiles today may not in a future Perl release. This warning is
+to alert you to that risk.
+
=item Use \x{...} for more than two hex characters in regex; marked by
S<<-- HERE> in m/%s/
these circumstances, Perl discards all but the first character
of the returned sequence, which is not likely what you want.
+=item Using /u for '%s' instead of /%s in regex; marked by S<<-- HERE> in m/%s/
+
+(W regexp) You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a
+portion of a regular expression where the character set modifiers C</a>
+or C</aa> are in effect. These two modifiers indicate an ASCII
+interpretation, and this doesn't make sense for a Unicode defintion.
+The generated regular expression will compile so that the boundary uses
+all of Unicode. No other portion of the regular expression is affected.
+
=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
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
(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8
one), a multi-byte character was encountered. Perl considers this
-character to be the specified Unicode code point. Combining non-UTF8
+character to be the specified Unicode code point. Combining non-UTF-8
locales and Unicode is dangerous. Almost certainly some characters
will have two different representations. For example, in the ISO 8859-7
(Greek) locale, the code point 0xC3 represents a Capital Gamma. But so
with your single-byte locale (or perhaps you thought you had a UTF-8
locale, but Perl disagrees).
+=item %s() with negative argument
+
+(S misc) Certain operations make no sense with negative arguments.
+Warning is given and the operation is not done.
+
=item Within []-length '%c' not allowed
(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]>