This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
4496770184935bc360bfab01cd1f6d6e64434164
[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 was 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 was not met.  See the L<version> module for more details on
2271 allowed version formats.
2272
2273 =item ioctl is not implemented
2274
2275 (F) Your machine apparently doesn't implement ioctl(), which is pretty
2276 strange for a machine that supports C.
2277
2278 =item ioctl() on unopened %s
2279
2280 (W unopened) You tried ioctl() on a filehandle that was never opened.
2281 Check you control flow and number of arguments.
2282
2283 =item IO layers (like '%s') unavailable
2284
2285 (F) Your Perl has not been configured to have PerlIO, and therefore
2286 you cannot use IO layers.  To have PerlIO Perl must be configured
2287 with 'useperlio'.
2288
2289 =item IO::Socket::atmark not implemented on this architecture
2290
2291 (F) Your machine doesn't implement the sockatmark() functionality,
2292 neither as a system call or an ioctl call (SIOCATMARK).
2293
2294 =item $* is no longer supported
2295
2296 (D deprecated, syntax) The special variable C<$*>, deprecated in older perls, has
2297 been removed as of 5.9.0 and is no longer supported. In previous versions of perl the use of
2298 C<$*> enabled or disabled multi-line matching within a string.
2299
2300 Instead of using C<$*> you should use the C</m> (and maybe C</s>) regexp
2301 modifiers. (In older versions: when C<$*> was set to a true value then all regular
2302 expressions behaved as if they were written using C</m>.)
2303
2304 =item $# is no longer supported
2305
2306 (D deprecated, syntax) The special variable C<$#>, deprecated in older perls, has
2307 been removed as of 5.9.3 and is no longer supported. You should use the
2308 printf/sprintf functions instead.
2309
2310 =item `%s' is not a code reference
2311
2312 (W overload) The second (fourth, sixth, ...) argument of overload::constant
2313 needs to be a code reference. Either an anonymous subroutine, or a reference
2314 to a subroutine.
2315
2316 =item `%s' is not an overloadable type
2317
2318 (W overload) You tried to overload a constant type the overload package is
2319 unaware of.
2320
2321 =item junk on end of regexp
2322
2323 (P) The regular expression parser is confused.
2324
2325 =item Label not found for "last %s"
2326
2327 (F) You named a loop to break out of, but you're not currently in a loop
2328 of that name, not even if you count where you were called from.  See
2329 L<perlfunc/last>.
2330
2331 =item Label not found for "next %s"
2332
2333 (F) You named a loop to continue, but you're not currently in a loop of
2334 that name, not even if you count where you were called from.  See
2335 L<perlfunc/last>.
2336
2337 =item Label not found for "redo %s"
2338
2339 (F) You named a loop to restart, 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 leaving effective %s failed
2344
2345 (F) While under the C<use filetest> pragma, switching the real and
2346 effective uids or gids failed.
2347
2348 =item length/code after end of string in unpack
2349
2350 (F) While unpacking, the string buffer was already used up when an unpack
2351 length/code combination tried to obtain more data. This results in
2352 an undefined value for the length. See L<perlfunc/pack>.
2353
2354 =item Lexing code attempted to stuff non-Latin-1 character into Latin-1 input
2355
2356 (F) An extension is attempting to insert text into the current parse
2357 (using L<lex_stuff_pvn_flags|perlapi/lex_stuff_pvn_flags> or similar), but
2358 tried to insert a character that couldn't be part of the current input.
2359 This is an inherent pitfall of the stuffing mechanism, and one of the
2360 reasons to avoid it.  Where it is necessary to stuff, stuffing only
2361 plain ASCII is recommended.
2362
2363 =item Lexing code internal error (%s)
2364
2365 (F) Lexing code supplied by an extension violated the lexer's API in a
2366 detectable way.
2367
2368 =item listen() on closed socket %s
2369
2370 (W closed) You tried to do a listen on a closed socket.  Did you forget
2371 to check the return value of your socket() call?  See
2372 L<perlfunc/listen>.
2373
2374 =item localtime(%.0f) too large
2375
2376 (W overflow) You called C<localtime> with an number that was larger
2377 than it can reliably handle and C<localtime> probably returned the
2378 wrong date. This warning is also triggered with nan (the special
2379 not-a-number value).
2380
2381 =item localtime(%.0f) too small
2382
2383 (W overflow) You called C<localtime> with an number that was smaller
2384 than it can reliably handle and C<localtime> probably returned the
2385 wrong date. This warning is also triggered with nan (the special
2386 not-a-number value).
2387
2388 =item Lookbehind longer than %d not implemented in regex m/%s/
2389
2390 (F) There is currently a limit on the length of string which lookbehind can
2391 handle. This restriction may be eased in a future release. 
2392
2393 =item Lost precision when %s %f by 1
2394
2395 (W) The value you attempted to increment or decrement by one is too large
2396 for the underlying floating point representation to store accurately,
2397 hence the target of C<++> or C<--> is unchanged. Perl issues this warning
2398 because it has already switched from integers to floating point when values
2399 are too large for integers, and now even floating point is insufficient.
2400 You may wish to switch to using L<Math::BigInt> explicitly.
2401
2402 =item lstat() on filehandle %s
2403
2404 (W io) You tried to do an lstat on a filehandle.  What did you mean
2405 by that?  lstat() makes sense only on filenames.  (Perl did a fstat()
2406 instead on the filehandle.)
2407
2408 =item lvalue attribute ignored after the subroutine has been defined
2409
2410 (W misc) Making a subroutine an lvalue subroutine after it has been defined
2411 by declaring the subroutine with a lvalue attribute is not
2412 possible. To make the the subroutine a lvalue subroutine add the
2413 lvalue attribute to the definition, or put the the declaration before
2414 the definition.
2415
2416 =item Lvalue subs returning %s not implemented yet
2417
2418 (F) Due to limitations in the current implementation, array and hash
2419 values cannot be returned in subroutines used in lvalue context.  See
2420 L<perlsub/"Lvalue subroutines">.
2421
2422 =item Malformed integer in [] in  pack
2423
2424 (F) Between the  brackets enclosing a numeric repeat count only digits
2425 are permitted.  See L<perlfunc/pack>.
2426
2427 =item Malformed integer in [] in unpack
2428
2429 (F) Between the  brackets enclosing a numeric repeat count only digits
2430 are permitted.  See L<perlfunc/pack>.
2431
2432 =item Malformed PERLLIB_PREFIX
2433
2434 (F) An error peculiar to OS/2.  PERLLIB_PREFIX should be of the form
2435
2436     prefix1;prefix2
2437
2438 or
2439     prefix1 prefix2
2440
2441 with nonempty prefix1 and prefix2.  If C<prefix1> is indeed a prefix of
2442 a builtin library search path, prefix2 is substituted.  The error may
2443 appear if components are not found, or are too long.  See
2444 "PERLLIB_PREFIX" in L<perlos2>.
2445
2446 =item Malformed prototype for %s: %s
2447
2448 (F) You tried to use a function with a malformed prototype.  The
2449 syntax of function prototypes is given a brief compile-time check for
2450 obvious errors like invalid characters.  A more rigorous check is run
2451 when the function is called.
2452
2453 =item Malformed UTF-8 character (%s)
2454
2455 (S utf8) (F) Perl detected a string that didn't comply with UTF-8
2456 encoding rules, even though it had the UTF8 flag on.
2457
2458 One possible cause is that you set the UTF8 flag yourself for data that
2459 you thought to be in UTF-8 but it wasn't (it was for example legacy
2460 8-bit data). To guard against this, you can use Encode::decode_utf8.
2461
2462 If you use the C<:encoding(UTF-8)> PerlIO layer for input, invalid byte
2463 sequences are handled gracefully, but if you use C<:utf8>, the flag is
2464 set without validating the data, possibly resulting in this error
2465 message.
2466
2467 See also L<Encode/"Handling Malformed Data">.
2468
2469 =item Malformed UTF-16 surrogate
2470
2471 (F) Perl thought it was reading UTF-16 encoded character data but while
2472 doing it Perl met a malformed Unicode surrogate.
2473
2474 =item Malformed UTF-8 returned by \N
2475
2476 (F) The charnames handler returned malformed UTF-8.
2477
2478 =item Malformed UTF-8 string in pack
2479
2480 (F) You tried to pack something that didn't comply with UTF-8 encoding
2481 rules and perl was unable to guess how to make more progress.
2482
2483 =item Malformed UTF-8 string in unpack
2484
2485 (F) You tried to unpack something that didn't comply with UTF-8 encoding
2486 rules and perl was unable to guess how to make more progress.
2487
2488 =item Malformed UTF-8 string in '%c' format in unpack
2489
2490 (F) You tried to unpack something that didn't comply with UTF-8 encoding
2491 rules and perl was unable to guess how to make more progress.
2492
2493 =item Maximal count of pending signals (%d) exceeded
2494
2495 (F) Perl aborted due to a too high number of signals pending. This
2496 usually indicates that your operating system tried to deliver signals
2497 too fast (with a very high priority), starving the perl process from
2498 resources it would need to reach a point where it can process signals
2499 safely. (See L<perlipc/"Deferred Signals (Safe Signals)">.)
2500
2501 =item %s matches null string many times in regex; marked by <-- HERE in m/%s/
2502
2503 (W regexp) The pattern you've specified would be an infinite loop if the
2504 regular expression engine didn't specifically check for that.  The <-- HERE
2505 shows in the regular expression about where the problem was discovered.
2506 See L<perlre>.
2507
2508 =item "%s" may clash with future reserved word
2509
2510 (W) This warning may be due to running a perl5 script through a perl4
2511 interpreter, especially if the word that is being warned about is
2512 "use" or "my".
2513
2514 =item % may not be used in pack
2515
2516 (F) You can't pack a string by supplying a checksum, because the
2517 checksumming process loses information, and you can't go the other way.
2518 See L<perlfunc/unpack>.
2519
2520 =item Method for operation %s not found in package %s during blessing
2521
2522 (F) An attempt was made to specify an entry in an overloading table that
2523 doesn't resolve to a valid subroutine.  See L<overload>.
2524
2525 =item Method %s not permitted
2526
2527 See Server error.
2528
2529 =item Might be a runaway multi-line %s string starting on line %d
2530
2531 (S) An advisory indicating that the previous error may have been caused
2532 by a missing delimiter on a string or pattern, because it eventually
2533 ended earlier on the current line.
2534
2535 =item Misplaced _ in number
2536
2537 (W syntax) An underscore (underbar) in a numeric constant did not
2538 separate two digits.
2539
2540 =item Missing argument in %s
2541
2542 (W uninitialized) A printf-type format required more arguments than were
2543 supplied.
2544
2545 =item Missing argument to -%c
2546
2547 (F) The argument to the indicated command line switch must follow
2548 immediately after the switch, without intervening spaces.
2549
2550 =item Missing braces on \N{}
2551
2552 (F) Wrong syntax of character name literal C<\N{charname}> within
2553 double-quotish context.  This can also happen when there is a space (or
2554 comment) between the C<\N> and the C<{> in a regex with the C</x> modifier.
2555 This modifier does not change the requirement that the brace immediately follow
2556 the C<\N>.
2557
2558 =item Missing braces on \o{}
2559
2560 (F) A C<\o> must be followed immediately by a C<{> in double-quotish context.
2561
2562 =item Missing comma after first argument to %s function
2563
2564 (F) While certain functions allow you to specify a filehandle or an
2565 "indirect object" before the argument list, this ain't one of them.
2566
2567 =item Missing command in piped open
2568
2569 (W pipe) You used the C<open(FH, "| command")> or
2570 C<open(FH, "command |")> construction, but the command was missing or
2571 blank.
2572
2573 =item Missing control char name in \c
2574
2575 (F) A double-quoted string ended with "\c", without the required control
2576 character name.
2577
2578 =item Missing name in "my sub"
2579
2580 (F) The reserved syntax for lexically scoped subroutines requires that
2581 they have a name with which they can be found.
2582
2583 =item Missing $ on loop variable
2584
2585 (F) Apparently you've been programming in B<csh> too much.  Variables
2586 are always mentioned with the $ in Perl, unlike in the shells, where it
2587 can vary from one line to the next.
2588
2589 =item (Missing operator before %s?)
2590
2591 (S syntax) This is an educated guess made in conjunction with the message
2592 "%s found where operator expected".  Often the missing operator is a comma.
2593
2594 =item Missing right brace on %s
2595
2596 (F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>.
2597
2598 =item Missing right brace on \N{} or unescaped left brace after \N
2599
2600 (F)
2601 C<\N> has two meanings.
2602
2603 The traditional one has it followed by a name enclosed
2604 in braces, meaning the character (or sequence of characters) given by that name.
2605 Thus C<\N{ASTERISK}> is another way of writing C<*>, valid in both
2606 double-quoted strings and regular expression patterns.  In patterns, it doesn't
2607 have the meaning an unescaped C<*> does.
2608
2609 Starting in Perl 5.12.0, C<\N> also can have an additional meaning (only) in
2610 patterns, namely to match a non-newline character.  (This is short for
2611 C<[^\n]>, and like C<.> but is not affected by the C</s> regex modifier.)
2612
2613 This can lead to some ambiguities.  When C<\N> is not followed immediately by a
2614 left brace, Perl assumes the C<[^\n]> meaning.  Also, if
2615 the braces form a valid quantifier such as C<\N{3}> or C<\N{5,}>, Perl assumes
2616 that this means to match the given quantity of non-newlines (in these examples,
2617 3; and 5 or more, respectively).  In all other case, where there is a C<\N{>
2618 and a matching C<}>, Perl assumes that a character name is desired.
2619
2620 However, if there is no matching C<}>, Perl doesn't know if it was mistakenly
2621 omitted, or if C<[^\n]{> was desired, and
2622 raises this error.  If you meant the former, add the right brace; if you meant
2623 the latter, escape the brace with a backslash, like so: C<\N\{>
2624
2625 =item Missing right curly or square bracket
2626
2627 (F) The lexer counted more opening curly or square brackets than closing
2628 ones.  As a general rule, you'll find it's missing near the place you
2629 were last editing.
2630
2631 =item (Missing semicolon on previous line?)
2632
2633 (S syntax) This is an educated guess made in conjunction with the message
2634 "%s found where operator expected".  Don't automatically put a semicolon on
2635 the previous line just because you saw this message.
2636
2637 =item Modification of a read-only value attempted
2638
2639 (F) You tried, directly or indirectly, to change the value of a
2640 constant.  You didn't, of course, try "2 = 1", because the compiler
2641 catches that.  But an easy way to do the same thing is:
2642
2643     sub mod { $_[0] = 1 }
2644     mod(2);
2645
2646 Another way is to assign to a substr() that's off the end of the string.
2647
2648 Yet another way is to assign to a C<foreach> loop I<VAR> when I<VAR>
2649 is aliased to a constant in the look I<LIST>:
2650
2651         $x = 1;
2652         foreach my $n ($x, 2) {
2653             $n *= 2; # modifies the $x, but fails on attempt to modify the 2
2654         }
2655
2656 =item Modification of non-creatable array value attempted, %s
2657
2658 (F) You tried to make an array value spring into existence, and the
2659 subscript was probably negative, even counting from end of the array
2660 backwards.
2661
2662 =item Modification of non-creatable hash value attempted, %s
2663
2664 (P) You tried to make a hash value spring into existence, and it
2665 couldn't be created for some peculiar reason.
2666
2667 =item Module name must be constant
2668
2669 (F) Only a bare module name is allowed as the first argument to a "use".
2670
2671 =item Module name required with -%c option
2672
2673 (F) The C<-M> or C<-m> options say that Perl should load some module, but
2674 you omitted the name of the module.  Consult L<perlrun> for full details
2675 about C<-M> and C<-m>.
2676
2677 =item More than one argument to '%s' open
2678
2679 (F) The C<open> function has been asked to open multiple files. This
2680 can happen if you are trying to open a pipe to a command that takes a
2681 list of arguments, but have forgotten to specify a piped open mode.
2682 See L<perlfunc/open> for details.
2683
2684 =item msg%s not implemented
2685
2686 (F) You don't have System V message IPC on your system.
2687
2688 =item Multidimensional syntax %s not supported
2689
2690 (W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
2691 They're written like C<$foo[1][2][3]>, as in C.
2692
2693 =item '/' must follow a numeric type in unpack
2694
2695 (F) You had an unpack template that contained a '/', but this did not
2696 follow some unpack specification producing a numeric value.
2697 See L<perlfunc/pack>.
2698
2699 =item "my sub" not yet implemented
2700
2701 (F) Lexically scoped subroutines are not yet implemented.  Don't try
2702 that yet.
2703
2704 =item "%s" variable %s can't be in a package
2705
2706 (F) Lexically scoped variables aren't in a package, so it doesn't make
2707 sense to try to declare one with a package qualifier on the front.  Use
2708 local() if you want to localize a package variable.
2709
2710 =item \N in a character class must be a named character: \N{...}
2711
2712 (F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed
2713 character class, for the same reason that C<.> in a character class loses its
2714 specialness: it matches almost everything, which is probably not what you want.
2715
2716 =item \N{NAME} must be resolved by the lexer
2717
2718 (F) When compiling a regex pattern, an unresolved named character or sequence
2719 was encountered.  This can happen in any of several ways that bypass the lexer,
2720 such as using single-quotish context, or an extra backslash in double quotish:
2721
2722     $re = '\N{SPACE}';  # Wrong!
2723     $re = "\\N{SPACE}"; # Wrong!
2724     /$re/;
2725
2726 Instead, use double-quotes with a single backslash:
2727
2728     $re = "\N{SPACE}";  # ok
2729     /$re/;
2730
2731 The lexer can be bypassed as well by creating the pattern from smaller
2732 components:
2733
2734     $re = '\N';
2735     /${re}{SPACE}/;     # Wrong!
2736
2737 It's not a good idea to split a construct in the middle like this, and it
2738 doesn't work here.  Instead use the solution above.
2739
2740 Finally, the message also can happen under the C</x> regex modifier when the
2741 C<\N> is separated by spaces from the C<{>, in which case, remove the spaces.
2742
2743     /\N {SPACE}/x;      # Wrong!
2744     /\N{SPACE}/x;       # ok
2745
2746 =item Name "%s::%s" used only once: possible typo
2747
2748 (W once) Typographical errors often show up as unique variable names.
2749 If you had a good reason for having a unique name, then just mention it
2750 again somehow to suppress the message.  The C<our> declaration is
2751 provided for this purpose.
2752
2753 NOTE: This warning detects symbols that have been used only once so $c, @c,
2754 %c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
2755 the same; if a program uses $c only once but also uses any of the others it
2756 will not trigger this warning.
2757
2758 =item Invalid hexadecimal number in \N{U+...}
2759
2760 (F) The character constant represented by C<...> is not a valid hexadecimal
2761 number.  Either it is empty, or you tried to use a character other than 0 - 9
2762 or A - F, a - f in a hexadecimal number.
2763
2764 =item Negative '/' count in unpack
2765
2766 (F) The length count obtained from a length/code unpack operation was
2767 negative.  See L<perlfunc/pack>.
2768
2769 =item Negative length
2770
2771 (F) You tried to do a read/write/send/recv operation with a buffer
2772 length that is less than 0.  This is difficult to imagine.
2773
2774 =item Negative offset to vec in lvalue context
2775
2776 (F) When C<vec> is called in an lvalue context, the second argument must be
2777 greater than or equal to zero.
2778
2779 =item Nested quantifiers in regex; marked by <-- HERE in m/%s/
2780
2781 (F) You can't quantify a quantifier without intervening parentheses. So
2782 things like ** or +* or ?* are illegal. The <-- HERE shows in the regular
2783 expression about where the problem was discovered.
2784
2785 Note that the minimal matching quantifiers, C<*?>, C<+?>, and
2786 C<??> appear to be nested quantifiers, but aren't.  See L<perlre>.
2787
2788 =item %s never introduced
2789
2790 (S internal) The symbol in question was declared but somehow went out of
2791 scope before it could possibly have been used.
2792
2793 =item next::method/next::can/maybe::next::method cannot find enclosing method
2794
2795 (F) C<next::method> needs to be called within the context of a
2796 real method in a real package, and it could not find such a context.
2797 See L<mro>.
2798
2799 =item No %s allowed while running setuid
2800
2801 (F) Certain operations are deemed to be too insecure for a setuid or
2802 setgid script to even be allowed to attempt.  Generally speaking there
2803 will be another way to do what you want that is, if not secure, at least
2804 securable.  See L<perlsec>.
2805
2806 =item No comma allowed after %s
2807
2808 (F) A list operator that has a filehandle or "indirect object" is not
2809 allowed to have a comma between that and the following arguments.
2810 Otherwise it'd be just another one of the arguments.
2811
2812 One possible cause for this is that you expected to have imported a
2813 constant to your name space with B<use> or B<import> while no such
2814 importing took place, it may for example be that your operating system
2815 does not support that particular constant. Hopefully you did use an
2816 explicit import list for the constants you expect to see, please see
2817 L<perlfunc/use> and L<perlfunc/import>. While an explicit import list
2818 would probably have caught this error earlier it naturally does not
2819 remedy the fact that your operating system still does not support that
2820 constant. Maybe you have a typo in the constants of the symbol import
2821 list of B<use> or B<import> or in the constant name at the line where
2822 this error was triggered?
2823
2824 =item No command into which to pipe on command line
2825
2826 (F) An error peculiar to VMS.  Perl handles its own command line
2827 redirection, and found a '|' at the end of the command line, so it
2828 doesn't know where you want to pipe the output from this command.
2829
2830 =item No DB::DB routine defined
2831
2832 (F) The currently executing code was compiled with the B<-d> switch, but
2833 for some reason the  current debugger (e.g. F<perl5db.pl> or a C<Devel::>
2834 module) didn't define a routine to be called at the beginning of each
2835 statement.
2836
2837 =item No dbm on this machine
2838
2839 (P) This is counted as an internal error, because every machine should
2840 supply dbm nowadays, because Perl comes with SDBM.  See L<SDBM_File>.
2841
2842 =item No DB::sub routine defined
2843
2844 (F) The currently executing code was compiled with the B<-d> switch, but
2845 for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::>
2846 module) didn't define a C<DB::sub> routine to be called at the beginning
2847 of each ordinary subroutine call.
2848
2849 =item No B<-e> allowed in setuid scripts
2850
2851 (F) A setuid script can't be specified by the user.
2852
2853 =item No error file after 2> or 2>> on command line
2854
2855 (F) An error peculiar to VMS.  Perl handles its own command line
2856 redirection, and found a '2>' or a '2>>' on the command line, but can't
2857 find the name of the file to which to write data destined for stderr.
2858
2859 =item No group ending character '%c' found in template
2860
2861 (F) A pack or unpack template has an opening '(' or '[' without its
2862 matching counterpart. See L<perlfunc/pack>.
2863
2864 =item No input file after < on command line
2865
2866 (F) An error peculiar to VMS.  Perl handles its own command line
2867 redirection, and found a '<' on the command line, but can't find the
2868 name of the file from which to read data for stdin.
2869
2870 =item No #! line
2871
2872 (F) The setuid emulator requires that scripts have a well-formed #! line
2873 even on machines that don't support the #! construct.
2874
2875 =item No next::method '%s' found for %s
2876
2877 (F) C<next::method> found no further instances of this method name
2878 in the remaining packages of the MRO of this class.  If you don't want
2879 it throwing an exception, use C<maybe::next::method>
2880 or C<next::can>. See L<mro>.
2881
2882 =item "no" not allowed in expression
2883
2884 (F) The "no" keyword is recognized and executed at compile time, and
2885 returns no useful value.  See L<perlmod>.
2886
2887 =item No output file after > on command line
2888
2889 (F) An error peculiar to VMS.  Perl handles its own command line
2890 redirection, and found a lone '>' at the end of the command line, so it
2891 doesn't know where you wanted to redirect stdout.
2892
2893 =item No output file after > or >> on command line
2894
2895 (F) An error peculiar to VMS.  Perl handles its own command line
2896 redirection, and found a '>' or a '>>' on the command line, but can't
2897 find the name of the file to which to write data destined for stdout.
2898
2899 =item No package name allowed for variable %s in "our"
2900
2901 (F) Fully qualified variable names are not allowed in "our"
2902 declarations, because that doesn't make much sense under existing
2903 semantics.  Such syntax is reserved for future extensions.
2904
2905 =item No Perl script found in input
2906
2907 (F) You called C<perl -x>, but no line was found in the file beginning
2908 with #! and containing the word "perl".
2909
2910 =item No setregid available
2911
2912 (F) Configure didn't find anything resembling the setregid() call for
2913 your system.
2914
2915 =item No setreuid available
2916
2917 (F) Configure didn't find anything resembling the setreuid() call for
2918 your system.
2919
2920 =item No %s specified for -%c
2921
2922 (F) The indicated command line switch needs a mandatory argument, but
2923 you haven't specified one.
2924 =item No such class field "%s" in variable %s of type %s
2925
2926 (F) You tried to access a key from a hash through the indicated typed variable
2927 but that key is not allowed by the package of the same type.  The indicated
2928 package has restricted the set of allowed keys using the L<fields> pragma.
2929
2930 =item No such class %s
2931
2932 (F) You provided a class qualifier in a "my", "our" or "state" declaration, but
2933 this class doesn't exist at this point in your program.
2934
2935 =item No such hook: %s
2936
2937 (F) You specified a signal hook that was not recognized by Perl.  Currently, Perl
2938 accepts C<__DIE__> and C<__WARN__> as valid signal hooks
2939
2940 =item No such pipe open
2941
2942 (P) An error peculiar to VMS.  The internal routine my_pclose() tried to
2943 close a pipe which hadn't been opened.  This should have been caught
2944 earlier as an attempt to close an unopened filehandle.
2945
2946 =item No such signal: SIG%s
2947
2948 (W signal) You specified a signal name as a subscript to %SIG that was
2949 not recognized.  Say C<kill -l> in your shell to see the valid signal
2950 names on your system.
2951
2952 =item Not a CODE reference
2953
2954 (F) Perl was trying to evaluate a reference to a code value (that is, a
2955 subroutine), but found a reference to something else instead.  You can
2956 use the ref() function to find out what kind of ref it really was.  See
2957 also L<perlref>.
2958
2959 =item Not a format reference
2960
2961 (F) I'm not sure how you managed to generate a reference to an anonymous
2962 format, but this indicates you did, and that it didn't exist.
2963
2964 =item Not a GLOB reference
2965
2966 (F) Perl was trying to evaluate a reference to a "typeglob" (that is, a
2967 symbol table entry that looks like C<*foo>), but found a reference to
2968 something else instead.  You can use the ref() function to find out what
2969 kind of ref it really was.  See L<perlref>.
2970
2971 =item Not a HASH reference
2972
2973 (F) Perl was trying to evaluate a reference to a hash value, but found a
2974 reference to something else instead.  You can use the ref() function to
2975 find out what kind of ref it really was.  See L<perlref>.
2976
2977 =item Not an ARRAY reference
2978
2979 (F) Perl was trying to evaluate a reference to an array value, but found
2980 a reference to something else instead.  You can use the ref() function
2981 to find out what kind of ref it really was.  See L<perlref>.
2982
2983 =item Not a perl script
2984
2985 (F) The setuid emulator requires that scripts have a well-formed #! line
2986 even on machines that don't support the #! construct.  The line must
2987 mention perl.
2988
2989 =item Not a SCALAR reference
2990
2991 (F) Perl was trying to evaluate a reference to a scalar value, but found
2992 a reference to something else instead.  You can use the ref() function
2993 to find out what kind of ref it really was.  See L<perlref>.
2994
2995 =item Not a subroutine reference
2996
2997 (F) Perl was trying to evaluate a reference to a code value (that is, a
2998 subroutine), but found a reference to something else instead.  You can
2999 use the ref() function to find out what kind of ref it really was.  See
3000 also L<perlref>.
3001
3002 =item Not a subroutine reference in overload table
3003
3004 (F) An attempt was made to specify an entry in an overloading table that
3005 doesn't somehow point to a valid subroutine.  See L<overload>.
3006
3007 =item Not enough arguments for %s
3008
3009 (F) The function requires more arguments than you specified.
3010
3011 =item Not enough format arguments
3012
3013 (W syntax) A format specified more picture fields than the next line
3014 supplied.  See L<perlform>.
3015
3016 =item %s: not found
3017
3018 (A) You've accidentally run your script through the Bourne shell instead
3019 of Perl.  Check the #! line, or manually feed your script into Perl
3020 yourself.
3021
3022 =item no UTC offset information; assuming local time is UTC
3023
3024 (S) A warning peculiar to VMS.  Perl was unable to find the local
3025 timezone offset, so it's assuming that local system time is equivalent
3026 to UTC.  If it's not, define the logical name
3027 F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
3028 need to be added to UTC to get local time.
3029
3030 =item Non-octal character '%c'.  Resolved as "%s"
3031
3032 (W digit)  In parsing an octal numeric constant, a character was unexpectedly
3033 encountered that isn't octal.  The resulting value is as indicated.
3034
3035 =item Non-string passed as bitmask
3036
3037 (W misc) A number has been passed as a bitmask argument to select().
3038 Use the vec() function to construct the file descriptor bitmasks for
3039 select. See L<perlfunc/select>
3040
3041 =item Null filename used
3042
3043 (F) You can't require the null filename, especially because on many
3044 machines that means the current directory!  See L<perlfunc/require>.
3045
3046 =item NULL OP IN RUN
3047
3048 (P debugging) Some internal routine called run() with a null opcode
3049 pointer.
3050
3051 =item Null picture in formline
3052
3053 (F) The first argument to formline must be a valid format picture
3054 specification.  It was found to be empty, which probably means you
3055 supplied it an uninitialized value.  See L<perlform>.
3056
3057 =item Null realloc
3058
3059 (P) An attempt was made to realloc NULL.
3060
3061 =item NULL regexp argument
3062
3063 (P) The internal pattern matching routines blew it big time.
3064
3065 =item NULL regexp parameter
3066
3067 (P) The internal pattern matching routines are out of their gourd.
3068
3069 =item Number too long
3070
3071 (F) Perl limits the representation of decimal numbers in programs to
3072 about 250 characters.  You've exceeded that length.  Future
3073 versions of Perl are likely to eliminate this arbitrary limitation.  In
3074 the meantime, try using scientific notation (e.g. "1e6" instead of
3075 "1_000_000").
3076
3077 =item Number with no digits
3078
3079 (F) Perl was looking for a number but found nothing that looked like a number.
3080 This happens, for example with C<\o{}>, with no number between the braces.
3081
3082 =item Octal number in vector unsupported
3083
3084 (F) Numbers with a leading C<0> are not currently allowed in vectors.
3085 The octal number interpretation of such numbers may be supported in a
3086 future version.
3087
3088 =item Octal number > 037777777777 non-portable
3089
3090 (W portable) The octal number you specified is larger than 2**32-1
3091 (4294967295) and therefore non-portable between systems.  See
3092 L<perlport> for more on portability concerns.
3093
3094 See also L<perlport> for writing portable code.
3095
3096 =item Odd number of arguments for overload::constant
3097
3098 (W overload) The call to overload::constant contained an odd number of
3099 arguments. The arguments should come in pairs.
3100
3101 =item Odd number of elements in anonymous hash
3102
3103 (W misc) You specified an odd number of elements to initialize a hash,
3104 which is odd, because hashes come in key/value pairs.
3105
3106 =item Odd number of elements in hash assignment
3107
3108 (W misc) You specified an odd number of elements to initialize a hash,
3109 which is odd, because hashes come in key/value pairs.
3110
3111 =item Offset outside string
3112
3113 (F, W layer) You tried to do a read/write/send/recv/seek operation
3114 with an offset pointing outside the buffer.  This is difficult to
3115 imagine.  The sole exceptions to this are that zero padding will
3116 take place when going past the end of the string when either
3117 C<sysread()>ing a file, or when seeking past the end of a scalar opened
3118 for I/O (in anticipation of future reads and to imitate the behaviour
3119 with real files).
3120
3121 =item %s() on unopened %s
3122
3123 (W unopened) An I/O operation was attempted on a filehandle that was
3124 never initialized.  You need to do an open(), a sysopen(), or a socket()
3125 call, or call a constructor from the FileHandle package.
3126
3127 =item -%s on unopened filehandle %s
3128
3129 (W unopened) You tried to invoke a file test operator on a filehandle
3130 that isn't open.  Check your control flow.  See also L<perlfunc/-X>.
3131
3132 =item oops: oopsAV
3133
3134 (S internal) An internal warning that the grammar is screwed up.
3135
3136 =item oops: oopsHV
3137
3138 (S internal) An internal warning that the grammar is screwed up.
3139
3140 =item Opening dirhandle %s also as a file
3141
3142 (W io deprecated) You used open() to associate a filehandle to
3143 a symbol (glob or scalar) that already holds a dirhandle.
3144 Although legal, this idiom might render your code confusing
3145 and is deprecated.
3146
3147 =item Opening filehandle %s also as a directory
3148
3149 (W io deprecated) You used opendir() to associate a dirhandle to
3150 a symbol (glob or scalar) that already holds a filehandle.
3151 Although legal, this idiom might render your code confusing
3152 and is deprecated.
3153
3154 =item Operation "%s": no method found, %s
3155
3156 (F) An attempt was made to perform an overloaded operation for which no
3157 handler was defined.  While some handlers can be autogenerated in terms
3158 of other handlers, there is no default handler for any operation, unless
3159 C<fallback> overloading key is specified to be true.  See L<overload>.
3160
3161 =item Operator or semicolon missing before %s
3162
3163 (S ambiguous) You used a variable or subroutine call where the parser
3164 was expecting an operator.  The parser has assumed you really meant to
3165 use an operator, but this is highly likely to be incorrect.  For
3166 example, if you say "*foo *foo" it will be interpreted as if you said
3167 "*foo * 'foo'".
3168
3169 =item "our" variable %s redeclared
3170
3171 (W misc) You seem to have already declared the same global once before
3172 in the current lexical scope.
3173
3174 =item Out of memory!
3175
3176 (X) The malloc() function returned 0, indicating there was insufficient
3177 remaining memory (or virtual memory) to satisfy the request.  Perl has
3178 no option but to exit immediately.
3179
3180 At least in Unix you may be able to get past this by increasing your
3181 process datasize limits: in csh/tcsh use C<limit> and
3182 C<limit datasize n> (where C<n> is the number of kilobytes) to check
3183 the current limits and change them, and in ksh/bash/zsh use C<ulimit -a>
3184 and C<ulimit -d n>, respectively.
3185
3186 =item Out of memory during %s extend
3187
3188 (X) An attempt was made to extend an array, a list, or a string beyond
3189 the largest possible memory allocation.
3190
3191 =item Out of memory during "large" request for %s
3192
3193 (F) The malloc() function returned 0, indicating there was insufficient
3194 remaining memory (or virtual memory) to satisfy the request. However,
3195 the request was judged large enough (compile-time default is 64K), so a
3196 possibility to shut down by trapping this error is granted.
3197
3198 =item Out of memory during request for %s
3199
3200 (X|F) The malloc() function returned 0, indicating there was
3201 insufficient remaining memory (or virtual memory) to satisfy the
3202 request.
3203
3204 The request was judged to be small, so the possibility to trap it
3205 depends on the way perl was compiled.  By default it is not trappable.
3206 However, if compiled for this, Perl may use the contents of C<$^M> as an
3207 emergency pool after die()ing with this message.  In this case the error
3208 is trappable I<once>, and the error message will include the line and file
3209 where the failed request happened.
3210
3211 =item Out of memory during ridiculously large request
3212
3213 (F) You can't allocate more than 2^31+"small amount" bytes.  This error
3214 is most likely to be caused by a typo in the Perl program. e.g.,
3215 C<$arr[time]> instead of C<$arr[$time]>.
3216
3217 =item Out of memory for yacc stack
3218
3219 (F) The yacc parser wanted to grow its stack so it could continue
3220 parsing, but realloc() wouldn't give it more memory, virtual or
3221 otherwise.
3222
3223 =item '.' outside of string in pack
3224
3225 (F) The argument to a '.' in your template tried to move the working
3226 position to before the start of the packed string being built.
3227
3228 =item '@' outside of string in unpack
3229
3230 (F) You had a template that specified an absolute position outside
3231 the string being unpacked.  See L<perlfunc/pack>.
3232
3233 =item '@' outside of string with malformed UTF-8 in unpack
3234
3235 (F) You had a template that specified an absolute position outside
3236 the string being unpacked. The string being unpacked was also invalid
3237 UTF-8. See L<perlfunc/pack>.
3238
3239 =item Overloaded dereference did not return a reference
3240
3241 (F) An object with an overloaded dereference operator was dereferenced,
3242 but the overloaded operation did not return a reference. See
3243 L<overload>.
3244
3245 =item Overloaded qr did not return a REGEXP
3246
3247 (F) An object with a C<qr> overload was used as part of a match, but the
3248 overloaded operation didn't return a compiled regexp. See L<overload>.
3249
3250 =item %s package attribute may clash with future reserved word: %s
3251
3252 (W reserved) A lowercase attribute name was used that had a
3253 package-specific handler.  That name might have a meaning to Perl itself
3254 some day, even though it doesn't yet.  Perhaps you should use a
3255 mixed-case attribute name, instead.  See L<attributes>.
3256
3257 =item pack/unpack repeat count overflow
3258
3259 (F) You can't specify a repeat count so large that it overflows your
3260 signed integers.  See L<perlfunc/pack>.
3261
3262 =item page overflow
3263
3264 (W io) A single call to write() produced more lines than can fit on a
3265 page.  See L<perlform>.
3266
3267 =item panic: %s
3268
3269 (P) An internal error.
3270
3271 =item panic: attempt to call %s in %s
3272
3273 (P) One of the file test operators entered a code branch that calls
3274 an ACL related-function, but that function is not available on this
3275 platform.  Earlier checks mean that it should not be possible to
3276 enter this branch on this platform.
3277
3278 =item panic: ck_grep
3279
3280 (P) Failed an internal consistency check trying to compile a grep.
3281
3282 =item panic: ck_split
3283
3284 (P) Failed an internal consistency check trying to compile a split.
3285
3286 =item panic: corrupt saved stack index
3287
3288 (P) The savestack was requested to restore more localized values than
3289 there are in the savestack.
3290
3291 =item panic: del_backref
3292
3293 (P) Failed an internal consistency check while trying to reset a weak
3294 reference.
3295
3296 =item panic: Devel::DProf inconsistent subroutine return
3297
3298 (P) Devel::DProf called a subroutine that exited using goto(LABEL),
3299 last(LABEL) or next(LABEL). Leaving that way a subroutine called from
3300 an XSUB will lead very probably to a crash of the interpreter. This is
3301 a bug that will hopefully one day get fixed.
3302
3303 =item panic: die %s
3304
3305 (P) We popped the context stack to an eval context, and then discovered
3306 it wasn't an eval context.
3307
3308 =item panic: do_subst
3309
3310 (P) The internal pp_subst() routine was called with invalid operational
3311 data.
3312
3313 =item panic: do_trans_%s
3314
3315 (P) The internal do_trans routines were called with invalid operational
3316 data.
3317
3318 =item panic: fold_constants JMPENV_PUSH returned %d
3319
3320 (P) While attempting folding constants an exception other than an C<eval>
3321 failure was caught.
3322
3323 =item panic: frexp
3324
3325 (P) The library function frexp() failed, making printf("%f") impossible.
3326
3327 =item panic: goto
3328
3329 (P) We popped the context stack to a context with the specified label,
3330 and then discovered it wasn't a context we know how to do a goto in.
3331
3332 =item panic: hfreeentries failed to free hash
3333
3334 (P) The internal routine used to clear a hashes entries tried repeatedly,
3335 but each time something added more entries to the hash. Most likely the hash
3336 contains an object with a reference back to the hash and a destructor that
3337 adds a new object to the hash.
3338
3339 =item panic: INTERPCASEMOD
3340
3341 (P) The lexer got into a bad state at a case modifier.
3342
3343 =item panic: INTERPCONCAT
3344
3345 (P) The lexer got into a bad state parsing a string with brackets.
3346
3347 =item panic: kid popen errno read
3348
3349 (F) forked child returned an incomprehensible message about its errno.
3350
3351 =item panic: last
3352
3353 (P) We popped the context stack to a block context, and then discovered
3354 it wasn't a block context.
3355
3356 =item panic: leave_scope clearsv
3357
3358 (P) A writable lexical variable became read-only somehow within the
3359 scope.
3360
3361 =item panic: leave_scope inconsistency
3362
3363 (P) The savestack probably got out of sync.  At least, there was an
3364 invalid enum on the top of it.
3365
3366 =item panic: magic_killbackrefs
3367
3368 (P) Failed an internal consistency check while trying to reset all weak
3369 references to an object.
3370
3371 =item panic: malloc
3372
3373 (P) Something requested a negative number of bytes of malloc.
3374
3375 =item panic: memory wrap
3376
3377 (P) Something tried to allocate more memory than possible.
3378
3379 =item panic: pad_alloc
3380
3381 (P) The compiler got confused about which scratch pad it was allocating
3382 and freeing temporaries and lexicals from.
3383
3384 =item panic: pad_free curpad
3385
3386 (P) The compiler got confused about which scratch pad it was allocating
3387 and freeing temporaries and lexicals from.
3388
3389 =item panic: pad_free po
3390
3391 (P) An invalid scratch pad offset was detected internally.
3392
3393 =item panic: pad_reset curpad
3394
3395 (P) The compiler got confused about which scratch pad it was allocating
3396 and freeing temporaries and lexicals from.
3397
3398 =item panic: pad_sv po
3399
3400 (P) An invalid scratch pad offset was detected internally.
3401
3402 =item panic: pad_swipe curpad
3403
3404 (P) The compiler got confused about which scratch pad it was allocating
3405 and freeing temporaries and lexicals from.
3406
3407 =item panic: pad_swipe po
3408
3409 (P) An invalid scratch pad offset was detected internally.
3410
3411 =item panic: pp_iter
3412
3413 (P) The foreach iterator got called in a non-loop context frame.
3414
3415 =item panic: pp_match%s
3416
3417 (P) The internal pp_match() routine was called with invalid operational
3418 data.
3419
3420 =item panic: pp_split
3421
3422 (P) Something terrible went wrong in setting up for the split.
3423
3424 =item panic: realloc
3425
3426 (P) Something requested a negative number of bytes of realloc.
3427
3428 =item panic: restartop
3429
3430 (P) Some internal routine requested a goto (or something like it), and
3431 didn't supply the destination.
3432
3433 =item panic: return
3434
3435 (P) We popped the context stack to a subroutine or eval context, and
3436 then discovered it wasn't a subroutine or eval context.
3437
3438 =item panic: scan_num
3439
3440 (P) scan_num() got called on something that wasn't a number.
3441
3442 =item panic: sv_chop %s
3443
3444 (P) The sv_chop() routine was passed a position that is not within the
3445 scalar's string buffer.
3446
3447 =item panic: sv_insert
3448
3449 (P) The sv_insert() routine was told to remove more string than there
3450 was string.
3451
3452 =item panic: top_env
3453
3454 (P) The compiler attempted to do a goto, or something weird like that.
3455
3456 =item panic: unimplemented op %s (#%d) called
3457
3458 (P) The compiler is screwed up and attempted to use an op that isn't permitted
3459 at run time.
3460
3461 =item panic: utf16_to_utf8: odd bytelen
3462
3463 (P) Something tried to call utf16_to_utf8 with an odd (as opposed
3464 to even) byte length.
3465
3466 =item panic: utf16_to_utf8_reversed: odd bytelen
3467
3468 (P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed
3469 to even) byte length.
3470
3471 =item panic: yylex
3472
3473 (P) The lexer got into a bad state while processing a case modifier.
3474
3475 =item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/
3476
3477 (F) You used a pattern that uses too many nested subpattern calls without
3478 consuming any text. Restructure the pattern so text is consumed before the
3479 nesting limit is exceeded.
3480
3481 The <-- HERE shows in the regular expression about where the problem was
3482 discovered.
3483
3484 =item Parentheses missing around "%s" list
3485
3486 (W parenthesis) You said something like
3487
3488     my $foo, $bar = @_;
3489
3490 when you meant
3491
3492     my ($foo, $bar) = @_;
3493
3494 Remember that "my", "our", "local" and "state" bind tighter than comma.
3495
3496 =item C<-p> destination: %s
3497
3498 (F) An error occurred during the implicit output invoked by the C<-p>
3499 command-line switch.  (This output goes to STDOUT unless you've
3500 redirected it with select().)
3501
3502 =item (perhaps you forgot to load "%s"?)
3503
3504 (F) This is an educated guess made in conjunction with the message
3505 "Can't locate object method \"%s\" via package \"%s\"".  It often means
3506 that a method requires a package that has not been loaded.
3507
3508 =item Perl_my_%s() not available
3509
3510 (F) Your platform has very uncommon byte-order and integer size,
3511 so it was not possible to set up some or all fixed-width byte-order
3512 conversion functions.  This is only a problem when you're using the
3513 '<' or '>' modifiers in (un)pack templates.  See L<perlfunc/pack>.
3514
3515 =item Perl %s required--this is only version %s, stopped
3516
3517 (F) The module in question uses features of a version of Perl more
3518 recent than the currently running version.  How long has it been since
3519 you upgraded, anyway?  See L<perlfunc/require>.
3520
3521 =item PERL_SH_DIR too long
3522
3523 (F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
3524 C<sh>-shell in.  See "PERL_SH_DIR" in L<perlos2>.
3525
3526 =item PERL_SIGNALS illegal: "%s"
3527
3528 See L<perlrun/PERL_SIGNALS> for legal values.
3529
3530 =item perl: warning: Setting locale failed.
3531
3532 (S) The whole warning message will look something like:
3533
3534         perl: warning: Setting locale failed.
3535         perl: warning: Please check that your locale settings:
3536                 LC_ALL = "En_US",
3537                 LANG = (unset)
3538             are supported and installed on your system.
3539         perl: warning: Falling back to the standard locale ("C").
3540
3541 Exactly what were the failed locale settings varies.  In the above the
3542 settings were that the LC_ALL was "En_US" and the LANG had no value.
3543 This error means that Perl detected that you and/or your operating
3544 system supplier and/or system administrator have set up the so-called
3545 locale system but Perl could not use those settings.  This was not
3546 dead serious, fortunately: there is a "default locale" called "C" that
3547 Perl can and will use, the script will be run.  Before you really fix
3548 the problem, however, you will get the same error message each time
3549 you run Perl.  How to really fix the problem can be found in
3550 L<perllocale> section B<LOCALE PROBLEMS>.
3551
3552 =item pid %x not a child
3553
3554 (W exec) A warning peculiar to VMS.  Waitpid() was asked to wait for a
3555 process which isn't a subprocess of the current process.  While this is
3556 fine from VMS' perspective, it's probably not what you intended.
3557
3558 =item 'P' must have an explicit size in unpack
3559
3560 (F) The unpack format P must have an explicit size, not "*".
3561
3562 =item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
3563
3564 (F) The class in the character class [: :] syntax is unknown.  The <-- HERE
3565 shows in the regular expression about where the problem was discovered.
3566 Note that the POSIX character classes do B<not> have the C<is> prefix
3567 the corresponding C interfaces have: in other words, it's C<[[:print:]]>,
3568 not C<isprint>.  See L<perlre>.
3569
3570 =item POSIX getpgrp can't take an argument
3571
3572 (F) Your system has POSIX getpgrp(), which takes no argument, unlike
3573 the BSD version, which takes a pid.
3574
3575 =item POSIX syntax [%s] belongs inside character classes in regex; marked by <-- HERE in m/%s/
3576
3577 (W regexp) The character class constructs [: :], [= =], and [. .]  go
3578 I<inside> character classes, the [] are part of the construct, for example:
3579 /[012[:alpha:]345]/.  Note that [= =] and [. .] are not currently
3580 implemented; they are simply placeholders for future extensions and will
3581 cause fatal errors.  The <-- HERE shows in the regular expression about
3582 where the problem was discovered.  See L<perlre>.
3583
3584 =item POSIX syntax [. .] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
3585
3586 (F regexp) Within regular expression character classes ([]) the syntax
3587 beginning with "[." and ending with ".]" is reserved for future extensions.
3588 If you need to represent those character sequences inside a regular
3589 expression character class, just quote the square brackets with the
3590 backslash: "\[." and ".\]".  The <-- HERE shows in the regular expression
3591 about where the problem was discovered.  See L<perlre>.
3592
3593 =item POSIX syntax [= =] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
3594
3595 (F) Within regular expression character classes ([]) the syntax beginning
3596 with "[=" and ending with "=]" is reserved for future extensions.  If you
3597 need to represent those character sequences inside a regular expression
3598 character class, just quote the square brackets with the backslash: "\[="
3599 and "=\]".  The <-- HERE shows in the regular expression about where the
3600 problem was discovered.  See L<perlre>.
3601
3602 =item Possible attempt to put comments in qw() list
3603
3604 (W qw) qw() lists contain items separated by whitespace; as with literal
3605 strings, comment characters are not ignored, but are instead treated as
3606 literal data.  (You may have used different delimiters than the
3607 parentheses shown here; braces are also frequently used.)
3608
3609 You probably wrote something like this:
3610
3611     @list = qw(
3612         a # a comment
3613         b # another comment
3614     );
3615
3616 when you should have written this:
3617
3618     @list = qw(
3619         a
3620         b
3621     );
3622
3623 If you really want comments, build your list the
3624 old-fashioned way, with quotes and commas:
3625
3626     @list = (
3627         'a',    # a comment
3628         'b',    # another comment
3629     );
3630
3631 =item Possible attempt to separate words with commas
3632
3633 (W qw) qw() lists contain items separated by whitespace; therefore
3634 commas aren't needed to separate the items.  (You may have used
3635 different delimiters than the parentheses shown here; braces are also
3636 frequently used.)
3637
3638 You probably wrote something like this:
3639
3640     qw! a, b, c !;
3641
3642 which puts literal commas into some of the list items.  Write it without
3643 commas if you don't want them to appear in your data:
3644
3645     qw! a b c !;
3646
3647 =item Possible memory corruption: %s overflowed 3rd argument
3648
3649 (F) An ioctl() or fcntl() returned more than Perl was bargaining for.
3650 Perl guesses a reasonable buffer size, but puts a sentinel byte at the
3651 end of the buffer just in case.  This sentinel byte got clobbered, and
3652 Perl assumes that memory is now corrupted.  See L<perlfunc/ioctl>.
3653
3654 =item Possible precedence problem on bitwise %c operator
3655
3656 (W precedence) Your program uses a bitwise logical operator in conjunction
3657 with a numeric comparison operator, like this :
3658
3659     if ($x & $y == 0) { ... }
3660
3661 This expression is actually equivalent to C<$x & ($y == 0)>, due to the
3662 higher precedence of C<==>. This is probably not what you want. (If you
3663 really meant to write this, disable the warning, or, better, put the
3664 parentheses explicitly and write C<$x & ($y == 0)>).
3665
3666 =item Possible unintended interpolation of %s in string
3667
3668 (W ambiguous) You said something like `@foo' in a double-quoted string
3669 but there was no array C<@foo> in scope at the time. If you wanted a
3670 literal @foo, then write it as \@foo; otherwise find out what happened
3671 to the array you apparently lost track of.
3672
3673 =item Possible unintended interpolation of $\ in regex
3674
3675 (W ambiguous) You said something like C<m/$\/> in a regex.
3676 The regex C<m/foo$\s+bar/m> translates to: match the word 'foo', the output
3677 record separator (see L<perlvar/$\>) and the letter 's' (one time or more)
3678 followed by the word 'bar'.
3679
3680 If this is what you intended then you can silence the warning by using 
3681 C<m/${\}/> (for example: C<m/foo${\}s+bar/>).
3682
3683 If instead you intended to match the word 'foo' at the end of the line
3684 followed by whitespace and the word 'bar' on the next line then you can use
3685 C<m/$(?)\/> (for example: C<m/foo$(?)\s+bar/>).
3686
3687 =item Precedence problem: open %s should be open(%s)
3688
3689 (S precedence) The old irregular construct
3690
3691     open FOO || die;
3692
3693 is now misinterpreted as
3694
3695     open(FOO || die);
3696
3697 because of the strict regularization of Perl 5's grammar into unary and
3698 list operators.  (The old open was a little of both.)  You must put
3699 parentheses around the filehandle, or use the new "or" operator instead
3700 of "||".
3701
3702 =item Premature end of script headers
3703
3704 See Server error.
3705
3706 =item printf() on closed filehandle %s
3707
3708 (W closed) The filehandle you're writing to got itself closed sometime
3709 before now.  Check your control flow.
3710
3711 =item print() on closed filehandle %s
3712
3713 (W closed) The filehandle you're printing on got itself closed sometime
3714 before now.  Check your control flow.
3715
3716 =item Process terminated by SIG%s
3717
3718 (W) This is a standard message issued by OS/2 applications, while *nix
3719 applications die in silence.  It is considered a feature of the OS/2
3720 port.  One can easily disable this by appropriate sighandlers, see
3721 L<perlipc/"Signals">.  See also "Process terminated by SIGTERM/SIGINT"
3722 in L<perlos2>.
3723
3724 =item Prototype after '%c' for %s : %s
3725
3726 (W illegalproto) A character follows % or @ in a prototype. This is useless,
3727 since % and @ gobble the rest of the subroutine arguments.
3728
3729 =item Prototype mismatch: %s vs %s
3730
3731 (S prototype) The subroutine being declared or defined had previously been
3732 declared or defined with a different function prototype.
3733
3734 =item Prototype not terminated
3735
3736 (F) You've omitted the closing parenthesis in a function prototype
3737 definition.
3738
3739 =item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
3740
3741 (F) You started a regular expression with a quantifier. Backslash it if you
3742 meant it literally. The <-- HERE shows in the regular expression about
3743 where the problem was discovered. See L<perlre>.
3744
3745 =item Quantifier in {,} bigger than %d in regex; marked by <-- HERE in m/%s/
3746
3747 (F) There is currently a limit to the size of the min and max values of the
3748 {min,max} construct. The <-- HERE shows in the regular expression about where
3749 the problem was discovered. See L<perlre>.
3750
3751 =item Quantifier unexpected on zero-length expression; marked by <-- HERE in m/%s/
3752
3753 (W regexp) You applied a regular expression quantifier in a place where
3754 it makes no sense, such as on a zero-width assertion.  Try putting the
3755 quantifier inside the assertion instead.  For example, the way to match
3756 "abc" provided that it is followed by three repetitions of "xyz" is
3757 C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
3758
3759 The <-- HERE shows in the regular expression about where the problem was
3760 discovered.
3761
3762 =item Range iterator outside integer range
3763
3764 (F) One (or both) of the numeric arguments to the range operator ".."
3765 are outside the range which can be represented by integers internally.
3766 One possible workaround is to force Perl to use magical string increment
3767 by prepending "0" to your numbers.
3768
3769 =item readdir() attempted on invalid dirhandle %s
3770
3771 (W io) The dirhandle you're reading from is either closed or not really
3772 a dirhandle.  Check your control flow.
3773
3774 =item readline() on closed filehandle %s
3775
3776 (W closed) The filehandle you're reading from got itself closed sometime
3777 before now.  Check your control flow.
3778
3779 =item read() on closed filehandle %s
3780
3781 (W closed) You tried to read from a closed filehandle.
3782
3783 =item read() on unopened filehandle %s
3784
3785 (W unopened) You tried to read from a filehandle that was never opened.
3786
3787 =item Reallocation too large: %lx
3788
3789 (F) You can't allocate more than 64K on an MS-DOS machine.
3790
3791 =item realloc() of freed memory ignored
3792
3793 (S malloc) An internal routine called realloc() on something that had
3794 already been freed.
3795
3796 =item Recompile perl with B<-D>DEBUGGING to use B<-D> switch
3797
3798 (F debugging) You can't use the B<-D> option unless the code to produce
3799 the desired output is compiled into Perl, which entails some overhead,
3800 which is why it's currently left out of your copy.
3801
3802 =item Recursive inheritance detected in package '%s'
3803
3804 (F) While calculating the method resolution order (MRO) of a package, Perl
3805 believes it found an infinite loop in the C<@ISA> hierarchy.  This is a
3806 crude check that bails out after 100 levels of C<@ISA> depth.
3807
3808 =item Recursive inheritance detected while looking for method %s
3809
3810 (F) More than 100 levels of inheritance were encountered while invoking
3811 a method.  Probably indicates an unintended loop in your inheritance
3812 hierarchy.
3813
3814 =item Reference found where even-sized list expected
3815
3816 (W misc) You gave a single reference where Perl was expecting a list
3817 with an even number of elements (for assignment to a hash). This usually
3818 means that you used the anon hash constructor when you meant to use
3819 parens. In any case, a hash requires key/value B<pairs>.
3820
3821     %hash = { one => 1, two => 2, };    # WRONG
3822     %hash = [ qw/ an anon array / ];    # WRONG
3823     %hash = ( one => 1, two => 2, );    # right
3824     %hash = qw( one 1 two 2 );                  # also fine
3825
3826 =item Reference is already weak
3827
3828 (W misc) You have attempted to weaken a reference that is already weak.
3829 Doing so has no effect.
3830
3831 =item Reference miscount in sv_replace()
3832
3833 (W internal) The internal sv_replace() function was handed a new SV with
3834 a reference count of other than 1.
3835
3836 =item Reference to invalid group 0
3837
3838 (F) You used C<\g0> or similar in a regular expression. You may refer to
3839 capturing parentheses only with strictly positive integers (normal
3840 backreferences) or with strictly negative integers (relative
3841 backreferences), but using 0 does not make sense.
3842
3843 =item Reference to nonexistent group in regex; marked by <-- HERE in m/%s/
3844
3845 (F) You used something like C<\7> in your regular expression, but there are
3846 not at least seven sets of capturing parentheses in the expression. If you
3847 wanted to have the character with ordinal 7 inserted into the regular expression,
3848 prepend zeroes to make it three digits long: C<\007>
3849
3850 The <-- HERE shows in the regular expression about where the problem was
3851 discovered.
3852
3853 =item Reference to nonexistent or unclosed group in regex; marked by <-- HERE in m/%s/
3854
3855 (F) You used something like C<\g{-7}> in your regular expression, but there are
3856 not at least seven sets of closed capturing parentheses in the expression before
3857 where the C<\g{-7}> was located.
3858
3859 The <-- HERE shows in the regular expression about where the problem was
3860 discovered.
3861
3862 =item Reference to nonexistent named group in regex; marked by <-- HERE in m/%s/
3863
3864 (F) You used something like C<\k'NAME'> or C<< \k<NAME> >> in your regular
3865 expression, but there is no corresponding named capturing parentheses such
3866 as C<(?'NAME'...)> or C<(?<NAME>...). Check if the name has been spelled
3867 correctly both in the backreference and the declaration.
3868
3869 The <-- HERE shows in the regular expression about where the problem was
3870 discovered.
3871
3872 =item (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in m/%s/
3873
3874 (F) You used something like C<(?(DEFINE)...|..)> which is illegal. The
3875 most likely cause of this error is that you left out a parenthesis inside
3876 of the C<....> part.
3877
3878 The <-- HERE shows in the regular expression about where the problem was
3879 discovered.
3880
3881 =item regexp memory corruption
3882
3883 (P) The regular expression engine got confused by what the regular
3884 expression compiler gave it.
3885
3886 =item Regexp out of space
3887
3888 (P) A "can't happen" error, because safemalloc() should have caught it
3889 earlier.
3890
3891 =item Repeated format line will never terminate (~~ and @# incompatible)
3892
3893 (F) Your format contains the ~~ repeat-until-blank sequence and a
3894 numeric field that will never go blank so that the repetition never
3895 terminates. You might use ^# instead.  See L<perlform>.
3896
3897 =item Replacement list is longer than search list
3898
3899 (W misc) You have used a replacement list that is longer than the
3900 search list. So the additional elements in the replacement list
3901 are meaningless.
3902
3903 =item Reversed %s= operator
3904
3905 (W syntax) You wrote your assignment operator backwards.  The = must
3906 always comes last, to avoid ambiguity with subsequent unary operators.
3907
3908 =item rewinddir() attempted on invalid dirhandle %s
3909
3910 (W io) The dirhandle you tried to do a rewinddir() on is either closed or not
3911 really a dirhandle.  Check your control flow.
3912
3913 =item Scalars leaked: %d
3914
3915 (P) Something went wrong in Perl's internal bookkeeping of scalars:
3916 not all scalar variables were deallocated by the time Perl exited.
3917 What this usually indicates is a memory leak, which is of course bad,
3918 especially if the Perl program is intended to be long-running.
3919
3920 =item Scalar value @%s[%s] better written as $%s[%s]
3921
3922 (W syntax) You've used an array slice (indicated by @) to select a
3923 single element of an array.  Generally it's better to ask for a scalar
3924 value (indicated by $).  The difference is that C<$foo[&bar]> always
3925 behaves like a scalar, both when assigning to it and when evaluating its
3926 argument, while C<@foo[&bar]> behaves like a list when you assign to it,
3927 and provides a list context to its subscript, which can do weird things
3928 if you're expecting only one subscript.
3929
3930 On the other hand, if you were actually hoping to treat the array
3931 element as a list, you need to look into how references work, because
3932 Perl will not magically convert between scalars and lists for you.  See
3933 L<perlref>.
3934
3935 =item Scalar value @%s{%s} better written as $%s{%s}
3936
3937 (W syntax) You've used a hash slice (indicated by @) to select a single
3938 element of a hash.  Generally it's better to ask for a scalar value
3939 (indicated by $).  The difference is that C<$foo{&bar}> always behaves
3940 like a scalar, both when assigning to it and when evaluating its
3941 argument, while C<@foo{&bar}> behaves like a list when you assign to it,
3942 and provides a list context to its subscript, which can do weird things
3943 if you're expecting only one subscript.
3944
3945 On the other hand, if you were actually hoping to treat the hash element
3946 as a list, you need to look into how references work, because Perl will
3947 not magically convert between scalars and lists for you.  See
3948 L<perlref>.
3949
3950 =item Search pattern not terminated
3951
3952 (F) The lexer couldn't find the final delimiter of a // or m{}
3953 construct.  Remember that bracketing delimiters count nesting level.
3954 Missing the leading C<$> from a variable C<$m> may cause this error.
3955
3956 Note that since Perl 5.9.0 a // can also be the I<defined-or>
3957 construct, not just the empty search pattern.  Therefore code written
3958 in Perl 5.9.0 or later that uses the // as the I<defined-or> can be
3959 misparsed by pre-5.9.0 Perls as a non-terminated search pattern.
3960
3961 =item Search pattern not terminated or ternary operator parsed as search pattern
3962
3963 (F) The lexer couldn't find the final delimiter of a C<?PATTERN?>
3964 construct.
3965
3966 The question mark is also used as part of the ternary operator (as in
3967 C<foo ? 0 : 1>) leading to some ambiguous constructions being wrongly
3968 parsed. One way to disambiguate the parsing is to put parentheses around
3969 the conditional expression, i.e. C<(foo) ? 0 : 1>.
3970
3971 =item %sseek() on unopened filehandle
3972
3973 (W unopened) You tried to use the seek() or sysseek() function on a
3974 filehandle that was either never opened or has since been closed.
3975
3976 =item seekdir() attempted on invalid dirhandle %s
3977
3978 (W io) The dirhandle you are doing a seekdir() on is either closed or not
3979 really a dirhandle.  Check your control flow.
3980
3981 =item select not implemented
3982
3983 (F) This machine doesn't implement the select() system call.
3984
3985 =item Self-ties of arrays and hashes are not supported
3986
3987 (F) Self-ties are of arrays and hashes are not supported in
3988 the current implementation.
3989
3990 =item Semicolon seems to be missing
3991
3992 (W semicolon) A nearby syntax error was probably caused by a missing
3993 semicolon, or possibly some other missing operator, such as a comma.
3994
3995 =item semi-panic: attempt to dup freed string
3996
3997 (S internal) The internal newSVsv() routine was called to duplicate a
3998 scalar that had previously been marked as free.
3999
4000 =item sem%s not implemented
4001
4002 (F) You don't have System V semaphore IPC on your system.
4003
4004 =item send() on closed socket %s
4005
4006 (W closed) The socket you're sending to got itself closed sometime
4007 before now.  Check your control flow.
4008
4009 =item Sequence (? incomplete in regex; marked by <-- HERE in m/%s/
4010
4011 (F) A regular expression ended with an incomplete extension (?. The <-- HERE
4012 shows in the regular expression about where the problem was discovered. See
4013 L<perlre>.
4014
4015 =item Sequence (?%s...) not implemented in regex; marked by <-- HERE in m/%s/
4016
4017 (F) A proposed regular expression extension has the character reserved but
4018 has not yet been written. The <-- HERE shows in the regular expression about
4019 where the problem was discovered. See L<perlre>.
4020
4021 =item Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/
4022
4023 (F) You used a regular expression extension that doesn't make sense.  The
4024 <-- HERE shows in the regular expression about where the problem was
4025 discovered.  See L<perlre>.
4026
4027 =item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/
4028
4029 (F) The regular expression expects a mandatory argument following the escape
4030 sequence and this has been omitted or incorrectly written.
4031
4032 =item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/
4033
4034 (F) A regular expression comment must be terminated by a closing
4035 parenthesis.  Embedded parentheses aren't allowed.  The <-- HERE shows in
4036 the regular expression about where the problem was discovered. See
4037 L<perlre>.
4038
4039 =item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
4040
4041 (F) If the contents of a (?{...}) clause contains braces, they must balance
4042 for Perl to properly detect the end of the clause. The <-- HERE shows in
4043 the regular expression about where the problem was discovered. See
4044 L<perlre>.
4045
4046 =item 500 Server error
4047
4048 See Server error.
4049
4050 =item Server error
4051
4052 This is the error message generally seen in a browser window when trying
4053 to run a CGI program (including SSI) over the web. The actual error text
4054 varies widely from server to server. The most frequently-seen variants
4055 are "500 Server error", "Method (something) not permitted", "Document
4056 contains no data", "Premature end of script headers", and "Did not
4057 produce a valid header".
4058
4059 B<This is a CGI error, not a Perl error>.
4060
4061 You need to make sure your script is executable, is accessible by the
4062 user CGI is running the script under (which is probably not the user
4063 account you tested it under), does not rely on any environment variables
4064 (like PATH) from the user it isn't running under, and isn't in a
4065 location where the CGI server can't find it, basically, more or less.
4066 Please see the following for more information:
4067
4068         http://www.perl.org/CGI_MetaFAQ.html
4069         http://www.htmlhelp.org/faq/cgifaq.html
4070         http://www.w3.org/Security/Faq/
4071
4072 You should also look at L<perlfaq9>.
4073
4074 =item setegid() not implemented
4075
4076 (F) You tried to assign to C<$)>, and your operating system doesn't
4077 support the setegid() system call (or equivalent), or at least Configure
4078 didn't think so.
4079
4080 =item seteuid() not implemented
4081
4082 (F) You tried to assign to C<< $> >>, and your operating system doesn't
4083 support the seteuid() system call (or equivalent), or at least Configure
4084 didn't think so.
4085
4086 =item setpgrp can't take arguments
4087
4088 (F) Your system has the setpgrp() from BSD 4.2, which takes no
4089 arguments, unlike POSIX setpgid(), which takes a process ID and process
4090 group ID.
4091
4092 =item setrgid() not implemented
4093
4094 (F) You tried to assign to C<$(>, and your operating system doesn't
4095 support the setrgid() system call (or equivalent), or at least Configure
4096 didn't think so.
4097
4098 =item setruid() not implemented
4099
4100 (F) You tried to assign to C<$<>, and your operating system doesn't
4101 support the setruid() system call (or equivalent), or at least Configure
4102 didn't think so.
4103
4104 =item setsockopt() on closed socket %s
4105
4106 (W closed) You tried to set a socket option on a closed socket.  Did you
4107 forget to check the return value of your socket() call?  See
4108 L<perlfunc/setsockopt>.
4109
4110 =item Setuid/gid script is writable by world
4111
4112 (F) The setuid emulator won't run a script that is writable by the
4113 world, because the world might have written on it already.
4114
4115 =item Setuid script not plain file
4116
4117 (F) The setuid emulator won't run a script that isn't read from a file,
4118 but from a socket, a pipe or another device.
4119
4120 =item shm%s not implemented
4121
4122 (F) You don't have System V shared memory IPC on your system.
4123
4124 =item !=~ should be !~
4125
4126 (W syntax) The non-matching operator is !~, not !=~.  !=~ will be
4127 interpreted as the != (numeric not equal) and ~ (1's complement)
4128 operators: probably not what you intended.
4129
4130 =item <> should be quotes
4131
4132 (F) You wrote C<< require <file> >> when you should have written
4133 C<require 'file'>.
4134
4135 =item /%s/ should probably be written as "%s"
4136
4137 (W syntax) You have used a pattern where Perl expected to find a string,
4138 as in the first argument to C<join>.  Perl will treat the true or false
4139 result of matching the pattern against $_ as the string, which is
4140 probably not what you had in mind.
4141
4142 =item shutdown() on closed socket %s
4143
4144 (W closed) You tried to do a shutdown on a closed socket.  Seems a bit
4145 superfluous.
4146
4147 =item SIG%s handler "%s" not defined
4148
4149 (W signal) The signal handler named in %SIG doesn't, in fact, exist.
4150 Perhaps you put it into the wrong package?
4151
4152 =item Smart matching a non-overloaded object breaks encapsulation
4153
4154 (F) You should not use the C<~~> operator on an object that does not
4155 overload it: Perl refuses to use the object's underlying structure for
4156 the smart match.
4157
4158 =item sort is now a reserved word
4159
4160 (F) An ancient error message that almost nobody ever runs into anymore.
4161 But before sort was a keyword, people sometimes used it as a filehandle.
4162
4163 =item Sort subroutine didn't return single value
4164
4165 (F) A sort comparison subroutine may not return a list value with more
4166 or less than one element.  See L<perlfunc/sort>.
4167
4168 =item splice() offset past end of array
4169
4170 (W misc) You attempted to specify an offset that was past the end of
4171 the array passed to splice(). Splicing will instead commence at the end
4172 of the array, rather than past it. If this isn't what you want, try
4173 explicitly pre-extending the array by assigning $#array = $offset. See
4174 L<perlfunc/splice>.
4175
4176 =item Split loop
4177
4178 (P) The split was looping infinitely.  (Obviously, a split shouldn't
4179 iterate more times than there are characters of input, which is what
4180 happened.) See L<perlfunc/split>.
4181
4182 =item Statement unlikely to be reached
4183
4184 (W exec) You did an exec() with some statement after it other than a
4185 die().  This is almost always an error, because exec() never returns
4186 unless there was a failure.  You probably wanted to use system()
4187 instead, which does return.  To suppress this warning, put the exec() in
4188 a block by itself.
4189
4190 =item stat() on unopened filehandle %s
4191
4192 (W unopened) You tried to use the stat() function on a filehandle that
4193 was either never opened or has since been closed.
4194
4195 =item Stub found while resolving method "%s" overloading "%s" in package "%s"
4196
4197 (P) Overloading resolution over @ISA tree may be broken by importation
4198 stubs.  Stubs should never be implicitly created, but explicit calls to
4199 C<can> may break this.
4200
4201 =item Subroutine %s redefined
4202
4203 (W redefine) You redefined a subroutine.  To suppress this warning, say
4204
4205     {
4206         no warnings 'redefine';
4207         eval "sub name { ... }";
4208     }
4209
4210 =item Substitution loop
4211
4212 (P) The substitution was looping infinitely.  (Obviously, a substitution
4213 shouldn't iterate more times than there are characters of input, which
4214 is what happened.)  See the discussion of substitution in
4215 L<perlop/"Regexp Quote-Like Operators">.
4216
4217 =item Substitution pattern not terminated
4218
4219 (F) The lexer couldn't find the interior delimiter of an s/// or s{}{}
4220 construct.  Remember that bracketing delimiters count nesting level.
4221 Missing the leading C<$> from variable C<$s> may cause this error.
4222
4223 =item Substitution replacement not terminated
4224
4225 (F) The lexer couldn't find the final delimiter of an s/// or s{}{}
4226 construct.  Remember that bracketing delimiters count nesting level.
4227 Missing the leading C<$> from variable C<$s> may cause this error.
4228
4229 =item substr outside of string
4230
4231 (W substr),(F) You tried to reference a substr() that pointed outside of
4232 a string.  That is, the absolute value of the offset was larger than the
4233 length of the string.  See L<perlfunc/substr>.  This warning is fatal if
4234 substr is used in an lvalue context (as the left hand side of an
4235 assignment or as a subroutine argument for example).
4236
4237 =item sv_upgrade from type %d down to type %d
4238
4239 (P) Perl tried to force the upgrade an SV to a type which was actually
4240 inferior to its current type.
4241
4242 =item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
4243
4244 (F) A (?(condition)if-clause|else-clause) construct can have at most two
4245 branches (the if-clause and the else-clause). If you want one or both to
4246 contain alternation, such as using C<this|that|other>, enclose it in
4247 clustering parentheses:
4248
4249     (?(condition)(?:this|that|other)|else-clause)
4250
4251 The <-- HERE shows in the regular expression about where the problem was
4252 discovered. See L<perlre>.
4253
4254 =item Switch condition not recognized in regex; marked by <-- HERE in m/%s/
4255
4256 (F) If the argument to the (?(...)if-clause|else-clause) construct is a
4257 number, it can be only a number. The <-- HERE shows in the regular expression
4258 about where the problem was discovered. See L<perlre>.
4259
4260 =item switching effective %s is not implemented
4261
4262 (F) While under the C<use filetest> pragma, we cannot switch the real
4263 and effective uids or gids.
4264
4265 =item %s syntax
4266
4267 (F) The final summary message when a C<perl -c> succeeds.
4268
4269 =item syntax error
4270
4271 (F) Probably means you had a syntax error.  Common reasons include:
4272
4273     A keyword is misspelled.
4274     A semicolon is missing.
4275     A comma is missing.
4276     An opening or closing parenthesis is missing.
4277     An opening or closing brace is missing.
4278     A closing quote is missing.
4279
4280 Often there will be another error message associated with the syntax
4281 error giving more information.  (Sometimes it helps to turn on B<-w>.)
4282 The error message itself often tells you where it was in the line when
4283 it decided to give up.  Sometimes the actual error is several tokens
4284 before this, because Perl is good at understanding random input.
4285 Occasionally the line number may be misleading, and once in a blue moon
4286 the only way to figure out what's triggering the error is to call
4287 C<perl -c> repeatedly, chopping away half the program each time to see
4288 if the error went away.  Sort of the cybernetic version of S<20
4289 questions>.
4290
4291 =item syntax error at line %d: `%s' unexpected
4292
4293 (A) You've accidentally run your script through the Bourne shell instead
4294 of Perl.  Check the #! line, or manually feed your script into Perl
4295 yourself.
4296
4297 =item syntax error in file %s at line %d, next 2 tokens "%s"
4298
4299 (F) This error is likely to occur if you run a perl5 script through
4300 a perl4 interpreter, especially if the next 2 tokens are "use strict"
4301 or "my $var" or "our $var".
4302
4303 =item sysread() on closed filehandle %s
4304
4305 (W closed) You tried to read from a closed filehandle.
4306
4307 =item sysread() on unopened filehandle %s
4308
4309 (W unopened) You tried to read from a filehandle that was never opened.
4310
4311 =item System V %s is not implemented on this machine
4312
4313 (F) You tried to do something with a function beginning with "sem",
4314 "shm", or "msg" but that System V IPC is not implemented in your
4315 machine.  In some machines the functionality can exist but be
4316 unconfigured.  Consult your system support.
4317
4318 =item syswrite() on closed filehandle %s
4319
4320 (W closed) The filehandle you're writing to got itself closed sometime
4321 before now.  Check your control flow.
4322
4323 =item C<-T> and C<-B> not implemented on filehandles
4324
4325 (F) Perl can't peek at the stdio buffer of filehandles when it doesn't
4326 know about your kind of stdio.  You'll have to use a filename instead.
4327
4328 =item Target of goto is too deeply nested
4329
4330 (F) You tried to use C<goto> to reach a label that was too deeply nested
4331 for Perl to reach.  Perl is doing you a favor by refusing.
4332
4333 =item tell() on unopened filehandle
4334
4335 (W unopened) You tried to use the tell() function on a filehandle that
4336 was either never opened or has since been closed.
4337
4338 =item telldir() attempted on invalid dirhandle %s
4339
4340 (W io) The dirhandle you tried to telldir() is either closed or not really
4341 a dirhandle.  Check your control flow.
4342
4343 =item That use of $[ is unsupported
4344
4345 (F) Assignment to C<$[> is now strictly circumscribed, and interpreted
4346 as a compiler directive.  You may say only one of
4347
4348     $[ = 0;
4349     $[ = 1;
4350     ...
4351     local $[ = 0;
4352     local $[ = 1;
4353     ...
4354
4355 This is to prevent the problem of one module changing the array base out
4356 from under another module inadvertently.  See L<perlvar/$[>.
4357
4358 =item The crypt() function is unimplemented due to excessive paranoia
4359
4360 (F) Configure couldn't find the crypt() function on your machine,
4361 probably because your vendor didn't supply it, probably because they
4362 think the U.S. Government thinks it's a secret, or at least that they
4363 will continue to pretend that it is.  And if you quote me on that, I
4364 will deny it.
4365
4366 =item The %s function is unimplemented
4367
4368 The function indicated isn't implemented on this architecture, according
4369 to the probings of Configure.
4370
4371 =item The stat preceding %s wasn't an lstat
4372
4373 (F) It makes no sense to test the current stat buffer for symbolic
4374 linkhood if the last stat that wrote to the stat buffer already went
4375 past the symlink to get to the real file.  Use an actual filename
4376 instead.
4377
4378 =item The 'unique' attribute may only be applied to 'our' variables
4379
4380 (F) This attribute was never supported on C<my> or C<sub> declarations.
4381
4382 =item This Perl can't reset CRTL environ elements (%s)
4383
4384 =item This Perl can't set CRTL environ elements (%s=%s)
4385
4386 (W internal) Warnings peculiar to VMS.  You tried to change or delete an
4387 element of the CRTL's internal environ array, but your copy of Perl
4388 wasn't built with a CRTL that contained the setenv() function.  You'll
4389 need to rebuild Perl with a CRTL that does, or redefine
4390 F<PERL_ENV_TABLES> (see L<perlvms>) so that the environ array isn't the
4391 target of the change to
4392 %ENV which produced the warning.
4393
4394 =item thread failed to start: %s
4395
4396 (W threads)(S) The entry point function of threads->create() failed for some reason.
4397
4398 =item times not implemented
4399
4400 (F) Your version of the C library apparently doesn't do times().  I
4401 suspect you're not running on Unix.
4402
4403 =item "-T" is on the #! line, it must also be used on the command line
4404
4405 (X) The #! line (or local equivalent) in a Perl script contains the
4406 B<-T> option (or the B<-t> option), but Perl was not invoked with B<-T> in its command line.
4407 This is an error because, by the time Perl discovers a B<-T> in a
4408 script, it's too late to properly taint everything from the environment.
4409 So Perl gives up.
4410
4411 If the Perl script is being executed as a command using the #!
4412 mechanism (or its local equivalent), this error can usually be fixed by
4413 editing the #! line so that the B<-%c> option is a part of Perl's first
4414 argument: e.g. change C<perl -n -%c> to C<perl -%c -n>.
4415
4416 If the Perl script is being executed as C<perl scriptname>, then the
4417 B<-%c> option must appear on the command line: C<perl -%c scriptname>.
4418
4419 =item To%s: illegal mapping '%s'
4420
4421 (F) You tried to define a customized To-mapping for lc(), lcfirst,
4422 uc(), or ucfirst() (or their string-inlined versions), but you
4423 specified an illegal mapping.
4424 See L<perlunicode/"User-Defined Character Properties">.
4425
4426 =item Too deeply nested ()-groups
4427
4428 (F) Your template contains ()-groups with a ridiculously deep nesting level.
4429
4430 =item Too few args to syscall
4431
4432 (F) There has to be at least one argument to syscall() to specify the
4433 system call to call, silly dilly.
4434
4435 =item Too late for "-%s" option
4436
4437 (X) The #! line (or local equivalent) in a Perl script contains the
4438 B<-M>, B<-m> or B<-C> option.
4439
4440 In the case of B<-M> and B<-m>, this is an error because those options are
4441 not intended for use inside scripts.  Use the C<use> pragma instead.
4442
4443 The B<-C> option only works if it is specified on the command line as well
4444 (with the same sequence of letters or numbers following). Either specify
4445 this option on the command line, or, if your system supports it, make your
4446 script executable and run it directly instead of passing it to perl. 
4447
4448 =item Too late to run %s block
4449
4450 (W void) A CHECK or INIT block is being defined during run time proper,
4451 when the opportunity to run them has already passed.  Perhaps you are
4452 loading a file with C<require> or C<do> when you should be using C<use>
4453 instead.  Or perhaps you should put the C<require> or C<do> inside a
4454 BEGIN block.
4455
4456 =item Too many args to syscall
4457
4458 (F) Perl supports a maximum of only 14 args to syscall().
4459
4460 =item Too many arguments for %s
4461
4462 (F) The function requires fewer arguments than you specified.
4463
4464 =item Too many )'s
4465
4466 (A) You've accidentally run your script through B<csh> instead of Perl.
4467 Check the #! line, or manually feed your script into Perl yourself.
4468
4469 =item Too many ('s
4470
4471 (A) You've accidentally run your script through B<csh> instead of Perl.
4472 Check the #! line, or manually feed your script into Perl yourself.
4473
4474 =item Trailing \ in regex m/%s/
4475
4476 (F) The regular expression ends with an unbackslashed backslash.
4477 Backslash it.   See L<perlre>.
4478
4479 =item Transliteration pattern not terminated
4480
4481 (F) The lexer couldn't find the interior delimiter of a tr/// or tr[][]
4482 or y/// or y[][] construct.  Missing the leading C<$> from variables
4483 C<$tr> or C<$y> may cause this error.
4484
4485 =item Transliteration replacement not terminated
4486
4487 (F) The lexer couldn't find the final delimiter of a tr///, tr[][],
4488 y/// or y[][] construct.
4489
4490 =item '%s' trapped by operation mask
4491
4492 (F) You tried to use an operator from a Safe compartment in which it's
4493 disallowed. See L<Safe>.
4494
4495 =item truncate not implemented
4496
4497 (F) Your machine doesn't implement a file truncation mechanism that
4498 Configure knows about.
4499
4500 =item Type of arg %d to %s must be %s (not %s)
4501
4502 (F) This function requires the argument in that position to be of a
4503 certain type.  Arrays must be @NAME or C<@{EXPR}>.  Hashes must be
4504 %NAME or C<%{EXPR}>.  No implicit dereferencing is allowed--use the
4505 {EXPR} forms as an explicit dereference.  See L<perlref>.
4506
4507 =item umask not implemented
4508
4509 (F) Your machine doesn't implement the umask function and you tried to
4510 use it to restrict permissions for yourself (EXPR & 0700).
4511
4512 =item Unable to create sub named "%s"
4513
4514 (F) You attempted to create or access a subroutine with an illegal name.
4515
4516 =item Unbalanced context: %d more PUSHes than POPs
4517
4518 (W internal) The exit code detected an internal inconsistency in how
4519 many execution contexts were entered and left.
4520
4521 =item Unbalanced saves: %d more saves than restores
4522
4523 (W internal) The exit code detected an internal inconsistency in how
4524 many values were temporarily localized.
4525
4526 =item Unbalanced scopes: %d more ENTERs than LEAVEs
4527
4528 (W internal) The exit code detected an internal inconsistency in how
4529 many blocks were entered and left.
4530
4531 =item Unbalanced tmps: %d more allocs than frees
4532
4533 (W internal) The exit code detected an internal inconsistency in how
4534 many mortal scalars were allocated and freed.
4535
4536 =item Undefined format "%s" called
4537
4538 (F) The format indicated doesn't seem to exist.  Perhaps it's really in
4539 another package?  See L<perlform>.
4540
4541 =item Undefined sort subroutine "%s" called
4542
4543 (F) The sort comparison routine specified doesn't seem to exist.
4544 Perhaps it's in a different package?  See L<perlfunc/sort>.
4545
4546 =item Undefined subroutine &%s called
4547
4548 (F) The subroutine indicated hasn't been defined, or if it was, it has
4549 since been undefined.
4550
4551 =item Undefined subroutine called
4552
4553 (F) The anonymous subroutine you're trying to call hasn't been defined,
4554 or if it was, it has since been undefined.
4555
4556 =item Undefined subroutine in sort
4557
4558 (F) The sort comparison routine specified is declared but doesn't seem
4559 to have been defined yet.  See L<perlfunc/sort>.
4560
4561 =item Undefined top format "%s" called
4562
4563 (F) The format indicated doesn't seem to exist.  Perhaps it's really in
4564 another package?  See L<perlform>.
4565
4566 =item Undefined value assigned to typeglob
4567
4568 (W misc) An undefined value was assigned to a typeglob, a la
4569 C<*foo = undef>.  This does nothing.  It's possible that you really mean
4570 C<undef *foo>.
4571
4572 =item %s: Undefined variable
4573
4574 (A) You've accidentally run your script through B<csh> instead of Perl.
4575 Check the #! line, or manually feed your script into Perl yourself.
4576
4577 =item unexec of %s into %s failed!
4578
4579 (F) The unexec() routine failed for some reason.  See your local FSF
4580 representative, who probably put it there in the first place.
4581
4582 =item Unicode non-character %s is illegal for interchange
4583
4584 (W utf8) Certain codepoints, such as U+FFFE and U+FFFF, are defined by the
4585 Unicode standard to be non-characters. Those are legal codepoints, but are
4586 reserved for internal use; so, applications shouldn't attempt to exchange
4587 them.  In some cases, this message is also given if you use a codepoint that
4588 isn't in Unicode--that is it is above the legal maximum of U+10FFFF.  These
4589 aren't legal at all in Unicode, so they are illegal for interchange, but can be
4590 used internally in a Perl program.  If you know what you are doing you can turn
4591 off this warning by C<no warnings 'utf8';>.
4592
4593 =item Unknown BYTEORDER
4594
4595 (F) There are no byte-swapping functions for a machine with this byte
4596 order.
4597
4598 =item Unknown open() mode '%s'
4599
4600 (F) The second argument of 3-argument open() is not among the list
4601 of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
4602 C<< +> >>, C<<< +>> >>>, C<-|>, C<|->, C<< <& >>, C<< >& >>.
4603
4604 =item Unknown PerlIO layer "%s"
4605
4606 (W layer) An attempt was made to push an unknown layer onto the Perl I/O
4607 system.  (Layers take care of transforming data between external and
4608 internal representations.)  Note that some layers, such as C<mmap>,
4609 are not supported in all environments.  If your program didn't
4610 explicitly request the failing operation, it may be the result of the
4611 value of the environment variable PERLIO.
4612
4613 =item Unknown process %x sent message to prime_env_iter: %s
4614
4615 (P) An error peculiar to VMS.  Perl was reading values for %ENV before
4616 iterating over it, and someone else stuck a message in the stream of
4617 data Perl expected.  Someone's very confused, or perhaps trying to
4618 subvert Perl's population of %ENV for nefarious purposes.
4619
4620 =item Unknown "re" subpragma '%s' (known ones are: %s)
4621
4622 You tried to use an unknown subpragma of the "re" pragma.
4623
4624 =item Unknown switch condition (?(%.2s in regex; marked by <-- HERE in m/%s/
4625
4626 (F) The condition part of a (?(condition)if-clause|else-clause) construct
4627 is not known. The condition may be lookahead or lookbehind (the condition
4628 is true if the lookahead or lookbehind is true), a (?{...})  construct (the
4629 condition is true if the code evaluates to a true value), or a number (the
4630 condition is true if the set of capturing parentheses named by the number
4631 matched).
4632
4633 The <-- HERE shows in the regular expression about where the problem was
4634 discovered.  See L<perlre>.
4635
4636 =item Unknown Unicode option letter '%c'
4637
4638 You specified an unknown Unicode option.  See L<perlrun> documentation
4639 of the C<-C> switch for the list of known options.
4640
4641 =item Unknown Unicode option value %x
4642
4643 You specified an unknown Unicode option.  See L<perlrun> documentation
4644 of the C<-C> switch for the list of known options.
4645
4646 =item Unknown warnings category '%s'
4647
4648 (F) An error issued by the C<warnings> pragma. You specified a warnings
4649 category that is unknown to perl at this point.
4650
4651 Note that if you want to enable a warnings category registered by a module
4652 (e.g. C<use warnings 'File::Find'>), you must have imported this module
4653
4654 =item Unknown verb pattern '%s' in regex; marked by <-- HERE in m/%s/
4655
4656 (F) You either made a typo or have incorrectly put a C<*> quantifier
4657 after an open brace in your pattern.  Check the pattern and review
4658 L<perlre> for details on legal verb patterns.
4659
4660 first.
4661
4662 =item unmatched [ in regex; marked by <-- HERE in m/%s/
4663
4664 (F) The brackets around a character class must match. If you wish to
4665 include a closing bracket in a character class, backslash it or put it
4666 first. The <-- HERE shows in the regular expression about where the problem
4667 was discovered. See L<perlre>.
4668
4669 =item unmatched ( in regex; marked by <-- HERE in m/%s/
4670
4671 (F) Unbackslashed parentheses must always be balanced in regular
4672 expressions. If you're a vi user, the % key is valuable for finding the
4673 matching parenthesis. The <-- HERE shows in the regular expression about
4674 where the problem was discovered. See L<perlre>.
4675
4676 =item Unmatched right %s bracket
4677
4678 (F) The lexer counted more closing curly or square brackets than opening
4679 ones, so you're probably missing a matching opening bracket.  As a
4680 general rule, you'll find the missing one (so to speak) near the place
4681 you were last editing.
4682
4683 =item Unquoted string "%s" may clash with future reserved word
4684
4685 (W reserved) You used a bareword that might someday be claimed as a
4686 reserved word.  It's best to put such a word in quotes, or capitalize it
4687 somehow, or insert an underbar into it.  You might also declare it as a
4688 subroutine.
4689
4690 =item Unrecognized character %s; marked by <-- HERE after %s near column %d
4691
4692 (F) The Perl parser has no idea what to do with the specified character
4693 in your Perl script (or eval) near the specified column.  Perhaps you tried 
4694 to run a compressed script, a binary program, or a directory as a Perl program.
4695
4696 =item Unrecognized escape \%c in character class passed through in regex; marked by <-- HERE in m/%s/
4697
4698 (W regexp) You used a backslash-character combination which is not
4699 recognized by Perl inside character classes.  The character was
4700 understood literally, but this may change in a future version of Perl.
4701 The <-- HERE shows in the regular expression about where the
4702 escape was discovered.
4703
4704 =item Unrecognized escape \%c passed through
4705
4706 (W misc) You used a backslash-character combination which is not
4707 recognized by Perl.  The character was understood literally, but this may
4708 change in a future version of Perl.
4709
4710 =item Unrecognized escape \%c 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.  The character was understood literally, but this may
4714 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 signal name "%s"
4719
4720 (F) You specified a signal name to the kill() function that was not
4721 recognized.  Say C<kill -l> in your shell to see the valid signal names
4722 on your system.
4723
4724 =item Unrecognized switch: -%s  (-h will show valid options)
4725
4726 (F) You specified an illegal option to Perl.  Don't do that.  (If you
4727 think you didn't do that, check the #! line to see if it's supplying the
4728 bad switch on your behalf.)
4729
4730 =item Unsuccessful %s on filename containing newline
4731
4732 (W newline) A file operation was attempted on a filename, and that
4733 operation failed, PROBABLY because the filename contained a newline,
4734 PROBABLY because you forgot to chomp() it off.  See L<perlfunc/chomp>.
4735
4736 =item Unsupported directory function "%s" called
4737
4738 (F) Your machine doesn't support opendir() and readdir().
4739
4740 =item Unsupported function %s
4741
4742 (F) This machine doesn't implement the indicated function, apparently.
4743 At least, Configure doesn't think so.
4744
4745 =item Unsupported function fork
4746
4747 (F) Your version of executable does not support forking.
4748
4749 Note that under some systems, like OS/2, there may be different flavors
4750 of Perl executables, some of which may support fork, some not. Try
4751 changing the name you call Perl by to C<perl_>, C<perl__>, and so on.
4752
4753 =item Unsupported script encoding %s
4754
4755 (F) Your program file begins with a Unicode Byte Order Mark (BOM) which
4756 declares it to be in a Unicode encoding that Perl cannot read.
4757
4758 =item Unsupported socket function "%s" called
4759
4760 (F) Your machine doesn't support the Berkeley socket mechanism, or at
4761 least that's what Configure thought.
4762
4763 =item Unterminated attribute list
4764
4765 (F) The lexer found something other than a simple identifier at the
4766 start of an attribute, and it wasn't a semicolon or the start of a
4767 block.  Perhaps you terminated the parameter list of the previous
4768 attribute too soon.  See L<attributes>.
4769
4770 =item Unterminated attribute parameter in attribute list
4771
4772 (F) The lexer saw an opening (left) parenthesis character while parsing
4773 an attribute list, but the matching closing (right) parenthesis
4774 character was not found.  You may need to add (or remove) a backslash
4775 character to get your parentheses to balance.  See L<attributes>.
4776
4777 =item Unterminated compressed integer
4778
4779 (F) An argument to unpack("w",...) was incompatible with the BER
4780 compressed integer format and could not be converted to an integer.
4781 See L<perlfunc/pack>.
4782
4783 =item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/
4784
4785 (F) You used a pattern of the form C<(*VERB)> but did not terminate
4786 the pattern with a C<)>. Fix the pattern and retry.
4787
4788 =item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/
4789
4790 (F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate
4791 the pattern with a C<)>. Fix the pattern and retry.
4792
4793 =item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/
4794
4795 (F) You missed a close brace on a \g{..} pattern (group reference) in
4796 a regular expression. Fix the pattern and retry.
4797
4798 =item Unterminated <> operator
4799
4800 (F) The lexer saw a left angle bracket in a place where it was expecting
4801 a term, so it's looking for the corresponding right angle bracket, and
4802 not finding it.  Chances are you left some needed parentheses out
4803 earlier in the line, and you really meant a "less than".
4804
4805 =item untie attempted while %d inner references still exist
4806
4807 (W untie) A copy of the object returned from C<tie> (or C<tied>) was
4808 still valid when C<untie> was called.
4809
4810 =item Usage: POSIX::%s(%s)
4811
4812 (F) You called a POSIX function with incorrect arguments.
4813 See L<POSIX/FUNCTIONS> for more information.
4814
4815 =item Usage: Win32::%s(%s)
4816
4817 (F) You called a Win32 function with incorrect arguments.
4818 See L<Win32> for more information.
4819
4820 =item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/
4821
4822 (W regexp) You have used an internal modifier such as (?-o) that has no
4823 meaning unless removed from the entire regexp:
4824
4825     if ($string =~ /(?-o)$pattern/o) { ... }
4826
4827 must be written as
4828
4829     if ($string =~ /$pattern/) { ... }
4830
4831 The <-- HERE shows in the regular expression about
4832 where the problem was discovered. See L<perlre>.
4833
4834 =item Useless localization of %s
4835
4836 (W syntax) The localization of lvalues such as C<local($x=10)> is
4837 legal, but in fact the local() currently has no effect. This may change at
4838 some point in the future, but in the meantime such code is discouraged.
4839
4840 =item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
4841
4842 (W regexp) You have used an internal modifier such as (?o) that has no
4843 meaning unless applied to the entire regexp:
4844
4845     if ($string =~ /(?o)$pattern/) { ... }
4846
4847 must be written as
4848
4849     if ($string =~ /$pattern/o) { ... }
4850
4851 The <-- HERE shows in the regular expression about