This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
773c43bdcc92d0fa041bfb514324c1e5b3af47c0
[perl5.git] / pod / perldiag.pod
1 =head1 NAME
2
3 perldiag - various Perl diagnostics
4
5 =head1 DESCRIPTION
6
7 These messages are classified as follows (listed in increasing order of
8 desperation):
9
10     (W) A warning (optional).
11     (D) A deprecation (enabled by default).
12     (S) A severe warning (enabled by default).
13     (F) A fatal error (trappable).
14     (P) An internal error you should never see (trappable).
15     (X) A very fatal error (nontrappable).
16     (A) An alien error message (not generated by Perl).
17
18 The majority of messages from the first three classifications above
19 (W, D & S) can be controlled using the C<warnings> pragma.
20
21 If a message can be controlled by the C<warnings> pragma, its warning
22 category is included with the classification letter in the description
23 below.  E.g. C<(W closed)> means a warning in the C<closed> category.
24
25 Optional warnings are enabled by using the C<warnings> pragma or the B<-w>
26 and B<-W> switches.  Warnings may be captured by setting C<$SIG{__WARN__}>
27 to a reference to a routine that will be called on each warning instead
28 of printing it.  See L<perlvar>.
29
30 Severe warnings are always enabled, unless they are explicitly disabled
31 with the C<warnings> pragma or the B<-X> switch.
32
33 Trappable errors may be trapped using the eval operator.  See
34 L<perlfunc/eval>.  In almost all cases, warnings may be selectively
35 disabled or promoted to fatal errors using the C<warnings> pragma.
36 See L<warnings>.
37
38 The messages are in alphabetical order, without regard to upper or
39 lower-case.  Some of these messages are generic.  Spots that vary are
40 denoted with a %s or other printf-style escape.  These escapes are
41 ignored by the alphabetical order, as are all characters other than
42 letters.  To look up your message, just ignore anything that is not a
43 letter.
44
45 =over 4
46
47 =item accept() on closed socket %s
48
49 (W closed) You tried to do an accept on a closed socket.  Did you forget
50 to check the return value of your socket() call?  See
51 L<perlfunc/accept>.
52
53 =item Allocation too large: %x
54
55 (X) You can't allocate more than 64K on an MS-DOS machine.
56
57 =item '%c' allowed only after types %s in %s
58
59 (F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only
60 after certain types.  See L<perlfunc/pack>.
61
62 =item Ambiguous call resolved as CORE::%s(), qualify as such or use &
63
64 (W ambiguous) A subroutine you have declared has the same name as a Perl
65 keyword, and you have used the name without qualification for calling
66 one or the other.  Perl decided to call the builtin because the
67 subroutine is not imported.
68
69 To force interpretation as a subroutine call, either put an ampersand
70 before the subroutine name, or qualify the name with its package.
71 Alternatively, you can import the subroutine (or pretend that it's
72 imported with the C<use subs> pragma).
73
74 To silently interpret it as the Perl operator, use the C<CORE::> prefix
75 on the operator (e.g. C<CORE::log($x)>) or declare the subroutine
76 to be an object method (see L<perlsub/"Subroutine Attributes"> or
77 L<attributes>).
78
79 =item Ambiguous range in transliteration operator
80
81 (F) You wrote something like C<tr/a-z-0//> which doesn't mean anything at
82 all.  To include a C<-> character in a transliteration, put it either
83 first or last.  (In the past, C<tr/a-z-0//> was synonymous with
84 C<tr/a-y//>, which was probably not what you would have expected.)
85
86 =item Ambiguous use of %s resolved as %s
87
88 (S ambiguous) You said something that may not be interpreted the way
89 you thought.  Normally it's pretty easy to disambiguate it by supplying
90 a missing quote, operator, parenthesis pair or declaration.
91
92 =item Ambiguous use of -%s resolved as -&%s()
93
94 (S ambiguous) You wrote something like C<-foo>, which might be the
95 string C<"-foo">, or a call to the function C<foo>, negated.  If you meant
96 the string, just write C<"-foo">.  If you meant the function call,
97 write C<-foo()>.
98
99 =item Ambiguous use of %c resolved as operator %c
100
101 (S ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus,
102 bitwise and, and multiplication) I<and> initial special characters
103 (denoting hashes, subroutines and typeglobs), and you said something
104 like C<*foo * foo> that might be interpreted as either of them.  We
105 assumed you meant the infix operator, but please try to make it more
106 clear -- in the example given, you might write C<*foo * foo()> if you
107 really meant to multiply a glob by the result of calling a function.
108
109 =item Ambiguous use of %c{%s} resolved to %c%s
110
111 (W ambiguous) You wrote something like C<@{foo}>, which might be
112 asking for the variable C<@foo>, or it might be calling a function
113 named foo, and dereferencing it as an array reference.  If you wanted
114 the variable, you can just write C<@foo>.  If you wanted to call the
115 function, write C<@{foo()}> ... or you could just not have a variable
116 and a function with the same name, and save yourself a lot of trouble.
117
118 =item Ambiguous use of %c{%s[...]} resolved to %c%s[...]
119
120 =item Ambiguous use of %c{%s{...}} resolved to %c%s{...}
121
122 (W ambiguous) You wrote something like C<${foo[2]}> (where foo represents
123 the name of a Perl keyword), which might be looking for element number
124 2 of the array named C<@foo>, in which case please write C<$foo[2]>, or you
125 might have meant to pass an anonymous arrayref to the function named
126 foo, and then do a scalar deref on the value it returns.  If you meant
127 that, write C<${foo([2])}>.
128
129 In regular expressions, the C<${foo[2]}> syntax is sometimes necessary
130 to disambiguate between array subscripts and character classes.
131 C</$length[2345]/>, for instance, will be interpreted as C<$length> followed
132 by the character class C<[2345]>.  If an array subscript is what you
133 want, you can avoid the warning by changing C</${length[2345]}/> to the
134 unsightly C</${\$length[2345]}/>, by renaming your array to something
135 that does not coincide with a built-in keyword, or by simply turning
136 off warnings with C<no warnings 'ambiguous';>.
137
138 =item '|' and '<' may not both be specified on command line
139
140 (F) An error peculiar to VMS.  Perl does its own command line
141 redirection, and found that STDIN was a pipe, and that you also tried to
142 redirect STDIN using '<'.  Only one STDIN stream to a customer, please.
143
144 =item '|' and '>' may not both be specified on command line
145
146 (F) An error peculiar to VMS.  Perl does its own command line
147 redirection, and thinks you tried to redirect stdout both to a file and
148 into a pipe to another command.  You need to choose one or the other,
149 though nothing's stopping you from piping into a program or Perl script
150 which 'splits' output into two streams, such as
151
152     open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!";
153     while (<STDIN>) {
154         print;
155         print OUT;
156     }
157     close OUT;
158
159 =item Applying %s to %s will act on scalar(%s)
160
161 (W misc) The pattern match (C<//>), substitution (C<s///>), and
162 transliteration (C<tr///>) operators work on scalar values.  If you apply
163 one of them to an array or a hash, it will convert the array or hash to
164 a scalar value (the length of an array, or the population info of a
165 hash) and then work on that scalar value.  This is probably not what
166 you meant to do.  See L<perlfunc/grep> and L<perlfunc/map> for
167 alternatives.
168
169 =item Arg too short for msgsnd
170
171 (F) msgsnd() requires a string at least as long as sizeof(long).
172
173 =item Argument "%s" isn't numeric%s
174
175 (W numeric) The indicated string was fed as an argument to an operator
176 that expected a numeric value instead.  If you're fortunate the message
177 will identify which operator was so unfortunate.
178
179 =item Argument list not closed for PerlIO layer "%s"
180
181 (W layer) When pushing a layer with arguments onto the Perl I/O
182 system you forgot the ) that closes the argument list.  (Layers
183 take care of transforming data between external and internal
184 representations.)  Perl stopped parsing the layer list at this
185 point and did not attempt to push this layer.  If your program
186 didn't explicitly request the failing operation, it may be the
187 result of the value of the environment variable PERLIO.
188
189 =item Argument "%s" treated as 0 in increment (++)
190
191 (W numeric) The indicated string was fed as an argument to the C<++>
192 operator which expects either a number or a string matching
193 C</^[a-zA-Z]*[0-9]*\z/>.  See L<perlop/Auto-increment and
194 Auto-decrement> for details.
195
196 =item Array @%s missing the @ in argument %d of %s()
197
198 (D deprecated) Really old Perl let you omit the @ on array names in some
199 spots.  This is now heavily deprecated.
200
201 =item A sequence of multiple spaces in a charnames alias definition is deprecated
202
203 (D deprecated) You defined a character name which had multiple space
204 characters in a row.  Change them to single spaces.  Usually these
205 names are defined in the C<:alias> import argument to C<use charnames>, but
206 they could be defined by a translator installed into C<$^H{charnames}>.
207 See L<charnames/CUSTOM ALIASES>.
208
209 =item assertion botched: %s
210
211 (X) The malloc package that comes with Perl had an internal failure.
212
213 =item Assertion %s failed: file "%s", line %d
214
215 (X) A general assertion failed.  The file in question must be examined.
216
217 =item Assigning non-zero to $[ is no longer possible
218
219 (F) When the "array_base" feature is disabled (e.g., under C<use v5.16;>)
220 the special variable C<$[>, which is deprecated, is now a fixed zero value.
221
222 =item Assignment to both a list and a scalar
223
224 (F) If you assign to a conditional operator, the 2nd and 3rd arguments
225 must either both be scalars or both be lists.  Otherwise Perl won't
226 know which context to supply to the right side.
227
228 =item Attempt to access disallowed key '%s' in a restricted hash
229
230 (F) The failing code has attempted to get or set a key which is not in
231 the current set of allowed keys of a restricted hash.
232
233 =item Attempt to bless into a freed package
234
235 (F) You wrote C<bless $foo> with one argument after somehow causing
236 the current package to be freed.  Perl cannot figure out what to
237 do, so it throws up in hands in despair.
238
239 =item Attempt to bless into a reference
240
241 (F) The CLASSNAME argument to the bless() operator is expected to be
242 the name of the package to bless the resulting object into.  You've
243 supplied instead a reference to something: perhaps you wrote
244
245     bless $self, $proto;
246
247 when you intended
248
249     bless $self, ref($proto) || $proto;
250
251 If you actually want to bless into the stringified version
252 of the reference supplied, you need to stringify it yourself, for
253 example by:
254
255     bless $self, "$proto";
256
257 =item Attempt to clear deleted array
258
259 (S debugging) An array was assigned to when it was being freed.
260 Freed values are not supposed to be visible to Perl code.  This
261 can also happen if XS code calls C<av_clear> from a custom magic
262 callback on the array.
263
264 =item Attempt to delete disallowed key '%s' from a restricted hash
265
266 (F) The failing code attempted to delete from a restricted hash a key
267 which is not in its key set.
268
269 =item Attempt to delete readonly key '%s' from a restricted hash
270
271 (F) The failing code attempted to delete a key whose value has been
272 declared readonly from a restricted hash.
273
274 =item Attempt to free non-arena SV: 0x%x
275
276 (S internal) All SV objects are supposed to be allocated from arenas
277 that will be garbage collected on exit.  An SV was discovered to be
278 outside any of those arenas.
279
280 =item Attempt to free nonexistent shared string '%s'%s
281
282 (S internal) Perl maintains a reference-counted internal table of
283 strings to optimize the storage and access of hash keys and other
284 strings.  This indicates someone tried to decrement the reference count
285 of a string that can no longer be found in the table.
286
287 =item Attempt to free temp prematurely: SV 0x%x
288
289 (S debugging) Mortalized values are supposed to be freed by the
290 free_tmps() routine.  This indicates that something else is freeing the
291 SV before the free_tmps() routine gets a chance, which means that the
292 free_tmps() routine will be freeing an unreferenced scalar when it does
293 try to free it.
294
295 =item Attempt to free unreferenced glob pointers
296
297 (S internal) The reference counts got screwed up on symbol aliases.
298
299 =item Attempt to free unreferenced scalar: SV 0x%x
300
301 (S internal) Perl went to decrement the reference count of a scalar to
302 see if it would go to 0, and discovered that it had already gone to 0
303 earlier, and should have been freed, and in fact, probably was freed.
304 This could indicate that SvREFCNT_dec() was called too many times, or
305 that SvREFCNT_inc() was called too few times, or that the SV was
306 mortalized when it shouldn't have been, or that memory has been
307 corrupted.
308
309 =item Attempt to pack pointer to temporary value
310
311 (W pack) You tried to pass a temporary value (like the result of a
312 function, or a computed expression) to the "p" pack() template.  This
313 means the result contains a pointer to a location that could become
314 invalid anytime, even before the end of the current statement.  Use
315 literals or global values as arguments to the "p" pack() template to
316 avoid this warning.
317
318 =item Attempt to reload %s aborted.
319
320 (F) You tried to load a file with C<use> or C<require> that failed to
321 compile once already.  Perl will not try to compile this file again
322 unless you delete its entry from %INC.  See L<perlfunc/require> and
323 L<perlvar/%INC>.
324
325 =item Attempt to set length of freed array
326
327 (W misc) You tried to set the length of an array which has
328 been freed.  You can do this by storing a reference to the
329 scalar representing the last index of an array and later
330 assigning through that reference.  For example
331
332     $r = do {my @a; \$#a};
333     $$r = 503
334
335 =item Attempt to use reference as lvalue in substr
336
337 (W substr) You supplied a reference as the first argument to substr()
338 used as an lvalue, which is pretty strange.  Perhaps you forgot to
339 dereference it first.  See L<perlfunc/substr>.
340
341 =item Attribute "locked" is deprecated
342
343 (D deprecated) You have used the attributes pragma to modify the
344 "locked" attribute on a code reference.  The :locked attribute is
345 obsolete, has had no effect since 5005 threads were removed, and
346 will be removed in a future release of Perl 5.
347
348 =item Attribute prototype(%s) discards earlier prototype attribute in same sub
349
350 (W misc) A sub was declared as sub foo : prototype(A) : prototype(B) {}, for
351 example.  Since each sub can only have one prototype, the earlier
352 declaration(s) are discarded while the last one is applied.
353
354 =item Attribute "unique" is deprecated
355
356 (D deprecated) You have used the attributes pragma to modify
357 the "unique" attribute on an array, hash or scalar reference.
358 The :unique attribute has had no effect since Perl 5.8.8, and
359 will be removed in a future release of Perl 5.
360
361 =item av_reify called on tied array
362
363 (S debugging) This indicates that something went wrong and Perl got I<very>
364 confused about C<@_> or C<@DB::args> being tied.
365
366 =item Bad arg length for %s, is %u, should be %d
367
368 (F) You passed a buffer of the wrong size to one of msgctl(), semctl()
369 or shmctl().  In C parlance, the correct sizes are, respectively,
370 S<sizeof(struct msqid_ds *)>, S<sizeof(struct semid_ds *)>, and
371 S<sizeof(struct shmid_ds *)>.
372
373 =item Bad evalled substitution pattern
374
375 (F) You've used the C</e> switch to evaluate the replacement for a
376 substitution, but perl found a syntax error in the code to evaluate,
377 most likely an unexpected right brace '}'.
378
379 =item Bad filehandle: %s
380
381 (F) A symbol was passed to something wanting a filehandle, but the
382 symbol has no filehandle associated with it.  Perhaps you didn't do an
383 open(), or did it in another package.
384
385 =item Bad free() ignored
386
387 (S malloc) An internal routine called free() on something that had never
388 been malloc()ed in the first place.  Mandatory, but can be disabled by
389 setting environment variable C<PERL_BADFREE> to 0.
390
391 This message can be seen quite often with DB_File on systems with "hard"
392 dynamic linking, like C<AIX> and C<OS/2>.  It is a bug of C<Berkeley DB>
393 which is left unnoticed if C<DB> uses I<forgiving> system malloc().
394
395 =item Bad hash
396
397 (P) One of the internal hash routines was passed a null HV pointer.
398
399 =item Badly placed ()'s
400
401 (A) You've accidentally run your script through B<csh> instead
402 of Perl.  Check the #! line, or manually feed your script into
403 Perl yourself.
404
405 =item Bad name after %s
406
407 (F) You started to name a symbol by using a package prefix, and then
408 didn't finish the symbol.  In particular, you can't interpolate outside
409 of quotes, so
410
411     $var = 'myvar';
412     $sym = mypack::$var;
413
414 is not the same as
415
416     $var = 'myvar';
417     $sym = "mypack::$var";
418
419 =item Bad plugin affecting keyword '%s'
420
421 (F) An extension using the keyword plugin mechanism violated the
422 plugin API.
423
424 =item Bad realloc() ignored
425
426 (S malloc) An internal routine called realloc() on something that
427 had never been malloc()ed in the first place.  Mandatory, but can
428 be disabled by setting the environment variable C<PERL_BADFREE> to 1.
429
430 =item Bad symbol for array
431
432 (P) An internal request asked to add an array entry to something that
433 wasn't a symbol table entry.
434
435 =item Bad symbol for dirhandle
436
437 (P) An internal request asked to add a dirhandle entry to something
438 that wasn't a symbol table entry.
439
440 =item Bad symbol for filehandle
441
442 (P) An internal request asked to add a filehandle entry to something
443 that wasn't a symbol table entry.
444
445 =item Bad symbol for hash
446
447 (P) An internal request asked to add a hash entry to something that
448 wasn't a symbol table entry.
449
450 =item Bareword found in conditional
451
452 (W bareword) The compiler found a bareword where it expected a
453 conditional, which often indicates that an || or && was parsed as part
454 of the last argument of the previous construct, for example:
455
456     open FOO || die;
457
458 It may also indicate a misspelled constant that has been interpreted as
459 a bareword:
460
461     use constant TYPO => 1;
462     if (TYOP) { print "foo" }
463
464 The C<strict> pragma is useful in avoiding such errors.
465
466 =item Bareword "%s" not allowed while "strict subs" in use
467
468 (F) With "strict subs" in use, a bareword is only allowed as a
469 subroutine identifier, in curly brackets or to the left of the "=>"
470 symbol.  Perhaps you need to predeclare a subroutine?
471
472 =item Bareword "%s" refers to nonexistent package
473
474 (W bareword) You used a qualified bareword of the form C<Foo::>, but the
475 compiler saw no other uses of that namespace before that point.  Perhaps
476 you need to predeclare a package?
477
478 =item BEGIN failed--compilation aborted
479
480 (F) An untrapped exception was raised while executing a BEGIN
481 subroutine.  Compilation stops immediately and the interpreter is
482 exited.
483
484 =item BEGIN not safe after errors--compilation aborted
485
486 (F) Perl found a C<BEGIN {}> subroutine (or a C<use> directive, which
487 implies a C<BEGIN {}>) after one or more compilation errors had already
488 occurred.  Since the intended environment for the C<BEGIN {}> could not
489 be guaranteed (due to the errors), and since subsequent code likely
490 depends on its correct operation, Perl just gave up.
491
492 =item \%d better written as $%d
493
494 (W syntax) Outside of patterns, backreferences live on as variables.
495 The use of backslashes is grandfathered on the right-hand side of a
496 substitution, but stylistically it's better to use the variable form
497 because other Perl programmers will expect it, and it works better if
498 there are more than 9 backreferences.
499
500 =item Binary number > 0b11111111111111111111111111111111 non-portable
501
502 (W portable) The binary number you specified is larger than 2**32-1
503 (4294967295) and therefore non-portable between systems.  See
504 L<perlport> for more on portability concerns.
505
506 =item bind() on closed socket %s
507
508 (W closed) You tried to do a bind on a closed socket.  Did you forget to
509 check the return value of your socket() call?  See L<perlfunc/bind>.
510
511 =item binmode() on closed filehandle %s
512
513 (W unopened) You tried binmode() on a filehandle that was never opened.
514 Check your control flow and number of arguments.
515
516 =item "\b{" is deprecated; use "\b\{" or "\b[{]" instead in regex; marked
517 by S<<-- HERE> in m/%s/
518
519 =item "\B{" is deprecated; use "\B\{" or "\B[{]" instead in regex; marked
520 by S<<-- HERE> in m/%s/
521
522 (D deprecated) Use of an unescaped "{" immediately following
523 a C<\b> or C<\B> is now deprecated so as to reserve its use for Perl
524 itself in a future release.  You can either precede the brace
525 with a backslash, or enclose it in square brackets; the latter
526 is the way to go if the pattern delimiters are C<{}>.
527
528 =item Bit vector size > 32 non-portable
529
530 (W portable) Using bit vector sizes larger than 32 is non-portable.
531
532 =item Bizarre copy of %s
533
534 (P) Perl detected an attempt to copy an internal value that is not
535 copiable.
536
537 =item Bizarre SvTYPE [%d]
538
539 (P) When starting a new thread or returning values from a thread, Perl
540 encountered an invalid data type.
541
542 =item Buffer overflow in prime_env_iter: %s
543
544 (W internal) A warning peculiar to VMS.  While Perl was preparing to
545 iterate over %ENV, it encountered a logical name or symbol definition
546 which was too long, so it was truncated to the string shown.
547
548 =item Callback called exit
549
550 (F) A subroutine invoked from an external package via call_sv()
551 exited by calling exit.
552
553 =item %s() called too early to check prototype
554
555 (W prototype) You've called a function that has a prototype before the
556 parser saw a definition or declaration for it, and Perl could not check
557 that the call conforms to the prototype.  You need to either add an
558 early prototype declaration for the subroutine in question, or move the
559 subroutine definition ahead of the call to get proper prototype
560 checking.  Alternatively, if you are certain that you're calling the
561 function correctly, you may put an ampersand before the name to avoid
562 the warning.  See L<perlsub>.
563
564 =item Cannot compress integer in pack
565
566 (F) An argument to pack("w",...) was too large to compress.  The BER
567 compressed integer format can only be used with positive integers, and you
568 attempted to compress Infinity or a very large number (> 1e308).
569 See L<perlfunc/pack>.
570
571 =item Cannot compress negative numbers in pack
572
573 (F) An argument to pack("w",...) was negative.  The BER compressed integer
574 format can only be used with positive integers.  See L<perlfunc/pack>.
575
576 =item Cannot convert a reference to %s to typeglob
577
578 (F) You manipulated Perl's symbol table directly, stored a reference
579 in it, then tried to access that symbol via conventional Perl syntax.
580 The access triggers Perl to autovivify that typeglob, but it there is
581 no legal conversion from that type of reference to a typeglob.
582
583 =item Cannot copy to %s
584
585 (P) Perl detected an attempt to copy a value to an internal type that cannot
586 be directly assigned to.
587
588 =item Cannot find encoding "%s"
589
590 (S io) You tried to apply an encoding that did not exist to a filehandle,
591 either with open() or binmode().
592
593 =item Cannot set tied @DB::args
594
595 (F) C<caller> tried to set C<@DB::args>, but found it tied.  Tying C<@DB::args>
596 is not supported.  (Before this error was added, it used to crash.)
597
598 =item Cannot tie unreifiable array
599
600 (P) You somehow managed to call C<tie> on an array that does not
601 keep a reference count on its arguments and cannot be made to
602 do so.  Such arrays are not even supposed to be accessible to
603 Perl code, but are only used internally.
604
605 =item Can only compress unsigned integers in pack
606
607 (F) An argument to pack("w",...) was not an integer.  The BER compressed
608 integer format can only be used with positive integers, and you attempted
609 to compress something else.  See L<perlfunc/pack>.
610
611 =item Can't bless non-reference value
612
613 (F) Only hard references may be blessed.  This is how Perl "enforces"
614 encapsulation of objects.  See L<perlobj>.
615
616 =item Can't "break" in a loop topicalizer
617
618 (F) You called C<break>, but you're in a C<foreach> block rather than
619 a C<given> block.  You probably meant to use C<next> or C<last>.
620
621 =item Can't "break" outside a given block
622
623 (F) You called C<break>, but you're not inside a C<given> block.
624
625 =item Can't call method "%s" on an undefined value
626
627 (F) You used the syntax of a method call, but the slot filled by the
628 object reference or package name contains an undefined value.  Something
629 like this will reproduce the error:
630
631     $BADREF = undef;
632     process $BADREF 1,2,3;
633     $BADREF->process(1,2,3);
634
635 =item Can't call method "%s" on unblessed reference
636
637 (F) A method call must know in what package it's supposed to run.  It
638 ordinarily finds this out from the object reference you supply, but you
639 didn't supply an object reference in this case.  A reference isn't an
640 object reference until it has been blessed.  See L<perlobj>.
641
642 =item Can't call method "%s" without a package or object reference
643
644 (F) You used the syntax of a method call, but the slot filled by the
645 object reference or package name contains an expression that returns a
646 defined value which is neither an object reference nor a package name.
647 Something like this will reproduce the error:
648
649     $BADREF = 42;
650     process $BADREF 1,2,3;
651     $BADREF->process(1,2,3);
652
653 =item Can't call mro_isa_changed_in() on anonymous symbol table
654
655 (P) Perl got confused as to whether a hash was a plain hash or a
656 symbol table hash when trying to update @ISA caches.
657
658 =item Can't call mro_method_changed_in() on anonymous symbol table
659
660 (F) An XS module tried to call C<mro_method_changed_in> on a hash that was
661 not attached to the symbol table.
662
663 =item Can't chdir to %s
664
665 (F) You called C<perl -x/foo/bar>, but F</foo/bar> is not a directory
666 that you can chdir to, possibly because it doesn't exist.
667
668 =item Can't check filesystem of script "%s" for nosuid
669
670 (P) For some reason you can't check the filesystem of the script for
671 nosuid.
672
673 =item Can't coerce %s to %s in %s
674
675 (F) Certain types of SVs, in particular real symbol table entries
676 (typeglobs), can't be forced to stop being what they are.  So you can't
677 say things like:
678
679     *foo += 1;
680
681 You CAN say
682
683     $foo = *foo;
684     $foo += 1;
685
686 but then $foo no longer contains a glob.
687
688 =item Can't "continue" outside a when block
689
690 (F) You called C<continue>, but you're not inside a C<when>
691 or C<default> block.
692
693 =item Can't create pipe mailbox
694
695 (P) An error peculiar to VMS.  The process is suffering from exhausted
696 quotas or other plumbing problems.
697
698 =item Can't declare %s in "%s"
699
700 (F) Only scalar, array, and hash variables may be declared as "my", "our" or
701 "state" variables.  They must have ordinary identifiers as names.
702
703 =item Can't "default" outside a topicalizer
704
705 (F) You have used a C<default> block that is neither inside a
706 C<foreach> loop nor a C<given> block.  (Note that this error is
707 issued on exit from the C<default> block, so you won't get the
708 error if you use an explicit C<continue>.)
709
710 =item Can't do inplace edit: %s is not a regular file
711
712 (S inplace) You tried to use the B<-i> switch on a special file, such as
713 a file in /dev, a FIFO or an uneditable directory.  The file was ignored.
714
715 =item Can't do inplace edit on %s: %s
716
717 (S inplace) The creation of the new file failed for the indicated
718 reason.
719
720 =item Can't do inplace edit without backup
721
722 (F) You're on a system such as MS-DOS that gets confused if you try
723 reading from a deleted (but still opened) file.  You have to say
724 C<-i.bak>, or some such.
725
726 =item Can't do inplace edit: %s would not be unique
727
728 (S inplace) Your filesystem does not support filenames longer than 14
729 characters and Perl was unable to create a unique filename during
730 inplace editing with the B<-i> switch.  The file was ignored.
731
732 =item Can't do waitpid with flags
733
734 (F) This machine doesn't have either waitpid() or wait4(), so only
735 waitpid() without flags is emulated.
736
737 =item Can't emulate -%s on #! line
738
739 (F) The #! line specifies a switch that doesn't make sense at this
740 point.  For example, it'd be kind of silly to put a B<-x> on the #!
741 line.
742
743 =item Can't %s %s-endian %ss on this platform
744
745 (F) Your platform's byte-order is neither big-endian nor little-endian,
746 or it has a very strange pointer size.  Packing and unpacking big- or
747 little-endian floating point values and pointers may not be possible.
748 See L<perlfunc/pack>.
749
750 =item Can't exec "%s": %s
751
752 (W exec) A system(), exec(), or piped open call could not execute the
753 named program for the indicated reason.  Typical reasons include: the
754 permissions were wrong on the file, the file wasn't found in
755 C<$ENV{PATH}>, the executable in question was compiled for another
756 architecture, or the #! line in a script points to an interpreter that
757 can't be run for similar reasons.  (Or maybe your system doesn't support
758 #! at all.)
759
760 =item Can't exec %s
761
762 (F) Perl was trying to execute the indicated program for you because
763 that's what the #! line said.  If that's not what you wanted, you may
764 need to mention "perl" on the #! line somewhere.
765
766 =item Can't execute %s
767
768 (F) You used the B<-S> switch, but the copies of the script to execute
769 found in the PATH did not have correct permissions.
770
771 =item Can't find an opnumber for "%s"
772
773 (F) A string of a form C<CORE::word> was given to prototype(), but there
774 is no builtin with the name C<word>.
775
776 =item Can't find %s character property "%s"
777
778 (F) You used C<\p{}> or C<\P{}> but the character property by that name
779 could not be found.  Maybe you misspelled the name of the property?
780 See L<perluniprops/Properties accessible through \p{} and \P{}>
781 for a complete list of available official properties.
782
783 =item Can't find label %s
784
785 (F) You said to goto a label that isn't mentioned anywhere that it's
786 possible for us to go to.  See L<perlfunc/goto>.
787
788 =item Can't find %s on PATH
789
790 (F) You used the B<-S> switch, but the script to execute could not be
791 found in the PATH.
792
793 =item Can't find %s on PATH, '.' not in PATH
794
795 (F) You used the B<-S> switch, but the script to execute could not be
796 found in the PATH, or at least not with the correct permissions.  The
797 script exists in the current directory, but PATH prohibits running it.
798
799 =item Can't find string terminator %s anywhere before EOF
800
801 (F) Perl strings can stretch over multiple lines.  This message means
802 that the closing delimiter was omitted.  Because bracketed quotes count
803 nesting levels, the following is missing its final parenthesis:
804
805     print q(The character '(' starts a side comment.);
806
807 If you're getting this error from a here-document, you may have
808 included unseen whitespace before or after your closing tag or there
809 may not be a linebreak after it.  A good programmer's editor will have
810 a way to help you find these characters (or lack of characters).  See
811 L<perlop> for the full details on here-documents.
812
813 =item Can't find Unicode property definition "%s"
814
815 (F) You may have tried to use C<\p> which means a Unicode
816 property (for example C<\p{Lu}> matches all uppercase
817 letters).  If you did mean to use a Unicode property, see
818 L<perluniprops/Properties accessible through \p{} and \P{}>
819 for a complete list of available properties.  If you didn't
820 mean to use a Unicode property, escape the C<\p>, either by
821 C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, or
822 until C<\E>).
823
824 =item Can't fork: %s
825
826 (F) A fatal error occurred while trying to fork while opening a
827 pipeline.
828
829 =item Can't fork, trying again in 5 seconds
830
831 (W pipe) A fork in a piped open failed with EAGAIN and will be retried
832 after five seconds.
833
834 =item Can't get filespec - stale stat buffer?
835
836 (S) A warning peculiar to VMS.  This arises because of the difference
837 between access checks under VMS and under the Unix model Perl assumes.
838 Under VMS, access checks are done by filename, rather than by bits in
839 the stat buffer, so that ACLs and other protections can be taken into
840 account.  Unfortunately, Perl assumes that the stat buffer contains all
841 the necessary information, and passes it, instead of the filespec, to
842 the access-checking routine.  It will try to retrieve the filespec using
843 the device name and FID present in the stat buffer, but this works only
844 if you haven't made a subsequent call to the CRTL stat() routine,
845 because the device name is overwritten with each call.  If this warning
846 appears, the name lookup failed, and the access-checking routine gave up
847 and returned FALSE, just to be conservative.  (Note: The access-checking
848 routine knows about the Perl C<stat> operator and file tests, so you
849 shouldn't ever see this warning in response to a Perl command; it arises
850 only if some internal code takes stat buffers lightly.)
851
852 =item Can't get pipe mailbox device name
853
854 (P) An error peculiar to VMS.  After creating a mailbox to act as a
855 pipe, Perl can't retrieve its name for later use.
856
857 =item Can't get SYSGEN parameter value for MAXBUF
858
859 (P) An error peculiar to VMS.  Perl asked $GETSYI how big you want your
860 mailbox buffers to be, and didn't get an answer.
861
862 =item Can't "goto" into the middle of a foreach loop
863
864 (F) A "goto" statement was executed to jump into the middle of a foreach
865 loop.  You can't get there from here.  See L<perlfunc/goto>.
866
867 =item Can't "goto" out of a pseudo block
868
869 (F) A "goto" statement was executed to jump out of what might look like
870 a block, except that it isn't a proper block.  This usually occurs if
871 you tried to jump out of a sort() block or subroutine, which is a no-no.
872 See L<perlfunc/goto>.
873
874 =item Can't goto subroutine from an eval-%s
875
876 (F) The "goto subroutine" call can't be used to jump out of an eval
877 "string" or block.
878
879 =item Can't goto subroutine from a sort sub (or similar callback)
880
881 (F) The "goto subroutine" call can't be used to jump out of the
882 comparison sub for a sort(), or from a similar callback (such
883 as the reduce() function in List::Util).
884
885 =item Can't goto subroutine outside a subroutine
886
887 (F) The deeply magical "goto subroutine" call can only replace one
888 subroutine call for another.  It can't manufacture one out of whole
889 cloth.  In general you should be calling it out of only an AUTOLOAD
890 routine anyway.  See L<perlfunc/goto>.
891
892 =item Can't ignore signal CHLD, forcing to default
893
894 (W signal) Perl has detected that it is being run with the SIGCHLD
895 signal (sometimes known as SIGCLD) disabled.  Since disabling this
896 signal will interfere with proper determination of exit status of child
897 processes, Perl has reset the signal to its default value.  This
898 situation typically indicates that the parent program under which Perl
899 may be running (e.g. cron) is being very careless.
900
901 =item Can't kill a non-numeric process ID
902
903 (F) Process identifiers must be (signed) integers.  It is a fatal error to
904 attempt to kill() an undefined, empty-string or otherwise non-numeric
905 process identifier.
906
907 =item Can't "last" outside a loop block
908
909 (F) A "last" statement was executed to break out of the current block,
910 except that there's this itty bitty problem called there isn't a current
911 block.  Note that an "if" or "else" block doesn't count as a "loopish"
912 block, as doesn't a block given to sort(), map() or grep().  You can
913 usually double the curlies to get the same effect though, because the
914 inner curlies will be considered a block that loops once.  See
915 L<perlfunc/last>.
916
917 =item Can't linearize anonymous symbol table
918
919 (F) Perl tried to calculate the method resolution order (MRO) of a
920 package, but failed because the package stash has no name.
921
922 =item Can't load '%s' for module %s
923
924 (F) The module you tried to load failed to load a dynamic extension.
925 This may either mean that you upgraded your version of perl to one
926 that is incompatible with your old dynamic extensions (which is known
927 to happen between major versions of perl), or (more likely) that your
928 dynamic extension was built against an older version of the library
929 that is installed on your system.  You may need to rebuild your old
930 dynamic extensions.
931
932 =item Can't localize lexical variable %s
933
934 (F) You used local on a variable name that was previously declared as a
935 lexical variable using "my" or "state".  This is not allowed.  If you
936 want to localize a package variable of the same name, qualify it with
937 the package name.
938
939 =item Can't localize through a reference
940
941 (F) You said something like C<local $$ref>, which Perl can't currently
942 handle, because when it goes to restore the old value of whatever $ref
943 pointed to after the scope of the local() is finished, it can't be sure
944 that $ref will still be a reference.
945
946 =item Can't locate %s
947
948 (F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be found.
949 Perl looks for the file in all the locations mentioned in @INC, unless
950 the file name included the full path to the file.  Perhaps you need
951 to set the PERL5LIB or PERL5OPT environment variable to say where the
952 extra library is, or maybe the script needs to add the library name
953 to @INC.  Or maybe you just misspelled the name of the file.  See
954 L<perlfunc/require> and L<lib>.
955
956 =item Can't locate auto/%s.al in @INC
957
958 (F) A function (or method) was called in a package which allows
959 autoload, but there is no function to autoload.  Most probable causes
960 are a misprint in a function/method name or a failure to C<AutoSplit>
961 the file, say, by doing C<make install>.
962
963 =item Can't locate loadable object for module %s in @INC
964
965 (F) The module you loaded is trying to load an external library, like
966 for example, F<foo.so> or F<bar.dll>, but the L<DynaLoader> module was
967 unable to locate this library.  See L<DynaLoader>.
968
969 =item Can't locate object method "%s" via package "%s"
970
971 (F) You called a method correctly, and it correctly indicated a package
972 functioning as a class, but that package doesn't define that particular
973 method, nor does any of its base classes.  See L<perlobj>.
974
975 =item Can't locate package %s for @%s::ISA
976
977 (W syntax) The @ISA array contained the name of another package that
978 doesn't seem to exist.
979
980 =item Can't locate PerlIO%s
981
982 (F) You tried to use in open() a PerlIO layer that does not exist,
983 e.g. open(FH, ">:nosuchlayer", "somefile").
984
985 =item Can't make list assignment to %ENV on this system
986
987 (F) List assignment to %ENV is not supported on some systems, notably
988 VMS.
989
990 =item Can't make loaded symbols global on this platform while loading %s
991
992 (S) A module passed the flag 0x01 to DynaLoader::dl_load_file() to request
993 that symbols from the stated file are made available globally within the
994 process, but that functionality is not available on this platform.  Whilst
995 the module likely will still work, this may prevent the perl interpreter
996 from loading other XS-based extensions which need to link directly to
997 functions defined in the C or XS code in the stated file.
998
999 =item Can't modify %s in %s
1000
1001 (F) You aren't allowed to assign to the item indicated, or otherwise try
1002 to change it, such as with an auto-increment.
1003
1004 =item Can't modify nonexistent substring
1005
1006 (P) The internal routine that does assignment to a substr() was handed
1007 a NULL.
1008
1009 =item Can't modify non-lvalue subroutine call
1010
1011 (F) Subroutines meant to be used in lvalue context should be declared as
1012 such.  See L<perlsub/"Lvalue subroutines">.
1013
1014 =item Can't msgrcv to read-only var
1015
1016 (F) The target of a msgrcv must be modifiable to be used as a receive
1017 buffer.
1018
1019 =item Can't "next" outside a loop block
1020
1021 (F) A "next" statement was executed to reiterate the current block, but
1022 there isn't a current block.  Note that an "if" or "else" block doesn't
1023 count as a "loopish" block, as doesn't a block given to sort(), map() or
1024 grep().  You can usually double the curlies to get the same effect
1025 though, because the inner curlies will be considered a block that loops
1026 once.  See L<perlfunc/next>.
1027
1028 =item Can't open %s
1029
1030 (F) You tried to run a perl built with MAD support with
1031 the PERL_XMLDUMP environment variable set, but the file
1032 named by that variable could not be opened.
1033
1034 =item Can't open %s: %s
1035
1036 (S inplace) The implicit opening of a file through use of the C<< <> >>
1037 filehandle, either implicitly under the C<-n> or C<-p> command-line
1038 switches, or explicitly, failed for the indicated reason.  Usually
1039 this is because you don't have read permission for a file which
1040 you named on the command line.
1041
1042 (F) You tried to call perl with the B<-e> switch, but F</dev/null> (or
1043 your operating system's equivalent) could not be opened.
1044
1045 =item Can't open a reference
1046
1047 (W io) You tried to open a scalar reference for reading or writing,
1048 using the 3-arg open() syntax:
1049
1050     open FH, '>', $ref;
1051
1052 but your version of perl is compiled without perlio, and this form of
1053 open is not supported.
1054
1055 =item Can't open bidirectional pipe
1056
1057 (W pipe) You tried to say C<open(CMD, "|cmd|")>, which is not supported.
1058 You can try any of several modules in the Perl library to do this, such
1059 as IPC::Open2.  Alternately, direct the pipe's output to a file using
1060 ">", and then read it in under a different file handle.
1061
1062 =item Can't open error file %s as stderr
1063
1064 (F) An error peculiar to VMS.  Perl does its own command line
1065 redirection, and couldn't open the file specified after '2>' or '2>>' on
1066 the command line for writing.
1067
1068 =item Can't open input file %s as stdin
1069
1070 (F) An error peculiar to VMS.  Perl does its own command line
1071 redirection, and couldn't open the file specified after '<' on the
1072 command line for reading.
1073
1074 =item Can't open output file %s as stdout
1075
1076 (F) An error peculiar to VMS.  Perl does its own command line
1077 redirection, and couldn't open the file specified after '>' or '>>' on
1078 the command line for writing.
1079
1080 =item Can't open output pipe (name: %s)
1081
1082 (P) An error peculiar to VMS.  Perl does its own command line
1083 redirection, and couldn't open the pipe into which to send data destined
1084 for stdout.
1085
1086 =item Can't open perl script "%s": %s
1087
1088 (F) The script you specified can't be opened for the indicated reason.
1089
1090 If you're debugging a script that uses #!, and normally relies on the
1091 shell's $PATH search, the -S option causes perl to do that search, so
1092 you don't have to type the path or C<`which $scriptname`>.
1093
1094 =item Can't read CRTL environ
1095
1096 (S) A warning peculiar to VMS.  Perl tried to read an element of %ENV
1097 from the CRTL's internal environment array and discovered the array was
1098 missing.  You need to figure out where your CRTL misplaced its environ
1099 or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
1100 searched.
1101
1102 =item Can't "redo" outside a loop block
1103
1104 (F) A "redo" statement was executed to restart the current block, but
1105 there isn't a current block.  Note that an "if" or "else" block doesn't
1106 count as a "loopish" block, as doesn't a block given to sort(), map()
1107 or grep().  You can usually double the curlies to get the same effect
1108 though, because the inner curlies will be considered a block that
1109 loops once.  See L<perlfunc/redo>.
1110
1111 =item Can't remove %s: %s, skipping file
1112
1113 (S inplace) You requested an inplace edit without creating a backup
1114 file.  Perl was unable to remove the original file to replace it with
1115 the modified file.  The file was left unmodified.
1116
1117 =item Can't rename %s to %s: %s, skipping file
1118
1119 (S inplace) The rename done by the B<-i> switch failed for some reason,
1120 probably because you don't have write permission to the directory.
1121
1122 =item Can't reopen input pipe (name: %s) in binary mode
1123
1124 (P) An error peculiar to VMS.  Perl thought stdin was a pipe, and tried
1125 to reopen it to accept binary data.  Alas, it failed.
1126
1127 =item Can't reset %ENV on this system
1128
1129 (F) You called C<reset('E')> or similar, which tried to reset
1130 all variables in the current package beginning with "E".  In
1131 the main package, that includes %ENV.  Resetting %ENV is not
1132 supported on some systems, notably VMS.
1133
1134 =item Can't resolve method "%s" overloading "%s" in package "%s"
1135
1136 (F)(P) Error resolving overloading specified by a method name (as
1137 opposed to a subroutine reference): no such method callable via the
1138 package.  If the method name is C<???>, this is an internal error.
1139
1140 =item Can't return %s from lvalue subroutine
1141
1142 (F) Perl detected an attempt to return illegal lvalues (such as
1143 temporary or readonly values) from a subroutine used as an lvalue.  This
1144 is not allowed.
1145
1146 =item Can't return outside a subroutine
1147
1148 (F) The return statement was executed in mainline code, that is, where
1149 there was no subroutine call to return out of.  See L<perlsub>.
1150
1151 =item Can't return %s to lvalue scalar context
1152
1153 (F) You tried to return a complete array or hash from an lvalue
1154 subroutine, but you called the subroutine in a way that made Perl
1155 think you meant to return only one value.  You probably meant to
1156 write parentheses around the call to the subroutine, which tell
1157 Perl that the call should be in list context.
1158
1159 =item Can't stat script "%s"
1160
1161 (P) For some reason you can't fstat() the script even though you have it
1162 open already.  Bizarre.
1163
1164 =item Can't take log of %g
1165
1166 (F) For ordinary real numbers, you can't take the logarithm of a
1167 negative number or zero.  There's a Math::Complex package that comes
1168 standard with Perl, though, if you really want to do that for the
1169 negative numbers.
1170
1171 =item Can't take sqrt of %g
1172
1173 (F) For ordinary real numbers, you can't take the square root of a
1174 negative number.  There's a Math::Complex package that comes standard
1175 with Perl, though, if you really want to do that.
1176
1177 =item Can't undef active subroutine
1178
1179 (F) You can't undefine a routine that's currently running.  You can,
1180 however, redefine it while it's running, and you can even undef the
1181 redefined subroutine while the old routine is running.  Go figure.
1182
1183 =item Can't upgrade %s (%d) to %d
1184
1185 (P) The internal sv_upgrade routine adds "members" to an SV, making it
1186 into a more specialized kind of SV.  The top several SV types are so
1187 specialized, however, that they cannot be interconverted.  This message
1188 indicates that such a conversion was attempted.
1189
1190 =item Can't use '%c' after -mname
1191
1192 (F) You tried to call perl with the B<-m> switch, but you put something
1193 other than "=" after the module name.
1194
1195 =item Can't use anonymous symbol table for method lookup
1196
1197 (F) The internal routine that does method lookup was handed a symbol
1198 table that doesn't have a name.  Symbol tables can become anonymous
1199 for example by undefining stashes: C<undef %Some::Package::>.
1200
1201 =item Can't use an undefined value as %s reference
1202
1203 (F) A value used as either a hard reference or a symbolic reference must
1204 be a defined value.  This helps to delurk some insidious errors.
1205
1206 =item Can't use bareword ("%s") as %s ref while "strict refs" in use
1207
1208 (F) Only hard references are allowed by "strict refs".  Symbolic
1209 references are disallowed.  See L<perlref>.
1210
1211 =item Can't use %! because Errno.pm is not available
1212
1213 (F) The first time the C<%!> hash is used, perl automatically loads the
1214 Errno.pm module.  The Errno module is expected to tie the %! hash to
1215 provide symbolic names for C<$!> errno values.
1216
1217 =item Can't use both '<' and '>' after type '%c' in %s
1218
1219 (F) A type cannot be forced to have both big-endian and little-endian
1220 byte-order at the same time, so this combination of modifiers is not
1221 allowed.  See L<perlfunc/pack>.
1222
1223 =item Can't use %s for loop variable
1224
1225 (F) Only a simple scalar variable may be used as a loop variable on a
1226 foreach.
1227
1228 =item Can't use global %s in "%s"
1229
1230 (F) You tried to declare a magical variable as a lexical variable.  This
1231 is not allowed, because the magic can be tied to only one location
1232 (namely the global variable) and it would be incredibly confusing to
1233 have variables in your program that looked like magical variables but
1234 weren't.
1235
1236 =item Can't use '%c' in a group with different byte-order in %s
1237
1238 (F) You attempted to force a different byte-order on a type
1239 that is already inside a group with a byte-order modifier.
1240 For example you cannot force little-endianness on a type that
1241 is inside a big-endian group.
1242
1243 =item Can't use "my %s" in sort comparison
1244
1245 (F) The global variables $a and $b are reserved for sort comparisons.
1246 You mentioned $a or $b in the same line as the <=> or cmp operator,
1247 and the variable had earlier been declared as a lexical variable.
1248 Either qualify the sort variable with the package name, or rename the
1249 lexical variable.
1250
1251 =item Can't use %s ref as %s ref
1252
1253 (F) You've mixed up your reference types.  You have to dereference a
1254 reference of the type needed.  You can use the ref() function to
1255 test the type of the reference, if need be.
1256
1257 =item Can't use string ("%s") as %s ref while "strict refs" in use
1258
1259 =item Can't use string ("%s"...) as %s ref while "strict refs" in use
1260
1261 (F) You've told Perl to dereference a string, something which
1262 C<use strict> blocks to prevent it happening accidentally.  See
1263 L<perlref/"Symbolic references">.  This can be triggered by an C<@> or C<$>
1264 in a double-quoted string immediately before interpolating a variable,
1265 for example in C<"user @$twitter_id">, which says to treat the contents
1266 of C<$twitter_id> as an array reference; use a C<\> to have a literal C<@>
1267 symbol followed by the contents of C<$twitter_id>: C<"user \@$twitter_id">.
1268
1269 =item Can't use subscript on %s
1270
1271 (F) The compiler tried to interpret a bracketed expression as a
1272 subscript.  But to the left of the brackets was an expression that
1273 didn't look like a hash or array reference, or anything else subscriptable.
1274
1275 =item Can't use \%c to mean $%c in expression
1276
1277 (W syntax) In an ordinary expression, backslash is a unary operator that
1278 creates a reference to its argument.  The use of backslash to indicate a
1279 backreference to a matched substring is valid only as part of a regular
1280 expression pattern.  Trying to do this in ordinary Perl code produces a
1281 value that prints out looking like SCALAR(0xdecaf).  Use the $1 form
1282 instead.
1283
1284 =item Can't weaken a nonreference
1285
1286 (F) You attempted to weaken something that was not a reference.  Only
1287 references can be weakened.
1288
1289 =item Can't "when" outside a topicalizer
1290
1291 (F) You have used a when() block that is neither inside a C<foreach>
1292 loop nor a C<given> block.  (Note that this error is issued on exit
1293 from the C<when> block, so you won't get the error if the match fails,
1294 or if you use an explicit C<continue>.)
1295
1296 =item Can't x= to read-only value
1297
1298 (F) You tried to repeat a constant value (often the undefined value)
1299 with an assignment operator, which implies modifying the value itself.
1300 Perhaps you need to copy the value to a temporary, and repeat that.
1301
1302 =item Character following "\c" must be ASCII
1303
1304 (F)(D deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character.
1305 It is planned to make this fatal in all instances in Perl v5.20.  In
1306 the cases where it isn't fatal, the character this evaluates to is
1307 derived by exclusive or'ing the code point of this character with 0x40.
1308
1309 Note that non-alphabetic ASCII characters are discouraged here as well,
1310 and using non-printable ones will be deprecated starting in v5.18.
1311
1312 =item Character in 'C' format wrapped in pack
1313
1314 (W pack) You said
1315
1316     pack("C", $x)
1317
1318 where $x is either less than 0 or more than 255; the C<"C"> format is
1319 only for encoding native operating system characters (ASCII, EBCDIC,
1320 and so on) and not for Unicode characters, so Perl behaved as if you meant
1321
1322     pack("C", $x & 255)
1323
1324 If you actually want to pack Unicode codepoints, use the C<"U"> format
1325 instead.
1326
1327 =item Character in 'c' format wrapped in pack
1328
1329 (W pack) You said
1330
1331     pack("c", $x)
1332
1333 where $x is either less than -128 or more than 127; the C<"c"> format
1334 is only for encoding native operating system characters (ASCII, EBCDIC,
1335 and so on) and not for Unicode characters, so Perl behaved as if you meant
1336
1337     pack("c", $x & 255);
1338
1339 If you actually want to pack Unicode codepoints, use the C<"U"> format
1340 instead.
1341
1342 =item Character in '%c' format wrapped in unpack
1343
1344 (W unpack) You tried something like
1345
1346    unpack("H", "\x{2a1}")
1347
1348 where the format expects to process a byte (a character with a value
1349 below 256), but a higher value was provided instead.  Perl uses the
1350 value modulus 256 instead, as if you had provided:
1351
1352    unpack("H", "\x{a1}")
1353
1354 =item Character in 'W' format wrapped in pack
1355
1356 (W pack) You said
1357
1358     pack("U0W", $x)
1359
1360 where $x is either less than 0 or more than 255.  However, C<U0>-mode
1361 expects all values to fall in the interval [0, 255], so Perl behaved
1362 as if you meant:
1363
1364     pack("U0W", $x & 255)
1365
1366 =item Character(s) in '%c' format wrapped in pack
1367
1368 (W pack) You tried something like
1369
1370    pack("u", "\x{1f3}b")
1371
1372 where the format expects to process a sequence of bytes (character with a
1373 value below 256), but some of the characters had a higher value.  Perl
1374 uses the character values modulus 256 instead, as if you had provided:
1375
1376    pack("u", "\x{f3}b")
1377
1378 =item Character(s) in '%c' format wrapped in unpack
1379
1380 (W unpack) You tried something like
1381
1382    unpack("s", "\x{1f3}b")
1383
1384 where the format expects to process a sequence of bytes (character with a
1385 value below 256), but some of the characters had a higher value.  Perl
1386 uses the character values modulus 256 instead, as if you had provided:
1387
1388    unpack("s", "\x{f3}b")
1389
1390 =item "\c{" is deprecated and is more clearly written as ";"
1391
1392 (D deprecated, syntax) The C<\cI<X>> construct is intended to be a way
1393 to specify non-printable characters.  You used it with a "{" which
1394 evaluates to ";", which is printable.  It is planned to remove the
1395 ability to specify a semi-colon this way in Perl 5.20.  Just use a
1396 semi-colon or a backslash-semi-colon without the "\c".
1397
1398 =item "\c%c" is more clearly written simply as "%s"
1399
1400 (W syntax) The C<\cI<X>> construct is intended to be a way to specify
1401 non-printable characters.  You used it for a printable one, which is better
1402 written as simply itself, perhaps preceded by a backslash for non-word
1403 characters.
1404
1405 =item Cloning substitution context is unimplemented
1406
1407 (F) Creating a new thread inside the C<s///> operator is not supported.
1408
1409 =item closedir() attempted on invalid dirhandle %s
1410
1411 (W io) The dirhandle you tried to close is either closed or not really
1412 a dirhandle.  Check your control flow.
1413
1414 =item close() on unopened filehandle %s
1415
1416 (W unopened) You tried to close a filehandle that was never opened.
1417
1418 =item Closure prototype called
1419
1420 (F) If a closure has attributes, the subroutine passed to an attribute
1421 handler is the prototype that is cloned when a new closure is created.
1422 This subroutine cannot be called.
1423
1424 =item Code missing after '/'
1425
1426 (F) You had a (sub-)template that ends with a '/'.  There must be
1427 another template code following the slash.  See L<perlfunc/pack>.
1428
1429 =item Code point 0x%X is not Unicode, all \p{} matches fail; all \P{} matches 
1430 succeed
1431
1432 =item Code point 0x%X is not Unicode, may not be portable
1433
1434 (S utf8, non_unicode) You had a code point above the Unicode maximum
1435 of U+10FFFF.
1436
1437 Perl allows strings to contain a superset of Unicode code points, up
1438 to the limit of what is storable in an unsigned integer on your system,
1439 but these may not be accepted by other languages/systems.  At one time,
1440 it was legal in some standards to have code points up to 0x7FFF_FFFF,
1441 but not higher.  Code points above 0xFFFF_FFFF require larger than a
1442 32 bit word.
1443
1444 None of the Unicode or Perl-defined properties will match a non-Unicode
1445 code point.  For example,
1446
1447     chr(0x7FF_FFFF) =~ /\p{Any}/
1448
1449 will not match, because the code point is not in Unicode.  But
1450
1451     chr(0x7FF_FFFF) =~ /\P{Any}/
1452
1453 will match.
1454
1455 This may be counterintuitive at times, as both these fail:
1456
1457  chr(0x110000) =~ /\p{ASCII_Hex_Digit=True}/      # Fails.
1458  chr(0x110000) =~ /\p{ASCII_Hex_Digit=False}/     # Also fails!
1459
1460 and both these succeed:
1461
1462  chr(0x110000) =~ /\P{ASCII_Hex_Digit=True}/      # Succeeds.
1463  chr(0x110000) =~ /\P{ASCII_Hex_Digit=False}/     # Also succeeds!
1464
1465 =item %s: Command not found
1466
1467 (A) You've accidentally run your script through B<csh> or another shell
1468 shell instead of Perl.  Check the #! line, or manually feed your script
1469 into Perl yourself.  The #! line at the top of your file could look like
1470
1471   #!/usr/bin/perl -w
1472
1473 =item Compilation failed in require
1474
1475 (F) Perl could not compile a file specified in a C<require> statement.
1476 Perl uses this generic message when none of the errors that it
1477 encountered were severe enough to halt compilation immediately.
1478
1479 =item Complex regular subexpression recursion limit (%d) exceeded
1480
1481 (W regexp) The regular expression engine uses recursion in complex
1482 situations where back-tracking is required.  Recursion depth is limited
1483 to 32766, or perhaps less in architectures where the stack cannot grow
1484 arbitrarily.  ("Simple" and "medium" situations are handled without
1485 recursion and are not subject to a limit.)  Try shortening the string
1486 under examination; looping in Perl code (e.g. with C<while>) rather than
1487 in the regular expression engine; or rewriting the regular expression so
1488 that it is simpler or backtracks less.  (See L<perlfaq2> for information
1489 on I<Mastering Regular Expressions>.)
1490
1491 =item connect() on closed socket %s
1492
1493 (W closed) You tried to do a connect on a closed socket.  Did you forget
1494 to check the return value of your socket() call?  See
1495 L<perlfunc/connect>.
1496
1497 =item Constant(%s): Call to &{$^H{%s}} did not return a defined value
1498
1499 (F) The subroutine registered to handle constant overloading
1500 (see L<overload>) or a custom charnames handler (see
1501 L<charnames/CUSTOM TRANSLATORS>) returned an undefined value.
1502
1503 =item Constant(%s): $^H{%s} is not defined
1504
1505 (F) The parser found inconsistencies while attempting to define an
1506 overloaded constant.  Perhaps you forgot to load the corresponding
1507 L<overload> pragma?.
1508
1509 =item Constant is not %s reference
1510
1511 (F) A constant value (perhaps declared using the C<use constant> pragma)
1512 is being dereferenced, but it amounts to the wrong type of reference.
1513 The message indicates the type of reference that was expected.  This
1514 usually indicates a syntax error in dereferencing the constant value.
1515 See L<perlsub/"Constant Functions"> and L<constant>.
1516
1517 =item Constant subroutine %s redefined
1518
1519 (W redefine)(S) You redefined a subroutine which had previously
1520 been eligible for inlining.  See L<perlsub/"Constant Functions">
1521 for commentary and workarounds.
1522
1523 =item Constant subroutine %s undefined
1524
1525 (W misc) You undefined a subroutine which had previously been eligible
1526 for inlining.  See L<perlsub/"Constant Functions"> for commentary and
1527 workarounds.
1528
1529 =item Constant(%s) unknown
1530
1531 (F) The parser found inconsistencies either while attempting
1532 to define an overloaded constant, or when trying to find the
1533 character name specified in the C<\N{...}> escape.  Perhaps you
1534 forgot to load the corresponding L<overload> pragma?.
1535
1536 =item Copy method did not return a reference
1537
1538 (F) The method which overloads "=" is buggy.  See
1539 L<overload/Copy Constructor>.
1540
1541 =item &CORE::%s cannot be called directly
1542
1543 (F) You tried to call a subroutine in the C<CORE::> namespace
1544 with C<&foo> syntax or through a reference.  Some subroutines
1545 in this package cannot yet be called that way, but must be
1546 called as barewords.  Something like this will work:
1547
1548     BEGIN { *shove = \&CORE::push; }
1549     shove @array, 1,2,3; # pushes on to @array
1550
1551 =item CORE::%s is not a keyword
1552
1553 (F) The CORE:: namespace is reserved for Perl keywords.
1554
1555 =item Corrupted regexp opcode %d > %d
1556
1557 (P) This is either an error in Perl, or, if you're using
1558 one, your L<custom regular expression engine|perlreapi>.  If not the
1559 latter, report the problem through the L<perlbug> utility.
1560
1561 =item corrupted regexp pointers
1562
1563 (P) The regular expression engine got confused by what the regular
1564 expression compiler gave it.
1565
1566 =item corrupted regexp program
1567
1568 (P) The regular expression engine got passed a regexp program without a
1569 valid magic number.
1570
1571 =item Corrupt malloc ptr 0x%x at 0x%x
1572
1573 (P) The malloc package that comes with Perl had an internal failure.
1574
1575 =item Count after length/code in unpack
1576
1577 (F) You had an unpack template indicating a counted-length string, but
1578 you have also specified an explicit size for the string.  See
1579 L<perlfunc/pack>.
1580
1581 =item Deep recursion on anonymous subroutine
1582
1583 =item Deep recursion on subroutine "%s"
1584
1585 (W recursion) This subroutine has called itself (directly or indirectly)
1586 100 times more than it has returned.  This probably indicates an
1587 infinite recursion, unless you're writing strange benchmark programs, in
1588 which case it indicates something else.
1589
1590 This threshold can be changed from 100, by recompiling the F<perl> binary,
1591 setting the C pre-processor macro C<PERL_SUB_DEPTH_WARN> to the desired value.
1592
1593 =item defined(@array) is deprecated
1594
1595 (D deprecated) defined() is not usually useful on arrays because it
1596 checks for an undefined I<scalar> value.  If you want to see if the
1597 array is empty, just use C<if (@array) { # not empty }> for example.
1598
1599 =item defined(%hash) is deprecated
1600
1601 (D deprecated) C<defined()> is not usually right on hashes and has been
1602 discouraged since 5.004.
1603
1604 Although C<defined %hash> is false on a plain not-yet-used hash, it
1605 becomes true in several non-obvious circumstances, including iterators,
1606 weak references, stash names, even remaining true after C<undef %hash>.
1607 These things make C<defined %hash> fairly useless in practice.
1608
1609 If a check for non-empty is what you wanted then just put it in boolean
1610 context (see L<perldata/Scalar values>):
1611
1612     if (%hash) {
1613        # not empty
1614     }
1615
1616 If you had C<defined %Foo::Bar::QUUX> to check whether such a package
1617 variable exists then that's never really been reliable, and isn't
1618 a good way to enquire about the features of a package, or whether
1619 it's loaded, etc.
1620
1621
1622 =item (?(DEFINE)....) does not allow branches in regex; marked by
1623 S<<-- HERE> in m/%s/
1624
1625 (F) You used something like C<(?(DEFINE)...|..)> which is illegal.  The
1626 most likely cause of this error is that you left out a parenthesis inside
1627 of the C<....> part.
1628
1629 The <-- HERE shows whereabouts in the regular expression the problem was
1630 discovered.
1631
1632 =item %s defines neither package nor VERSION--version check failed
1633
1634 (F) You said something like "use Module 42" but in the Module file
1635 there are neither package declarations nor a C<$VERSION>.
1636
1637 =item delete argument is index/value array slice, use array slice
1638
1639 (F) You used index/value array slice syntax (C<%array[...]>) as
1640 the argument to C<delete>.  You probably meant C<@array[...]> with
1641 an @ symbol instead.
1642
1643 =item delete argument is key/value hash slice, use hash slice
1644
1645 (F) You used key/value hash slice syntax (C<%hash{...}>) as the argument to
1646 C<delete>.  You probably meant C<@hash{...}> with an @ symbol instead.
1647
1648 =item delete argument is not a HASH or ARRAY element or slice
1649
1650 (F) The argument to C<delete> must be either a hash or array element,
1651 such as:
1652
1653     $foo{$bar}
1654     $ref->{"susie"}[12]
1655
1656 or a hash or array slice, such as:
1657
1658     @foo[$bar, $baz, $xyzzy]
1659     @{$ref->[12]}{"susie", "queue"}
1660
1661 =item Delimiter for here document is too long
1662
1663 (F) In a here document construct like C<<<FOO>, the label C<FOO> is too
1664 long for Perl to handle.  You have to be seriously twisted to write code
1665 that triggers this error.
1666
1667 =item Deprecated use of my() in false conditional
1668
1669 (D deprecated) You used a declaration similar to C<my $x if 0>.  There
1670 has been a long-standing bug in Perl that causes a lexical variable
1671 not to be cleared at scope exit when its declaration includes a false
1672 conditional.  Some people have exploited this bug to achieve a kind of
1673 static variable.  Since we intend to fix this bug, we don't want people
1674 relying on this behavior.  You can achieve a similar static effect by
1675 declaring the variable in a separate block outside the function, eg
1676
1677     sub f { my $x if 0; return $x++ }
1678
1679 becomes
1680
1681     { my $x; sub f { return $x++ } }
1682
1683 Beginning with perl 5.9.4, you can also use C<state> variables to have
1684 lexicals that are initialized only once (see L<feature>):
1685
1686     sub f { state $x; return $x++ }
1687
1688 =item DESTROY created new reference to dead object '%s'
1689
1690 (F) A DESTROY() method created a new reference to the object which is
1691 just being DESTROYed.  Perl is confused, and prefers to abort rather
1692 than to create a dangling reference.
1693
1694 =item Did not produce a valid header
1695
1696 See Server error.
1697
1698 =item %s did not return a true value
1699
1700 (F) A required (or used) file must return a true value to indicate that
1701 it compiled correctly and ran its initialization code correctly.  It's
1702 traditional to end such a file with a "1;", though any true value would
1703 do.  See L<perlfunc/require>.
1704
1705 =item (Did you mean &%s instead?)
1706
1707 (W misc) You probably referred to an imported subroutine &FOO as $FOO or
1708 some such.
1709
1710 =item (Did you mean "local" instead of "our"?)
1711
1712 (W misc) Remember that "our" does not localize the declared global
1713 variable.  You have declared it again in the same lexical scope, which
1714 seems superfluous.
1715
1716 =item (Did you mean $ or @ instead of %?)
1717
1718 (W) You probably said %hash{$key} when you meant $hash{$key} or
1719 @hash{@keys}.  On the other hand, maybe you just meant %hash and got
1720 carried away.
1721
1722 =item Died
1723
1724 (F) You passed die() an empty string (the equivalent of C<die "">) or
1725 you called it with no args and C<$@> was empty.
1726
1727 =item Document contains no data
1728
1729 See Server error.
1730
1731 =item %s does not define %s::VERSION--version check failed
1732
1733 (F) You said something like "use Module 42" but the Module did not
1734 define a C<$VERSION>.
1735
1736 =item '/' does not take a repeat count
1737
1738 (F) You cannot put a repeat count of any kind right after the '/' code.
1739 See L<perlfunc/pack>.
1740
1741 =item Don't know how to get file name
1742
1743 (P) C<PerlIO_getname>, a perl internal I/O function specific to VMS, was
1744 somehow called on another platform.  This should not happen.
1745
1746 =item Don't know how to handle magic of type \%o
1747
1748 (P) The internal handling of magical variables has been cursed.
1749
1750 =item do_study: out of memory
1751
1752 (P) This should have been caught by safemalloc() instead.
1753
1754 =item (Do you need to predeclare %s?)
1755
1756 (S syntax) This is an educated guess made in conjunction with the message
1757 "%s found where operator expected".  It often means a subroutine or module
1758 name is being referenced that hasn't been declared yet.  This may be
1759 because of ordering problems in your file, or because of a missing
1760 "sub", "package", "require", or "use" statement.  If you're referencing
1761 something that isn't defined yet, you don't actually have to define the
1762 subroutine or package before the current location.  You can use an empty
1763 "sub foo;" or "package FOO;" to enter a "forward" declaration.
1764
1765 =item dump() better written as CORE::dump()
1766
1767 (W misc) You used the obsolescent C<dump()> built-in function, without fully
1768 qualifying it as C<CORE::dump()>.  Maybe it's a typo.  See L<perlfunc/dump>.
1769
1770 =item dump is not supported
1771
1772 (F) Your machine doesn't support dump/undump.
1773
1774 =item Duplicate free() ignored
1775
1776 (S malloc) An internal routine called free() on something that had
1777 already been freed.
1778
1779 =item Duplicate modifier '%c' after '%c' in %s
1780
1781 (W unpack) You have applied the same modifier more than once after a
1782 type in a pack template.  See L<perlfunc/pack>.
1783
1784 =item elseif should be elsif
1785
1786 (S syntax) There is no keyword "elseif" in Perl because Larry thinks
1787 it's ugly.  Your code will be interpreted as an attempt to call a method
1788 named "elseif" for the class returned by the following block.  This is
1789 unlikely to be what you want.
1790
1791 =item Empty \%c{} in regex; marked by S<<-- HERE> in m/%s/
1792
1793 (F) C<\p> and C<\P> are used to introduce a named Unicode property, as
1794 described in L<perlunicode> and L<perlre>.  You used C<\p> or C<\P> in
1795 a regular expression without specifying the property name.
1796
1797 =item entering effective %s failed
1798
1799 (F) While under the C<use filetest> pragma, switching the real and
1800 effective uids or gids failed.
1801
1802 =item %ENV is aliased to %s
1803
1804 (F) You're running under taint mode, and the C<%ENV> variable has been
1805 aliased to another hash, so it doesn't reflect anymore the state of the
1806 program's environment.  This is potentially insecure.
1807
1808 =item Error converting file specification %s
1809
1810 (F) An error peculiar to VMS.  Because Perl may have to deal with file
1811 specifications in either VMS or Unix syntax, it converts them to a
1812 single form when it must operate on them directly.  Either you've passed
1813 an invalid file specification to Perl, or you've found a case the
1814 conversion routines don't handle.  Drat.
1815
1816 =item Escape literal pattern white space under /x
1817
1818 (D deprecated) You compiled a regular expression pattern with C</x> to
1819 ignore white space, and you used, as a literal, one of the characters
1820 that Perl plans to eventually treat as white space.  The character must
1821 be escaped somehow, or it will work differently on a future Perl that
1822 does treat it as white space.  The easiest way is to insert a backslash
1823 immediately before it, or to enclose it with square brackets.  This
1824 change is to bring Perl into conformance with Unicode recommendations.
1825 Here are the five characters that generate this warning:
1826 U+0085 NEXT LINE,
1827 U+200E LEFT-TO-RIGHT MARK,
1828 U+200F RIGHT-TO-LEFT MARK,
1829 U+2028 LINE SEPARATOR,
1830 and
1831 U+2029 PARAGRAPH SEPARATOR.
1832
1833 =item Eval-group in insecure regular expression
1834
1835 (F) Perl detected tainted data when trying to compile a regular
1836 expression that contains the C<(?{ ... })> zero-width assertion, which
1837 is unsafe.  See L<perlre/(?{ code })>, and L<perlsec>.
1838
1839 =item Eval-group not allowed at runtime, use re 'eval' in regex m/%s/
1840
1841 (F) Perl tried to compile a regular expression containing the
1842 C<(?{ ... })> zero-width assertion at run time, as it would when the
1843 pattern contains interpolated values.  Since that is a security risk,
1844 it is not allowed.  If you insist, you may still do this by using the
1845 C<re 'eval'> pragma or by explicitly building the pattern from an
1846 interpolated string at run time and using that in an eval().  See
1847 L<perlre/(?{ code })>.
1848
1849 =item Eval-group not allowed, use re 'eval' in regex m/%s/
1850
1851 (F) A regular expression contained the C<(?{ ... })> zero-width
1852 assertion, but that construct is only allowed when the C<use re 'eval'>
1853 pragma is in effect.  See L<perlre/(?{ code })>.
1854
1855 =item EVAL without pos change exceeded limit in regex; marked by
1856 S<<-- HERE> in m/%s/
1857
1858 (F) You used a pattern that nested too many EVAL calls without consuming
1859 any text.  Restructure the pattern so that text is consumed.
1860
1861 The <-- HERE shows whereabouts in the regular expression the problem was
1862 discovered.
1863
1864 =item Excessively long <> operator
1865
1866 (F) The contents of a <> operator may not exceed the maximum size of a
1867 Perl identifier.  If you're just trying to glob a long list of
1868 filenames, try using the glob() operator, or put the filenames into a
1869 variable and glob that.
1870
1871 =item exec? I'm not *that* kind of operating system
1872
1873 (F) The C<exec> function is not implemented on some systems, e.g., Symbian
1874 OS.  See L<perlport>.
1875
1876 =item Execution of %s aborted due to compilation errors.
1877
1878 (F) The final summary message when a Perl compilation fails.
1879
1880 =item exists argument is not a HASH or ARRAY element or a subroutine
1881
1882 (F) The argument to C<exists> must be a hash or array element or a
1883 subroutine with an ampersand, such as:
1884
1885     $foo{$bar}
1886     $ref->{"susie"}[12]
1887     &do_something
1888
1889 =item exists argument is not a subroutine name
1890
1891 (F) The argument to C<exists> for C<exists &sub> must be a subroutine name,
1892 and not a subroutine call.  C<exists &sub()> will generate this error.
1893
1894 =item Exiting eval via %s
1895
1896 (W exiting) You are exiting an eval by unconventional means, such as a
1897 goto, or a loop control statement.
1898
1899 =item Exiting format via %s
1900
1901 (W exiting) You are exiting a format by unconventional means, such as a
1902 goto, or a loop control statement.
1903
1904 =item Exiting pseudo-block via %s
1905
1906 (W exiting) You are exiting a rather special block construct (like a
1907 sort block or subroutine) by unconventional means, such as a goto, or a
1908 loop control statement.  See L<perlfunc/sort>.
1909
1910 =item Exiting subroutine via %s
1911
1912 (W exiting) You are exiting a subroutine by unconventional means, such
1913 as a goto, or a loop control statement.
1914
1915 =item Exiting substitution via %s
1916
1917 (W exiting) You are exiting a substitution by unconventional means, such
1918 as a return, a goto, or a loop control statement.
1919
1920 =item Expecting close bracket in regex; marked by S<<-- HERE> in m/%s/
1921
1922 (F) You wrote something like
1923
1924  (?13
1925
1926 to denote a capturing group of the form
1927 L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>,
1928 but omitted the C<")">.
1929
1930 =item Expecting '(?flags:(?[...' in regex; marked by S<<-- HERE> in m/%s/
1931
1932 (F) The C<(?[...])> extended character class regular expression construct
1933 only allows character classes (including character class escapes like
1934 C<\d>), operators, and parentheses.  The one exception is C<(?flags:...)>
1935 containing at least one flag and exactly one C<(?[...])> construct.
1936 This allows a regular expression containing just C<(?[...])> to be
1937 interpolated.  If you see this error message, then you probably
1938 have some other C<(?...)> construct inside your character class.  See
1939 L<perlrecharclass/Extended Bracketed Character Classes>.
1940
1941 =item Experimental "%s" subs not enabled
1942
1943 (F) To use lexical subs, you must first enable them:
1944
1945     no warnings 'experimental::lexical_subs';
1946     use feature 'lexical_subs';
1947     my sub foo { ... }
1948
1949 =item Explicit blessing to '' (assuming package main)
1950
1951 (W misc) You are blessing a reference to a zero length string.  This has
1952 the effect of blessing the reference into the package main.  This is
1953 usually not what you want.  Consider providing a default target package,
1954 e.g. bless($ref, $p || 'MyPackage');
1955
1956 =item %s: Expression syntax
1957
1958 (A) You've accidentally run your script through B<csh> instead of Perl.
1959 Check the #! line, or manually feed your script into Perl yourself.
1960
1961 =item %s failed--call queue aborted
1962
1963 (F) An untrapped exception was raised while executing a UNITCHECK,
1964 CHECK, INIT, or END subroutine.  Processing of the remainder of the
1965 queue of such routines has been prematurely ended.
1966
1967 =item False [] range "%s" in regex; marked by S<<-- HERE> in m/%s/
1968
1969 (W regexp)(F) A character class range must start and end at a literal
1970 character, not another character class like C<\d> or C<[:alpha:]>.  The "-"
1971 in your false range is interpreted as a literal "-".  In a C<(?[...])>
1972 construct, this is an error, rather than a warning.  Consider quoting
1973 the "-", "\-".  The S<<-- HERE> shows whereabouts in the regular expression
1974 the problem was discovered.  See L<perlre>.
1975
1976 =item Fatal VMS error (status=%d) at %s, line %d
1977
1978 (P) An error peculiar to VMS.  Something untoward happened in a VMS
1979 system service or RTL routine; Perl's exit status should provide more
1980 details.  The filename in "at %s" and the line number in "line %d" tell
1981 you which section of the Perl source code is distressed.
1982
1983 =item fcntl is not implemented
1984
1985 (F) Your machine apparently doesn't implement fcntl().  What is this, a
1986 PDP-11 or something?
1987
1988 =item FETCHSIZE returned a negative value
1989
1990 (F) A tied array claimed to have a negative number of elements, which
1991 is not possible.
1992
1993 =item Field too wide in 'u' format in pack
1994
1995 (W pack) Each line in an uuencoded string starts with a length indicator
1996 which can't encode values above 63.  So there is no point in asking for
1997 a line length bigger than that.  Perl will behave as if you specified
1998 C<u63> as the format.
1999
2000 =item Filehandle %s opened only for input
2001
2002 (W io) You tried to write on a read-only filehandle.  If you intended
2003 it to be a read-write filehandle, you needed to open it with "+<" or
2004 "+>" or "+>>" instead of with "<" or nothing.  If you intended only to
2005 write the file, use ">" or ">>".  See L<perlfunc/open>.
2006
2007 =item Filehandle %s opened only for output
2008
2009 (W io) You tried to read from a filehandle opened only for writing, If
2010 you intended it to be a read/write filehandle, you needed to open it
2011 with "+<" or "+>" or "+>>" instead of with ">".  If you intended only to
2012 read from the file, use "<".  See L<perlfunc/open>.  Another possibility
2013 is that you attempted to open filedescriptor 0 (also known as STDIN) for
2014 output (maybe you closed STDIN earlier?).
2015
2016 =item Filehandle %s reopened as %s only for input
2017
2018 (W io) You opened for reading a filehandle that got the same filehandle id
2019 as STDOUT or STDERR.  This occurred because you closed STDOUT or STDERR
2020 previously.
2021
2022 =item Filehandle STDIN reopened as %s only for output
2023
2024 (W io) You opened for writing a filehandle that got the same filehandle id
2025 as STDIN.  This occurred because you closed STDIN previously.
2026
2027 =item Final $ should be \$ or $name
2028
2029 (F) You must now decide whether the final $ in a string was meant to be
2030 a literal dollar sign, or was meant to introduce a variable name that
2031 happens to be missing.  So you have to put either the backslash or the
2032 name.
2033
2034 =item flock() on closed filehandle %s
2035
2036 (W closed) The filehandle you're attempting to flock() got itself closed
2037 some time before now.  Check your control flow.  flock() operates on
2038 filehandles.  Are you attempting to call flock() on a dirhandle by the
2039 same name?
2040
2041 =item Format not terminated
2042
2043 (F) A format must be terminated by a line with a solitary dot.  Perl got
2044 to the end of your file without finding such a line.
2045
2046 =item Format %s redefined
2047
2048 (W redefine) You redefined a format.  To suppress this warning, say
2049
2050     {
2051         no warnings 'redefine';
2052         eval "format NAME =...";
2053     }
2054
2055 =item Found = in conditional, should be ==
2056
2057 (W syntax) You said
2058
2059     if ($foo = 123)
2060
2061 when you meant
2062
2063     if ($foo == 123)
2064
2065 (or something like that).
2066
2067 =item %s found where operator expected
2068
2069 (S syntax) The Perl lexer knows whether to expect a term or an operator.
2070 If it sees what it knows to be a term when it was expecting to see an
2071 operator, it gives you this warning.  Usually it indicates that an
2072 operator or delimiter was omitted, such as a semicolon.
2073
2074 =item gdbm store returned %d, errno %d, key "%s"
2075
2076 (S) A warning from the GDBM_File extension that a store failed.
2077
2078 =item gethostent not implemented
2079
2080 (F) Your C library apparently doesn't implement gethostent(), probably
2081 because if it did, it'd feel morally obligated to return every hostname
2082 on the Internet.
2083
2084 =item get%sname() on closed socket %s
2085
2086 (W closed) You tried to get a socket or peer socket name on a closed
2087 socket.  Did you forget to check the return value of your socket() call?
2088
2089 =item getpwnam returned invalid UIC %#o for user "%s"
2090
2091 (S) A warning peculiar to VMS.  The call to C<sys$getuai> underlying the
2092 C<getpwnam> operator returned an invalid UIC.
2093
2094 =item getsockopt() on closed socket %s
2095
2096 (W closed) You tried to get a socket option on a closed socket.  Did you
2097 forget to check the return value of your socket() call?  See
2098 L<perlfunc/getsockopt>.
2099
2100 =item given is experimental
2101
2102 (S experimental::smartmatch) C<given> depends on smartmatch, which
2103 is experimental, so its behavior may change or even be removed
2104 in any future release of perl.  See the explanation under
2105 L<perlsyn/Experimental Details on given and when>.
2106
2107 =item Global symbol "%s" requires explicit package name
2108
2109 (F) You've said "use strict" or "use strict vars", which indicates 
2110 that all variables must either be lexically scoped (using "my" or "state"), 
2111 declared beforehand using "our", or explicitly qualified to say 
2112 which package the global variable is in (using "::").
2113
2114 =item glob failed (%s)
2115
2116 (S glob) Something went wrong with the external program(s) used
2117 for C<glob> and C<< <*.c> >>.  Usually, this means that you supplied a C<glob>
2118 pattern that caused the external program to fail and exit with a
2119 nonzero status.  If the message indicates that the abnormal exit
2120 resulted in a coredump, this may also mean that your csh (C shell)
2121 is broken.  If so, you should change all of the csh-related variables
2122 in config.sh:  If you have tcsh, make the variables refer to it as
2123 if it were csh (e.g. C<full_csh='/usr/bin/tcsh'>); otherwise, make them
2124 all empty (except that C<d_csh> should be C<'undef'>) so that Perl will
2125 think csh is missing.  In either case, after editing config.sh, run
2126 C<./Configure -S> and rebuild Perl.
2127
2128 =item Glob not terminated
2129
2130 (F) The lexer saw a left angle bracket in a place where it was expecting
2131 a term, so it's looking for the corresponding right angle bracket, and
2132 not finding it.  Chances are you left some needed parentheses out
2133 earlier in the line, and you really meant a "less than".
2134
2135 =item gmtime(%f) too large
2136
2137 (W overflow) You called C<gmtime> with a number that was larger than
2138 it can reliably handle and C<gmtime> probably returned the wrong
2139 date.  This warning is also triggered with NaN (the special
2140 not-a-number value).
2141
2142 =item gmtime(%f) too small
2143
2144 (W overflow) You called C<gmtime> with a number that was smaller than
2145 it can reliably handle and C<gmtime> probably returned the wrong date.
2146
2147 =item Got an error from DosAllocMem
2148
2149 (P) An error peculiar to OS/2.  Most probably you're using an obsolete
2150 version of Perl, and this should not happen anyway.
2151
2152 =item goto must have label
2153
2154 (F) Unlike with "next" or "last", you're not allowed to goto an
2155 unspecified destination.  See L<perlfunc/goto>.
2156
2157 =item Goto undefined subroutine%s
2158
2159 (F) You tried to call a subroutine with C<goto &sub> syntax, but
2160 the indicated subroutine hasn't been defined, or if it was, it
2161 has since been undefined.
2162
2163 =item Group name must start with a non-digit word character in regex; marked by 
2164 S<<-- HERE> in m/%s/
2165
2166 (F) Group names must follow the rules for perl identifiers, meaning
2167 they must start with a non-digit word character.  A common cause of
2168 this error is using (?&0) instead of (?0).  See L<perlre>.
2169
2170 =item ()-group starts with a count
2171
2172 (F) A ()-group started with a count.  A count is supposed to follow
2173 something: a template character or a ()-group.  See L<perlfunc/pack>.
2174
2175 =item %s had compilation errors.
2176
2177 (F) The final summary message when a C<perl -c> fails.
2178
2179 =item Had to create %s unexpectedly
2180
2181 (S internal) A routine asked for a symbol from a symbol table that ought
2182 to have existed already, but for some reason it didn't, and had to be
2183 created on an emergency basis to prevent a core dump.
2184
2185 =item Hash %%s missing the % in argument %d of %s()
2186
2187 (D deprecated) Really old Perl let you omit the % on hash names in some
2188 spots.  This is now heavily deprecated.
2189
2190 =item %s has too many errors
2191
2192 (F) The parser has given up trying to parse the program after 10 errors.
2193 Further error messages would likely be uninformative.
2194
2195 =item Hexadecimal number > 0xffffffff non-portable
2196
2197 (W portable) The hexadecimal number you specified is larger than 2**32-1
2198 (4294967295) and therefore non-portable between systems.  See
2199 L<perlport> for more on portability concerns.
2200
2201 =item Identifier too long
2202
2203 (F) Perl limits identifiers (names for variables, functions, etc.) to
2204 about 250 characters for simple names, and somewhat more for compound
2205 names (like C<$A::B>).  You've exceeded Perl's limits.  Future versions
2206 of Perl are likely to eliminate these arbitrary limitations.
2207
2208 =item Ignoring zero length \N{} in character class in regex; marked by
2209 S<<-- HERE> in m/%s/
2210
2211 (W regexp) Named Unicode character escapes C<(\N{...})> may return a
2212 zero-length sequence.  When such an escape is used in a character class
2213 its behaviour is not well defined.  Check that the correct escape has
2214 been used, and the correct charname handler is in scope.
2215
2216 =item Illegal binary digit %s
2217
2218 (F) You used a digit other than 0 or 1 in a binary number.
2219
2220 =item Illegal binary digit %s ignored
2221
2222 (W digit) You may have tried to use a digit other than 0 or 1 in a
2223 binary number.  Interpretation of the binary number stopped before the
2224 offending digit.
2225
2226 =item Illegal character after '_' in prototype for %s : %s
2227
2228 (W illegalproto) An illegal character was found in a prototype
2229 declaration.  The '_' in a prototype must be followed by a ';',
2230 indicating the rest of the parameters are optional, or one of '@'
2231 or '%', since those two will accept 0 or more final parameters.
2232
2233 =item Illegal character \%o (carriage return)
2234
2235 (F) Perl normally treats carriage returns in the program text as it
2236 would any other whitespace, which means you should never see this error
2237 when Perl was built using standard options.  For some reason, your
2238 version of Perl appears to have been built without this support.  Talk
2239 to your Perl administrator.
2240
2241 =item Illegal character in prototype for %s : %s
2242
2243 (W illegalproto) An illegal character was found in a prototype declaration.
2244 Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +.
2245
2246 =item Illegal declaration of anonymous subroutine
2247
2248 (F) When using the C<sub> keyword to construct an anonymous subroutine,
2249 you must always specify a block of code.  See L<perlsub>.
2250
2251 =item Illegal declaration of subroutine %s
2252
2253 (F) A subroutine was not declared correctly.  See L<perlsub>.
2254
2255 =item Illegal division by zero
2256
2257 (F) You tried to divide a number by 0.  Either something was wrong in
2258 your logic, or you need to put a conditional in to guard against
2259 meaningless input.
2260
2261 =item Illegal hexadecimal digit %s ignored
2262
2263 (W digit) You may have tried to use a character other than 0 - 9 or
2264 A - F, a - f in a hexadecimal number.  Interpretation of the hexadecimal
2265 number stopped before the illegal character.
2266
2267 =item Illegal modulus zero
2268
2269 (F) You tried to divide a number by 0 to get the remainder.  Most
2270 numbers don't take to this kindly.
2271
2272 =item Illegal number of bits in vec
2273
2274 (F) The number of bits in vec() (the third argument) must be a power of
2275 two from 1 to 32 (or 64, if your platform supports that).
2276
2277 =item Illegal octal digit %s
2278
2279 (F) You used an 8 or 9 in an octal number.
2280
2281 =item Illegal octal digit %s ignored
2282
2283 (W digit) You may have tried to use an 8 or 9 in an octal number.
2284 Interpretation of the octal number stopped before the 8 or 9.
2285
2286 =item Illegal pattern in regex; marked by S<<-- HERE> in m/%s/
2287
2288 (F) You wrote something like
2289
2290  (?+foo)
2291
2292 The C<"+"> is valid only when followed by digits, indicating a
2293 capturing group.  See
2294 L<C<(?I<PARNO>)>|perlre/(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)>.
2295
2296 =item Illegal switch in PERL5OPT: -%c
2297
2298 (X) The PERL5OPT environment variable may only be used to set the
2299 following switches: B<-[CDIMUdmtw]>.
2300
2301 =item Ill-formed CRTL environ value "%s"
2302
2303 (W internal) A warning peculiar to VMS.  Perl tried to read the CRTL's
2304 internal environ array, and encountered an element without the C<=>
2305 delimiter used to separate keys from values.  The element is ignored.
2306
2307 =item Ill-formed message in prime_env_iter: |%s|
2308
2309 (W internal) A warning peculiar to VMS.  Perl tried to read a logical
2310 name or CLI symbol definition when preparing to iterate over %ENV, and
2311 didn't see the expected delimiter between key and value, so the line was
2312 ignored.
2313
2314 =item (in cleanup) %s
2315
2316 (W misc) This prefix usually indicates that a DESTROY() method raised
2317 the indicated exception.  Since destructors are usually called by the
2318 system at arbitrary points during execution, and often a vast number of
2319 times, the warning is issued only once for any number of failures that
2320 would otherwise result in the same message being repeated.
2321
2322 Failure of user callbacks dispatched using the C<G_KEEPERR> flag could
2323 also result in this warning.  See L<perlcall/G_KEEPERR>.
2324
2325 =item Incomplete expression within '(?[ ])' in regex; marked by S<<-- HERE>
2326 in m/%s/
2327
2328 (F) There was a syntax error within the C<(?[ ])>.  This can happen if the
2329 expression inside the construct was completely empty, or if there are
2330 too many or few operands for the number of operators.  Perl is not smart
2331 enough to give you a more precise indication as to what is wrong.
2332
2333 =item Inconsistent hierarchy during C3 merge of class '%s': merging failed on 
2334 parent '%s'
2335
2336 (F) The method resolution order (MRO) of the given class is not
2337 C3-consistent, and you have enabled the C3 MRO for this class.  See the C3
2338 documentation in L<mro> for more information.
2339
2340 =item In EBCDIC the v-string components cannot exceed 2147483647
2341
2342 (F) An error peculiar to EBCDIC.  Internally, v-strings are stored as
2343 Unicode code points, and encoded in EBCDIC as UTF-EBCDIC.  The UTF-EBCDIC
2344 encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
2345
2346 =item Infinite recursion in regex
2347
2348 (F) You used a pattern that references itself without consuming any input
2349 text.  You should check the pattern to ensure that recursive patterns
2350 either consume text or fail.
2351
2352 =item Initialization of state variables in list context currently forbidden
2353
2354 (F) Currently the implementation of "state" only permits the
2355 initialization of scalar variables in scalar context.  Re-write
2356 C<state ($a) = 42> as C<state $a = 42> to change from list to scalar
2357 context.  Constructions such as C<state (@a) = foo()> will be
2358 supported in a future perl release.
2359
2360 =item %%s[%s] in scalar context better written as $%s[%s]
2361
2362 (W syntax) In scalar context, you've used an array index/value slice
2363 (indicated by %) to select a single element of an array.  Generally
2364 it's better to ask for a scalar value (indicated by $).  The difference
2365 is that C<$foo[&bar]> always behaves like a scalar, both in the value it
2366 returns and when evaluating its argument, while C<%foo[&bar]> provides
2367 a list context to its subscript, which can do weird things if you're
2368 expecting only one subscript.  When called in list context, it also
2369 returns the index (what C<&bar> returns) in addition to the value.
2370
2371 =item %%s{%s} in scalar context better written as $%s{%s}
2372
2373 (W syntax) In scalar context, you've used a hash key/value slice
2374 (indicated by %) to select a single element of a hash.  Generally it's
2375 better to ask for a scalar value (indicated by $).  The difference
2376 is that C<$foo{&bar}> always behaves like a scalar, both in the value
2377 it returns and when evaluating its argument, while C<@foo{&bar}> and
2378 provides a list context to its subscript, which can do weird things
2379 if you're expecting only one subscript.  When called in list context,
2380 it also returns the key in addition to the value.
2381
2382 =item Insecure dependency in %s
2383
2384 (F) You tried to do something that the tainting mechanism didn't like.
2385 The tainting mechanism is turned on when you're running setuid or
2386 setgid, or when you specify B<-T> to turn it on explicitly.  The
2387 tainting mechanism labels all data that's derived directly or indirectly
2388 from the user, who is considered to be unworthy of your trust.  If any
2389 such data is used in a "dangerous" operation, you get this error.  See
2390 L<perlsec> for more information.
2391
2392 =item Insecure directory in %s
2393
2394 (F) You can't use system(), exec(), or a piped open in a setuid or
2395 setgid script if C<$ENV{PATH}> contains a directory that is writable by
2396 the world.  Also, the PATH must not contain any relative directory.
2397 See L<perlsec>.
2398
2399 =item Insecure $ENV{%s} while running %s
2400
2401 (F) You can't use system(), exec(), or a piped open in a setuid or
2402 setgid script if any of C<$ENV{PATH}>, C<$ENV{IFS}>, C<$ENV{CDPATH}>,
2403 C<$ENV{ENV}>, C<$ENV{BASH_ENV}> or C<$ENV{TERM}> are derived from data
2404 supplied (or potentially supplied) by the user.  The script must set
2405 the path to a known value, using trustworthy data.  See L<perlsec>.
2406
2407 =item Insecure user-defined property %s
2408
2409 (F) Perl detected tainted data when trying to compile a regular
2410 expression that contains a call to a user-defined character property
2411 function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
2412 See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
2413
2414 =item In '(?...)', splitting the initial '(?' is deprecated in regex;
2415 marked by S<<-- HERE> in m/%s/
2416
2417 (D regexp, deprecated) The two-character sequence C<"(?"> in
2418 this context in a regular expression pattern should be an
2419 indivisible token, with nothing intervening between the C<"(">
2420 and the C<"?">, but you separated them.  Due to an accident of
2421 implementation, this prohibition was not enforced, but we do
2422 plan to forbid it in a future Perl version.  This message
2423 serves as giving you fair warning of this pending change.
2424
2425 =item Integer overflow in format string for %s
2426
2427 (F) The indexes and widths specified in the format string of C<printf()>
2428 or C<sprintf()> are too large.  The numbers must not overflow the size of
2429 integers for your architecture.
2430
2431 =item Integer overflow in %s number
2432
2433 (S overflow) The hexadecimal, octal or binary number you have specified
2434 either as a literal or as an argument to hex() or oct() is too big for
2435 your architecture, and has been converted to a floating point number.
2436 On a 32-bit architecture the largest hexadecimal, octal or binary number
2437 representable without overflow is 0xFFFFFFFF, 037777777777, or
2438 0b11111111111111111111111111111111 respectively.  Note that Perl
2439 transparently promotes all numbers to a floating point representation
2440 internally--subject to loss of precision errors in subsequent
2441 operations.
2442
2443 =item Integer overflow in srand
2444
2445 (S overflow) The number you have passed to srand is too big to fit
2446 in your architecture's integer representation.  The number has been
2447 replaced with the largest integer supported (0xFFFFFFFF on 32-bit
2448 architectures).  This means you may be getting less randomness than
2449 you expect, because different random seeds above the maximum will
2450 return the same sequence of random numbers.
2451
2452 =item Integer overflow in version
2453
2454 =item Integer overflow in version %d
2455
2456 (W overflow) Some portion of a version initialization is too large for
2457 the size of integers for your architecture.  This is not a warning
2458 because there is no rational reason for a version to try and use an
2459 element larger than typically 2**32.  This is usually caused by trying
2460 to use some odd mathematical operation as a version, like 100/9.
2461
2462 =item Internal disaster in regex; marked by S<<-- HERE> in m/%s/
2463
2464 (P) Something went badly wrong in the regular expression parser.
2465 The S<<-- HERE> shows whereabouts in the regular expression the problem was
2466 discovered.
2467
2468 =item Internal inconsistency in tracking vforks
2469
2470 (S) A warning peculiar to VMS.  Perl keeps track of the number of times
2471 you've called C<fork> and C<exec>, to determine whether the current call
2472 to C<exec> should affect the current script or a subprocess (see
2473 L<perlvms/"exec LIST">).  Somehow, this count has become scrambled, so
2474 Perl is making a guess and treating this C<exec> as a request to
2475 terminate the Perl script and execute the specified command.
2476
2477 =item internal %<num>p might conflict with future printf extensions
2478
2479 (S internal) Perl's internal routine that handles C<printf> and C<sprintf>
2480 formatting follows a slightly different set of rules when called from
2481 C or XS code.  Specifically, formats consisting of digits followed
2482 by "p" (e.g., "%7p") are reserved for future use.  If you see this
2483 message, then an XS module tried to call that routine with one such
2484 reserved format.
2485
2486 =item Internal urp in regex; marked by S<<-- HERE> in m/%s/
2487
2488 (P) Something went badly awry in the regular expression parser.  The
2489 S<<-- HERE> shows whereabouts in the regular expression the problem was
2490 discovered.
2491
2492 =item %s (...) interpreted as function
2493
2494 (W syntax) You've run afoul of the rule that says that any list operator
2495 followed by parentheses turns into a function, with all the list
2496 operators arguments found inside the parentheses.  See
2497 L<perlop/Terms and List Operators (Leftward)>.
2498
2499 =item Invalid %s attribute: %s
2500
2501 (F) The indicated attribute for a subroutine or variable was not recognized
2502 by Perl or by a user-supplied handler.  See L<attributes>.
2503
2504 =item Invalid %s attributes: %s
2505
2506 (F) The indicated attributes for a subroutine or variable were not
2507 recognized by Perl or by a user-supplied handler.  See L<attributes>.
2508
2509 =item Invalid character in charnames alias definition; marked by
2510 S<<-- HERE> in '%s
2511
2512 (F) You tried to create a custom alias for a character name, with
2513 the C<:alias> option to C<use charnames> and the specified character in
2514 the indicated name isn't valid.  See L<charnames/CUSTOM ALIASES>.
2515
2516 =item Invalid \0 character in %s for %s: %s\0%s
2517
2518 (W syscalls) Embedded \0 characters in pathnames or other system call
2519 arguments produce a warning as of 5.20.  The parts after the \0 were
2520 formerly ignored by system calls.
2521
2522 =item Invalid character in \N{...}; marked by S<<-- HERE> in \N{%s}
2523
2524 (F) Only certain characters are valid for character names.  The
2525 indicated one isn't.  See L<charnames/CUSTOM ALIASES>.
2526
2527 =item Invalid conversion in %s: "%s"
2528
2529 (W printf) Perl does not understand the given format conversion.  See
2530 L<perlfunc/sprintf>.
2531
2532 =item Invalid escape in the specified encoding in regex; marked by
2533 S<<-- HERE> in m/%s/
2534
2535 (W regexp) The numeric escape (for example C<\xHH>) of value < 256
2536 didn't correspond to a single character through the conversion
2537 from the encoding specified by the encoding pragma.
2538 The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead.
2539 The S<<-- HERE> shows whereabouts in the regular expression the
2540 escape was discovered.
2541
2542 =item Invalid hexadecimal number in \N{U+...}
2543
2544 =item Invalid hexadecimal number in \N{U+...} in regex; marked by
2545 S<<-- HERE> in m/%s/
2546
2547 (F) The character constant represented by C<...> is not a valid hexadecimal
2548 number.  Either it is empty, or you tried to use a character other than
2549 0 - 9 or A - F, a - f in a hexadecimal number.
2550
2551 =item Invalid module name %s with -%c option: contains single ':'
2552
2553 (F) The module argument to perl's B<-m> and B<-M> command-line options
2554 cannot contain single colons in the module name, but only in the
2555 arguments after "=".  In other words, B<-MFoo::Bar=:baz> is ok, but
2556 B<-MFoo:Bar=baz> is not.
2557
2558 =item Invalid mro name: '%s'
2559
2560 (F) You tried to C<mro::set_mro("classname", "foo")> or C<use mro 'foo'>,
2561 where C<foo> is not a valid method resolution order (MRO).  Currently,
2562 the only valid ones supported are C<dfs> and C<c3>, unless you have loaded
2563 a module that is a MRO plugin.  See L<mro> and L<perlmroapi>.
2564
2565 =item Invalid negative number (%s) in chr
2566
2567 (W utf8) You passed a negative number to C<chr>.  Negative numbers are
2568 not valid characters numbers, so it return the Unicode replacement
2569 character (U+FFFD).
2570
2571 =item invalid option -D%c, use -D'' to see choices
2572
2573 (S debugging) Perl was called with invalid debugger flags.  Call perl
2574 with the B<-D> option with no flags to see the list of acceptable values.
2575 See also L<perlrun/-Dletters>.
2576
2577 =item Invalid [] range "%s" in regex; marked by S<<-- HERE> in m/%s/
2578
2579 (F) The range specified in a character class had a minimum character
2580 greater than the maximum character.  One possibility is that you forgot the
2581 C<{}> from your ending C<\x{}> - C<\x> without the curly braces can go only
2582 up to C<ff>.  The S<<-- HERE> shows whereabouts in the regular expression the
2583 problem was discovered.  See L<perlre>.
2584
2585 =item Invalid range "%s" in transliteration operator
2586
2587 (F) The range specified in the tr/// or y/// operator had a minimum
2588 character greater than the maximum character.  See L<perlop>.
2589
2590 =item Invalid separator character %s in attribute list
2591
2592 (F) Something other than a colon or whitespace was seen between the
2593 elements of an attribute list.  If the previous attribute had a
2594 parenthesised parameter list, perhaps that list was terminated too soon.
2595 See L<attributes>.
2596
2597 =item Invalid separator character %s in PerlIO layer specification %s
2598
2599 (W layer) When pushing layers onto the Perl I/O system, something other
2600 than a colon or whitespace was seen between the elements of a layer list.
2601 If the previous attribute had a parenthesised parameter list, perhaps that
2602 list was terminated too soon.
2603
2604 =item Invalid strict version format (%s)
2605
2606 (F) A version number did not meet the "strict" criteria for versions.
2607 A "strict" version number is a positive decimal number (integer or
2608 decimal-fraction) without exponentiation or else a dotted-decimal
2609 v-string with a leading 'v' character and at least three components.
2610 The parenthesized text indicates which criteria were not met.
2611 See the L<version> module for more details on allowed version formats.
2612
2613 =item Invalid type '%s' in %s
2614
2615 (F) The given character is not a valid pack or unpack type.
2616 See L<perlfunc/pack>.
2617
2618 (W) The given character is not a valid pack or unpack type but used to be
2619 silently ignored.
2620
2621 =item Invalid version format (%s)
2622
2623 (F) A version number did not meet the "lax" criteria for versions.
2624 A "lax" version number is a positive decimal number (integer or
2625 decimal-fraction) without exponentiation or else a dotted-decimal
2626 v-string.  If the v-string has fewer than three components, it
2627 must have a leading 'v' character.  Otherwise, the leading 'v' is
2628 optional.  Both decimal and dotted-decimal versions may have a
2629 trailing "alpha" component separated by an underscore character
2630 after a fractional or dotted-decimal component.  The parenthesized
2631 text indicates which criteria were not met.  See the L<version> module
2632 for more details on allowed version formats.
2633
2634 =item Invalid version object
2635
2636 (F) The internal structure of the version object was invalid.
2637 Perhaps the internals were modified directly in some way or
2638 an arbitrary reference was blessed into the "version" class.
2639
2640 =item In '(*VERB...)', splitting the initial '(*' is deprecated in regex;
2641 marked by S<<-- HERE> in m/%s/
2642
2643 (D regexp, deprecated) The two-character sequence C<"(*"> in
2644 this context in a regular expression pattern should be an
2645 indivisible token, with nothing intervening between the C<"(">
2646 and the C<"*">, but you separated them.  Due to an accident of
2647 implementation, this prohibition was not enforced, but we do
2648 plan to forbid it in a future Perl version.  This message
2649 serves as giving you fair warning of this pending change.
2650
2651 =item ioctl is not implemented
2652
2653 (F) Your machine apparently doesn't implement ioctl(), which is pretty
2654 strange for a machine that supports C.
2655
2656 =item ioctl() on unopened %s
2657
2658 (W unopened) You tried ioctl() on a filehandle that was never opened.
2659 Check your control flow and number of arguments.
2660
2661 =item IO layers (like '%s') unavailable
2662
2663 (F) Your Perl has not been configured to have PerlIO, and therefore
2664 you cannot use IO layers.  To have PerlIO, Perl must be configured
2665 with 'useperlio'.
2666
2667 =item IO::Socket::atmark not implemented on this architecture
2668
2669 (F) Your machine doesn't implement the sockatmark() functionality,
2670 neither as a system call nor an ioctl call (SIOCATMARK).
2671
2672 =item $* is no longer supported
2673
2674 (D deprecated, syntax) The special variable C<$*>, deprecated in older
2675 perls, has been removed as of 5.9.0 and is no longer supported.  In
2676 previous versions of perl the use of C<$*> enabled or disabled multi-line
2677 matching within a string.
2678
2679 Instead of using C<$*> you should use the C</m> (and maybe C</s>) regexp
2680 modifiers.  You can enable C</m> for a lexical scope (even a whole file)
2681 with C<use re '/m'>.  (In older versions: when C<$*> was set to a true value
2682 then all regular expressions behaved as if they were written using C</m>.)
2683
2684 =item $# is no longer supported
2685
2686 (D deprecated, syntax) The special variable C<$#>, deprecated in older
2687 perls, has been removed as of 5.9.3 and is no longer supported.  You
2688 should use the printf/sprintf functions instead.
2689
2690 =item '%s' is not a code reference
2691
2692 (W overload) The second (fourth, sixth, ...) argument of
2693 overload::constant needs to be a code reference.  Either
2694 an anonymous subroutine, or a reference to a subroutine.
2695
2696 =item '%s' is not an overloadable type
2697
2698 (W overload) You tried to overload a constant type the overload package is
2699 unaware of.
2700
2701 =item -i used with no filenames on the command line, reading from STDIN
2702
2703 (S inplace) The C<-i> option was passed on the command line, indicating
2704 that the script is intended to edit files in place, but no files were
2705 given.  This is usually a mistake, since editing STDIN in place doesn't
2706 make sense, and can be confusing because it can make perl look like
2707 it is hanging when it is really just trying to read from STDIN.  You
2708 should either pass a filename to edit, or remove C<-i> from the command
2709 line.  See L<perlrun> for more details.
2710
2711 =item Junk on end of regexp in regex m/%s/
2712
2713 (P) The regular expression parser is confused.
2714
2715 =item Label not found for "last %s"
2716
2717 (F) You named a loop to break out of, but you're not currently in a loop
2718 of that name, not even if you count where you were called from.  See
2719 L<perlfunc/last>.
2720
2721 =item Label not found for "next %s"
2722
2723 (F) You named a loop to continue, but you're not currently in a loop of
2724 that name, not even if you count where you were called from.  See
2725 L<perlfunc/last>.
2726
2727 =item Label not found for "redo %s"
2728
2729 (F) You named a loop to restart, but you're not currently in a loop of
2730 that name, not even if you count where you were called from.  See
2731 L<perlfunc/last>.
2732
2733 =item leaving effective %s failed
2734
2735 (F) While under the C<use filetest> pragma, switching the real and
2736 effective uids or gids failed.
2737
2738 =item length/code after end of string in unpack
2739
2740 (F) While unpacking, the string buffer was already used up when an unpack
2741 length/code combination tried to obtain more data.  This results in
2742 an undefined value for the length.  See L<perlfunc/pack>.
2743
2744 =item length() used on %s (did you mean "scalar(%s)"?)
2745
2746 (W syntax) You used length() on either an array or a hash when you
2747 probably wanted a count of the items.
2748
2749 Array size can be obtained by doing:
2750
2751     scalar(@array);
2752
2753 The number of items in a hash can be obtained by doing:
2754
2755     scalar(keys %hash);
2756
2757 =item Lexing code attempted to stuff non-Latin-1 character into Latin-1 input
2758
2759 (F) An extension is attempting to insert text into the current parse
2760 (using L<lex_stuff_pvn|perlapi/lex_stuff_pvn> or similar), but tried to insert a character that
2761 couldn't be part of the current input.  This is an inherent pitfall
2762 of the stuffing mechanism, and one of the reasons to avoid it.  Where
2763 it is necessary to stuff, stuffing only plain ASCII is recommended.
2764
2765 =item Lexing code internal error (%s)
2766
2767 (F) Lexing code supplied by an extension violated the lexer's API in a
2768 detectable way.
2769
2770 =item listen() on closed socket %s
2771
2772 (W closed) You tried to do a listen on a closed socket.  Did you forget
2773 to check the return value of your socket() call?  See
2774 L<perlfunc/listen>.
2775
2776 =item List form of piped open not implemented
2777
2778 (F) On some platforms, notably Windows, the three-or-more-arguments
2779 form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>.
2780 Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead.
2781
2782 =item localtime(%f) too large
2783
2784 (W overflow) You called C<localtime> with a number that was larger
2785 than it can reliably handle and C<localtime> probably returned the
2786 wrong date.  This warning is also triggered with NaN (the special
2787 not-a-number value).
2788
2789 =item localtime(%f) too small
2790
2791 (W overflow) You called C<localtime> with a number that was smaller
2792 than it can reliably handle and C<localtime> probably returned the
2793 wrong date.
2794
2795 =item Lookbehind longer than %d not implemented in regex m/%s/
2796
2797 (F) There is currently a limit on the length of string which lookbehind can
2798 handle.  This restriction may be eased in a future release. 
2799
2800 =item Lost precision when %s %f by 1
2801
2802 (W imprecision) The value you attempted to increment or decrement by one
2803 is too large for the underlying floating point representation to store
2804 accurately, hence the target of C<++> or C<--> is unchanged.  Perl issues this
2805 warning because it has already switched from integers to floating point
2806 when values are too large for integers, and now even floating point is
2807 insufficient.  You may wish to switch to using L<Math::BigInt> explicitly.
2808
2809 =item lstat() on filehandle%s
2810
2811 (W io) You tried to do an lstat on a filehandle.  What did you mean
2812 by that?  lstat() makes sense only on filenames.  (Perl did a fstat()
2813 instead on the filehandle.)
2814
2815 =item lvalue attribute %s already-defined subroutine
2816
2817 (W misc) Although L<attributes.pm|attributes> allows this, turning the lvalue
2818 attribute on or off on a Perl subroutine that is already defined
2819 does not always work properly.  It may or may not do what you
2820 want, depending on what code is inside the subroutine, with exact
2821 details subject to change between Perl versions.  Only do this
2822 if you really know what you are doing.
2823
2824 =item lvalue attribute ignored after the subroutine has been defined
2825
2826 (W misc) Using the C<:lvalue> declarative syntax to make a Perl
2827 subroutine an lvalue subroutine after it has been defined is
2828 not permitted.  To make the subroutine an lvalue subroutine,
2829 add the lvalue attribute to the definition, or put the C<sub
2830 foo :lvalue;> declaration before the definition.
2831
2832 See also L<attributes.pm|attributes>.
2833
2834 =item Magical list constants are not supported
2835
2836 (F) You assigned a magical array to a stash element, and then tried
2837 to use the subroutine from the same slot.  You are asking Perl to do
2838 something it cannot do, details subject to change between Perl versions.
2839
2840 =item Malformed integer in [] in pack
2841
2842 (F) Between the brackets enclosing a numeric repeat count only digits
2843 are permitted.  See L<perlfunc/pack>.
2844
2845 =item Malformed integer in [] in unpack
2846
2847 (F) Between the brackets enclosing a numeric repeat count only digits
2848 are permitted.  See L<perlfunc/pack>.
2849
2850 =item Malformed PERLLIB_PREFIX
2851
2852 (F) An error peculiar to OS/2.  PERLLIB_PREFIX should be of the form
2853
2854     prefix1;prefix2
2855
2856 or
2857     prefix1 prefix2
2858
2859 with nonempty prefix1 and prefix2.  If C<prefix1> is indeed a prefix of
2860 a builtin library search path, prefix2 is substituted.  The error may
2861 appear if components are not found, or are too long.  See
2862 "PERLLIB_PREFIX" in L<perlos2>.
2863
2864 =item Malformed prototype for %s: %s
2865
2866 (F) You tried to use a function with a malformed prototype.  The
2867 syntax of function prototypes is given a brief compile-time check for
2868 obvious errors like invalid characters.  A more rigorous check is run
2869 when the function is called.
2870
2871 =item Malformed UTF-8 character (%s)
2872
2873 (S utf8)(F) Perl detected a string that didn't comply with UTF-8
2874 encoding rules, even though it had the UTF8 flag on.
2875
2876 One possible cause is that you set the UTF8 flag yourself for data that
2877 you thought to be in UTF-8 but it wasn't (it was for example legacy
2878 8-bit data).  To guard against this, you can use Encode::decode_utf8.
2879
2880 If you use the C<:encoding(UTF-8)> PerlIO layer for input, invalid byte
2881 sequences are handled gracefully, but if you use C<:utf8>, the flag is
2882 set without validating the data, possibly resulting in this error
2883 message.
2884
2885 See also L<Encode/"Handling Malformed Data">.
2886
2887 =item Malformed UTF-8 character immediately after '%s'
2888
2889 (F) You said C<use utf8>, but the program file doesn't comply with UTF-8
2890 encoding rules.  The message prints out the properly encoded characters
2891 just before the first bad one.  If C<utf8> warnings are enabled, a
2892 warning is generated that gives more details about the type of
2893 malformation.
2894
2895 =item Malformed UTF-8 returned by \N{%s} immediately after '%s'
2896
2897 (F) The charnames handler returned malformed UTF-8.
2898
2899 =item Malformed UTF-8 string in '%c' format in unpack
2900
2901 (F) You tried to unpack something that didn't comply with UTF-8 encoding
2902 rules and perl was unable to guess how to make more progress.
2903
2904 =item Malformed UTF-8 string in pack
2905
2906 (F) You tried to pack something that didn't comply with UTF-8 encoding
2907 rules and perl was unable to guess how to make more progress.
2908
2909 =item Malformed UTF-8 string in unpack
2910
2911 (F) You tried to unpack something that didn't comply with UTF-8 encoding
2912 rules and perl was unable to guess how to make more progress.
2913
2914 =item Malformed UTF-16 surrogate
2915
2916 (F) Perl thought it was reading UTF-16 encoded character data but while
2917 doing it Perl met a malformed Unicode surrogate.
2918
2919 =item %s matches null string many times in regex; marked by S<<-- HERE> in
2920 m/%s/
2921
2922 (W regexp) The pattern you've specified would be an infinite loop if the
2923 regular expression engine didn't specifically check for that.  The S<<-- HERE>
2924 shows whereabouts in the regular expression the problem was discovered.
2925 See L<perlre>.
2926
2927 =item Maximal count of pending signals (%u) exceeded
2928
2929 (F) Perl aborted due to too high a number of signals pending.  This
2930 usually indicates that your operating system tried to deliver signals
2931 too fast (with a very high priority), starving the perl process from
2932 resources it would need to reach a point where it can process signals
2933 safely.  (See L<perlipc/"Deferred Signals (Safe Signals)">.)
2934
2935 =item "%s" may clash with future reserved word
2936
2937 (W) This warning may be due to running a perl5 script through a perl4
2938 interpreter, especially if the word that is being warned about is
2939 "use" or "my".
2940
2941 =item '%' may not be used in pack
2942
2943 (F) You can't pack a string by supplying a checksum, because the
2944 checksumming process loses information, and you can't go the other way.
2945 See L<perlfunc/unpack>.
2946
2947 =item Method for operation %s not found in package %s during blessing
2948
2949 (F) An attempt was made to specify an entry in an overloading table that
2950 doesn't resolve to a valid subroutine.  See L<overload>.
2951
2952 =item Method %s not permitted
2953
2954 See Server error.
2955
2956 =item Might be a runaway multi-line %s string starting on line %d
2957
2958 (S) An advisory indicating that the previous error may have been caused
2959 by a missing delimiter on a string or pattern, because it eventually
2960 ended earlier on the current line.
2961
2962 =item Misplaced _ in number
2963
2964 (W syntax) An underscore (underbar) in a numeric constant did not
2965 separate two digits.
2966
2967 =item Missing argument in %s
2968
2969 (W uninitialized) A printf-type format required more arguments than were
2970 supplied.
2971
2972 =item Missing argument to -%c
2973
2974 (F) The argument to the indicated command line switch must follow
2975 immediately after the switch, without intervening spaces.
2976
2977 =item Missing braces on \N{}
2978
2979 =item Missing braces on \N{} in regex; marked by S<<-- HERE> in m/%s/
2980
2981 (F) Wrong syntax of character name literal C<\N{charname}> within
2982 double-quotish context.  This can also happen when there is a space
2983 (or comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
2984 This modifier does not change the requirement that the brace immediately
2985 follow the C<\N>.
2986
2987 =item Missing braces on \o{}
2988
2989 (F) A C<\o> must be followed immediately by a C<{> in double-quotish context.
2990
2991 =item Missing comma after first argument to %s function
2992
2993 (F) While certain functions allow you to specify a filehandle or an
2994 "indirect object" before the argument list, this ain't one of them.
2995
2996 =item Missing command in piped open
2997
2998 (W pipe) You used the C<open(FH, "| command")> or
2999 C<open(FH, "command |")> construction, but the command was missing or
3000 blank.
3001
3002 =item Missing control char name in \c
3003
3004 (F) A double-quoted string ended with "\c", without the required control
3005 character name.
3006
3007 =item Missing ']' in prototype for %s : %s
3008
3009 (W illegalproto) A grouping was started with C<[> but never closed with C<]>.
3010
3011 =item Missing name in "%s sub"
3012
3013 (F) The syntax for lexically scoped subroutines requires that
3014 they have a name with which they can be found.
3015
3016 =item Missing $ on loop variable
3017
3018 (F) Apparently you've been programming in B<csh> too much.  Variables
3019 are always mentioned with the $ in Perl, unlike in the shells, where it
3020 can vary from one line to the next.
3021
3022 =item (Missing operator before %s?)
3023
3024 (S syntax) This is an educated guess made in conjunction with the message
3025 "%s found where operator expected".  Often the missing operator is a comma.
3026
3027 =item Missing right brace on \%c{} in regex; marked by S<<-- HERE> in m/%s/
3028
3029 (F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
3030
3031 =item Missing right brace on \N{} or unescaped left brace after \N
3032
3033 (F) C<\N> has two meanings.
3034
3035 The traditional one has it followed by a name enclosed in braces,
3036 meaning the character (or sequence of characters) given by that
3037 name.  Thus C<\N{ASTERISK}> is another way of writing C<*>, valid in both
3038 double-quoted strings and regular expression patterns.  In patterns,
3039 it doesn't have the meaning an unescaped C<*> does.
3040
3041 Starting in Perl 5.12.0, C<\N> also can have an additional meaning (only)
3042 in patterns, namely to match a non-newline character.  (This is short
3043 for C<[^\n]>, and like C<.> but is not affected by the C</s> regex modifier.)
3044
3045 This can lead to some ambiguities.  When C<\N> is not followed immediately
3046 by a left brace, Perl assumes the C<[^\n]> meaning.  Also, if the braces
3047 form a valid quantifier such as C<\N{3}> or C<\N{5,}>, Perl assumes that this
3048 means to match the given quantity of non-newlines (in these examples,
3049 3; and 5 or more, respectively).  In all other case, where there is a
3050 C<\N{> and a matching C<}>, Perl assumes that a character name is desired.
3051
3052 However, if there is no matching C<}>, Perl doesn't know if it was
3053 mistakenly omitted, or if C<[^\n]{> was desired, and raises this error.
3054 If you meant the former, add the right brace; if you meant the latter,
3055 escape the brace with a backslash, like so: C<\N\{>
3056
3057 =item Missing right curly or square bracket
3058
3059 (F) The lexer counted more opening curly or square brackets than closing
3060 ones.  As a general rule, you'll find it's missing near the place you
3061 were last editing.
3062
3063 =item (Missing semicolon on previous line?)
3064
3065 (S syntax) This is an educated guess made in conjunction with the message
3066 "%s found where operator expected".  Don't automatically put a semicolon on
3067 the previous line just because you saw this message.
3068
3069 =item Modification of a read-only value attempted
3070
3071 (F) You tried, directly or indirectly, to change the value of a
3072 constant.  You didn't, of course, try "2 = 1", because the compiler
3073 catches that.  But an easy way to do the same thing is:
3074
3075     sub mod { $_[0] = 1 }
3076     mod(2);
3077
3078 Another way is to assign to a substr() that's off the end of the string.
3079
3080 Yet another way is to assign to a C<foreach> loop I<VAR> when I<VAR>
3081 is aliased to a constant in the look I<LIST>:
3082
3083     $x = 1;
3084     foreach my $n ($x, 2) {
3085         $n *= 2; # modifies the $x, but fails on attempt to
3086     }            # modify the 2
3087
3088 =item Modification of non-creatable array value attempted, %s
3089
3090 (F) You tried to make an array value spring into existence, and the
3091 subscript was probably negative, even counting from end of the array
3092 backwards.
3093
3094 =item Modification of non-creatable hash value attempted, %s
3095
3096 (P) You tried to make a hash value spring into existence, and it
3097 couldn't be created for some peculiar reason.
3098
3099 =item Module name must be constant
3100
3101 (F) Only a bare module name is allowed as the first argument to a "use".
3102
3103 =item Module name required with -%c option
3104
3105 (F) The C<-M> or C<-m> options say that Perl should load some module, but
3106 you omitted the name of the module.  Consult L<perlrun> for full details
3107 about C<-M> and C<-m>.
3108
3109 =item More than one argument to '%s' open
3110
3111 (F) The C<open> function has been asked to open multiple files.  This
3112 can happen if you are trying to open a pipe to a command that takes a
3113 list of arguments, but have forgotten to specify a piped open mode.
3114 See L<perlfunc/open> for details.
3115
3116 =item mprotect for %p %u failed with %d
3117
3118 =item mprotect RW for %p %u failed with %d
3119
3120 (S) You compiled perl with B<-D>PERL_DEBUG_READONLY_OPS (see
3121 L<perlhacktips>), but an op tree could not be made read-only, or a
3122 read-only op tree could not be made mutable before freeing the ops.
3123
3124 =item msg%s not implemented
3125
3126 (F) You don't have System V message IPC on your system.
3127
3128 =item Multidimensional syntax %s not supported
3129
3130 (W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
3131 They're written like C<$foo[1][2][3]>, as in C.
3132
3133 =item '/' must follow a numeric type in unpack
3134
3135 (F) You had an unpack template that contained a '/', but this did not
3136 follow some unpack specification producing a numeric value.
3137 See L<perlfunc/pack>.
3138
3139 =item "my sub" not yet implemented
3140
3141 (F) Lexically scoped subroutines are not yet implemented.  Don't try
3142 that yet.
3143
3144 =item "my %s" used in sort comparison
3145
3146 (W syntax) The package variables $a and $b are used for sort comparisons.
3147 You used $a or $b in as an operand to the C<< <=> >> or C<cmp> operator inside a
3148 sort comparison block, and the variable had earlier been declared as a
3149 lexical variable.  Either qualify the sort variable with the package
3150 name, or rename the lexical variable.
3151
3152 =item "my" variable %s can't be in a package
3153
3154 (F) Lexically scoped variables aren't in a package, so it doesn't make
3155 sense to try to declare one with a package qualifier on the front.  Use
3156 local() if you want to localize a package variable.
3157
3158 =item Name "%s::%s" used only once: possible typo
3159
3160 (W once) Typographical errors often show up as unique variable
3161 names.  If you had a good reason for having a unique name, then
3162 just mention it again somehow to suppress the message.  The C<our>
3163 declaration is provided for this purpose.
3164
3165 NOTE: This warning detects symbols that have been used only once
3166 so $c, @c, %c, *c, &c, sub c{}, c(), and c (the filehandle or
3167 format) are considered the same; if a program uses $c only once
3168 but also uses any of the others it will not trigger this warning.
3169 Symbols beginning with an underscore and symbols using special
3170 identifiers (q.v. L<perldata>) are exempt from this warning.
3171
3172 =item Need exactly 3 octal digits in regex; marked by S<<-- HERE> in m/%s/
3173
3174 (F) Within S<C<(?[   ])>>, all constants interpreted as octal need to be
3175 exactly 3 digits long.  This helps catch some ambiguities.  If your
3176 constant is too short, add leading zeros, like
3177
3178  (?[ [ \078 ] ])     # Syntax error!
3179  (?[ [ \0078 ] ])    # Works
3180  (?[ [ \007 8 ] ])   # Clearer
3181
3182 The maximum number this construct can express is C<\777>.  If you
3183 need a larger one, you need to use L<\o{}|perlrebackslash/Octal escapes> instead.  If you meant
3184 two separate things, you need to separate them:
3185
3186  (?[ [ \7776 ] ])        # Syntax error!
3187  (?[ [ \o{7776} ] ])     # One meaning
3188  (?[ [ \777 6 ] ])       # Another meaning
3189  (?[ [ \777 \006 ] ])    # Still another
3190
3191 =item Negative '/' count in unpack
3192
3193 (F) The length count obtained from a length/code unpack operation was
3194 negative.  See L<perlfunc/pack>.
3195
3196 =item Negative length
3197
3198 (F) You tried to do a read/write/send/recv operation with a buffer
3199 length that is less than 0.  This is difficult to imagine.
3200
3201 =item Negative offset to vec in lvalue context
3202
3203 (F) When C<vec> is called in an lvalue context, the second argument must be
3204 greater than or equal to zero.
3205
3206 =item Nested quantifiers in regex; marked by S<<-- HERE> in m/%s/
3207
3208 (F) You can't quantify a quantifier without intervening parentheses.
3209 So things like ** or +* or ?* are illegal.  The S<<-- HERE> shows
3210 whereabouts in the regular expression the problem was discovered.
3211
3212 Note that the minimal matching quantifiers, C<*?>, C<+?>, and
3213 C<??> appear to be nested quantifiers, but aren't.  See L<perlre>.
3214
3215 =item %s never introduced
3216
3217 (S internal) The symbol in question was declared but somehow went out of
3218 scope before it could possibly have been used.
3219
3220 =item next::method/next::can/maybe::next::method cannot find enclosing method
3221
3222 (F) C<next::method> needs to be called within the context of a
3223 real method in a real package, and it could not find such a context.
3224 See L<mro>.
3225
3226 =item \N in a character class must be a named character: \N{...} in regex; 
3227 marked by S<<-- HERE> in m/%s/
3228
3229 (F) The new (as of Perl 5.12) meaning of C<\N> as C<[^\n]> is not valid in a
3230 bracketed character class, for the same reason that C<.> in a character
3231 class loses its specialness: it matches almost everything, which is
3232 probably not what you want.
3233
3234 =item \N{} in character class restricted to one character in regex; marked
3235 by S<<-- HERE> in m/%s/
3236
3237 (F) Named Unicode character escapes C<(\N{...})> may return a
3238 multi-character sequence.  Such an escape may not be used in
3239 a character class, because character classes always match one
3240 character of input.  Check that the correct escape has been used,
3241 and the correct charname handler is in scope.  The S<<-- HERE> shows
3242 whereabouts in the regular expression the problem was discovered.
3243
3244 =item \N{NAME} must be resolved by the lexer in regex; marked by
3245 S<<-- HERE> in m/%s/
3246
3247 (F) When compiling a regex pattern, an unresolved named character or
3248 sequence was encountered.  This can happen in any of several ways that
3249 bypass the lexer, such as using single-quotish context, or an extra
3250 backslash in double-quotish:
3251
3252     $re = '\N{SPACE}';  # Wrong!
3253     $re = "\\N{SPACE}"; # Wrong!
3254     /$re/;
3255
3256 Instead, use double-quotes with a single backslash:
3257
3258     $re = "\N{SPACE}";  # ok
3259     /$re/;
3260
3261 The lexer can be bypassed as well by creating the pattern from smaller
3262 components:
3263
3264     $re = '\N';
3265     /${re}{SPACE}/;     # Wrong!
3266
3267 It's not a good idea to split a construct in the middle like this, and
3268 it doesn't work here.  Instead use the solution above.
3269
3270 Finally, the message also can happen under the C</x> regex modifier when the
3271 C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
3272
3273     /\N {SPACE}/x;      # Wrong!
3274     /\N{SPACE}/x;       # ok
3275
3276 =item No %s allowed while running setuid
3277
3278 (F) Certain operations are deemed to be too insecure for a setuid or
3279 setgid script to even be allowed to attempt.  Generally speaking there
3280 will be another way to do what you want that is, if not secure, at least
3281 securable.  See L<perlsec>.
3282
3283 =item No code specified for -%c
3284
3285 (F) Perl's B<-e> and B<-E> command-line options require an argument.  If
3286 you want to run an empty program, pass the empty string as a separate
3287 argument or run a program consisting of a single 0 or 1:
3288
3289     perl -e ""
3290     perl -e0
3291     perl -e1
3292
3293 =item No comma allowed after %s
3294
3295 (F) A list operator that has a filehandle or "indirect object" is
3296 not allowed to have a comma between that and the following arguments.
3297 Otherwise it'd be just another one of the arguments.
3298
3299 One possible cause for this is that you expected to have imported
3300 a constant to your name space with B<use> or B<import> while no such
3301 importing took place, it may for example be that your operating
3302 system does not support that particular constant.  Hopefully you did
3303 use an explicit import list for the constants you expect to see;
3304 please see L<perlfunc/use> and L<perlfunc/import>.  While an
3305 explicit import list would probably have caught this error earlier
3306 it naturally does not remedy the fact that your operating system
3307 still does not support that constant.  Maybe you have a typo in
3308 the constants of the symbol import list of B<use> or B<import> or in the
3309 constant name at the line where this error was triggered?
3310
3311 =item No command into which to pipe on command line
3312
3313 (F) An error peculiar to VMS.  Perl handles its own command line
3314 redirection, and found a '|' at the end of the command line, so it
3315 doesn't know where you want to pipe the output from this command.
3316
3317 =item No DB::DB routine defined
3318
3319 (F) The currently executing code was compiled with the B<-d> switch, but
3320 for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
3321 module) didn't define a routine to be called at the beginning of each
3322 statement.
3323
3324 =item No dbm on this machine
3325
3326 (P) This is counted as an internal error, because every machine should
3327 supply dbm nowadays, because Perl comes with SDBM.  See L<SDBM_File>.
3328
3329 =item No DB::sub routine defined
3330
3331 (F) The currently executing code was compiled with the B<-d> switch, but
3332 for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
3333 module) didn't define a C<DB::sub> routine to be called at the beginning
3334 of each ordinary subroutine call.
3335
3336 =item No directory specified for -I
3337
3338 (F) The B<-I> command-line switch requires a directory name as part of the
3339 I<same> argument.  Use B<-Ilib>, for instance.  B<-I lib> won't work.
3340
3341 =item No error file after 2> or 2>> on command line
3342
3343 (F) An error peculiar to VMS.  Perl handles its own command line
3344 redirection, and found a '2>' or a '2>>' on the command line, but can't
3345 find the name of the file to which to write data destined for stderr.
3346
3347 =item No group ending character '%c' found in template
3348
3349 (F) A pack or unpack template has an opening '(' or '[' without its
3350 matching counterpart.  See L<perlfunc/pack>.
3351
3352 =item No input file after < on command line
3353
3354 (F) An error peculiar to VMS.  Perl handles its own command line
3355 redirection, and found a '<' on the command line, but can't find the
3356 name of the file from which to read data for stdin.
3357
3358 =item No next::method '%s' found for %s
3359
3360 (F) C<next::method> found no further instances of this method name
3361 in the remaining packages of the MRO of this class.  If you don't want
3362 it throwing an exception, use C<maybe::next::method>
3363 or C<next::can>.  See L<mro>.
3364
3365 =item Non-hex character in regex; marked by S<<-- HERE> in m/%s/
3366
3367 (F) In a regular expression, there was a non-hexadecimal character where
3368 a hex one was expected, like
3369
3370  (?[ [ \xDG ] ])
3371  (?[ [ \x{DEKA} ] ])
3372
3373 =item Non-octal character in regex; marked by S<<-- HERE> in m/%s/
3374
3375 (F) In a regular expression, there was a non-octal character where
3376 an octal one was expected, like
3377
3378  (?[ [ \o{1278} ] ])
3379
3380 =item Non-octal character '%c'.  Resolved as "%s"
3381
3382 (W digit) In parsing an octal numeric constant, a character was
3383 unexpectedly encountered that isn't octal.  The resulting value
3384 is as indicated.
3385
3386 =item "no" not allowed in expression
3387
3388 (F) The "no" keyword is recognized and executed at compile time, and
3389 returns no useful value.  See L<perlmod>.
3390
3391 =item Non-string passed as bitmask
3392
3393 (W misc) A number has been passed as a bitmask argument to select().
3394 Use the vec() function to construct the file descriptor bitmasks for
3395 select.  See L<perlfunc/select>.
3396
3397 =item No output file after > on command line
3398
3399 (F) An error peculiar to VMS.  Perl handles its own command line
3400 redirection, and found a lone '>' at the end of the command line, so it
3401 doesn't know where you wanted to redirect stdout.
3402
3403 =item No output file after > or >> on command line
3404
3405 (F) An error peculiar to VMS.  Perl handles its own command line
3406 redirection, and found a '>' or a '>>' on the command line, but can't
3407 find the name of the file to which to write data destined for stdout.
3408
3409 =item No package name allowed for variable %s in "our"
3410
3411 (F) Fully qualified variable names are not allowed in "our"
3412 declarations, because that doesn't make much sense under existing
3413 semantics.  Such syntax is reserved for future extensions.
3414
3415 =item No Perl script found in input
3416
3417 (F) You called C<perl -x>, but no line was found in the file beginning
3418 with #! and containing the word "perl".
3419
3420 =item No setregid available
3421
3422 (F) Configure didn't find anything resembling the setregid() call for
3423 your system.
3424
3425 =item No setreuid available
3426
3427 (F) Configure didn't find anything resembling the setreuid() call for
3428 your system.
3429
3430 =item No such class %s
3431
3432 (F) You provided a class qualifier in a "my", "our" or "state"
3433 declaration, but this class doesn't exist at this point in your program.
3434
3435 =item No such class field "%s" in variable %s of type %s
3436
3437 (F) You tried to access a key from a hash through the indicated typed
3438 variable but that key is not allowed by the package of the same type.
3439 The indicated package has restricted the set of allowed keys using the
3440 L<fields> pragma.
3441
3442 =item No such hook: %s
3443
3444 (F) You specified a signal hook that was not recognized by Perl.
3445 Currently, Perl accepts C<__DIE__> and C<__WARN__> as valid signal hooks.
3446
3447 =item No such pipe open
3448
3449 (P) An error peculiar to VMS.  The internal routine my_pclose() tried to
3450 close a pipe which hadn't been opened.  This should have been caught
3451 earlier as an attempt to close an unopened filehandle.
3452
3453 =item No such signal: SIG%s
3454
3455 (W signal) You specified a signal name as a subscript to %SIG that was
3456 not recognized.  Say C<kill -l> in your shell to see the valid signal
3457 names on your system.
3458
3459 =item Not a CODE reference
3460
3461 (F) Perl was trying to evaluate a reference to a code value (that is, a
3462 subroutine), but found a reference to something else instead.  You can
3463 use the ref() function to find out what kind of ref it really was.  See
3464 also L<perlref>.
3465
3466 =item Not a GLOB reference
3467
3468 (F) Perl was trying to evaluate a reference to a "typeglob" (that is, a
3469 symbol table entry that looks like C<*foo>), but found a reference to
3470 something else instead.  You can use the ref() function to find out what
3471 kind of ref it really was.  See L<perlref>.
3472
3473 =item Not a HASH reference
3474
3475 (F) Perl was trying to evaluate a reference to a hash value, but found a
3476 reference to something else instead.  You can use the ref() function to
3477 find out what kind of ref it really was.  See L<perlref>.
3478
3479 =item Not an ARRAY reference
3480
3481 (F) Perl was trying to evaluate a reference to an array value, but found
3482 a reference to something else instead.  You can use the ref() function
3483 to find out what kind of ref it really was.  See L<perlref>.
3484
3485 =item Not an unblessed ARRAY reference
3486
3487 (F) You passed a reference to a blessed array to C<push>, C<shift> or
3488 another array function.  These only accept unblessed array references
3489 or arrays beginning explicitly with C<@>.
3490
3491 =item Not a SCALAR reference
3492
3493 (F) Perl was trying to evaluate a reference to a scalar value, but found
3494 a reference to something else instead.  You can use the ref() function
3495 to find out what kind of ref it really was.  See L<perlref>.
3496
3497 =item Not a subroutine reference
3498
3499 (F) Perl was trying to evaluate a reference to a code value (that is, a
3500 subroutine), but found a reference to something else instead.  You can
3501 use the ref() function to find out what kind of ref it really was.  See
3502 also L<perlref>.
3503
3504 =item Not a subroutine reference in overload table
3505
3506 (F) An attempt was made to specify an entry in an overloading table that
3507 doesn't somehow point to a valid subroutine.  See L<overload>.
3508
3509 =item Not enough arguments for %s
3510
3511 (F) The function requires more arguments than you specified.
3512
3513 =item Not enough format arguments
3514
3515 (W syntax) A format specified more picture fields than the next line
3516 supplied.  See L<perlform>.
3517
3518 =item %s: not found
3519
3520 (A) You've accidentally run your script through the Bourne shell instead
3521 of Perl.  Check the #! line, or manually feed your script into Perl
3522 yourself.
3523
3524 =item (?[...]) not valid in locale in regex; marked by S<<-- HERE> in m/%s/
3525
3526 (F) C<(?[...])> cannot be used within the scope of a C<S<use locale>> or with
3527 an C</l> regular expression modifier, as that would require deferring
3528 to run-time the calculation of what it should evaluate to, and it is
3529 regex compile-time only.
3530
3531 =item no UTC offset information; assuming local time is UTC
3532
3533 (S) A warning peculiar to VMS.  Perl was unable to find the local
3534 timezone offset, so it's assuming that local system time is equivalent
3535 to UTC.  If it's not, define the logical name
3536 F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
3537 need to be added to UTC to get local time.
3538
3539 =item Null filename used
3540
3541 (F) You can't require the null filename, especially because on many
3542 machines that means the current directory!  See L<perlfunc/require>.
3543
3544 =item NULL OP IN RUN
3545
3546 (S debugging) Some internal routine called run() with a null opcode
3547 pointer.
3548
3549 =item Null picture in formline
3550
3551 (F) The first argument to formline must be a valid format picture
3552 specification.  It was found to be empty, which probably means you
3553 supplied it an uninitialized value.  See L<perlform>.
3554
3555 =item Null realloc
3556
3557 (P) An attempt was made to realloc NULL.
3558
3559 =item NULL regexp argument
3560
3561 (P) The internal pattern matching routines blew it big time.
3562
3563 =item NULL regexp parameter
3564
3565 (P) The internal pattern matching routines are out of their gourd.
3566
3567 =item Number too long
3568
3569 (F) Perl limits the representation of decimal numbers in programs to
3570 about 250 characters.  You've exceeded that length.  Future
3571 versions of Perl are likely to eliminate this arbitrary limitation.  In
3572 the meantime, try using scientific notation (e.g. "1e6" instead of
3573 "1_000_000").
3574
3575 =item Number with no digits
3576
3577 (F) Perl was looking for a number but found nothing that looked like
3578 a number.  This happens, for example with C<\o{}>, with no number between
3579 the braces.
3580
3581 =item Octal number > 037777777777 non-portable
3582
3583 (W portable) The octal number you specified is larger than 2**32-1
3584 (4294967295) and therefore non-portable between systems.  See
3585 L<perlport> for more on portability concerns.
3586
3587 =item Odd number of arguments for overload::constant
3588
3589 (W overload) The call to overload::constant contained an odd number of
3590 arguments.  The arguments should come in pairs.
3591
3592 =item Odd number of elements in anonymous hash
3593
3594 (W misc) You specified an odd number of elements to initialize a hash,
3595 which is odd, because hashes come in key/value pairs.
3596
3597 =item Odd number of elements in hash assignment
3598
3599 (W misc) You specified an odd number of elements to initialize a hash,
3600 which is odd, because hashes come in key/value pairs.
3601
3602 =item Offset outside string
3603
3604 (F)(W layer) You tried to do a read/write/send/recv/seek operation
3605 with an offset pointing outside the buffer.  This is difficult to
3606 imagine.  The sole exceptions to this are that zero padding will
3607 take place when going past the end of the string when either
3608 C<sysread()>ing a file, or when seeking past the end of a scalar opened
3609 for I/O (in anticipation of future reads and to imitate the behaviour
3610 with real files).
3611
3612 =item %s() on unopened %s
3613
3614 (W unopened) An I/O operation was attempted on a filehandle that was
3615 never initialized.  You need to do an open(), a sysopen(), or a socket()
3616 call, or call a constructor from the FileHandle package.
3617
3618 =item -%s on unopened filehandle %s
3619
3620 (W unopened) You tried to invoke a file test operator on a filehandle
3621 that isn't open.  Check your control flow.  See also L<perlfunc/-X>.
3622
3623 =item oops: oopsAV
3624
3625 (S internal) An internal warning that the grammar is screwed up.
3626
3627 =item oops: oopsHV
3628
3629 (S internal) An internal warning that the grammar is screwed up.
3630
3631 =item Opening dirhandle %s also as a file
3632
3633 (D io, deprecated) You used open() to associate a filehandle to
3634 a symbol (glob or scalar) that already holds a dirhandle.
3635 Although legal, this idiom might render your code confusing
3636 and is deprecated.
3637
3638 =item Opening filehandle %s also as a directory
3639
3640 (D io, deprecated) You used opendir() to associate a dirhandle to
3641 a symbol (glob or scalar) that already holds a filehandle.
3642 Although legal, this idiom might render your code confusing
3643 and is deprecated.
3644
3645 =item Operand with no preceding operator in regex; marked by S<<-- HERE> in
3646 m/%s/
3647
3648 (F) You wrote something like
3649
3650  (?[ \p{Digit} \p{Thai} ])
3651
3652 There are two operands, but no operator giving how you want to combine
3653 them.
3654
3655 =item Operation "%s": no method found, %s
3656
3657 (F) An attempt was made to perform an overloaded operation for which no
3658 handler was defined.  While some handlers can be autogenerated in terms
3659 of other handlers, there is no default handler for any operation, unless
3660 the C<fallback> overloading key is specified to be true.  See L<overload>.
3661
3662 =item Operation "%s" returns its argument for non-Unicode code point 0x%X
3663
3664 (S utf8, non_unicode) You performed an operation requiring Unicode
3665 semantics on a code point that is not in Unicode, so what it should do
3666 is not defined.  Perl has chosen to have it do nothing, and warn you.
3667
3668 If the operation shown is "ToFold", it means that case-insensitive
3669 matching in a regular expression was done on the code point.
3670
3671 If you know what you are doing you can turn off this warning by
3672 C<no warnings 'non_unicode';>.
3673
3674 =item Operation "%s" returns its argument for UTF-16 surrogate U+%X
3675
3676 (S utf8, surrogate) You performed an operation requiring Unicode
3677 semantics on a Unicode surrogate.  Unicode frowns upon the use of
3678 surrogates for anything but storing strings in UTF-16, but semantics
3679 are (reluctantly) defined for the surrogates, and they are to do
3680 nothing for this operation.  Because the use of surrogates can be
3681 dangerous, Perl warns.
3682
3683 If the operation shown is "ToFold", it means that case-insensitive
3684 matching in a regular expression was done on the code point.
3685
3686 If you know what you are doing you can turn off this warning by
3687 C<no warnings 'surrogate';>.
3688
3689 =item Operator or semicolon missing before %s
3690
3691 (S ambiguous) You used a variable or subroutine call where the parser
3692 was expecting an operator.  The parser has assumed you really meant to
3693 use an operator, but this is highly likely to be incorrect.  For
3694 example, if you say "*foo *foo" it will be interpreted as if you said
3695 "*foo * 'foo'".
3696
3697 =item "our" variable %s redeclared
3698
3699 (W misc) You seem to have already declared the same global once before
3700 in the current lexical scope.
3701
3702 =item Out of memory!
3703
3704 (X) The malloc() function returned 0, indicating there was insufficient
3705 remaining memory (or virtual memory) to satisfy the request.  Perl has
3706 no option but to exit immediately.
3707
3708 At least in Unix you may be able to get past this by increasing your
3709 process datasize limits: in csh/tcsh use C<limit> and
3710 C<limit datasize n> (where C<n> is the number of kilobytes) to check
3711 the current limits and change them, and in ksh/bash/zsh use C<ulimit -a>
3712 and C<ulimit -d n>, respectively.
3713
3714 =item Out of memory during %s extend
3715
3716 (X) An attempt was made to extend an array, a list, or a string beyond
3717 the largest possible memory allocation.
3718
3719 =item Out of memory during "large" request for %s
3720
3721 (F) The malloc() function returned 0, indicating there was insufficient
3722 remaining memory (or virtual memory) to satisfy the request.  However,
3723 the request was judged large enough (compile-time default is 64K), so a
3724 possibility to shut down by trapping this error is granted.
3725
3726 =item Out of memory during request for %s
3727
3728 (X)(F) The malloc() function returned 0, indicating there was
3729 insufficient remaining memory (or virtual memory) to satisfy the
3730 request.
3731
3732 The request was judged to be small, so the possibility to trap it
3733 depends on the way perl was compiled.  By default it is not trappable.
3734 However, if compiled for this, Perl may use the contents of C<$^M> as an
3735 emergency pool after die()ing with this message.  In this case the error
3736 is trappable I<once>, and the error message will include the line and file
3737 where the failed request happened.
3738
3739 =item Out of memory during ridiculously large request
3740
3741 (F) You can't allocate more than 2^31+"small amount" bytes.  This error
3742 is most likely to be caused by a typo in the Perl program. e.g.,
3743 C<$arr[time]> instead of C<$arr[$time]>.
3744
3745 =item Out of memory for yacc stack
3746
3747 (F) The yacc parser wanted to grow its stack so it could continue
3748 parsing, but realloc() wouldn't give it more memory, virtual or
3749 otherwise.
3750
3751 =item '.' outside of string in pack
3752
3753 (F) The argument to a '.' in your template tried to move the working
3754 position to before the start of the packed string being built.
3755
3756 =item '@' outside of string in unpack
3757
3758 (F) You had a template that specified an absolute position outside
3759 the string being unpacked.  See L<perlfunc/pack>.
3760
3761 =item '@' outside of string with malformed UTF-8 in unpack
3762
3763 (F) You had a template that specified an absolute position outside
3764 the string being unpacked.  The string being unpacked was also invalid
3765 UTF-8.  See L<perlfunc/pack>.
3766
3767 =item overload arg '%s' is invalid
3768
3769 (W overload) The L<overload> pragma was passed an argument it did not
3770 recognize.  Did you mistype an operator?
3771
3772 =item Overloaded dereference did not return a reference
3773
3774 (F) An object with an overloaded dereference operator was dereferenced,
3775 but the overloaded operation did not return a reference.  See
3776 L<overload>.
3777
3778 =item Overloaded qr did not return a REGEXP
3779
3780 (F) An object with a C<qr> overload was used as part of a match, but the
3781 overloaded operation didn't return a compiled regexp.  See L<overload>.
3782
3783 =item %s package attribute may clash with future reserved word: %s
3784
3785 (W reserved) A lowercase attribute name was used that had a
3786 package-specific handler.  That name might have a meaning to Perl itself
3787 some day, even though it doesn't yet.  Perhaps you should use a
3788 mixed-case attribute name, instead.  See L<attributes>.
3789
3790 =item pack/unpack repeat count overflow
3791
3792 (F) You can't specify a repeat count so large that it overflows your
3793 signed integers.  See L<perlfunc/pack>.
3794
3795 =item page overflow
3796
3797 (W io) A single call to write() produced more lines than can fit on a
3798 page.  See L<perlform>.
3799
3800 =item panic: %s
3801
3802 (P) An internal error.
3803
3804 =item panic: attempt to call %s in %s
3805
3806 (P) One of the file test operators entered a code branch that calls
3807 an ACL related-function, but that function is not available on this
3808 platform.  Earlier checks mean that it should not be possible to
3809 enter this branch on this platform.
3810
3811 =item panic: child pseudo-process was never scheduled
3812
3813 (P) A child pseudo-process in the ithreads implementation on Windows
3814 was not scheduled within the time period allowed and therefore was not
3815 able to initialize properly.
3816
3817 =item panic: ck_grep, type=%u
3818
3819 (P) Failed an internal consistency check trying to compile a grep.
3820
3821 =item panic: ck_split, type=%u
3822
3823 (P) Failed an internal consistency check trying to compile a split.
3824
3825 =item panic: corrupt saved stack index %ld
3826
3827 (P) The savestack was requested to restore more localized values than
3828 there are in the savestack.
3829
3830 =item panic: del_backref
3831
3832 (P) Failed an internal consistency check while trying to reset a weak
3833 reference.
3834
3835 =item panic: die %s
3836
3837 (P) We popped the context stack to an eval context, and then discovered
3838 it wasn't an eval context.
3839
3840 =item panic: do_subst
3841
3842 (P) The internal pp_subst() routine was called with invalid operational
3843 data.
3844
3845 =item panic: do_trans_%s
3846
3847 (P) The internal do_trans routines were called with invalid operational
3848 data.
3849
3850 =item panic: fold_constants JMPENV_PUSH returned %d
3851
3852 (P) While attempting folding constants an exception other than an C<eval>
3853 failure was caught.
3854
3855 =item panic: frexp
3856
3857 (P) The library function frexp() failed, making printf("%f") impossible.
3858
3859 =item panic: goto, type=%u, ix=%ld
3860
3861 (P) We popped the context stack to a context with the specified label,
3862 and then discovered it wasn't a context we know how to do a goto in.
3863
3864 =item panic: gp_free failed to free glob pointer
3865
3866 (P) The internal routine used to clear a typeglob's entries tried
3867 repeatedly, but each time something re-created entries in the glob.
3868 Most likely the glob contains an object with a reference back to
3869 the glob and a destructor that adds a new object to the glob.
3870
3871 =item panic: INTERPCASEMOD, %s
3872
3873 (P) The lexer got into a bad state at a case modifier.
3874
3875 =item panic: INTERPCONCAT, %s
3876
3877 (P) The lexer got into a bad state parsing a string with brackets.
3878
3879 =item panic: kid popen errno read
3880
3881 (F) A forked child returned an incomprehensible message about its errno.
3882
3883 =item panic: last, type=%u
3884
3885 (P) We popped the context stack to a block context, and then discovered
3886 it wasn't a block context.
3887
3888 =item panic: leave_scope clearsv
3889
3890 (P) A writable lexical variable became read-only somehow within the
3891 scope.
3892
3893 =item panic: leave_scope inconsistency %u
3894
3895 (P) The savestack probably got out of sync.  At least, there was an
3896 invalid enum on the top of it.
3897
3898 =item panic: magic_killbackrefs
3899
3900 (P) Failed an internal consistency check while trying to reset all weak
3901 references to an object.
3902
3903 =item panic: malloc, %s
3904
3905 (P) Something requested a negative number of bytes of malloc.
3906
3907 =item panic: memory wrap
3908
3909 (P) Something tried to allocate either more memory than possible or a
3910 negative amount.
3911
3912 =item panic: pad_alloc, %p!=%p
3913
3914 (P) The compiler got confused about which scratch pad it was allocating
3915 and freeing temporaries and lexicals from.
3916
3917 =item panic: pad_free curpad, %p!=%p
3918
3919 (P) The compiler got confused about which scratch pad it was allocating
3920 and freeing temporaries and lexicals from.
3921
3922 =item panic: pad_free po
3923
3924 (P) An invalid scratch pad offset was detected internally.
3925
3926 =item panic: pad_reset curpad, %p!=%p
3927
3928 (P) The compiler got confused about which scratch pad it was allocating
3929 and freeing temporaries and lexicals from.
3930
3931 =item panic: pad_sv po
3932
3933 (P) An invalid scratch pad offset was detected internally.
3934
3935 =item panic: pad_swipe curpad, %p!=%p
3936
3937 (P) The compiler got confused about which scratch pad it was allocating
3938 and freeing temporaries and lexicals from.
3939
3940 =item panic: pad_swipe po
3941
3942 (P) An invalid scratch pad offset was detected internally.
3943
3944 =item panic: pp_iter, type=%u
3945
3946 (P) The foreach iterator got called in a non-loop context frame.
3947
3948 =item panic: pp_match%s
3949
3950 (P) The internal pp_match() routine was called with invalid operational
3951 data.
3952
3953 =item panic: pp_split, pm=%p, s=%p
3954
3955 (P) Something terrible went wrong in setting up for the split.
3956
3957 =item panic: realloc, %s
3958
3959 (P) Something requested a negative number of bytes of realloc.
3960
3961 =item panic: reference miscount on nsv in sv_replace() (%d != 1)
3962
3963 (P) The internal sv_replace() function was handed a new SV with a
3964 reference count other than 1.
3965
3966 =item panic: restartop in %s
3967
3968 (P) Some internal routine requested a goto (or something like it), and
3969 didn't supply the destination.
3970
3971 =item panic: return, type=%u
3972
3973 (P) We popped the context stack to a subroutine or eval context, and
3974 then discovered it wasn't a subroutine or eval context.
3975
3976 =item panic: scan_num, %s
3977
3978 (P) scan_num() got called on something that wasn't a number.
3979
3980 =item panic: Sequence (?{...}): no code block found in regex m/%s/
3981
3982 (P) While compiling a pattern that has embedded (?{}) or (??{}) code
3983 blocks, perl couldn't locate the code block that should have already been
3984 seen and compiled by perl before control passed to the regex compiler.
3985
3986 =item panic: strxfrm() gets absurd - a => %u, ab => %u
3987
3988 (P) The interpreter's sanity check of the C function strxfrm() failed.
3989 In your current locale the returned transformation of the string "ab"
3990 is shorter than that of the string "a", which makes no sense.
3991
3992 =item panic: sv_chop %s
3993
3994 (P) The sv_chop() routine was passed a position that is not within the
3995 scalar's string buffer.
3996
3997 =item panic: sv_insert, midend=%p, bigend=%p
3998
3999 (P) The sv_insert() routine was told to remove more string than there
4000 was string.
4001
4002 =item panic: top_env
4003
4004 (P) The compiler attempted to do a goto, or something weird like that.
4005
4006 =item panic: unimplemented op %s (#%d) called
4007
4008 (P) The compiler is screwed up and attempted to use an op that isn't
4009 permitted at run time.
4010
4011 =item panic: utf16_to_utf8: odd bytelen
4012
4013 (P) Something tried to call utf16_to_utf8 with an odd (as opposed
4014 to even) byte length.
4015
4016 =item panic: utf16_to_utf8_reversed: odd bytelen
4017
4018 (P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed
4019 to even) byte length.
4020
4021 =item panic: yylex, %s
4022
4023 (P) The lexer got into a bad state while processing a case modifier.
4024
4025 =item Parentheses missing around "%s" list
4026
4027 (W parenthesis) You said something like
4028
4029     my $foo, $bar = @_;
4030
4031 when you meant
4032
4033     my ($foo, $bar) = @_;
4034
4035 Remember that "my", "our", "local" and "state" bind tighter than comma.
4036
4037 =item Parsing code internal error (%s)
4038
4039 (F) Parsing code supplied by an extension violated the parser's API in
4040 a detectable way.
4041
4042 =item Passing malformed UTF-8 to "%s" is deprecated
4043
4044 (D deprecated, utf8) This message indicates a bug either in the Perl
4045 core or in XS code.  Such code was trying to find out if a character,
4046 allegedly stored internally encoded as UTF-8, was of a given type, such
4047 as being punctuation or a digit.  But the character was not encoded in
4048 legal UTF-8.  The C<%s> is replaced by a string that can be used by
4049 knowledgeable people to determine what the type being checked against
4050 was.  If C<utf8> warnings are enabled, a further message is raised,
4051 giving details of the malformation.
4052
4053 =item Pattern subroutine nesting without pos change exceeded limit in regex
4054
4055 (F) You used a pattern that uses too many nested subpattern calls without
4056 consuming any text.  Restructure the pattern so text is consumed before
4057 the nesting limit is exceeded.
4058
4059 =item C<-p> destination: %s
4060
4061 (F) An error occurred during the implicit output invoked by the C<-p>
4062 command-line switch.  (This output goes to STDOUT unless you've
4063 redirected it with select().)
4064
4065 =item (perhaps you forgot to load "%s"?)
4066
4067 (F) This is an educated guess made in conjunction with the message
4068 "Can't locate object method \"%s\" via package \"%s\"".  It often means
4069 that a method requires a package that has not been loaded.
4070
4071 =item Perl folding rules are not up-to-date for 0x%X; please use the perlbug 
4072 utility to report; in regex; marked by S<<-- HERE> in m/%s/
4073
4074 (S regexp) You used a regular expression with case-insensitive matching,
4075 and there is a bug in Perl in which the built-in regular expression
4076 folding rules are not accurate.  This may lead to incorrect results.
4077 Please report this as a bug using the L<perlbug> utility.
4078
4079 =item Perl_my_%s() not available
4080
4081 (F) Your platform has very uncommon byte-order and integer size,
4082 so it was not possible to set up some or all fixed-width byte-order
4083 conversion functions.  This is only a problem when you're using the
4084 '<' or '>' modifiers in (un)pack templates.  See L<perlfunc/pack>.
4085
4086 =item Perl %s required (did you mean %s?)--this is only %s, stopped
4087
4088 (F) The code you are trying to run has asked for a newer version of
4089 Perl than you are running.  Perhaps C<use 5.10> was written instead
4090 of C<use 5.010> or C<use v5.10>.  Without the leading C<v>, the number is
4091 interpreted as a decimal, with every three digits after the
4092 decimal point representing a part of the version number.  So 5.10
4093 is equivalent to v5.100.
4094
4095 =item Perl %s required--this is only %s, stopped
4096
4097 (F) The module in question uses features of a version of Perl more
4098 recent than the currently running version.  How long has it been since
4099 you upgraded, anyway?  See L<perlfunc/require>.
4100
4101 =item PERL_SH_DIR too long
4102
4103 (F) An error peculiar to OS/2.  PERL_SH_DIR is the directory to find the
4104 C<sh>-shell in.  See "PERL_SH_DIR" in L<perlos2>.
4105
4106 =item PERL_SIGNALS illegal: "%s"
4107
4108 (X) See L<perlrun/PERL_SIGNALS> for legal values.
4109
4110 =item Perls since %s too modern--this is %s, stopped
4111
4112 (F) The code you are trying to run claims it will not run
4113 on the version of Perl you are using because it is too new.
4114 Maybe the code needs to be updated, or maybe it is simply
4115 wrong and the version check should just be removed.
4116
4117 =item perl: warning: Non hex character in '$ENV{PERL_HASH_SEED}', seed only partially set
4118
4119 (S) PERL_HASH_SEED should match /^\s*(?:0x)?[0-9a-fA-F]+\s*\z/ but it
4120 contained a non hex character.  This could mean you are not using the
4121 hash seed you think you are.
4122
4123 =item perl: warning: Setting locale failed.
4124
4125 (S) The whole warning message will look something like:
4126
4127         perl: warning: Setting locale failed.
4128         perl: warning: Please check that your locale settings:
4129                 LC_ALL = "En_US",
4130                 LANG = (unset)
4131             are supported and installed on your system.
4132         perl: warning: Falling back to the standard locale ("C").
4133
4134 Exactly what were the failed locale settings varies.  In the above the
4135 settings were that the LC_ALL was "En_US" and the LANG had no value.
4136 This error means that Perl detected that you and/or your operating
4137 system supplier and/or system administrator have set up the so-called
4138 locale system but Perl could not use those settings.  This was not
4139 dead serious, fortunately: there is a "default locale" called "C" that
4140 Perl can and will use, and the script will be run.  Before you really
4141 fix the problem, however, you will get the same error message each
4142 time you run Perl.  How to really fix the problem can be found in
4143 L<perllocale> section B<LOCALE PROBLEMS>.
4144
4145 =item perl: warning: strange setting in '$ENV{PERL_PERTURB_KEYS}': '%s'
4146
4147 (S) Perl was run with the environment variable PERL_PERTURB_KEYS defined
4148 but containing an unexpected value.  The legal values of this setting
4149 are as follows.
4150
4151   Numeric | String        | Result
4152   --------+---------------+-----------------------------------------
4153   0       | NO            | Disables key traversal randomization
4154   1       | RANDOM        | Enables full key traversal randomization
4155   2       | DETERMINISTIC | Enables repeatable key traversal
4156           |               | randomization
4157
4158 Both numeric and string values are accepted, but note that string values are
4159 case sensitive.  The default for this setting is "RANDOM" or 1.
4160
4161 =item pid %x not a child
4162
4163 (W exec) A warning peculiar to VMS.  Waitpid() was asked to wait for a
4164 process which isn't a subprocess of the current process.  While this is
4165 fine from VMS' perspective, it's probably not what you intended.
4166
4167 =item 'P' must have an explicit size in unpack
4168
4169 (F) The unpack format P must have an explicit size, not "*".
4170
4171 =item POSIX class [:%s:] unknown in regex; marked by S<<-- HERE> in m/%s/
4172
4173 (F) The class in the character class [: :] syntax is unknown.  The S<<-- HERE>
4174 shows whereabouts in the regular expression the problem was discovered.
4175 Note that the POSIX character classes do B<not> have the C<is> prefix
4176 the corresponding C interfaces have: in other words, it's C<[[:print:]]>,
4177 not C<isprint>.  See L<perlre>.
4178
4179 =item POSIX getpgrp can't take an argument
4180
4181 (F) Your system has POSIX getpgrp(), which takes no argument, unlike
4182 the BSD version, which takes a pid.
4183
4184 =item POSIX syntax [%c %c] belongs inside character classes in regex; marked by 
4185 S<<-- HERE> in m/%s/
4186
4187 (W regexp) The character class constructs [: :], [= =], and [. .]  go
4188 I<inside> character classes, the [] are part of the construct, for example:
4189 /[012[:alpha:]345]/.  Note that [= =] and [. .] are not currently
4190 implemented; they are simply placeholders for future extensions and
4191 will cause fatal errors.  The S<<-- HERE> shows whereabouts in the regular
4192 expression the problem was discovered.  See L<perlre>.
4193
4194 =item POSIX syntax [. .] is reserved for future extensions in regex; marked by 
4195 S<<-- HERE> in m/%s/
4196
4197 (F) Within regular expression character classes ([]) the syntax beginning
4198 with "[." and ending with ".]" is reserved for future extensions.  If you
4199 need to represent those character sequences inside a regular expression
4200 character class, just quote the square brackets with the backslash: "\[."
4201 and ".\]".  The S<<-- HERE> shows whereabouts in the regular expression the
4202 problem was discovered.  See L<perlre>.
4203
4204 =item POSIX syntax [= =] is reserved for future extensions in regex; marked by 
4205 S<<-- HERE> in m/%s/
4206
4207 (F) Within regular expression character classes ([]) the syntax beginning
4208 with "[=" and ending with "=]" is reserved for future extensions.  If you
4209 need to represent those character sequences inside a regular expression
4210 character class, just quote the square brackets with the backslash: "\[="
4211 and "=\]".  The S<<-- HERE> shows whereabouts in the regular expression the
4212 problem was discovered.  See L<perlre>.
4213
4214 =item Possible attempt to put comments in qw() list
4215
4216 (W qw) qw() lists contain items separated by whitespace; as with literal
4217 strings, comment characters are not ignored, but are instead treated as
4218 literal data.  (You may have used different delimiters than the
4219 parentheses shown here; braces are also frequently used.)
4220
4221 You probably wrote something like this:
4222
4223     @list = qw(
4224         a # a comment
4225         b # another comment
4226     );
4227
4228 when you should have written this:
4229
4230     @list = qw(
4231         a
4232         b
4233     );
4234
4235 If you really want comments, build your list the
4236 old-fashioned way, with quotes and commas:
4237
4238     @list = (
4239         'a',    # a comment
4240         'b',    # another comment
4241     );
4242
4243 =item Possible attempt to separate words with commas
4244
4245 (W qw) qw() lists contain items separated by whitespace; therefore
4246 commas aren't needed to separate the items.  (You may have used
4247 different delimiters than the parentheses shown here; braces are also
4248 frequently used.)
4249
4250 You probably wrote something like this:
4251
4252     qw! a, b, c !;
4253
4254 which puts literal commas into some of the list items.  Write it without
4255 commas if you don't want them to appear in your data:
4256
4257     qw! a b c !;
4258
4259 =item Possible memory corruption: %s overflowed 3rd argument
4260
4261 (F) An ioctl() or fcntl() returned more than Perl was bargaining for.
4262 Perl guesses a reasonable buffer size, but puts a sentinel byte at the
4263 end of the buffer just in case.  This sentinel byte got clobbered, and
4264 Perl assumes that memory is now corrupted.  See L<perlfunc/ioctl>.
4265
4266 =item Possible precedence issue with control flow operator
4267
4268 (W syntax) There is a possible problem with the mixing of a control
4269 flow operator (e.g. C<return>) and a low-precedence operator like
4270 C<or>.  Consider:
4271
4272     sub { return $a or $b; }
4273
4274 This is parsed as:
4275
4276     sub { (return $a) or $b; }
4277
4278 Which is effectively just:
4279
4280     sub { return $a; }
4281
4282 Either use parentheses or the high-precedence variant of the operator.
4283
4284 Note this may be also triggered for constructs like:
4285
4286     sub { 1 if die; }
4287
4288 =item Possible precedence problem on bitwise %c operator
4289
4290 (W precedence) Your program uses a bitwise logical operator in conjunction
4291 with a numeric comparison operator, like this :
4292
4293     if ($x & $y == 0) { ... }
4294
4295 This expression is actually equivalent to C<$x & ($y == 0)>, due to the
4296 higher precedence of C<==>.  This is probably not what you want.  (If you
4297 really meant to write this, disable the warning, or, better, put the
4298 parentheses explicitly and write C<$x & ($y == 0)>).
4299
4300 =item Possible unintended interpolation of $\ in regex
4301
4302 (W ambiguous) You said something like C<m/$\/> in a regex.
4303 The regex C<m/foo$\s+bar/m> translates to: match the word 'foo', the output
4304 record separator (see L<perlvar/$\>) and the letter 's' (one time or more)
4305 followed by the word 'bar'.
4306
4307 If this is what you intended then you can silence the warning by using 
4308 C<m/${\}/> (for example: C<m/foo${\}s+bar/>).
4309
4310 If instead you intended to match the word 'foo' at the end of the line
4311 followed by whitespace and the word 'bar' on the next line then you can use
4312 C<m/$(?)\/> (for example: C<m/foo$(?)\s+bar/>).
4313
4314 =item Possible unintended interpolation of %s in string
4315
4316 (W ambiguous) You said something like '@foo' in a double-quoted string
4317 but there was no array C<@foo> in scope at the time.  If you wanted a
4318 literal @foo, then write it as \@foo; otherwise find out what happened
4319 to the array you apparently lost track of.
4320
4321 =item Postfix dereference is experimental
4322
4323 (S experimental::postderef) This warning is emitted if you use
4324 the experimental postfix dereference syntax.  Simply suppress the
4325 warning if you want to use the feature, but know that in doing
4326 so you are taking the risk of using an experimental feature which
4327 may change or be removed in a future Perl version:
4328
4329     no warnings "experimental::postderef";
4330     use feature "postderef", "postderef_qq";
4331     $ref->$*;
4332     $aref->@*;
4333     $aref->@[@indices];
4334     ... etc ...
4335
4336 =item Precedence problem: open %s should be open(%s)
4337
4338 (S precedence) The old irregular construct
4339
4340     open FOO || die;
4341
4342 is now misinterpreted as
4343
4344     open(FOO || die);
4345
4346 because of the strict regularization of Perl 5's grammar into unary and
4347 list operators.  (The old open was a little of both.)  You must put
4348 parentheses around the filehandle, or use the new "or" operator instead
4349 of "||".
4350
4351 =item Premature end of script headers
4352
4353 See Server error.
4354
4355 =item printf() on closed filehandle %s
4356
4357 (W closed) The filehandle you're writing to got itself closed sometime
4358 before now.  Check your control flow.
4359
4360 =item print() on closed filehandle %s
4361
4362 (W closed) The filehandle you're printing on got itself closed sometime
4363 before now.  Check your control flow.
4364
4365 =item Process terminated by SIG%s
4366
4367 (W) This is a standard message issued by OS/2 applications, while *nix
4368 applications die in silence.  It is considered a feature of the OS/2
4369 port.  One can easily disable this by appropriate sighandlers, see
4370 L<perlipc/"Signals">.  See also "Process terminated by SIGTERM/SIGINT"
4371 in L<perlos2>.
4372
4373 =item Property '%s' is unknown in regex; marked by S<<-- HERE> in m/%s/
4374
4375 (F) The named property which you specified via C<\p> or C<\P> is not one
4376 known to Perl.  Perhaps you misspelled the name?  See
4377 L<perluniprops/Properties accessible through \p{} and \P{}>
4378 for a complete list of available official
4379 properties.  If it is a L<user-defined property|perlunicode/User-Defined Character Properties>
4380 it must have been defined by the time the regular expression is
4381 compiled.
4382
4383 =item Prototype after '%c' for %s : %s
4384
4385 (W illegalproto) A character follows % or @ in a prototype.  This is
4386 useless, since % and @ gobble the rest of the subroutine arguments.
4387
4388 =item Prototype mismatch: %s vs %s
4389
4390 (S prototype) The subroutine being declared or defined had previously been
4391 declared or defined with a different function prototype.
4392
4393 =item Prototype not terminated
4394
4395 (F) You've omitted the closing parenthesis in a function prototype
4396 definition.
4397
4398 =item Prototype '%s' overridden by attribute 'prototype(%s)' in %s
4399
4400 (W prototype) A prototype was declared in both the parentheses after
4401 the sub name and via the prototype attribute.  The prototype in
4402 parentheses is useless, since it will be replaced by the prototype
4403 from the attribute before it's ever used.
4404
4405 =item \p{} uses Unicode rules, not locale rules
4406
4407 (W) You compiled a regular expression that contained a Unicode property
4408 match (C<\p> or C<\P>), but the regular expression is also being told to
4409 use the run-time locale, not Unicode.  Instead, use a POSIX character
4410 class, which should know about the locale's rules.
4411 (See L<perlrecharclass/POSIX Character Classes>.)
4412
4413 Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of
4414 Unicode, some properties will give results that are not valid for that
4415 subset.
4416
4417 Here are a couple of examples to help you see what's going on.  If the
4418 locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK
4419 CAPITAL LETTER CHI".  But in Unicode that code point means the
4420 "MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode
4421 meaning.  That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]>
4422 should.  Only in the Latin1 locale are all the characters in the same
4423 positions as they are in Unicode.  But, even here, some properties give
4424 incorrect results.  An example is C<\p{Changes_When_Uppercased}> which
4425 is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper
4426 case of that character is not in Latin1, in that locale it doesn't
4427 change when upper cased.
4428
4429 =item Quantifier follows nothing in regex; marked by S<<-- HERE> in m/%s/
4430
4431 (F) You started a regular expression with a quantifier.  Backslash it if
4432 you meant it literally.  The S<<-- HERE> shows whereabouts in the regular
4433 expression the problem was discovered.  See L<perlre>.
4434
4435 =item Quantifier in {,} bigger than %d in regex; marked by S<<-- HERE> in
4436 m/%s/
4437
4438 (F) There is currently a limit to the size of the min and max values of
4439 the {min,max} construct.  The S<<-- HERE> shows whereabouts in the regular
4440 expression the problem was discovered.  See L<perlre>.
4441
4442 =item Quantifier {n,m} with n > m can't match in regex
4443
4444 =item Quantifier {n,m} with n > m can't match in regex; marked by
4445 S<<-- HERE> in m/%s/
4446
4447 (W regexp) Minima should be less than or equal to maxima.  If you really
4448 want your regexp to match something 0 times, just put {0}.
4449
4450 =item Quantifier unexpected on zero-length expression in regex; marked by <-- 
4451 HERE in m/%s/
4452
4453 (W regexp) You applied a regular expression quantifier in a place where
4454 it makes no sense, such as on a zero-width assertion.  Try putting the
4455 quantifier inside the assertion instead.  For example, the way to match
4456 "abc" provided that it is followed by three repetitions of "xyz" is
4457 C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
4458
4459 The <-- HERE shows whereabouts in the regular expression the problem was
4460 discovered.
4461
4462 =item Range iterator outside integer range
4463
4464 (F) One (or both) of the numeric arguments to the range operator ".."
4465 are outside the range which can be represented by integers internally.
4466 One possible workaround is to force Perl to use magical string increment
4467 by prepending "0" to your numbers.
4468
4469 =item readdir() attempted on invalid dirhandle %s
4470
4471 (W io) The dirhandle you're reading from is either closed or not really
4472 a dirhandle.  Check your control flow.
4473
4474 =item readline() on closed filehandle %s
4475
4476 (W closed) The filehandle you're reading from got itself closed sometime
4477 before now.  Check your control flow.
4478
4479 =item read() on closed filehandle %s
4480
4481 (W closed) You tried to read from a closed filehandle.
4482
4483 =item read() on unopened filehandle %s
4484
4485 (W unopened) You tried to read from a filehandle that was never opened.
4486
4487 =item Reallocation too large: %x
4488
4489 (F) You can't allocate more than 64K on an MS-DOS machine.
4490
4491 =item realloc() of freed memory ignored
4492
4493 (S malloc) An internal routine called realloc() on something that had
4494 already been freed.
4495
4496 =item Recompile perl with B<-D>DEBUGGING to use B<-D> switch
4497
4498 (S debugging) You can't use the B<-D> option unless the code to produce
4499 the desired output is compiled into Perl, which entails some overhead,
4500 which is why it's currently left out of your copy.
4501
4502 =item Recursive call to Perl_load_module in PerlIO_find_layer
4503
4504 (P) It is currently not permitted to load modules when creating
4505 a filehandle inside an %INC hook.  This can happen with C<open my
4506 $fh, '<', \$scalar>, which implicitly loads PerlIO::scalar.  Try
4507 loading PerlIO::scalar explicitly first.
4508
4509 =item Recursive inheritance detected in package '%s'
4510
4511 (F) While calculating the method resolution order (MRO) of a package, Perl
4512 believes it found an infinite loop in the C<@ISA> hierarchy.  This is a
4513 crude check that bails out after 100 levels of C<@ISA> depth.
4514
4515 =item refcnt_dec: fd %d%s
4516
4517 =item refcnt: fd %d%s
4518
4519 =item refcnt_inc: fd %d%s
4520
4521 (P) Perl's I/O implementation failed an internal consistency check.  If
4522 you see this message, something is very wrong.
4523
4524 =item Reference found where even-sized list expected
4525
4526 (W misc) You gave a single reference where Perl was expecting a list
4527 with an even number of elements (for assignment to a hash).  This
4528 usually means that you used the anon hash constructor when you meant
4529 to use parens.  In any case, a hash requires key/value B<pairs>.
4530
4531     %hash = { one => 1, two => 2, };    # WRONG
4532     %hash = [ qw/ an anon array / ];    # WRONG
4533     %hash = ( one => 1, two => 2, );    # right
4534     %hash = qw( one 1 two 2 );                  # also fine
4535
4536 =item Reference is already weak
4537
4538 (W misc) You have attempted to weaken a reference that is already weak.
4539 Doing so has no effect.
4540
4541 =item Reference to invalid group 0 in regex; marked by S<<-- HERE> in m/%s/
4542
4543 (F) You used C<\g0> or similar in a regular expression.  You may refer
4544 to capturing parentheses only with strictly positive integers
4545 (normal backreferences) or with strictly negative integers (relative
4546 backreferences).  Using 0 does not make sense.
4547
4548 =item Reference to nonexistent group in regex; marked by S<<-- HERE> in
4549 m/%s/
4550
4551 (F) You used something like C<\7> in your regular expression, but there are
4552 not at least seven sets of capturing parentheses in the expression.  If
4553 you wanted to have the character with ordinal 7 inserted into the regular
4554 expression, prepend zeroes to make it three digits long: C<\007>
4555
4556 The <-- HERE shows whereabouts in the regular expression the problem was
4557 discovered.
4558
4559 =item Reference to nonexistent named group in regex; marked by S<<-- HERE>
4560 in m/%s/
4561
4562 (F) You used something like C<\k'NAME'> or C<< \k<NAME> >> in your regular
4563 expression, but there is no corresponding named capturing parentheses
4564 such as C<(?'NAME'...)> or C<< (?<NAME>...) >>.  Check if the name has been
4565 spelled correctly both in the backreference and the declaration.
4566
4567 The <-- HERE shows whereabouts in the regular expression the problem was
4568 discovered.
4569
4570 =item Reference to nonexistent or unclosed group in regex; marked by
4571 S<<-- HERE> in m/%s/
4572
4573 (F) You used something like C<\g{-7}> in your regular expression, but there
4574 are not at least seven sets of closed capturing parentheses in the
4575 expression before where the C<\g{-7}> was located.
4576
4577 The <-- HERE shows whereabouts in the regular expression the problem was
4578 discovered.
4579
4580 =item regexp memory corruption
4581
4582 (P) The regular expression engine got confused by what the regular
4583 expression compiler gave it.
4584
4585 =item Regexp modifier "/%c" may appear a maximum of twice
4586
4587 =item Regexp modifier "%c" may appear a maximum of twice in regex; marked
4588 by S<<-- HERE> in m/%s/
4589
4590 (F) The regular expression pattern had too many occurrences
4591 of the specified modifier.  Remove the extraneous ones.
4592
4593 =item Regexp modifier "%c" may not appear after the "-" in regex; marked by <-- 
4594 HERE in m/%s/
4595
4596 (F) Turning off the given modifier has the side effect of turning on
4597 another one.  Perl currently doesn't allow this.  Reword the regular
4598 expression to use the modifier you want to turn on (and place it before
4599 the minus), instead of the one you want to turn off.
4600
4601 =item Regexp modifier "/%c" may not appear twice
4602
4603 =item Regexp modifier "%c" may not appear twice in regex; marked by <--
4604 HERE in m/%s/
4605
4606 (F) The regular expression pattern had too many occurrences
4607 of the specified modifier.  Remove the extraneous ones.
4608
4609 =item Regexp modifiers "/%c" and "/%c" are mutually exclusive
4610
4611 =item Regexp modifiers "%c" and "%c" are mutually exclusive in regex;
4612 marked by S<<-- HERE> in m/%s/
4613
4614 (F) The regular expression pattern had more than one of these
4615 mutually exclusive modifiers.  Retain only the modifier that is
4616 supposed to be there.
4617
4618 =item Regexp out of space in regex m/%s/
4619
4620 (P) A "can't happen" error, because safemalloc() should have caught it
4621 earlier.
4622
4623 =item Repeated format line will never terminate (~~ and @#)
4624
4625 (F) Your format contains the ~~ repeat-until-blank sequence and a
4626 numeric field that will never go blank so that the repetition never
4627 terminates.  You might use ^# instead.  See L<perlform>.
4628
4629 =item Replacement list is longer than search list
4630
4631 (W misc) You have used a replacement list that is longer than the
4632 search list.  So the additional elements in the replacement list
4633 are meaningless.
4634
4635 =item '%s' resolved to '\o{%s}%d'
4636
4637 (W misc, regexp)  You wrote something like C<\08>, or C<\179> in a
4638 double-quotish string.  All but the last digit is treated as a single
4639 character, specified in octal.  The last digit is the next character in
4640 the string.  To tell Perl that this is indeed what you want, you can use
4641 the C<\o{ }> syntax, or use exactly three digits to specify the octal
4642 for the character.
4643
4644 =item Reversed %s= operator
4645
4646 (W syntax) You wrote your assignment operator backwards.  The = must
4647 always come last, to avoid ambiguity with subsequent unary operators.
4648
4649 =item rewinddir() attempted on invalid dirhandle %s
4650
4651 (W io) The dirhandle you tried to do a rewinddir() on is either closed or not
4652 really a dirhandle.  Check your control flow.
4653
4654 =item Scalars leaked: %d
4655
4656 (S internal) Something went wrong in Perl's internal bookkeeping
4657 of scalars: not all scalar variables were deallocated by the time
4658 Perl exited.  What this usually indicates is a memory leak, which
4659 is of course bad, especially if the Perl program is intended to be
4660 long-running.
4661
4662 =item Scalar value @%s[%s] better written as $%s[%s]
4663
4664 (W syntax) You've used an array slice (indicated by @) to select a
4665 single element of an array.  Generally it's better to ask for a scalar
4666 value (indicated by $).  The difference is that C<$foo[&bar]> always
4667 behaves like a scalar, both when assigning to it and when evaluating its
4668 argument, while C<@foo[&bar]> behaves like a list when you assign to it,
4669 and provides a list context to its subscript, which can do weird things
4670 if you're expecting only one subscript.
4671
4672 On the other hand, if you were actually hoping to treat the array
4673 element as a list, you need to look into how references work, because
4674 Perl will not magically convert between scalars and lists for you.  See
4675 L<perlref>.
4676
4677 =item Scalar value @%s{%s} better written as $%s{%s}
4678
4679 (W syntax) You've used a hash slice (indicated by @) to select a single
4680 element of a hash.  Generally it's better to ask for a scalar value
4681 (indicated by $).  The difference is that C<$foo{&bar}> always behaves
4682 like a scalar, both when assigning to it and when evaluating its
4683 argument, while C<@foo{&bar}> behaves like a list when you assign to it,
4684 and provides a list context to its subscript, which can do weird things
4685 if you're expecting only one subscript.
4686
4687 On the other hand, if you were actually hoping to treat the hash element
4688 as a list, you need to look into how references work, because Perl will
4689 not magically convert between scalars and lists for you.  See
4690 L<perlref>.
4691
4692 =item Search pattern not terminated
4693
4694 (F) The lexer couldn't find the final delimiter of a // or m{}
4695 construct.  Remember that bracketing delimiters count nesting level.
4696 Missing the leading C<$> from a variable C<$m> may cause this error.
4697
4698 Note that since Perl 5.9.0 a // can also be the I<defined-or>
4699 construct, not just the empty search pattern.  Therefore code written
4700 in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
4701 misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
4702
4703 =item Search pattern not terminated or ternary operator parsed as search pattern
4704
4705 (F) The lexer couldn't find the final delimiter of a C<?PATTERN?>
4706 construct.
4707
4708 The question mark is also used as part of the ternary operator (as in
4709 C<foo ? 0 : 1>) leading to some ambiguous constructions being wrongly
4710 parsed.  One way to disambiguate the parsing is to put parentheses around
4711 the conditional expression, i.e. C<(foo) ? 0 : 1>.
4712
4713 =item seekdir() attempted on invalid dirhandle %s
4714
4715 (W io) The dirhandle you are doing a seekdir() on is either closed or not
4716 really a dirhandle.  Check your control flow.
4717
4718 =item %sseek() on unopened filehandle
4719
4720 (W unopened) You tried to use the seek() or sysseek() function on a
4721 filehandle that was either never opened or has since been closed.
4722
4723 =item select not implemented
4724
4725 (F) This machine doesn't implement the select() system call.
4726
4727 =item Self-ties of arrays and hashes are not supported
4728
4729 (F) Self-ties are of arrays and hashes are not supported in
4730 the current implementation.
4731
4732 =item Semicolon seems to be missing
4733
4734 (W semicolon) A nearby syntax error was probably caused by a missing
4735 semicolon, or possibly some other missing operator, such as a comma.
4736
4737 =item semi-panic: attempt to dup freed string
4738
4739 (S internal) The internal newSVsv() routine was called to duplicate a
4740 scalar that had previously been marked as free.
4741
4742 =item sem%s not implemented
4743
4744 (F) You don't have System V semaphore IPC on your system.
4745
4746 =item send() on closed socket %s
4747
4748 (W closed) The socket you're sending to got itself closed sometime
4749 before now.  Check your control flow.
4750
4751 =item Sequence (? incomplete in regex; marked by S<<-- HERE> in m/%s/
4752
4753 (F) A regular expression ended with an incomplete extension (?.  The
4754 S<<-- HERE> shows whereabouts in the regular expression the problem was
4755 discovered.  See L<perlre>.
4756
4757 =item Sequence (?%c...) not implemented in regex; marked by S<<-- HERE> in
4758 m/%s/
4759
4760 (F) A proposed regular expression extension has the character reserved
4761 but has not yet been written.  The S<<-- HERE> shows whereabouts in the
4762 regular expression the problem was discovered.  See L<perlre>.
4763
4764 =item Sequence (?%s...) not recognized in regex; marked by S<<-- HERE> in
4765 m/%s/
4766
4767 (F) You used a regular expression extension that doesn't make sense.
4768 The S<<-- HERE> shows whereabouts in the regular expression the problem was
4769 discovered.  This may happen when using the C<(?^...)> construct to tell
4770 Perl to use the default regular expression modifiers, and you
4771 redundantly specify a default modifier.  For other
4772 causes, see L<perlre>.
4773
4774 =item Sequence (?#... not terminated in regex m/%s/
4775
4776 (F) A regular expression comment must be terminated by a closing
4777 parenthesis.  Embedded parentheses aren't allowed.  See
4778 L<perlre>.
4779
4780 =item Sequence (?&... not terminated in regex; marked by S<<-- HERE> in
4781 m/%s/
4782
4783 (F) A named reference of the form C<(?&...)> was missing the final
4784 closing parenthesis after the name.  The S<<-- HERE> shows whereabouts
4785 in the regular expression the problem was discovered.
4786
4787 =item Sequence (?%c... not terminated in regex; marked by S<<-- HERE>
4788 in m/%s/
4789
4790 (F) A named group of the form C<(?'...')> or C<< (?<...>) >> was missing the final
4791 closing quote or angle bracket.  The S<<-- HERE> shows whereabouts in the
4792 regular expression the problem was discovered.
4793
4794 =item Sequence (?(%c... not terminated in regex; marked by S<<-- HERE>
4795 in m/%s/
4796
4797 (F) A named reference of the form C<(?('...')...)> or C<< (?(<...>)...) >> was
4798 missing the final closing quote or angle bracket after the name.  The
4799 S<<-- HERE> shows whereabouts in the regular expression the problem was
4800 discovered.
4801
4802 =item Sequence \%s... not terminated in regex; marked by S<<-- HERE> in
4803 m/%s/
4804
4805 (F) The regular expression expects a mandatory argument following the escape
4806 sequence and this has been omitted or incorrectly written.
4807
4808 =item Sequence (?{...}) not terminated with ')'
4809
4810 (F) The end of the perl code contained within the {...} must be
4811 followed immediately by a ')'.
4812
4813 =item Sequence ?P=... not terminated in regex; marked by S<<-- HERE> in
4814 m/%s/
4815
4816 (F) A named reference of the form C<(?P=...)> was missing the final
4817 closing parenthesis after the name.  The S<<-- HERE> shows whereabouts
4818 in the regular expression the problem was discovered.