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