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