This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
improved docs on the warn_uninit diagnostic (from David Glasser
[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 (optional).
12     (S) A severe warning (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 Default 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 '!' allowed only after types %s
58
59 (F) The '!' is allowed in pack() and unpack() only after certain types.
60 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 by declaring the subroutine
76 to be an object method (see L<perlsub/"Subroutine Attributes"> or
77 L<attributes>).
78
79 =item Ambiguous use of %s resolved as %s
80
81 (W ambiguous)(S) You said something that may not be interpreted the way
82 you thought.  Normally it's pretty easy to disambiguate it by supplying
83 a missing quote, operator, parenthesis pair or declaration.
84
85 =item '|' and '<' may not both be specified on command line
86
87 (F) An error peculiar to VMS.  Perl does its own command line
88 redirection, and found that STDIN was a pipe, and that you also tried to
89 redirect STDIN using '<'.  Only one STDIN stream to a customer, please.
90
91 =item '|' and '>' may not both be specified on command line
92
93 (F) An error peculiar to VMS.  Perl does its own command line
94 redirection, and thinks you tried to redirect stdout both to a file and
95 into a pipe to another command.  You need to choose one or the other,
96 though nothing's stopping you from piping into a program or Perl script
97 which 'splits' output into two streams, such as
98
99     open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!";
100     while (<STDIN>) {
101         print;
102         print OUT;
103     }
104     close OUT;
105
106 =item Applying %s to %s will act on scalar(%s)
107
108 (W misc) The pattern match (//), substitution (s///), and
109 transliteration (tr///) operators work on scalar values.  If you apply
110 one of them to an array or a hash, it will convert the array or hash to
111 a scalar value -- the length of an array, or the population info of a
112 hash -- and then work on that scalar value.  This is probably not what
113 you meant to do.  See L<perlfunc/grep> and L<perlfunc/map> for
114 alternatives.
115
116 =item Args must match #! line
117
118 (F) The setuid emulator requires that the arguments Perl was invoked
119 with match the arguments specified on the #! line.  Since some systems
120 impose a one-argument limit on the #! line, try combining switches;
121 for example, turn C<-w -U> into C<-wU>.
122
123 =item Arg too short for msgsnd
124
125 (F) msgsnd() requires a string at least as long as sizeof(long).
126
127 =item %s argument is not a HASH or ARRAY element
128
129 (F) The argument to exists() must be a hash or array element, such as:
130
131     $foo{$bar}
132     $ref->{"susie"}[12]
133
134 =item %s argument is not a HASH or ARRAY element or slice
135
136 (F) The argument to delete() must be either a hash or array element,
137 such as:
138
139     $foo{$bar}
140     $ref->{"susie"}[12]
141
142 or a hash or array slice, such as:
143
144     @foo[$bar, $baz, $xyzzy]
145     @{$ref->[12]}{"susie", "queue"}
146
147 =item %s argument is not a subroutine name
148
149 (F) The argument to exists() for C<exists &sub> must be a subroutine
150 name, and not a subroutine call.  C<exists &sub()> will generate this
151 error.
152
153 =item Argument "%s" isn't numeric%s
154
155 (W numeric) The indicated string was fed as an argument to an operator
156 that expected a numeric value instead.  If you're fortunate the message
157 will identify which operator was so unfortunate.
158
159 =item Array @%s missing the @ in argument %d of %s()
160
161 (D deprecated) Really old Perl let you omit the @ on array names in some
162 spots.  This is now heavily deprecated.
163
164 =item assertion botched: %s
165
166 (P) The malloc package that comes with Perl had an internal failure.
167
168 =item Assertion failed: file "%s"
169
170 (P) A general assertion failed.  The file in question must be examined.
171
172 =item Assignment to both a list and a scalar
173
174 (F) If you assign to a conditional operator, the 2nd and 3rd arguments
175 must either both be scalars or both be lists.  Otherwise Perl won't
176 know which context to supply to the right side.
177
178 =item Attempt to free non-arena SV: 0x%lx
179
180 (P internal) All SV objects are supposed to be allocated from arenas
181 that will be garbage collected on exit.  An SV was discovered to be
182 outside any of those arenas.
183
184 =item Attempt to free nonexistent shared string
185
186 (P internal) Perl maintains a reference counted internal table of
187 strings to optimize the storage and access of hash keys and other
188 strings.  This indicates someone tried to decrement the reference count
189 of a string that can no longer be found in the table.
190
191 =item Attempt to free temp prematurely
192
193 (W debugging) Mortalized values are supposed to be freed by the
194 free_tmps() routine.  This indicates that something else is freeing the
195 SV before the free_tmps() routine gets a chance, which means that the
196 free_tmps() routine will be freeing an unreferenced scalar when it does
197 try to free it.
198
199 =item Attempt to free unreferenced glob pointers
200
201 (P internal) The reference counts got screwed up on symbol aliases.
202
203 =item Attempt to free unreferenced scalar
204
205 (W internal) Perl went to decrement the reference count of a scalar to
206 see if it would go to 0, and discovered that it had already gone to 0
207 earlier, and should have been freed, and in fact, probably was freed.
208 This could indicate that SvREFCNT_dec() was called too many times, or
209 that SvREFCNT_inc() was called too few times, or that the SV was
210 mortalized when it shouldn't have been, or that memory has been
211 corrupted.
212
213 =item Attempt to join self
214
215 (F) You tried to join a thread from within itself, which is an
216 impossible task.  You may be joining the wrong thread, or you may need
217 to move the join() to some other thread.
218
219 =item Attempt to pack pointer to temporary value
220
221 (W pack) You tried to pass a temporary value (like the result of a
222 function, or a computed expression) to the "p" pack() template.  This
223 means the result contains a pointer to a location that could become
224 invalid anytime, even before the end of the current statement.  Use
225 literals or global values as arguments to the "p" pack() template to
226 avoid this warning.
227
228 =item Attempt to use reference as lvalue in substr
229
230 (W substr) You supplied a reference as the first argument to substr()
231 used as an lvalue, which is pretty strange.  Perhaps you forgot to
232 dereference it first.  See L<perlfunc/substr>.
233
234 =item Bad arg length for %s, is %d, should be %d
235
236 (F) You passed a buffer of the wrong size to one of msgctl(), semctl()
237 or shmctl().  In C parlance, the correct sizes are, respectively,
238 S<sizeof(struct msqid_ds *)>, S<sizeof(struct semid_ds *)>, and
239 S<sizeof(struct shmid_ds *)>.
240
241 =item Bad evalled substitution pattern
242
243 (F) You've used the /e switch to evaluate the replacement for a
244 substitution, but perl found a syntax error in the code to evaluate,
245 most likely an unexpected right brace '}'.
246
247 =item Bad filehandle: %s
248
249 (F) A symbol was passed to something wanting a filehandle, but the
250 symbol has no filehandle associated with it.  Perhaps you didn't do an
251 open(), or did it in another package.
252
253 =item Bad free() ignored
254
255 (S malloc) An internal routine called free() on something that had never
256 been malloc()ed in the first place. Mandatory, but can be disabled by
257 setting environment variable C<PERL_BADFREE> to 1.
258
259 This message can be quite often seen with DB_File on systems with "hard"
260 dynamic linking, like C<AIX> and C<OS/2>. It is a bug of C<Berkeley DB>
261 which is left unnoticed if C<DB> uses I<forgiving> system malloc().
262
263 =item Bad hash
264
265 (P) One of the internal hash routines was passed a null HV pointer.
266
267 =item Bad index while coercing array into hash
268
269 (F) The index looked up in the hash found as the 0'th element of a
270 pseudo-hash is not legal.  Index values must be at 1 or greater.
271 See L<perlref>.
272
273 =item Badly placed ()'s
274
275 (A) You've accidentally run your script through B<csh> instead
276 of Perl.  Check the #! line, or manually feed your script into
277 Perl yourself.
278
279 =item Bad name after %s::
280
281 (F) You started to name a symbol by using a package prefix, and then
282 didn't finish the symbol.  In particular, you can't interpolate outside
283 of quotes, so
284
285     $var = 'myvar';
286     $sym = mypack::$var;
287
288 is not the same as
289
290     $var = 'myvar';
291     $sym = "mypack::$var";
292
293 =item Bad realloc() ignored
294
295 (S malloc) An internal routine called realloc() on something that had
296 never been malloc()ed in the first place. Mandatory, but can be disabled
297 by setting environment variable C<PERL_BADFREE> to 1.
298
299 =item Bad symbol for array
300
301 (P) An internal request asked to add an array entry to something that
302 wasn't a symbol table entry.
303
304 =item Bad symbol for filehandle
305
306 (P) An internal request asked to add a filehandle entry to something
307 that wasn't a symbol table entry.
308
309 =item Bad symbol for hash
310
311 (P) An internal request asked to add a hash entry to something that
312 wasn't a symbol table entry.
313
314 =item Bareword found in conditional
315
316 (W bareword) The compiler found a bareword where it expected a
317 conditional, which often indicates that an || or && was parsed as part
318 of the last argument of the previous construct, for example:
319
320     open FOO || die;
321
322 It may also indicate a misspelled constant that has been interpreted as
323 a bareword:
324
325     use constant TYPO => 1;
326     if (TYOP) { print "foo" }
327
328 The C<strict> pragma is useful in avoiding such errors.
329
330 =item Bareword "%s" not allowed while "strict subs" in use
331
332 (F) With "strict subs" in use, a bareword is only allowed as a
333 subroutine identifier, in curly brackets or to the left of the "=>"
334 symbol.  Perhaps you need to predeclare a subroutine?
335
336 =item Bareword "%s" refers to nonexistent package
337
338 (W bareword) You used a qualified bareword of the form C<Foo::>, but the
339 compiler saw no other uses of that namespace before that point.  Perhaps
340 you need to predeclare a package?
341
342 =item BEGIN failed--compilation aborted
343
344 (F) An untrapped exception was raised while executing a BEGIN
345 subroutine.  Compilation stops immediately and the interpreter is
346 exited.
347
348 =item BEGIN not safe after errors--compilation aborted
349
350 (F) Perl found a C<BEGIN {}> subroutine (or a C<use> directive, which
351 implies a C<BEGIN {}>) after one or more compilation errors had already
352 occurred.  Since the intended environment for the C<BEGIN {}> could not
353 be guaranteed (due to the errors), and since subsequent code likely
354 depends on its correct operation, Perl just gave up.
355
356 =item \1 better written as $1
357
358 (W syntax) Outside of patterns, backreferences live on as variables.
359 The use of backslashes is grandfathered on the right-hand side of a
360 substitution, but stylistically it's better to use the variable form
361 because other Perl programmers will expect it, and it works better if
362 there are more than 9 backreferences.
363
364 =item Binary number > 0b11111111111111111111111111111111 non-portable
365
366 (W portable) The binary number you specified is larger than 2**32-1
367 (4294967295) and therefore non-portable between systems.  See
368 L<perlport> for more on portability concerns.
369
370 =item bind() on closed socket %s
371
372 (W closed) You tried to do a bind on a closed socket.  Did you forget to
373 check the return value of your socket() call?  See L<perlfunc/bind>.
374
375 =item Bit vector size > 32 non-portable
376
377 (W portable) Using bit vector sizes larger than 32 is non-portable.
378
379 =item Bizarre copy of %s in %s
380
381 (P) Perl detected an attempt to copy an internal value that is not
382 copiable.
383
384 =item B<-P> not allowed for setuid/setgid script
385
386 (F) The script would have to be opened by the C preprocessor by name,
387 which provides a race condition that breaks security.
388
389 =item Buffer overflow in prime_env_iter: %s
390
391 (W internal) A warning peculiar to VMS.  While Perl was preparing to
392 iterate over %ENV, it encountered a logical name or symbol definition
393 which was too long, so it was truncated to the string shown.
394
395 =item Callback called exit
396
397 (F) A subroutine invoked from an external package via call_sv()
398 exited by calling exit.
399
400 =item %s() called too early to check prototype
401
402 (W prototype) You've called a function that has a prototype before the
403 parser saw a definition or declaration for it, and Perl could not check
404 that the call conforms to the prototype.  You need to either add an
405 early prototype declaration for the subroutine in question, or move the
406 subroutine definition ahead of the call to get proper prototype
407 checking.  Alternatively, if you are certain that you're calling the
408 function correctly, you may put an ampersand before the name to avoid
409 the warning.  See L<perlsub>.
410
411 =item / cannot take a count
412
413 (F) You had an unpack template indicating a counted-length string, but
414 you have also specified an explicit size for the string.  See
415 L<perlfunc/pack>.
416
417 =item Can't bless non-reference value
418
419 (F) Only hard references may be blessed.  This is how Perl "enforces"
420 encapsulation of objects.  See L<perlobj>.
421
422 =item Can't break at that line
423
424 (S internal) A warning intended to only be printed while running within
425 the debugger, indicating the line number specified wasn't the location
426 of a statement that could be stopped at.
427
428 =item Can't call method "%s" in empty package "%s"
429
430 (F) You called a method correctly, and it correctly indicated a package
431 functioning as a class, but that package doesn't have ANYTHING defined
432 in it, let alone methods.  See L<perlobj>.
433
434 =item Can't call method "%s" on an undefined value
435
436 (F) You used the syntax of a method call, but the slot filled by the
437 object reference or package name contains an undefined value.  Something
438 like this will reproduce the error:
439
440     $BADREF = undef;
441     process $BADREF 1,2,3;
442     $BADREF->process(1,2,3);
443
444 =item Can't call method "%s" on unblessed reference
445
446 (F) A method call must know in what package it's supposed to run.  It
447 ordinarily finds this out from the object reference you supply, but you
448 didn't supply an object reference in this case.  A reference isn't an
449 object reference until it has been blessed.  See L<perlobj>.
450
451 =item Can't call method "%s" without a package or object reference
452
453 (F) You used the syntax of a method call, but the slot filled by the
454 object reference or package name contains an expression that returns a
455 defined value which is neither an object reference nor a package name.
456 Something like this will reproduce the error:
457
458     $BADREF = 42;
459     process $BADREF 1,2,3;
460     $BADREF->process(1,2,3);
461
462 =item Can't chdir to %s
463
464 (F) You called C<perl -x/foo/bar>, but C</foo/bar> is not a directory
465 that you can chdir to, possibly because it doesn't exist.
466
467 =item Can't check filesystem of script "%s" for nosuid
468
469 (P) For some reason you can't check the filesystem of the script for
470 nosuid.
471
472 =item Can't coerce array into hash
473
474 (F) You used an array where a hash was expected, but the array has no
475 information on how to map from keys to array indices.  You can do that
476 only with arrays that have a hash reference at index 0.
477
478 =item Can't coerce %s to integer in %s
479
480 (F) Certain types of SVs, in particular real symbol table entries
481 (typeglobs), can't be forced to stop being what they are.  So you can't
482 say things like:
483
484     *foo += 1;
485
486 You CAN say
487
488     $foo = *foo;
489     $foo += 1;
490
491 but then $foo no longer contains a glob.
492
493 =item Can't coerce %s to number in %s
494
495 (F) Certain types of SVs, in particular real symbol table entries
496 (typeglobs), can't be forced to stop being what they are.
497
498 =item Can't coerce %s to string in %s
499
500 (F) Certain types of SVs, in particular real symbol table entries
501 (typeglobs), can't be forced to stop being what they are.
502
503 =item Can't create pipe mailbox
504
505 (P) An error peculiar to VMS.  The process is suffering from exhausted
506 quotas or other plumbing problems.
507
508 =item Can't declare class for non-scalar %s in "%s"
509
510 (S) Currently, only scalar variables can declared with a specific class
511 qualifier in a "my" or "our" declaration.  The semantics may be extended
512 for other types of variables in future.
513
514 =item Can't declare %s in "%s"
515
516 (F) Only scalar, array, and hash variables may be declared as "my" or
517 "our" variables.  They must have ordinary identifiers as names.
518
519 =item Can't do inplace edit: %s is not a regular file
520
521 (S inplace) You tried to use the B<-i> switch on a special file, such as
522 a file in /dev, or a FIFO.  The file was ignored.
523
524 =item Can't do inplace edit on %s: %s
525
526 (S inplace) The creation of the new file failed for the indicated
527 reason.
528
529 =item Can't do inplace edit without backup
530
531 (F) You're on a system such as MS-DOS that gets confused if you try
532 reading from a deleted (but still opened) file.  You have to say
533 C<-i.bak>, or some such.
534
535 =item Can't do inplace edit: %s would not be unique
536
537 (S inplace) Your filesystem does not support filenames longer than 14
538 characters and Perl was unable to create a unique filename during
539 inplace editing with the B<-i> switch.  The file was ignored.
540
541 =item Can't do {n,m} with n > m
542
543 (F) Minima must be less than or equal to maxima.  If you really want
544 your regexp to match something 0 times, just put {0}.  See L<perlre>.
545
546 =item Can't do setegid!
547
548 (P) The setegid() call failed for some reason in the setuid emulator of
549 suidperl.
550
551 =item Can't do seteuid!
552
553 (P) The setuid emulator of suidperl failed for some reason.
554
555 =item Can't do setuid
556
557 (F) This typically means that ordinary perl tried to exec suidperl to do
558 setuid emulation, but couldn't exec it.  It looks for a name of the form
559 sperl5.000 in the same directory that the perl executable resides under
560 the name perl5.000, typically /usr/local/bin on Unix machines.  If the
561 file is there, check the execute permissions.  If it isn't, ask your
562 sysadmin why he and/or she removed it.
563
564 =item Can't do waitpid with flags
565
566 (F) This machine doesn't have either waitpid() or wait4(), so only
567 waitpid() without flags is emulated.
568
569 =item Can't emulate -%s on #! line
570
571 (F) The #! line specifies a switch that doesn't make sense at this
572 point.  For example, it'd be kind of silly to put a B<-x> on the #!
573 line.
574
575 =item Can't exec "%s": %s
576
577 (W exec) An system(), exec(), or piped open call could not execute the
578 named program for the indicated reason.  Typical reasons include: the
579 permissions were wrong on the file, the file wasn't found in
580 C<$ENV{PATH}>, the executable in question was compiled for another
581 architecture, or the #! line in a script points to an interpreter that
582 can't be run for similar reasons.  (Or maybe your system doesn't support
583 #! at all.)
584
585 =item Can't exec %s
586
587 (F) Perl was trying to execute the indicated program for you because
588 that's what the #! line said.  If that's not what you wanted, you may
589 need to mention "perl" on the #! line somewhere.
590
591 =item Can't execute %s
592
593 (F) You used the B<-S> switch, but the copies of the script to execute
594 found in the PATH did not have correct permissions.
595
596 =item Can't find an opnumber for "%s"
597
598 (F) A string of a form C<CORE::word> was given to prototype(), but there
599 is no builtin with the name C<word>.
600
601 =item Can't find label %s
602
603 (F) You said to goto a label that isn't mentioned anywhere that it's
604 possible for us to go to.  See L<perlfunc/goto>.
605
606 =item Can't find %s on PATH
607
608 (F) You used the B<-S> switch, but the script to execute could not be
609 found in the PATH.
610
611 =item Can't find %s on PATH, '.' not in PATH
612
613 (F) You used the B<-S> switch, but the script to execute could not be
614 found in the PATH, or at least not with the correct permissions.  The
615 script exists in the current directory, but PATH prohibits running it.
616
617 =item Can't find string terminator %s anywhere before EOF
618
619 (F) Perl strings can stretch over multiple lines.  This message means
620 that the closing delimiter was omitted.  Because bracketed quotes count
621 nesting levels, the following is missing its final parenthesis:
622
623     print q(The character '(' starts a side comment.);
624
625 If you're getting this error from a here-document, you may have included
626 unseen whitespace before or after your closing tag. A good programmer's
627 editor will have a way to help you find these characters.
628
629 =item Can't fork
630
631 (F) A fatal error occurred while trying to fork while opening a
632 pipeline.
633
634 =item Can't get filespec - stale stat buffer?
635
636 (S) A warning peculiar to VMS.  This arises because of the difference
637 between access checks under VMS and under the Unix model Perl assumes.
638 Under VMS, access checks are done by filename, rather than by bits in
639 the stat buffer, so that ACLs and other protections can be taken into
640 account.  Unfortunately, Perl assumes that the stat buffer contains all
641 the necessary information, and passes it, instead of the filespec, to
642 the access checking routine.  It will try to retrieve the filespec using
643 the device name and FID present in the stat buffer, but this works only
644 if you haven't made a subsequent call to the CRTL stat() routine,
645 because the device name is overwritten with each call.  If this warning
646 appears, the name lookup failed, and the access checking routine gave up
647 and returned FALSE, just to be conservative.  (Note: The access checking
648 routine knows about the Perl C<stat> operator and file tests, so you
649 shouldn't ever see this warning in response to a Perl command; it arises
650 only if some internal code takes stat buffers lightly.)
651
652 =item Can't get pipe mailbox device name
653
654 (P) An error peculiar to VMS.  After creating a mailbox to act as a
655 pipe, Perl can't retrieve its name for later use.
656
657 =item Can't get SYSGEN parameter value for MAXBUF
658
659 (P) An error peculiar to VMS.  Perl asked $GETSYI how big you want your
660 mailbox buffers to be, and didn't get an answer.
661
662 =item Can't "goto" into the middle of a foreach loop
663
664 (F) A "goto" statement was executed to jump into the middle of a foreach
665 loop.  You can't get there from here.  See L<perlfunc/goto>.
666
667 =item Can't "goto" out of a pseudo block
668
669 (F) A "goto" statement was executed to jump out of what might look like
670 a block, except that it isn't a proper block.  This usually occurs if
671 you tried to jump out of a sort() block or subroutine, which is a no-no.
672 See L<perlfunc/goto>.
673
674 =item Can't goto subroutine from an eval-string
675
676 (F) The "goto subroutine" call can't be used to jump out of an eval
677 "string".  (You can use it to jump out of an eval {BLOCK}, but you
678 probably don't want to.)
679
680 =item Can't goto subroutine outside a subroutine
681
682 (F) The deeply magical "goto subroutine" call can only replace one
683 subroutine call for another.  It can't manufacture one out of whole
684 cloth.  In general you should be calling it out of only an AUTOLOAD
685 routine anyway.  See L<perlfunc/goto>.
686
687 =item Can't ignore signal CHLD, forcing to default
688
689 (W signal) Perl has detected that it is being run with the SIGCHLD
690 signal (sometimes known as SIGCLD) disabled.  Since disabling this
691 signal will interfere with proper determination of exit status of child
692 processes, Perl has reset the signal to its default value.  This
693 situation typically indicates that the parent program under which Perl
694 may be running (e.g. cron) is being very careless.
695
696 =item Can't "last" outside a loop block
697
698 (F) A "last" statement was executed to break out of the current block,
699 except that there's this itty bitty problem called there isn't a current
700 block.  Note that an "if" or "else" block doesn't count as a "loopish"
701 block, as doesn't a block given to sort(), map() or grep().  You can
702 usually double the curlies to get the same effect though, because the
703 inner curlies will be considered a block that loops once.  See
704 L<perlfunc/last>.
705
706 =item Can't localize lexical variable %s
707
708 (F) You used local on a variable name that was previously declared as a
709 lexical variable using "my".  This is not allowed.  If you want to
710 localize a package variable of the same name, qualify it with the
711 package name.
712
713 =item Can't localize pseudo-hash element
714
715 (F) You said something like C<< local $ar->{'key'} >>, where $ar is a
716 reference to a pseudo-hash.  That hasn't been implemented yet, but you
717 can get a similar effect by localizing the corresponding array element
718 directly -- C<< local $ar->[$ar->[0]{'key'}] >>.
719
720 =item Can't localize through a reference
721
722 (F) You said something like C<local $$ref>, which Perl can't currently
723 handle, because when it goes to restore the old value of whatever $ref
724 pointed to after the scope of the local() is finished, it can't be sure
725 that $ref will still be a reference.  
726
727 =item Can't locate %s
728
729 (F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be
730 found. Perl looks for the file in all the locations mentioned in @INC,
731 unless the file name included the full path to the file.  Perhaps you
732 need to set the PERL5LIB or PERL5OPT environment variable to say where
733 the extra library is, or maybe the script needs to add the library name
734 to @INC.  Or maybe you just misspelled the name of the file.  See
735 L<perlfunc/require> and L<lib>.
736
737 =item Can't locate auto/%s.al in @INC
738
739 (F) A function (or method) was called in a package which allows
740 autoload, but there is no function to autoload.  Most probable causes
741 are a misprint in a function/method name or a failure to C<AutoSplit>
742 the file, say, by doing C<make install>.
743
744 =item Can't locate object method "%s" via package "%s"
745
746 (F) You called a method correctly, and it correctly indicated a package
747 functioning as a class, but that package doesn't define that particular
748 method, nor does any of its base classes.  See L<perlobj>.
749
750 =item Can't locate package %s for @%s::ISA
751
752 (W syntax) The @ISA array contained the name of another package that
753 doesn't seem to exist.
754
755 =item Can't make list assignment to \%ENV on this system
756
757 (F) List assignment to %ENV is not supported on some systems, notably
758 VMS.
759
760 =item Can't modify %s in %s
761
762 (F) You aren't allowed to assign to the item indicated, or otherwise try
763 to change it, such as with an auto-increment.
764
765 =item Can't modify nonexistent substring
766
767 (P) The internal routine that does assignment to a substr() was handed
768 a NULL.
769
770 =item Can't modify non-lvalue subroutine call
771
772 (F) Subroutines meant to be used in lvalue context should be declared as
773 such, see L<perlsub/"Lvalue subroutines">.
774
775 =item Can't msgrcv to read-only var
776
777 (F) The target of a msgrcv must be modifiable to be used as a receive
778 buffer.
779
780 =item Can't "next" outside a loop block
781
782 (F) A "next" statement was executed to reiterate the current block, but
783 there isn't a current block.  Note that an "if" or "else" block doesn't
784 count as a "loopish" block, as doesn't a block given to sort(), map() or
785 grep().  You can usually double the curlies to get the same effect
786 though, because the inner curlies will be considered a block that loops
787 once.  See L<perlfunc/next>.
788
789 =item Can't open %s: %s
790
791 (S inplace) The implicit opening of a file through use of the C<< <> >>
792 filehandle, either implicitly under the C<-n> or C<-p> command-line
793 switches, or explicitly, failed for the indicated reason.  Usually this
794 is because you don't have read permission for a file which you named on
795 the command line.
796
797 =item Can't open bidirectional pipe
798
799 (W pipe) You tried to say C<open(CMD, "|cmd|")>, which is not supported.
800 You can try any of several modules in the Perl library to do this, such
801 as IPC::Open2.  Alternately, direct the pipe's output to a file using
802 ">", and then read it in under a different file handle.
803
804 =item Can't open error file %s as stderr
805
806 (F) An error peculiar to VMS.  Perl does its own command line
807 redirection, and couldn't open the file specified after '2>' or '2>>' on
808 the command line for writing.
809
810 =item Can't open input file %s as stdin
811
812 (F) An error peculiar to VMS.  Perl does its own command line
813 redirection, and couldn't open the file specified after '<' on the
814 command line for reading.
815
816 =item Can't open output file %s as stdout
817
818 (F) An error peculiar to VMS.  Perl does its own command line
819 redirection, and couldn't open the file specified after '>' or '>>' on
820 the command line for writing.
821
822 =item Can't open output pipe (name: %s)
823
824 (P) An error peculiar to VMS.  Perl does its own command line
825 redirection, and couldn't open the pipe into which to send data destined
826 for stdout.
827
828 =item Can't open perl script "%s": %s
829
830 (F) The script you specified can't be opened for the indicated reason.
831
832 =item Can't read CRTL environ
833
834 (S) A warning peculiar to VMS.  Perl tried to read an element of %ENV
835 from the CRTL's internal environment array and discovered the array was
836 missing.  You need to figure out where your CRTL misplaced its environ
837 or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
838 searched.
839
840 =item Can't redefine active sort subroutine %s
841
842 (F) Perl optimizes the internal handling of sort subroutines and keeps
843 pointers into them.  You tried to redefine one such sort subroutine when
844 it was currently active, which is not allowed.  If you really want to do
845 this, you should write C<sort { &func } @x> instead of C<sort func @x>.
846
847 =item Can't "redo" outside a loop block
848
849 (F) A "redo" statement was executed to restart the current block, but
850 there isn't a current block.  Note that an "if" or "else" block doesn't
851 count as a "loopish" block, as doesn't a block given to sort(), map()
852 or grep().  You can usually double the curlies to get the same effect
853 though, because the inner curlies will be considered a block that
854 loops once.  See L<perlfunc/redo>.
855
856 =item Can't remove %s: %s, skipping file 
857
858 (S inplace) You requested an inplace edit without creating a backup
859 file.  Perl was unable to remove the original file to replace it with
860 the modified file.  The file was left unmodified.
861
862 =item Can't rename %s to %s: %s, skipping file
863
864 (S inplace) The rename done by the B<-i> switch failed for some reason,
865 probably because you don't have write permission to the directory.
866
867 =item Can't reopen input pipe (name: %s) in binary mode
868
869 (P) An error peculiar to VMS.  Perl thought stdin was a pipe, and tried
870 to reopen it to accept binary data.  Alas, it failed.
871
872 =item Can't resolve method `%s' overloading `%s' in package `%s'
873
874 (F|P) Error resolving overloading specified by a method name (as opposed
875 to a subroutine reference): no such method callable via the package. If
876 method name is C<???>, this is an internal error.
877
878 =item Can't reswap uid and euid
879
880 (P) The setreuid() call failed for some reason in the setuid emulator of
881 suidperl.
882
883 =item Can't return %s from lvalue subroutine
884
885 (F) Perl detected an attempt to return illegal lvalues (such as
886 temporary or readonly values) from a subroutine used as an lvalue.  This
887 is not allowed.
888
889 =item Can't return outside a subroutine
890
891 (F) The return statement was executed in mainline code, that is, where
892 there was no subroutine call to return out of.  See L<perlsub>.
893
894 =item Can't stat script "%s"
895
896 (P) For some reason you can't fstat() the script even though you have it
897 open already.  Bizarre.
898
899 =item Can't swap uid and euid
900
901 (P) The setreuid() call failed for some reason in the setuid emulator of
902 suidperl.
903
904 =item Can't take log of %g
905
906 (F) For ordinary real numbers, you can't take the logarithm of a
907 negative number or zero. There's a Math::Complex package that comes
908 standard with Perl, though, if you really want to do that for the
909 negative numbers.
910
911 =item Can't take sqrt of %g
912
913 (F) For ordinary real numbers, you can't take the square root of a
914 negative number.  There's a Math::Complex package that comes standard
915 with Perl, though, if you really want to do that.
916
917 =item Can't undef active subroutine
918
919 (F) You can't undefine a routine that's currently running.  You can,
920 however, redefine it while it's running, and you can even undef the
921 redefined subroutine while the old routine is running.  Go figure.
922
923 =item Can't unshift
924
925 (F) You tried to unshift an "unreal" array that can't be unshifted, such
926 as the main Perl stack.
927
928 =item Can't upgrade that kind of scalar
929
930 (P) The internal sv_upgrade routine adds "members" to an SV, making it
931 into a more specialized kind of SV.  The top several SV types are so
932 specialized, however, that they cannot be interconverted.  This message
933 indicates that such a conversion was attempted.
934
935 =item Can't upgrade to undef
936
937 (P) The undefined SV is the bottom of the totem pole, in the scheme of
938 upgradability.  Upgrading to undef indicates an error in the code
939 calling sv_upgrade.
940
941 =item Can't use an undefined value as %s reference
942
943 (F) A value used as either a hard reference or a symbolic reference must
944 be a defined value.  This helps to delurk some insidious errors.
945
946 =item Can't use bareword ("%s") as %s ref while "strict refs" in use
947
948 (F) Only hard references are allowed by "strict refs".  Symbolic
949 references are disallowed.  See L<perlref>.
950
951 =item Can't use %%! because Errno.pm is not available
952
953 (F) The first time the %! hash is used, perl automatically loads the
954 Errno.pm module. The Errno module is expected to tie the %! hash to
955 provide symbolic names for C<$!> errno values.
956
957 =item Can't use %s for loop variable
958
959 (F) Only a simple scalar variable may be used as a loop variable on a
960 foreach.
961
962 =item Can't use global %s in "my"
963
964 (F) You tried to declare a magical variable as a lexical variable.  This
965 is not allowed, because the magic can be tied to only one location
966 (namely the global variable) and it would be incredibly confusing to
967 have variables in your program that looked like magical variables but
968 weren't.
969
970 =item Can't use "my %s" in sort comparison
971
972 (F) The global variables $a and $b are reserved for sort comparisons.
973 You mentioned $a or $b in the same line as the <=> or cmp operator,
974 and the variable had earlier been declared as a lexical variable.
975 Either qualify the sort variable with the package name, or rename the
976 lexical variable.
977
978 =item Can't use %s ref as %s ref
979
980 (F) You've mixed up your reference types.  You have to dereference a
981 reference of the type needed.  You can use the ref() function to
982 test the type of the reference, if need be.
983
984 =item Can't use string ("%s") as %s ref while "strict refs" in use
985
986 (F) Only hard references are allowed by "strict refs".  Symbolic
987 references are disallowed.  See L<perlref>.
988
989 =item Can't use subscript on %s
990
991 (F) The compiler tried to interpret a bracketed expression as a
992 subscript.  But to the left of the brackets was an expression that
993 didn't look like an array reference, or anything else subscriptable.
994
995 =item Can't use \%c to mean $%c in expression
996
997 (W syntax) In an ordinary expression, backslash is a unary operator that
998 creates a reference to its argument.  The use of backslash to indicate a
999 backreference to a matched substring is valid only as part of a regular
1000 expression pattern.  Trying to do this in ordinary Perl code produces a
1001 value that prints out looking like SCALAR(0xdecaf).  Use the $1 form
1002 instead.
1003
1004 =item Can't weaken a nonreference
1005
1006 (F) You attempted to weaken something that was not a reference.  Only
1007 references can be weakened.
1008
1009 =item Can't x= to read-only value
1010
1011 (F) You tried to repeat a constant value (often the undefined value)
1012 with an assignment operator, which implies modifying the value itself.
1013 Perhaps you need to copy the value to a temporary, and repeat that.
1014
1015 =item Character class syntax [%s] belongs inside character classes
1016
1017 (W unsafe) The character class constructs [: :], [= =], and [. .]  go
1018 I<inside> character classes, the [] are part of the construct, for
1019 example: /[012[:alpha:]345]/.  Note that [= =] and [. .] are not
1020 currently implemented; they are simply placeholders for future
1021 extensions.
1022
1023 =item Character class syntax [. .] is reserved for future extensions
1024
1025 (W regexp) Within regular expression character classes ([]) the syntax
1026 beginning with "[." and ending with ".]" is reserved for future
1027 extensions.  If you need to represent those character sequences inside a
1028 regular expression character class, just quote the square brackets with
1029 the backslash: "\[." and ".\]".
1030
1031 =item Character class syntax [= =] is reserved for future extensions
1032
1033 (W regexp) Within regular expression character classes ([]) the syntax
1034 beginning with "[=" and ending with "=]" is reserved for future
1035 extensions.  If you need to represent those character sequences inside a
1036 regular expression character class, just quote the square brackets with
1037 the backslash: "\[=" and "=\]".
1038
1039 =item Character class [:%s:] unknown
1040
1041 (F) The class in the character class [: :] syntax is unknown.  See
1042 L<perlre>.
1043
1044 =item chmod() mode argument is missing initial 0
1045
1046 (W chmod) A novice will sometimes say
1047
1048     chmod 777, $filename
1049
1050 not realizing that 777 will be interpreted as a decimal number,
1051 equivalent to 01411.  Octal constants are introduced with a leading 0 in
1052 Perl, as in C.
1053
1054 =item Close on unopened file <%s>
1055
1056 (W unopened) You tried to close a filehandle that was never opened.
1057
1058 =item %s: Command not found
1059
1060 (A) You've accidentally run your script through B<csh> instead of Perl.
1061 Check the #! line, or manually feed your script into Perl yourself.
1062
1063 =item Compilation failed in require
1064
1065 (F) Perl could not compile a file specified in a C<require> statement.
1066 Perl uses this generic message when none of the errors that it
1067 encountered were severe enough to halt compilation immediately.
1068
1069 =item Complex regular subexpression recursion limit (%d) exceeded
1070
1071 (W regexp) The regular expression engine uses recursion in complex
1072 situations where back-tracking is required.  Recursion depth is limited
1073 to 32766, or perhaps less in architectures where the stack cannot grow
1074 arbitrarily.  ("Simple" and "medium" situations are handled without
1075 recursion and are not subject to a limit.)  Try shortening the string
1076 under examination; looping in Perl code (e.g. with C<while>) rather than
1077 in the regular expression engine; or rewriting the regular expression so
1078 that it is simpler or backtracks less.  (See L<perlbook> for information
1079 on I<Mastering Regular Expressions>.)
1080
1081 =item connect() on closed socket %s
1082
1083 (W closed) You tried to do a connect on a closed socket.  Did you forget
1084 to check the return value of your socket() call?  See
1085 L<perlfunc/connect>.
1086
1087 =item constant(%s): %s
1088
1089 (F) The parser found inconsistencies either while attempting to define
1090 an overloaded constant, or when trying to find the character name
1091 specified in the C<\N{...}> escape.  Perhaps you forgot to load the
1092 corresponding C<overload> or C<charnames> pragma?  See L<charnames> and
1093 L<overload>.
1094
1095 =item Constant is not %s reference
1096
1097 (F) A constant value (perhaps declared using the C<use constant> pragma)
1098 is being dereferenced, but it amounts to the wrong type of reference.
1099 The message indicates the type of reference that was expected. This
1100 usually indicates a syntax error in dereferencing the constant value.
1101 See L<perlsub/"Constant Functions"> and L<constant>.
1102
1103 =item Constant subroutine %s redefined
1104
1105 (S|W redefine) You redefined a subroutine which had previously been
1106 eligible for inlining.  See L<perlsub/"Constant Functions"> for
1107 commentary and workarounds.
1108
1109 =item Constant subroutine %s undefined
1110
1111 (W misc) You undefined a subroutine which had previously been eligible
1112 for inlining.  See L<perlsub/"Constant Functions"> for commentary and
1113 workarounds.
1114
1115 =item Copy method did not return a reference
1116
1117 (F) The method which overloads "=" is buggy. See L<overload/Copy
1118 Constructor>.
1119
1120 =item CORE::%s is not a keyword
1121
1122 (F) The CORE:: namespace is reserved for Perl keywords.
1123
1124 =item corrupted regexp pointers
1125
1126 (P) The regular expression engine got confused by what the regular
1127 expression compiler gave it.
1128
1129 =item corrupted regexp program
1130
1131 (P) The regular expression engine got passed a regexp program without a
1132 valid magic number.
1133
1134 =item Corrupt malloc ptr 0x%lx at 0x%lx
1135
1136 (P) The malloc package that comes with Perl had an internal failure.
1137
1138 =item C<-p> destination: %s
1139
1140 (F) An error occurred during the implicit output invoked by the C<-p>
1141 command-line switch.  (This output goes to STDOUT unless you've
1142 redirected it with select().)
1143
1144 =item C<-T> and C<-B> not implemented on filehandles
1145
1146 (F) Perl can't peek at the stdio buffer of filehandles when it doesn't
1147 know about your kind of stdio.  You'll have to use a filename instead.
1148
1149 =item Deep recursion on subroutine "%s"
1150
1151 (W recursion) This subroutine has called itself (directly or indirectly)
1152 100 times more than it has returned.  This probably indicates an
1153 infinite recursion, unless you're writing strange benchmark programs, in
1154 which case it indicates something else.
1155
1156 =item defined(@array) is deprecated
1157
1158 (D deprecated) defined() is not usually useful on arrays because it
1159 checks for an undefined I<scalar> value.  If you want to see if the
1160 array is empty, just use C<if (@array) { # not empty }> for example.  
1161
1162 =item defined(%hash) is deprecated
1163
1164 (D deprecated) defined() is not usually useful on hashes because it
1165 checks for an undefined I<scalar> value.  If you want to see if the hash
1166 is empty, just use C<if (%hash) { # not empty }> for example.  
1167
1168 =item Delimiter for here document is too long
1169
1170 (F) In a here document construct like C<<<FOO>, the label C<FOO> is too
1171 long for Perl to handle.  You have to be seriously twisted to write code
1172 that triggers this error.
1173
1174 =item Did not produce a valid header
1175
1176 See Server error.
1177
1178 =item %s did not return a true value
1179
1180 (F) A required (or used) file must return a true value to indicate that
1181 it compiled correctly and ran its initialization code correctly.  It's
1182 traditional to end such a file with a "1;", though any true value would
1183 do.  See L<perlfunc/require>.
1184
1185 =item (Did you mean &%s instead?)
1186
1187 (W) You probably referred to an imported subroutine &FOO as $FOO or some
1188 such.
1189
1190 =item (Did you mean "local" instead of "our"?)
1191
1192 (W misc) Remember that "our" does not localize the declared global
1193 variable.  You have declared it again in the same lexical scope, which
1194 seems superfluous.
1195
1196 =item (Did you mean $ or @ instead of %?)
1197
1198 (W) You probably said %hash{$key} when you meant $hash{$key} or
1199 @hash{@keys}.  On the other hand, maybe you just meant %hash and got
1200 carried away.
1201
1202 =item Died
1203
1204 (F) You passed die() an empty string (the equivalent of C<die "">) or
1205 you called it with no args and both C<$@> and C<$_> were empty.
1206
1207 =item Document contains no data
1208
1209 See Server error.
1210
1211 =item Don't know how to handle magic of type '%s'
1212
1213 (P) The internal handling of magical variables has been cursed.
1214
1215 =item do_study: out of memory
1216
1217 (P) This should have been caught by safemalloc() instead.
1218
1219 =item (Do you need to predeclare %s?)
1220
1221 (S) This is an educated guess made in conjunction with the message "%s
1222 found where operator expected".  It often means a subroutine or module
1223 name is being referenced that hasn't been declared yet.  This may be
1224 because of ordering problems in your file, or because of a missing
1225 "sub", "package", "require", or "use" statement.  If you're referencing
1226 something that isn't defined yet, you don't actually have to define the
1227 subroutine or package before the current location.  You can use an empty
1228 "sub foo;" or "package FOO;" to enter a "forward" declaration.
1229
1230 =item Duplicate free() ignored
1231
1232 (S malloc) An internal routine called free() on something that had
1233 already been freed.
1234
1235 =item elseif should be elsif
1236
1237 (S) There is no keyword "elseif" in Perl because Larry thinks it's ugly.
1238 Your code will be interpreted as an attempt to call a method named
1239 "elseif" for the class returned by the following block.  This is
1240 unlikely to be what you want.
1241
1242 =item entering effective %s failed
1243
1244 (F) While under the C<use filetest> pragma, switching the real and
1245 effective uids or gids failed.
1246
1247 =item Error converting file specification %s
1248
1249 (F) An error peculiar to VMS.  Because Perl may have to deal with file
1250 specifications in either VMS or Unix syntax, it converts them to a
1251 single form when it must operate on them directly.  Either you've passed
1252 an invalid file specification to Perl, or you've found a case the
1253 conversion routines don't handle.  Drat.
1254
1255 =item %s: Eval-group in insecure regular expression
1256
1257 (F) Perl detected tainted data when trying to compile a regular
1258 expression that contains the C<(?{ ... })> zero-width assertion, which
1259 is unsafe.  See L<perlre/(?{ code })>, and L<perlsec>.
1260
1261 =item %s: Eval-group not allowed at run time
1262
1263 (F) Perl tried to compile a regular expression containing the
1264 C<(?{ ... })> zero-width assertion at run time, as it would when the
1265 pattern contains interpolated values.  Since that is a security risk, it
1266 is not allowed.  If you insist, you may still do this by explicitly
1267 building the pattern from an interpolated string at run time and using
1268 that in an eval().  See L<perlre/(?{ code })>.
1269
1270 =item %s: Eval-group not allowed, use re 'eval'
1271
1272 (F) A regular expression contained the C<(?{ ... })> zero-width
1273 assertion, but that construct is only allowed when the C<use re 'eval'>
1274 pragma is in effect.  See L<perlre/(?{ code })>.
1275
1276 =item Excessively long <> operator
1277
1278 (F) The contents of a <> operator may not exceed the maximum size of a
1279 Perl identifier.  If you're just trying to glob a long list of
1280 filenames, try using the glob() operator, or put the filenames into a
1281 variable and glob that.
1282
1283 =item Execution of %s aborted due to compilation errors
1284
1285 (F) The final summary message when a Perl compilation fails.
1286
1287 =item Exiting eval via %s
1288
1289 (W exiting) You are exiting an eval by unconventional means, such as a
1290 goto, or a loop control statement.
1291
1292 =item Exiting format via %s
1293
1294 (W exiting) You are exiting an eval by unconventional means, such as a
1295 goto, or a loop control statement.
1296
1297 =item Exiting pseudo-block via %s
1298
1299 (W exiting) You are exiting a rather special block construct (like a
1300 sort block or subroutine) by unconventional means, such as a goto, or a
1301 loop control statement.  See L<perlfunc/sort>.
1302
1303 =item Exiting subroutine via %s
1304
1305 (W exiting) You are exiting a subroutine by unconventional means, such
1306 as a goto, or a loop control statement.
1307
1308 =item Exiting substitution via %s
1309
1310 (W exiting) You are exiting a substitution by unconventional means, such
1311 as a return, a goto, or a loop control statement.
1312
1313 =item Explicit blessing to '' (assuming package main)
1314
1315 (W misc) You are blessing a reference to a zero length string.  This has
1316 the effect of blessing the reference into the package main.  This is
1317 usually not what you want.  Consider providing a default target package,
1318 e.g. bless($ref, $p || 'MyPackage');
1319
1320 =item %s: Expression syntax
1321
1322 (A) You've accidentally run your script through B<csh> instead of Perl.
1323 Check the #! line, or manually feed your script into Perl yourself.
1324
1325 =item %s failed--call queue aborted
1326
1327 (F) An untrapped exception was raised while executing a CHECK, INIT, or
1328 END subroutine.  Processing of the remainder of the queue of such
1329 routines has been prematurely ended.
1330
1331 =item false [] range "%s" in regexp
1332
1333 (W regexp) A character class range must start and end at a literal
1334 character, not another character class like C<\d> or C<[:alpha:]>.  The
1335 "-" in your false range is interpreted as a literal "-".  Consider
1336 quoting the "-",  "\-".  See L<perlre>.
1337
1338 =item Fatal VMS error at %s, line %d
1339
1340 (P) An error peculiar to VMS.  Something untoward happened in a VMS
1341 system service or RTL routine; Perl's exit status should provide more
1342 details.  The filename in "at %s" and the line number in "line %d" tell
1343 you which section of the Perl source code is distressed.
1344
1345 =item fcntl is not implemented
1346
1347 (F) Your machine apparently doesn't implement fcntl().  What is this, a
1348 PDP-11 or something?
1349
1350 =item Filehandle %s never opened
1351
1352 (W unopened) An I/O operation was attempted on a filehandle that was
1353 never initialized.  You need to do an open() or a socket() call, or call
1354 a constructor from the FileHandle package.
1355
1356 =item Filehandle %s opened only for input
1357
1358 (W io) You tried to write on a read-only filehandle.  If you intended it
1359 to be a read-write filehandle, you needed to open it with "+<" or "+>"
1360 or "+>>" instead of with "<" or nothing.  If you intended only to write
1361 the file, use ">" or ">>".  See L<perlfunc/open>.
1362
1363 =item Filehandle %s opened only for output
1364
1365 (W io) You tried to read from a filehandle opened only for writing.  If
1366 you intended it to be a read/write filehandle, you needed to open it
1367 with "+<" or "+>" or "+>>" instead of with "<" or nothing.  If you
1368 intended only to read from the file, use "<".  See L<perlfunc/open>.
1369
1370 =item Final $ should be \$ or $name
1371
1372 (F) You must now decide whether the final $ in a string was meant to be
1373 a literal dollar sign, or was meant to introduce a variable name that
1374 happens to be missing.  So you have to put either the backslash or the
1375 name.
1376
1377 =item Final @ should be \@ or @name
1378
1379 (F) You must now decide whether the final @ in a string was meant to be
1380 a literal "at" sign, or was meant to introduce a variable name that
1381 happens to be missing.  So you have to put either the backslash or the
1382 name.
1383
1384 =item flock() on closed filehandle %s
1385
1386 (W closed) The filehandle you're attempting to flock() got itself closed
1387 some time before now.  Check your logic flow.  flock() operates on
1388 filehandles.  Are you attempting to call flock() on a dirhandle by the
1389 same name?
1390
1391 =item ?+* follows nothing in regexp
1392
1393 (F) You started a regular expression with a quantifier.  Backslash it if
1394 you meant it literally.   See L<perlre>.
1395
1396 =item Format not terminated
1397
1398 (F) A format must be terminated by a line with a solitary dot.  Perl got
1399 to the end of your file without finding such a line.
1400
1401 =item Format %s redefined
1402
1403 (W redefine) You redefined a format.  To suppress this warning, say
1404
1405     {
1406         no warnings;
1407         eval "format NAME =...";
1408     }
1409
1410 =item Found = in conditional, should be ==
1411
1412 (W syntax) You said
1413
1414     if ($foo = 123)
1415
1416 when you meant
1417
1418     if ($foo == 123)
1419
1420 (or something like that).
1421
1422 =item %s found where operator expected
1423
1424 (S) The Perl lexer knows whether to expect a term or an operator.  If it
1425 sees what it knows to be a term when it was expecting to see an
1426 operator, it gives you this warning.  Usually it indicates that an
1427 operator or delimiter was omitted, such as a semicolon.
1428
1429 =item gdbm store returned %d, errno %d, key "%s"
1430
1431 (S) A warning from the GDBM_File extension that a store failed.
1432
1433 =item gethostent not implemented
1434
1435 (F) Your C library apparently doesn't implement gethostent(), probably
1436 because if it did, it'd feel morally obligated to return every hostname
1437 on the Internet.
1438
1439 =item get%sname() on closed socket %s
1440
1441 (W closed) You tried to get a socket or peer socket name on a closed
1442 socket.  Did you forget to check the return value of your socket() call?
1443
1444 =item getpwnam returned invalid UIC %#o for user "%s"
1445
1446 (S) A warning peculiar to VMS.  The call to C<sys$getuai> underlying the
1447 C<getpwnam> operator returned an invalid UIC.
1448
1449 =item getsockopt() on closed socket %s
1450
1451 (W closed) You tried to get a socket option on a closed socket.  Did you
1452 forget to check the return value of your socket() call?  See
1453 L<perlfunc/getsockopt>.
1454
1455 =item Global symbol "%s" requires explicit package name
1456
1457 (F) You've said "use strict vars", which indicates that all variables
1458 must either be lexically scoped (using "my"), declared beforehand using
1459 "our", or explicitly qualified to say which package the global variable
1460 is in (using "::").
1461
1462 =item glob failed (%s)
1463
1464 (W glob) Something went wrong with the external program(s) used for
1465 C<glob> and C<< <*.c> >>.  Usually, this means that you supplied a
1466 C<glob> pattern that caused the external program to fail and exit with a
1467 nonzero status.  If the message indicates that the abnormal exit
1468 resulted in a coredump, this may also mean that your csh (C shell) is
1469 broken.  If so, you should change all of the csh-related variables in
1470 config.sh:  If you have tcsh, make the variables refer to it as if it
1471 were csh (e.g.  C<full_csh='/usr/bin/tcsh'>); otherwise, make them all
1472 empty (except that C<d_csh> should be C<'undef'>) so that Perl will
1473 think csh is missing.  In either case, after editing config.sh, run
1474 C<./Configure -S> and rebuild Perl.
1475
1476 =item Glob not terminated
1477
1478 (F) The lexer saw a left angle bracket in a place where it was expecting
1479 a term, so it's looking for the corresponding right angle bracket, and
1480 not finding it.  Chances are you left some needed parentheses out
1481 earlier in the line, and you really meant a "less than".
1482
1483 =item Got an error from DosAllocMem
1484
1485 (P) An error peculiar to OS/2.  Most probably you're using an obsolete
1486 version of Perl, and this should not happen anyway.
1487
1488 =item goto must have label
1489
1490 (F) Unlike with "next" or "last", you're not allowed to goto an
1491 unspecified destination.  See L<perlfunc/goto>.
1492
1493 =item %s had compilation errors
1494
1495 (F) The final summary message when a C<perl -c> fails.
1496
1497 =item Had to create %s unexpectedly
1498
1499 (S internal) A routine asked for a symbol from a symbol table that ought
1500 to have existed already, but for some reason it didn't, and had to be
1501 created on an emergency basis to prevent a core dump.
1502
1503 =item Hash %%s missing the % in argument %d of %s()
1504
1505 (D deprecated) Really old Perl let you omit the % on hash names in some
1506 spots.  This is now heavily deprecated.
1507
1508 =item %s has too many errors
1509
1510 (F) The parser has given up trying to parse the program after 10 errors.
1511 Further error messages would likely be uninformative.
1512
1513 =item Hexadecimal number > 0xffffffff non-portable
1514
1515 (W portable) The hexadecimal number you specified is larger than 2**32-1
1516 (4294967295) and therefore non-portable between systems.  See
1517 L<perlport> for more on portability concerns.
1518
1519 =item Identifier too long
1520
1521 (F) Perl limits identifiers (names for variables, functions, etc.) to
1522 about 250 characters for simple names, and somewhat more for compound
1523 names (like C<$A::B>).  You've exceeded Perl's limits.  Future versions
1524 of Perl are likely to eliminate these arbitrary limitations.
1525
1526 =item Illegal binary digit %s
1527
1528 (F) You used a digit other than 0 or 1 in a binary number.
1529
1530 =item Illegal binary digit %s ignored
1531
1532 (W digit) You may have tried to use a digit other than 0 or 1 in a
1533 binary number.  Interpretation of the binary number stopped before the
1534 offending digit.
1535
1536 =item Illegal character %s (carriage return)
1537
1538 (F) Perl normally treats carriage returns in the program text as it
1539 would any other whitespace, which means you should never see this error
1540 when Perl was built using standard options.  For some reason, your
1541 version of Perl appears to have been built without this support.  Talk
1542 to your Perl administrator.
1543
1544 =item Illegal division by zero
1545
1546 (F) You tried to divide a number by 0.  Either something was wrong in
1547 your logic, or you need to put a conditional in to guard against
1548 meaningless input.
1549
1550 =item Illegal hexadecimal digit %s ignored
1551
1552 (W digit) You may have tried to use a character other than 0 - 9 or
1553 A - F, a - f in a hexadecimal number.  Interpretation of the hexadecimal
1554 number stopped before the illegal character.
1555
1556 =item Illegal modulus zero
1557
1558 (F) You tried to divide a number by 0 to get the remainder.  Most
1559 numbers don't take to this kindly.
1560
1561 =item Illegal number of bits in vec
1562
1563 (F) The number of bits in vec() (the third argument) must be a power of
1564 two from 1 to 32 (or 64, if your platform supports that).
1565
1566 =item Illegal octal digit %s
1567
1568 (F) You used an 8 or 9 in a octal number.
1569
1570 =item Illegal octal digit %s ignored
1571
1572 (W digit) You may have tried to use an 8 or 9 in a octal number.
1573 Interpretation of the octal number stopped before the 8 or 9.
1574
1575 =item Illegal switch in PERL5OPT: %s
1576
1577 (X) The PERL5OPT environment variable may only be used to set the
1578 following switches: B<-[DIMUdmw]>.
1579
1580 =item Ill-formed CRTL environ value "%s"
1581
1582 (W internal) A warning peculiar to VMS.  Perl tried to read the CRTL's
1583 internal environ array, and encountered an element without the C<=>
1584 delimiter used to separate keys from values.  The element is ignored.
1585
1586 =item Ill-formed message in prime_env_iter: |%s|
1587
1588 (W internal) A warning peculiar to VMS.  Perl tried to read a logical
1589 name or CLI symbol definition when preparing to iterate over %ENV, and
1590 didn't see the expected delimiter between key and value, so the line was
1591 ignored.
1592
1593 =item (in cleanup) %s
1594
1595 (W misc) This prefix usually indicates that a DESTROY() method raised
1596 the indicated exception.  Since destructors are usually called by the
1597 system at arbitrary points during execution, and often a vast number of
1598 times, the warning is issued only once for any number of failures that
1599 would otherwise result in the same message being repeated.
1600
1601 Failure of user callbacks dispatched using the C<G_KEEPERR> flag could
1602 also result in this warning.  See L<perlcall/G_KEEPERR>.
1603
1604 =item Insecure dependency in %s
1605
1606 (F) You tried to do something that the tainting mechanism didn't like.
1607 The tainting mechanism is turned on when you're running setuid or
1608 setgid, or when you specify B<-T> to turn it on explicitly.  The
1609 tainting mechanism labels all data that's derived directly or indirectly
1610 from the user, who is considered to be unworthy of your trust.  If any
1611 such data is used in a "dangerous" operation, you get this error.  See
1612 L<perlsec> for more information.
1613
1614 =item Insecure directory in %s
1615
1616 (F) You can't use system(), exec(), or a piped open in a setuid or
1617 setgid script if C<$ENV{PATH}> contains a directory that is writable by
1618 the world.  See L<perlsec>.
1619
1620 =item Insecure $ENV{%s} while running %s
1621
1622 (F) You can't use system(), exec(), or a piped open in a setuid or
1623 setgid script if any of C<$ENV{PATH}>, C<$ENV{IFS}>, C<$ENV{CDPATH}>,
1624 C<$ENV{ENV}> or C<$ENV{BASH_ENV}> are derived from data supplied (or
1625 potentially supplied) by the user.  The script must set the path to a
1626 known value, using trustworthy data.  See L<perlsec>.
1627
1628 =item In string, @%s now must be written as \@%s
1629
1630 (F) It used to be that Perl would try to guess whether you wanted an
1631 array interpolated or a literal @.  It did this when the string was
1632 first used at runtime.  Now strings are parsed at compile time, and
1633 ambiguous instances of @ must be disambiguated, either by prepending a
1634 backslash to indicate a literal, or by declaring (or using) the array
1635 within the program before the string (lexically).  (Someday it will
1636 simply assume that an unbackslashed @ interpolates an array.)
1637
1638 =item Integer overflow in %s number
1639
1640 (W overflow) The hexadecimal, octal or binary number you have specified
1641 either as a literal or as an argument to hex() or oct() is too big for
1642 your architecture, and has been converted to a floating point number.
1643 On a 32-bit architecture the largest hexadecimal, octal or binary number
1644 representable without overflow is 0xFFFFFFFF, 037777777777, or
1645 0b11111111111111111111111111111111 respectively.  Note that Perl
1646 transparently promotes all numbers to a floating point representation
1647 internally--subject to loss of precision errors in subsequent
1648 operations.
1649
1650 =item internal disaster in regexp
1651
1652 (P) Something went badly wrong in the regular expression parser.
1653
1654 =item Internal inconsistency in tracking vforks
1655
1656 (S) A warning peculiar to VMS.  Perl keeps track of the number of times
1657 you've called C<fork> and C<exec>, to determine whether the current call
1658 to C<exec> should affect the current script or a subprocess (see
1659 L<perlvms/"exec LIST">).  Somehow, this count has become scrambled, so
1660 Perl is making a guess and treating this C<exec> as a request to
1661 terminate the Perl script and execute the specified command.
1662
1663 =item internal urp in regexp at /%s/
1664
1665 (P) Something went badly awry in the regular expression parser.
1666
1667 =item %s (...) interpreted as function
1668
1669 (W syntax) You've run afoul of the rule that says that any list operator
1670 followed by parentheses turns into a function, with all the list
1671 operators arguments found inside the parentheses.  See L<perlop/Terms
1672 and List Operators (Leftward)>.
1673
1674 =item Invalid %s attribute: %s
1675
1676 The indicated attribute for a subroutine or variable was not recognized
1677 by Perl or by a user-supplied handler.  See L<attributes>.
1678
1679 =item Invalid %s attributes: %s
1680
1681 The indicated attributes for a subroutine or variable were not
1682 recognized by Perl or by a user-supplied handler.  See L<attributes>.
1683
1684 =item Invalid conversion in %s: "%s"
1685
1686 (W printf) Perl does not understand the given format conversion.  See
1687 L<perlfunc/sprintf>.
1688
1689 =item invalid [] range "%s" in regexp
1690
1691 (F) The range specified in a character class had a minimum character
1692 greater than the maximum character.  See L<perlre>.
1693
1694 =item Invalid separator character %s in attribute list
1695
1696 (F) Something other than a colon or whitespace was seen between the
1697 elements of an attribute list.  If the previous attribute had a
1698 parenthesised parameter list, perhaps that list was terminated too soon.
1699 See L<attributes>.
1700
1701 =item Invalid type in pack: '%s'
1702
1703 (F) The given character is not a valid pack type.  See L<perlfunc/pack>.
1704 (W pack) The given character is not a valid pack type but used to be
1705 silently ignored.
1706
1707 =item Invalid type in unpack: '%s'
1708
1709 (F) The given character is not a valid unpack type.  See
1710 L<perlfunc/unpack>.
1711 (W unpack) The given character is not a valid unpack type but used to be
1712 silently ignored.
1713
1714 =item ioctl is not implemented
1715
1716 (F) Your machine apparently doesn't implement ioctl(), which is pretty
1717 strange for a machine that supports C.
1718
1719 =item junk on end of regexp
1720
1721 (P) The regular expression parser is confused.
1722
1723 =item Label not found for "last %s"
1724
1725 (F) You named a loop to break out of, but you're not currently in a loop
1726 of that name, not even if you count where you were called from.  See
1727 L<perlfunc/last>.
1728
1729 =item Label not found for "next %s"
1730
1731 (F) You named a loop to continue, but you're not currently in a loop of
1732 that name, not even if you count where you were called from.  See
1733 L<perlfunc/last>.
1734
1735 =item Label not found for "redo %s"
1736
1737 (F) You named a loop to restart, but you're not currently in a loop of
1738 that name, not even if you count where you were called from.  See
1739 L<perlfunc/last>.
1740
1741 =item leaving effective %s failed
1742
1743 (F) While under the C<use filetest> pragma, switching the real and
1744 effective uids or gids failed.
1745
1746 =item listen() on closed socket %s
1747
1748 (W closed) You tried to do a listen on a closed socket.  Did you forget
1749 to check the return value of your socket() call?  See
1750 L<perlfunc/listen>.
1751
1752 =item Lvalue subs returning %s not implemented yet
1753
1754 (F) Due to limitations in the current implementation, array and hash
1755 values cannot be returned in subroutines used in lvalue context.  See
1756 L<perlsub/"Lvalue subroutines">.
1757
1758 =item Malformed PERLLIB_PREFIX
1759
1760 (F) An error peculiar to OS/2.  PERLLIB_PREFIX should be of the form
1761
1762     prefix1;prefix2
1763
1764 or
1765
1766     prefix1 prefix2
1767
1768 with nonempty prefix1 and prefix2.  If C<prefix1> is indeed a prefix of
1769 a builtin library search path, prefix2 is substituted.  The error may
1770 appear if components are not found, or are too long.  See
1771 "PERLLIB_PREFIX" in F<README.os2>.
1772
1773 =item %s matches null string many times
1774
1775 (W regexp) The pattern you've specified would be an infinite loop if the
1776 regular expression engine didn't specifically check for that.  See
1777 L<perlre>.
1778
1779 =item % may only be used in unpack
1780
1781 (F) You can't pack a string by supplying a checksum, because the
1782 checksumming process loses information, and you can't go the other way.
1783 See L<perlfunc/unpack>.
1784
1785 =item Method for operation %s not found in package %s during blessing
1786
1787 (F) An attempt was made to specify an entry in an overloading table that
1788 doesn't resolve to a valid subroutine.  See L<overload>.
1789
1790 =item Method %s not permitted
1791
1792 See Server error.
1793
1794 =item Might be a runaway multi-line %s string starting on line %d
1795
1796 (S) An advisory indicating that the previous error may have been caused
1797 by a missing delimiter on a string or pattern, because it eventually
1798 ended earlier on the current line.
1799
1800 =item Misplaced _ in number
1801
1802 (W syntax) An underline in a decimal constant wasn't on a 3-digit boundary.
1803
1804 =item Missing %sbrace%s on \N{}
1805
1806 (F) Wrong syntax of character name literal C<\N{charname}> within
1807 double-quotish context.
1808
1809 =item Missing comma after first argument to %s function
1810
1811 (F) While certain functions allow you to specify a filehandle or an
1812 "indirect object" before the argument list, this ain't one of them.
1813
1814 =item Missing command in piped open
1815
1816 (W pipe) You used the C<open(FH, "| command")> or
1817 C<open(FH, "command |")> construction, but the command was missing or
1818 blank.
1819
1820 =item Missing name in "my sub"
1821
1822 (F) The reserved syntax for lexically scoped subroutines requires that
1823 they have a name with which they can be found.
1824
1825 =item Missing $ on loop variable
1826
1827 (F) Apparently you've been programming in B<csh> too much.  Variables
1828 are always mentioned with the $ in Perl, unlike in the shells, where it
1829 can vary from one line to the next.
1830
1831 =item (Missing operator before %s?)
1832
1833 (S) This is an educated guess made in conjunction with the message "%s
1834 found where operator expected".  Often the missing operator is a comma.
1835
1836 =item Missing right curly or square bracket
1837
1838 (F) The lexer counted more opening curly or square brackets than closing
1839 ones.  As a general rule, you'll find it's missing near the place you
1840 were last editing.
1841
1842 =item (Missing semicolon on previous line?)
1843
1844 (S) This is an educated guess made in conjunction with the message "%s
1845 found where operator expected".  Don't automatically put a semicolon on
1846 the previous line just because you saw this message.
1847
1848 =item Modification of a read-only value attempted
1849
1850 (F) You tried, directly or indirectly, to change the value of a
1851 constant.  You didn't, of course, try "2 = 1", because the compiler
1852 catches that.  But an easy way to do the same thing is:
1853
1854     sub mod { $_[0] = 1 }
1855     mod(2);
1856
1857 Another way is to assign to a substr() that's off the end of the string.
1858
1859 =item Modification of non-creatable array value attempted, subscript %d
1860
1861 (F) You tried to make an array value spring into existence, and the
1862 subscript was probably negative, even counting from end of the array
1863 backwards.
1864
1865 =item Modification of non-creatable hash value attempted, subscript "%s"
1866
1867 (P) You tried to make a hash value spring into existence, and it
1868 couldn't be created for some peculiar reason.
1869
1870 =item Module name must be constant
1871
1872 (F) Only a bare module name is allowed as the first argument to a "use".
1873
1874 =item Module name required with -M option
1875
1876 (F) The C<-M> option says that Perl should load some module, but you
1877 omitted the name of the module.  Consult L<perlrun> for full details
1878 about C<-M>.
1879
1880 =item msg%s not implemented
1881
1882 (F) You don't have System V message IPC on your system.
1883
1884 =item Multidimensional syntax %s not supported
1885
1886 (W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
1887 They're written like C<$foo[1][2][3]>, as in C.
1888
1889 =item / must be followed by a*, A* or Z*
1890
1891 (F) You had a pack template indicating a counted-length string,
1892 Currently the only things that can have their length counted are a*, A*
1893 or Z*.  See L<perlfunc/pack>.
1894
1895 =item / must be followed by a, A or Z
1896
1897 (F) You had an unpack template indicating a counted-length string, which
1898 must be followed by one of the letters a, A or Z to indicate what sort
1899 of string is to be unpacked.  See L<perlfunc/pack>.
1900
1901 =item / must follow a numeric type
1902
1903 (F) You had an unpack template that contained a '#', but this did not
1904 follow some numeric unpack specification.  See L<perlfunc/pack>.
1905
1906 =item "my sub" not yet implemented
1907
1908 (F) Lexically scoped subroutines are not yet implemented.  Don't try
1909 that yet.
1910
1911 =item "my" variable %s can't be in a package
1912
1913 (F) Lexically scoped variables aren't in a package, so it doesn't make
1914 sense to try to declare one with a package qualifier on the front.  Use
1915 local() if you want to localize a package variable.
1916
1917 =item Name "%s::%s" used only once: possible typo
1918
1919 (W once) Typographical errors often show up as unique variable names.
1920 If you had a good reason for having a unique name, then just mention it
1921 again somehow to suppress the message.  The C<our> declaration is
1922 provided for this purpose.
1923
1924 =item Negative length
1925
1926 (F) You tried to do a read/write/send/recv operation with a buffer
1927 length that is less than 0.  This is difficult to imagine.
1928
1929 =item nested *?+ in regexp
1930
1931 (F) You can't quantify a quantifier without intervening parentheses.  So
1932 things like ** or +* or ?* are illegal.
1933
1934 Note, however, that the minimal matching quantifiers, C<*?>, C<+?>, and
1935 C<??> appear to be nested quantifiers, but aren't.  See L<perlre>.
1936
1937 =item %s never introduced
1938
1939 (S internal) The symbol in question was declared but somehow went out of
1940 scope before it could possibly have been used.
1941
1942 =item No %s allowed while running setuid
1943
1944 (F) Certain operations are deemed to be too insecure for a setuid or
1945 setgid script to even be allowed to attempt.  Generally speaking there
1946 will be another way to do what you want that is, if not secure, at least
1947 securable.  See L<perlsec>.
1948
1949 =item No B<-e> allowed in setuid scripts
1950
1951 (F) A setuid script can't be specified by the user.
1952
1953 =item No comma allowed after %s
1954
1955 (F) A list operator that has a filehandle or "indirect object" is not
1956 allowed to have a comma between that and the following arguments.
1957 Otherwise it'd be just another one of the arguments.
1958
1959 One possible cause for this is that you expected to have imported a
1960 constant to your name space with B<use> or B<import> while no such
1961 importing took place, it may for example be that your operating system
1962 does not support that particular constant. Hopefully you did use an
1963 explicit import list for the constants you expect to see, please see
1964 L<perlfunc/use> and L<perlfunc/import>. While an explicit import list
1965 would probably have caught this error earlier it naturally does not
1966 remedy the fact that your operating system still does not support that
1967 constant. Maybe you have a typo in the constants of the symbol import
1968 list of B<use> or B<import> or in the constant name at the line where
1969 this error was triggered?
1970
1971 =item No command into which to pipe on command line
1972
1973 (F) An error peculiar to VMS.  Perl handles its own command line
1974 redirection, and found a '|' at the end of the command line, so it
1975 doesn't know where you want to pipe the output from this command.
1976
1977 =item No DB::DB routine defined
1978
1979 (F) The currently executing code was compiled with the B<-d> switch, but
1980 for some reason the perl5db.pl file (or some facsimile thereof) didn't
1981 define a routine to be called at the beginning of each statement.  Which
1982 is odd, because the file should have been required automatically, and
1983 should have blown up the require if it didn't parse right.
1984
1985 =item No dbm on this machine
1986
1987 (P) This is counted as an internal error, because every machine should
1988 supply dbm nowadays, because Perl comes with SDBM.  See L<SDBM_File>.
1989
1990 =item No DBsub routine
1991
1992 (F) The currently executing code was compiled with the B<-d> switch,
1993 but for some reason the perl5db.pl file (or some facsimile thereof)
1994 didn't define a DB::sub routine to be called at the beginning of each
1995 ordinary subroutine call.
1996
1997 =item No error file after 2> or 2>> on command line
1998
1999 (F) An error peculiar to VMS.  Perl handles its own command line
2000 redirection, and found a '2>' or a '2>>' on the command line, but can't
2001 find the name of the file to which to write data destined for stderr.
2002
2003 =item No input file after < on command line
2004
2005 (F) An error peculiar to VMS.  Perl handles its own command line
2006 redirection, and found a '<' on the command line, but can't find the
2007 name of the file from which to read data for stdin.
2008
2009 =item No #! line
2010
2011 (F) The setuid emulator requires that scripts have a well-formed #! line
2012 even on machines that don't support the #! construct.
2013
2014 =item "no" not allowed in expression
2015
2016 (F) The "no" keyword is recognized and executed at compile time, and
2017 returns no useful value.  See L<perlmod>.
2018
2019 =item No output file after > on command line
2020
2021 (F) An error peculiar to VMS.  Perl handles its own command line
2022 redirection, and found a lone '>' at the end of the command line, so it
2023 doesn't know where you wanted to redirect stdout.
2024
2025 =item No output file after > or >> on command line
2026
2027 (F) An error peculiar to VMS.  Perl handles its own command line
2028 redirection, and found a '>' or a '>>' on the command line, but can't
2029 find the name of the file to which to write data destined for stdout.
2030
2031 =item No package name allowed for variable %s in "our"
2032
2033 (F) Fully qualified variable names are not allowed in "our"
2034 declarations, because that doesn't make much sense under existing
2035 semantics.  Such syntax is reserved for future extensions.
2036
2037 =item No Perl script found in input
2038
2039 (F) You called C<perl -x>, but no line was found in the file beginning
2040 with #! and containing the word "perl".
2041
2042 =item No setregid available
2043
2044 (F) Configure didn't find anything resembling the setregid() call for
2045 your system.
2046
2047 =item No setreuid available
2048
2049 (F) Configure didn't find anything resembling the setreuid() call for
2050 your system.
2051
2052 =item No space allowed after -%c
2053
2054 (F) The argument to the indicated command line switch must follow
2055 immediately after the switch, without intervening spaces.
2056
2057 =item No %s specified for -%c
2058
2059 (F) The indicated command line switch needs a mandatory argument, but
2060 you haven't specified one.
2061
2062 =item No such pipe open
2063
2064 (P) An error peculiar to VMS.  The internal routine my_pclose() tried to
2065 close a pipe which hadn't been opened.  This should have been caught
2066 earlier as an attempt to close an unopened filehandle.
2067
2068 =item No such pseudo-hash field "%s"
2069
2070 (F) You tried to access an array as a hash, but the field name used is
2071 not defined.  The hash at index 0 should map all valid field names to
2072 array indices for that to work.
2073
2074 =item No such pseudo-hash field "%s" in variable %s of type %s
2075
2076 (F) You tried to access a field of a typed variable where the type does
2077 not know about the field name.  The field names are looked up in the
2078 %FIELDS hash in the type package at compile time.  The %FIELDS hash is
2079 %usually set up with the 'fields' pragma.
2080
2081 =item No such signal: SIG%s
2082
2083 (W signal) You specified a signal name as a subscript to %SIG that was
2084 not recognized.  Say C<kill -l> in your shell to see the valid signal
2085 names on your system.
2086
2087 =item Not a CODE reference
2088
2089 (F) Perl was trying to evaluate a reference to a code value (that is, a
2090 subroutine), but found a reference to something else instead.  You can
2091 use the ref() function to find out what kind of ref it really was.  See
2092 also L<perlref>.
2093
2094 =item Not a format reference
2095
2096 (F) I'm not sure how you managed to generate a reference to an anonymous
2097 format, but this indicates you did, and that it didn't exist.
2098
2099 =item Not a GLOB reference
2100
2101 (F) Perl was trying to evaluate a reference to a "typeglob" (that is, a
2102 symbol table entry that looks like C<*foo>), but found a reference to
2103 something else instead.  You can use the ref() function to find out what
2104 kind of ref it really was.  See L<perlref>.
2105
2106 =item Not a HASH reference
2107
2108 (F) Perl was trying to evaluate a reference to a hash value, but found a
2109 reference to something else instead.  You can use the ref() function to
2110 find out what kind of ref it really was.  See L<perlref>.
2111
2112 =item Not an ARRAY reference
2113
2114 (F) Perl was trying to evaluate a reference to an array value, but found
2115 a reference to something else instead.  You can use the ref() function
2116 to find out what kind of ref it really was.  See L<perlref>.
2117
2118 =item Not a perl script
2119
2120 (F) The setuid emulator requires that scripts have a well-formed #! line
2121 even on machines that don't support the #! construct.  The line must
2122 mention perl.
2123
2124 =item Not a SCALAR reference
2125
2126 (F) Perl was trying to evaluate a reference to a scalar value, but found
2127 a reference to something else instead.  You can use the ref() function
2128 to find out what kind of ref it really was.  See L<perlref>.
2129
2130 =item Not a subroutine reference
2131
2132 (F) Perl was trying to evaluate a reference to a code value (that is, a
2133 subroutine), but found a reference to something else instead.  You can
2134 use the ref() function to find out what kind of ref it really was.  See
2135 also L<perlref>.
2136
2137 =item Not a subroutine reference in overload table
2138
2139 (F) An attempt was made to specify an entry in an overloading table that
2140 doesn't somehow point to a valid subroutine.  See L<overload>.
2141
2142 =item Not enough arguments for %s
2143
2144 (F) The function requires more arguments than you specified.
2145
2146 =item Not enough format arguments
2147
2148 (W syntax) A format specified more picture fields than the next line
2149 supplied.  See L<perlform>.
2150
2151 =item %s: not found
2152
2153 (A) You've accidentally run your script through the Bourne shell instead
2154 of Perl.  Check the #! line, or manually feed your script into Perl
2155 yourself.
2156
2157 =item no UTC offset information; assuming local time is UTC
2158
2159 (S) A warning peculiar to VMS.  Perl was unable to find the local
2160 timezone offset, so it's assuming that local system time is equivalent
2161 to UTC.  If it's not, define the logical name
2162 F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
2163 need to be added to UTC to get local time.
2164
2165 =item Null filename used
2166
2167 (F) You can't require the null filename, especially because on many
2168 machines that means the current directory!  See L<perlfunc/require>.
2169
2170 =item NULL OP IN RUN
2171
2172 (P debugging) Some internal routine called run() with a null opcode
2173 pointer.
2174
2175 =item Null picture in formline
2176
2177 (F) The first argument to formline must be a valid format picture
2178 specification.  It was found to be empty, which probably means you
2179 supplied it an uninitialized value.  See L<perlform>.
2180
2181 =item Null realloc
2182
2183 (P) An attempt was made to realloc NULL.
2184
2185 =item NULL regexp argument
2186
2187 (P) The internal pattern matching routines blew it big time.
2188
2189 =item NULL regexp parameter
2190
2191 (P) The internal pattern matching routines are out of their gourd.
2192
2193 =item Number too long
2194
2195 (F) Perl limits the representation of decimal numbers in programs to
2196 about about 250 characters.  You've exceeded that length.  Future
2197 versions of Perl are likely to eliminate this arbitrary limitation.  In
2198 the meantime, try using scientific notation (e.g. "1e6" instead of
2199 "1_000_000").
2200
2201 =item Octal number in vector unsupported
2202
2203 (F) Numbers with a leading C<0> are not currently allowed in vectors.
2204 The octal number interpretation of such numbers may be supported in a
2205 future version.
2206
2207 =item Octal number > 037777777777 non-portable
2208
2209 (W portable) The octal number you specified is larger than 2**32-1
2210 (4294967295) and therefore non-portable between systems.  See
2211 L<perlport> for more on portability concerns.
2212
2213 See also L<perlport> for writing portable code.
2214
2215 =item Odd number of elements in hash assignment
2216
2217 (W misc) You specified an odd number of elements to initialize a hash,
2218 which is odd, because hashes come in key/value pairs.
2219
2220 =item Offset outside string
2221
2222 (F) You tried to do a read/write/send/recv operation with an offset
2223 pointing outside the buffer.  This is difficult to imagine.  The sole
2224 exception to this is that C<sysread()>ing past the buffer will extend
2225 the buffer and zero pad the new area.
2226
2227 =item oops: oopsAV
2228
2229 (S internal) An internal warning that the grammar is screwed up.
2230
2231 =item oops: oopsHV
2232
2233 (S internal) An internal warning that the grammar is screwed up.
2234
2235 =item Operation `%s': no method found, %s
2236
2237 (F) An attempt was made to perform an overloaded operation for which no
2238 handler was defined.  While some handlers can be autogenerated in terms
2239 of other handlers, there is no default handler for any operation, unless
2240 C<fallback> overloading key is specified to be true.  See L<overload>.
2241
2242 =item Operator or semicolon missing before %s
2243
2244 (S ambiguous) You used a variable or subroutine call where the parser
2245 was expecting an operator.  The parser has assumed you really meant to
2246 use an operator, but this is highly likely to be incorrect.  For
2247 example, if you say "*foo *foo" it will be interpreted as if you said
2248 "*foo * 'foo'".
2249
2250 =item "our" variable %s redeclared
2251
2252 (W misc) You seem to have already declared the same global once before
2253 in the current lexical scope.
2254
2255 =item Out of memory!
2256
2257 (X) The malloc() function returned 0, indicating there was insufficient
2258 remaining memory (or virtual memory) to satisfy the request.  Perl has
2259 no option but to exit immediately.
2260
2261 =item Out of memory during "large" request for %s
2262
2263 (F) The malloc() function returned 0, indicating there was insufficient
2264 remaining memory (or virtual memory) to satisfy the request. However,
2265 the request was judged large enough (compile-time default is 64K), so a
2266 possibility to shut down by trapping this error is granted.
2267
2268 =item Out of memory during request for %s
2269
2270 (X|F) The malloc() function returned 0, indicating there was
2271 insufficient remaining memory (or virtual memory) to satisfy the
2272 request.
2273
2274 The request was judged to be small, so the possibility to trap it
2275 depends on the way perl was compiled.  By default it is not trappable.
2276 However, if compiled for this, Perl may use the contents of C<$^M> as an
2277 emergency pool after die()ing with this message.  In this case the error
2278 is trappable I<once>.
2279
2280 =item Out of memory during ridiculously large request
2281
2282 (F) You can't allocate more than 2^31+"small amount" bytes.  This error
2283 is most likely to be caused by a typo in the Perl program. e.g.,
2284 C<$arr[time]> instead of C<$arr[$time]>.
2285
2286 =item Out of memory for yacc stack
2287
2288 (F) The yacc parser wanted to grow its stack so it could continue
2289 parsing, but realloc() wouldn't give it more memory, virtual or
2290 otherwise.
2291
2292 =item @ outside of string
2293
2294 (F) You had a pack template that specified an absolute position outside
2295 the string being unpacked.  See L<perlfunc/pack>.
2296
2297 =item %s package attribute may clash with future reserved word: %s
2298
2299 (W reserved) A lowercase attribute name was used that had a
2300 package-specific handler.  That name might have a meaning to Perl itself
2301 some day, even though it doesn't yet.  Perhaps you should use a
2302 mixed-case attribute name, instead.  See L<attributes>.
2303
2304 =item page overflow
2305
2306 (W io) A single call to write() produced more lines than can fit on a
2307 page.  See L<perlform>.
2308
2309 =item panic: %s
2310
2311 (P) An internal error.
2312
2313 =item panic: ck_grep
2314
2315 (P) Failed an internal consistency check trying to compile a grep.
2316
2317 =item panic: ck_split
2318
2319 (P) Failed an internal consistency check trying to compile a split.
2320
2321 =item panic: corrupt saved stack index
2322
2323 (P) The savestack was requested to restore more localized values than
2324 there are in the savestack.
2325
2326 =item panic: del_backref
2327
2328 (P) Failed an internal consistency check while trying to reset a weak
2329 reference.
2330
2331 =item panic: die %s
2332
2333 (P) We popped the context stack to an eval context, and then discovered
2334 it wasn't an eval context.
2335
2336 =item panic: do_match
2337
2338 (P) The internal pp_match() routine was called with invalid operational
2339 data.
2340
2341 =item panic: do_split
2342
2343 (P) Something terrible went wrong in setting up for the split.
2344
2345 =item panic: do_subst
2346
2347 (P) The internal pp_subst() routine was called with invalid operational
2348 data.
2349
2350 =item panic: do_trans
2351
2352 (P) The internal do_trans() routine was called with invalid operational
2353 data.
2354
2355 =item panic: frexp
2356
2357 (P) The library function frexp() failed, making printf("%f") impossible.
2358
2359 =item panic: goto
2360
2361 (P) We popped the context stack to a context with the specified label,
2362 and then discovered it wasn't a context we know how to do a goto in.
2363
2364 =item panic: INTERPCASEMOD
2365
2366 (P) The lexer got into a bad state at a case modifier.
2367
2368 =item panic: INTERPCONCAT
2369
2370 (P) The lexer got into a bad state parsing a string with brackets.
2371
2372 =item panic: kid popen errno read
2373
2374 (F) forked child returned an incomprehensible message about its errno.
2375
2376 =item panic: last
2377
2378 (P) We popped the context stack to a block context, and then discovered
2379 it wasn't a block context.
2380
2381 =item panic: leave_scope clearsv
2382
2383 (P) A writable lexical variable became read-only somehow within the
2384 scope.
2385
2386 =item panic: leave_scope inconsistency
2387
2388 (P) The savestack probably got out of sync.  At least, there was an
2389 invalid enum on the top of it.
2390
2391 =item panic: magic_killbackrefs
2392
2393 (P) Failed an internal consistency check while trying to reset all weak
2394 references to an object.
2395
2396 =item panic: malloc
2397
2398 (P) Something requested a negative number of bytes of malloc.
2399
2400 =item panic: mapstart
2401
2402 (P) The compiler is screwed up with respect to the map() function.
2403
2404 =item panic: null array
2405
2406 (P) One of the internal array routines was passed a null AV pointer.
2407
2408 =item panic: pad_alloc
2409
2410 (P) The compiler got confused about which scratch pad it was allocating
2411 and freeing temporaries and lexicals from.
2412
2413 =item panic: pad_free curpad
2414
2415 (P) The compiler got confused about which scratch pad it was allocating
2416 and freeing temporaries and lexicals from.
2417
2418 =item panic: pad_free po
2419
2420 (P) An invalid scratch pad offset was detected internally.
2421
2422 =item panic: pad_reset curpad
2423
2424 (P) The compiler got confused about which scratch pad it was allocating
2425 and freeing temporaries and lexicals from.
2426
2427 =item panic: pad_sv po
2428
2429 (P) An invalid scratch pad offset was detected internally.
2430
2431 =item panic: pad_swipe curpad
2432
2433 (P) The compiler got confused about which scratch pad it was allocating
2434 and freeing temporaries and lexicals from.
2435
2436 =item panic: pad_swipe po
2437
2438 (P) An invalid scratch pad offset was detected internally.
2439
2440 =item panic: pp_iter
2441
2442 (P) The foreach iterator got called in a non-loop context frame.
2443
2444 =item panic: realloc
2445
2446 (P) Something requested a negative number of bytes of realloc.
2447
2448 =item panic: restartop
2449
2450 (P) Some internal routine requested a goto (or something like it), and
2451 didn't supply the destination.
2452
2453 =item panic: return
2454
2455 (P) We popped the context stack to a subroutine or eval context, and
2456 then discovered it wasn't a subroutine or eval context.
2457
2458 =item panic: scan_num
2459
2460 (P) scan_num() got called on something that wasn't a number.
2461
2462 =item panic: sv_insert
2463
2464 (P) The sv_insert() routine was told to remove more string than there
2465 was string.
2466
2467 =item panic: top_env
2468
2469 (P) The compiler attempted to do a goto, or something weird like that.
2470
2471 =item panic: yylex
2472
2473 (P) The lexer got into a bad state while processing a case modifier.
2474
2475 =item Parentheses missing around "%s" list
2476
2477 (W parenthesis) You said something like
2478
2479     my $foo, $bar = @_;
2480
2481 when you meant
2482
2483     my ($foo, $bar) = @_;
2484
2485 Remember that "my", "our", and "local" bind tighter than comma.
2486
2487 =item Perl %s required--this is only version %s, stopped
2488
2489 (F) The module in question uses features of a version of Perl more
2490 recent than the currently running version.  How long has it been since
2491 you upgraded, anyway?  See L<perlfunc/require>.
2492
2493 =item PERL_SH_DIR too long
2494
2495 (F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
2496 C<sh>-shell in.  See "PERL_SH_DIR" in F<README.os2>.
2497
2498 =item perl: warning: Setting locale failed.
2499
2500 (S) The whole warning message will look something like:
2501
2502         perl: warning: Setting locale failed.
2503         perl: warning: Please check that your locale settings:
2504                 LC_ALL = "En_US",
2505                 LANG = (unset)
2506             are supported and installed on your system.
2507         perl: warning: Falling back to the standard locale ("C").
2508
2509 Exactly what were the failed locale settings varies.  In the above the
2510 settings were that the LC_ALL was "En_US" and the LANG had no value.
2511 This error means that Perl detected that you and/or your system
2512 administrator have set up the so-called variable system but Perl could
2513 not use those settings.  This was not dead serious, fortunately: there
2514 is a "default locale" called "C" that Perl can and will use, the script
2515 will be run.  Before you really fix the problem, however, you will get
2516 the same error message each time you run Perl.  How to really fix the
2517 problem can be found in L<perllocale> section B<LOCALE PROBLEMS>.
2518
2519 =item Permission denied
2520
2521 (F) The setuid emulator in suidperl decided you were up to no good.
2522
2523 =item pid %x not a child
2524
2525 (W exec) A warning peculiar to VMS.  Waitpid() was asked to wait for a
2526 process which isn't a subprocess of the current process.  While this is
2527 fine from VMS' perspective, it's probably not what you intended.
2528
2529 =item POSIX getpgrp can't take an argument
2530
2531 (F) Your system has POSIX getpgrp(), which takes no argument, unlike
2532 the BSD version, which takes a pid.
2533
2534 =item Possible attempt to put comments in qw() list
2535
2536 (W qw) qw() lists contain items separated by whitespace; as with literal
2537 strings, comment characters are not ignored, but are instead treated as
2538 literal data.  (You may have used different delimiters than the
2539 parentheses shown here; braces are also frequently used.)
2540
2541 You probably wrote something like this:
2542
2543     @list = qw(
2544         a # a comment
2545         b # another comment
2546     );
2547
2548 when you should have written this:
2549
2550     @list = qw(
2551         a
2552         b
2553     );
2554
2555 If you really want comments, build your list the
2556 old-fashioned way, with quotes and commas:
2557
2558     @list = (
2559         'a',    # a comment
2560         'b',    # another comment
2561     );
2562
2563 =item Possible attempt to separate words with commas
2564
2565 (W qw) qw() lists contain items separated by whitespace; therefore
2566 commas aren't needed to separate the items.  (You may have used
2567 different delimiters than the parentheses shown here; braces are also
2568 frequently used.)
2569
2570 You probably wrote something like this:
2571
2572     qw! a, b, c !;
2573
2574 which puts literal commas into some of the list items.  Write it without
2575 commas if you don't want them to appear in your data:
2576
2577     qw! a b c !;
2578
2579 =item Possible memory corruption: %s overflowed 3rd argument
2580
2581 (F) An ioctl() or fcntl() returned more than Perl was bargaining for.
2582 Perl guesses a reasonable buffer size, but puts a sentinel byte at the
2583 end of the buffer just in case.  This sentinel byte got clobbered, and
2584 Perl assumes that memory is now corrupted.  See L<perlfunc/ioctl>.
2585
2586 =item Possible Y2K bug: %s
2587
2588 (W y2k) You are concatenating the number 19 with another number, which
2589 could be a potential Year 2000 problem.
2590
2591 =item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
2592
2593 (W deprecated) You have written something like this:
2594
2595     sub doit
2596     {
2597         use attrs qw(locked);
2598     }
2599
2600 You should use the new declaration syntax instead.
2601
2602     sub doit : locked
2603     {
2604         ...
2605
2606 The C<use attrs> pragma is now obsolete, and is only provided for
2607 backward-compatibility. See L<perlsub/"Subroutine Attributes">.
2608
2609 =item Precedence problem: open %s should be open(%s)
2610
2611 (S precedence) The old irregular construct
2612
2613     open FOO || die;
2614
2615 is now misinterpreted as
2616
2617     open(FOO || die);
2618
2619 because of the strict regularization of Perl 5's grammar into unary and
2620 list operators.  (The old open was a little of both.)  You must put
2621 parentheses around the filehandle, or use the new "or" operator instead
2622 of "||".
2623
2624 =item Premature end of script headers
2625
2626 See Server error.
2627
2628 =item printf() on closed filehandle %s
2629
2630 (W closed) The filehandle you're writing to got itself closed sometime
2631 before now.  Check your logic flow.
2632
2633 =item print() on closed filehandle %s
2634
2635 (W closed) The filehandle you're printing on got itself closed sometime
2636 before now.  Check your logic flow.
2637
2638 =item Process terminated by SIG%s
2639
2640 (W) This is a standard message issued by OS/2 applications, while *nix
2641 applications die in silence.  It is considered a feature of the OS/2
2642 port.  One can easily disable this by appropriate sighandlers, see
2643 L<perlipc/"Signals">.  See also "Process terminated by SIGTERM/SIGINT"
2644 in F<README.os2>.
2645
2646 =item Prototype mismatch: %s vs %s
2647
2648 (S unsafe) The subroutine being declared or defined had previously been
2649 declared or defined with a different function prototype.
2650
2651 =item Range iterator outside integer range
2652
2653 (F) One (or both) of the numeric arguments to the range operator ".."
2654 are outside the range which can be represented by integers internally.
2655 One possible workaround is to force Perl to use magical string increment
2656 by prepending "0" to your numbers.
2657
2658 =item readline() on closed filehandle %s
2659
2660 (W closed) The filehandle you're reading from got itself closed sometime
2661 before now.  Check your logic flow.
2662
2663 =item Reallocation too large: %lx
2664
2665 (F) You can't allocate more than 64K on an MS-DOS machine.
2666
2667 =item realloc() of freed memory ignored
2668
2669 (S malloc) An internal routine called realloc() on something that had
2670 already been freed.
2671
2672 =item Recompile perl with B<-D>DEBUGGING to use B<-D> switch
2673
2674 (F debugging) You can't use the B<-D> option unless the code to produce
2675 the desired output is compiled into Perl, which entails some overhead,
2676 which is why it's currently left out of your copy.
2677
2678 =item Recursive inheritance detected in package '%s'
2679
2680 (F) More than 100 levels of inheritance were used.  Probably indicates
2681 an unintended loop in your inheritance hierarchy.
2682
2683 =item Recursive inheritance detected while looking for method '%s' in package '%s'
2684
2685 (F) More than 100 levels of inheritance were encountered while invoking
2686 a method.  Probably indicates an unintended loop in your inheritance
2687 hierarchy.
2688
2689 =item Reference found where even-sized list expected
2690
2691 (W misc) You gave a single reference where Perl was expecting a list
2692 with an even number of elements (for assignment to a hash). This usually
2693 means that you used the anon hash constructor when you meant to use
2694 parens. In any case, a hash requires key/value B<pairs>.
2695
2696     %hash = { one => 1, two => 2, };    # WRONG
2697     %hash = [ qw/ an anon array / ];    # WRONG
2698     %hash = ( one => 1, two => 2, );    # right
2699     %hash = qw( one 1 two 2 );                  # also fine
2700
2701 =item Reference is already weak
2702
2703 (W misc) You have attempted to weaken a reference that is already weak.
2704 Doing so has no effect.
2705
2706 =item Reference miscount in sv_replace()
2707
2708 (W internal) The internal sv_replace() function was handed a new SV with
2709 a reference count of other than 1.
2710
2711 =item regexp memory corruption
2712
2713 (P) The regular expression engine got confused by what the regular
2714 expression compiler gave it.
2715
2716 =item regexp *+ operand could be empty
2717
2718 (F) The part of the regexp subject to either the * or + quantifier could
2719 match an empty string.
2720
2721 =item regexp out of space
2722
2723 (P) A "can't happen" error, because safemalloc() should have caught it
2724 earlier.
2725
2726 =item Repeat count in pack overflows
2727
2728 (F) You can't specify a repeat count so large that it overflows your
2729 signed integers.  See L<perlfunc/pack>.
2730
2731 =item Repeat count in unpack overflows
2732
2733 (F) You can't specify a repeat count so large that it overflows your
2734 signed integers.  See L<perlfunc/unpack>.
2735
2736 =item Reversed %s= operator
2737
2738 (W syntax) You wrote your assignment operator backwards.  The = must
2739 always comes last, to avoid ambiguity with subsequent unary operators.
2740
2741 =item Runaway format
2742
2743 (F) Your format contained the ~~ repeat-until-blank sequence, but it
2744 produced 200 lines at once, and the 200th line looked exactly like the
2745 199th line.  Apparently you didn't arrange for the arguments to exhaust
2746 themselves, either by using ^ instead of @ (for scalar variables), or by
2747 shifting or popping (for array variables).  See L<perlform>.
2748
2749 =item Scalar value @%s[%s] better written as $%s[%s]
2750
2751 (W syntax) You've used an array slice (indicated by @) to select a
2752 single element of an array.  Generally it's better to ask for a scalar
2753 value (indicated by $).  The difference is that C<$foo[&bar]> always
2754 behaves like a scalar, both when assigning to it and when evaluating its
2755 argument, while C<@foo[&bar]> behaves like a list when you assign to it,
2756 and provides a list context to its subscript, which can do weird things
2757 if you're expecting only one subscript.
2758
2759 On the other hand, if you were actually hoping to treat the array
2760 element as a list, you need to look into how references work, because
2761 Perl will not magically convert between scalars and lists for you.  See
2762 L<perlref>.
2763
2764 =item Scalar value @%s{%s} better written as $%s{%s}
2765
2766 (W syntax) You've used a hash slice (indicated by @) to select a single
2767 element of a hash.  Generally it's better to ask for a scalar value
2768 (indicated by $).  The difference is that C<$foo{&bar}> always behaves
2769 like a scalar, both when assigning to it and when evaluating its
2770 argument, while C<@foo{&bar}> behaves like a list when you assign to it,
2771 and provides a list context to its subscript, which can do weird things
2772 if you're expecting only one subscript.
2773
2774 On the other hand, if you were actually hoping to treat the hash element
2775 as a list, you need to look into how references work, because Perl will
2776 not magically convert between scalars and lists for you.  See
2777 L<perlref>.
2778
2779 =item Script is not setuid/setgid in suidperl
2780
2781 (F) Oddly, the suidperl program was invoked on a script without a setuid
2782 or setgid bit set.  This doesn't make much sense.
2783
2784 =item Search pattern not terminated
2785
2786 (F) The lexer couldn't find the final delimiter of a // or m{}
2787 construct.  Remember that bracketing delimiters count nesting level.
2788 Missing the leading C<$> from a variable C<$m> may cause this error.
2789
2790 =item %sseek() on unopened file
2791
2792 (W unopened) You tried to use the seek() or sysseek() function on a
2793 filehandle that was either never opened or has since been closed.
2794
2795 =item select not implemented
2796
2797 (F) This machine doesn't implement the select() system call.
2798
2799 =item Semicolon seems to be missing
2800
2801 (W semicolon) A nearby syntax error was probably caused by a missing
2802 semicolon, or possibly some other missing operator, such as a comma.
2803
2804 =item semi-panic: attempt to dup freed string
2805
2806 (S internal) The internal newSVsv() routine was called to duplicate a
2807 scalar that had previously been marked as free.
2808
2809 =item sem%s not implemented
2810
2811 (F) You don't have System V semaphore IPC on your system.
2812
2813 =item send() on closed socket %s
2814
2815 (W closed) The socket you're sending to got itself closed sometime
2816 before now.  Check your logic flow.
2817
2818 =item Sequence (? incomplete
2819
2820 (F) A regular expression ended with an incomplete extension (?.  See
2821 L<perlre>.
2822
2823 =item Sequence (?%s...) not implemented
2824
2825 (F) A proposed regular expression extension has the character reserved
2826 but has not yet been written.  See L<perlre>.
2827
2828 =item Sequence (?%s...) not recognized
2829
2830 (F) You used a regular expression extension that doesn't make sense.
2831 See L<perlre>.
2832
2833 =item Sequence (?#... not terminated
2834
2835 (F) A regular expression comment must be terminated by a closing
2836 parenthesis.  Embedded parentheses aren't allowed.  See L<perlre>.
2837
2838 =item 500 Server error
2839
2840 See Server error.
2841
2842 =item Server error
2843
2844 This is the error message generally seen in a browser window when trying
2845 to run a CGI program (including SSI) over the web. The actual error text
2846 varies widely from server to server. The most frequently-seen variants
2847 are "500 Server error", "Method (something) not permitted", "Document
2848 contains no data", "Premature end of script headers", and "Did not
2849 produce a valid header".
2850
2851 B<This is a CGI error, not a Perl error>.
2852
2853 You need to make sure your script is executable, is accessible by the
2854 user CGI is running the script under (which is probably not the user
2855 account you tested it under), does not rely on any environment variables
2856 (like PATH) from the user it isn't running under, and isn't in a
2857 location where the CGI server can't find it, basically, more or less.
2858 Please see the following for more information:
2859
2860         http://www.perl.com/CPAN/doc/FAQs/cgi/idiots-guide.html
2861         http://www.perl.com/CPAN/doc/FAQs/cgi/perl-cgi-faq.html
2862         ftp://rtfm.mit.edu/pub/usenet/news.answers/www/cgi-faq
2863         http://hoohoo.ncsa.uiuc.edu/cgi/interface.html
2864         http://www-genome.wi.mit.edu/WWW/faqs/www-security-faq.html
2865
2866 You should also look at L<perlfaq9>.
2867
2868 =item setegid() not implemented
2869
2870 (F) You tried to assign to C<$)>, and your operating system doesn't
2871 support the setegid() system call (or equivalent), or at least Configure
2872 didn't think so.
2873
2874 =item seteuid() not implemented
2875
2876 (F) You tried to assign to C<< $> >>, and your operating system doesn't
2877 support the seteuid() system call (or equivalent), or at least Configure
2878 didn't think so.
2879
2880 =item setpgrp can't take arguments
2881
2882 (F) Your system has the setpgrp() from BSD 4.2, which takes no
2883 arguments, unlike POSIX setpgid(), which takes a process ID and process
2884 group ID.
2885
2886 =item setrgid() not implemented
2887
2888 (F) You tried to assign to C<$(>, and your operating system doesn't
2889 support the setrgid() system call (or equivalent), or at least Configure
2890 didn't think so.
2891
2892 =item setruid() not implemented
2893
2894 (F) You tried to assign to C<$<>, and your operating system doesn't
2895 support the setruid() system call (or equivalent), or at least Configure
2896 didn't think so.
2897
2898 =item setsockopt() on closed socket %s
2899
2900 (W closed) You tried to set a socket option on a closed socket.  Did you
2901 forget to check the return value of your socket() call?  See
2902 L<perlfunc/setsockopt>.
2903
2904 =item Setuid/gid script is writable by world
2905
2906 (F) The setuid emulator won't run a script that is writable by the
2907 world, because the world might have written on it already.
2908
2909 =item shm%s not implemented
2910
2911 (F) You don't have System V shared memory IPC on your system.
2912
2913 =item <> should be quotes
2914
2915 (F) You wrote C<< require <file> >> when you should have written
2916 C<require 'file'>.
2917
2918 =item /%s/ should probably be written as "%s"
2919
2920 (W syntax) You have used a pattern where Perl expected to find a string,
2921 as in the first argument to C<join>.  Perl will treat the true or false
2922 result of matching the pattern against $_ as the string, which is
2923 probably not what you had in mind.
2924
2925 =item shutdown() on closed socket %s
2926
2927 (W closed) You tried to do a shutdown on a closed socket.  Seems a bit
2928 superfluous.
2929
2930 =item SIG%s handler "%s" not defined
2931
2932 (W signal) The signal handler named in %SIG doesn't, in fact, exist.
2933 Perhaps you put it into the wrong package?
2934
2935 =item sort is now a reserved word
2936
2937 (F) An ancient error message that almost nobody ever runs into anymore.
2938 But before sort was a keyword, people sometimes used it as a filehandle.
2939
2940 =item Sort subroutine didn't return a numeric value
2941
2942 (F) A sort comparison routine must return a number.  You probably blew
2943 it by not using C<< <=> >> or C<cmp>, or by not using them correctly.
2944 See L<perlfunc/sort>.
2945
2946 =item Sort subroutine didn't return single value
2947
2948 (F) A sort comparison subroutine may not return a list value with more
2949 or less than one element.  See L<perlfunc/sort>.
2950
2951 =item Split loop
2952
2953 (P) The split was looping infinitely.  (Obviously, a split shouldn't
2954 iterate more times than there are characters of input, which is what
2955 happened.) See L<perlfunc/split>.
2956
2957 =item Statement unlikely to be reached
2958
2959 (W exec) You did an exec() with some statement after it other than a
2960 die().  This is almost always an error, because exec() never returns
2961 unless there was a failure.  You probably wanted to use system()
2962 instead, which does return.  To suppress this warning, put the exec() in
2963 a block by itself.
2964
2965 =item Stat on unopened file <%s>
2966
2967 (W unopened) You tried to use the stat() function (or an equivalent file
2968 test) on a filehandle that was either never opened or has since been
2969 closed.
2970
2971 =item Strange *+?{} on zero-length expression
2972
2973 (W regexp) You applied a regular expression quantifier in a place where
2974 it makes no sense, such as on a zero-width assertion.  Try putting the
2975 quantifier inside the assertion instead.  For example, the way to match
2976 "abc" provided that it is followed by three repetitions of "xyz" is
2977 C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
2978
2979 =item Stub found while resolving method `%s' overloading `%s' in package `%s'
2980
2981 (P) Overloading resolution over @ISA tree may be broken by importation
2982 stubs.  Stubs should never be implicitly created, but explicit calls to
2983 C<can> may break this.
2984
2985 =item Subroutine %s redefined
2986
2987 (W redefine) You redefined a subroutine.  To suppress this warning, say
2988
2989     {
2990         no warnings;
2991         eval "sub name { ... }";
2992     }
2993
2994 =item Substitution loop
2995
2996 (P) The substitution was looping infinitely.  (Obviously, a substitution
2997 shouldn't iterate more times than there are characters of input, which
2998 is what happened.)  See the discussion of substitution in
2999 L<perlop/"Quote and Quote-like Operators">.
3000
3001 =item Substitution pattern not terminated
3002
3003 (F) The lexer couldn't find the interior delimiter of a s/// or s{}{}
3004 construct.  Remember that bracketing delimiters count nesting level.
3005 Missing the leading C<$> from variable C<$s> may cause this error.
3006
3007 =item Substitution replacement not terminated
3008
3009 (F) The lexer couldn't find the final delimiter of a s/// or s{}{}
3010 construct.  Remember that bracketing delimiters count nesting level.
3011 Missing the leading C<$> from variable C<$s> may cause this error.
3012
3013 =item substr outside of string
3014
3015 (W substr),(F) You tried to reference a substr() that pointed outside of
3016 a string.  That is, the absolute value of the offset was larger than the
3017 length of the string.  See L<perlfunc/substr>.  This warning is fatal if
3018 substr is used in an lvalue context (as the left hand side of an
3019 assignment or as a subroutine argument for example).
3020
3021 =item suidperl is no longer needed since %s
3022
3023 (F) Your Perl was compiled with B<-D>SETUID_SCRIPTS_ARE_SECURE_NOW, but
3024 a version of the setuid emulator somehow got run anyway.
3025
3026 =item switching effective %s is not implemented
3027
3028 (F) While under the C<use filetest> pragma, we cannot switch the real
3029 and effective uids or gids.
3030
3031 =item syntax error
3032
3033 (F) Probably means you had a syntax error.  Common reasons include:
3034
3035     A keyword is misspelled.
3036     A semicolon is missing.
3037     A comma is missing.
3038     An opening or closing parenthesis is missing.
3039     An opening or closing brace is missing.
3040     A closing quote is missing.
3041
3042 Often there will be another error message associated with the syntax
3043 error giving more information.  (Sometimes it helps to turn on B<-w>.)
3044 The error message itself often tells you where it was in the line when
3045 it decided to give up.  Sometimes the actual error is several tokens
3046 before this, because Perl is good at understanding random input.
3047 Occasionally the line number may be misleading, and once in a blue moon
3048 the only way to figure out what's triggering the error is to call
3049 C<perl -c> repeatedly, chopping away half the program each time to see
3050 if the error went away.  Sort of the cybernetic version of S<20
3051 questions>.
3052
3053 =item syntax error at line %d: `%s' unexpected
3054
3055 (A) You've accidentally run your script through the Bourne shell instead
3056 of Perl.  Check the #! line, or manually feed your script into Perl
3057 yourself.
3058
3059 =item %s syntax OK
3060
3061 (F) The final summary message when a C<perl -c> succeeds.
3062
3063 =item System V %s is not implemented on this machine
3064
3065 (F) You tried to do something with a function beginning with "sem",
3066 "shm", or "msg" but that System V IPC is not implemented in your
3067 machine.  In some machines the functionality can exist but be
3068 unconfigured.  Consult your system support.
3069
3070 =item syswrite() on closed filehandle %s
3071
3072 (W closed) The filehandle you're writing to got itself closed sometime
3073 before now.  Check your logic flow.
3074
3075 =item Target of goto is too deeply nested
3076
3077 (F) You tried to use C<goto> to reach a label that was too deeply nested
3078 for Perl to reach.  Perl is doing you a favor by refusing.
3079
3080 =item tell() on unopened file
3081
3082 (W unopened) You tried to use the tell() function on a filehandle that
3083 was either never opened or has since been closed.
3084
3085 =item Test on unopened file <%s>
3086
3087 (W unopened) You tried to invoke a file test operator on a filehandle
3088 that isn't open.  Check your logic.  See also L<perlfunc/-X>.
3089
3090 =item That use of $[ is unsupported
3091
3092 (F) Assignment to C<$[> is now strictly circumscribed, and interpreted
3093 as a compiler directive.  You may say only one of
3094
3095     $[ = 0;
3096     $[ = 1;
3097     ...
3098     local $[ = 0;
3099     local $[ = 1;
3100     ...
3101
3102 This is to prevent the problem of one module changing the array base out
3103 from under another module inadvertently.  See L<perlvar/$[>.
3104
3105 =item The crypt() function is unimplemented due to excessive paranoia
3106
3107 (F) Configure couldn't find the crypt() function on your machine,
3108 probably because your vendor didn't supply it, probably because they
3109 think the U.S. Government thinks it's a secret, or at least that they
3110 will continue to pretend that it is.  And if you quote me on that, I
3111 will deny it.
3112
3113 =item The %s function is unimplemented
3114
3115 The function indicated isn't implemented on this architecture, according
3116 to the probings of Configure.
3117
3118 =item The stat preceding C<-l _> wasn't an lstat
3119
3120 (F) It makes no sense to test the current stat buffer for symbolic
3121 linkhood if the last stat that wrote to the stat buffer already went
3122 past the symlink to get to the real file.  Use an actual filename
3123 instead.
3124
3125 =item This Perl can't reset CRTL environ elements (%s)
3126
3127 =item This Perl can't set CRTL environ elements (%s=%s)
3128
3129 (W internal) Warnings peculiar to VMS.  You tried to change or delete an
3130 element of the CRTL's internal environ array, but your copy of Perl
3131 wasn't built with a CRTL that contained the setenv() function.  You'll
3132 need to rebuild Perl with a CRTL that does, or redefine
3133 F<PERL_ENV_TABLES> (see L<perlvms>) so that the environ array isn't the
3134 target of the change to
3135 %ENV which produced the warning.
3136
3137 =item times not implemented
3138
3139 (F) Your version of the C library apparently doesn't do times().  I
3140 suspect you're not running on Unix.
3141
3142 =item Too few args to syscall
3143
3144 (F) There has to be at least one argument to syscall() to specify the
3145 system call to call, silly dilly.
3146
3147 =item Too late for "B<-T>" option
3148
3149 (X) The #! line (or local equivalent) in a Perl script contains the
3150 B<-T> option, but Perl was not invoked with B<-T> in its command line.
3151 This is an error because, by the time Perl discovers a B<-T> in a
3152 script, it's too late to properly taint everything from the environment.
3153 So Perl gives up.
3154
3155 If the Perl script is being executed as a command using the #!
3156 mechanism (or its local equivalent), this error can usually be fixed by
3157 editing the #! line so that the B<-T> option is a part of Perl's first
3158 argument: e.g. change C<perl -n -T> to C<perl -T -n>.
3159
3160 If the Perl script is being executed as C<perl scriptname>, then the
3161 B<-T> option must appear on the command line: C<perl -T scriptname>.
3162
3163 =item Too late for "-%s" option
3164
3165 (X) The #! line (or local equivalent) in a Perl script contains the
3166 B<-M> or B<-m> option.  This is an error because B<-M> and B<-m> options
3167 are not intended for use inside scripts.  Use the C<use> pragma instead.
3168
3169 =item Too late to run %s block
3170
3171 (W void) A CHECK or INIT block is being defined during run time proper,
3172 when the opportunity to run them has already passed.  Perhaps you are
3173 loading a file with C<require> or C<do> when you should be using C<use>
3174 instead.  Or perhaps you should put the C<require> or C<do> inside a
3175 BEGIN block.
3176
3177 =item Too many args to syscall
3178
3179 (F) Perl supports a maximum of only 14 args to syscall().
3180
3181 =item Too many arguments for %s
3182
3183 (F) The function requires fewer arguments than you specified.
3184
3185 =item Too many )'s
3186
3187 (A) You've accidentally run your script through B<csh> instead of Perl.
3188 Check the #! line, or manually feed your script into Perl yourself.
3189
3190 =item Too many ('s
3191
3192 =item trailing \ in regexp
3193
3194 (F) The regular expression ends with an unbackslashed backslash.
3195 Backslash it.   See L<perlre>.
3196
3197 =item Transliteration pattern not terminated
3198
3199 (F) The lexer couldn't find the interior delimiter of a tr/// or tr[][]
3200 or y/// or y[][] construct.  Missing the leading C<$> from variables
3201 C<$tr> or C<$y> may cause this error.
3202
3203 =item Transliteration replacement not terminated
3204
3205 (F) The lexer couldn't find the final delimiter of a tr/// or tr[][]
3206 construct.
3207
3208 =item truncate not implemented
3209
3210 (F) Your machine doesn't implement a file truncation mechanism that
3211 Configure knows about.
3212
3213 =item Type of arg %d to %s must be %s (not %s)
3214
3215 (F) This function requires the argument in that position to be of a
3216 certain type.  Arrays must be @NAME or C<@{EXPR}>.  Hashes must be
3217 %NAME or C<%{EXPR}>.  No implicit dereferencing is allowed--use the
3218 {EXPR} forms as an explicit dereference.  See L<perlref>.
3219
3220 =item umask: argument is missing initial 0
3221
3222 (W umask) A umask of 222 is incorrect.  It should be 0222, because octal
3223 literals always start with 0 in Perl, as in C.
3224
3225 =item umask not implemented
3226
3227 (F) Your machine doesn't implement the umask function and you tried to
3228 use it to restrict permissions for yourself (EXPR & 0700).
3229
3230 =item Unable to create sub named "%s"
3231
3232 (F) You attempted to create or access a subroutine with an illegal name.
3233
3234 =item Unbalanced context: %d more PUSHes than POPs
3235
3236 (W internal) The exit code detected an internal inconsistency in how
3237 many execution contexts were entered and left.
3238
3239 =item Unbalanced saves: %d more saves than restores
3240
3241 (W internal) The exit code detected an internal inconsistency in how
3242 many values were temporarily localized.
3243
3244 =item Unbalanced scopes: %d more ENTERs than LEAVEs
3245
3246 (W internal) The exit code detected an internal inconsistency in how
3247 many blocks were entered and left.
3248
3249 =item Unbalanced tmps: %d more allocs than frees
3250
3251 (W internal) The exit code detected an internal inconsistency in how
3252 many mortal scalars were allocated and freed.
3253
3254 =item Undefined format "%s" called
3255
3256 (F) The format indicated doesn't seem to exist.  Perhaps it's really in
3257 another package?  See L<perlform>.
3258
3259 =item Undefined sort subroutine "%s" called
3260
3261 (F) The sort comparison routine specified doesn't seem to exist.
3262 Perhaps it's in a different package?  See L<perlfunc/sort>.
3263
3264 =item Undefined subroutine &%s called
3265
3266 (F) The subroutine indicated hasn't been defined, or if it was, it has
3267 since been undefined.
3268
3269 =item Undefined subroutine called
3270
3271 (F) The anonymous subroutine you're trying to call hasn't been defined,
3272 or if it was, it has since been undefined.
3273
3274 =item Undefined subroutine in sort
3275
3276 (F) The sort comparison routine specified is declared but doesn't seem
3277 to have been defined yet.  See L<perlfunc/sort>.
3278
3279 =item Undefined top format "%s" called
3280
3281 (F) The format indicated doesn't seem to exist.  Perhaps it's really in
3282 another package?  See L<perlform>.
3283
3284 =item Undefined value assigned to typeglob
3285
3286 (W misc) An undefined value was assigned to a typeglob, a la
3287 C<*foo = undef>.  This does nothing.  It's possible that you really mean
3288 C<undef *foo>.
3289
3290 =item %s: Undefined variable
3291
3292 (A) You've accidentally run your script through B<csh> instead of Perl.
3293 Check the #! line, or manually feed your script into Perl yourself.
3294
3295 =item unexec of %s into %s failed!
3296
3297 (F) The unexec() routine failed for some reason.  See your local FSF
3298 representative, who probably put it there in the first place.
3299
3300 =item Unknown BYTEORDER
3301
3302 (F) There are no byte-swapping functions for a machine with this byte
3303 order.
3304
3305 =item Unknown open() mode '%s'
3306
3307 (F) The second argument of 3-argument open() is not among the list
3308 of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
3309 C<< +> >>, C<<< +>> >>>, C<-|>, C<|->.
3310
3311 =item Unknown process %x sent message to prime_env_iter: %s
3312
3313 (P) An error peculiar to VMS.  Perl was reading values for %ENV before
3314 iterating over it, and someone else stuck a message in the stream of
3315 data Perl expected.  Someone's very confused, or perhaps trying to
3316 subvert Perl's population of %ENV for nefarious purposes.
3317
3318 =item unmatched [] in regexp
3319
3320 (F) The brackets around a character class must match.  If you wish to
3321 include a closing bracket in a character class, backslash it or put it
3322 first.  See L<perlre>.
3323
3324 =item unmatched () in regexp
3325
3326 (F) Unbackslashed parentheses must always be balanced in regular
3327 expressions.  If you're a vi user, the % key is valuable for finding the
3328 matching parenthesis.  See L<perlre>.
3329
3330 =item Unmatched right %s bracket
3331
3332 (F) The lexer counted more closing curly or square brackets than opening
3333 ones, so you're probably missing a matching opening bracket.  As a
3334 general rule, you'll find the missing one (so to speak) near the place
3335 you were last editing.
3336
3337 =item Unquoted string "%s" may clash with future reserved word
3338
3339 (W reserved) You used a bareword that might someday be claimed as a
3340 reserved word.  It's best to put such a word in quotes, or capitalize it
3341 somehow, or insert an underbar into it.  You might also declare it as a
3342 subroutine.
3343
3344 =item Unrecognized character %s
3345
3346 (F) The Perl parser has no idea what to do with the specified character
3347 in your Perl script (or eval).  Perhaps you tried to run a compressed
3348 script, a binary program, or a directory as a Perl program.
3349
3350 =item /%s/: Unrecognized escape \\%c in character class passed through
3351
3352 (W regexp) You used a backslash-character combination which is not
3353 recognized by Perl inside character classes.  The character was
3354 understood literally.
3355
3356 =item /%s/: Unrecognized escape \\%c passed through
3357
3358 (W regexp) You used a backslash-character combination which is not
3359 recognized by Perl.  This combination appears in an interpolated
3360 variable or a C<'>-delimited regular expression.  The character was
3361 understood literally.
3362
3363 =item Unrecognized escape \\%c passed through
3364
3365 (W misc) You used a backslash-character combination which is not
3366 recognized by Perl.
3367
3368 =item Unrecognized signal name "%s"
3369
3370 (F) You specified a signal name to the kill() function that was not
3371 recognized.  Say C<kill -l> in your shell to see the valid signal names
3372 on your system.
3373
3374 =item Unrecognized switch: -%s  (-h will show valid options)
3375
3376 (F) You specified an illegal option to Perl.  Don't do that.  (If you
3377 think you didn't do that, check the #! line to see if it's supplying the
3378 bad switch on your behalf.)
3379
3380 =item Unsuccessful %s on filename containing newline
3381
3382 (W newline) A file operation was attempted on a filename, and that
3383 operation failed, PROBABLY because the filename contained a newline,
3384 PROBABLY because you forgot to chop() or chomp() it off.  See
3385 L<perlfunc/chomp>.
3386
3387 =item Unsupported directory function "%s" called
3388
3389 (F) Your machine doesn't support opendir() and readdir().
3390
3391 =item Unsupported function %s
3392
3393 (F) This machine doesn't implement the indicated function, apparently.
3394 At least, Configure doesn't think so.
3395
3396 =item Unsupported function fork
3397
3398 (F) Your version of executable does not support forking.
3399
3400 Note that under some systems, like OS/2, there may be different flavors
3401 of Perl executables, some of which may support fork, some not. Try
3402 changing the name you call Perl by to C<perl_>, C<perl__>, and so on.
3403
3404 =item Unsupported socket function "%s" called
3405
3406 (F) Your machine doesn't support the Berkeley socket mechanism, or at
3407 least that's what Configure thought.
3408
3409 =item Unterminated attribute list
3410
3411 (F) The lexer found something other than a simple identifier at the
3412 start of an attribute, and it wasn't a semicolon or the start of a
3413 block.  Perhaps you terminated the parameter list of the previous
3414 attribute too soon.  See L<attributes>.
3415
3416 =item Unterminated attribute parameter in attribute list
3417
3418 (F) The lexer saw an opening (left) parenthesis character while parsing
3419 an attribute list, but the matching closing (right) parenthesis
3420 character was not found.  You may need to add (or remove) a backslash
3421 character to get your parentheses to balance.  See L<attributes>.
3422
3423 =item Unterminated <> operator
3424
3425 (F) The lexer saw a left angle bracket in a place where it was expecting
3426 a term, so it's looking for the corresponding right angle bracket, and
3427 not finding it.  Chances are you left some needed parentheses out
3428 earlier in the line, and you really meant a "less than".
3429
3430 =item untie attempted while %d inner references still exist
3431
3432 (W untie) A copy of the object returned from C<tie> (or C<tied>) was
3433 still valid when C<untie> was called.
3434
3435 =item Useless use of %s in void context
3436
3437 (W void) You did something without a side effect in a context that does
3438 nothing with the return value, such as a statement that doesn't return a
3439 value from a block, or the left side of a scalar comma operator.  Very
3440 often this points not to stupidity on your part, but a failure of Perl
3441 to parse your program the way you thought it would.  For example, you'd
3442 get this if you mixed up your C precedence with Python precedence and
3443 said
3444
3445     $one, $two = 1, 2;
3446
3447 when you meant to say
3448
3449     ($one, $two) = (1, 2);
3450
3451 Another common error is to use ordinary parentheses to construct a list
3452 reference when you should be using square or curly brackets, for
3453 example, if you say
3454
3455     $array = (1,2);
3456
3457 when you should have said
3458
3459     $array = [1,2];
3460
3461 The square brackets explicitly turn a list value into a scalar value,
3462 while parentheses do not.  So when a parenthesized list is evaluated in
3463 a scalar context, the comma is treated like C's comma operator, which
3464 throws away the left argument, which is not what you want.  See
3465 L<perlref> for more on this.
3466
3467 =item Useless use of "re" pragma
3468
3469 (W) You did C<use re;> without any arguments.   That isn't very useful.
3470
3471 =item "use" not allowed in expression
3472
3473 (F) The "use" keyword is recognized and executed at compile time, and
3474 returns no useful value.  See L<perlmod>.
3475
3476 =item Use of bare << to mean <<"" is deprecated
3477
3478 (D deprecated) You are now encouraged to use the explicitly quoted form
3479 if you wish to use an empty line as the terminator of the here-document.
3480
3481 =item Use of implicit split to @_ is deprecated
3482
3483 (D deprecated) It makes a lot of work for the compiler when you clobber
3484 a subroutine's argument list, so it's better if you assign the results
3485 of a split() explicitly to an array (or list).
3486
3487 =item Use of inherited AUTOLOAD for non-method %s() is deprecated
3488
3489 (D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
3490 are looked up as methods (using the C<@ISA> hierarchy) even when the
3491 subroutines to be autoloaded were called as plain functions (e.g.
3492 C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or C<<
3493 $obj->bar() >>).
3494
3495 This bug will be rectified in future by using method lookup only for
3496 methods' C<AUTOLOAD>s.  However, there is a significant base of existing
3497 code that may be using the old behavior.  So, as an interim step, Perl
3498 currently issues an optional warning when non-methods use inherited
3499 C<AUTOLOAD>s.
3500
3501 The simple rule is:  Inheritance will not work when autoloading
3502 non-methods.  The simple fix for old code is:  In any module that used
3503 to depend on inheriting C<AUTOLOAD> for non-methods from a base class
3504 named C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during
3505 startup.
3506
3507 In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);>
3508 you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
3509 C<use AutoLoader 'AUTOLOAD';>.
3510
3511 =item Use of %s in printf format not supported
3512
3513 (F) You attempted to use a feature of printf that is accessible from
3514 only C.  This usually means there's a better way to do it in Perl.
3515
3516 =item Use of $* is deprecated
3517
3518 (D deprecated) This variable magically turned on multi-line pattern
3519 matching, both for you and for any luckless subroutine that you happen
3520 to call.  You should use the new C<//m> and C<//s> modifiers now to do
3521 that without the dangerous action-at-a-distance effects of C<$*>.
3522
3523 =item Use of %s is deprecated
3524
3525 (D deprecated) The construct indicated is no longer recommended for use,
3526 generally because there's a better way to do it, and also because the
3527 old way has bad side effects.
3528
3529 =item Use of $# is deprecated
3530
3531 (D deprecated) This was an ill-advised attempt to emulate a poorly
3532 defined B<awk> feature.  Use an explicit printf() or sprintf() instead.
3533
3534 =item Use of reserved word "%s" is deprecated
3535
3536 (D deprecated) The indicated bareword is a reserved word.  Future
3537 versions of perl may use it as a keyword, so you're better off either
3538 explicitly quoting the word in a manner appropriate for its context of
3539 use, or using a different name altogether.  The warning can be
3540 suppressed for subroutine names by either adding a C<&> prefix, or using
3541 a package qualifier, e.g. C<&our()>, or C<Foo::our()>.
3542
3543 =item Use of uninitialized value%s
3544
3545 (W uninitialized) An undefined value was used as if it were already
3546 defined.  It was interpreted as a "" or a 0, but maybe it was a mistake.
3547 To suppress this warning assign a defined value to your variables.
3548
3549 To help you figure out what was undefined, perl tells you what operation
3550 you used the undefined value in.  Note, however, that perl optimizes your
3551 program and the operation displayed in the warning may not necessarily
3552 appear literally in your program.  For example, C<"that $foo"> is
3553 usually optimized into C<"that " . $foo>, and the warning will refer to
3554 the C<concatenation (.)> operator, even though there is no C<.> in your
3555 program.
3556
3557 =item Value of %s can be "0"; test with defined()
3558
3559 (W misc) In a conditional expression, you used <HANDLE>, <*> (glob),
3560 C<each()>, or C<readdir()> as a boolean value.  Each of these constructs
3561 can return a value of "0"; that would make the conditional expression
3562 false, which is probably not what you intended.  When using these
3563 constructs in conditional expressions, test their values with the
3564 C<defined> operator.
3565
3566 =item Value of CLI symbol "%s" too long
3567
3568 (W misc) A warning peculiar to VMS.  Perl tried to read the value of an
3569 %ENV element from a CLI symbol table, and found a resultant string
3570 longer than 1024 characters.  The return value has been truncated to
3571 1024 characters.
3572
3573 =item Variable "%s" is not imported%s
3574
3575 (F) While "use strict" in effect, you referred to a global variable that
3576 you apparently thought was imported from another module, because
3577 something else of the same name (usually a subroutine) is exported by
3578 that module.  It usually means you put the wrong funny character on the
3579 front of your variable.
3580
3581 =item "%s" variable %s masks earlier declaration in same %s
3582
3583 (W misc) A "my" or "our" variable has been redeclared in the current
3584 scope or statement, effectively eliminating all access to the previous
3585 instance.  This is almost always a typographical error.  Note that the
3586 earlier variable will still exist until the end of the scope or until
3587 all closure referents to it are destroyed.
3588
3589 =item Variable "%s" may be unavailable
3590
3591 (W closure) An inner (nested) I<anonymous> subroutine is inside a
3592 I<named> subroutine, and outside that is another subroutine; and the
3593 anonymous (innermost) subroutine is referencing a lexical variable
3594 defined in the outermost subroutine.  For example:
3595
3596    sub outermost { my $a; sub middle { sub { $a } } }
3597
3598 If the anonymous subroutine is called or referenced (directly or
3599 indirectly) from the outermost subroutine, it will share the variable as
3600 you would expect.  But if the anonymous subroutine is called or
3601 referenced when the outermost subroutine is not active, it will see the
3602 value of the shared variable as it was before and during the *first*
3603 call to the outermost subroutine, which is probably not what you want.
3604
3605 In these circumstances, it is usually best to make the middle subroutine
3606 anonymous, using the C<sub {}> syntax.  Perl has specific support for
3607 shared variables in nested anonymous subroutines; a named subroutine in
3608 between interferes with this feature.
3609
3610 =item Variable syntax
3611
3612 (A) You've accidentally run your script through B<csh> instead
3613 of Perl.  Check the #! line, or manually feed your script into
3614 Perl yourself.
3615
3616 =item Variable "%s" will not stay shared
3617
3618 (W closure) An inner (nested) I<named> subroutine is referencing a
3619 lexical variable defined in an outer subroutine.
3620
3621 When the inner subroutine is called, it will probably see the value of
3622 the outer subroutine's variable as it was before and during the *first*
3623 call to the outer subroutine; in this case, after the first call to the
3624 outer subroutine is complete, the inner and outer subroutines will no
3625 longer share a common value for the variable.  In other words, the
3626 variable will no longer be shared.
3627
3628 Furthermore, if the outer subroutine is anonymous and references a
3629 lexical variable outside itself, then the outer and inner subroutines
3630 will I<never> share the given variable.
3631
3632 This problem can usually be solved by making the inner subroutine
3633 anonymous, using the C<sub {}> syntax.  When inner anonymous subs that
3634 reference variables in outer subroutines are called or referenced, they
3635 are automatically rebound to the current values of such variables.
3636
3637 =item Version number must be a constant number
3638
3639 (P) The attempt to translate a C<use Module n.n LIST> statement into
3640 its equivalent C<BEGIN> block found an internal inconsistency with
3641 the version number.
3642
3643 =item Warning: something's wrong
3644
3645 (W) You passed warn() an empty string (the equivalent of C<warn "">) or
3646 you called it with no args and C<$_> was empty.
3647
3648 =item Warning: unable to close filehandle %s properly
3649
3650 (S) The implicit close() done by an open() got an error indication on
3651 the close().  This usually indicates your file system ran out of disk
3652 space.
3653
3654 =item Warning: Use of "%s" without parentheses is ambiguous
3655
3656 (S ambiguous) You wrote a unary operator followed by something that
3657 looks like a binary operator that could also have been interpreted as a
3658 term or unary operator.  For instance, if you know that the rand
3659 function has a default argument of 1.0, and you write
3660
3661     rand + 5;
3662
3663 you may THINK you wrote the same thing as
3664
3665     rand() + 5;
3666
3667 but in actual fact, you got
3668
3669     rand(+5);
3670
3671 So put in parentheses to say what you really mean.
3672
3673 =item write() on closed filehandle %s
3674
3675 (W closed) The filehandle you're writing to got itself closed sometime
3676 before now.  Check your logic flow.
3677
3678 =item X outside of string
3679
3680 (F) You had a pack template that specified a relative position before
3681 the beginning of the string being unpacked.  See L<perlfunc/pack>.
3682
3683 =item x outside of string
3684
3685 (F) You had a pack template that specified a relative position after
3686 the end of the string being unpacked.  See L<perlfunc/pack>.
3687
3688 =item Xsub "%s" called in sort
3689
3690 (F) The use of an external subroutine as a sort comparison is not yet
3691 supported.
3692
3693 =item Xsub called in sort
3694
3695 (F) The use of an external subroutine as a sort comparison is not yet
3696 supported.
3697
3698 =item You can't use C<-l> on a filehandle
3699
3700 (F) A filehandle represents an opened file, and when you opened the file
3701 it already went past any symlink you are presumably trying to look for.
3702 Use a filename instead.
3703
3704 =item YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!
3705
3706 (F) And you probably never will, because you probably don't have the
3707 sources to your kernel, and your vendor probably doesn't give a rip
3708 about what you want.  Your best bet is to use the wrapsuid script in the
3709 eg directory to put a setuid C wrapper around your script.
3710
3711 =item You need to quote "%s"
3712
3713 (W syntax) You assigned a bareword as a signal handler name.
3714 Unfortunately, you already have a subroutine of that name declared,
3715 which means that Perl 5 will try to call the subroutine when the
3716 assignment is executed, which is probably not what you want.  (If it IS
3717 what you want, put an & in front.)
3718
3719 =back
3720
3721 =cut