1PERLDIAG(1) Perl Programmers Reference Guide PERLDIAG(1)
2
6 perldiag - various Perl diagnostics
7
9 These messages are classified as follows (listed in increasing order of
10 desperation):
11 (W) A warning (optional).
13 (D) A deprecation (enabled by default).
14 (S) A severe warning (enabled by default).
15 (F) A fatal error (trappable).
16 (P) An internal error you should never see (trappable).
17 (X) A very fatal error (nontrappable).
18 (A) An alien error message (not generated by Perl).
19 The majority of messages from the first three classifications above (W,
21 D & S) can be controlled using the "warnings" pragma.
22 If a message can be controlled by the "warnings" pragma, its warning
24 category is included with the classification letter in the description
25 below. E.g. "(W closed)" means a warning in the "closed" category.
26 Optional warnings are enabled by using the "warnings" pragma or the -w
28 and -W switches. Warnings may be captured by setting $SIG{__WARN__} to
29 a reference to a routine that will be called on each warning instead of
30 printing it. See perlvar.
31 Severe warnings are always enabled, unless they are explicitly disabled
33 with the "warnings" pragma or the -X switch.
34 Trappable errors may be trapped using the eval operator. See "eval" in
36 perlfunc. In almost all cases, warnings may be selectively disabled or
37 promoted to fatal errors using the "warnings" pragma. See warnings.
38 The messages are in alphabetical order, without regard to upper or
40 lower-case. Some of these messages are generic. Spots that vary are
41 denoted with a %s or other printf-style escape. These escapes are
42 ignored by the alphabetical order, as are all characters other than
43 letters. To look up your message, just ignore anything that is not a
44 letter.
45 accept() on closed socket %s
47 (W closed) You tried to do an accept on a closed socket. Did you
48 forget to check the return value of your socket() call? See
49 "accept" in perlfunc.
50 ADJUST is experimental
52 (S experimental::class) This warning is emitted if you use the
53 "ADJUST" keyword of "use feature 'class'". This keyword is
54 currently experimental and its behaviour may change in future
55 releases of Perl.
56 Aliasing via reference is experimental
58 (S experimental::refaliasing) This warning is emitted if you use a
59 reference constructor on the left-hand side of an assignment to
60 alias one variable to another. Simply suppress the warning if you
61 want to use the feature, but know that in doing so you are taking
62 the risk of using an experimental feature which may change or be
63 removed in a future Perl version:
64 no warnings "experimental::refaliasing";
66 use feature "refaliasing";
67 \$x = \$y;
68 '%c' allowed only after types %s in %s
70 (F) The modifiers '!', '<' and '>' are allowed in pack() or
71 unpack() only after certain types. See "pack" in perlfunc.
72 alpha->numify() is lossy
74 (W numeric) An alpha version can not be numified without losing
75 information.
76 Ambiguous call resolved as CORE::%s(), qualify as such or use &
78 (W ambiguous) A subroutine you have declared has the same name as a
79 Perl keyword, and you have used the name without qualification for
80 calling one or the other. Perl decided to call the builtin because
81 the subroutine is not imported.
82 To force interpretation as a subroutine call, either put an
84 ampersand before the subroutine name, or qualify the name with its
85 package. Alternatively, you can import the subroutine (or pretend
86 that it's imported with the "use subs" pragma).
87 To silently interpret it as the Perl operator, use the "CORE::"
89 prefix on the operator (e.g. CORE::log($x)) or declare the
90 subroutine to be an object method (see "Subroutine Attributes" in
91 perlsub or attributes).
92 Ambiguous range in transliteration operator
94 (F) You wrote something like "tr/a-z-0//" which doesn't mean
95 anything at all. To include a "-" character in a transliteration,
96 put it either first or last. (In the past, "tr/a-z-0//" was
97 synonymous with "tr/a-y//", which was probably not what you would
98 have expected.)
99 Ambiguous use of %s resolved as %s
101 (S ambiguous) You said something that may not be interpreted the
102 way you thought. Normally it's pretty easy to disambiguate it by
103 supplying a missing quote, operator, parenthesis pair or
104 declaration.
105 Ambiguous use of -%s resolved as -&%s()
107 (S ambiguous) You wrote something like "-foo", which might be the
108 string "-foo", or a call to the function "foo", negated. If you
109 meant the string, just write "-foo". If you meant the function
110 call, write "-foo()".
111 Ambiguous use of %c resolved as operator %c
113 (S ambiguous) "%", "&", and "*" are both infix operators (modulus,
114 bitwise and, and multiplication) and initial special characters
115 (denoting hashes, subroutines and typeglobs), and you said
116 something like "*foo * foo" that might be interpreted as either of
117 them. We assumed you meant the infix operator, but please try to
118 make it more clear -- in the example given, you might write "*foo *
119 foo()" if you really meant to multiply a glob by the result of
120 calling a function.
121 Ambiguous use of %c{%s} resolved to %c%s
123 (W ambiguous) You wrote something like "@{foo}", which might be
124 asking for the variable @foo, or it might be calling a function
125 named foo, and dereferencing it as an array reference. If you
126 wanted the variable, you can just write @foo. If you wanted to
127 call the function, write "@{foo()}" ... or you could just not have
128 a variable and a function with the same name, and save yourself a
129 lot of trouble.
130 Ambiguous use of %c{%s[...]} resolved to %c%s[...]
132 Ambiguous use of %c{%s{...}} resolved to %c%s{...}
133 (W ambiguous) You wrote something like "${foo[2]}" (where foo
134 represents the name of a Perl keyword), which might be looking for
135 element number 2 of the array named @foo, in which case please
136 write $foo[2], or you might have meant to pass an anonymous
137 arrayref to the function named foo, and then do a scalar deref on
138 the value it returns. If you meant that, write "${foo([2])}".
139 In regular expressions, the "${foo[2]}" syntax is sometimes
141 necessary to disambiguate between array subscripts and character
142 classes. "/$length[2345]/", for instance, will be interpreted as
143 $length followed by the character class "[2345]". If an array
144 subscript is what you want, you can avoid the warning by changing
145 "/${length[2345]}/" to the unsightly "/${\$length[2345]}/", by
146 renaming your array to something that does not coincide with a
147 built-in keyword, or by simply turning off warnings with "no
148 warnings 'ambiguous';".
149 '|' and '<' may not both be specified on command line
151 (F) An error peculiar to VMS. Perl does its own command line
152 redirection, and found that STDIN was a pipe, and that you also
153 tried to redirect STDIN using '<'. Only one STDIN stream to a
154 customer, please.
155 '|' and '>' may not both be specified on command line
157 (F) An error peculiar to VMS. Perl does its own command line
158 redirection, and thinks you tried to redirect stdout both to a file
159 and into a pipe to another command. You need to choose one or the
160 other, though nothing's stopping you from piping into a program or
161 Perl script which 'splits' output into two streams, such as
162 open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!";
164 while (<STDIN>) {
165 print;
166 print OUT;
167 }
168 close OUT;
169 Applying %s to %s will act on scalar(%s)
171 (W misc) The pattern match ("//"), substitution ("s///"), and
172 transliteration ("tr///") operators work on scalar values. If you
173 apply one of them to an array or a hash, it will convert the array
174 or hash to a scalar value (the length of an array, or the
175 population info of a hash) and then work on that scalar value.
176 This is probably not what you meant to do. See "grep" in perlfunc
177 and "map" in perlfunc for alternatives.
178 Arg too short for msgsnd
180 (F) msgsnd() requires a string at least as long as sizeof(long).
181 Argument "%s" isn't numeric%s
183 (W numeric) The indicated string was fed as an argument to an
184 operator that expected a numeric value instead. If you're
185 fortunate the message will identify which operator was so
186 unfortunate.
187 Note that for the "Inf" and "NaN" (infinity and not-a-number) the
189 definition of "numeric" is somewhat unusual: the strings themselves
190 (like "Inf") are considered numeric, and anything following them is
191 considered non-numeric.
192 Argument list not closed for PerlIO layer "%s"
194 (W layer) When pushing a layer with arguments onto the Perl I/O
195 system you forgot the ) that closes the argument list. (Layers
196 take care of transforming data between external and internal
197 representations.) Perl stopped parsing the layer list at this
198 point and did not attempt to push this layer. If your program
199 didn't explicitly request the failing operation, it may be the
200 result of the value of the environment variable PERLIO.
201 Argument "%s" treated as 0 in increment (++)
203 (W numeric) The indicated string was fed as an argument to the "++"
204 operator which expects either a number or a string matching
205 "/^[a-zA-Z]*[0-9]*\z/". See "Auto-increment and Auto-decrement" in
206 perlop for details.
207 Array passed to stat will be coerced to a scalar%s
209 (W syntax) You called stat() on an array, but the array will be
210 coerced to a scalar - the number of elements in the array.
211 A signature parameter must start with '$', '@' or '%'
213 (F) Each subroutine signature parameter declaration must start with
214 a valid sigil; for example:
215 sub foo ($a, $, $b = 1, @c) {}
217 A slurpy parameter may not have a default value
219 (F) Only scalar subroutine signature parameters may have a default
220 value; for example:
221 sub foo ($a = 1) {} # legal
223 sub foo (@a = (1)) {} # invalid
224 sub foo (%a = (a => b)) {} # invalid
225 assertion botched: %s
227 (X) The malloc package that comes with Perl had an internal
228 failure.
229 Assertion %s failed: file "%s", line %d
231 (X) A general assertion failed. The file in question must be
232 examined.
233 Assigned value is not a reference
235 (F) You tried to assign something that was not a reference to an
236 lvalue reference (e.g., "\$x = $y"). If you meant to make $x an
237 alias to $y, use "\$x = \$y".
238 Assigned value is not %s reference
240 (F) You tried to assign a reference to a reference constructor, but
241 the two references were not of the same type. You cannot alias a
242 scalar to an array, or an array to a hash; the two types must
243 match.
244 \$x = \@y; # error
246 \@x = \%y; # error
247 $y = [];
248 \$x = $y; # error; did you mean \$y?
249 Assigning non-zero to $[ is no longer possible
251 (F) When the "array_base" feature is disabled (e.g., and under "use
252 v5.16;", and as of Perl 5.30) the special variable $[, which is
253 deprecated, is now a fixed zero value.
254 Assignment to both a list and a scalar
256 (F) If you assign to a conditional operator, the 2nd and 3rd
257 arguments must either both be scalars or both be lists. Otherwise
258 Perl won't know which context to supply to the right side.
259 Assuming NOT a POSIX class since %s in regex; marked by <-- HERE in
261 m/%s/
262 (W regexp) You had something like these:
263 [[:alnum]]
265 [[:digit:xyz]
266 They look like they might have been meant to be the POSIX classes
268 "[:alnum:]" or "[:digit:]". If so, they should be written:
269 [[:alnum:]]
271 [[:digit:]xyz]
272 Since these aren't legal POSIX class specifications, but are legal
274 bracketed character classes, Perl treats them as the latter. In
275 the first example, it matches the characters ":", "[", "a", "l",
276 "m", "n", and "u".
277 If these weren't meant to be POSIX classes, this warning message is
279 spurious, and can be suppressed by reordering things, such as
280 [[al:num]]
282 or
284 [[:munla]]
286 <> at require-statement should be quotes
288 (F) You wrote "require <file>" when you should have written
289 "require 'file'".
290 Attempt to access disallowed key '%s' in a restricted hash
292 (F) The failing code has attempted to get or set a key which is not
293 in the current set of allowed keys of a restricted hash.
294 Attempt to bless into a freed package
296 (F) You wrote "bless $foo" with one argument after somehow causing
297 the current package to be freed. Perl cannot figure out what to
298 do, so it throws up its hands in despair.
299 Attempt to bless into a class
301 (F) You are attempting to call "bless" with a package name that is
302 a new-style "class". This is not necessary, as instances created
303 by the constructor are already in the correct class. Instances
304 cannot be created by other means, such as "bless".
305 Attempt to bless into a reference
307 (F) The CLASSNAME argument to the bless() operator is expected to
308 be the name of the package to bless the resulting object into.
309 You've supplied instead a reference to something: perhaps you wrote
310 bless $self, $proto;
312 when you intended
314 bless $self, ref($proto) || $proto;
316 If you actually want to bless into the stringified version of the
318 reference supplied, you need to stringify it yourself, for example
319 by:
320 bless $self, "$proto";
322 Attempt to clear deleted array
324 (S debugging) An array was assigned to when it was being freed.
325 Freed values are not supposed to be visible to Perl code. This can
326 also happen if XS code calls "av_clear" from a custom magic
327 callback on the array.
328 Attempt to delete disallowed key '%s' from a restricted hash
330 (F) The failing code attempted to delete from a restricted hash a
331 key which is not in its key set.
332 Attempt to delete readonly key '%s' from a restricted hash
334 (F) The failing code attempted to delete a key whose value has been
335 declared readonly from a restricted hash.
336 Attempt to free non-arena SV: 0x%x
338 (S internal) All SV objects are supposed to be allocated from
339 arenas that will be garbage collected on exit. An SV was
340 discovered to be outside any of those arenas.
341 Attempt to free nonexistent shared string '%s'%s
343 (S internal) Perl maintains a reference-counted internal table of
344 strings to optimize the storage and access of hash keys and other
345 strings. This indicates someone tried to decrement the reference
346 count of a string that can no longer be found in the table.
347 Attempt to free temp prematurely: SV 0x%x
349 (S debugging) Mortalized values are supposed to be freed by the
350 free_tmps() routine. This indicates that something else is freeing
351 the SV before the free_tmps() routine gets a chance, which means
352 that the free_tmps() routine will be freeing an unreferenced scalar
353 when it does try to free it.
354 Attempt to free unreferenced glob pointers
356 (S internal) The reference counts got screwed up on symbol aliases.
357 Attempt to free unreferenced scalar: SV 0x%x
359 (S internal) Perl went to decrement the reference count of a scalar
360 to see if it would go to 0, and discovered that it had already gone
361 to 0 earlier, and should have been freed, and in fact, probably was
362 freed. This could indicate that SvREFCNT_dec() was called too many
363 times, or that SvREFCNT_inc() was called too few times, or that the
364 SV was mortalized when it shouldn't have been, or that memory has
365 been corrupted.
366 Attempt to pack pointer to temporary value
368 (W pack) You tried to pass a temporary value (like the result of a
369 function, or a computed expression) to the "p" pack() template.
370 This means the result contains a pointer to a location that could
371 become invalid anytime, even before the end of the current
372 statement. Use literals or global values as arguments to the "p"
373 pack() template to avoid this warning.
374 Attempt to reload %s aborted.
376 (F) You tried to load a file with "use" or "require" that failed to
377 compile once already. Perl will not try to compile this file again
378 unless you delete its entry from %INC. See "require" in perlfunc
379 and "%INC" in perlvar.
380 Attempt to set length of freed array
382 (W misc) You tried to set the length of an array which has been
383 freed. You can do this by storing a reference to the scalar
384 representing the last index of an array and later assigning through
385 that reference. For example
386 $r = do {my @a; \$#a};
388 $$r = 503
389 Attempt to use reference as lvalue in substr
391 (W substr) You supplied a reference as the first argument to
392 substr() used as an lvalue, which is pretty strange. Perhaps you
393 forgot to dereference it first. See "substr" in perlfunc.
394 Attribute prototype(%s) discards earlier prototype attribute in same
396 sub
397 (W misc) A sub was declared as sub foo : prototype(A) :
398 prototype(B) {}, for example. Since each sub can only have one
399 prototype, the earlier declaration(s) are discarded while the last
400 one is applied.
401 av_reify called on tied array
403 (S debugging) This indicates that something went wrong and Perl got
404 very confused about @_ or @DB::args being tied.
405 Bad arg length for %s, is %u, should be %d
407 (F) You passed a buffer of the wrong size to one of msgctl(),
408 semctl() or shmctl(). In C parlance, the correct sizes are,
409 respectively, sizeof(struct msqid_ds *), sizeof(struct semid_ds *),
410 and sizeof(struct shmid_ds *).
411 Bad evalled substitution pattern
413 (F) You've used the "/e" switch to evaluate the replacement for a
414 substitution, but perl found a syntax error in the code to
415 evaluate, most likely an unexpected right brace '}'.
416 Bad filehandle: %s
418 (F) A symbol was passed to something wanting a filehandle, but the
419 symbol has no filehandle associated with it. Perhaps you didn't do
420 an open(), or did it in another package.
421 Bad free() ignored
423 (S malloc) An internal routine called free() on something that had
424 never been malloc()ed in the first place. Mandatory, but can be
425 disabled by setting environment variable "PERL_BADFREE" to 0.
426 This message can be seen quite often with DB_File on systems with
428 "hard" dynamic linking, like "AIX" and "OS/2". It is a bug of
429 "Berkeley DB" which is left unnoticed if "DB" uses forgiving system
430 malloc().
431 Bad infix plugin result (%zd) - did not consume entire identifier <%s>
433 (F) A plugin using the "PL_infix_plugin" mechanism to parse an
434 infix keyword consumed part of a named identifier operator name but
435 did not consume all of it. This is not permitted as it leads to
436 fragile parsing results.
437 Badly placed ()'s
439 (A) You've accidentally run your script through csh instead of
440 Perl. Check the #! line, or manually feed your script into Perl
441 yourself.
442 Bad name after %s
444 (F) You started to name a symbol by using a package prefix, and
445 then didn't finish the symbol. In particular, you can't
446 interpolate outside of quotes, so
447 $var = 'myvar';
449 $sym = mypack::$var;
450 is not the same as
452 $var = 'myvar';
454 $sym = "mypack::$var";
455 Bad plugin affecting keyword '%s'
457 (F) An extension using the keyword plugin mechanism violated the
458 plugin API.
459 Bad realloc() ignored
461 (S malloc) An internal routine called realloc() on something that
462 had never been malloc()ed in the first place. Mandatory, but can
463 be disabled by setting the environment variable "PERL_BADFREE" to
464 1.
465 Bad symbol for %s
467 (P) An internal request asked to add an entry of the named type to
468 something that wasn't a symbol table entry.
469 Bad symbol for scalar
471 (P) An internal request asked to add a scalar entry to something
472 that wasn't a symbol table entry.
473 Bareword found in conditional
475 (W bareword) The compiler found a bareword where it expected a
476 conditional, which often indicates that an || or && was parsed as
477 part of the last argument of the previous construct, for example:
478 open FOO || die;
480 It may also indicate a misspelled constant that has been
482 interpreted as a bareword:
483 use constant TYPO => 1;
485 if (TYOP) { print "foo" }
486 The "strict" pragma is useful in avoiding such errors.
488 Bareword in require contains "%s"
490 Bareword in require maps to disallowed filename "%s"
491 Bareword in require maps to empty filename
492 (F) The bareword form of require has been invoked with a filename
493 which could not have been generated by a valid bareword permitted
494 by the parser. You shouldn't be able to get this error from Perl
495 code, but XS code may throw it if it passes an invalid module name
496 to "Perl_load_module".
497 Bareword in require must not start with a double-colon: "%s"
499 (F) In "require Bare::Word", the bareword is not allowed to start
500 with a double-colon. Write "require ::Foo::Bar" as "require
501 Foo::Bar" instead.
502 Bareword "%s" not allowed while "strict subs" in use
504 (F) With "strict subs" in use, a bareword is only allowed as a
505 subroutine identifier, in curly brackets or to the left of the "=>"
506 symbol. Perhaps you need to predeclare a subroutine?
507 Bareword "%s" refers to nonexistent package
509 (W bareword) You used a qualified bareword of the form "Foo::", but
510 the compiler saw no other uses of that namespace before that point.
511 Perhaps you need to predeclare a package?
512 Bareword filehandle "%s" not allowed under 'no feature
514 "bareword_filehandles"'
515 (F) You attempted to use a bareword filehandle with the
516 "bareword_filehandles" feature disabled.
517 Only the built-in handles "STDIN", "STDOUT", "STDERR", "ARGV",
519 "ARGVOUT" and "DATA" can be used with the "bareword_filehandles"
520 feature disabled.
521 BEGIN failed--compilation aborted
523 (F) An untrapped exception was raised while executing a BEGIN
524 subroutine. Compilation stops immediately and the interpreter is
525 exited.
526 BEGIN not safe after errors--compilation aborted
528 (F) Perl found a "BEGIN {}" subroutine (or a "use" directive, which
529 implies a "BEGIN {}") after one or more compilation errors had
530 already occurred. Since the intended environment for the "BEGIN
531 {}" could not be guaranteed (due to the errors), and since
532 subsequent code likely depends on its correct operation, Perl just
533 gave up.
534 \%d better written as $%d
536 (W syntax) Outside of patterns, backreferences live on as
537 variables. The use of backslashes is grandfathered on the right-
538 hand side of a substitution, but stylistically it's better to use
539 the variable form because other Perl programmers will expect it,
540 and it works better if there are more than 9 backreferences.
541 Binary number > 0b11111111111111111111111111111111 non-portable
543 (W portable) The binary number you specified is larger than 2**32-1
544 (4294967295) and therefore non-portable between systems. See
545 perlport for more on portability concerns.
546 bind() on closed socket %s
548 (W closed) You tried to do a bind on a closed socket. Did you
549 forget to check the return value of your socket() call? See "bind"
550 in perlfunc.
551 binmode() on closed filehandle %s
553 (W unopened) You tried binmode() on a filehandle that was never
554 opened. Check your control flow and number of arguments.
555 Bit vector size > 32 non-portable
557 (W portable) Using bit vector sizes larger than 32 is non-portable.
558 Bizarre copy of %s
560 (P) Perl detected an attempt to copy an internal value that is not
561 copiable.
562 Bizarre SvTYPE [%d]
564 (P) When starting a new thread or returning values from a thread,
565 Perl encountered an invalid data type.
566 Both or neither range ends should be Unicode in regex; marked by
568 <-- HERE in m/%s/
569 (W regexp) (only under "use re 'strict'" or within "(?[...])")
570 In a bracketed character class in a regular expression pattern, you
572 had a range which has exactly one end of it specified using "\N{}",
573 and the other end is specified using a non-portable mechanism.
574 Perl treats the range as a Unicode range, that is, all the
575 characters in it are considered to be the Unicode characters, and
576 which may be different code points on some platforms Perl runs on.
577 For example, "[\N{U+06}-\x08]" is treated as if you had instead
578 said "[\N{U+06}-\N{U+08}]", that is it matches the characters whose
579 code points in Unicode are 6, 7, and 8. But that "\x08" might
580 indicate that you meant something different, so the warning gets
581 raised.
582 Buffer overflow in prime_env_iter: %s
584 (W internal) A warning peculiar to VMS. While Perl was preparing
585 to iterate over %ENV, it encountered a logical name or symbol
586 definition which was too long, so it was truncated to the string
587 shown.
588 Built-in function '%s' is experimental
590 (S experimental::builtin) A call is being made to a function in the
591 "builtin::" namespace, which is currently experimental. The
592 existence or nature of the function may be subject to change in a
593 future version of Perl.
594 builtin::import can only be called at compile time
596 (F) The "import" method of the "builtin" package was invoked when
597 no code is currently being compiled. Since this method is used to
598 introduce new lexical subroutines into the scope currently being
599 compiled, this is not going to have any effect.
600 Callback called exit
602 (F) A subroutine invoked from an external package via call_sv()
603 exited by calling exit.
604 %s() called too early to check prototype
606 (W prototype) You've called a function that has a prototype before
607 the parser saw a definition or declaration for it, and Perl could
608 not check that the call conforms to the prototype. You need to
609 either add an early prototype declaration for the subroutine in
610 question, or move the subroutine definition ahead of the call to
611 get proper prototype checking. Alternatively, if you are certain
612 that you're calling the function correctly, you may put an
613 ampersand before the name to avoid the warning. See perlsub.
614 Cannot assign :param(%s) to field %s because that name is already in
616 use
617 (F) An attempt was made to apply a parameter name to a field, when
618 the name is already being used by another field in the same class,
619 or one of its parent classes. This would cause a name clash so is
620 not allowed.
621 Cannot chr %f
623 (F) You passed an invalid number (like an infinity or not-a-number)
624 to "chr".
625 Cannot complete in-place edit of %s: %s
627 (F) Your perl script appears to have changed directory while
628 performing an in-place edit of a file specified by a relative path,
629 and your system doesn't include the directory relative POSIX
630 functions needed to handle that.
631 Cannot compress %f in pack
633 (F) You tried compressing an infinity or not-a-number as an
634 unsigned integer with BER, which makes no sense.
635 Cannot compress integer in pack
637 (F) An argument to pack("w",...) was too large to compress. The
638 BER compressed integer format can only be used with positive
639 integers, and you attempted to compress a very large number (>
640 1e308). See "pack" in perlfunc.
641 Cannot compress negative numbers in pack
643 (F) An argument to pack("w",...) was negative. The BER compressed
644 integer format can only be used with positive integers. See "pack"
645 in perlfunc.
646 Cannot convert a reference to %s to typeglob
648 (F) You manipulated Perl's symbol table directly, stored a
649 reference in it, then tried to access that symbol via conventional
650 Perl syntax. The access triggers Perl to autovivify that typeglob,
651 but it there is no legal conversion from that type of reference to
652 a typeglob.
653 Cannot copy to %s
655 (P) Perl detected an attempt to copy a value to an internal type
656 that cannot be directly assigned to.
657 Cannot create class %s as it already has a non-empty @ISA
659 (F) An attempt was made to create a class out of a package that
660 already has an @ISA array, and the array is not empty. This is not
661 permitted, as it would lead to a class with inconsistent
662 inheritance.
663 Cannot find encoding "%s"
665 (S io) You tried to apply an encoding that did not exist to a
666 filehandle, either with open() or binmode().
667 Cannot invoke a method of "%s" on an instance of "%s"
669 (F) You tried to directly call a "method" subroutine of one class
670 by passing in a value that is an instance of a different class.
671 This is not permitted, as the method would not have access to the
672 correct instance fields.
673 Cannot invoke method on a non-instance
675 (F) You tried to directly call a "method" subroutine of a class by
676 passing in a value that is not an instance of that class. This is
677 not permitted, as the method would not then have access to its
678 instance fields.
679 Cannot open %s as a dirhandle: it is already open as a filehandle
681 (F) You tried to use opendir() to associate a dirhandle to a symbol
682 (glob or scalar) that already holds a filehandle. Since this idiom
683 might render your code confusing, it was deprecated in Perl 5.10.
684 As of Perl 5.28, it is a fatal error.
685 Cannot open %s as a filehandle: it is already open as a dirhandle
687 (F) You tried to use open() to associate a filehandle to a symbol
688 (glob or scalar) that already holds a dirhandle. Since this idiom
689 might render your code confusing, it was deprecated in Perl 5.10.
690 As of Perl 5.28, it is a fatal error.
691 Cannot '%s' outside of a 'class'
693 (F) You attempted to use one of the keywords that only makes sense
694 inside a "class" definition, at a location that is not inside such
695 a class.
696 Cannot pack %f with '%c'
698 (F) You tried converting an infinity or not-a-number to an integer,
699 which makes no sense.
700 Cannot printf %f with '%c'
702 (F) You tried printing an infinity or not-a-number as a character
703 (%c), which makes no sense. Maybe you meant '%s', or just
704 stringifying it?
705 Cannot reopen existing class "%s"
707 (F) You tried to begin a "class" definition for a class that
708 already exists. A class may only have one definition block.
709 Cannot set tied @DB::args
711 (F) "caller" tried to set @DB::args, but found it tied. Tying
712 @DB::args is not supported. (Before this error was added, it used
713 to crash.)
714 Cannot tie unreifiable array
716 (P) You somehow managed to call "tie" on an array that does not
717 keep a reference count on its arguments and cannot be made to do
718 so. Such arrays are not even supposed to be accessible to Perl
719 code, but are only used internally.
720 Cannot yet reorder sv_vcatpvfn() arguments from va_list
722 (F) Some XS code tried to use sv_vcatpvfn() or a related function
723 with a format string that specifies explicit indexes for some of
724 the elements, and using a C-style variable-argument list (a
725 "va_list"). This is not currently supported. XS authors wanting
726 to do this must instead construct a C array of "SV*" scalars
727 containing the arguments.
728 Can only compress unsigned integers in pack
730 (F) An argument to pack("w",...) was not an integer. The BER
731 compressed integer format can only be used with positive integers,
732 and you attempted to compress something else. See "pack" in
733 perlfunc.
734 Can't "%s" out of a "defer" block
736 (F) An attempt was made to jump out of the scope of a "defer" block
737 by using a control-flow statement such as "return", "goto" or a
738 loop control. This is not permitted.
739 Can't "%s" out of a "finally" block
741 (F) Similar to above, but involving a "finally" block at the end of
742 a "try"/"catch" construction rather than a "defer" block.
743 Can't bless an object reference
745 (F) You attempted to call "bless" on a value that already refers to
746 a real object instance.
747 Can't bless non-reference value
749 (F) Only hard references may be blessed. This is how Perl
750 "enforces" encapsulation of objects. See perlobj.
751 Can't "break" in a loop topicalizer
753 (F) You called "break", but you're in a "foreach" block rather than
754 a "given" block. You probably meant to use "next" or "last".
755 Can't "break" outside a given block
757 (F) You called "break", but you're not inside a "given" block.
758 Can't call destructor for 0x%p in global destruction
760 (S) This should not happen. Internals code has set up a destructor
761 using "mortal_destructor_sv" or "mortal_destructor_x" which is
762 firing during global destruction. Please attempt to reduce the code
763 that triggers this warning down to a small an example as possible
764 and then report the problem to
765 <https://github.com/Perl/perl5/issues/new/choose>
766 Can't call method "%s" on an undefined value
768 (F) You used the syntax of a method call, but the slot filled by
769 the object reference or package name contains an undefined value.
770 Something like this will reproduce the error:
771 $BADREF = undef;
773 process $BADREF 1,2,3;
774 $BADREF->process(1,2,3);
775 Can't call method "%s" on unblessed reference
777 (F) A method call must know in what package it's supposed to run.
778 It ordinarily finds this out from the object reference you supply,
779 but you didn't supply an object reference in this case. A
780 reference isn't an object reference until it has been blessed. See
781 perlobj.
782 Can't call method "%s" without a package or object reference
784 (F) You used the syntax of a method call, but the slot filled by
785 the object reference or package name contains an expression that
786 returns a defined value which is neither an object reference nor a
787 package name. Something like this will reproduce the error:
788 $BADREF = 42;
790 process $BADREF 1,2,3;
791 $BADREF->process(1,2,3);
792 Can't call mro_isa_changed_in() on anonymous symbol table
794 (P) Perl got confused as to whether a hash was a plain hash or a
795 symbol table hash when trying to update @ISA caches.
796 Can't call mro_method_changed_in() on anonymous symbol table
798 (F) An XS module tried to call "mro_method_changed_in" on a hash
799 that was not attached to the symbol table.
800 Can't chdir to %s
802 (F) You called "perl -x/foo/bar", but /foo/bar is not a directory
803 that you can chdir to, possibly because it doesn't exist.
804 Can't coerce %s to %s in %s
806 (F) Certain types of SVs, in particular real symbol table entries
807 (typeglobs), can't be forced to stop being what they are. So you
808 can't say things like:
809 *foo += 1;
811 You CAN say
813 $foo = *foo;
815 $foo += 1;
816 but then $foo no longer contains a glob.
818 Can't "continue" outside a when block
820 (F) You called "continue", but you're not inside a "when" or
821 "default" block.
822 can't convert empty path
824 (F) On Cygwin, you called a path conversion function with an empty
825 path. Only non-empty paths are legal.
826 Can't create pipe mailbox
828 (P) An error peculiar to VMS. The process is suffering from
829 exhausted quotas or other plumbing problems.
830 Can't declare %s in "%s"
832 (F) Only scalar, array, and hash variables may be declared as "my",
833 "our" or "state" variables. They must have ordinary identifiers as
834 names.
835 Can't "default" outside a topicalizer
837 (F) You have used a "default" block that is neither inside a
838 "foreach" loop nor a "given" block. (Note that this error is
839 issued on exit from the "default" block, so you won't get the error
840 if you use an explicit "continue".)
841 Can't determine class of operator %s, assuming BASEOP
843 (S) This warning indicates something wrong in the internals of
844 perl. Perl was trying to find the class (e.g. LISTOP) of a
845 particular OP, and was unable to do so. This is likely to be due to
846 a bug in the perl internals, or due to a bug in XS code which
847 manipulates perl optrees.
848 Can't do inplace edit: %s is not a regular file
850 (S inplace) You tried to use the -i switch on a special file, such
851 as a file in /dev, a FIFO or an uneditable directory. The file was
852 ignored.
853 Can't do inplace edit on %s: %s
855 (S inplace) The creation of the new file failed for the indicated
856 reason.
857 Can't do inplace edit: %s would not be unique
859 (S inplace) Your filesystem does not support filenames longer than
860 14 characters and Perl was unable to create a unique filename
861 during inplace editing with the -i switch. The file was ignored.
862 Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".
864 (W locale) You are 1) running under ""use locale""; 2) the current
865 locale is not a UTF-8 one; 3) you tried to do the designated case-
866 change operation on the specified Unicode character; and 4) the
867 result of this operation would mix Unicode and locale rules, which
868 likely conflict. Mixing of different rule types is forbidden, so
869 the operation was not done; instead the result is the indicated
870 value, which is the best available that uses entirely Unicode
871 rules. That turns out to almost always be the original character,
872 unchanged.
873 It is generally a bad idea to mix non-UTF-8 locales and Unicode,
875 and this issue is one of the reasons why. This warning is raised
876 when Unicode rules would normally cause the result of this
877 operation to contain a character that is in the range specified by
878 the locale, 0..255, and hence is subject to the locale's rules, not
879 Unicode's.
880 If you are using locale purely for its characteristics related to
882 things like its numeric and time formatting (and not "LC_CTYPE"),
883 consider using a restricted form of the locale pragma (see "The
884 "use locale" pragma" in perllocale) like
885 ""use locale ':not_characters'"".
886 Note that failed case-changing operations done as a result of case-
888 insensitive "/i" regular expression matching will show up in this
889 warning as having the "fc" operation (as that is what the regular
890 expression engine calls behind the scenes.)
891 Can't do waitpid with flags
893 (F) This machine doesn't have either waitpid() or wait4(), so only
894 waitpid() without flags is emulated.
895 Can't emulate -%s on #! line
897 (F) The #! line specifies a switch that doesn't make sense at this
898 point. For example, it'd be kind of silly to put a -x on the #!
899 line.
900 Can't %s %s-endian %ss on this platform
902 (F) Your platform's byte-order is neither big-endian nor little-
903 endian, or it has a very strange pointer size. Packing and
904 unpacking big- or little-endian floating point values and pointers
905 may not be possible. See "pack" in perlfunc.
906 Can't exec "%s": %s
908 (W exec) A system(), exec(), or piped open call could not execute
909 the named program for the indicated reason. Typical reasons
910 include: the permissions were wrong on the file, the file wasn't
911 found in $ENV{PATH}, the executable in question was compiled for
912 another architecture, or the #! line in a script points to an
913 interpreter that can't be run for similar reasons. (Or maybe your
914 system doesn't support #! at all.)
915 Can't exec %s
917 (F) Perl was trying to execute the indicated program for you
918 because that's what the #! line said. If that's not what you
919 wanted, you may need to mention "perl" on the #! line somewhere.
920 Can't execute %s
922 (F) You used the -S switch, but the copies of the script to execute
923 found in the PATH did not have correct permissions.
924 Can't find an opnumber for "%s"
926 (F) A string of a form "CORE::word" was given to prototype(), but
927 there is no builtin with the name "word".
928 Can't find label %s
930 (F) You said to goto a label that isn't mentioned anywhere that
931 it's possible for us to go to. See "goto" in perlfunc.
932 Can't find %s on PATH
934 (F) You used the -S switch, but the script to execute could not be
935 found in the PATH.
936 Can't find %s on PATH, '.' not in PATH
938 (F) You used the -S switch, but the script to execute could not be
939 found in the PATH, or at least not with the correct permissions.
940 The script exists in the current directory, but PATH prohibits
941 running it.
942 Can't find string terminator %s anywhere before EOF
944 (F) Perl strings can stretch over multiple lines. This message
945 means that the closing delimiter was omitted. Because bracketed
946 quotes count nesting levels, the following is missing its final
947 parenthesis:
948 print q(The character '(' starts a side comment.);
950 If you're getting this error from a here-document, you may have
952 included unseen whitespace before or after your closing tag or
953 there may not be a linebreak after it. A good programmer's editor
954 will have a way to help you find these characters (or lack of
955 characters). See perlop for the full details on here-documents.
956 Can't find Unicode property definition "%s"
958 Can't find Unicode property definition "%s" in regex; marked by <--
959 HERE in m/%s/
960 (F) The named property which you specified via "\p" or "\P" is not
961 one known to Perl. Perhaps you misspelled the name? See
962 "Properties accessible through \p{} and \P{}" in perluniprops for a
963 complete list of available official properties. If it is a user-
964 defined property it must have been defined by the time the regular
965 expression is matched.
966 If you didn't mean to use a Unicode property, escape the "\p",
968 either by "\\p" (just the "\p") or by "\Q\p" (the rest of the
969 string, or until "\E").
970 Can't fork: %s
972 (F) A fatal error occurred while trying to fork while opening a
973 pipeline.
974 Can't fork, trying again in 5 seconds
976 (W pipe) A fork in a piped open failed with EAGAIN and will be
977 retried after five seconds.
978 Can't get filespec - stale stat buffer?
980 (S) A warning peculiar to VMS. This arises because of the
981 difference between access checks under VMS and under the Unix model
982 Perl assumes. Under VMS, access checks are done by filename,
983 rather than by bits in the stat buffer, so that ACLs and other
984 protections can be taken into account. Unfortunately, Perl assumes
985 that the stat buffer contains all the necessary information, and
986 passes it, instead of the filespec, to the access-checking routine.
987 It will try to retrieve the filespec using the device name and FID
988 present in the stat buffer, but this works only if you haven't made
989 a subsequent call to the CRTL stat() routine, because the device
990 name is overwritten with each call. If this warning appears, the
991 name lookup failed, and the access-checking routine gave up and
992 returned FALSE, just to be conservative. (Note: The access-
993 checking routine knows about the Perl "stat" operator and file
994 tests, so you shouldn't ever see this warning in response to a Perl
995 command; it arises only if some internal code takes stat buffers
996 lightly.)
997 Can't get pipe mailbox device name
999 (P) An error peculiar to VMS. After creating a mailbox to act as a
1000 pipe, Perl can't retrieve its name for later use.
1001 Can't get SYSGEN parameter value for MAXBUF
1003 (P) An error peculiar to VMS. Perl asked $GETSYI how big you want
1004 your mailbox buffers to be, and didn't get an answer.
1005 Can't "goto" into a binary or list expression
1007 (F) A "goto" statement was executed to jump into the middle of a
1008 binary or list expression. You can't get there from here. The
1009 reason for this restriction is that the interpreter would get
1010 confused as to how many arguments there are, resulting in stack
1011 corruption or crashes. This error occurs in cases such as these:
1012 goto F;
1014 print do { F: }; # Can't jump into the arguments to print
1015 goto G;
1017 $x + do { G: $y }; # How is + supposed to get its first operand?
1018 Can't "goto" into a "defer" block
1020 (F) A "goto" statement was executed to jump into the scope of a
1021 "defer" block. This is not permitted.
1022 Can't "goto" into a "given" block
1024 (F) A "goto" statement was executed to jump into the middle of a
1025 "given" block. You can't get there from here. See "goto" in
1026 perlfunc.
1027 Can't "goto" into the middle of a foreach loop
1029 (F) A "goto" statement was executed to jump into the middle of a
1030 foreach loop. You can't get there from here. See "goto" in
1031 perlfunc.
1032 Can't "goto" out of a pseudo block
1034 (F) A "goto" statement was executed to jump out of what might look
1035 like a block, except that it isn't a proper block. This usually
1036 occurs if you tried to jump out of a sort() block or subroutine,
1037 which is a no-no. See "goto" in perlfunc.
1038 Can't goto subroutine from an eval-%s
1040 (F) The "goto subroutine" call can't be used to jump out of an eval
1041 "string" or block.
1042 Can't goto subroutine from a sort sub (or similar callback)
1044 (F) The "goto subroutine" call can't be used to jump out of the
1045 comparison sub for a sort(), or from a similar callback (such as
1046 the reduce() function in List::Util).
1047 Can't goto subroutine outside a subroutine
1049 (F) The deeply magical "goto subroutine" call can only replace one
1050 subroutine call for another. It can't manufacture one out of whole
1051 cloth. In general you should be calling it out of only an AUTOLOAD
1052 routine anyway. See "goto" in perlfunc.
1053 Can't ignore signal CHLD, forcing to default
1055 (W signal) Perl has detected that it is being run with the SIGCHLD
1056 signal (sometimes known as SIGCLD) disabled. Since disabling this
1057 signal will interfere with proper determination of exit status of
1058 child processes, Perl has reset the signal to its default value.
1059 This situation typically indicates that the parent program under
1060 which Perl may be running (e.g. cron) is being very careless.
1061 Can't kill a non-numeric process ID
1063 (F) Process identifiers must be (signed) integers. It is a fatal
1064 error to attempt to kill() an undefined, empty-string or otherwise
1065 non-numeric process identifier.
1066 Can't "last" outside a loop block
1068 (F) A "last" statement was executed to break out of the current
1069 block, except that there's this itty bitty problem called there
1070 isn't a current block. Note that an "if" or "else" block doesn't
1071 count as a "loopish" block, as doesn't a block given to sort(),
1072 map() or grep(). You can usually double the curlies to get the
1073 same effect though, because the inner curlies will be considered a
1074 block that loops once. See "last" in perlfunc.
1075 Can't linearize anonymous symbol table
1077 (F) Perl tried to calculate the method resolution order (MRO) of a
1078 package, but failed because the package stash has no name.
1079 Can't load '%s' for module %s
1081 (F) The module you tried to load failed to load a dynamic
1082 extension. This may either mean that you upgraded your version of
1083 perl to one that is incompatible with your old dynamic extensions
1084 (which is known to happen between major versions of perl), or (more
1085 likely) that your dynamic extension was built against an older
1086 version of the library that is installed on your system. You may
1087 need to rebuild your old dynamic extensions.
1088 Can't localize lexical variable %s
1090 (F) You used local on a variable name that was previously declared
1091 as a lexical variable using "my" or "state". This is not allowed.
1092 If you want to localize a package variable of the same name,
1093 qualify it with the package name.
1094 Can't localize through a reference
1096 (F) You said something like "local $$ref", which Perl can't
1097 currently handle, because when it goes to restore the old value of
1098 whatever $ref pointed to after the scope of the local() is
1099 finished, it can't be sure that $ref will still be a reference.
1100 Can't locate %s
1102 (F) You said to "do" (or "require", or "use") a file that couldn't
1103 be found. Perl looks for the file in all the locations mentioned
1104 in @INC, unless the file name included the full path to the file.
1105 Perhaps you need to set the PERL5LIB or PERL5OPT environment
1106 variable to say where the extra library is, or maybe the script
1107 needs to add the library name to @INC. Or maybe you just
1108 misspelled the name of the file. See "require" in perlfunc and
1109 lib.
1110 Can't locate auto/%s.al in @INC
1112 (F) A function (or method) was called in a package which allows
1113 autoload, but there is no function to autoload. Most probable
1114 causes are a misprint in a function/method name or a failure to
1115 "AutoSplit" the file, say, by doing "make install".
1116 Can't locate loadable object for module %s in @INC
1118 (F) The module you loaded is trying to load an external library,
1119 like for example, foo.so or bar.dll, but the DynaLoader module was
1120 unable to locate this library. See DynaLoader.
1121 Can't locate object method "%s" via package "%s"
1123 (F) You called a method correctly, and it correctly indicated a
1124 package functioning as a class, but that package doesn't define
1125 that particular method, nor does any of its base classes. See
1126 perlobj.
1127 Can't locate object method "%s" via package "%s" (perhaps you forgot to
1129 load "%s"?)
1130 (F) You called a method on a class that did not exist, and the
1131 method could not be found in UNIVERSAL. This often means that a
1132 method requires a package that has not been loaded.
1133 Can't locate object method "INC", nor "INCDIR" nor string overload via
1135 package "%s" %s in @INC
1136 (F) You pushed an object, either directly or via an array reference
1137 hook, into @INC, but the object doesn't support any known hook
1138 methods, nor a string overload and is also not a blessed CODE
1139 reference. In short the "require" function does not know what to do
1140 with the object. See also "require" in perlfunc.
1141 Can't locate package %s for @%s::ISA
1143 (W syntax) The @ISA array contained the name of another package
1144 that doesn't seem to exist.
1145 Can't locate PerlIO%s
1147 (F) You tried to use in open() a PerlIO layer that does not exist,
1148 e.g. open(FH, ">:nosuchlayer", "somefile").
1149 Can't make list assignment to %ENV on this system
1151 (F) List assignment to %ENV is not supported on some systems,
1152 notably VMS.
1153 Can't make loaded symbols global on this platform while loading %s
1155 (S) A module passed the flag 0x01 to DynaLoader::dl_load_file() to
1156 request that symbols from the stated file are made available
1157 globally within the process, but that functionality is not
1158 available on this platform. Whilst the module likely will still
1159 work, this may prevent the perl interpreter from loading other XS-
1160 based extensions which need to link directly to functions defined
1161 in the C or XS code in the stated file.
1162 Can't modify %s in %s
1164 (F) You aren't allowed to assign to the item indicated, or
1165 otherwise try to change it, such as with an auto-increment.
1166 Can't modify non-lvalue subroutine call of &%s
1168 Can't modify non-lvalue subroutine call of &%s in %s
1169 (F) Subroutines meant to be used in lvalue context should be
1170 declared as such. See "Lvalue subroutines" in perlsub.
1171 Can't modify reference to %s in %s assignment
1173 (F) Only a limited number of constructs can be used as the argument
1174 to a reference constructor on the left-hand side of an assignment,
1175 and what you used was not one of them. See "Assigning to
1176 References" in perlref.
1177 Can't modify reference to localized parenthesized array in list
1179 assignment
1180 (F) Assigning to "\local(@array)" or "\(local @array)" is not
1181 supported, as it is not clear exactly what it should do. If you
1182 meant to make @array refer to some other array, use "\@array =
1183 \@other_array". If you want to make the elements of @array aliases
1184 of the scalars referenced on the right-hand side, use "\(@array) =
1185 @scalar_refs".
1186 Can't modify reference to parenthesized hash in list assignment
1188 (F) Assigning to "\(%hash)" is not supported. If you meant to make
1189 %hash refer to some other hash, use "\%hash = \%other_hash". If
1190 you want to make the elements of %hash into aliases of the scalars
1191 referenced on the right-hand side, use a hash slice: "\@hash{@keys}
1192 = @those_scalar_refs".
1193 Can't msgrcv to read-only var
1195 (F) The target of a msgrcv must be modifiable to be used as a
1196 receive buffer.
1197 Can't "next" outside a loop block
1199 (F) A "next" statement was executed to reiterate the current block,
1200 but there isn't a current block. Note that an "if" or "else" block
1201 doesn't count as a "loopish" block, as doesn't a block given to
1202 sort(), map() or grep(). You can usually double the curlies to get
1203 the same effect though, because the inner curlies will be
1204 considered a block that loops once. See "next" in perlfunc.
1205 Can't open %s: %s
1207 (S inplace) The implicit opening of a file through use of the "<>"
1208 filehandle, either implicitly under the "-n" or "-p" command-line
1209 switches, or explicitly, failed for the indicated reason. Usually
1210 this is because you don't have read permission for a file which you
1211 named on the command line.
1212 (F) You tried to call perl with the -e switch, but /dev/null (or
1214 your operating system's equivalent) could not be opened.
1215 Can't open a reference
1217 (W io) You tried to open a scalar reference for reading or writing,
1218 using the 3-arg open() syntax:
1219 open FH, '>', $ref;
1221 but your version of perl is compiled without perlio, and this form
1223 of open is not supported.
1224 Can't open bidirectional pipe
1226 (W pipe) You tried to say "open(CMD, "|cmd|")", which is not
1227 supported. You can try any of several modules in the Perl library
1228 to do this, such as IPC::Open2. Alternately, direct the pipe's
1229 output to a file using ">", and then read it in under a different
1230 file handle.
1231 Can't open error file %s as stderr
1233 (F) An error peculiar to VMS. Perl does its own command line
1234 redirection, and couldn't open the file specified after '2>' or
1235 '2>>' on the command line for writing.
1236 Can't open input file %s as stdin
1238 (F) An error peculiar to VMS. Perl does its own command line
1239 redirection, and couldn't open the file specified after '<' on the
1240 command line for reading.
1241 Can't open output file %s as stdout
1243 (F) An error peculiar to VMS. Perl does its own command line
1244 redirection, and couldn't open the file specified after '>' or '>>'
1245 on the command line for writing.
1246 Can't open output pipe (name: %s)
1248 (P) An error peculiar to VMS. Perl does its own command line
1249 redirection, and couldn't open the pipe into which to send data
1250 destined for stdout.
1251 Can't open perl script "%s": %s
1253 (F) The script you specified can't be opened for the indicated
1254 reason.
1255 If you're debugging a script that uses #!, and normally relies on
1257 the shell's $PATH search, the -S option causes perl to do that
1258 search, so you don't have to type the path or `which $scriptname`.
1259 Can't read CRTL environ
1261 (S) A warning peculiar to VMS. Perl tried to read an element of
1262 %ENV from the CRTL's internal environment array and discovered the
1263 array was missing. You need to figure out where your CRTL
1264 misplaced its environ or define PERL_ENV_TABLES (see perlvms) so
1265 that environ is not searched.
1266 Can't redeclare "%s" in "%s"
1268 (F) A "my", "our" or "state" declaration was found within another
1269 declaration, such as "my ($x, my($y), $z)" or "our (my $x)".
1270 Can't "redo" outside a loop block
1272 (F) A "redo" statement was executed to restart the current block,
1273 but there isn't a current block. Note that an "if" or "else" block
1274 doesn't count as a "loopish" block, as doesn't a block given to
1275 sort(), map() or grep(). You can usually double the curlies to get
1276 the same effect though, because the inner curlies will be
1277 considered a block that loops once. See "redo" in perlfunc.
1278 Can't remove %s: %s, skipping file
1280 (S inplace) You requested an inplace edit without creating a backup
1281 file. Perl was unable to remove the original file to replace it
1282 with the modified file. The file was left unmodified.
1283 Can't rename in-place work file '%s' to '%s': %s
1285 (F) When closed implicitly, the temporary file for in-place editing
1286 couldn't be renamed to the original filename.
1287 Can't rename %s to %s: %s, skipping file
1289 (F) The rename done by the -i switch failed for some reason,
1290 probably because you don't have write permission to the directory.
1291 Can't reopen input pipe (name: %s) in binary mode
1293 (P) An error peculiar to VMS. Perl thought stdin was a pipe, and
1294 tried to reopen it to accept binary data. Alas, it failed.
1295 Can't represent character for Ox%X on this platform
1297 (F) There is a hard limit to how big a character code point can be
1298 due to the fundamental properties of UTF-8, especially on EBCDIC
1299 platforms. The given code point exceeds that. The only work-
1300 around is to not use such a large code point.
1301 Can't reset %ENV on this system
1303 (F) You called reset('E') or similar, which tried to reset all
1304 variables in the current package beginning with "E". In the main
1305 package, that includes %ENV. Resetting %ENV is not supported on
1306 some systems, notably VMS.
1307 Can't resolve method "%s" overloading "%s" in package "%s"
1309 (F)(P) Error resolving overloading specified by a method name (as
1310 opposed to a subroutine reference): no such method callable via the
1311 package. If the method name is "???", this is an internal error.
1312 Can't return %s from lvalue subroutine
1314 (F) Perl detected an attempt to return illegal lvalues (such as
1315 temporary or readonly values) from a subroutine used as an lvalue.
1316 This is not allowed.
1317 Can't return outside a subroutine
1319 (F) The return statement was executed in mainline code, that is,
1320 where there was no subroutine call to return out of. See perlsub.
1321 Can't return %s to lvalue scalar context
1323 (F) You tried to return a complete array or hash from an lvalue
1324 subroutine, but you called the subroutine in a way that made Perl
1325 think you meant to return only one value. You probably meant to
1326 write parentheses around the call to the subroutine, which tell
1327 Perl that the call should be in list context.
1328 Can't take log of %g
1330 (F) For ordinary real numbers, you can't take the logarithm of a
1331 negative number or zero. There's a Math::Complex package that
1332 comes standard with Perl, though, if you really want to do that for
1333 the negative numbers.
1334 Can't take sqrt of %g
1336 (F) For ordinary real numbers, you can't take the square root of a
1337 negative number. There's a Math::Complex package that comes
1338 standard with Perl, though, if you really want to do that.
1339 Can't undef active subroutine
1341 (F) You can't undefine a routine that's currently running. You
1342 can, however, redefine it while it's running, and you can even
1343 undef the redefined subroutine while the old routine is running.
1344 Go figure.
1345 Can't unweaken a nonreference
1347 (F) You attempted to unweaken something that was not a reference.
1348 Only references can be unweakened.
1349 Can't upgrade %s (%d) to %d
1351 (P) The internal sv_upgrade routine adds "members" to an SV, making
1352 it into a more specialized kind of SV. The top several SV types
1353 are so specialized, however, that they cannot be interconverted.
1354 This message indicates that such a conversion was attempted.
1355 Can't use '%c' after -mname
1357 (F) You tried to call perl with the -m switch, but you put
1358 something other than "=" after the module name.
1359 Can't use a hash as a reference
1361 (F) You tried to use a hash as a reference, as in "%foo->{"bar"}"
1362 or "%$ref->{"hello"}". Versions of perl <= 5.22.0 used to allow
1363 this syntax, but shouldn't have. This was deprecated in perl
1364 5.6.1.
1365 Can't use an array as a reference
1367 (F) You tried to use an array as a reference, as in "@foo->[23]" or
1368 "@$ref->[99]". Versions of perl <= 5.22.0 used to allow this
1369 syntax, but shouldn't have. This was deprecated in perl 5.6.1.
1370 Can't use anonymous symbol table for method lookup
1372 (F) The internal routine that does method lookup was handed a
1373 symbol table that doesn't have a name. Symbol tables can become
1374 anonymous for example by undefining stashes: "undef
1375 %Some::Package::".
1376 Can't use an undefined value as %s reference
1378 (F) A value used as either a hard reference or a symbolic reference
1379 must be a defined value. This helps to delurk some insidious
1380 errors.
1381 Can't use bareword ("%s") as %s ref while "strict refs" in use
1383 (F) Only hard references are allowed by "strict refs". Symbolic
1384 references are disallowed. See perlref.
1385 Can't use %! because Errno.pm is not available
1387 (F) The first time the "%!" hash is used, perl automatically loads
1388 the Errno.pm module. The Errno module is expected to tie the %!
1389 hash to provide symbolic names for $! errno values.
1390 Can't use both '<' and '>' after type '%c' in %s
1392 (F) A type cannot be forced to have both big-endian and little-
1393 endian byte-order at the same time, so this combination of
1394 modifiers is not allowed. See "pack" in perlfunc.
1395 Can't use 'defined(@array)' (Maybe you should just omit the defined()?)
1397 (F) defined() is not useful on arrays because it checks for an
1398 undefined scalar value. If you want to see if the array is empty,
1399 just use "if (@array) { # not empty }" for example.
1400 Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)
1402 (F) defined() is not usually right on hashes.
1403 Although "defined %hash" is false on a plain not-yet-used hash, it
1405 becomes true in several non-obvious circumstances, including
1406 iterators, weak references, stash names, even remaining true after
1407 "undef %hash". These things make "defined %hash" fairly useless in
1408 practice, so it now generates a fatal error.
1409 If a check for non-empty is what you wanted then just put it in
1411 boolean context (see "Scalar values" in perldata):
1412 if (%hash) {
1414 # not empty
1415 }
1416 If you had "defined %Foo::Bar::QUUX" to check whether such a
1418 package variable exists then that's never really been reliable, and
1419 isn't a good way to enquire about the features of a package, or
1420 whether it's loaded, etc.
1421 Can't use %s for loop variable
1423 (P) The parser got confused when trying to parse a "foreach" loop.
1424 Can't use global %s in %s
1426 (F) You tried to declare a magical variable as a lexical variable.
1427 This is not allowed, because the magic can be tied to only one
1428 location (namely the global variable) and it would be incredibly
1429 confusing to have variables in your program that looked like
1430 magical variables but weren't.
1431 Can't use '%c' in a group with different byte-order in %s
1433 (F) You attempted to force a different byte-order on a type that is
1434 already inside a group with a byte-order modifier. For example you
1435 cannot force little-endianness on a type that is inside a big-
1436 endian group.
1437 Can't use "my %s" in sort comparison
1439 (F) The global variables $a and $b are reserved for sort
1440 comparisons. You mentioned $a or $b in the same line as the <=> or
1441 cmp operator, and the variable had earlier been declared as a
1442 lexical variable. Either qualify the sort variable with the
1443 package name, or rename the lexical variable.
1444 Can't use %s ref as %s ref
1446 (F) You've mixed up your reference types. You have to dereference
1447 a reference of the type needed. You can use the ref() function to
1448 test the type of the reference, if need be.
1449 Can't use string ("%s") as %s ref while "strict refs" in use
1451 Can't use string ("%s"...) as %s ref while "strict refs" in use
1452 (F) You've told Perl to dereference a string, something which "use
1453 strict" blocks to prevent it happening accidentally. See "Symbolic
1454 references" in perlref. This can be triggered by an "@" or "$" in
1455 a double-quoted string immediately before interpolating a variable,
1456 for example in "user @$twitter_id", which says to treat the
1457 contents of $twitter_id as an array reference; use a "\" to have a
1458 literal "@" symbol followed by the contents of $twitter_id: "user
1459 \@$twitter_id".
1460 Can't use subscript on %s
1462 (F) The compiler tried to interpret a bracketed expression as a
1463 subscript. But to the left of the brackets was an expression that
1464 didn't look like a hash or array reference, or anything else
1465 subscriptable.
1466 Can't use \%c to mean $%c in expression
1468 (W syntax) In an ordinary expression, backslash is a unary operator
1469 that creates a reference to its argument. The use of backslash to
1470 indicate a backreference to a matched substring is valid only as
1471 part of a regular expression pattern. Trying to do this in
1472 ordinary Perl code produces a value that prints out looking like
1473 SCALAR(0xdecaf). Use the $1 form instead.
1474 Can't weaken a nonreference
1476 (F) You attempted to weaken something that was not a reference.
1477 Only references can be weakened.
1478 Can't "when" outside a topicalizer
1480 (F) You have used a when() block that is neither inside a "foreach"
1481 loop nor a "given" block. (Note that this error is issued on exit
1482 from the "when" block, so you won't get the error if the match
1483 fails, or if you use an explicit "continue".)
1484 Can't x= to read-only value
1486 (F) You tried to repeat a constant value (often the undefined
1487 value) with an assignment operator, which implies modifying the
1488 value itself. Perhaps you need to copy the value to a temporary,
1489 and repeat that.
1490 catch block requires a (VAR)
1492 (F) You tried to use the "try" and "catch" syntax of "use feature
1493 'try'" but did not include the error variable in the "catch" block.
1494 The parenthesized variable name is not optional, unlike in some
1495 other forms of syntax you may be familiar with from CPAN modules or
1496 other languages.
1497 The required syntax is
1499 try { ... }
1501 catch ($var) { ... }
1502 Character following "\c" must be printable ASCII
1504 (F) In "\cX", X must be a printable (non-control) ASCII character.
1505 Note that ASCII characters that don't map to control characters are
1507 discouraged, and will generate the warning (when enabled) ""\c%c"
1508 is more clearly written simply as "%s"".
1509 Character following \%c must be '{' or a single-character Unicode
1511 property name in regex; marked by <-- HERE in m/%s/
1512 (F) (In the above the %c is replaced by either "p" or "P".) You
1513 specified something that isn't a legal Unicode property name. Most
1514 Unicode properties are specified by "\p{...}". But if the name is
1515 a single character one, the braces may be omitted.
1516 Character in 'C' format wrapped in pack
1518 (W pack) You said
1519 pack("C", $x)
1521 where $x is either less than 0 or more than 255; the "C" format is
1523 only for encoding native operating system characters (ASCII,
1524 EBCDIC, and so on) and not for Unicode characters, so Perl behaved
1525 as if you meant
1526 pack("C", $x & 255)
1528 If you actually want to pack Unicode codepoints, use the "U" format
1530 instead.
1531 Character in 'c' format wrapped in pack
1533 (W pack) You said
1534 pack("c", $x)
1536 where $x is either less than -128 or more than 127; the "c" format
1538 is only for encoding native operating system characters (ASCII,
1539 EBCDIC, and so on) and not for Unicode characters, so Perl behaved
1540 as if you meant
1541 pack("c", $x & 255);
1543 If you actually want to pack Unicode codepoints, use the "U" format
1545 instead.
1546 Character in '%c' format wrapped in unpack
1548 (W unpack) You tried something like
1549 unpack("H", "\x{2a1}")
1551 where the format expects to process a byte (a character with a
1553 value below 256), but a higher value was provided instead. Perl
1554 uses the value modulus 256 instead, as if you had provided:
1555 unpack("H", "\x{a1}")
1557 Character in 'W' format wrapped in pack
1559 (W pack) You said
1560 pack("U0W", $x)
1562 where $x is either less than 0 or more than 255. However,
1564 "U0"-mode expects all values to fall in the interval [0, 255], so
1565 Perl behaved as if you meant:
1566 pack("U0W", $x & 255)
1568 Character(s) in '%c' format wrapped in pack
1570 (W pack) You tried something like
1571 pack("u", "\x{1f3}b")
1573 where the format expects to process a sequence of bytes (character
1575 with a value below 256), but some of the characters had a higher
1576 value. Perl uses the character values modulus 256 instead, as if
1577 you had provided:
1578 pack("u", "\x{f3}b")
1580 Character(s) in '%c' format wrapped in unpack
1582 (W unpack) You tried something like
1583 unpack("s", "\x{1f3}b")
1585 where the format expects to process a sequence of bytes (character
1587 with a value below 256), but some of the characters had a higher
1588 value. Perl uses the character values modulus 256 instead, as if
1589 you had provided:
1590 unpack("s", "\x{f3}b")
1592 charnames alias definitions may not contain a sequence of multiple
1594 spaces; marked by <-- HERE in %s
1595 (F) You defined a character name which had multiple space
1596 characters in a row. Change them to single spaces. Usually these
1597 names are defined in the ":alias" import argument to "use
1598 charnames", but they could be defined by a translator installed
1599 into $^H{charnames}. See "CUSTOM ALIASES" in charnames.
1600 chdir() on unopened filehandle %s
1602 (W unopened) You tried chdir() on a filehandle that was never
1603 opened.
1604 "\c%c" is more clearly written simply as "%s"
1606 (W syntax) The "\cX" construct is intended to be a way to specify
1607 non-printable characters. You used it for a printable one, which
1608 is better written as simply itself, perhaps preceded by a backslash
1609 for non-word characters. Doing it the way you did is not portable
1610 between ASCII and EBCDIC platforms.
1611 Class already has a superclass, cannot add another
1613 (F) You attempted to specify a second superclass for a "class" by
1614 using the ":isa" attribute, when one is already specified. Unlike
1615 classes whose instances are created with "bless", classes created
1616 via the "class" keyword cannot have more than one superclass.
1617 Class attribute %s requires a value
1619 (F) You specified an attribute for a class that would require a
1620 value to be passed in parentheses, but did not provide one.
1621 Remember that whitespace is not permitted between the attribute
1622 name and its value; you must write this as
1623 class Example::Class :attr(VALUE) ...
1625 class is experimental
1627 (S experimental::class) This warning is emitted if you use the
1628 "class" keyword of "use feature 'class'". This keyword is
1629 currently experimental and its behaviour may change in future
1630 releases of Perl.
1631 Class :isa attribute requires a class but "%s" is not one
1633 (F) When creating a subclass using the "class" ":isa" attribute,
1634 the named superclass must also be a real class created using the
1635 "class" keyword.
1636 Cloning substitution context is unimplemented
1638 (F) Creating a new thread inside the "s///" operator is not
1639 supported.
1640 closedir() attempted on invalid dirhandle %s
1642 (W io) The dirhandle you tried to close is either closed or not
1643 really a dirhandle. Check your control flow.
1644 close() on unopened filehandle %s
1646 (W unopened) You tried to close a filehandle that was never opened.
1647 Closure prototype called
1649 (F) If a closure has attributes, the subroutine passed to an
1650 attribute handler is the prototype that is cloned when a new
1651 closure is created. This subroutine cannot be called.
1652 \C no longer supported in regex; marked by <-- HERE in m/%s/
1654 (F) The \C character class used to allow a match of single byte
1655 within a multi-byte utf-8 character, but was removed in v5.24 as it
1656 broke encapsulation and its implementation was extremely buggy. If
1657 you really need to process the individual bytes, you probably want
1658 to convert your string to one where each underlying byte is stored
1659 as a character, with utf8::encode().
1660 Code missing after '/'
1662 (F) You had a (sub-)template that ends with a '/'. There must be
1663 another template code following the slash. See "pack" in perlfunc.
1664 Code point 0x%X is not Unicode, and not portable
1666 (S non_unicode portable) You had a code point that has never been
1667 in any standard, so it is likely that languages other than Perl
1668 will NOT understand it. This code point also will not fit in a
1669 32-bit word on ASCII platforms and therefore is non-portable
1670 between systems.
1671 At one time, it was legal in some standards to have code points up
1673 to 0x7FFF_FFFF, but not higher, and this code point is higher.
1674 Acceptance of these code points is a Perl extension, and you should
1676 expect that nothing other than Perl can handle them; Perl itself on
1677 EBCDIC platforms before v5.24 does not handle them.
1678 Perl also makes no guarantees that the representation of these code
1680 points won't change at some point in the future, say when machines
1681 become available that have larger than a 64-bit word. At that
1682 time, files containing any of these, written by an older Perl might
1683 require conversion before being readable by a newer Perl.
1684 Code point 0x%X is not Unicode, may not be portable
1686 (S non_unicode) You had a code point above the Unicode maximum of
1687 U+10FFFF.
1688 Perl allows strings to contain a superset of Unicode code points,
1690 but these may not be accepted by other languages/systems. Further,
1691 even if these languages/systems accept these large code points,
1692 they may have chosen a different representation for them than the
1693 UTF-8-like one that Perl has, which would mean files are not
1694 exchangeable between them and Perl.
1695 On EBCDIC platforms, code points above 0x3FFF_FFFF have a different
1697 representation in Perl v5.24 than before, so any file containing
1698 these that was written before that version will require conversion
1699 before being readable by a later Perl.
1700 %s: Command not found
1702 (A) You've accidentally run your script through csh or another
1703 shell instead of Perl. Check the #! line, or manually feed your
1704 script into Perl yourself. The #! line at the top of your file
1705 could look like
1706 #!/usr/bin/perl
1708 %s: command not found
1710 (A) You've accidentally run your script through bash or another
1711 shell instead of Perl. Check the #! line, or manually feed your
1712 script into Perl yourself. The #! line at the top of your file
1713 could look like
1714 #!/usr/bin/perl
1716 %s: command not found: %s
1718 (A) You've accidentally run your script through zsh or another
1719 shell instead of Perl. Check the #! line, or manually feed your
1720 script into Perl yourself. The #! line at the top of your file
1721 could look like
1722 #!/usr/bin/perl
1724 Compilation failed in require
1726 (F) Perl could not compile a file specified in a "require"
1727 statement. Perl uses this generic message when none of the errors
1728 that it encountered were severe enough to halt compilation
1729 immediately.
1730 connect() on closed socket %s
1732 (W closed) You tried to do a connect on a closed socket. Did you
1733 forget to check the return value of your socket() call? See
1734 "connect" in perlfunc.
1735 Constant(%s): Call to &{$^H{%s}} did not return a defined value
1737 (F) The subroutine registered to handle constant overloading (see
1738 overload) or a custom charnames handler (see "CUSTOM TRANSLATORS"
1739 in charnames) returned an undefined value.
1740 Constant(%s): $^H{%s} is not defined
1742 (F) The parser found inconsistencies while attempting to define an
1743 overloaded constant. Perhaps you forgot to load the corresponding
1744 overload pragma?
1745 Constant is not %s reference
1747 (F) A constant value (perhaps declared using the "use constant"
1748 pragma) is being dereferenced, but it amounts to the wrong type of
1749 reference. The message indicates the type of reference that was
1750 expected. This usually indicates a syntax error in dereferencing
1751 the constant value. See "Constant Functions" in perlsub and
1752 constant.
1753 Constants from lexical variables potentially modified elsewhere are no
1755 longer permitted
1756 (F) You wrote something like
1757 my $var;
1759 $sub = sub () { $var };
1760 but $var is referenced elsewhere and could be modified after the
1762 "sub" expression is evaluated. Either it is explicitly modified
1763 elsewhere ("$var = 3") or it is passed to a subroutine or to an
1764 operator like "printf" or "map", which may or may not modify the
1765 variable.
1766 Traditionally, Perl has captured the value of the variable at that
1768 point and turned the subroutine into a constant eligible for
1769 inlining. In those cases where the variable can be modified
1770 elsewhere, this breaks the behavior of closures, in which the
1771 subroutine captures the variable itself, rather than its value, so
1772 future changes to the variable are reflected in the subroutine's
1773 return value.
1774 This usage was deprecated, and as of Perl 5.32 is no longer
1776 allowed, making it possible to change the behavior in the future.
1777 If you intended for the subroutine to be eligible for inlining,
1779 then make sure the variable is not referenced elsewhere, possibly
1780 by copying it:
1781 my $var2 = $var;
1783 $sub = sub () { $var2 };
1784 If you do want this subroutine to be a closure that reflects future
1786 changes to the variable that it closes over, add an explicit
1787 "return":
1788 my $var;
1790 $sub = sub () { return $var };
1791 Constant subroutine %s redefined
1793 (W redefine)(S) You redefined a subroutine which had previously
1794 been eligible for inlining. See "Constant Functions" in perlsub
1795 for commentary and workarounds.
1796 Constant subroutine %s undefined
1798 (W misc) You undefined a subroutine which had previously been
1799 eligible for inlining. See "Constant Functions" in perlsub for
1800 commentary and workarounds.
1801 Constant(%s) unknown
1803 (F) The parser found inconsistencies either while attempting to
1804 define an overloaded constant, or when trying to find the character
1805 name specified in the "\N{...}" escape. Perhaps you forgot to load
1806 the corresponding overload pragma?
1807 :const is experimental
1809 (S experimental::const_attr) The "const" attribute is experimental.
1810 If you want to use the feature, disable the warning with no
1811 warnings 'experimental::const_attr', but know that in doing so you
1812 are taking the risk that your code may break in a future Perl
1813 version.
1814 :const is not permitted on named subroutines
1816 (F) The "const" attribute causes an anonymous subroutine to be run
1817 and its value captured at the time that it is cloned. Named
1818 subroutines are not cloned like this, so the attribute does not
1819 make sense on them.
1820 Copy method did not return a reference
1822 (F) The method which overloads "=" is buggy. See "Copy
1823 Constructor" in overload.
1824 &CORE::%s cannot be called directly
1826 (F) You tried to call a subroutine in the "CORE::" namespace with
1827 &foo syntax or through a reference. Some subroutines in this
1828 package cannot yet be called that way, but must be called as
1829 barewords. Something like this will work:
1830 BEGIN { *shove = \&CORE::push; }
1832 shove @array, 1,2,3; # pushes on to @array
1833 CORE::%s is not a keyword
1835 (F) The CORE:: namespace is reserved for Perl keywords.
1836 Corrupted regexp opcode %d > %d
1838 (P) This is either an error in Perl, or, if you're using one, your
1839 custom regular expression engine. If not the latter, report the
1840 problem to <https://github.com/Perl/perl5/issues/new/choose>.
1841 corrupted regexp pointers
1843 (P) The regular expression engine got confused by what the regular
1844 expression compiler gave it.
1845 corrupted regexp program
1847 (P) The regular expression engine got passed a regexp program
1848 without a valid magic number.
1849 Corrupt malloc ptr 0x%x at 0x%x
1851 (P) The malloc package that comes with Perl had an internal
1852 failure.
1853 Count after length/code in unpack
1855 (F) You had an unpack template indicating a counted-length string,
1856 but you have also specified an explicit size for the string. See
1857 "pack" in perlfunc.
1858 Declaring references is experimental
1860 (S experimental::declared_refs) This warning is emitted if you use
1861 a reference constructor on the right-hand side of "my", "state",
1862 "our", or "local". Simply suppress the warning if you want to use
1863 the feature, but know that in doing so you are taking the risk of
1864 using an experimental feature which may change or be removed in a
1865 future Perl version:
1866 no warnings "experimental::declared_refs";
1868 use feature "declared_refs";
1869 $fooref = my \$foo;
1870 Deep recursion on anonymous subroutine
1872 Deep recursion on subroutine "%s"
1873 (W recursion) This subroutine has called itself (directly or
1874 indirectly) 100 times more than it has returned. This probably
1875 indicates an infinite recursion, unless you're writing strange
1876 benchmark programs, in which case it indicates something else.
1877 This threshold can be changed from 100, by recompiling the perl
1879 binary, setting the C pre-processor macro "PERL_SUB_DEPTH_WARN" to
1880 the desired value.
1881 (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in
1883 m/%s/
1884 (F) You used something like "(?(DEFINE)...|..)" which is illegal.
1885 The most likely cause of this error is that you left out a
1886 parenthesis inside of the "...." part.
1887 The <-- HERE shows whereabouts in the regular expression the
1889 problem was discovered.
1890 %s defines neither package nor VERSION--version check failed
1892 (F) You said something like "use Module 42" but in the Module file
1893 there are neither package declarations nor a $VERSION.
1894 delete argument is not a HASH or ARRAY element or slice
1896 (F) The argument to "delete" must be either a hash or array
1897 element, such as:
1898 $foo{$bar}
1900 $ref->{"susie"}[12]
1901 or a hash or array slice, such as:
1903 @foo[$bar, $baz, $xyzzy]
1905 $ref->[12]->@{"susie", "queue"}
1906 or a hash key/value or array index/value slice, such as:
1908 %foo[$bar, $baz, $xyzzy]
1910 $ref->[12]->%{"susie", "queue"}
1911 Delimiter for here document is too long
1913 (F) In a here document construct like "<<FOO", the label "FOO" is
1914 too long for Perl to handle. You have to be seriously twisted to
1915 write code that triggers this error.
1916 DESTROY created new reference to dead object '%s'
1918 (F) A DESTROY() method created a new reference to the object which
1919 is just being DESTROYed. Perl is confused, and prefers to abort
1920 rather than to create a dangling reference.
1921 Did not produce a valid header
1923 See "500 Server error".
1924 %s did not return a true value
1926 (F) A required (or used) file must return a true value to indicate
1927 that it compiled correctly and ran its initialization code
1928 correctly. It's traditional to end such a file with a "1;", though
1929 any true value would do. See "require" in perlfunc.
1930 (Did you mean &%s instead?)
1932 (W misc) You probably referred to an imported subroutine &FOO as
1933 $FOO or some such.
1934 (Did you mean "local" instead of "our"?)
1936 (W shadow) Remember that "our" does not localize the declared
1937 global variable. You have declared it again in the same lexical
1938 scope, which seems superfluous.
1939 (Did you mean $ or @ instead of %?)
1941 (W) You probably said %hash{$key} when you meant $hash{$key} or
1942 @hash{@keys}. On the other hand, maybe you just meant %hash and
1943 got carried away.
1944 Died
1946 (F) You passed die() an empty string (the equivalent of "die """)
1947 or you called it with no args and $@ was empty.
1948 Document contains no data
1950 See "500 Server error".
1951 %s does not define %s::VERSION--version check failed
1953 (F) You said something like "use Module 42" but the Module did not
1954 define a $VERSION.
1955 '/' does not take a repeat count in %s
1957 (F) You cannot put a repeat count of any kind right after the '/'
1958 code. See "pack" in perlfunc.
1959 do "%s" failed, '.' is no longer in @INC; did you mean do "./%s"?
1961 (D deprecated::dot_in_inc) Previously " do "somefile"; " would
1962 search the current directory for the specified file. Since perl
1963 v5.26.0, . has been removed from @INC by default, so this is no
1964 longer true. To search the current directory (and only the current
1965 directory) you can write " do "./somefile"; ".
1966 Don't know how to get file name
1968 (P) "PerlIO_getname", a perl internal I/O function specific to VMS,
1969 was somehow called on another platform. This should not happen.
1970 Don't know how to handle magic of type \%o
1972 (P) The internal handling of magical variables has been cursed.
1973 Downgrading a use VERSION declaration to below v5.11 is deprecated
1975 (S deprecated::version_downgrade) This warning is emitted on a "use
1976 VERSION" statement that requests a version below v5.11 (when the
1977 effects of "use strict" would be disabled), after a previous
1978 declaration of one having a larger number (which would have enabled
1979 these effects). Because of a change to the way that "use VERSION"
1980 interacts with the strictness flags, this is no longer supported.
1981 (Do you need to predeclare %s?)
1983 (S syntax) This is an educated guess made in conjunction with the
1984 message "%s found where operator expected". It often means a
1985 subroutine or module name is being referenced that hasn't been
1986 declared yet. This may be because of ordering problems in your
1987 file, or because of a missing "sub", "package", "require", or "use"
1988 statement. If you're referencing something that isn't defined yet,
1989 you don't actually have to define the subroutine or package before
1990 the current location. You can use an empty "sub foo;" or "package
1991 FOO;" to enter a "forward" declaration.
1992 dump() must be written as CORE::dump() as of Perl 5.30
1994 (F) You used the obsolete dump() built-in function. That was
1995 deprecated in Perl 5.8.0. As of Perl 5.30 it must be written in
1996 fully qualified format: CORE::dump().
1997 See "dump" in perlfunc.
1999 dump is not supported
2001 (F) Your machine doesn't support dump/undump.
2002 Duplicate free() ignored
2004 (S malloc) An internal routine called free() on something that had
2005 already been freed.
2006 Duplicate modifier '%c' after '%c' in %s
2008 (W unpack) You have applied the same modifier more than once after
2009 a type in a pack template. See "pack" in perlfunc.
2010 each on anonymous %s will always start from the beginning
2012 (W syntax) You called each on an anonymous hash or array. Since a
2013 new hash or array is created each time, each() will restart
2014 iterating over your hash or array every time.
2015 elseif should be elsif
2017 (S syntax) There is no keyword "elseif" in Perl because Larry
2018 thinks it's ugly. Your code will be interpreted as an attempt to
2019 call a method named "elseif" for the class returned by the
2020 following block. This is unlikely to be what you want.
2021 Empty \%c in regex; marked by <-- HERE in m/%s/
2023 Empty \%c{}
2024 Empty \%c{} in regex; marked by <-- HERE in m/%s/
2025 (F) You used something like "\b{}", "\B{}", "\o{}", "\p", "\P", or
2026 "\x" without specifying anything for it to operate on.
2027 Unfortunately, for backwards compatibility reasons, an empty "\x"
2029 is legal outside "use re 'strict'" and expands to a NUL character.
2030 Empty (?) without any modifiers in regex; marked by <-- HERE in m/%s/
2032 (W regexp) (only under "use re 'strict'") "(?)" does nothing, so
2033 perhaps this is a typo.
2034 ${^ENCODING} is no longer supported
2036 (F) The special variable "${^ENCODING}", formerly used to implement
2037 the "encoding" pragma, is no longer supported as of Perl 5.26.0.
2038 Setting it to anything other than "undef" is a fatal error as of
2040 Perl 5.28.
2041 ${^HOOK}{%s} may only be a CODE reference or undef
2043 (F) You attempted to assign something other than undef or a CODE
2044 ref to "%{^HOOK}". Hooks may only be CODE refs. See "%{^HOOK}" in
2045 perlvar for details.
2046 Attempt to set unknown hook '%s' in %{^HOOK}
2048 (F) You attempted to assign something other than undef or a CODE
2049 ref to "%{^HOOK}". Hooks may only be CODE refs. See "%{^HOOK}" in
2050 perlvar for details.
2051 entering effective %s failed
2053 (F) While under the "use filetest" pragma, switching the real and
2054 effective uids or gids failed.
2055 %ENV is aliased to %s
2057 (F) You're running under taint mode, and the %ENV variable has been
2058 aliased to another hash, so it doesn't reflect anymore the state of
2059 the program's environment. This is potentially insecure.
2060 Error converting file specification %s
2062 (F) An error peculiar to VMS. Because Perl may have to deal with
2063 file specifications in either VMS or Unix syntax, it converts them
2064 to a single form when it must operate on them directly. Either
2065 you've passed an invalid file specification to Perl, or you've
2066 found a case the conversion routines don't handle. Drat.
2067 Error %s in expansion of %s
2069 (F) An error was encountered in handling a user-defined property
2070 ("User-Defined Character Properties" in perlunicode). These are
2071 programmer written subroutines, hence subject to errors that may
2072 prevent them from compiling or running. The calls to these subs
2073 are "eval"'d, and if there is a failure, this message is raised,
2074 using the contents of $@ from the failed "eval".
2075 Another possibility is that tainted data was encountered somewhere
2077 in the chain of expanding the property. If so, the message wording
2078 will indicate that this is the problem. See "Insecure user-defined
2079 property %s".
2080 Eval-group in insecure regular expression
2082 (F) Perl detected tainted data when trying to compile a regular
2083 expression that contains the "(?{ ... })" zero-width assertion,
2084 which is unsafe. See "(?{ code })" in perlre, and perlsec.
2085 Eval-group not allowed at runtime, use re 'eval' in regex m/%s/
2087 (F) Perl tried to compile a regular expression containing the "(?{
2088 ... })" zero-width assertion at run time, as it would when the
2089 pattern contains interpolated values. Since that is a security
2090 risk, it is not allowed. If you insist, you may still do this by
2091 using the "re 'eval'" pragma or by explicitly building the pattern
2092 from an interpolated string at run time and using that in an
2093 eval(). See "(?{ code })" in perlre.
2094 Eval-group not allowed, use re 'eval' in regex m/%s/
2096 (F) A regular expression contained the "(?{ ... })" zero-width
2097 assertion, but that construct is only allowed when the "use re
2098 'eval'" pragma is in effect. See "(?{ code })" in perlre.
2099 EVAL without pos change exceeded limit in regex; marked by <-- HERE in
2101 m/%s/
2102 (F) You used a pattern that nested too many EVAL calls without
2103 consuming any text. Restructure the pattern so that text is
2104 consumed.
2105 The <-- HERE shows whereabouts in the regular expression the
2107 problem was discovered.
2108 Excessively long <> operator
2110 (F) The contents of a <> operator may not exceed the maximum size
2111 of a Perl identifier. If you're just trying to glob a long list of
2112 filenames, try using the glob() operator, or put the filenames into
2113 a variable and glob that.
2114 exec? I'm not *that* kind of operating system
2116 (F) The "exec" function is not implemented on some systems, e.g.
2117 Catamount. See perlport.
2118 %sExecution of %s aborted due to compilation errors.
2120 (F) The final summary message when a Perl compilation fails.
2121 Execution of %s aborted due to compilation errors.
2123 (F) The final summary message when a Perl compilation fails.
2124 exists argument is not a HASH or ARRAY element or a subroutine
2126 (F) The argument to "exists" must be a hash or array element or a
2127 subroutine with an ampersand, such as:
2128 $foo{$bar}
2130 $ref->{"susie"}[12]
2131 &do_something
2132 exists argument is not a subroutine name
2134 (F) The argument to "exists" for "exists &sub" must be a subroutine
2135 name, and not a subroutine call. "exists &sub()" will generate
2136 this error.
2137 Exiting eval via %s
2139 (W exiting) You are exiting an eval by unconventional means, such
2140 as a goto, or a loop control statement.
2141 Exiting format via %s
2143 (W exiting) You are exiting a format by unconventional means, such
2144 as a goto, or a loop control statement.
2145 Exiting pseudo-block via %s
2147 (W exiting) You are exiting a rather special block construct (like
2148 a sort block or subroutine) by unconventional means, such as a
2149 goto, or a loop control statement. See "sort" in perlfunc.
2150 Exiting subroutine via %s
2152 (W exiting) You are exiting a subroutine by unconventional means,
2153 such as a goto, or a loop control statement.
2154 Exiting substitution via %s
2156 (W exiting) You are exiting a substitution by unconventional means,
2157 such as a return, a goto, or a loop control statement.
2158 Expected %s reference in export_lexically
2160 (F) The type of a reference given to "export_lexically" in builtin
2161 did not match the sigil of the preceding name, or the value was not
2162 a reference at all.
2163 Expecting close bracket in regex; marked by <-- HERE in m/%s/
2165 (F) You wrote something like
2166 (?13
2168 to denote a capturing group of the form "(?PARNO)", but omitted the
2170 ")".
2171 Expecting interpolated extended charclass in regex; marked by <-- HERE
2173 in m/%s/
2174 (F) It looked like you were attempting to interpolate an already-
2175 compiled extended character class, like so:
2176 my $thai_or_lao = qr/(?[ \p{Thai} + \p{Lao} ])/;
2178 ...
2179 qr/(?[ \p{Digit} & $thai_or_lao ])/;
2180 But the marked code isn't syntactically correct to be such an
2182 interpolated class.
2183 Experimental aliasing via reference not enabled
2185 (F) To do aliasing via references, you must first enable the
2186 feature:
2187 no warnings "experimental::refaliasing";
2189 use feature "refaliasing";
2190 \$x = \$y;
2191 Experimental %s on scalar is now forbidden
2193 (F) An experimental feature added in Perl 5.14 allowed "each",
2194 "keys", "push", "pop", "shift", "splice", "unshift", and "values"
2195 to be called with a scalar argument. This experiment is considered
2196 unsuccessful, and has been removed. The "postderef" feature may
2197 meet your needs better.
2198 Experimental subroutine signatures not enabled
2200 (F) To use subroutine signatures, you must first enable them:
2201 use feature "signatures";
2203 sub foo ($left, $right) { ... }
2204 Explicit blessing to '' (assuming package main)
2206 (W misc) You are blessing a reference to a zero length string.
2207 This has the effect of blessing the reference into the package
2208 main. This is usually not what you want. Consider providing a
2209 default target package, e.g. bless($ref, $p || 'MyPackage');
2210 export_lexically can only be called at compile time
2212 (F) "export_lexically" in builtin was called at runtime. Because
2213 it creates new names in the lexical scope currently being compiled,
2214 it can only be called from code inside "BEGIN" block in that scope.
2215 %s: Expression syntax
2217 (A) You've accidentally run your script through csh instead of
2218 Perl. Check the #! line, or manually feed your script into Perl
2219 yourself.
2220 %s failed--call queue aborted
2222 (F) An untrapped exception was raised while executing a UNITCHECK,
2223 CHECK, INIT, or END subroutine. Processing of the remainder of the
2224 queue of such routines has been prematurely ended.
2225 Failed to close in-place work file %s: %s
2227 (F) Closing an output file from in-place editing, as with the "-i"
2228 command-line switch, failed.
2229 False [] range "%s" in regex; marked by <-- HERE in m/%s/
2231 (W regexp)(F) A character class range must start and end at a
2232 literal character, not another character class like "\d" or
2233 "[:alpha:]". The "-" in your false range is interpreted as a
2234 literal "-". In a "(?[...])" construct, this is an error, rather
2235 than a warning. Consider quoting the "-", "\-". The <-- HERE
2236 shows whereabouts in the regular expression the problem was
2237 discovered. See perlre.
2238 Fatal VMS error (status=%d) at %s, line %d
2240 (P) An error peculiar to VMS. Something untoward happened in a VMS
2241 system service or RTL routine; Perl's exit status should provide
2242 more details. The filename in "at %s" and the line number in "line
2243 %d" tell you which section of the Perl source code is distressed.
2244 fcntl is not implemented
2246 (F) Your machine apparently doesn't implement fcntl(). What is
2247 this, a PDP-11 or something?
2248 FETCHSIZE returned a negative value
2250 (F) A tied array claimed to have a negative number of elements,
2251 which is not possible.
2252 Field already has a parameter name, cannot add another
2254 (F) A field may have at most one application of the ":param"
2255 attribute to assign a parameter name to it; once applied a second
2256 one is not allowed.
2257 Field attribute %s requires a value
2259 (F) You specified an attribute for a field that would require a
2260 value to be passed in parentheses, but did not provide one.
2261 Remember that whitespace is not permitted between the attribute
2262 name and its value; you must write this as
2263 field $var :attr(VALUE) ...
2265 field is experimental
2267 (S experimental::class) This warning is emitted if you use the
2268 "field" keyword of "use feature 'class'". This keyword is
2269 currently experimental and its behaviour may change in future
2270 releases of Perl.
2271 Field %s is not accessible outside a method
2273 (F) An attempt was made to access a field variable of a class from
2274 code that does not appear inside the body of a "method" subroutine.
2275 This is not permitted, as only methods will have access to the
2276 fields of an instance.
2277 Field %s of "%s" is not accessible in a method of "%s"
2279 (F) An attempt was made to access a field variable of a class, from
2280 a method of another class nested inside the one that actually
2281 defined it. This is not permitted, as only methods defined by a
2282 given class are permitted to access fields of that class.
2283 Field too wide in 'u' format in pack
2285 (W pack) Each line in an uuencoded string starts with a length
2286 indicator which can't encode values above 63. So there is no point
2287 in asking for a line length bigger than that. Perl will behave as
2288 if you specified "u63" as the format.
2289 Filehandle %s opened only for input
2291 (W io) You tried to write on a read-only filehandle. If you
2292 intended it to be a read-write filehandle, you needed to open it
2293 with "+<" or "+>" or "+>>" instead of with "<" or nothing. If you
2294 intended only to write the file, use ">" or ">>". See "open" in
2295 perlfunc.
2296 Filehandle %s opened only for output
2298 (W io) You tried to read from a filehandle opened only for writing,
2299 If you intended it to be a read/write filehandle, you needed to
2300 open it with "+<" or "+>" or "+>>" instead of with ">". If you
2301 intended only to read from the file, use "<". See "open" in
2302 perlfunc. Another possibility is that you attempted to open
2303 filedescriptor 0 (also known as STDIN) for output (maybe you closed
2304 STDIN earlier?).
2305 Filehandle %s reopened as %s only for input
2307 (W io) You opened for reading a filehandle that got the same
2308 filehandle id as STDOUT or STDERR. This occurred because you
2309 closed STDOUT or STDERR previously.
2310 Filehandle STDIN reopened as %s only for output
2312 (W io) You opened for writing a filehandle that got the same
2313 filehandle id as STDIN. This occurred because you closed STDIN
2314 previously.
2315 Filehandle STD%s reopened as %s only for input
2317 (W io) You opened for reading a filehandle that got the same
2318 filehandle id as STDOUT or STDERR. This occurred because you
2319 closed the handle previously.
2320 Final $ should be \$ or $name
2322 (F) You must now decide whether the final $ in a string was meant
2323 to be a literal dollar sign, or was meant to introduce a variable
2324 name that happens to be missing. So you have to put either the
2325 backslash or the name.
2326 defer is experimental
2328 (S experimental::defer) The "defer" block modifier is experimental.
2329 If you want to use the feature, disable the warning with "no
2330 warnings 'experimental::defer'", but know that in doing so you are
2331 taking the risk that your code may break in a future Perl version.
2332 flock() on closed filehandle %s
2334 (W closed) The filehandle you're attempting to flock() got itself
2335 closed some time before now. Check your control flow. flock()
2336 operates on filehandles. Are you attempting to call flock() on a
2337 dirhandle by the same name?
2338 for my (...) is experimental
2340 (S experimental::for_list) This warning is emitted if you use "for"
2341 to iterate multiple values at a time. This syntax is currently
2342 experimental and its behaviour may change in future releases of
2343 Perl.
2344 Format not terminated
2346 (F) A format must be terminated by a line with a solitary dot.
2347 Perl got to the end of your file without finding such a line.
2348 Format %s redefined
2350 (W redefine) You redefined a format. To suppress this warning, say
2351 {
2353 no warnings 'redefine';
2354 eval "format NAME =...";
2355 }
2356 Found = in conditional, should be ==
2358 (W syntax) You said
2359 if ($foo = 123)
2361 when you meant
2363 if ($foo == 123)
2365 (or something like that).
2367 %s found where operator expected
2369 (S syntax) The Perl lexer knows whether to expect a term or an
2370 operator. If it sees what it knows to be a term when it was
2371 expecting to see an operator, it gives you this warning. Usually
2372 it indicates that an operator or delimiter was omitted, such as a
2373 semicolon.
2374 gdbm store returned %d, errno %d, key "%s"
2376 (S) A warning from the GDBM_File extension that a store failed.
2377 gethostent not implemented
2379 (F) Your C library apparently doesn't implement gethostent(),
2380 probably because if it did, it'd feel morally obligated to return
2381 every hostname on the Internet.
2382 get%sname() on closed socket %s
2384 (W closed) You tried to get a socket or peer socket name on a
2385 closed socket. Did you forget to check the return value of your
2386 socket() call?
2387 getpwnam returned invalid UIC %#o for user "%s"
2389 (S) A warning peculiar to VMS. The call to "sys$getuai" underlying
2390 the "getpwnam" operator returned an invalid UIC.
2391 getsockopt() on closed socket %s
2393 (W closed) You tried to get a socket option on a closed socket.
2394 Did you forget to check the return value of your socket() call?
2395 See "getsockopt" in perlfunc.
2396 given is deprecated
2398 (D deprecated::smartmatch) "given" depends on smartmatch, which is
2399 deprecated. It will be removed in Perl 5.42. See the explanation
2400 under "Experimental Details on given and when" in perlsyn.
2401 Global symbol "%s" requires explicit package name (did you forget to
2403 declare "my %s"?)
2404 (F) You've said "use strict" or "use strict vars", which indicates
2405 that all variables must either be lexically scoped (using "my" or
2406 "state"), declared beforehand using "our", or explicitly qualified
2407 to say which package the global variable is in (using "::").
2408 glob failed (%s)
2410 (S glob) Something went wrong with the external program(s) used for
2411 "glob" and "<*.c>". Usually, this means that you supplied a "glob"
2412 pattern that caused the external program to fail and exit with a
2413 nonzero status. If the message indicates that the abnormal exit
2414 resulted in a coredump, this may also mean that your csh (C shell)
2415 is broken. If so, you should change all of the csh-related
2416 variables in config.sh: If you have tcsh, make the variables refer
2417 to it as if it were csh (e.g. "full_csh='/usr/bin/tcsh'");
2418 otherwise, make them all empty (except that "d_csh" should be
2419 'undef') so that Perl will think csh is missing. In either case,
2420 after editing config.sh, run "./Configure -S" and rebuild Perl.
2421 Glob not terminated
2423 (F) The lexer saw a left angle bracket in a place where it was
2424 expecting a term, so it's looking for the corresponding right angle
2425 bracket, and not finding it. Chances are you left some needed
2426 parentheses out earlier in the line, and you really meant a "less
2427 than".
2428 gmtime(%f) failed
2430 (W overflow) You called "gmtime" with a number that it could not
2431 handle: too large, too small, or NaN. The returned value is
2432 "undef".
2433 gmtime(%f) too large
2435 (W overflow) You called "gmtime" with a number that was larger than
2436 it can reliably handle and "gmtime" probably returned the wrong
2437 date. This warning is also triggered with NaN (the special not-a-
2438 number value).
2439 gmtime(%f) too small
2441 (W overflow) You called "gmtime" with a number that was smaller
2442 than it can reliably handle and "gmtime" probably returned the
2443 wrong date.
2444 Got an error from DosAllocMem
2446 (P) An error peculiar to OS/2. Most probably you're using an
2447 obsolete version of Perl, and this should not happen anyway.
2448 goto must have label
2450 (F) Unlike with "next" or "last", you're not allowed to goto an
2451 unspecified destination. See "goto" in perlfunc.
2452 Goto undefined subroutine%s
2454 (F) You tried to call a subroutine with "goto &sub" syntax, but the
2455 indicated subroutine hasn't been defined, or if it was, it has
2456 since been undefined.
2457 Group name must start with a non-digit word character in regex; marked
2459 by <-- HERE in m/%s/
2460 (F) Group names must follow the rules for perl identifiers, meaning
2461 they must start with a non-digit word character. A common cause of
2462 this error is using (?&0) instead of (?0). See perlre.
2463 ()-group starts with a count
2465 (F) A ()-group started with a count. A count is supposed to follow
2466 something: a template character or a ()-group. See "pack" in
2467 perlfunc.
2468 %s had compilation errors.
2470 (F) The final summary message when a "perl -c" fails.
2471 Had to create %s unexpectedly
2473 (S internal) A routine asked for a symbol from a symbol table that
2474 ought to have existed already, but for some reason it didn't, and
2475 had to be created on an emergency basis to prevent a core dump.
2476 %s has too many errors
2478 (F) The parser has given up trying to parse the program after 10
2479 errors. Further error messages would likely be uninformative.
2480 Hexadecimal float: exponent overflow
2482 (W overflow) The hexadecimal floating point has a larger exponent
2483 than the floating point supports.
2484 Hexadecimal float: exponent underflow
2486 (W overflow) The hexadecimal floating point has a smaller exponent
2487 than the floating point supports. With the IEEE 754 floating
2488 point, this may also mean that the subnormals (formerly known as
2489 denormals) are being used, which may or may not be an error.
2490 Hexadecimal float: internal error (%s)
2492 (F) Something went horribly bad in hexadecimal float handling.
2493 Hexadecimal float: mantissa overflow
2495 (W overflow) The hexadecimal floating point literal had more bits
2496 in the mantissa (the part between the 0x and the exponent, also
2497 known as the fraction or the significand) than the floating point
2498 supports.
2499 Hexadecimal float: precision loss
2501 (W overflow) The hexadecimal floating point had internally more
2502 digits than could be output. This can be caused by unsupported
2503 long double formats, or by 64-bit integers not being available
2504 (needed to retrieve the digits under some configurations).
2505 Hexadecimal float: unsupported long double format
2507 (F) You have configured Perl to use long doubles but the internals
2508 of the long double format are unknown; therefore the hexadecimal
2509 float output is impossible.
2510 Hexadecimal number > 0xffffffff non-portable
2512 (W portable) The hexadecimal number you specified is larger than
2513 2**32-1 (4294967295) and therefore non-portable between systems.
2514 See perlport for more on portability concerns.
2515 Identifier too long
2517 (F) Perl limits identifiers (names for variables, functions, etc.)
2518 to about 250 characters for simple names, and somewhat more for
2519 compound names (like $A::B). You've exceeded Perl's limits.
2520 Future versions of Perl are likely to eliminate these arbitrary
2521 limitations.
2522 Ignoring zero length \N{} in character class in regex; marked by
2524 <-- HERE in m/%s/
2525 (W regexp) Named Unicode character escapes ("\N{...}") may return a
2526 zero-length sequence. When such an escape is used in a character
2527 class its behavior is not well defined. Check that the correct
2528 escape has been used, and the correct charname handler is in scope.
2529 Illegal %s digit '%c' ignored
2531 (W digit) Here %s is one of "binary", "octal", or "hex". You may
2532 have tried to use a digit other than one that is legal for the
2533 given type, such as only 0 and 1 for binary. For octals, this is
2534 raised only if the illegal character is an '8' or '9'. For hex,
2535 'A' - 'F' and 'a' - 'f' are legal. Interpretation of the number
2536 stopped just before the offending digit or character.
2537 Illegal binary digit '%c'
2539 (F) You used a digit other than 0 or 1 in a binary number.
2540 Illegal character after '_' in prototype for %s : %s
2542 (W illegalproto) An illegal character was found in a prototype
2543 declaration. The '_' in a prototype must be followed by a ';',
2544 indicating the rest of the parameters are optional, or one of '@'
2545 or '%', since those two will accept 0 or more final parameters.
2546 Illegal character \%o (carriage return)
2548 (F) Perl normally treats carriage returns in the program text as it
2549 would any other whitespace, which means you should never see this
2550 error when Perl was built using standard options. For some reason,
2551 your version of Perl appears to have been built without this
2552 support. Talk to your Perl administrator.
2553 Illegal character following sigil in a subroutine signature
2555 (F) A parameter in a subroutine signature contained an unexpected
2556 character following the "$", "@" or "%" sigil character. Normally
2557 the sigil should be followed by the variable name or "=" etc.
2558 Perhaps you are trying use a prototype while in the scope of "use
2559 feature 'signatures'"? For example:
2560 sub foo ($$) {} # legal - a prototype
2562 use feature 'signatures;
2564 sub foo ($$) {} # illegal - was expecting a signature
2565 sub foo ($a, $b)
2566 :prototype($$) {} # legal
2567 Illegal character in prototype for %s : %s
2569 (W illegalproto) An illegal character was found in a prototype
2570 declaration. Legal characters in prototypes are $, @, %, *, ;, [,
2571 ], &, \, and +. Perhaps you were trying to write a subroutine
2572 signature but didn't enable that feature first ("use feature
2573 'signatures'"), so your signature was instead interpreted as a bad
2574 prototype.
2575 Illegal declaration of anonymous subroutine
2577 (F) When using the "sub" keyword to construct an anonymous
2578 subroutine, you must always specify a block of code. See perlsub.
2579 Illegal declaration of subroutine %s
2581 (F) A subroutine was not declared correctly. See perlsub.
2582 Illegal division by zero
2584 (F) You tried to divide a number by 0. Either something was wrong
2585 in your logic, or you need to put a conditional in to guard against
2586 meaningless input.
2587 Illegal modulus zero
2589 (F) You tried to divide a number by 0 to get the remainder. Most
2590 numbers don't take to this kindly.
2591 Illegal number of bits in vec
2593 (F) The number of bits in vec() (the third argument) must be a
2594 power of two from 1 to 32 (or 64, if your platform supports that).
2595 Illegal octal digit '%c'
2597 (F) You used an 8 or 9 in an octal number.
2598 Illegal operator following parameter in a subroutine signature
2600 (F) A parameter in a subroutine signature, was followed by
2601 something other than "=" introducing a default, "," or ")".
2602 use feature 'signatures';
2604 sub foo ($=1) {} # legal
2605 sub foo ($a = 1) {} # legal
2606 sub foo ($a += 1) {} # illegal
2607 sub foo ($a == 1) {} # illegal
2608 Illegal pattern in regex; marked by <-- HERE in m/%s/
2610 (F) You wrote something like
2611 (?+foo)
2613 The "+" is valid only when followed by digits, indicating a
2615 capturing group. See "(?PARNO)".
2616 Illegal suidscript
2618 (F) The script run under suidperl was somehow illegal.
2619 Illegal switch in PERL5OPT: -%c
2621 (X) The PERL5OPT environment variable may only be used to set the
2622 following switches: -[CDIMUdmtw].
2623 Illegal user-defined property name
2625 (F) You specified a Unicode-like property name in a regular
2626 expression pattern (using "\p{}" or "\P{}") that Perl knows isn't
2627 an official Unicode property, and was likely meant to be a user-
2628 defined property name, but it can't be one of those, as they must
2629 begin with either "In" or "Is". Check the spelling. See also
2630 "Can't find Unicode property definition "%s"".
2631 Ill-formed CRTL environ value "%s"
2633 (W internal) A warning peculiar to VMS. Perl tried to read the
2634 CRTL's internal environ array, and encountered an element without
2635 the "=" delimiter used to separate keys from values. The element
2636 is ignored.
2637 Ill-formed message in prime_env_iter: |%s|
2639 (W internal) A warning peculiar to VMS. Perl tried to read a
2640 logical name or CLI symbol definition when preparing to iterate
2641 over %ENV, and didn't see the expected delimiter between key and
2642 value, so the line was ignored.
2643 (in cleanup) %s
2645 (W misc) This prefix usually indicates that a DESTROY() method
2646 raised the indicated exception. Since destructors are usually
2647 called by the system at arbitrary points during execution, and
2648 often a vast number of times, the warning is issued only once for
2649 any number of failures that would otherwise result in the same
2650 message being repeated.
2651 Failure of user callbacks dispatched using the "G_KEEPERR" flag
2653 could also result in this warning. See "G_KEEPERR" in perlcall.
2654 Implicit use of @_ in %s with signatured subroutine is experimental
2656 (S experimental::args_array_with_signatures) An expression that
2657 implicitly involves the @_ arguments array was found in a
2658 subroutine that uses a signature. This is experimental because the
2659 interaction between the arguments array and parameter handling via
2660 signatures is not guaranteed to remain stable in any future version
2661 of Perl, and such code should be avoided.
2662 Incomplete expression within '(?[ ])' in regex; marked by <-- HERE in
2664 m/%s/
2665 (F) There was a syntax error within the "(?[ ])". This can happen
2666 if the expression inside the construct was completely empty, or if
2667 there are too many or few operands for the number of operators.
2668 Perl is not smart enough to give you a more precise indication as
2669 to what is wrong.
2670 Inconsistent hierarchy during C3 merge of class '%s': merging failed on
2672 parent '%s'
2673 (F) The method resolution order (MRO) of the given class is not
2674 C3-consistent, and you have enabled the C3 MRO for this class. See
2675 the C3 documentation in mro for more information.
2676 Indentation on line %d of here-doc doesn't match delimiter
2678 (F) You have an indented here-document where one or more of its
2679 lines have whitespace at the beginning that does not match the
2680 closing delimiter.
2681 For example, line 2 below is wrong because it does not have at
2683 least 2 spaces, but lines 1 and 3 are fine because they have at
2684 least 2:
2685 if ($something) {
2687 print <<~EOF;
2688 Line 1
2689 Line 2 not
2690 Line 3
2691 EOF
2692 }
2693 Note that tabs and spaces are compared strictly, meaning 1 tab will
2695 not match 8 spaces.
2696 Infinite recursion in regex
2698 (F) You used a pattern that references itself without consuming any
2699 input text. You should check the pattern to ensure that recursive
2700 patterns either consume text or fail.
2701 Infinite recursion in user-defined property
2703 (F) A user-defined property ("User-Defined Character Properties" in
2704 perlunicode) can depend on the definitions of other user-defined
2705 properties. If the chain of dependencies leads back to this
2706 property, infinite recursion would occur, were it not for the check
2707 that raised this error.
2708 Restructure your property definitions to avoid this.
2710 Infinite recursion via empty pattern
2712 (F) You tried to use the empty pattern inside of a regex code
2713 block, for instance "/(?{ s!!! })/", which resulted in re-executing
2714 the same pattern, which is an infinite loop which is broken by
2715 throwing an exception.
2716 Initialization of state variables in list currently forbidden
2718 (F) "state" only permits initializing a single variable, specified
2719 without parentheses. So "state $a = 42" and "state @a = qw(a b c)"
2720 are allowed, but not "state ($a) = 42" or "(state $a) = 42". To
2721 initialize more than one "state" variable, initialize them one at a
2722 time.
2723 %%s[%s] in scalar context better written as $%s[%s]
2725 (W syntax) In scalar context, you've used an array index/value
2726 slice (indicated by %) to select a single element of an array.
2727 Generally it's better to ask for a scalar value (indicated by $).
2728 The difference is that $foo[&bar] always behaves like a scalar,
2729 both in the value it returns and when evaluating its argument,
2730 while %foo[&bar] provides a list context to its subscript, which
2731 can do weird things if you're expecting only one subscript. When
2732 called in list context, it also returns the index (what &bar
2733 returns) in addition to the value.
2734 %%s{%s} in scalar context better written as $%s{%s}
2736 (W syntax) In scalar context, you've used a hash key/value slice
2737 (indicated by %) to select a single element of a hash. Generally
2738 it's better to ask for a scalar value (indicated by $). The
2739 difference is that $foo{&bar} always behaves like a scalar, both in
2740 the value it returns and when evaluating its argument, while
2741 @foo{&bar} and provides a list context to its subscript, which can
2742 do weird things if you're expecting only one subscript. When
2743 called in list context, it also returns the key in addition to the
2744 value.
2745 Insecure dependency in %s
2747 (F) You tried to do something that the tainting mechanism didn't
2748 like. The tainting mechanism is turned on when you're running
2749 setuid or setgid, or when you specify -T to turn it on explicitly.
2750 The tainting mechanism labels all data that's derived directly or
2751 indirectly from the user, who is considered to be unworthy of your
2752 trust. If any such data is used in a "dangerous" operation, you
2753 get this error. See perlsec for more information.
2754 Insecure directory in %s
2756 (F) You can't use system(), exec(), or a piped open in a setuid or
2757 setgid script if $ENV{PATH} contains a directory that is writable
2758 by the world. Also, the PATH must not contain any relative
2759 directory. See perlsec.
2760 Insecure $ENV{%s} while running %s
2762 (F) You can't use system(), exec(), or a piped open in a setuid or
2763 setgid script if any of $ENV{PATH}, $ENV{IFS}, $ENV{CDPATH},
2764 $ENV{ENV}, $ENV{BASH_ENV} or $ENV{TERM} are derived from data
2765 supplied (or potentially supplied) by the user. The script must
2766 set the path to a known value, using trustworthy data. See
2767 perlsec.
2768 Insecure user-defined property %s
2770 (F) Perl detected tainted data when trying to compile a regular
2771 expression that contains a call to a user-defined character
2772 property function, i.e. "\p{IsFoo}" or "\p{InFoo}". See "User-
2773 Defined Character Properties" in perlunicode and perlsec.
2774 Integer overflow in format string for %s
2776 (F) The indexes and widths specified in the format string of
2777 printf() or sprintf() are too large. The numbers must not overflow
2778 the size of integers for your architecture.
2779 Integer overflow in %s number
2781 (S overflow) The hexadecimal, octal or binary number you have
2782 specified either as a literal or as an argument to hex() or oct()
2783 is too big for your architecture, and has been converted to a
2784 floating point number. On a 32-bit architecture the largest
2785 hexadecimal, octal or binary number representable without overflow
2786 is 0xFFFFFFFF, 037777777777, or 0b11111111111111111111111111111111
2787 respectively. Note that Perl transparently promotes all numbers to
2788 a floating point representation internally--subject to loss of
2789 precision errors in subsequent operations.
2790 Integer overflow in srand
2792 (S overflow) The number you have passed to srand is too big to fit
2793 in your architecture's integer representation. The number has been
2794 replaced with the largest integer supported (0xFFFFFFFF on 32-bit
2795 architectures). This means you may be getting less randomness than
2796 you expect, because different random seeds above the maximum will
2797 return the same sequence of random numbers.
2798 Integer overflow in version
2800 Integer overflow in version %d
2801 (W overflow) Some portion of a version initialization is too large
2802 for the size of integers for your architecture. This is not a
2803 warning because there is no rational reason for a version to try
2804 and use an element larger than typically 2**32. This is usually
2805 caused by trying to use some odd mathematical operation as a
2806 version, like 100/9.
2807 Internal disaster in regex; marked by <-- HERE in m/%s/
2809 (P) Something went badly wrong in the regular expression parser.
2810 The <-- HERE shows whereabouts in the regular expression the
2811 problem was discovered.
2812 Internal inconsistency in tracking vforks
2814 (S) A warning peculiar to VMS. Perl keeps track of the number of
2815 times you've called "fork" and "exec", to determine whether the
2816 current call to "exec" should affect the current script or a
2817 subprocess (see "exec LIST" in perlvms). Somehow, this count has
2818 become scrambled, so Perl is making a guess and treating this
2819 "exec" as a request to terminate the Perl script and execute the
2820 specified command.
2821 internal %<num>p might conflict with future printf extensions
2823 (S internal) Perl's internal routine that handles "printf" and
2824 "sprintf" formatting follows a slightly different set of rules when
2825 called from C or XS code. Specifically, formats consisting of
2826 digits followed by "p" (e.g., "%7p") are reserved for future use.
2827 If you see this message, then an XS module tried to call that
2828 routine with one such reserved format.
2829 Internal urp in regex; marked by <-- HERE in m/%s/
2831 (P) Something went badly awry in the regular expression parser.
2832 The <-- HERE shows whereabouts in the regular expression the
2833 problem was discovered.
2834 %s (...) interpreted as function
2836 (W syntax) You've run afoul of the rule that says that any list
2837 operator followed by parentheses turns into a function, with all
2838 the list operators arguments found inside the parentheses. See
2839 "Terms and List Operators (Leftward)" in perlop.
2840 In '(?...)', the '(' and '?' must be adjacent in regex; marked by
2842 <-- HERE in m/%s/
2843 (F) The two-character sequence "(?" in this context in a regular
2844 expression pattern should be an indivisible token, with nothing
2845 intervening between the "(" and the "?", but you separated them
2846 with whitespace.
2847 In '(*...)', the '(' and '*' must be adjacent in regex; marked by
2849 <-- HERE in m/%s/
2850 (F) The two-character sequence "(*" in this context in a regular
2851 expression pattern should be an indivisible token, with nothing
2852 intervening between the "(" and the "*", but you separated them.
2853 Fix the pattern and retry.
2854 Invalid %s attribute: %s
2856 (F) The indicated attribute for a subroutine or variable was not
2857 recognized by Perl or by a user-supplied handler. See attributes.
2858 Invalid %s attributes: %s
2860 (F) The indicated attributes for a subroutine or variable were not
2861 recognized by Perl or by a user-supplied handler. See attributes.
2862 Invalid character in charnames alias definition; marked by <-- HERE in
2864 '%s
2865 (F) You tried to create a custom alias for a character name, with
2866 the ":alias" option to "use charnames" and the specified character
2867 in the indicated name isn't valid. See "CUSTOM ALIASES" in
2868 charnames.
2869 Invalid \0 character in %s for %s: %s\0%s
2871 (W syscalls) Embedded \0 characters in pathnames or other system
2872 call arguments produce a warning as of 5.20. The parts after the
2873 \0 were formerly ignored by system calls.
2874 Invalid character in \N{...}; marked by <-- HERE in \N{%s}
2876 (F) Only certain characters are valid for character names. The
2877 indicated one isn't. See "CUSTOM ALIASES" in charnames.
2878 Invalid conversion in %s: "%s"
2880 (W printf) Perl does not understand the given format conversion.
2881 See "sprintf" in perlfunc.
2882 Invalid escape in the specified encoding in regex; marked by <-- HERE
2884 in m/%s/
2885 (W regexp)(F) The numeric escape (for example "\xHH") of value <
2886 256 didn't correspond to a single character through the conversion
2887 from the encoding specified by the encoding pragma. The escape was
2888 replaced with REPLACEMENT CHARACTER (U+FFFD) instead, except within
2889 "(?[ ])", where it is a fatal error. The <-- HERE shows
2890 whereabouts in the regular expression the escape was discovered.
2891 Invalid hexadecimal number in \N{U+...}
2893 Invalid hexadecimal number in \N{U+...} in regex; marked by <-- HERE in
2894 m/%s/
2895 (F) The character constant represented by "..." is not a valid
2896 hexadecimal number. Either it is empty, or you tried to use a
2897 character other than 0 - 9 or A - F, a - f in a hexadecimal number.
2898 Invalid module name %s with -%c option: contains single ':'
2900 (F) The module argument to perl's -m and -M command-line options
2901 cannot contain single colons in the module name, but only in the
2902 arguments after "=". In other words, -MFoo::Bar=:baz is ok, but
2903 -MFoo:Bar=baz is not.
2904 Invalid mro name: '%s'
2906 (F) You tried to "mro::set_mro("classname", "foo")" or "use mro
2907 'foo'", where "foo" is not a valid method resolution order (MRO).
2908 Currently, the only valid ones supported are "dfs" and "c3", unless
2909 you have loaded a module that is a MRO plugin. See mro and
2910 perlmroapi.
2911 Invalid negative number (%s) in chr
2913 (W utf8) You passed a negative number to "chr". Negative numbers
2914 are not valid character numbers, so it returns the Unicode
2915 replacement character (U+FFFD).
2916 Invalid number '%s' for -C option.
2918 (F) You supplied a number to the -C option that either has extra
2919 leading zeroes or overflows perl's unsigned integer representation.
2920 invalid option -D%c, use -D'' to see choices
2922 (S debugging) Perl was called with invalid debugger flags. Call
2923 perl with the -D option with no flags to see the list of acceptable
2924 values. See also "-Dletters" in perlrun.
2925 Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/
2927 (F) The pattern looks like a {min,max} quantifier, but the min or
2928 max could not be parsed as a valid number - either it has leading
2929 zeroes, or it represents too big a number to cope with. The
2930 <-- HERE shows where in the regular expression the problem was
2931 discovered. See perlre.
2932 Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
2934 (F) The range specified in a character class had a minimum
2935 character greater than the maximum character. One possibility is
2936 that you forgot the "{}" from your ending "\x{}" - "\x" without the
2937 curly braces can go only up to "ff". The <-- HERE shows
2938 whereabouts in the regular expression the problem was discovered.
2939 See perlre.
2940 Invalid range "%s" in transliteration operator
2942 (F) The range specified in the tr/// or y/// operator had a minimum
2943 character greater than the maximum character. See perlop.
2944 Invalid reference to group in regex; marked by <-- HERE in m/%s/
2946 (F) The capture group you specified can't possibly exist because
2947 the number you used is not within the legal range of possible
2948 values for this machine.
2949 Invalid separator character %s in attribute list
2951 (F) Something other than a colon or whitespace was seen between the
2952 elements of an attribute list. If the previous attribute had a
2953 parenthesised parameter list, perhaps that list was terminated too
2954 soon. See attributes.
2955 Invalid separator character %s in PerlIO layer specification %s
2957 (W layer) When pushing layers onto the Perl I/O system, something
2958 other than a colon or whitespace was seen between the elements of a
2959 layer list. If the previous attribute had a parenthesised
2960 parameter list, perhaps that list was terminated too soon.
2961 Invalid strict version format (%s)
2963 (F) A version number did not meet the "strict" criteria for
2964 versions. A "strict" version number is a positive decimal number
2965 (integer or decimal-fraction) without exponentiation or else a
2966 dotted-decimal v-string with a leading 'v' character and at least
2967 three components. The parenthesized text indicates which criteria
2968 were not met. See the version module for more details on allowed
2969 version formats.
2970 Invalid type '%s' in %s
2972 (F) The given character is not a valid pack or unpack type. See
2973 "pack" in perlfunc.
2974 (W) The given character is not a valid pack or unpack type but used
2976 to be silently ignored.
2977 Invalid version format (%s)
2979 (F) A version number did not meet the "lax" criteria for versions.
2980 A "lax" version number is a positive decimal number (integer or
2981 decimal-fraction) without exponentiation or else a dotted-decimal
2982 v-string. If the v-string has fewer than three components, it must
2983 have a leading 'v' character. Otherwise, the leading 'v' is
2984 optional. Both decimal and dotted-decimal versions may have a
2985 trailing "alpha" component separated by an underscore character
2986 after a fractional or dotted-decimal component. The parenthesized
2987 text indicates which criteria were not met. See the version module
2988 for more details on allowed version formats.
2989 Invalid version object
2991 (F) The internal structure of the version object was invalid.
2992 Perhaps the internals were modified directly in some way or an
2993 arbitrary reference was blessed into the "version" class.
2994 In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by
2996 <-- HERE in m/%s/
2997 Inverting a character class which contains a multi-character sequence
2998 is illegal in regex; marked by <-- HERE in m/%s/
2999 (F) You wrote something like
3000 qr/\P{name=KATAKANA LETTER AINU P}/
3002 qr/[^\p{name=KATAKANA LETTER AINU P}]/
3003 This name actually evaluates to a sequence of two Katakana
3005 characters, not just a single one, and it is illegal to try to take
3006 the complement of a sequence. (Mathematically it would mean any
3007 sequence of characters from 0 to infinity in length that weren't
3008 these two in a row, and that is likely not of any real use.)
3009 (F) The two-character sequence "(*" in this context in a regular
3011 expression pattern should be an indivisible token, with nothing
3012 intervening between the "(" and the "*", but you separated them.
3013 ioctl is not implemented
3015 (F) Your machine apparently doesn't implement ioctl(), which is
3016 pretty strange for a machine that supports C.
3017 ioctl() on unopened %s
3019 (W unopened) You tried ioctl() on a filehandle that was never
3020 opened. Check your control flow and number of arguments.
3021 IO layers (like '%s') unavailable
3023 (F) Your Perl has not been configured to have PerlIO, and therefore
3024 you cannot use IO layers. To have PerlIO, Perl must be configured
3025 with 'useperlio'.
3026 IO::Socket::atmark not implemented on this architecture
3028 (F) Your machine doesn't implement the sockatmark() functionality,
3029 neither as a system call nor an ioctl call (SIOCATMARK).
3030 '%s' is an unknown bound type in regex; marked by <-- HERE in m/%s/
3032 (F) You used "\b{...}" or "\B{...}" and the "..." is not known to
3033 Perl. The current valid ones are given in "\b{}, \b, \B{}, \B" in
3034 perlrebackslash.
3035 %s() isn't allowed on :utf8 handles
3037 (F) The sysread(), recv(), syswrite() and send() operators are not
3038 allowed on handles that have the ":utf8" layer, either explicitly,
3039 or implicitly, eg., with the :encoding(UTF-16LE) layer.
3040 Previously sysread() and recv() currently use only the ":utf8" flag
3042 for the stream, ignoring the actual layers. Since sysread() and
3043 recv() did no UTF-8 validation they can end up creating invalidly
3044 encoded scalars.
3045 Similarly, syswrite() and send() used only the ":utf8" flag,
3047 otherwise ignoring any layers. If the flag is set, both wrote the
3048 value UTF-8 encoded, even if the layer is some different encoding,
3049 such as the example above.
3050 Ideally, all of these operators would completely ignore the ":utf8"
3052 state, working only with bytes, but this would result in silently
3053 breaking existing code.
3054 "%s" is more clearly written simply as "%s" in regex; marked by
3056 <-- HERE in m/%s/
3057 (W regexp) (only under "use re 'strict'" or within "(?[...])")
3058 You specified a character that has the given plainer way of writing
3060 it, and which is also portable to platforms running with different
3061 character sets.
3062 $* is no longer supported as of Perl 5.30
3064 (F) The special variable $*, deprecated in older perls, was removed
3065 in 5.10.0, is no longer supported and is a fatal error as of Perl
3066 5.30. In previous versions of perl the use of $* enabled or
3067 disabled multi-line matching within a string.
3068 Instead of using $* you should use the "/m" (and maybe "/s") regexp
3070 modifiers. You can enable "/m" for a lexical scope (even a whole
3071 file) with "use re '/m'". (In older versions: when $* was set to a
3072 true value then all regular expressions behaved as if they were
3073 written using "/m".)
3074 Use of this variable will be a fatal error in Perl 5.30.
3076 $# is no longer supported as of Perl 5.30
3078 (F) The special variable $#, deprecated in older perls, was removed
3079 as of 5.10.0, is no longer supported and is a fatal error as of
3080 Perl 5.30. You should use the printf/sprintf functions instead.
3081 '%s' is not a code reference
3083 (W overload) The second (fourth, sixth, ...) argument of
3084 overload::constant needs to be a code reference. Either an
3085 anonymous subroutine, or a reference to a subroutine.
3086 '%s' is not an overloadable type
3088 (W overload) You tried to overload a constant type the overload
3089 package is unaware of.
3090 '%s' is not recognised as a builtin function
3092 (F) An attempt was made to "use" the builtin pragma module to
3093 create a lexical alias for an unknown function name.
3094 -i used with no filenames on the command line, reading from STDIN
3096 (S inplace) The "-i" option was passed on the command line,
3097 indicating that the script is intended to edit files in place, but
3098 no files were given. This is usually a mistake, since editing
3099 STDIN in place doesn't make sense, and can be confusing because it
3100 can make perl look like it is hanging when it is really just trying
3101 to read from STDIN. You should either pass a filename to edit, or
3102 remove "-i" from the command line. See perlrun for more details.
3103 Junk on end of regexp in regex m/%s/
3105 (P) The regular expression parser is confused.
3106 \K not permitted in lookahead/lookbehind in regex; marked by <-- HERE
3108 in m/%s/
3109 (F) Your regular expression used "\K" in a lookahead or lookbehind
3110 assertion, which currently isn't permitted.
3111 This may change in the future, see Support \K in lookarounds
3113 <https://github.com/Perl/perl5/issues/18134>.
3114 Label not found for "last %s"
3116 (F) You named a loop to break out of, but you're not currently in a
3117 loop of that name, not even if you count where you were called
3118 from. See "last" in perlfunc.
3119 Label not found for "next %s"
3121 (F) You named a loop to continue, but you're not currently in a
3122 loop of that name, not even if you count where you were called
3123 from. See "last" in perlfunc.
3124 Label not found for "redo %s"
3126 (F) You named a loop to restart, but you're not currently in a loop
3127 of that name, not even if you count where you were called from.
3128 See "last" in perlfunc.
3129 leaving effective %s failed
3131 (F) While under the "use filetest" pragma, switching the real and
3132 effective uids or gids failed.
3133 length/code after end of string in unpack
3135 (F) While unpacking, the string buffer was already used up when an
3136 unpack length/code combination tried to obtain more data. This
3137 results in an undefined value for the length. See "pack" in
3138 perlfunc.
3139 length() used on %s (did you mean "scalar(%s)"?)
3141 (W syntax) You used length() on either an array or a hash when you
3142 probably wanted a count of the items.
3143 Array size can be obtained by doing:
3145 scalar(@array);
3147 The number of items in a hash can be obtained by doing:
3149 scalar(keys %hash);
3151 Lexing code attempted to stuff non-Latin-1 character into Latin-1 input
3153 (F) An extension is attempting to insert text into the current
3154 parse (using lex_stuff_pvn or similar), but tried to insert a
3155 character that couldn't be part of the current input. This is an
3156 inherent pitfall of the stuffing mechanism, and one of the reasons
3157 to avoid it. Where it is necessary to stuff, stuffing only plain
3158 ASCII is recommended.
3159 Lexing code internal error (%s)
3161 (F) Lexing code supplied by an extension violated the lexer's API
3162 in a detectable way.
3163 listen() on closed socket %s
3165 (W closed) You tried to do a listen on a closed socket. Did you
3166 forget to check the return value of your socket() call? See
3167 "listen" in perlfunc.
3168 List form of piped open not implemented
3170 (F) On some platforms, notably Windows, the three-or-more-arguments
3171 form of "open" does not support pipes, such as "open($pipe, '|-',
3172 @args)". Use the two-argument "open($pipe, '|prog arg1 arg2...')"
3173 form instead.
3174 Literal vertical space in [] is illegal except under /x in regex;
3176 marked by <-- HERE in m/%s/
3177 (F) (only under "use re 'strict'" or within "(?[...])")
3178 Likely you forgot the "/x" modifier or there was a typo in the
3180 pattern. For example, did you really mean to match a form-feed?
3181 If so, all the ASCII vertical space control characters are
3182 representable by escape sequences which won't present such a
3183 jarring appearance as your pattern does when displayed.
3184 \r carriage return
3186 \f form feed
3187 \n line feed
3188 \cK vertical tab
3189 %s: loadable library and perl binaries are mismatched (got %s handshake
3191 key %p, needed %p)
3192 (P) A dynamic loading library ".so" or ".dll" was being loaded into
3193 the process that was built against a different build of perl than
3194 the said library was compiled against. Reinstalling the XS module
3195 will likely fix this error.
3196 Locale '%s' contains (at least) the following characters which have
3198 unexpected meanings: %s The Perl program will use the expected
3199 meanings
3200 (W locale) You are using the named UTF-8 locale. UTF-8 locales are
3201 expected to have very particular behavior, which most do. This
3202 message arises when perl found some departures from the
3203 expectations, and is notifying you that the expected behavior
3204 overrides these differences. In some cases the differences are
3205 caused by the locale definition being defective, but the most
3206 common causes of this warning are when there are ambiguities and
3207 conflicts in following the Standard, and the locale has chosen an
3208 approach that differs from Perl's.
3209 One of these is because that, contrary to the claims, Unicode is
3211 not completely locale insensitive. Turkish and some related
3212 languages have two types of "I" characters. One is dotted in both
3213 upper- and lowercase, and the other is dotless in both cases.
3214 Unicode allows a locale to use either the Turkish rules, or the
3215 rules used in all other instances, where there is only one type of
3216 "I", which is dotless in the uppercase, and dotted in the lower.
3217 The perl core does not (yet) handle the Turkish case, and this
3218 message warns you of that. Instead, the Unicode::Casing module
3219 allows you to mostly implement the Turkish casing rules.
3220 The other common cause is for the characters
3222 $ + < = > ^ ` | ~
3224 These are problematic. The C standard says that these should be
3226 considered punctuation in the C locale (and the POSIX standard
3227 defers to the C standard), and Unicode is generally considered a
3228 superset of the C locale. But Unicode has added an extra category,
3229 "Symbol", and classifies these particular characters as being
3230 symbols. Most UTF-8 locales have them treated as punctuation, so
3231 that ispunct(3) returns non-zero for them. But a few locales have
3232 it return 0. Perl takes the first approach, not using ispunct()
3233 at all (see Note [5] in perlrecharclass), and this message is
3234 raised to notify you that you are getting Perl's approach, not the
3235 locale's.
3236 Locale '%s' is unsupported, and may crash the interpreter.
3238 (S locale) The named locale is not supported by Perl, and using it
3239 leads to undefined behavior, including potentially crashing the
3240 computer.
3241 Currently the only locales that generate this severe warning are
3243 non-UTF-8 ones which have characters that require more than one
3244 byte to represent (common in older East Asian language locales).
3245 See perllocale.
3246 Locale '%s' may not work well.%s
3248 (W locale) You are using the named locale, which is a non-UTF-8
3249 one, and which perl has determined is not fully compatible with
3250 what it can handle. The second %s gives a reason.
3251 By far the most common reason is that the locale has characters in
3253 it that are represented by more than one byte. The only such
3254 locales that Perl can handle are the UTF-8 locales. Most likely
3255 the specified locale is a non-UTF-8 one for an East Asian language
3256 such as Chinese or Japanese. If the locale is a superset of ASCII,
3257 the ASCII portion of it may work in Perl.
3258 Some essentially obsolete locales that aren't supersets of ASCII,
3260 mainly those in ISO 646 or other 7-bit locales, such as ASMO 449,
3261 can also have problems, depending on what portions of the ASCII
3262 character set get changed by the locale and are also used by the
3263 program. The warning message lists the determinable conflicting
3264 characters.
3265 Note that not all incompatibilities are found.
3267 If this happens to you, there's not much you can do except switch
3269 to use a different locale or use Encode to translate from the
3270 locale into UTF-8; if that's impracticable, you have been warned
3271 that some things may break.
3272 This message is output once each time a bad locale is switched into
3274 within the scope of "use locale", or on the first possibly-affected
3275 operation if the "use locale" inherits a bad one. It is not raised
3276 for any operations from the POSIX module.
3277 localtime(%f) failed
3279 (W overflow) You called "localtime" with a number that it could not
3280 handle: too large, too small, or NaN. The returned value is
3281 "undef".
3282 localtime(%f) too large
3284 (W overflow) You called "localtime" with a number that was larger
3285 than it can reliably handle and "localtime" probably returned the
3286 wrong date. This warning is also triggered with NaN (the special
3287 not-a-number value).
3288 localtime(%f) too small
3290 (W overflow) You called "localtime" with a number that was smaller
3291 than it can reliably handle and "localtime" probably returned the
3292 wrong date.
3293 Lookbehind longer than %d not implemented in regex m/%s/
3295 (F) There is currently a limit on the length of string which
3296 lookbehind can handle. This restriction may be eased in a future
3297 release.
3298 Lost precision when %s %f by 1
3300 (W imprecision) You attempted to increment or decrement a value by
3301 one, but the result is too large for the underlying floating point
3302 representation to store accurately. Hence, the target of "++" or
3303 "--" is increased or decreased by quite different value than one,
3304 such as zero (i.e. the target is unchanged) or two, due to
3305 rounding. Perl issues this warning because it has already switched
3306 from integers to floating point when values are too large for
3307 integers, and now even floating point is insufficient. You may
3308 wish to switch to using Math::BigInt explicitly.
3309 lstat() on filehandle%s
3311 (W io) You tried to do an lstat on a filehandle. What did you mean
3312 by that? lstat() makes sense only on filenames. (Perl did a
3313 fstat() instead on the filehandle.)
3314 lvalue attribute %s already-defined subroutine
3316 (W misc) Although attributes.pm allows this, turning the lvalue
3317 attribute on or off on a Perl subroutine that is already defined
3318 does not always work properly. It may or may not do what you want,
3319 depending on what code is inside the subroutine, with exact details
3320 subject to change between Perl versions. Only do this if you
3321 really know what you are doing.
3322 lvalue attribute ignored after the subroutine has been defined
3324 (W misc) Using the ":lvalue" declarative syntax to make a Perl
3325 subroutine an lvalue subroutine after it has been defined is not
3326 permitted. To make the subroutine an lvalue subroutine, add the
3327 lvalue attribute to the definition, or put the "sub foo :lvalue;"
3328 declaration before the definition.
3329 See also attributes.pm.
3331 Magical list constants are not supported
3333 (F) You assigned a magical array to a stash element, and then tried
3334 to use the subroutine from the same slot. You are asking Perl to
3335 do something it cannot do, details subject to change between Perl
3336 versions.
3337 Malformed integer in [] in pack
3339 (F) Between the brackets enclosing a numeric repeat count only
3340 digits are permitted. See "pack" in perlfunc.
3341 Malformed integer in [] in unpack
3343 (F) Between the brackets enclosing a numeric repeat count only
3344 digits are permitted. See "pack" in perlfunc.
3345 Malformed PERLLIB_PREFIX
3347 (F) An error peculiar to OS/2. PERLLIB_PREFIX should be of the
3348 form
3349 prefix1;prefix2
3351 or
3353 prefix1 prefix2
3354 with nonempty prefix1 and prefix2. If "prefix1" is indeed a prefix
3356 of a builtin library search path, prefix2 is substituted. The
3357 error may appear if components are not found, or are too long. See
3358 "PERLLIB_PREFIX" in perlos2.
3359 Malformed prototype for %s: %s
3361 (F) You tried to use a function with a malformed prototype. The
3362 syntax of function prototypes is given a brief compile-time check
3363 for obvious errors like invalid characters. A more rigorous check
3364 is run when the function is called. Perhaps the function's author
3365 was trying to write a subroutine signature but didn't enable that
3366 feature first ("use feature 'signatures'"), so the signature was
3367 instead interpreted as a bad prototype.
3368 Malformed UTF-8 character%s
3370 (S utf8)(F) Perl detected a string that should be UTF-8, but didn't
3371 comply with UTF-8 encoding rules, or represents a code point whose
3372 ordinal integer value doesn't fit into the word size of the current
3373 platform (overflows). Details as to the exact malformation are
3374 given in the variable, %s, part of the message.
3375 One possible cause is that you set the UTF8 flag yourself for data
3377 that you thought to be in UTF-8 but it wasn't (it was for example
3378 legacy 8-bit data). To guard against this, you can use
3379 "Encode::decode('UTF-8', ...)".
3380 If you use the :encoding(UTF-8) PerlIO layer for input, invalid
3382 byte sequences are handled gracefully, but if you use ":utf8", the
3383 flag is set without validating the data, possibly resulting in this
3384 error message.
3385 See also "Handling Malformed Data" in Encode.
3387 Malformed UTF-8 returned by \N{%s} immediately after '%s'
3389 (F) The charnames handler returned malformed UTF-8.
3390 Malformed UTF-8 string in "%s"
3392 (F) This message indicates a bug either in the Perl core or in XS
3393 code. Such code was trying to find out if a character, allegedly
3394 stored internally encoded as UTF-8, was of a given type, such as
3395 being punctuation or a digit. But the character was not encoded in
3396 legal UTF-8. The %s is replaced by a string that can be used by
3397 knowledgeable people to determine what the type being checked
3398 against was.
3399 Passing malformed strings was deprecated in Perl 5.18, and became
3401 fatal in Perl 5.26.
3402 Malformed UTF-8 string in '%c' format in unpack
3404 (F) You tried to unpack something that didn't comply with UTF-8
3405 encoding rules and perl was unable to guess how to make more
3406 progress.
3407 Malformed UTF-8 string in pack
3409 (F) You tried to pack something that didn't comply with UTF-8
3410 encoding rules and perl was unable to guess how to make more
3411 progress.
3412 Malformed UTF-8 string in unpack
3414 (F) You tried to unpack something that didn't comply with UTF-8
3415 encoding rules and perl was unable to guess how to make more
3416 progress.
3417 Malformed UTF-16 surrogate
3419 (F) Perl thought it was reading UTF-16 encoded character data but
3420 while doing it Perl met a malformed Unicode surrogate.
3421 Mandatory parameter follows optional parameter
3423 (F) In a subroutine signature, you wrote something like "$a =
3424 undef, $b", making an earlier parameter optional and a later one
3425 mandatory. Parameters are filled from left to right, so it's
3426 impossible for the caller to omit an earlier one and pass a later
3427 one. If you want to act as if the parameters are filled from right
3428 to left, declare the rightmost optional and then shuffle the
3429 parameters around in the subroutine's body.
3430 Matched non-Unicode code point 0x%X against Unicode property; may not
3432 be portable
3433 (S non_unicode) Perl allows strings to contain a superset of
3434 Unicode code points; each code point may be as large as what is
3435 storable in a signed integer on your system, but these may not be
3436 accepted by other languages/systems. This message occurs when you
3437 matched a string containing such a code point against a regular
3438 expression pattern, and the code point was matched against a
3439 Unicode property, "\p{...}" or "\P{...}". Unicode properties are
3440 only defined on Unicode code points, so the result of this match is
3441 undefined by Unicode, but Perl (starting in v5.20) treats non-
3442 Unicode code points as if they were typical unassigned Unicode
3443 ones, and matched this one accordingly. Whether a given property
3444 matches these code points or not is specified in "Properties
3445 accessible through \p{} and \P{}" in perluniprops.
3446 This message is suppressed (unless it has been made fatal) if it is
3448 immaterial to the results of the match if the code point is Unicode
3449 or not. For example, the property "\p{ASCII_Hex_Digit}" only can
3450 match the 22 characters "[0-9A-Fa-f]", so obviously all other code
3451 points, Unicode or not, won't match it. (And "\P{ASCII_Hex_Digit}"
3452 will match every code point except these 22.)
3453 Getting this message indicates that the outcome of the match
3455 arguably should have been the opposite of what actually happened.
3456 If you think that is the case, you may wish to make the
3457 "non_unicode" warnings category fatal; if you agree with Perl's
3458 decision, you may wish to turn off this category.
3459 See "Beyond Unicode code points" in perlunicode for more
3461 information.
3462 %s matches null string many times in regex; marked by <-- HERE in m/%s/
3464 (W regexp) The pattern you've specified would be an infinite loop
3465 if the regular expression engine didn't specifically check for
3466 that. The <-- HERE shows whereabouts in the regular expression the
3467 problem was discovered. See perlre.
3468 Maximal count of pending signals (%u) exceeded
3470 (F) Perl aborted due to too high a number of signals pending. This
3471 usually indicates that your operating system tried to deliver
3472 signals too fast (with a very high priority), starving the perl
3473 process from resources it would need to reach a point where it can
3474 process signals safely. (See "Deferred Signals (Safe Signals)" in
3475 perlipc.)
3476 "%s" may clash with future reserved word
3478 (W) This warning may be due to running a perl5 script through a
3479 perl4 interpreter, especially if the word that is being warned
3480 about is "use" or "my".
3481 '%' may not be used in pack
3483 (F) You can't pack a string by supplying a checksum, because the
3484 checksumming process loses information, and you can't go the other
3485 way. See "unpack" in perlfunc.
3486 Method for operation %s not found in package %s during blessing
3488 (F) An attempt was made to specify an entry in an overloading table
3489 that doesn't resolve to a valid subroutine. See overload.
3490 method is experimental
3492 (S experimental::class) This warning is emitted if you use the
3493 "method" keyword of "use feature 'class'". This keyword is
3494 currently experimental and its behaviour may change in future
3495 releases of Perl.
3496 Method %s not permitted
3498 See "500 Server error".
3499 Method %s redefined
3501 (W redefine) You redefined a method. To suppress this warning, say
3502 {
3504 no warnings 'redefine';
3505 *name = method { ... };
3506 }
3507 Might be a runaway multi-line %s string starting on line %d
3509 (S) An advisory indicating that the previous error may have been
3510 caused by a missing delimiter on a string or pattern, because it
3511 eventually ended earlier on the current line.
3512 Mismatched brackets in template
3514 (F) A pack template could not be parsed because pairs of "[...]" or
3515 "(...)" could not be matched up. See "pack" in perlfunc.
3516 Misplaced _ in number
3518 (W syntax) An underscore (underbar) in a numeric constant did not
3519 separate two digits.
3520 Missing argument for %n in %s
3522 (F) A %n was used in a format string with no corresponding argument
3523 for perl to write the current string length to.
3524 Missing argument in %s
3526 (W missing) You called a function with fewer arguments than other
3527 arguments you supplied indicated would be needed.
3528 Currently only emitted when a printf-type format required more
3530 arguments than were supplied, but might be used in the future for
3531 other cases where we can statically determine that arguments to
3532 functions are missing, e.g. for the "pack" in perlfunc function.
3533 Missing argument to -%c
3535 (F) The argument to the indicated command line switch must follow
3536 immediately after the switch, without intervening spaces.
3537 Missing braces on \N{}
3539 Missing braces on \N{} in regex; marked by <-- HERE in m/%s/
3540 (F) Wrong syntax of character name literal "\N{charname}" within
3541 double-quotish context. This can also happen when there is a space
3542 (or comment) between the "\N" and the "{" in a regex with the "/x"
3543 modifier. This modifier does not change the requirement that the
3544 brace immediately follow the "\N".
3545 Missing braces on \o{}
3547 (F) A "\o" must be followed immediately by a "{" in double-quotish
3548 context.
3549 Missing comma after first argument to %s function
3551 (F) While certain functions allow you to specify a filehandle or an
3552 "indirect object" before the argument list, this ain't one of them.
3553 Missing command in piped open
3555 (W pipe) You used the "open(FH, "| command")" or "open(FH, "command
3556 |")" construction, but the command was missing or blank.
3557 Missing control char name in \c
3559 (F) A double-quoted string ended with "\c", without the required
3560 control character name.
3561 Missing ']' in prototype for %s : %s
3563 (W illegalproto) A grouping was started with "[" but never closed
3564 with "]".
3565 Missing name in "%s sub"
3567 (F) The syntax for lexically scoped subroutines requires that they
3568 have a name with which they can be found.
3569 Missing $ on loop variable
3571 (F) Apparently you've been programming in csh too much. Variables
3572 are always mentioned with the $ in Perl, unlike in the shells,
3573 where it can vary from one line to the next.
3574 (Missing operator before %s?)
3576 (S syntax) This is an educated guess made in conjunction with the
3577 message "%s found where operator expected". Often the missing
3578 operator is a comma.
3579 Missing or undefined argument to %s
3581 (F) You tried to call "require" or "do" with no argument or with an
3582 undefined value as an argument. Require expects either a package
3583 name or a file-specification as an argument; do expects a filename.
3584 See "require EXPR" in perlfunc and "do EXPR" in perlfunc.
3585 Missing or undefined argument to %s via %{^HOOK}{require__before}
3587 (F) A "%{^HOOK}{require__before}" hook rewrote the name of the file
3588 being compiled with "require" or "do" with an empty string an
3589 undefined value which is forbidden. See "%{^HOOK}" in perlvar and
3590 "require EXPR" in perlfunc.
3591 Missing right brace on \%c{} in regex; marked by <-- HERE in m/%s/
3593 (F) Missing right brace in "\x{...}", "\p{...}", "\P{...}", or
3594 "\N{...}".
3595 Missing right brace on \N{}
3597 Missing right brace on \N{} or unescaped left brace after \N
3598 (F) "\N" has two meanings.
3599 The traditional one has it followed by a name enclosed in braces,
3601 meaning the character (or sequence of characters) given by that
3602 name. Thus "\N{ASTERISK}" is another way of writing "*", valid in
3603 both double-quoted strings and regular expression patterns. In
3604 patterns, it doesn't have the meaning an unescaped "*" does.
3605 Starting in Perl 5.12.0, "\N" also can have an additional meaning
3607 (only) in patterns, namely to match a non-newline character. (This
3608 is short for "[^\n]", and like "." but is not affected by the "/s"
3609 regex modifier.)
3610 This can lead to some ambiguities. When "\N" is not followed
3612 immediately by a left brace, Perl assumes the "[^\n]" meaning.
3613 Also, if the braces form a valid quantifier such as "\N{3}" or
3614 "\N{5,}", Perl assumes that this means to match the given quantity
3615 of non-newlines (in these examples, 3; and 5 or more,
3616 respectively). In all other case, where there is a "\N{" and a
3617 matching "}", Perl assumes that a character name is desired.
3618 However, if there is no matching "}", Perl doesn't know if it was
3620 mistakenly omitted, or if "[^\n]{" was desired, and raises this
3621 error. If you meant the former, add the right brace; if you meant
3622 the latter, escape the brace with a backslash, like so: "\N\{"
3623 Missing right curly or square bracket
3625 (F) The lexer counted more opening curly or square brackets than
3626 closing ones. As a general rule, you'll find it's missing near the
3627 place you were last editing.
3628 (Missing semicolon on previous line?)
3630 (S syntax) This is an educated guess made in conjunction with the
3631 message "%s found where operator expected". Don't automatically
3632 put a semicolon on the previous line just because you saw this
3633 message.
3634 Modification of a read-only value attempted
3636 (F) You tried, directly or indirectly, to change the value of a
3637 constant. You didn't, of course, try "2 = 1", because the compiler
3638 catches that. But an easy way to do the same thing is:
3639 sub mod { $_[0] = 1 }
3641 mod(2);
3642 Another way is to assign to a substr() that's off the end of the
3644 string.
3645 Yet another way is to assign to a "foreach" loop VAR when VAR is
3647 aliased to a constant in the look LIST:
3648 $x = 1;
3650 foreach my $n ($x, 2) {
3651 $n *= 2; # modifies the $x, but fails on attempt to
3652 } # modify the 2
3653 PerlIO::scalar will also produce this message as a warning if you
3655 attempt to open a read-only scalar for writing.
3656 Modification of non-creatable array value attempted, %s
3658 (F) You tried to make an array value spring into existence, and the
3659 subscript was probably negative, even counting from end of the
3660 array backwards.
3661 Modification of non-creatable hash value attempted, %s
3663 (P) You tried to make a hash value spring into existence, and it
3664 couldn't be created for some peculiar reason.
3665 Module name must be constant
3667 (F) Only a bare module name is allowed as the first argument to a
3668 "use".
3669 Module name required with -%c option
3671 (F) The "-M" or "-m" options say that Perl should load some module,
3672 but you omitted the name of the module. Consult perlrun for full
3673 details about "-M" and "-m".
3674 More than one argument to '%s' open
3676 (F) The "open" function has been asked to open multiple files.
3677 This can happen if you are trying to open a pipe to a command that
3678 takes a list of arguments, but have forgotten to specify a piped
3679 open mode. See "open" in perlfunc for details.
3680 mprotect for COW string %p %u failed with %d
3682 (S) You compiled perl with -DPERL_DEBUG_READONLY_COW (see "Copy on
3683 Write" in perlguts), but a shared string buffer could not be made
3684 read-only.
3685 mprotect for %p %u failed with %d
3687 (S) You compiled perl with -DPERL_DEBUG_READONLY_OPS (see
3688 perlhacktips), but an op tree could not be made read-only.
3689 mprotect RW for COW string %p %u failed with %d
3691 (S) You compiled perl with -DPERL_DEBUG_READONLY_COW (see "Copy on
3692 Write" in perlguts), but a read-only shared string buffer could not
3693 be made mutable.
3694 mprotect RW for %p %u failed with %d
3696 (S) You compiled perl with -DPERL_DEBUG_READONLY_OPS (see
3697 perlhacktips), but a read-only op tree could not be made mutable
3698 before freeing the ops.
3699 msg%s not implemented
3701 (F) You don't have System V message IPC on your system.
3702 Multidimensional hash lookup is disabled
3704 (F) You supplied a list of subscripts to a hash lookup under "no
3705 feature "multidimensional";", eg:
3706 $z = $foo{$x, $y};
3708 which by default acts like:
3710 $z = $foo{join($;, $x, $y)};
3712 Multidimensional syntax %s not supported
3714 (W syntax) Multidimensional arrays aren't written like $foo[1,2,3].
3715 They're written like "$foo[1][2][3]", as in C.
3716 Multiple slurpy parameters not allowed
3718 (F) In subroutine signatures, a slurpy parameter ("@" or "%") must
3719 be the last parameter, and there must not be more than one of them;
3720 for example:
3721 sub foo ($a, @b) {} # legal
3723 sub foo ($a, @b, %) {} # invalid
3724 '/' must follow a numeric type in unpack
3726 (F) You had an unpack template that contained a '/', but this did
3727 not follow some unpack specification producing a numeric value.
3728 See "pack" in perlfunc.
3729 %s must not be a named sequence in transliteration operator
3731 (F) Transliteration ("tr///" and "y///") transliterates individual
3732 characters. But a named sequence by definition is more than an
3733 individual character, and hence doing this operation on it doesn't
3734 make sense.
3735 "my sub" not yet implemented
3737 (F) Lexically scoped subroutines are not yet implemented. Don't
3738 try that yet.
3739 "my" subroutine %s can't be in a package
3741 (F) Lexically scoped subroutines aren't in a package, so it doesn't
3742 make sense to try to declare one with a package qualifier on the
3743 front.
3744 "my %s" used in sort comparison
3746 (W syntax) The package variables $a and $b are used for sort
3747 comparisons. You used $a or $b in as an operand to the "<=>" or
3748 "cmp" operator inside a sort comparison block, and the variable had
3749 earlier been declared as a lexical variable. Either qualify the
3750 sort variable with the package name, or rename the lexical
3751 variable.
3752 "my" variable %s can't be in a package
3754 (F) Lexically scoped variables aren't in a package, so it doesn't
3755 make sense to try to declare one with a package qualifier on the
3756 front. Use local() if you want to localize a package variable.
3757 Name "%s::%s" used only once: possible typo
3759 (W once) Typographical errors often show up as unique variable
3760 names. If you had a good reason for having a unique name, then
3761 just mention it again somehow to suppress the message. The "our"
3762 declaration is also provided for this purpose.
3763 NOTE: This warning detects package symbols that have been used only
3765 once. This means lexical variables will never trigger this
3766 warning. It also means that all of the package variables $c, @c,
3767 %c, as well as *c, &c, sub c{}, c(), and c (the filehandle or
3768 format) are considered the same; if a program uses $c only once but
3769 also uses any of the others it will not trigger this warning.
3770 Symbols beginning with an underscore and symbols using special
3771 identifiers (q.v. perldata) are exempt from this warning.
3772 Need exactly 3 octal digits in regex; marked by <-- HERE in m/%s/
3774 (F) Within "(?[ ])", all constants interpreted as octal need to
3775 be exactly 3 digits long. This helps catch some ambiguities. If
3776 your constant is too short, add leading zeros, like
3777 (?[ [ \078 ] ]) # Syntax error!
3779 (?[ [ \0078 ] ]) # Works
3780 (?[ [ \007 8 ] ]) # Clearer
3781 The maximum number this construct can express is "\777". If you
3783 need a larger one, you need to use \o{} instead. If you meant two
3784 separate things, you need to separate them:
3785 (?[ [ \7776 ] ]) # Syntax error!
3787 (?[ [ \o{7776} ] ]) # One meaning
3788 (?[ [ \777 6 ] ]) # Another meaning
3789 (?[ [ \777 \006 ] ]) # Still another
3790 Negative '/' count in unpack
3792 (F) The length count obtained from a length/code unpack operation
3793 was negative. See "pack" in perlfunc.
3794 Negative length
3796 (F) You tried to do a read/write/send/recv operation with a buffer
3797 length that is less than 0. This is difficult to imagine.
3798 Negative offset to vec in lvalue context
3800 (F) When "vec" is called in an lvalue context, the second argument
3801 must be greater than or equal to zero.
3802 Negative repeat count does nothing
3804 (W numeric) You tried to execute the "x" repetition operator fewer
3805 than 0 times, which doesn't make sense.
3806 Nested quantifiers in regex; marked by <-- HERE in m/%s/
3808 (F) You can't quantify a quantifier without intervening
3809 parentheses. So things like ** or +* or ?* are illegal. The
3810 <-- HERE shows whereabouts in the regular expression the problem
3811 was discovered.
3812 Note that the minimal matching quantifiers, "*?", "+?", and "??"
3814 appear to be nested quantifiers, but aren't. See perlre.
3815 %s never introduced
3817 (S internal) The symbol in question was declared but somehow went
3818 out of scope before it could possibly have been used.
3819 next::method/next::can/maybe::next::method cannot find enclosing method
3821 (F) "next::method" needs to be called within the context of a real
3822 method in a real package, and it could not find such a context.
3823 See mro.
3824 \N in a character class must be a named character: \N{...} in regex;
3826 marked by <-- HERE in m/%s/
3827 (F) The new (as of Perl 5.12) meaning of "\N" as "[^\n]" is not
3828 valid in a bracketed character class, for the same reason that "."
3829 in a character class loses its specialness: it matches almost
3830 everything, which is probably not what you want.
3831 \N{} here is restricted to one character in regex; marked by <-- HERE
3833 in m/%s/
3834 (F) Named Unicode character escapes ("\N{...}") may return a multi-
3835 character sequence. Even though a character class is supposed to
3836 match just one character of input, perl will match the whole thing
3837 correctly, except under certain conditions. These currently are
3838 When the class is inverted ("[^...]")
3840 The mathematically logical behavior for what matches when
3841 inverting is very different from what people expect, so we have
3842 decided to forbid it.
3843 The escape is the beginning or final end point of a range
3845 Similarly unclear is what should be generated when the
3846 "\N{...}" is used as one of the end points of the range, such
3847 as in
3848 [\x{41}-\N{ARABIC SEQUENCE YEH WITH HAMZA ABOVE WITH AE}]
3850 What is meant here is unclear, as the "\N{...}" escape is a
3852 sequence of code points, so this is made an error.
3853 In a regex set
3855 The syntax "(?[ ])" in a regular expression yields a list of
3856 single code points, none can be a sequence.
3857 No %s allowed while running setuid
3859 (F) Certain operations are deemed to be too insecure for a setuid
3860 or setgid script to even be allowed to attempt. Generally speaking
3861 there will be another way to do what you want that is, if not
3862 secure, at least securable. See perlsec.
3863 No code specified for -%c
3865 (F) Perl's -e and -E command-line options require an argument. If
3866 you want to run an empty program, pass the empty string as a
3867 separate argument or run a program consisting of a single 0 or 1:
3868 perl -e ""
3870 perl -e0
3871 perl -e1
3872 No comma allowed after %s
3874 (F) A list operator that has a filehandle or "indirect object" is
3875 not allowed to have a comma between that and the following
3876 arguments. Otherwise it'd be just another one of the arguments.
3877 One possible cause for this is that you expected to have imported a
3879 constant to your name space with use or import while no such
3880 importing took place, it may for example be that your operating
3881 system does not support that particular constant. Hopefully you
3882 did use an explicit import list for the constants you expect to
3883 see; please see "use" in perlfunc and "import" in perlfunc. While
3884 an explicit import list would probably have caught this error
3885 earlier it naturally does not remedy the fact that your operating
3886 system still does not support that constant. Maybe you have a typo
3887 in the constants of the symbol import list of use or import or in
3888 the constant name at the line where this error was triggered?
3889 No command into which to pipe on command line
3891 (F) An error peculiar to VMS. Perl handles its own command line
3892 redirection, and found a '|' at the end of the command line, so it
3893 doesn't know where you want to pipe the output from this command.
3894 No DB::DB routine defined
3896 (F) The currently executing code was compiled with the -d switch,
3897 but for some reason the current debugger (e.g. perl5db.pl or a
3898 "Devel::" module) didn't define a routine to be called at the
3899 beginning of each statement.
3900 No dbm on this machine
3902 (P) This is counted as an internal error, because every machine
3903 should supply dbm nowadays, because Perl comes with SDBM. See
3904 SDBM_File.
3905 No DB::sub routine defined
3907 (F) The currently executing code was compiled with the -d switch,
3908 but for some reason the current debugger (e.g. perl5db.pl or a
3909 "Devel::" module) didn't define a "DB::sub" routine to be called at
3910 the beginning of each ordinary subroutine call.
3911 No digits found for %s literal
3913 (F) No hexadecimal digits were found following "0x" or no binary
3914 digits were found following "0b".
3915 No directory specified for -I
3917 (F) The -I command-line switch requires a directory name as part of
3918 the same argument. Use -Ilib, for instance. -I lib won't work.
3919 No error file after 2> or 2>> on command line
3921 (F) An error peculiar to VMS. Perl handles its own command line
3922 redirection, and found a '2>' or a '2>>' on the command line, but
3923 can't find the name of the file to which to write data destined for
3924 stderr.
3925 No group ending character '%c' found in template
3927 (F) A pack or unpack template has an opening '(' or '[' without its
3928 matching counterpart. See "pack" in perlfunc.
3929 No input file after < on command line
3931 (F) An error peculiar to VMS. Perl handles its own command line
3932 redirection, and found a '<' on the command line, but can't find
3933 the name of the file from which to read data for stdin.
3934 No next::method '%s' found for %s
3936 (F) "next::method" found no further instances of this method name
3937 in the remaining packages of the MRO of this class. If you don't
3938 want it throwing an exception, use "maybe::next::method" or
3939 "next::can". See mro.
3940 Non-finite repeat count does nothing
3942 (W numeric) You tried to execute the "x" repetition operator "Inf"
3943 (or "-Inf") or "NaN" times, which doesn't make sense.
3944 Non-hex character in regex; marked by <-- HERE in m/%s/
3946 (F) In a regular expression, there was a non-hexadecimal character
3947 where a hex one was expected, like
3948 (?[ [ \xDG ] ])
3950 (?[ [ \x{DEKA} ] ])
3951 Non-hex character '%c' terminates \x early. Resolved as "%s"
3953 (W digit) In parsing a hexadecimal numeric constant, a character
3954 was unexpectedly encountered that isn't hexadecimal. The resulting
3955 value is as indicated.
3956 Note that, within braces, every character starting with the first
3958 non-hexadecimal up to the ending brace is ignored.
3959 Non-octal character in regex; marked by <-- HERE in m/%s/
3961 (F) In a regular expression, there was a non-octal character where
3962 an octal one was expected, like
3963 (?[ [ \o{1278} ] ])
3965 Non-octal character '%c' terminates \o early. Resolved as "%s"
3967 (W digit) In parsing an octal numeric constant, a character was
3968 unexpectedly encountered that isn't octal. The resulting value is
3969 as indicated.
3970 When not using "\o{...}", you wrote something like "\08", or "\179"
3972 in a double-quotish string. The resolution is as indicated, with
3973 all but the last digit treated as a single character, specified in
3974 octal. The last digit is the next character in the string. To
3975 tell Perl that this is indeed what you want, you can use the "\o{
3976 }" syntax, or use exactly three digits to specify the octal for the
3977 character.
3978 Note that, within braces, every character starting with the first
3980 non-octal up to the ending brace is ignored.
3981 "no" not allowed in expression
3983 (F) The "no" keyword is recognized and executed at compile time,
3984 and returns no useful value. See perlmod.
3985 Non-string passed as bitmask
3987 (W misc) A number has been passed as a bitmask argument to
3988 select(). Use the vec() function to construct the file descriptor
3989 bitmasks for select. See "select" in perlfunc.
3990 No output file after > on command line
3992 (F) An error peculiar to VMS. Perl handles its own command line
3993 redirection, and found a lone '>' at the end of the command line,
3994 so it doesn't know where you wanted to redirect stdout.
3995 No output file after > or >> on command line
3997 (F) An error peculiar to VMS. Perl handles its own command line
3998 redirection, and found a '>' or a '>>' on the command line, but
3999 can't find the name of the file to which to write data destined for
4000 stdout.
4001 No package name allowed for subroutine %s in "our"
4003 No package name allowed for variable %s in "our"
4004 (F) Fully qualified subroutine and variable names are not allowed
4005 in "our" declarations, because that doesn't make much sense under
4006 existing rules. Such syntax is reserved for future extensions.
4007 No Perl script found in input
4009 (F) You called "perl -x", but no line was found in the file
4010 beginning with #! and containing the word "perl".
4011 No setregid available
4013 (F) Configure didn't find anything resembling the setregid() call
4014 for your system.
4015 No setreuid available
4017 (F) Configure didn't find anything resembling the setreuid() call
4018 for your system.
4019 No such class %s
4021 (F) You provided a class qualifier in a "my", "our" or "state"
4022 declaration, but this class doesn't exist at this point in your
4023 program.
4024 No such class field "%s" in variable %s of type %s
4026 (F) You tried to access a key from a hash through the indicated
4027 typed variable but that key is not allowed by the package of the
4028 same type. The indicated package has restricted the set of allowed
4029 keys using the fields pragma.
4030 No such hook: %s
4032 (F) You specified a signal hook that was not recognized by Perl.
4033 Currently, Perl accepts "__DIE__" and "__WARN__" as valid signal
4034 hooks.
4035 No such pipe open
4037 (P) An error peculiar to VMS. The internal routine my_pclose()
4038 tried to close a pipe which hadn't been opened. This should have
4039 been caught earlier as an attempt to close an unopened filehandle.
4040 No such signal: SIG%s
4042 (W signal) You specified a signal name as a subscript to %SIG that
4043 was not recognized. Say "kill -l" in your shell to see the valid
4044 signal names on your system.
4045 No Unicode property value wildcard matches:
4047 (W regexp) You specified a wildcard for a Unicode property value,
4048 but there is no property value in the current Unicode release that
4049 matches it. Check your spelling.
4050 Not a CODE reference
4052 (F) Perl was trying to evaluate a reference to a code value (that
4053 is, a subroutine), but found a reference to something else instead.
4054 You can use the ref() function to find out what kind of ref it
4055 really was. See also perlref.
4056 Not a GLOB reference
4058 (F) Perl was trying to evaluate a reference to a "typeglob" (that
4059 is, a symbol table entry that looks like *foo), but found a
4060 reference to something else instead. You can use the ref()
4061 function to find out what kind of ref it really was. See perlref.
4062 Not a HASH reference
4064 (F) Perl was trying to evaluate a reference to a hash value, but
4065 found a reference to something else instead. You can use the ref()
4066 function to find out what kind of ref it really was. See perlref.
4067 '#' not allowed immediately following a sigil in a subroutine signature
4069 (F) In a subroutine signature definition, a comment following a
4070 sigil ("$", "@" or "%"), needs to be separated by whitespace or a
4071 comma etc., in particular to avoid confusion with the $# variable.
4072 For example:
4073 # bad
4075 sub f ($# ignore first arg
4076 , $b) {}
4077 # good
4078 sub f ($, # ignore first arg
4079 $b) {}
4080 Not an ARRAY reference
4082 (F) Perl was trying to evaluate a reference to an array value, but
4083 found a reference to something else instead. You can use the ref()
4084 function to find out what kind of ref it really was. See perlref.
4085 Not a SCALAR reference
4087 (F) Perl was trying to evaluate a reference to a scalar value, but
4088 found a reference to something else instead. You can use the ref()
4089 function to find out what kind of ref it really was. See perlref.
4090 Not a subroutine reference
4092 (F) Perl was trying to evaluate a reference to a code value (that
4093 is, a subroutine), but found a reference to something else instead.
4094 You can use the ref() function to find out what kind of ref it
4095 really was. See also perlref.
4096 Not a subroutine reference in overload table
4098 (F) An attempt was made to specify an entry in an overloading table
4099 that doesn't somehow point to a valid subroutine. See overload.
4100 Not enough arguments for %s
4102 (F) The function requires more arguments than you specified.
4103 Not enough format arguments
4105 (W syntax) A format specified more picture fields than the next
4106 line supplied. See perlform.
4107 %s: not found
4109 (A) You've accidentally run your script through the Bourne shell
4110 instead of Perl. Check the #! line, or manually feed your script
4111 into Perl yourself.
4112 no UTC offset information; assuming local time is UTC
4114 (S) A warning peculiar to VMS. Perl was unable to find the local
4115 timezone offset, so it's assuming that local system time is
4116 equivalent to UTC. If it's not, define the logical name
4117 SYS$TIMEZONE_DIFFERENTIAL to translate to the number of seconds
4118 which need to be added to UTC to get local time.
4119 NULL OP IN RUN
4121 (S debugging) Some internal routine called run() with a null opcode
4122 pointer.
4123 Null picture in formline
4125 (F) The first argument to formline must be a valid format picture
4126 specification. It was found to be empty, which probably means you
4127 supplied it an uninitialized value. See perlform.
4128 NULL regexp parameter
4130 (P) The internal pattern matching routines are out of their gourd.
4131 Number too long
4133 (F) Perl limits the representation of decimal numbers in programs
4134 to about 250 characters. You've exceeded that length. Future
4135 versions of Perl are likely to eliminate this arbitrary limitation.
4136 In the meantime, try using scientific notation (e.g. "1e6" instead
4137 of "1_000_000").
4138 Number with no digits
4140 (F) Perl was looking for a number but found nothing that looked
4141 like a number. This happens, for example with "\o{}", with no
4142 number between the braces.
4143 Numeric format result too large
4145 (F) The length of the result of a numeric format supplied to
4146 sprintf() or printf() would have been too large for the underlying
4147 C function to report. This limit is typically 2GB.
4148 Numeric variables with more than one digit may not start with '0'
4150 (F) The only numeric variable which is allowed to start with a 0 is
4151 $0, and you mentioned a variable that starts with 0 that has more
4152 than one digit. You probably want to remove the leading 0, or if
4153 the intent was to express a variable name in octal you should
4154 convert to decimal.
4155 Octal number > 037777777777 non-portable
4157 (W portable) The octal number you specified is larger than 2**32-1
4158 (4294967295) and therefore non-portable between systems. See
4159 perlport for more on portability concerns.
4160 Odd name/value argument for subroutine '%s'
4162 (F) A subroutine using a slurpy hash parameter in its signature
4163 received an odd number of arguments to populate the hash. It
4164 requires the arguments to be paired, with the same number of keys
4165 as values. The caller of the subroutine is presumably at fault.
4166 The message attempts to include the name of the called subroutine.
4168 If the subroutine has been aliased, the subroutine's original name
4169 will be shown, regardless of what name the caller used.
4170 Odd number of arguments for overload::constant
4172 (W overload) The call to overload::constant contained an odd number
4173 of arguments. The arguments should come in pairs.
4174 Odd number of elements in anonymous hash
4176 (W misc) You specified an odd number of elements to initialize a
4177 hash, which is odd, because hashes come in key/value pairs.
4178 Odd number of elements in export_lexically
4180 (F) A call to "export_lexically" in builtin contained an odd number
4181 of arguments. This is not permitted, because each name must be
4182 paired with a valid reference value.
4183 Odd number of elements in hash assignment
4185 (W misc) You specified an odd number of elements to initialize a
4186 hash, which is odd, because hashes come in key/value pairs.
4187 Odd number of elements in hash field initialization
4189 (W misc) You specified an odd number of elements to initialise a
4190 hash field of an object. Hashes are initialised from a list of
4191 key/value pairs so there must be a corresponding value to every
4192 key. The final missing value will be filled in with undef instead.
4193 Offset outside string
4195 (F)(W layer) You tried to do a read/write/send/recv/seek operation
4196 with an offset pointing outside the buffer. This is difficult to
4197 imagine. The sole exceptions to this are that zero padding will
4198 take place when going past the end of the string when either
4199 sysread()ing a file, or when seeking past the end of a scalar
4200 opened for I/O (in anticipation of future reads and to imitate the
4201 behavior with real files).
4202 Old package separator "'" deprecated
4204 (W deprecated::apostrophe_as_package_separator, syntax) You used
4205 the old package separator "'" in a variable, subroutine or package
4206 name. Support for the old package separator will be removed in Perl
4207 5.42.
4208 Old package separator used in string
4210 (W deprecated::apostrophe_as_package_separator, syntax) You used
4211 the old package separator, "'", in a variable named inside a
4212 double-quoted string; e.g., "In $name's house". This is equivalent
4213 to "In $name::s house". If you meant the former, put a backslash
4214 before the apostrophe ("In $name\'s house").
4215 Support for the old package separator will be removed in Perl 5.42.
4217 Only scalar fields can take a :param attribute
4219 (F) You tried to apply the ":param" attribute to an array or hash
4220 field. Currently this is not permitted.
4221 %s() on unopened %s
4223 (W unopened) An I/O operation was attempted on a filehandle that
4224 was never initialized. You need to do an open(), a sysopen(), or a
4225 socket() call, or call a constructor from the FileHandle package.
4226 -%s on unopened filehandle %s
4228 (W unopened) You tried to invoke a file test operator on a
4229 filehandle that isn't open. Check your control flow. See also
4230 "-X" in perlfunc.
4231 oops: oopsAV
4233 (S internal) An internal warning that the grammar is screwed up.
4234 oops: oopsHV
4236 (S internal) An internal warning that the grammar is screwed up.
4237 Operand with no preceding operator in regex; marked by <-- HERE in
4239 m/%s/
4240 (F) You wrote something like
4241 (?[ \p{Digit} \p{Thai} ])
4243 There are two operands, but no operator giving how you want to
4245 combine them.
4246 Operation "%s": no method found, %s
4248 (F) An attempt was made to perform an overloaded operation for
4249 which no handler was defined. While some handlers can be
4250 autogenerated in terms of other handlers, there is no default
4251 handler for any operation, unless the "fallback" overloading key is
4252 specified to be true. See overload.
4253 Operation "%s" returns its argument for non-Unicode code point 0x%X
4255 (S non_unicode) You performed an operation requiring Unicode rules
4256 on a code point that is not in Unicode, so what it should do is not
4257 defined. Perl has chosen to have it do nothing, and warn you.
4258 If the operation shown is "ToFold", it means that case-insensitive
4260 matching in a regular expression was done on the code point.
4261 If you know what you are doing you can turn off this warning by "no
4263 warnings 'non_unicode';".
4264 Operation "%s" returns its argument for UTF-16 surrogate U+%X
4266 (S surrogate) You performed an operation requiring Unicode rules on
4267 a Unicode surrogate. Unicode frowns upon the use of surrogates for
4268 anything but storing strings in UTF-16, but rules are (reluctantly)
4269 defined for the surrogates, and they are to do nothing for this
4270 operation. Because the use of surrogates can be dangerous, Perl
4271 warns.
4272 If the operation shown is "ToFold", it means that case-insensitive
4274 matching in a regular expression was done on the code point.
4275 If you know what you are doing you can turn off this warning by "no
4277 warnings 'surrogate';".
4278 Operator or semicolon missing before %s
4280 (S ambiguous) You used a variable or subroutine call where the
4281 parser was expecting an operator. The parser has assumed you
4282 really meant to use an operator, but this is highly likely to be
4283 incorrect. For example, if you say "*foo *foo" it will be
4284 interpreted as if you said "*foo * 'foo'".
4285 Optional parameter lacks default expression
4287 (F) In a subroutine signature, you wrote something like "$a =",
4288 making a named optional parameter without a default value. A
4289 nameless optional parameter is permitted to have no default value,
4290 but a named one must have a specific default. You probably want
4291 "$a = undef".
4292 "our" variable %s redeclared
4294 (W shadow) You seem to have already declared the same global once
4295 before in the current lexical scope.
4296 Out of memory!
4298 (X) The malloc() function returned 0, indicating there was
4299 insufficient remaining memory (or virtual memory) to satisfy the
4300 request. Perl has no option but to exit immediately.
4301 At least in Unix you may be able to get past this by increasing
4303 your process datasize limits: in csh/tcsh use "limit" and "limit
4304 datasize n" (where "n" is the number of kilobytes) to check the
4305 current limits and change them, and in ksh/bash/zsh use "ulimit -a"
4306 and "ulimit -d n", respectively.
4307 Out of memory during %s extend
4309 (X) An attempt was made to extend an array, a list, or a string
4310 beyond the largest possible memory allocation.
4311 Out of memory during "large" request for %s
4313 (F) The malloc() function returned 0, indicating there was
4314 insufficient remaining memory (or virtual memory) to satisfy the
4315 request. However, the request was judged large enough (compile-
4316 time default is 64K), so a possibility to shut down by trapping
4317 this error is granted.
4318 Out of memory during request for %s
4320 (X)(F) The malloc() function returned 0, indicating there was
4321 insufficient remaining memory (or virtual memory) to satisfy the
4322 request.
4323 The request was judged to be small, so the possibility to trap it
4325 depends on the way perl was compiled. By default it is not
4326 trappable. However, if compiled for this, Perl may use the
4327 contents of $^M as an emergency pool after die()ing with this
4328 message. In this case the error is trappable once, and the error
4329 message will include the line and file where the failed request
4330 happened.
4331 Out of memory during ridiculously large request
4333 (F) You can't allocate more than 2^31+"small amount" bytes. This
4334 error is most likely to be caused by a typo in the Perl program.
4335 e.g., $arr[time] instead of $arr[$time].
4336 Out of memory for yacc stack
4338 (F) The yacc parser wanted to grow its stack so it could continue
4339 parsing, but realloc() wouldn't give it more memory, virtual or
4340 otherwise.
4341 '.' outside of string in pack
4343 (F) The argument to a '.' in your template tried to move the
4344 working position to before the start of the packed string being
4345 built.
4346 '@' outside of string in unpack
4348 (F) You had a template that specified an absolute position outside
4349 the string being unpacked. See "pack" in perlfunc.
4350 '@' outside of string with malformed UTF-8 in unpack
4352 (F) You had a template that specified an absolute position outside
4353 the string being unpacked. The string being unpacked was also
4354 invalid UTF-8. See "pack" in perlfunc.
4355 overload arg '%s' is invalid
4357 (W overload) The overload pragma was passed an argument it did not
4358 recognize. Did you mistype an operator?
4359 Overloaded dereference did not return a reference
4361 (F) An object with an overloaded dereference operator was
4362 dereferenced, but the overloaded operation did not return a
4363 reference. See overload.
4364 Overloaded qr did not return a REGEXP
4366 (F) An object with a "qr" overload was used as part of a match, but
4367 the overloaded operation didn't return a compiled regexp. See
4368 overload.
4369 %s package attribute may clash with future reserved word: %s
4371 (W reserved) A lowercase attribute name was used that had a
4372 package-specific handler. That name might have a meaning to Perl
4373 itself some day, even though it doesn't yet. Perhaps you should
4374 use a mixed-case attribute name, instead. See attributes.
4375 pack/unpack repeat count overflow
4377 (F) You can't specify a repeat count so large that it overflows
4378 your signed integers. See "pack" in perlfunc.
4379 page overflow
4381 (W io) A single call to write() produced more lines than can fit on
4382 a page. See perlform.
4383 panic: %s
4385 (P) An internal error.
4386 panic: attempt to call %s in %s
4388 (P) One of the file test operators entered a code branch that calls
4389 an ACL related-function, but that function is not available on this
4390 platform. Earlier checks mean that it should not be possible to
4391 enter this branch on this platform.
4392 panic: child pseudo-process was never scheduled
4394 (P) A child pseudo-process in the ithreads implementation on
4395 Windows was not scheduled within the time period allowed and
4396 therefore was not able to initialize properly.
4397 panic: ck_grep, type=%u
4399 (P) Failed an internal consistency check trying to compile a grep.
4400 panic: corrupt saved stack index %ld
4402 (P) The savestack was requested to restore more localized values
4403 than there are in the savestack.
4404 panic: del_backref
4406 (P) Failed an internal consistency check while trying to reset a
4407 weak reference.
4408 panic: fold_constants JMPENV_PUSH returned %d
4410 (P) While attempting folding constants an exception other than an
4411 "eval" failure was caught.
4412 panic: frexp: %f
4414 (P) The library function frexp() failed, making printf("%f")
4415 impossible.
4416 panic: goto, type=%u, ix=%ld
4418 (P) We popped the context stack to a context with the specified
4419 label, and then discovered it wasn't a context we know how to do a
4420 goto in.
4421 panic: gp_free failed to free glob pointer
4423 (P) The internal routine used to clear a typeglob's entries tried
4424 repeatedly, but each time something re-created entries in the glob.
4425 Most likely the glob contains an object with a reference back to
4426 the glob and a destructor that adds a new object to the glob.
4427 panic: INTERPCASEMOD, %s
4429 (P) The lexer got into a bad state at a case modifier.
4430 panic: INTERPCONCAT, %s
4432 (P) The lexer got into a bad state parsing a string with brackets.
4433 panic: kid popen errno read
4435 (F) A forked child returned an incomprehensible message about its
4436 errno.
4437 panic: leave_scope inconsistency %u
4439 (P) The savestack probably got out of sync. At least, there was an
4440 invalid enum on the top of it.
4441 panic: magic_killbackrefs
4443 (P) Failed an internal consistency check while trying to reset all
4444 weak references to an object.
4445 panic: malloc, %s
4447 (P) Something requested a negative number of bytes of malloc.
4448 panic: memory wrap
4450 (P) Something tried to allocate either more memory than possible or
4451 a negative amount.
4452 panic: newFORLOOP, %s
4454 (P) The parser failed an internal consistency check while trying to
4455 parse a "foreach" loop.
4456 panic: pad_alloc, %p!=%p
4458 (P) The compiler got confused about which scratch pad it was
4459 allocating and freeing temporaries and lexicals from.
4460 panic: pad_free curpad, %p!=%p
4462 (P) The compiler got confused about which scratch pad it was
4463 allocating and freeing temporaries and lexicals from.
4464 panic: pad_free po
4466 (P) A zero scratch pad offset was detected internally. An attempt
4467 was made to free a target that had not been allocated to begin
4468 with.
4469 panic: pad_reset curpad, %p!=%p
4471 (P) The compiler got confused about which scratch pad it was
4472 allocating and freeing temporaries and lexicals from.
4473 panic: pad_sv po
4475 (P) A zero scratch pad offset was detected internally. Most likely
4476 an operator needed a target but that target had not been allocated
4477 for whatever reason.
4478 panic: pad_swipe curpad, %p!=%p
4480 (P) The compiler got confused about which scratch pad it was
4481 allocating and freeing temporaries and lexicals from.
4482 panic: pad_swipe po
4484 (P) An invalid scratch pad offset was detected internally.
4485 panic: pp_iter, type=%u
4487 (P) The foreach iterator got called in a non-loop context frame.
4488 panic: pp_match%s
4490 (P) The internal pp_match() routine was called with invalid
4491 operational data.
4492 panic: realloc, %s
4494 (P) Something requested a negative number of bytes of realloc.
4495 panic: reference miscount on nsv in sv_replace() (%d != 1)
4497 (P) The internal sv_replace() function was handed a new SV with a
4498 reference count other than 1.
4499 panic: restartop in %s
4501 (P) Some internal routine requested a goto (or something like it),
4502 and didn't supply the destination.
4503 panic: return, type=%u
4505 (P) We popped the context stack to a subroutine or eval context,
4506 and then discovered it wasn't a subroutine or eval context.
4507 panic: scan_num, %s
4509 (P) scan_num() got called on something that wasn't a number.
4510 panic: Sequence (?{...}): no code block found in regex m/%s/
4512 (P) While compiling a pattern that has embedded (?{}) or (??{})
4513 code blocks, perl couldn't locate the code block that should have
4514 already been seen and compiled by perl before control passed to the
4515 regex compiler.
4516 panic: sv_chop %s
4518 (P) The sv_chop() routine was passed a position that is not within
4519 the scalar's string buffer.
4520 panic: sv_insert, midend=%p, bigend=%p
4522 (P) The sv_insert() routine was told to remove more string than
4523 there was string.
4524 panic: top_env
4526 (P) The compiler attempted to do a goto, or something weird like
4527 that.
4528 panic: unexpected constant lvalue entersub entry via type/targ %d:%d
4530 (P) When compiling a subroutine call in lvalue context, Perl failed
4531 an internal consistency check. It encountered a malformed op tree.
4532 panic: unimplemented op %s (#%d) called
4534 (P) The compiler is screwed up and attempted to use an op that
4535 isn't permitted at run time.
4536 panic: unknown OA_*: %x
4538 (P) The internal routine that handles arguments to &CORE::foo()
4539 subroutine calls was unable to determine what type of arguments
4540 were expected.
4541 panic: utf16_to_utf8: odd bytelen
4543 (P) Something tried to call utf16_to_utf8 with an odd (as opposed
4544 to even) byte length.
4545 panic: utf16_to_utf8_reversed: odd bytelen
4547 (P) Something tried to call utf16_to_utf8_reversed with an odd (as
4548 opposed to even) byte length.
4549 panic: yylex, %s
4551 (P) The lexer got into a bad state while processing a case
4552 modifier.
4553 Parentheses missing around "%s" list
4555 (W parenthesis) You said something like
4556 my $foo, $bar = @_;
4558 when you meant
4560 my ($foo, $bar) = @_;
4562 Remember that "my", "our", "local" and "state" bind tighter than
4564 comma.
4565 Parsing code internal error (%s)
4567 (F) Parsing code supplied by an extension violated the parser's API
4568 in a detectable way.
4569 Pattern subroutine nesting without pos change exceeded limit in regex
4571 (F) You used a pattern that uses too many nested subpattern calls
4572 without consuming any text. Restructure the pattern so text is
4573 consumed before the nesting limit is exceeded.
4574 "-p" destination: %s
4576 (F) An error occurred during the implicit output invoked by the
4577 "-p" command-line switch. (This output goes to STDOUT unless
4578 you've redirected it with select().)
4579 Perl API version %s of %s does not match %s
4581 (F) The XS module in question was compiled against a different
4582 incompatible version of Perl than the one that has loaded the XS
4583 module.
4584 Perl folding rules are not up-to-date for 0x%X; please use the perlbug
4586 utility to report; in regex; marked by <-- HERE in m/%s/
4587 (S regexp) You used a regular expression with case-insensitive
4588 matching, and there is a bug in Perl in which the built-in regular
4589 expression folding rules are not accurate. This may lead to
4590 incorrect results. Please report this as a bug to
4591 <https://github.com/Perl/perl5/issues/new/choose>.
4592 Perl_my_%s() not available
4594 (F) Your platform has very uncommon byte-order and integer size, so
4595 it was not possible to set up some or all fixed-width byte-order
4596 conversion functions. This is only a problem when you're using the
4597 '<' or '>' modifiers in (un)pack templates. See "pack" in
4598 perlfunc.
4599 Perl %s required (did you mean %s?)--this is only %s, stopped
4601 (F) The code you are trying to run has asked for a newer version of
4602 Perl than you are running. Perhaps "use 5.10" was written instead
4603 of "use 5.010" or "use v5.10". Without the leading "v", the number
4604 is interpreted as a decimal, with every three digits after the
4605 decimal point representing a part of the version number. So 5.10
4606 is equivalent to v5.100.
4607 Perl %s required--this is only %s, stopped
4609 (F) The module in question uses features of a version of Perl more
4610 recent than the currently running version. How long has it been
4611 since you upgraded, anyway? See "require" in perlfunc.
4612 PERL_SH_DIR too long
4614 (F) An error peculiar to OS/2. PERL_SH_DIR is the directory to
4615 find the "sh"-shell in. See "PERL_SH_DIR" in perlos2.
4616 PERL_SIGNALS illegal: "%s"
4618 (X) See "PERL_SIGNALS" in perlrun for legal values.
4619 Perls since %s too modern--this is %s, stopped
4621 (F) The code you are trying to run claims it will not run on the
4622 version of Perl you are using because it is too new. Maybe the
4623 code needs to be updated, or maybe it is simply wrong and the
4624 version check should just be removed.
4625 perl: warning: Non hex character in '$ENV{PERL_HASH_SEED}', seed only
4627 partially set
4628 (S) PERL_HASH_SEED should match /^\s*(?:0x)?[0-9a-fA-F]+\s*\z/ but
4629 it contained a non hex character. This could mean you are not
4630 using the hash seed you think you are.
4631 perl: warning: Setting locale failed.
4633 (S) The whole warning message will look something like:
4634 perl: warning: Setting locale failed.
4636 perl: warning: Please check that your locale settings:
4637 LC_ALL = "En_US",
4638 LANG = (unset)
4639 are supported and installed on your system.
4640 perl: warning: Falling back to the standard locale ("C").
4641 Exactly what were the failed locale settings varies. In the above
4643 the settings were that the LC_ALL was "En_US" and the LANG had no
4644 value. This error means that Perl detected that you and/or your
4645 operating system supplier and/or system administrator have set up
4646 the so-called locale system but Perl could not use those settings.
4647 This was not dead serious, fortunately: there is a "default locale"
4648 called "C" that Perl can and will use, and the script will be run.
4649 Before you really fix the problem, however, you will get the same
4650 error message each time you run Perl. How to really fix the
4651 problem can be found in perllocale section LOCALE PROBLEMS.
4652 perl: warning: strange setting in '$ENV{PERL_PERTURB_KEYS}': '%s'
4654 (S) Perl was run with the environment variable PERL_PERTURB_KEYS
4655 defined but containing an unexpected value. The legal values of
4656 this setting are as follows.
4657 Numeric | String | Result
4659 --------+---------------+-----------------------------------------
4660 0 | NO | Disables key traversal randomization
4661 1 | RANDOM | Enables full key traversal randomization
4662 2 | DETERMINISTIC | Enables repeatable key traversal
4663 | | randomization
4664 Both numeric and string values are accepted, but note that string
4666 values are case sensitive. The default for this setting is
4667 "RANDOM" or 1.
4668 pid %x not a child
4670 (W exec) A warning peculiar to VMS. Waitpid() was asked to wait
4671 for a process which isn't a subprocess of the current process.
4672 While this is fine from VMS' perspective, it's probably not what
4673 you intended.
4674 'P' must have an explicit size in unpack
4676 (F) The unpack format P must have an explicit size, not "*".
4677 POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
4679 (F) The class in the character class [: :] syntax is unknown. The
4680 <-- HERE shows whereabouts in the regular expression the problem
4681 was discovered. Note that the POSIX character classes do not have
4682 the "is" prefix the corresponding C interfaces have: in other
4683 words, it's "[[:print:]]", not "isprint". See perlre.
4684 POSIX getpgrp can't take an argument
4686 (F) Your system has POSIX getpgrp(), which takes no argument,
4687 unlike the BSD version, which takes a pid.
4688 POSIX syntax [%c %c] belongs inside character classes%s in regex;
4690 marked by <-- HERE in m/%s/
4691 (W regexp) Perl thinks that you intended to write a POSIX character
4692 class, but didn't use enough brackets. These POSIX class
4693 constructs [: :], [= =], and [. .] go inside character classes,
4694 the [] are part of the construct, for example:
4695 "qr/[012[:alpha:]345]/". What the regular expression pattern
4696 compiled to is probably not what you were intending. For example,
4697 "qr/[:alpha:]/" compiles to a regular bracketed character class
4698 consisting of the four characters ":", "a", "l", "h", and "p".
4699 To specify the POSIX class, it should have been written
4700 "qr/[[:alpha:]]/".
4701 Note that [= =] and [. .] are not currently implemented; they are
4703 simply placeholders for future extensions and will cause fatal
4704 errors. The <-- HERE shows whereabouts in the regular expression
4705 the problem was discovered. See perlre.
4706 If the specification of the class was not completely valid, the
4708 message indicates that.
4709 POSIX syntax [. .] is reserved for future extensions in regex; marked
4711 by <-- HERE in m/%s/
4712 (F) Within regular expression character classes ([]) the syntax
4713 beginning with "[." and ending with ".]" is reserved for future
4714 extensions. If you need to represent those character sequences
4715 inside a regular expression character class, just quote the square
4716 brackets with the backslash: "\[." and ".\]". The <-- HERE shows
4717 whereabouts in the regular expression the problem was discovered.
4718 See perlre.
4719 POSIX syntax [= =] is reserved for future extensions in regex; marked
4721 by <-- HERE in m/%s/
4722 (F) Within regular expression character classes ([]) the syntax
4723 beginning with "[=" and ending with "=]" is reserved for future
4724 extensions. If you need to represent those character sequences
4725 inside a regular expression character class, just quote the square
4726 brackets with the backslash: "\[=" and "=\]". The <-- HERE shows
4727 whereabouts in the regular expression the problem was discovered.
4728 See perlre.
4729 Possible attempt to put comments in qw() list
4731 (W qw) qw() lists contain items separated by whitespace; as with
4732 literal strings, comment characters are not ignored, but are
4733 instead treated as literal data. (You may have used different
4734 delimiters than the parentheses shown here; braces are also
4735 frequently used.)
4736 You probably wrote something like this:
4738 @list = qw(
4740 a # a comment
4741 b # another comment
4742 );
4743 when you should have written this:
4745 @list = qw(
4747 a
4748 b
4749 );
4750 If you really want comments, build your list the old-fashioned way,
4752 with quotes and commas:
4753 @list = (
4755 'a', # a comment
4756 'b', # another comment
4757 );
4758 Possible attempt to separate words with commas
4760 (W qw) qw() lists contain items separated by whitespace; therefore
4761 commas aren't needed to separate the items. (You may have used
4762 different delimiters than the parentheses shown here; braces are
4763 also frequently used.)
4764 You probably wrote something like this:
4766 qw! a, b, c !;
4768 which puts literal commas into some of the list items. Write it
4770 without commas if you don't want them to appear in your data:
4771 qw! a b c !;
4773 Possible memory corruption: %s overflowed 3rd argument
4775 (F) An ioctl() or fcntl() returned more than Perl was bargaining
4776 for. Perl guesses a reasonable buffer size, but puts a sentinel
4777 byte at the end of the buffer just in case. This sentinel byte got
4778 clobbered, and Perl assumes that memory is now corrupted. See
4779 "ioctl" in perlfunc.
4780 Possible precedence issue with control flow operator
4782 (W syntax) There is a possible problem with the mixing of a control
4783 flow operator (e.g. "return") and a low-precedence operator like
4784 "or". Consider:
4785 sub { return $a or $b; }
4787 This is parsed as:
4789 sub { (return $a) or $b; }
4791 Which is effectively just:
4793 sub { return $a; }
4795 Either use parentheses or the high-precedence variant of the
4797 operator.
4798 Note this may be also triggered for constructs like:
4800 sub { 1 if die; }
4802 Possible precedence problem on bitwise %s operator
4804 (W precedence) Your program uses a bitwise logical operator in
4805 conjunction with a numeric comparison operator, like this :
4806 if ($x & $y == 0) { ... }
4808 This expression is actually equivalent to "$x & ($y == 0)", due to
4810 the higher precedence of "==". This is probably not what you want.
4811 (If you really meant to write this, disable the warning, or,
4812 better, put the parentheses explicitly and write "$x & ($y == 0)").
4813 Possible unintended interpolation of $\ in regex
4815 (W ambiguous) You said something like "m/$\/" in a regex. The
4816 regex "m/foo$\s+bar/m" translates to: match the word 'foo', the
4817 output record separator (see "$\" in perlvar) and the letter 's'
4818 (one time or more) followed by the word 'bar'.
4819 If this is what you intended then you can silence the warning by
4821 using "m/${\}/" (for example: "m/foo${\}s+bar/").
4822 If instead you intended to match the word 'foo' at the end of the
4824 line followed by whitespace and the word 'bar' on the next line
4825 then you can use "m/$(?)\/" (for example: "m/foo$(?)\s+bar/").
4826 Possible unintended interpolation of %s in string
4828 (W ambiguous) You said something like '@foo' in a double-quoted
4829 string but there was no array @foo in scope at the time. If you
4830 wanted a literal @foo, then write it as \@foo; otherwise find out
4831 what happened to the array you apparently lost track of.
4832 Precedence problem: open %s should be open(%s)
4834 (S precedence) The old irregular construct
4835 open FOO || die;
4837 is now misinterpreted as
4839 open(FOO || die);
4841 because of the strict regularization of Perl 5's grammar into unary
4843 and list operators. (The old open was a little of both.) You must
4844 put parentheses around the filehandle, or use the new "or" operator
4845 instead of "||".
4846 Premature end of script headers
4848 See "500 Server error".
4849 printf() on closed filehandle %s
4851 (W closed) The filehandle you're writing to got itself closed
4852 sometime before now. Check your control flow.
4853 print() on closed filehandle %s
4855 (W closed) The filehandle you're printing on got itself closed
4856 sometime before now. Check your control flow.
4857 Process terminated by SIG%s
4859 (W) This is a standard message issued by OS/2 applications, while
4860 *nix applications die in silence. It is considered a feature of
4861 the OS/2 port. One can easily disable this by appropriate
4862 sighandlers, see "Signals" in perlipc. See also "Process
4863 terminated by SIGTERM/SIGINT" in perlos2.
4864 Prototype after '%c' for %s : %s
4866 (W illegalproto) A character follows % or @ in a prototype. This
4867 is useless, since % and @ gobble the rest of the subroutine
4868 arguments.
4869 Prototype mismatch: %s vs %s
4871 (S prototype) The subroutine being declared or defined had
4872 previously been declared or defined with a different function
4873 prototype.
4874 Prototype not terminated
4876 (F) You've omitted the closing parenthesis in a function prototype
4877 definition.
4878 Prototype '%s' overridden by attribute 'prototype(%s)' in %s
4880 (W prototype) A prototype was declared in both the parentheses
4881 after the sub name and via the prototype attribute. The prototype
4882 in parentheses is useless, since it will be replaced by the
4883 prototype from the attribute before it's ever used.
4884 %s on BEGIN block ignored
4886 (W syntax) "BEGIN" blocks are executed immediately after they are
4887 parsed and then thrown away. Any prototypes or attributes are
4888 therefore meaningless and are ignored. You should remove them from
4889 the "BEGIN" block. Note this also means you cannot create a
4890 constant called "BEGIN".
4891 Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
4893 (F) You started a regular expression with a quantifier. Backslash
4894 it if you meant it literally. The <-- HERE shows whereabouts in
4895 the regular expression the problem was discovered. See perlre.
4896 Quantifier in {,} bigger than %d in regex; marked by <-- HERE in m/%s/
4898 (F) There is currently a limit to the size of the min and max
4899 values of the {min,max} construct. The <-- HERE shows whereabouts
4900 in the regular expression the problem was discovered. See perlre.
4901 Quantifier {n,m} with n > m can't match in regex
4903 Quantifier {n,m} with n > m can't match in regex; marked by <-- HERE in
4904 m/%s/
4905 (W regexp) Minima should be less than or equal to maxima. If you
4906 really want your regexp to match something 0 times, just put {0}.
4907 Quantifier unexpected on zero-length expression in regex m/%s/
4909 (W regexp) You applied a regular expression quantifier in a place
4910 where it makes no sense, such as on a zero-width assertion. Try
4911 putting the quantifier inside the assertion instead. For example,
4912 the way to match "abc" provided that it is followed by three
4913 repetitions of "xyz" is "/abc(?=(?:xyz){3})/", not
4914 "/abc(?=xyz){3}/".
4915 Range iterator outside integer range
4917 (F) One (or both) of the numeric arguments to the range operator
4918 ".." are outside the range which can be represented by integers
4919 internally. One possible workaround is to force Perl to use
4920 magical string increment by prepending "0" to your numbers.
4921 Ranges of ASCII printables should be some subset of "0-9", "A-Z", or
4923 "a-z" in regex; marked by <-- HERE in m/%s/
4924 (W regexp) (only under "use re 'strict'" or within "(?[...])")
4925 Stricter rules help to find typos and other errors. Perhaps you
4927 didn't even intend a range here, if the "-" was meant to be some
4928 other character, or should have been escaped (like "\-"). If you
4929 did intend a range, the one that was used is not portable between
4930 ASCII and EBCDIC platforms, and doesn't have an obvious meaning to
4931 a casual reader.
4932 [3-7] # OK; Obvious and portable
4934 [d-g] # OK; Obvious and portable
4935 [A-Y] # OK; Obvious and portable
4936 [A-z] # WRONG; Not portable; not clear what is meant
4937 [a-Z] # WRONG; Not portable; not clear what is meant
4938 [%-.] # WRONG; Not portable; not clear what is meant
4939 [\x41-Z] # WRONG; Not portable; not obvious to non-geek
4940 (You can force portability by specifying a Unicode range, which
4942 means that the endpoints are specified by "\N{...}", but the
4943 meaning may still not be obvious.) The stricter rules require that
4944 ranges that start or stop with an ASCII character that is not a
4945 control have all their endpoints be the literal character, and not
4946 some escape sequence (like "\x41"), and the ranges must be all
4947 digits, or all uppercase letters, or all lowercase letters.
4948 Ranges of digits should be from the same group in regex; marked by
4950 <-- HERE in m/%s/
4951 (W regexp) (only under "use re 'strict'" or within "(?[...])")
4952 Stricter rules help to find typos and other errors. You included a
4954 range, and at least one of the end points is a decimal digit.
4955 Under the stricter rules, when this happens, both end points should
4956 be digits in the same group of 10 consecutive digits.
4957 readdir() attempted on invalid dirhandle %s
4959 (W io) The dirhandle you're reading from is either closed or not
4960 really a dirhandle. Check your control flow.
4961 readline() on closed filehandle %s
4963 (W closed) The filehandle you're reading from got itself closed
4964 sometime before now. Check your control flow.
4965 readline() on unopened filehandle %s
4967 (W unopened) The filehandle you're reading from was never opened.
4968 Check your control flow.
4969 read() on closed filehandle %s
4971 (W closed) You tried to read from a closed filehandle.
4972 read() on unopened filehandle %s
4974 (W unopened) You tried to read from a filehandle that was never
4975 opened.
4976 realloc() of freed memory ignored
4978 (S malloc) An internal routine called realloc() on something that
4979 had already been freed.
4980 Recompile perl with -DDEBUGGING to use -D switch
4982 (S debugging) You can't use the -D option unless the code to
4983 produce the desired output is compiled into Perl, which entails
4984 some overhead, which is why it's currently left out of your copy.
4985 Recursive call to Perl_load_module in PerlIO_find_layer
4987 (P) It is currently not permitted to load modules when creating a
4988 filehandle inside an %INC hook. This can happen with "open my $fh,
4989 '<', \$scalar", which implicitly loads PerlIO::scalar. Try loading
4990 PerlIO::scalar explicitly first.
4991 Recursive inheritance detected in package '%s'
4993 (F) While calculating the method resolution order (MRO) of a
4994 package, Perl believes it found an infinite loop in the @ISA
4995 hierarchy. This is a crude check that bails out after 100 levels
4996 of @ISA depth.
4997 Redundant argument in %s
4999 (W redundant) You called a function with more arguments than other
5000 arguments you supplied indicated would be needed. Currently only
5001 emitted when a printf-type format required fewer arguments than
5002 were supplied, but might be used in the future for e.g. "pack" in
5003 perlfunc.
5004 refcnt_dec: fd %d%s
5006 refcnt: fd %d%s
5007 refcnt_inc: fd %d%s
5008 (P) Perl's I/O implementation failed an internal consistency check.
5009 If you see this message, something is very wrong.
5010 Reference found where even-sized list expected
5012 (W misc) You gave a single reference where Perl was expecting a
5013 list with an even number of elements (for assignment to a hash).
5014 This usually means that you used the anon hash constructor when you
5015 meant to use parens. In any case, a hash requires key/value pairs.
5016 %hash = { one => 1, two => 2, }; # WRONG
5018 %hash = [ qw/ an anon array / ]; # WRONG
5019 %hash = ( one => 1, two => 2, ); # right
5020 %hash = qw( one 1 two 2 ); # also fine
5021 Reference is already weak
5023 (W misc) You have attempted to weaken a reference that is already
5024 weak. Doing so has no effect.
5025 Reference is not weak
5027 (W misc) You have attempted to unweaken a reference that is not
5028 weak. Doing so has no effect.
5029 Reference to invalid group 0 in regex; marked by <-- HERE in m/%s/
5031 (F) You used "\g0" or similar in a regular expression. You may
5032 refer to capturing parentheses only with strictly positive integers
5033 (normal backreferences) or with strictly negative integers
5034 (relative backreferences). Using 0 does not make sense.
5035 Reference to nonexistent group in regex; marked by <-- HERE in m/%s/
5037 (F) You used something like "\7" in your regular expression, but
5038 there are not at least seven sets of capturing parentheses in the
5039 expression. If you wanted to have the character with ordinal 7
5040 inserted into the regular expression, prepend zeroes to make it
5041 three digits long: "\007"
5042 The <-- HERE shows whereabouts in the regular expression the
5044 problem was discovered.
5045 Reference to nonexistent named group in regex; marked by <-- HERE in
5047 m/%s/
5048 (F) You used something like "\k'NAME'" or "\k<NAME>" in your
5049 regular expression, but there is no corresponding named capturing
5050 parentheses such as "(?'NAME'...)" or "(?<NAME>...)". Check if the
5051 name has been spelled correctly both in the backreference and the
5052 declaration.
5053 The <-- HERE shows whereabouts in the regular expression the
5055 problem was discovered.
5056 Reference to nonexistent or unclosed group in regex; marked by <-- HERE
5058 in m/%s/
5059 (F) You used something like "\g{-7}" in your regular expression,
5060 but there are not at least seven sets of closed capturing
5061 parentheses in the expression before where the "\g{-7}" was
5062 located.
5063 The <-- HERE shows whereabouts in the regular expression the
5065 problem was discovered.
5066 regexp memory corruption
5068 (P) The regular expression engine got confused by what the regular
5069 expression compiler gave it.
5070 Regexp modifier "/%c" may appear a maximum of twice
5072 Regexp modifier "%c" may appear a maximum of twice in regex; marked by
5073 <-- HERE in m/%s/
5074 (F) The regular expression pattern had too many occurrences of the
5075 specified modifier. Remove the extraneous ones.
5076 Regexp modifier "%c" may not appear after the "-" in regex; marked by
5078 <-- HERE in m/%s/
5079 (F) Turning off the given modifier has the side effect of turning
5080 on another one. Perl currently doesn't allow this. Reword the
5081 regular expression to use the modifier you want to turn on (and
5082 place it before the minus), instead of the one you want to turn
5083 off.
5084 Regexp modifier "/%c" may not appear twice
5086 Regexp modifier "%c" may not appear twice in regex; marked by <-- HERE
5087 in m/%s/
5088 (F) The regular expression pattern had too many occurrences of the
5089 specified modifier. Remove the extraneous ones.
5090 Regexp modifiers "/%c" and "/%c" are mutually exclusive
5092 Regexp modifiers "%c" and "%c" are mutually exclusive in regex; marked
5093 by <-- HERE in m/%s/
5094 (F) The regular expression pattern had more than one of these
5095 mutually exclusive modifiers. Retain only the modifier that is
5096 supposed to be there.
5097 Regexp out of space in regex m/%s/
5099 (P) A "can't happen" error, because safemalloc() should have caught
5100 it earlier.
5101 Repeated format line will never terminate (~~ and @#)
5103 (F) Your format contains the ~~ repeat-until-blank sequence and a
5104 numeric field that will never go blank so that the repetition never
5105 terminates. You might use ^# instead. See perlform.
5106 Replacement list is longer than search list
5108 (W misc) You have used a replacement list that is longer than the
5109 search list. So the additional elements in the replacement list
5110 are meaningless.
5111 Required parameter '%s' is missing for %s constructor
5113 (F) You called the constructor for a class that has a required
5114 named parameter, but did not pass that parameter at all.
5115 '(*%s' requires a terminating ':' in regex; marked by <-- HERE in m/%s/
5117 (F) You used a construct that needs a colon and pattern argument.
5118 Supply these or check that you are using the right construct.
5119 '%s' resolved to '\o{%s}%d'
5121 As of Perl 5.32, this message is no longer generated. Instead, see
5122 "Non-octal character '%c' terminates \o early. Resolved as "%s"".
5123 (W misc, regexp) You wrote something like "\08", or "\179" in a
5124 double-quotish string. All but the last digit is treated as a
5125 single character, specified in octal. The last digit is the next
5126 character in the string. To tell Perl that this is indeed what you
5127 want, you can use the "\o{ }" syntax, or use exactly three digits
5128 to specify the octal for the character.
5129 Reversed %s= operator
5131 (W syntax) You wrote your assignment operator backwards. The =
5132 must always come last, to avoid ambiguity with subsequent unary
5133 operators.
5134 rewinddir() attempted on invalid dirhandle %s
5136 (W io) The dirhandle you tried to do a rewinddir() on is either
5137 closed or not really a dirhandle. Check your control flow.
5138 Scalars leaked: %d
5140 (S internal) Something went wrong in Perl's internal bookkeeping of
5141 scalars: not all scalar variables were deallocated by the time Perl
5142 exited. What this usually indicates is a memory leak, which is of
5143 course bad, especially if the Perl program is intended to be long-
5144 running.
5145 Scalar value @%s[%s] better written as $%s[%s]
5147 (W syntax) You've used an array slice (indicated by @) to select a
5148 single element of an array. Generally it's better to ask for a
5149 scalar value (indicated by $). The difference is that $foo[&bar]
5150 always behaves like a scalar, both when assigning to it and when
5151 evaluating its argument, while @foo[&bar] behaves like a list when
5152 you assign to it, and provides a list context to its subscript,
5153 which can do weird things if you're expecting only one subscript.
5154 On the other hand, if you were actually hoping to treat the array
5156 element as a list, you need to look into how references work,
5157 because Perl will not magically convert between scalars and lists
5158 for you. See perlref.
5159 Scalar value @%s{%s} better written as $%s{%s}
5161 (W syntax) You've used a hash slice (indicated by @) to select a
5162 single element of a hash. Generally it's better to ask for a
5163 scalar value (indicated by $). The difference is that $foo{&bar}
5164 always behaves like a scalar, both when assigning to it and when
5165 evaluating its argument, while @foo{&bar} behaves like a list when
5166 you assign to it, and provides a list context to its subscript,
5167 which can do weird things if you're expecting only one subscript.
5168 On the other hand, if you were actually hoping to treat the hash
5170 element as a list, you need to look into how references work,
5171 because Perl will not magically convert between scalars and lists
5172 for you. See perlref.
5173 Search pattern not terminated
5175 (F) The lexer couldn't find the final delimiter of a // or m{}
5176 construct. Remember that bracketing delimiters count nesting
5177 level. Missing the leading "$" from a variable $m may cause this
5178 error.
5179 Note that since Perl 5.10.0 a // can also be the defined-or
5181 construct, not just the empty search pattern. Therefore code
5182 written in Perl 5.10.0 or later that uses the // as the defined-or
5183 can be misparsed by pre-5.10.0 Perls as a non-terminated search
5184 pattern.
5185 seekdir() attempted on invalid dirhandle %s
5187 (W io) The dirhandle you are doing a seekdir() on is either closed
5188 or not really a dirhandle. Check your control flow.
5189 %sseek() on unopened filehandle
5191 (W unopened) You tried to use the seek() or sysseek() function on a
5192 filehandle that was either never opened or has since been closed.
5193 select not implemented
5195 (F) This machine doesn't implement the select() system call.
5196 Self-ties of arrays and hashes are not supported
5198 (F) Self-ties are of arrays and hashes are not supported in the
5199 current implementation.
5200 Semicolon seems to be missing
5202 (W semicolon) A nearby syntax error was probably caused by a
5203 missing semicolon, or possibly some other missing operator, such as
5204 a comma.
5205 semi-panic: attempt to dup freed string
5207 (S internal) The internal newSVsv() routine was called to duplicate
5208 a scalar that had previously been marked as free.
5209 sem%s not implemented
5211 (F) You don't have System V semaphore IPC on your system.
5212 send() on closed socket %s
5214 (W closed) The socket you're sending to got itself closed sometime
5215 before now. Check your control flow.
5216 Sequence "\c{" invalid
5218 (F) These three characters may not appear in sequence in a double-
5219 quotish context. This message is raised only on non-ASCII
5220 platforms (a different error message is output on ASCII ones). If
5221 you were intending to specify a control character with this
5222 sequence, you'll have to use a different way to specify it.
5223 Sequence (? incomplete in regex; marked by <-- HERE in m/%s/
5225 (F) A regular expression ended with an incomplete extension (?.
5226 The <-- HERE shows whereabouts in the regular expression the
5227 problem was discovered. See perlre.
5228 Sequence (?%c...) not implemented in regex; marked by <-- HERE in m/%s/
5230 (F) A proposed regular expression extension has the character
5231 reserved but has not yet been written. The <-- HERE shows
5232 whereabouts in the regular expression the problem was discovered.
5233 See perlre.
5234 Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/
5236 (F) You used a regular expression extension that doesn't make
5237 sense. The <-- HERE shows whereabouts in the regular expression
5238 the problem was discovered. This may happen when using the
5239 "(?^...)" construct to tell Perl to use the default regular
5240 expression modifiers, and you redundantly specify a default
5241 modifier. For other causes, see perlre.
5242 Sequence (?#... not terminated in regex m/%s/
5244 (F) A regular expression comment must be terminated by a closing
5245 parenthesis. Embedded parentheses aren't allowed. See perlre.
5246 Sequence (?&... not terminated in regex; marked by <-- HERE in m/%s/
5248 (F) A named reference of the form "(?&...)" was missing the final
5249 closing parenthesis after the name. The <-- HERE shows whereabouts
5250 in the regular expression the problem was discovered.
5251 Sequence (?%c... not terminated in regex; marked by <-- HERE in m/%s/
5253 (F) A named group of the form "(?'...')" or "(?<...>)" was missing
5254 the final closing quote or angle bracket. The <-- HERE shows
5255 whereabouts in the regular expression the problem was discovered.
5256 Sequence (%s... not terminated in regex; marked by <-- HERE in m/%s/
5258 (F) A lookahead assertion "(?=...)" or "(?!...)" or lookbehind
5259 assertion "(?<=...)" or "(?<!...)" was missing the final closing
5260 parenthesis. The <-- HERE shows whereabouts in the regular
5261 expression the problem was discovered.
5262 Sequence (?(%c... not terminated in regex; marked by <-- HERE in m/%s/
5264 (F) A named reference of the form "(?('...')...)" or
5265 "(?(<...>)...)" was missing the final closing quote or angle
5266 bracket after the name. The <-- HERE shows whereabouts in the
5267 regular expression the problem was discovered.
5268 Sequence (?... not terminated in regex; marked by <-- HERE in m/%s/
5270 (F) There was no matching closing parenthesis for the '('. The
5271 <-- HERE shows whereabouts in the regular expression the problem
5272 was discovered.
5273 Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
5275 (F) The regular expression expects a mandatory argument following
5276 the escape sequence and this has been omitted or incorrectly
5277 written.
5278 Sequence (?{...}) not terminated with ')'
5280 (F) The end of the perl code contained within the {...} must be
5281 followed immediately by a ')'.
5282 Sequence (?P>... not terminated in regex; marked by <-- HERE in m/%s/
5284 (F) A named reference of the form "(?P>...)" was missing the final
5285 closing parenthesis after the name. The <-- HERE shows whereabouts
5286 in the regular expression the problem was discovered.
5287 Sequence (?P<... not terminated in regex; marked by <-- HERE in m/%s/
5289 (F) A named group of the form "(?P<...>')" was missing the final
5290 closing angle bracket. The <-- HERE shows whereabouts in the
5291 regular expression the problem was discovered.
5292 Sequence ?P=... not terminated in regex; marked by <-- HERE in m/%s/
5294 (F) A named reference of the form "(?P=...)" was missing the final
5295 closing parenthesis after the name. The <-- HERE shows whereabouts
5296 in the regular expression the problem was discovered.
5297 Sequence (?R) not terminated in regex m/%s/
5299 (F) An "(?R)" or "(?0)" sequence in a regular expression was
5300 missing the final parenthesis.
5301 500 Server error
5303 (A) This is the error message generally seen in a browser window
5304 when trying to run a CGI program (including SSI) over the web. The
5305 actual error text varies widely from server to server. The most
5306 frequently-seen variants are "500 Server error", "Method
5307 (something) not permitted", "Document contains no data", "Premature
5308 end of script headers", and "Did not produce a valid header".
5309 This is a CGI error, not a Perl error.
5311 You need to make sure your script is executable, is accessible by
5313 the user CGI is running the script under (which is probably not the
5314 user account you tested it under), does not rely on any environment
5315 variables (like PATH) from the user it isn't running under, and
5316 isn't in a location where the CGI server can't find it, basically,
5317 more or less. Please see the following for more information:
5318 https://www.perl.org/CGI_MetaFAQ.html
5320 http://www.htmlhelp.org/faq/cgifaq.html
5321 http://www.w3.org/Security/Faq/
5322 You should also look at perlfaq9.
5324 setegid() not implemented
5326 (F) You tried to assign to $), and your operating system doesn't
5327 support the setegid() system call (or equivalent), or at least
5328 Configure didn't think so.
5329 seteuid() not implemented
5331 (F) You tried to assign to $>, and your operating system doesn't
5332 support the seteuid() system call (or equivalent), or at least
5333 Configure didn't think so.
5334 setpgrp can't take arguments
5336 (F) Your system has the setpgrp() from BSD 4.2, which takes no
5337 arguments, unlike POSIX setpgid(), which takes a process ID and
5338 process group ID.
5339 setrgid() not implemented
5341 (F) You tried to assign to $(, and your operating system doesn't
5342 support the setrgid() system call (or equivalent), or at least
5343 Configure didn't think so.
5344 setruid() not implemented
5346 (F) You tried to assign to $<, and your operating system doesn't
5347 support the setruid() system call (or equivalent), or at least
5348 Configure didn't think so.
5349 setsockopt() on closed socket %s
5351 (W closed) You tried to set a socket option on a closed socket.
5352 Did you forget to check the return value of your socket() call?
5353 See "setsockopt" in perlfunc.
5354 Setting $/ to a reference to %s is forbidden
5356 (F) You assigned a reference to a scalar to $/ where the referenced
5357 item is not a positive integer. In older perls this appeared to
5358 work the same as setting it to "undef" but was in fact internally
5359 different, less efficient and with very bad luck could have
5360 resulted in your file being split by a stringified form of the
5361 reference.
5362 In Perl 5.20.0 this was changed so that it would be exactly the
5364 same as setting $/ to undef, with the exception that this warning
5365 would be thrown.
5366 You are recommended to change your code to set $/ to "undef"
5368 explicitly if you wish to slurp the file. As of Perl 5.28
5369 assigning $/ to a reference to an integer which isn't positive is a
5370 fatal error.
5371 Setting $/ to %s reference is forbidden
5373 (F) You tried to assign a reference to a non integer to $/. In
5374 older Perls this would have behaved similarly to setting it to a
5375 reference to a positive integer, where the integer was the address
5376 of the reference. As of Perl 5.20.0 this is a fatal error, to
5377 allow future versions of Perl to use non-integer refs for more
5378 interesting purposes.
5379 shm%s not implemented
5381 (F) You don't have System V shared memory IPC on your system.
5382 !=~ should be !~
5384 (W syntax) The non-matching operator is !~, not !=~. !=~ will be
5385 interpreted as the != (numeric not equal) and ~ (1's complement)
5386 operators: probably not what you intended.
5387 /%s/ should probably be written as "%s"
5389 (W syntax) You have used a pattern where Perl expected to find a
5390 string, as in the first argument to "join". Perl will treat the
5391 true or false result of matching the pattern against $_ as the
5392 string, which is probably not what you had in mind.
5393 shutdown() on closed socket %s
5395 (W closed) You tried to do a shutdown on a closed socket. Seems a
5396 bit superfluous.
5397 SIG%s handler "%s" not defined
5399 (W signal) The signal handler named in %SIG doesn't, in fact,
5400 exist. Perhaps you put it into the wrong package?
5401 Slab leaked from cv %p
5403 (S) If you see this message, then something is seriously wrong with
5404 the internal bookkeeping of op trees. An op tree needed to be
5405 freed after a compilation error, but could not be found, so it was
5406 leaked instead.
5407 sleep(%u) too large
5409 (W overflow) You called "sleep" with a number that was larger than
5410 it can reliably handle and "sleep" probably slept for less time
5411 than requested.
5412 Slurpy parameter not last
5414 (F) In a subroutine signature, you put something after a slurpy
5415 (array or hash) parameter. The slurpy parameter takes all the
5416 available arguments, so there can't be any left to fill later
5417 parameters.
5418 Smart matching a non-overloaded object breaks encapsulation
5420 (F) You should not use the "~~" operator on an object that does not
5421 overload it: Perl refuses to use the object's underlying structure
5422 for the smart match.
5423 Smartmatch is deprecated
5425 (D deprecated::smartmatch) This warning is emitted if you use the
5426 smartmatch ("~~") operator. This is a deprecated feature.
5427 Particularly, its behavior is noticed for being unnecessarily
5428 complex and unintuitive, and it will be removed in Perl 5.42.
5429 Sorry, hash keys must be smaller than 2**31 bytes
5431 (F) You tried to create a hash containing a very large key, where
5432 "very large" means that it needs at least 2 gigabytes to store.
5433 Unfortunately, Perl doesn't yet handle such large hash keys. You
5434 should reconsider your design to avoid hashing such a long string
5435 directly.
5436 sort is now a reserved word
5438 (F) An ancient error message that almost nobody ever runs into
5439 anymore. But before sort was a keyword, people sometimes used it
5440 as a filehandle.
5441 Source filters apply only to byte streams
5443 (F) You tried to activate a source filter (usually by loading a
5444 source filter module) within a string passed to "eval". This is
5445 not permitted under the "unicode_eval" feature. Consider using
5446 "evalbytes" instead. See feature.
5447 splice() offset past end of array
5449 (W misc) You attempted to specify an offset that was past the end
5450 of the array passed to splice(). Splicing will instead commence at
5451 the end of the array, rather than past it. If this isn't what you
5452 want, try explicitly pre-extending the array by assigning $#array =
5453 $offset. See "splice" in perlfunc.
5454 Split loop
5456 (P) The split was looping infinitely. (Obviously, a split
5457 shouldn't iterate more times than there are characters of input,
5458 which is what happened.) See "split" in perlfunc.
5459 Statement unlikely to be reached
5461 (W exec) You did an exec() with some statement after it other than
5462 a die(). This is almost always an error, because exec() never
5463 returns unless there was a failure. You probably wanted to use
5464 system() instead, which does return. To suppress this warning, put
5465 the exec() in a block by itself.
5466 "state" subroutine %s can't be in a package
5468 (F) Lexically scoped subroutines aren't in a package, so it doesn't
5469 make sense to try to declare one with a package qualifier on the
5470 front.
5471 "state %s" used in sort comparison
5473 (W syntax) The package variables $a and $b are used for sort
5474 comparisons. You used $a or $b in as an operand to the "<=>" or
5475 "cmp" operator inside a sort comparison block, and the variable had
5476 earlier been declared as a lexical variable. Either qualify the
5477 sort variable with the package name, or rename the lexical
5478 variable.
5479 "state" variable %s can't be in a package
5481 (F) Lexically scoped variables aren't in a package, so it doesn't
5482 make sense to try to declare one with a package qualifier on the
5483 front. Use local() if you want to localize a package variable.
5484 stat() on unopened filehandle %s
5486 (W unopened) You tried to use the stat() function on a filehandle
5487 that was either never opened or has since been closed.
5488 Strings with code points over 0xFF may not be mapped into in-memory
5490 file handles
5491 (W utf8) You tried to open a reference to a scalar for read or
5492 append where the scalar contained code points over 0xFF. In-memory
5493 files model on-disk files and can only contain bytes.
5494 Stub found while resolving method "%s" overloading "%s" in package "%s"
5496 (P) Overloading resolution over @ISA tree may be broken by
5497 importation stubs. Stubs should never be implicitly created, but
5498 explicit calls to "can" may break this.
5499 Subroutine attributes must come before the signature
5501 (F) When subroutine signatures are enabled, any subroutine
5502 attributes must come before the signature. Note that this order was
5503 the opposite in versions 5.22..5.26. So:
5504 sub foo :lvalue ($a, $b) { ... } # 5.20 and 5.28 +
5506 sub foo ($a, $b) :lvalue { ... } # 5.22 .. 5.26
5507 Subroutine "&%s" is not available
5509 (W closure) During compilation, an inner named subroutine or eval
5510 is attempting to capture an outer lexical subroutine that is not
5511 currently available. This can happen for one of two reasons.
5512 First, the lexical subroutine may be declared in an outer anonymous
5513 subroutine that has not yet been created. (Remember that named
5514 subs are created at compile time, while anonymous subs are created
5515 at run-time.) For example,
5516 sub { my sub a {...} sub f { \&a } }
5518 At the time that f is created, it can't capture the current "a"
5520 sub, since the anonymous subroutine hasn't been created yet.
5521 Conversely, the following won't give a warning since the anonymous
5522 subroutine has by now been created and is live:
5523 sub { my sub a {...} eval 'sub f { \&a }' }->();
5525 The second situation is caused by an eval accessing a lexical
5527 subroutine that has gone out of scope, for example,
5528 sub f {
5530 my sub a {...}
5531 sub { eval '\&a' }
5532 }
5533 f()->();
5534 Here, when the '\&a' in the eval is being compiled, f() is not
5536 currently being executed, so its &a is not available for capture.
5537 "%s" subroutine &%s masks earlier declaration in same %s
5539 (W shadow) A "my" or "state" subroutine has been redeclared in the
5540 current scope or statement, effectively eliminating all access to
5541 the previous instance. This is almost always a typographical
5542 error. Note that the earlier subroutine will still exist until the
5543 end of the scope or until all closure references to it are
5544 destroyed.
5545 Subroutine %s redefined
5547 (W redefine) You redefined a subroutine. To suppress this warning,
5548 say
5549 {
5551 no warnings 'redefine';
5552 eval "sub name { ... }";
5553 }
5554 Subroutine "%s" will not stay shared
5556 (W closure) An inner (nested) named subroutine is referencing a
5557 "my" subroutine defined in an outer named subroutine.
5558 When the inner subroutine is called, it will see the value of the
5560 outer subroutine's lexical subroutine as it was before and during
5561 the *first* call to the outer subroutine; in this case, after the
5562 first call to the outer subroutine is complete, the inner and outer
5563 subroutines will no longer share a common value for the lexical
5564 subroutine. In other words, it will no longer be shared. This
5565 will especially make a difference if the lexical subroutines
5566 accesses lexical variables declared in its surrounding scope.
5567 This problem can usually be solved by making the inner subroutine
5569 anonymous, using the "sub {}" syntax. When inner anonymous subs
5570 that reference lexical subroutines in outer subroutines are
5571 created, they are automatically rebound to the current values of
5572 such lexical subs.
5573 Substitution loop
5575 (P) The substitution was looping infinitely. (Obviously, a
5576 substitution shouldn't iterate more times than there are characters
5577 of input, which is what happened.) See the discussion of
5578 substitution in "Regexp Quote-Like Operators" in perlop.
5579 Substitution pattern not terminated
5581 (F) The lexer couldn't find the interior delimiter of an s/// or
5582 s{}{} construct. Remember that bracketing delimiters count nesting
5583 level. Missing the leading "$" from variable $s may cause this
5584 error.
5585 Substitution replacement not terminated
5587 (F) The lexer couldn't find the final delimiter of an s/// or s{}{}
5588 construct. Remember that bracketing delimiters count nesting
5589 level. Missing the leading "$" from variable $s may cause this
5590 error.
5591 substr outside of string
5593 (W substr)(F) You tried to reference a substr() that pointed
5594 outside of a string. That is, the absolute value of the offset was
5595 larger than the length of the string. See "substr" in perlfunc.
5596 This warning is fatal if substr is used in an lvalue context (as
5597 the left hand side of an assignment or as a subroutine argument for
5598 example).
5599 sv_upgrade from type %d down to type %d
5601 (P) Perl tried to force the upgrade of an SV to a type which was
5602 actually inferior to its current type.
5603 Switch (?(condition)... contains too many branches in regex; marked by
5605 <-- HERE in m/%s/
5606 (F) A (?(condition)if-clause|else-clause) construct can have at
5607 most two branches (the if-clause and the else-clause). If you want
5608 one or both to contain alternation, such as using
5609 "this|that|other", enclose it in clustering parentheses:
5610 (?(condition)(?:this|that|other)|else-clause)
5612 The <-- HERE shows whereabouts in the regular expression the
5614 problem was discovered. See perlre.
5615 Switch condition not recognized in regex; marked by <-- HERE in m/%s/
5617 (F) The condition part of a (?(condition)if-clause|else-clause)
5618 construct is not known. The condition must be one of the
5619 following:
5620 (1) (2) ... true if 1st, 2nd, etc., capture matched
5622 (<NAME>) ('NAME') true if named capture matched
5623 (?=...) (?<=...) true if subpattern matches
5624 (?!...) (?<!...) true if subpattern fails to match
5625 (?{ CODE }) true if code returns a true value
5626 (R) true if evaluating inside recursion
5627 (R1) (R2) ... true if directly inside capture group 1, 2, etc.
5628 (R&NAME) true if directly inside named capture
5629 (DEFINE) always false; for defining named subpatterns
5630 The <-- HERE shows whereabouts in the regular expression the
5632 problem was discovered. See perlre.
5633 Switch (?(condition)... not terminated in regex; marked by <-- HERE in
5635 m/%s/
5636 (F) You omitted to close a (?(condition)...) block somewhere in the
5637 pattern. Add a closing parenthesis in the appropriate position.
5638 See perlre.
5639 switching effective %s is not implemented
5641 (F) While under the "use filetest" pragma, we cannot switch the
5642 real and effective uids or gids.
5643 syntax error
5645 (F) Probably means you had a syntax error. Common reasons include:
5646 A keyword is misspelled.
5648 A semicolon is missing.
5649 A comma is missing.
5650 An opening or closing parenthesis is missing.
5651 An opening or closing brace is missing.
5652 A closing quote is missing.
5653 Often there will be another error message associated with the
5655 syntax error giving more information. (Sometimes it helps to turn
5656 on -w.) The error message itself often tells you where it was in
5657 the line when it decided to give up. Sometimes the actual error is
5658 several tokens before this, because Perl is good at understanding
5659 random input. Occasionally the line number may be misleading, and
5660 once in a blue moon the only way to figure out what's triggering
5661 the error is to call "perl -c" repeatedly, chopping away half the
5662 program each time to see if the error went away. Sort of the
5663 cybernetic version of 20 questions.
5664 syntax error at line %d: '%s' unexpected
5666 (A) You've accidentally run your script through the Bourne shell
5667 instead of Perl. Check the #! line, or manually feed your script
5668 into Perl yourself.
5669 syntax error in file %s at line %d, next 2 tokens "%s"
5671 (F) This error is likely to occur if you run a perl5 script through
5672 a perl4 interpreter, especially if the next 2 tokens are "use
5673 strict" or "my $var" or "our $var".
5674 Syntax error in (?[...]) in regex; marked by <-- HERE in m/%s/
5676 (F) Perl could not figure out what you meant inside this construct;
5677 this notifies you that it is giving up trying.
5678 %s syntax OK
5680 (F) The final summary message when a "perl -c" succeeds.
5681 sysread() on closed filehandle %s
5683 (W closed) You tried to read from a closed filehandle.
5684 sysread() on unopened filehandle %s
5686 (W unopened) You tried to read from a filehandle that was never
5687 opened.
5688 System V %s is not implemented on this machine
5690 (F) You tried to do something with a function beginning with "sem",
5691 "shm", or "msg" but that System V IPC is not implemented in your
5692 machine. In some machines the functionality can exist but be
5693 unconfigured. Consult your system support.
5694 syswrite() on closed filehandle %s
5696 (W closed) The filehandle you're writing to got itself closed
5697 sometime before now. Check your control flow.
5698 "-T" and "-B" not implemented on filehandles
5700 (F) Perl can't peek at the stdio buffer of filehandles when it
5701 doesn't know about your kind of stdio. You'll have to use a
5702 filename instead.
5703 Target of goto is too deeply nested
5705 (F) You tried to use "goto" to reach a label that was too deeply
5706 nested for Perl to reach. Perl is doing you a favor by refusing.
5707 telldir() attempted on invalid dirhandle %s
5709 (W io) The dirhandle you tried to telldir() is either closed or not
5710 really a dirhandle. Check your control flow.
5711 tell() on unopened filehandle
5713 (W unopened) You tried to use the tell() function on a filehandle
5714 that was either never opened or has since been closed.
5715 The crypt() function is unimplemented due to excessive paranoia.
5717 (F) Configure couldn't find the crypt() function on your machine,
5718 probably because your vendor didn't supply it, probably because
5719 they think the U.S. Government thinks it's a secret, or at least
5720 that they will continue to pretend that it is. And if you quote me
5721 on that, I will deny it.
5722 The experimental declared_refs feature is not enabled
5724 (F) To declare references to variables, as in "my \%x", you must
5725 first enable the feature:
5726 no warnings "experimental::declared_refs";
5728 use feature "declared_refs";
5729 The %s function is unimplemented
5731 (F) The function indicated isn't implemented on this architecture,
5732 according to the probings of Configure.
5733 The private_use feature is experimental
5735 (S experimental::private_use) This feature is actually a hook for
5736 future use.
5737 The stat preceding %s wasn't an lstat
5739 (F) It makes no sense to test the current stat buffer for symbolic
5740 linkhood if the last stat that wrote to the stat buffer already
5741 went past the symlink to get to the real file. Use an actual
5742 filename instead.
5743 The Unicode property wildcards feature is experimental
5745 (S experimental::uniprop_wildcards) This feature is experimental
5746 and its behavior may in any future release of perl. See "Wildcards
5747 in Property Values" in perlunicode.
5748 The 'unique' attribute may only be applied to 'our' variables
5750 (F) This attribute was never supported on "my" or "sub"
5751 declarations.
5752 This Perl can't reset CRTL environ elements (%s)
5754 This Perl can't set CRTL environ elements (%s=%s)
5755 (W internal) Warnings peculiar to VMS. You tried to change or
5756 delete an element of the CRTL's internal environ array, but your
5757 copy of Perl wasn't built with a CRTL that contained the setenv()
5758 function. You'll need to rebuild Perl with a CRTL that does, or
5759 redefine PERL_ENV_TABLES (see perlvms) so that the environ array
5760 isn't the target of the change to %ENV which produced the warning.
5761 This Perl has not been built with support for randomized hash key
5763 traversal but something called Perl_hv_rand_set().
5764 (F) Something has attempted to use an internal API call which
5765 depends on Perl being compiled with the default support for
5766 randomized hash key traversal, but this Perl has been compiled
5767 without it. You should report this warning to the relevant
5768 upstream party, or recompile perl with default options.
5769 This use of my() in false conditional is no longer allowed
5771 (F) You used a declaration similar to "my $x if 0". There has been
5772 a long-standing bug in Perl that causes a lexical variable not to
5773 be cleared at scope exit when its declaration includes a false
5774 conditional. Some people have exploited this bug to achieve a kind
5775 of static variable. Since we intend to fix this bug, we don't want
5776 people relying on this behavior. You can achieve a similar static
5777 effect by declaring the variable in a separate block outside the
5778 function, eg
5779 sub f { my $x if 0; return $x++ }
5781 becomes
5783 { my $x; sub f { return $x++ } }
5785 Beginning with perl 5.10.0, you can also use "state" variables to
5787 have lexicals that are initialized only once (see feature):
5788 sub f { state $x; return $x++ }
5790 This use of my() in a false conditional was deprecated beginning in
5792 Perl 5.10 and became a fatal error in Perl 5.30.
5793 Timeout waiting for another thread to define \p{%s}
5795 (F) The first time a user-defined property ("User-Defined Character
5796 Properties" in perlunicode) is used, its definition is looked up
5797 and converted into an internal form for more efficient handling in
5798 subsequent uses. There could be a race if two or more threads
5799 tried to do this processing nearly simultaneously. Instead, a
5800 critical section is created around this task, locking out all but
5801 one thread from doing it. This message indicates that the thread
5802 that is doing the conversion is taking an unexpectedly long time.
5803 The timeout exists solely to prevent deadlock; it's long enough
5804 that the system was likely thrashing and about to crash. There is
5805 no real remedy but rebooting.
5806 times not implemented
5808 (F) Your version of the C library apparently doesn't do times(). I
5809 suspect you're not running on Unix.
5810 "-T" is on the #! line, it must also be used on the command line
5812 (X) The #! line (or local equivalent) in a Perl script contains the
5813 -T option (or the -t option), but Perl was not invoked with -T in
5814 its command line. This is an error because, by the time Perl
5815 discovers a -T in a script, it's too late to properly taint
5816 everything from the environment. So Perl gives up.
5817 If the Perl script is being executed as a command using the #!
5819 mechanism (or its local equivalent), this error can usually be
5820 fixed by editing the #! line so that the -%c option is a part of
5821 Perl's first argument: e.g. change "perl -n -%c" to "perl -%c -n".
5822 If the Perl script is being executed as "perl scriptname", then the
5824 -%c option must appear on the command line: "perl -%c scriptname".
5825 To%s: illegal mapping '%s'
5827 (F) You tried to define a customized To-mapping for lc(), lcfirst,
5828 uc(), or ucfirst() (or their string-inlined versions), but you
5829 specified an illegal mapping. See "User-Defined Character
5830 Properties" in perlunicode.
5831 Too deeply nested ()-groups
5833 (F) Your template contains ()-groups with a ridiculously deep
5834 nesting level.
5835 Too few args to syscall
5837 (F) There has to be at least one argument to syscall() to specify
5838 the system call to call, silly dilly.
5839 Too few arguments for subroutine '%s' (got %d; expected %d)
5841 (F) A subroutine using a signature fewer arguments than required by
5842 the signature. The caller of the subroutine is presumably at
5843 fault.
5844 The message attempts to include the name of the called subroutine.
5846 If the subroutine has been aliased, the subroutine's original name
5847 will be shown, regardless of what name the caller used. It will
5848 also indicate the number of arguments given and the number
5849 expected.
5850 Too few arguments for subroutine '%s' (got %d; expected at least %d)
5852 Similar to the previous message but for subroutines that accept a
5853 variable number of arguments.
5854 Too late for "-%s" option
5856 (X) The #! line (or local equivalent) in a Perl script contains the
5857 -M, -m or -C option.
5858 In the case of -M and -m, this is an error because those options
5860 are not intended for use inside scripts. Use the "use" pragma
5861 instead.
5862 The -C option only works if it is specified on the command line as
5864 well (with the same sequence of letters or numbers following).
5865 Either specify this option on the command line, or, if your system
5866 supports it, make your script executable and run it directly
5867 instead of passing it to perl.
5868 Too late to run %s block
5870 (W void) A CHECK or INIT block is being defined during run time
5871 proper, when the opportunity to run them has already passed.
5872 Perhaps you are loading a file with "require" or "do" when you
5873 should be using "use" instead. Or perhaps you should put the
5874 "require" or "do" inside a BEGIN block.
5875 Too many args to syscall
5877 (F) Perl supports a maximum of only 14 args to syscall().
5878 Too many arguments for %s
5880 (F) The function requires fewer arguments than you specified.
5881 Too many arguments for subroutine '%s' (got %d; expected %d)
5883 (F) A subroutine using a signature received more arguments than
5884 permitted by the signature. The caller of the subroutine is
5885 presumably at fault.
5886 The message attempts to include the name of the called subroutine.
5888 If the subroutine has been aliased, the subroutine's original name
5889 will be shown, regardless of what name the caller used. It will
5890 also indicate the number of arguments given and the number
5891 expected.
5892 Too many arguments for subroutine '%s' (got %d; expected at most %d)
5894 Similar to the previous message but for subroutines that accept a
5895 variable number of arguments.
5896 Too many nested open parens in regex; marked by <-- HERE in m/%s/
5898 (F) You have exceeded the number of open "(" parentheses that
5899 haven't been matched by corresponding closing ones. This limit
5900 prevents eating up too much memory. It is initially set to 1000,
5901 but may be changed by setting "${^RE_COMPILE_RECURSION_LIMIT}" to
5902 some other value. This may need to be done in a BEGIN block before
5903 the regular expression pattern is compiled.
5904 Too many nested BEGIN blocks, maximum of %d allowed
5906 (F) You have executed code that nests too many BEGIN blocks inside
5907 of each other, either explicitly as BEGIN{} or implicitly as use
5908 statements. This limit defaults to a rather high number which
5909 should not be exceeded in normal circumstances, and triggering
5910 likely indicates something is very wrong in your code. For instance
5911 infinite recursion of eval and BEGIN blocks is known to trigger
5912 this error.
5913 If you know that you have good reason to exceed the limit you can
5915 change it by setting "${^MAX_NESTED_EVAL_BEGIN_BLOCKS}" to a
5916 different value from the default of 1000.
5917 Too many capture groups (limit is %d) in regex m/%s/
5919 (F) You have too many capture groups in your regex pattern. You
5920 need to rework your pattern to use less capture groups.
5921 Too many )'s
5923 (A) You've accidentally run your script through csh instead of
5924 Perl. Check the #! line, or manually feed your script into Perl
5925 yourself.
5926 Too many ('s
5928 (A) You've accidentally run your script through csh instead of
5929 Perl. Check the #! line, or manually feed your script into Perl
5930 yourself.
5931 Trailing \ in regex m/%s/
5933 (F) The regular expression ends with an unbackslashed backslash.
5934 Backslash it. See perlre.
5935 Transliteration pattern not terminated
5937 (F) The lexer couldn't find the interior delimiter of a tr/// or
5938 tr[][] or y/// or y[][] construct. Missing the leading "$" from
5939 variables $tr or $y may cause this error.
5940 Transliteration replacement not terminated
5942 (F) The lexer couldn't find the final delimiter of a tr///, tr[][],
5943 y/// or y[][] construct.
5944 Treating %s::INIT block as BEGIN block as workaround
5946 (S) A package is using an old version of "Module::Install::DSL" to
5947 install, which makes unsafe assumptions about when INIT blocks will
5948 be called. Because "Module::Install::DSL" is used to install other
5949 modules and is difficult to upgrade we have a special workaround in
5950 place to deal with this. Unless you are a maintainer of an affected
5951 module you can ignore this warning. We emit it only as a sanity
5952 check.
5953 '%s' trapped by operation mask
5955 (F) You tried to use an operator from a Safe compartment in which
5956 it's disallowed. See Safe.
5957 truncate not implemented
5959 (F) Your machine doesn't implement a file truncation mechanism that
5960 Configure knows about.
5961 try/catch is experimental
5963 (S experimental::try) This warning is emitted if you use the "try"
5964 and "catch" syntax. This syntax is currently experimental and its
5965 behaviour may change in future releases of Perl.
5966 try/catch/finally is experimental
5968 (S experimental::try) This warning is emitted if you use the "try"
5969 and "catch" syntax with a "finally" block. This syntax is currently
5970 experimental and its behaviour may change in future releases of
5971 Perl.
5972 Type of arg %d to &CORE::%s must be %s
5974 (F) The subroutine in question in the CORE package requires its
5975 argument to be a hard reference to data of the specified type.
5976 Overloading is ignored, so a reference to an object that is not the
5977 specified type, but nonetheless has overloading to handle it, will
5978 still not be accepted.
5979 Type of arg %d to %s must be %s (not %s)
5981 (F) This function requires the argument in that position to be of a
5982 certain type. Arrays must be @NAME or "@{EXPR}". Hashes must be
5983 %NAME or "%{EXPR}". No implicit dereferencing is allowed--use the
5984 {EXPR} forms as an explicit dereference. See perlref.
5985 umask not implemented
5987 (F) Your machine doesn't implement the umask function and you tried
5988 to use it to restrict permissions for yourself (EXPR & 0700).
5989 Unbalanced context: %d more PUSHes than POPs
5991 (S internal) The exit code detected an internal inconsistency in
5992 how many execution contexts were entered and left.
5993 Unbalanced saves: %d more saves than restores
5995 (S internal) The exit code detected an internal inconsistency in
5996 how many values were temporarily localized.
5997 Unbalanced scopes: %d more ENTERs than LEAVEs
5999 (S internal) The exit code detected an internal inconsistency in
6000 how many blocks were entered and left.
6001 Unbalanced string table refcount: (%d) for "%s"
6003 (S internal) On exit, Perl found some strings remaining in the
6004 shared string table used for copy on write and for hash keys. The
6005 entries should have been freed, so this indicates a bug somewhere.
6006 Unbalanced tmps: %d more allocs than frees
6008 (S internal) The exit code detected an internal inconsistency in
6009 how many mortal scalars were allocated and freed.
6010 Undefined format "%s" called
6012 (F) The format indicated doesn't seem to exist. Perhaps it's
6013 really in another package? See perlform.
6014 Undefined sort subroutine "%s" called
6016 (F) The sort comparison routine specified doesn't seem to exist.
6017 Perhaps it's in a different package? See "sort" in perlfunc.
6018 Undefined subroutine &%s called
6020 (F) The subroutine indicated hasn't been defined, or if it was, it
6021 has since been undefined.
6022 Undefined subroutine called
6024 (F) The anonymous subroutine you're trying to call hasn't been
6025 defined, or if it was, it has since been undefined.
6026 Undefined subroutine in sort
6028 (F) The sort comparison routine specified is declared but doesn't
6029 seem to have been defined yet. See "sort" in perlfunc.
6030 Undefined top format "%s" called
6032 (F) The format indicated doesn't seem to exist. Perhaps it's
6033 really in another package? See perlform.
6034 Undefined value assigned to typeglob
6036 (W misc) An undefined value was assigned to a typeglob, a la "*foo
6037 = undef". This does nothing. It's possible that you really mean
6038 "undef *foo".
6039 %s: Undefined variable
6041 (A) You've accidentally run your script through csh instead of
6042 Perl. Check the #! line, or manually feed your script into Perl
6043 yourself.
6044 Unescaped left brace in regex is illegal here in regex; marked by
6046 <-- HERE in m/%s/
6047 (F) The simple rule to remember, if you want to match a literal "{"
6048 character (U+007B "LEFT CURLY BRACKET") in a regular expression
6049 pattern, is to escape each literal instance of it in some way.
6050 Generally easiest is to precede it with a backslash, like "\{" or
6051 enclose it in square brackets ("[{]"). If the pattern delimiters
6052 are also braces, any matching right brace ("}") should also be
6053 escaped to avoid confusing the parser, for example,
6054 qr{abc\{def\}ghi}
6056 Forcing literal "{" characters to be escaped enables the Perl
6058 language to be extended in various ways in future releases. To
6059 avoid needlessly breaking existing code, the restriction is not
6060 enforced in contexts where there are unlikely to ever be extensions
6061 that could conflict with the use there of "{" as a literal. Those
6062 that are not potentially ambiguous do not warn; those that are do
6063 raise a non-deprecation warning.
6064 The contexts where no warnings or errors are raised are:
6066 • as the first character in a pattern, or following "^"
6068 indicating to anchor the match to the beginning of a line.
6069 • as the first character following a "|" indicating alternation.
6071 • as the first character in a parenthesized grouping like
6073 /foo({bar)/
6075 /foo(?:{bar)/
6076 • as the first character following a quantifier
6078 /\s*{/
6080 Unescaped left brace in regex is passed through in regex; marked by
6082 <-- HERE in m/%s/
6083 (W regexp) The simple rule to remember, if you want to match a
6084 literal "{" character (U+007B "LEFT CURLY BRACKET") in a regular
6085 expression pattern, is to escape each literal instance of it in
6086 some way. Generally easiest is to precede it with a backslash,
6087 like "\{" or enclose it in square brackets ("[{]"). If the pattern
6088 delimiters are also braces, any matching right brace ("}") should
6089 also be escaped to avoid confusing the parser, for example,
6090 qr{abc\{def\}ghi}
6092 Forcing literal "{" characters to be escaped enables the Perl
6094 language to be extended in various ways in future releases. To
6095 avoid needlessly breaking existing code, the restriction is not
6096 enforced in contexts where there are unlikely to ever be extensions
6097 that could conflict with the use there of "{" as a literal. Those
6098 that are not potentially ambiguous do not warn; those that are
6099 raise this warning. This makes sure that an inadvertent typo
6100 doesn't silently cause the pattern to compile to something
6101 unintended.
6102 The contexts where no warnings or errors are raised are:
6104 • as the first character in a pattern, or following "^"
6106 indicating to anchor the match to the beginning of a line.
6107 • as the first character following a "|" indicating alternation.
6109 • as the first character in a parenthesized grouping like
6111 /foo({bar)/
6113 /foo(?:{bar)/
6114 • as the first character following a quantifier
6116 /\s*{/
6118 Unescaped literal '%c' in regex; marked by <-- HERE in m/%s/
6120 (W regexp) (only under "use re 'strict'")
6121 Within the scope of "use re 'strict'" in a regular expression
6123 pattern, you included an unescaped "}" or "]" which was interpreted
6124 literally. These two characters are sometimes metacharacters, and
6125 sometimes literals, depending on what precedes them in the pattern.
6126 This is unlike the similar ")" which is always a metacharacter
6127 unless escaped.
6128 This action at a distance, perhaps a large distance, can lead to
6130 Perl silently misinterpreting what you meant, so when you specify
6131 that you want extra checking by "use re 'strict'", this warning is
6132 generated. If you meant the character as a literal, simply confirm
6133 that to Perl by preceding the character with a backslash, or make
6134 it into a bracketed character class (like "[}]"). If you meant it
6135 as closing a corresponding "[" or "{", you'll need to look back
6136 through the pattern to find out why that isn't happening.
6137 unexec of %s into %s failed!
6139 (F) The unexec() routine failed for some reason. See your local
6140 FSF representative, who probably put it there in the first place.
6141 Unexpected binary operator '%c' with no preceding operand in regex;
6143 marked by <-- HERE in m/%s/
6144 (F) You had something like this:
6145 (?[ | \p{Digit} ])
6147 where the "|" is a binary operator with an operand on the right,
6149 but no operand on the left.
6150 Unexpected character in regex; marked by <-- HERE in m/%s/
6152 (F) You had something like this:
6153 (?[ z ])
6155 Within "(?[ ])", no literal characters are allowed unless they are
6157 within an inner pair of square brackets, like
6158 (?[ [ z ] ])
6160 Another possibility is that you forgot a backslash. Perl isn't
6162 smart enough to figure out what you really meant.
6163 Unexpected characters while parsing class :isa attribute: %s
6165 (F) You tried to specify something other than a single class name
6166 with an optional trailing verison number as the value for a "class"
6167 ":isa" attribute. This confused the parser.
6168 Unexpected exit %u
6170 (S) exit() was called or the script otherwise finished gracefully
6171 when "PERL_EXIT_WARN" was set in "PL_exit_flags".
6172 Unexpected exit failure %d
6174 (S) An uncaught die() was called when "PERL_EXIT_WARN" was set in
6175 "PL_exit_flags".
6176 Unexpected ')' in regex; marked by <-- HERE in m/%s/
6178 (F) You had something like this:
6179 (?[ ( \p{Digit} + ) ])
6181 The ")" is out-of-place. Something apparently was supposed to be
6183 combined with the digits, or the "+" shouldn't be there, or
6184 something like that. Perl can't figure out what was intended.
6185 Unexpected ']' with no following ')' in (?[... in regex; marked by <--
6187 HERE in m/%s/
6188 (F) While parsing an extended character class a ']' character was
6189 encountered at a point in the definition where the only legal use
6190 of ']' is to close the character class definition as part of a
6191 '])', you may have forgotten the close paren, or otherwise confused
6192 the parser.
6193 Unexpected '(' with no preceding operator in regex; marked by <-- HERE
6195 in m/%s/
6196 (F) You had something like this:
6197 (?[ \p{Digit} ( \p{Lao} + \p{Thai} ) ])
6199 There should be an operator before the "(", as there's no
6201 indication as to how the digits are to be combined with the
6202 characters in the Lao and Thai scripts.
6203 Unicode non-character U+%X is not recommended for open interchange
6205 (S nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are
6206 defined by the Unicode standard to be non-characters. Those are
6207 legal codepoints, but are reserved for internal use; so,
6208 applications shouldn't attempt to exchange them. An application
6209 may not be expecting any of these characters at all, and receiving
6210 them may lead to bugs. If you know what you are doing you can turn
6211 off this warning by "no warnings 'nonchar';".
6212 This is not really a "severe" error, but it is supposed to be
6214 raised by default even if warnings are not enabled, and currently
6215 the only way to do that in Perl is to mark it as serious.
6216 Unicode property wildcard not terminated
6218 (F) A Unicode property wildcard looks like a delimited regular
6219 expression pattern (all within the braces of the enclosing
6220 "\p{...}". The closing delimtter to match the opening one was not
6221 found. If the opening one is escaped by preceding it with a
6222 backslash, the closing one must also be so escaped.
6223 Unicode string properties are not implemented in (?[...]) in regex;
6225 marked by <-- HERE in m/%s/
6226 (F) A Unicode string property is one which expands to a sequence of
6227 multiple characters. An example is "\p{name=KATAKANA LETTER AINU
6228 P}", which is comprised of the sequence "\N{KATAKANA LETTER SMALL
6229 H}" followed by "\N{COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND
6230 MARK}". Extended character classes, "(?[...])" currently cannot
6231 handle these.
6232 Unicode surrogate U+%X is illegal in UTF-8
6234 (S surrogate) You had a UTF-16 surrogate in a context where they
6235 are not considered acceptable. These code points, between U+D800
6236 and U+DFFF (inclusive), are used by Unicode only for UTF-16.
6237 However, Perl internally allows all unsigned integer code points
6238 (up to the size limit available on your platform), including
6239 surrogates. But these can cause problems when being input or
6240 output, which is likely where this message came from. If you
6241 really really know what you are doing you can turn off this warning
6242 by "no warnings 'surrogate';".
6243 Unimplemented
6245 (F) In Perl 5.12 and above, you have executed an ellipsis
6246 statement. This is a bare "...;", meant to be used to allow you to
6247 outline code that is to be written, but is not complete, similar to
6248 the following:
6249 sub not_done_yet {
6251 my($self, $arg1, $arg2) = @_;
6252 ...
6253 }
6254 If not_done_yet() is called, Perl will die with an "Unimplemented"
6256 error at the line containing "...".
6257 Unknown charname '%s'
6259 (F) The name you used inside "\N{}" is unknown to Perl. Check the
6260 spelling. You can say "use charnames ":loose"" to not have to be
6261 so precise about spaces, hyphens, and capitalization on standard
6262 Unicode names. (Any custom aliases that have been created must be
6263 specified exactly, regardless of whether ":loose" is used or not.)
6264 This error may also happen if the "\N{}" is not in the scope of the
6265 corresponding "use charnames".
6266 Unknown '(*...)' construct '%s' in regex; marked by <-- HERE in m/%s/
6268 (F) The "(*" was followed by something that the regular expression
6269 compiler does not recognize. Check your spelling.
6270 Unknown error
6272 (P) Perl was about to print an error message in $@, but the $@
6273 variable did not exist, even after an attempt to create it.
6274 Unknown locale category %d
6276 Unknown locale category %d; can't set it to %s
6277 (W locale) You used a locale category that perl doesn't recognize,
6278 so it cannot carry out your request. Check that you are using a
6279 valid category. If so, see "Multi-threaded" in perllocale for
6280 advice on reporting this as a bug, and for modifying perl locally
6281 to accommodate your needs.
6282 Unknown open() mode '%s'
6284 (F) The second argument of 3-argument open() is not among the list
6285 of valid modes: "<", ">", ">>", "+<", "+>", "+>>", "-|", "|-",
6286 "<&", ">&".
6287 Unknown PerlIO layer "%s"
6289 (W layer) An attempt was made to push an unknown layer onto the
6290 Perl I/O system. (Layers take care of transforming data between
6291 external and internal representations.) Note that some layers,
6292 such as "mmap", are not supported in all environments. If your
6293 program didn't explicitly request the failing operation, it may be
6294 the result of the value of the environment variable PERLIO.
6295 Unknown process %x sent message to prime_env_iter: %s
6297 (P) An error peculiar to VMS. Perl was reading values for %ENV
6298 before iterating over it, and someone else stuck a message in the
6299 stream of data Perl expected. Someone's very confused, or perhaps
6300 trying to subvert Perl's population of %ENV for nefarious purposes.
6301 Unknown regexp modifier "/%s"
6303 (F) Alphanumerics immediately following the closing delimiter of a
6304 regular expression pattern are interpreted by Perl as modifier
6305 flags for the regex. One of the ones you specified is invalid.
6306 One way this can happen is if you didn't put in white space between
6307 the end of the regex and a following alphanumeric operator:
6308 if ($a =~ /foo/and $bar == 3) { ... }
6310 The "a" is a valid modifier flag, but the "n" is not, and raises
6312 this error. Likely what was meant instead was:
6313 if ($a =~ /foo/ and $bar == 3) { ... }
6315 Unknown "re" subpragma '%s' (known ones are: %s)
6317 (W) You tried to use an unknown subpragma of the "re" pragma.
6318 Unknown switch condition (?(...)) in regex; marked by <-- HERE in m/%s/
6320 (F) The condition part of a (?(condition)if-clause|else-clause)
6321 construct is not known. The condition must be one of the
6322 following:
6323 (1) (2) ... true if 1st, 2nd, etc., capture matched
6325 (<NAME>) ('NAME') true if named capture matched
6326 (?=...) (?<=...) true if subpattern matches
6327 (*pla:...) (*plb:...) true if subpattern matches; also
6328 (*positive_lookahead:...)
6329 (*positive_lookbehind:...)
6330 (*nla:...) (*nlb:...) true if subpattern fails to match; also
6331 (*negative_lookahead:...)
6332 (*negative_lookbehind:...)
6333 (?{ CODE }) true if code returns a true value
6334 (R) true if evaluating inside recursion
6335 (R1) (R2) ... true if directly inside capture group 1, 2,
6336 etc.
6337 (R&NAME) true if directly inside named capture
6338 (DEFINE) always false; for defining named subpatterns
6339 The <-- HERE shows whereabouts in the regular expression the
6341 problem was discovered. See perlre.
6342 Unknown Unicode option letter '%c'
6344 (F) You specified an unknown Unicode option. See perlrun
6345 documentation of the "-C" switch for the list of known options.
6346 Unknown Unicode option value %d
6348 (F) You specified an unknown Unicode option. See perlrun
6349 documentation of the "-C" switch for the list of known options.
6350 Unknown user-defined property name \p{%s}
6352 (F) You specified to use a property within the "\p{...}" which was
6353 a syntactically valid user-defined property, but no definition was
6354 found for it by the time one was required to proceed. Check your
6355 spelling. See "User-Defined Character Properties" in perlunicode.
6356 Unknown verb pattern '%s' in regex; marked by <-- HERE in m/%s/
6358 (F) You either made a typo or have incorrectly put a "*" quantifier
6359 after an open brace in your pattern. Check the pattern and review
6360 perlre for details on legal verb patterns.
6361 Unknown warnings category '%s'
6363 (F) An error issued by the "warnings" pragma. You specified a
6364 warnings category that is unknown to perl at this point.
6365 Note that if you want to enable a warnings category registered by a
6367 module (e.g. "use warnings 'File::Find'"), you must have loaded
6368 this module first.
6369 Unmatched [ in regex; marked by <-- HERE in m/%s/
6371 (F) The brackets around a character class must match. If you wish
6372 to include a closing bracket in a character class, backslash it or
6373 put it first. The <-- HERE shows whereabouts in the regular
6374 expression the problem was discovered. See perlre.
6375 Unmatched ( in regex; marked by <-- HERE in m/%s/
6377 Unmatched ) in regex; marked by <-- HERE in m/%s/
6378 (F) Unbackslashed parentheses must always be balanced in regular
6379 expressions. If you're a vi user, the % key is valuable for
6380 finding the matching parenthesis. The <-- HERE shows whereabouts
6381 in the regular expression the problem was discovered. See perlre.
6382 Unmatched right %s bracket
6384 (F) The lexer counted more closing curly or square brackets than
6385 opening ones, so you're probably missing a matching opening
6386 bracket. As a general rule, you'll find the missing one (so to
6387 speak) near the place you were last editing.
6388 Unquoted string "%s" may clash with future reserved word
6390 (W reserved) You used a bareword that might someday be claimed as a
6391 reserved word. It's best to put such a word in quotes, or
6392 capitalize it somehow, or insert an underbar into it. You might
6393 also declare it as a subroutine.
6394 Unrecognized character %s; marked by <-- HERE after %s near column %d
6396 (F) The Perl parser has no idea what to do with the specified
6397 character in your Perl script (or eval) near the specified column.
6398 Perhaps you tried to run a compressed script, a binary program, or
6399 a directory as a Perl program.
6400 Unrecognized class attribute %s
6402 (F) You attempted to add a named attribute to a "class" definition,
6403 but perl does not recognise the name of the requested attribute.
6404 Unrecognized escape \%c in character class in regex; marked by <-- HERE
6406 in m/%s/
6407 (F) You used a backslash-character combination which is not
6408 recognized by Perl inside character classes. This is a fatal error
6409 when the character class is used within "(?[ ])".
6410 Unrecognized escape \%c in character class passed through in regex;
6412 marked by <-- HERE in m/%s/
6413 (W regexp) You used a backslash-character combination which is not
6414 recognized by Perl inside character classes. The character was
6415 understood literally, but this may change in a future version of
6416 Perl. The <-- HERE shows whereabouts in the regular expression the
6417 escape was discovered.
6418 Unrecognized escape \%c passed through
6420 (W misc) You used a backslash-character combination which is not
6421 recognized by Perl. The character was understood literally, but
6422 this may change in a future version of Perl.
6423 Unrecognized escape \%s passed through in regex; marked by <-- HERE in
6425 m/%s/
6426 (W regexp) You used a backslash-character combination which is not
6427 recognized by Perl. The character(s) were understood literally,
6428 but this may change in a future version of Perl. The <-- HERE
6429 shows whereabouts in the regular expression the escape was
6430 discovered.
6431 Unrecognized field attribute %s
6433 (F) You attempted to add a named attribute to a "field" definition,
6434 but perl does not recognise the name of the requested attribute.
6435 Unrecognized signal name "%s"
6437 (F) You specified a signal name to the kill() function that was not
6438 recognized. Say "kill -l" in your shell to see the valid signal
6439 names on your system.
6440 Unrecognized switch: -%s (-h will show valid options)
6442 (F) You specified an illegal option to Perl. Don't do that. (If
6443 you think you didn't do that, check the #! line to see if it's
6444 supplying the bad switch on your behalf.)
6445 Unsuccessful %s on filename containing newline
6447 (W newline) A file operation was attempted on a filename, and that
6448 operation failed, PROBABLY because the filename contained a
6449 newline, PROBABLY because you forgot to chomp() it off. See
6450 "chomp" in perlfunc.
6451 Unsupported directory function "%s" called
6453 (F) Your machine doesn't support opendir() and readdir().
6454 Unsupported function %s
6456 (F) This machine doesn't implement the indicated function,
6457 apparently. At least, Configure doesn't think so.
6458 Unsupported function fork
6460 (F) Your version of executable does not support forking.
6461 Note that under some systems, like OS/2, there may be different
6463 flavors of Perl executables, some of which may support fork, some
6464 not. Try changing the name you call Perl by to "perl_", "perl__",
6465 and so on.
6466 Unsupported script encoding %s
6468 (F) Your program file begins with a Unicode Byte Order Mark (BOM)
6469 which declares it to be in a Unicode encoding that Perl cannot
6470 read.
6471 Unsupported socket function "%s" called
6473 (F) Your machine doesn't support the Berkeley socket mechanism, or
6474 at least that's what Configure thought.
6475 Unterminated '(*...' argument in regex; marked by <-- HERE in m/%s/
6477 (F) You used a pattern of the form "(*...:...)" but did not
6478 terminate the pattern with a ")". Fix the pattern and retry.
6479 Unterminated attribute list
6481 (F) The lexer found something other than a simple identifier at the
6482 start of an attribute, and it wasn't a semicolon or the start of a
6483 block. Perhaps you terminated the parameter list of the previous
6484 attribute too soon. See attributes.
6485 Unterminated attribute parameter in attribute list
6487 (F) The lexer saw an opening (left) parenthesis character while
6488 parsing an attribute list, but the matching closing (right)
6489 parenthesis character was not found. You may need to add (or
6490 remove) a backslash character to get your parentheses to balance.
6491 See attributes.
6492 Unterminated compressed integer
6494 (F) An argument to unpack("w",...) was incompatible with the BER
6495 compressed integer format and could not be converted to an integer.
6496 See "pack" in perlfunc.
6497 Unterminated '(*...' construct in regex; marked by <-- HERE in m/%s/
6499 (F) You used a pattern of the form "(*...)" but did not terminate
6500 the pattern with a ")". Fix the pattern and retry.
6501 Unterminated delimiter for here document
6503 (F) This message occurs when a here document label has an initial
6504 quotation mark but the final quotation mark is missing. Perhaps
6505 you wrote:
6506 <<"foo
6508 instead of:
6510 <<"foo"
6512 Unterminated \g... pattern in regex; marked by <-- HERE in m/%s/
6514 Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
6515 (F) In a regular expression, you had a "\g" that wasn't followed by
6516 a proper group reference. In the case of "\g{", the closing brace
6517 is missing; otherwise the "\g" must be followed by an integer. Fix
6518 the pattern and retry.
6519 Unterminated <> operator
6521 (F) The lexer saw a left angle bracket in a place where it was
6522 expecting a term, so it's looking for the corresponding right angle
6523 bracket, and not finding it. Chances are you left some needed
6524 parentheses out earlier in the line, and you really meant a "less
6525 than".
6526 Unterminated verb pattern argument in regex; marked by <-- HERE in
6528 m/%s/
6529 (F) You used a pattern of the form "(*VERB:ARG)" but did not
6530 terminate the pattern with a ")". Fix the pattern and retry.
6531 Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
6533 (F) You used a pattern of the form "(*VERB)" but did not terminate
6534 the pattern with a ")". Fix the pattern and retry.
6535 untie attempted while %d inner references still exist
6537 (W untie) A copy of the object returned from "tie" (or "tied") was
6538 still valid when "untie" was called.
6539 Usage: POSIX::%s(%s)
6541 (F) You called a POSIX function with incorrect arguments. See
6542 "FUNCTIONS" in POSIX for more information.
6543 Usage: Win32::%s(%s)
6545 (F) You called a Win32 function with incorrect arguments. See
6546 Win32 for more information.
6547 $[ used in %s (did you mean $] ?)
6549 (W syntax) You used $[ in a comparison, such as:
6550 if ($[ > 5.006) {
6552 ...
6553 }
6554 You probably meant to use $] instead. $[ is the base for indexing
6556 arrays. $] is the Perl version number in decimal.
6557 Use "%s" instead of "%s"
6559 (F) The second listed construct is no longer legal. Use the first
6560 one instead.
6561 Useless assignment to a temporary
6563 (W misc) You assigned to an lvalue subroutine, but what the
6564 subroutine returned was a temporary scalar about to be discarded,
6565 so the assignment had no effect.
6566 Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in
6568 m/%s/
6569 (W regexp) You have used an internal modifier such as (?-o) that
6570 has no meaning unless removed from the entire regexp:
6571 if ($string =~ /(?-o)$pattern/o) { ... }
6573 must be written as
6575 if ($string =~ /$pattern/) { ... }
6577 The <-- HERE shows whereabouts in the regular expression the
6579 problem was discovered. See perlre.
6580 Useless localization of %s
6582 (W syntax) The localization of lvalues such as local($x=10) is
6583 legal, but in fact the local() currently has no effect. This may
6584 change at some point in the future, but in the meantime such code
6585 is discouraged.
6586 Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
6588 (W regexp) You have used an internal modifier such as (?o) that has
6589 no meaning unless applied to the entire regexp:
6590 if ($string =~ /(?o)$pattern/) { ... }
6592 must be written as
6594 if ($string =~ /$pattern/o) { ... }
6596 The <-- HERE shows whereabouts in the regular expression the
6598 problem was discovered. See perlre.
6599 Useless use of attribute "const"
6601 (W misc) The "const" attribute has no effect except on anonymous
6602 closure prototypes. You applied it to a subroutine via
6603 attributes.pm. This is only useful inside an attribute handler for
6604 an anonymous subroutine.
6605 Useless use of /d modifier in transliteration operator
6607 (W misc) You have used the /d modifier where the searchlist has the
6608 same length as the replacelist. See perlop for more information
6609 about the /d modifier.
6610 Useless use of \E
6612 (W misc) You have a \E in a double-quotish string without a "\U",
6613 "\L" or "\Q" preceding it.
6614 Useless use of greediness modifier '%c' in regex; marked by <-- HERE in
6616 m/%s/
6617 (W regexp) You specified something like these:
6618 qr/a{3}?/
6620 qr/b{1,1}+/
6621 The "?" and "+" don't have any effect, as they modify whether to
6623 match more or fewer when there is a choice, and by specifying to
6624 match exactly a given number, there is no room left for a choice.
6625 Useless use of %s in scalar context
6627 (W scalar) You did something whose only interesting return value is
6628 a list without a side effect in scalar context, which does not
6629 accept a list.
6630 For example
6632 my $x = sort @y;
6634 This is not very useful, and perl currently optimizes this away.
6636 Useless use of %s in void context
6638 (W void) You did something without a side effect in a context that
6639 does nothing with the return value, such as a statement that
6640 doesn't return a value from a block, or the left side of a scalar
6641 comma operator. Very often this points not to stupidity on your
6642 part, but a failure of Perl to parse your program the way you
6643 thought it would. For example, you'd get this if you mixed up your
6644 C precedence with Python precedence and said
6645 $one, $two = 1, 2;
6647 when you meant to say
6649 ($one, $two) = (1, 2);
6651 Another common error is to use ordinary parentheses to construct a
6653 list reference when you should be using square or curly brackets,
6654 for example, if you say
6655 $array = (1,2);
6657 when you should have said
6659 $array = [1,2];
6661 The square brackets explicitly turn a list value into a scalar
6663 value, while parentheses do not. So when a parenthesized list is
6664 evaluated in a scalar context, the comma is treated like C's comma
6665 operator, which throws away the left argument, which is not what
6666 you want. See perlref for more on this.
6667 This warning will not be issued for numerical constants equal to 0
6669 or 1 since they are often used in statements like
6670 1 while sub_with_side_effects();
6672 String constants that would normally evaluate to 0 or 1 are warned
6674 about.
6675 Useless use of (?-p) in regex; marked by <-- HERE in m/%s/
6677 (W regexp) The "p" modifier cannot be turned off once set. Trying
6678 to do so is futile.
6679 Useless use of "re" pragma
6681 (W) You did "use re;" without any arguments. That isn't very
6682 useful.
6683 Useless use of %s with no values
6685 (W syntax) You used the push() or unshift() function with no
6686 arguments apart from the array, like push(@x) or unshift(@foo).
6687 That won't usually have any effect on the array, so is completely
6688 useless. It's possible in principle that push(@tied_array) could
6689 have some effect if the array is tied to a class which implements a
6690 PUSH method. If so, you can write it as "push(@tied_array,())" to
6691 avoid this warning.
6692 "use" not allowed in expression
6694 (F) The "use" keyword is recognized and executed at compile time,
6695 and returns no useful value. See perlmod.
6696 Use of @_ in %s with signatured subroutine is experimental
6698 (S experimental::args_array_with_signatures) An expression
6699 involving the @_ arguments array was found in a subroutine that
6700 uses a signature. This is experimental because the interaction
6701 between the arguments array and parameter handling via signatures
6702 is not guaranteed to remain stable in any future version of Perl,
6703 and such code should be avoided.
6704 Use of bare << to mean <<"" is forbidden
6706 (F) You are now required to use the explicitly quoted form if you
6707 wish to use an empty line as the terminator of the here-document.
6708 Use of a bare terminator was deprecated in Perl 5.000, and is a
6710 fatal error as of Perl 5.28.
6711 Use of /c modifier is meaningless in s///
6713 (W regexp) You used the /c modifier in a substitution. The /c
6714 modifier is not presently meaningful in substitutions.
6715 Use of /c modifier is meaningless without /g
6717 (W regexp) You used the /c modifier with a regex operand, but
6718 didn't use the /g modifier. Currently, /c is meaningful only when
6719 /g is used. (This may change in the future.)
6720 Use of code point 0x%s is not allowed; the permissible max is 0x%X
6722 Use of code point 0x%s is not allowed; the permissible max is 0x%X in
6723 regex; marked by <-- HERE in m/%s/
6724 (F) You used a code point that is not allowed, because it is too
6725 large. Unicode only allows code points up to 0x10FFFF, but Perl
6726 allows much larger ones. Earlier versions of Perl allowed code
6727 points above IV_MAX (0x7FFFFFF on 32-bit platforms,
6728 0x7FFFFFFFFFFFFFFF on 64-bit platforms), however, this could
6729 possibly break the perl interpreter in some constructs, including
6730 causing it to hang in a few cases.
6731 If your code is to run on various platforms, keep in mind that the
6733 upper limit depends on the platform. It is much larger on 64-bit
6734 word sizes than 32-bit ones.
6735 The use of out of range code points was deprecated in Perl 5.24,
6737 and became a fatal error in Perl 5.28.
6738 Use of each() on hash after insertion without resetting hash iterator
6740 results in undefined behavior
6741 (S internal) The behavior of each() after insertion is undefined;
6742 it may skip items, or visit items more than once. Consider using
6743 keys() instead of each().
6744 Use of := for an empty attribute list is not allowed
6746 (F) The construction "my $x := 42" used to parse as equivalent to
6747 "my $x : = 42" (applying an empty attribute list to $x). This
6748 construct was deprecated in 5.12.0, and has now been made a syntax
6749 error, so ":=" can be reclaimed as a new operator in the future.
6750 If you need an empty attribute list, for example in a code
6752 generator, add a space before the "=".
6753 Use of %s for non-UTF-8 locale is wrong. Assuming a UTF-8 locale
6755 (W locale) You are matching a regular expression using locale
6756 rules, and the specified construct was encountered. This construct
6757 is only valid for UTF-8 locales, which the current locale isn't.
6758 This doesn't make sense. Perl will continue, assuming a Unicode
6759 (UTF-8) locale, but the results are likely to be wrong.
6760 Use of freed value in iteration
6762 (F) Perhaps you modified the iterated array within the loop? This
6763 error is typically caused by code like the following:
6764 @a = (3,4);
6766 @a = () for (1,2,@a);
6767 You are not supposed to modify arrays while they are being iterated
6769 over. For speed and efficiency reasons, Perl internally does not
6770 do full reference-counting of iterated items, hence deleting such
6771 an item in the middle of an iteration causes Perl to see a freed
6772 value.
6773 Use of /g modifier is meaningless in split
6775 (W regexp) You used the /g modifier on the pattern for a "split"
6776 operator. Since "split" always tries to match the pattern
6777 repeatedly, the "/g" has no effect.
6778 Use of "goto" to jump into a construct is deprecated
6780 (D deprecated::goto_construct) Using "goto" to jump from an outer
6781 scope into an inner scope is deprecated and should be avoided.
6782 This was deprecated in Perl 5.12.
6784 Use of '%s' in \p{} or \P{} is deprecated because: %s
6786 (D deprecated::unicode_property_name) Certain properties are
6787 deprecated by Unicode, and may eventually be removed from the
6788 Standard, at which time Perl will follow along. In the meantime,
6789 this message is raised to notify you.
6790 Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed
6792 (F) As an accidental feature, "AUTOLOAD" subroutines were looked up
6793 as methods (using the @ISA hierarchy), even when the subroutines to
6794 be autoloaded were called as plain functions (e.g. Foo::bar()), not
6795 as methods (e.g. "Foo->bar()" or "$obj->bar()").
6796 This was deprecated in Perl 5.004, and was made fatal in Perl 5.28.
6798 Use of %s in printf format not supported
6800 (F) You attempted to use a feature of printf that is accessible
6801 from only C. This usually means there's a better way to do it in
6802 Perl.
6803 Use of '%s' is deprecated as a string delimiter
6805 (D deprecated::delimiter_will_be_paired) You used the given
6806 character as a starting delimiter of a string outside the scope of
6807 "use feature 'extra_paired_delimiters'". This character is the
6808 mirror image of another Unicode character; within the scope of that
6809 feature, the two are considered a pair for delimitting strings. It
6810 is planned to make that feature the default, at which point this
6811 usage would become illegal; hence this warning.
6812 For now, you may live with this warning, or turn it off, but this
6814 code will no longer compile in a future version of Perl. Or you
6815 can turn on "use feature 'extra_paired_delimiters'" and use the
6816 character that is the mirror image of this one for the closing
6817 string delimiter.
6818 Use of '%s' is experimental as a string delimiter
6820 (S experimental::extra_paired_delimiters) This warning is emitted
6821 if you use as a string delimiter one of the non-ASCII mirror image
6822 ones enabled by "use feature 'extra_paired_delimiters'". Simply
6823 suppress the warning if you want to use the feature, but know that
6824 in doing so you are taking the risk of using an experimental
6825 feature which may change or be removed in a future Perl version:
6826 Use of %s is not allowed in Unicode property wildcard subpatterns in
6828 regex; marked by <-- HERE in m/%s/
6829 (F) You were using a wildcard subpattern a Unicode property value,
6830 and the subpattern contained something that is illegal. Not all
6831 regular expression capabilities are legal in such subpatterns, and
6832 this is one. Rewrite your subppattern to not use the offending
6833 construct. See "Wildcards in Property Values" in perlunicode.
6834 Use of -l on filehandle%s
6836 (W io) A filehandle represents an opened file, and when you opened
6837 the file it already went past any symlink you are presumably trying
6838 to look for. The operation returned "undef". Use a filename
6839 instead.
6840 Use of reference "%s" as array index
6842 (W misc) You tried to use a reference as an array index; this
6843 probably isn't what you mean, because references in numerical
6844 context tend to be huge numbers, and so usually indicates
6845 programmer error.
6846 If you really do mean it, explicitly numify your reference, like
6848 so: $array[0+$ref]. This warning is not given for overloaded
6849 objects, however, because you can overload the numification and
6850 stringification operators and then you presumably know what you are
6851 doing.
6852 Use of strings with code points over 0xFF as arguments to %s operator
6854 is not allowed
6855 (F) You tried to use one of the string bitwise operators ("&" or
6856 "|" or "^" or "~") on a string containing a code point over 0xFF.
6857 The string bitwise operators treat their operands as strings of
6858 bytes, and values beyond 0xFF are nonsensical in this context.
6859 Certain instances became fatal in Perl 5.28; others in perl 5.32.
6861 Use of strings with code points over 0xFF as arguments to vec is
6863 forbidden
6864 (F) You tried to use "vec" on a string containing a code point over
6865 0xFF, which is nonsensical here.
6866 This became fatal in Perl 5.32.
6868 Use of tainted arguments in %s is deprecated
6870 (W taint, deprecated) You have supplied system() or exec() with
6871 multiple arguments and at least one of them is tainted. This used
6872 to be allowed but will become a fatal error in a future version of
6873 perl. Untaint your arguments. See perlsec.
6874 Use of unassigned code point or non-standalone grapheme for a delimiter
6876 is not allowed
6877 (F) A grapheme is what appears to a native-speaker of a language to
6878 be a character. In Unicode (and hence Perl) a grapheme may
6879 actually be several adjacent characters that together form a
6880 complete grapheme. For example, there can be a base character,
6881 like "R" and an accent, like a circumflex "^", that appear when
6882 displayed to be a single character with the circumflex hovering
6883 over the "R". Perl currently allows things like that circumflex to
6884 be delimiters of strings, patterns, etc. When displayed, the
6885 circumflex would look like it belongs to the character just to the
6886 left of it. In order to move the language to be able to accept
6887 graphemes as delimiters, we cannot allow the use of delimiters
6888 which aren't graphemes by themselves. Also, a delimiter must
6889 already be assigned (or known to be never going to be assigned) to
6890 try to future-proof code, for otherwise code that works today would
6891 fail to compile if the currently unassigned delimiter ends up being
6892 something that isn't a stand-alone grapheme. Because Unicode is
6893 never going to assign non-character code points, nor code points
6894 that are above the legal Unicode maximum, those can be delimiters,
6895 and their use is legal.
6896 Use of uninitialized value%s
6898 (W uninitialized) An undefined value was used as if it were already
6899 defined. It was interpreted as a "" or a 0, but maybe it was a
6900 mistake. To suppress this warning assign a defined value to your
6901 variables.
6902 To help you figure out what was undefined, perl will try to tell
6904 you the name of the variable (if any) that was undefined. In some
6905 cases it cannot do this, so it also tells you what operation you
6906 used the undefined value in. Note, however, that perl optimizes
6907 your program and the operation displayed in the warning may not
6908 necessarily appear literally in your program. For example, "that
6909 $foo" is usually optimized into ""that " . $foo", and the warning
6910 will refer to the "concatenation (.)" operator, even though there
6911 is no "." in your program.
6912 "use re 'strict'" is experimental
6914 (S experimental::re_strict) The things that are different when a
6915 regular expression pattern is compiled under 'strict' are subject
6916 to change in future Perl releases in incompatible ways. This means
6917 that a pattern that compiles today may not in a future Perl
6918 release. This warning is to alert you to that risk.
6919 Use \x{...} for more than two hex characters in regex; marked by
6921 <-- HERE in m/%s/
6922 (F) In a regular expression, you said something like
6923 (?[ [ \xBEEF ] ])
6925 Perl isn't sure if you meant this
6927 (?[ [ \x{BEEF} ] ])
6929 or if you meant this
6931 (?[ [ \x{BE} E F ] ])
6933 You need to add either braces or blanks to disambiguate.
6935 Using just the first character returned by \N{} in character class in
6937 regex; marked by <-- HERE in m/%s/
6938 (W regexp) Named Unicode character escapes "(\N{...})" may return a
6939 multi-character sequence. Even though a character class is
6940 supposed to match just one character of input, perl will match the
6941 whole thing correctly, except when the class is inverted
6942 ("[^...]"), or the escape is the beginning or final end point of a
6943 range. For these, what should happen isn't clear at all. In these
6944 circumstances, Perl discards all but the first character of the
6945 returned sequence, which is not likely what you want.
6946 Using just the single character results returned by \p{} in (?[...]) in
6948 regex; marked by <-- HERE in m/%s/
6949 (W regexp) Extended character classes currently cannot handle
6950 operands that evaluate to more than one character. These are
6951 removed from the results of the expansion of the "\p{}".
6952 This situation can happen, for example, in
6954 (?[ \p{name=/KATAKANA/} ])
6956 "KATAKANA LETTER AINU P" is a legal Unicode name (technically a
6958 "named sequence"), but it is actually two characters. The above
6959 expression with match only the Unicode names containing KATAKANA
6960 that represent single characters.
6961 Using /u for '%s' instead of /%s in regex; marked by <-- HERE in m/%s/
6963 (W regexp) You used a Unicode boundary ("\b{...}" or "\B{...}") in
6964 a portion of a regular expression where the character set modifiers
6965 "/a" or "/aa" are in effect. These two modifiers indicate an ASCII
6966 interpretation, and this doesn't make sense for a Unicode
6967 definition. The generated regular expression will compile so that
6968 the boundary uses all of Unicode. No other portion of the regular
6969 expression is affected.
6970 Using !~ with %s doesn't make sense
6972 (F) Using the "!~" operator with "s///r", "tr///r" or "y///r" is
6973 currently reserved for future use, as the exact behavior has not
6974 been decided. (Simply returning the boolean opposite of the
6975 modified string is usually not particularly useful.)
6976 UTF-16 surrogate U+%X
6978 (S surrogate) You had a UTF-16 surrogate in a context where they
6979 are not considered acceptable. These code points, between U+D800
6980 and U+DFFF (inclusive), are used by Unicode only for UTF-16.
6981 However, Perl internally allows all unsigned integer code points
6982 (up to the size limit available on your platform), including
6983 surrogates. But these can cause problems when being input or
6984 output, which is likely where this message came from. If you
6985 really really know what you are doing you can turn off this warning
6986 by "no warnings 'surrogate';".
6987 Value of %s can be "0"; test with defined()
6989 (W misc) In a conditional expression, you used <HANDLE>, <*>
6990 (glob), each(), or readdir() as a boolean value. Each of these
6991 constructs can return a value of "0"; that would make the
6992 conditional expression false, which is probably not what you
6993 intended. When using these constructs in conditional expressions,
6994 test their values with the "defined" operator.
6995 Value of CLI symbol "%s" too long
6997 (W misc) A warning peculiar to VMS. Perl tried to read the value
6998 of an %ENV element from a CLI symbol table, and found a resultant
6999 string longer than 1024 characters. The return value has been
7000 truncated to 1024 characters.
7001 Variable "%s" is not available
7003 (W closure) During compilation, an inner named subroutine or eval
7004 is attempting to capture an outer lexical that is not currently
7005 available. This can happen for one of two reasons. First, the
7006 outer lexical may be declared in an outer anonymous subroutine that
7007 has not yet been created. (Remember that named subs are created at
7008 compile time, while anonymous subs are created at run-time.) For
7009 example,
7010 sub { my $a; sub f { $a } }
7012 At the time that f is created, it can't capture the current value
7014 of $a, since the anonymous subroutine hasn't been created yet.
7015 Conversely, the following won't give a warning since the anonymous
7016 subroutine has by now been created and is live:
7017 sub { my $a; eval 'sub f { $a }' }->();
7019 The second situation is caused by an eval accessing a variable that
7021 has gone out of scope, for example,
7022 sub f {
7024 my $a;
7025 sub { eval '$a' }
7026 }
7027 f()->();
7028 Here, when the '$a' in the eval is being compiled, f() is not
7030 currently being executed, so its $a is not available for capture.
7031 Variable "%s" is not imported%s
7033 (S misc) With "use strict" in effect, you referred to a global
7034 variable that you apparently thought was imported from another
7035 module, because something else of the same name (usually a
7036 subroutine) is exported by that module. It usually means you put
7037 the wrong funny character on the front of your variable. It is also
7038 possible you used an "our" variable whose scope has ended.
7039 Variable length lookbehind not implemented in regex m/%s/
7041 (F) This message no longer should be raised as of Perl 5.30. It is
7042 retained in this document as a convenience for people using an
7043 earlier Perl version.
7044 In Perl 5.30 and earlier, lookbehind is allowed only for
7046 subexpressions whose length is fixed and known at compile time.
7047 For positive lookbehind, you can use the "\K" regex construct as a
7048 way to get the equivalent functionality. See (?<=pattern) and \K
7049 in perlre.
7050 Starting in Perl 5.18, there are non-obvious Unicode rules under
7052 "/i" that can match variably, but which you might not think could.
7053 For example, the substring "ss" can match the single character
7054 LATIN SMALL LETTER SHARP S. Here's a complete list of the current
7055 ones affecting ASCII characters:
7056 ASCII
7058 sequence Matches single letter under /i
7059 FF U+FB00 LATIN SMALL LIGATURE FF
7060 FFI U+FB03 LATIN SMALL LIGATURE FFI
7061 FFL U+FB04 LATIN SMALL LIGATURE FFL
7062 FI U+FB01 LATIN SMALL LIGATURE FI
7063 FL U+FB02 LATIN SMALL LIGATURE FL
7064 SS U+00DF LATIN SMALL LETTER SHARP S
7065 U+1E9E LATIN CAPITAL LETTER SHARP S
7066 ST U+FB06 LATIN SMALL LIGATURE ST
7067 U+FB05 LATIN SMALL LIGATURE LONG S T
7068 This list is subject to change, but is quite unlikely to. Each
7070 ASCII sequence can be any combination of upper- and lowercase.
7071 You can avoid this by using a bracketed character class in the
7073 lookbehind assertion, like
7074 (?<![sS]t)
7076 (?<![fF]f[iI])
7077 This fools Perl into not matching the ligatures.
7079 Another option for Perls starting with 5.16, if you only care about
7081 ASCII matches, is to add the "/aa" modifier to the regex. This
7082 will exclude all these non-obvious matches, thus getting rid of
7083 this message. You can also say
7084 use if $] ge 5.016, re => '/aa';
7086 to apply "/aa" to all regular expressions compiled within its
7088 scope. See re.
7089 Variable length positive lookbehind with capturing is experimental in
7091 regex m/%s/
7092 (W) Variable length positive lookbehind with capturing is not well
7093 defined. This warning alerts you to the fact that you are using a
7094 construct which may change in a future version of perl. See the
7095 documentation of Positive Lookbehind in perlre for details. You may
7096 silence this warning with the following:
7097 no warnings 'experimental::vlb';
7099 Variable length negative lookbehind with capturing is experimental in
7101 regex m/%s/
7102 (W) Variable length negative lookbehind with capturing is not well
7103 defined. This warning alerts you to the fact that you are using a
7104 construct which may change in a future version of perl. See the
7105 documentation of Negative Lookbehind in perlre for details. You may
7106 silence this warning with the following:
7107 no warnings 'experimental::vlb';
7109 "%s" variable %s masks earlier declaration in same %s
7111 (W shadow) A "my", "our" or "state" variable has been redeclared in
7112 the current scope or statement, effectively eliminating all access
7113 to the previous instance. This is almost always a typographical
7114 error. Note that the earlier variable will still exist until the
7115 end of the scope or until all closure references to it are
7116 destroyed.
7117 Variable syntax
7119 (A) You've accidentally run your script through csh instead of
7120 Perl. Check the #! line, or manually feed your script into Perl
7121 yourself.
7122 Variable "%s" will not stay shared
7124 (W closure) An inner (nested) named subroutine is referencing a
7125 lexical variable defined in an outer named subroutine.
7126 When the inner subroutine is called, it will see the value of the
7128 outer subroutine's variable as it was before and during the *first*
7129 call to the outer subroutine; in this case, after the first call to
7130 the outer subroutine is complete, the inner and outer subroutines
7131 will no longer share a common value for the variable. In other
7132 words, the variable will no longer be shared.
7133 This problem can usually be solved by making the inner subroutine
7135 anonymous, using the "sub {}" syntax. When inner anonymous subs
7136 that reference variables in outer subroutines are created, they are
7137 automatically rebound to the current values of such variables.
7138 vector argument not supported with alpha versions
7140 (S printf) The %vd (s)printf format does not support version
7141 objects with alpha parts.
7142 Verb pattern '%s' has a mandatory argument in regex; marked by <-- HERE
7144 in m/%s/
7145 (F) You used a verb pattern that requires an argument. Supply an
7146 argument or check that you are using the right verb.
7147 Verb pattern '%s' may not have an argument in regex; marked by <-- HERE
7149 in m/%s/
7150 (F) You used a verb pattern that is not allowed an argument.
7151 Remove the argument or check that you are using the right verb.
7152 Version control conflict marker
7154 (F) The parser found a line starting with "<<<<<<<", ">>>>>>>", or
7155 "=======". These may be left by a version control system to mark
7156 conflicts after a failed merge operation.
7157 Version number must be a constant number
7159 (P) The attempt to translate a "use Module n.n LIST" statement into
7160 its equivalent "BEGIN" block found an internal inconsistency with
7161 the version number.
7162 Version string '%s' contains invalid data; ignoring: '%s'
7164 (W misc) The version string contains invalid characters at the end,
7165 which are being ignored.
7166 Warning: something's wrong
7168 (W) You passed warn() an empty string (the equivalent of "warn """)
7169 or you called it with no args and $@ was empty.
7170 Warning: unable to close filehandle %s properly
7172 (S) The implicit close() done by an open() got an error indication
7173 on the close(). This usually indicates your file system ran out of
7174 disk space.
7175 Warning: unable to close filehandle properly: %s
7177 Warning: unable to close filehandle %s properly: %s
7178 (S io) There were errors during the implicit close() done on a
7179 filehandle when its reference count reached zero while it was still
7180 open, e.g.:
7181 {
7183 open my $fh, '>', $file or die "open: '$file': $!\n";
7184 print $fh $data or die "print: $!";
7185 } # implicit close here
7186 Because various errors may only be detected by close() (e.g.
7188 buffering could allow the "print" in this example to return true
7189 even when the disk is full), it is dangerous to ignore its result.
7190 So when it happens implicitly, perl will signal errors by warning.
7191 Prior to version 5.22.0, perl ignored such errors, so the common
7193 idiom shown above was liable to cause silent data loss.
7194 Warning: Use of "%s" without parentheses is ambiguous
7196 (S ambiguous) You wrote a unary operator followed by something that
7197 looks like a binary operator that could also have been interpreted
7198 as a term or unary operator. For instance, if you know that the
7199 rand function has a default argument of 1.0, and you write
7200 rand + 5;
7202 you may THINK you wrote the same thing as
7204 rand() + 5;
7206 but in actual fact, you got
7208 rand(+5);
7210 So put in parentheses to say what you really mean.
7212 when is deprecated
7214 (D deprecated::smartmatch) "when" depends on smartmatch, which is
7215 deprecated. Additionally, it has several special cases that may
7216 not be immediately obvious, and it will be removed in Perl 5.42.
7217 See the explanation under "Experimental Details on given and when"
7218 in perlsyn.
7219 Wide character in %s
7221 (S utf8) Perl met a wide character (ordinal >255) when it wasn't
7222 expecting one. This warning is by default on for I/O (like print).
7223 If this warning does come from I/O, the easiest way to quiet it is
7225 simply to add the ":utf8" layer, e.g., "binmode STDOUT, ':utf8'".
7226 Another way to turn off the warning is to add "no warnings 'utf8';"
7227 but that is often closer to cheating. In general, you are supposed
7228 to explicitly mark the filehandle with an encoding, see open and
7229 "binmode" in perlfunc.
7230 If the warning comes from other than I/O, this diagnostic probably
7232 indicates that incorrect results are being obtained. You should
7233 examine your code to determine how a wide character is getting to
7234 an operation that doesn't handle them.
7235 Wide character (U+%X) in %s
7237 (W locale) While in a single-byte locale (i.e., a non-UTF-8 one), a
7238 multi-byte character was encountered. Perl considers this
7239 character to be the specified Unicode code point. Combining
7240 non-UTF-8 locales and Unicode is dangerous. Almost certainly some
7241 characters will have two different representations. For example,
7242 in the ISO 8859-7 (Greek) locale, the code point 0xC3 represents a
7243 Capital Gamma. But so also does 0x393. This will make string
7244 comparisons unreliable.
7245 You likely need to figure out how this multi-byte character got
7247 mixed up with your single-byte locale (or perhaps you thought you
7248 had a UTF-8 locale, but Perl disagrees).
7249 Within []-length '%c' not allowed
7251 (F) The count in the (un)pack template may be replaced by
7252 "[TEMPLATE]" only if "TEMPLATE" always matches the same amount of
7253 packed bytes that can be determined from the template alone. This
7254 is not possible if it contains any of the codes @, /, U, u, w or a
7255 *-length. Redesign the template.
7256 While trying to resolve method call %s->%s() can not locate package
7258 "%s" yet it is mentioned in @%s::ISA (perhaps you forgot to load "%s"?)
7259 (W syntax) It is possible that the @ISA contains a misspelled or
7260 never loaded package name, which can result in perl choosing an
7261 unexpected parent class's method to resolve the method call. If
7262 this is deliberate you can do something like
7263 @Missing::Package::ISA = ();
7265 to silence the warnings, otherwise you should correct the package
7267 name, or ensure that the package is loaded prior to the method
7268 call.
7269 %s() with negative argument
7271 (S misc) Certain operations make no sense with negative arguments.
7272 Warning is given and the operation is not done.
7273 write() on closed filehandle %s
7275 (W closed) The filehandle you're writing to got itself closed
7276 sometime before now. Check your control flow.
7277 %s "\x%X" does not map to Unicode
7279 (S utf8) When reading in different encodings, Perl tries to map
7280 everything into Unicode characters. The bytes you read in are not
7281 legal in this encoding. For example
7282 utf8 "\xE4" does not map to Unicode
7284 if you try to read in the a-diaereses Latin-1 as UTF-8.
7286 'X' outside of string
7288 (F) You had a (un)pack template that specified a relative position
7289 before the beginning of the string being (un)packed. See "pack" in
7290 perlfunc.
7291 'x' outside of string in unpack
7293 (F) You had an unpack template that specified a relative position
7294 after the end of the string being unpacked. See "pack" in
7295 perlfunc.
7296 YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!
7298 (F) And you probably never will, because you probably don't have
7299 the sources to your kernel, and your vendor probably doesn't give a
7300 rip about what you want. There is a vulnerability anywhere that
7301 you have a set-id script, and to close it you need to remove the
7302 set-id bit from the script that you're attempting to run. To
7303 actually run the script set-id, your best bet is to put a set-id C
7304 wrapper around your script.
7305 You need to quote "%s"
7307 (W syntax) You assigned a bareword as a signal handler name.
7308 Unfortunately, you already have a subroutine of that name declared,
7309 which means that Perl 5 will try to call the subroutine when the
7310 assignment is executed, which is probably not what you want. (If
7311 it IS what you want, put an & in front.)
7312 Your random numbers are not that random
7314 (F) When trying to initialize the random seed for hashes, Perl
7315 could not get any randomness out of your system. This usually
7316 indicates Something Very Wrong.
7317 Zero length \N{} in regex; marked by <-- HERE in m/%s/
7319 (F) Named Unicode character escapes ("\N{...}") may return a zero-
7320 length sequence. Such an escape was used in an extended character
7321 class, i.e. "(?[...])", or under "use re 'strict'", which is not
7322 permitted. Check that the correct escape has been used, and the
7323 correct charnames handler is in scope. The <-- HERE shows
7324 whereabouts in the regular expression the problem was discovered.
7325
7327 warnings, diagnostics.
7328perl v5.38.2 2023-11-30 PERLDIAG(1)