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