diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perldiag.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/pods/perldiag.pod | 5763 |
1 files changed, 0 insertions, 5763 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perldiag.pod b/Master/tlpkg/tlperl/lib/pods/perldiag.pod deleted file mode 100644 index 9a8c9347a88..00000000000 --- a/Master/tlpkg/tlperl/lib/pods/perldiag.pod +++ /dev/null @@ -1,5763 +0,0 @@ -=head1 NAME - -perldiag - various Perl diagnostics - -=head1 DESCRIPTION - -These messages are classified as follows (listed in increasing order of -desperation): - - (W) A warning (optional). - (D) A deprecation (enabled by default). - (S) A severe warning (enabled by default). - (F) A fatal error (trappable). - (P) An internal error you should never see (trappable). - (X) A very fatal error (nontrappable). - (A) An alien error message (not generated by Perl). - -The majority of messages from the first three classifications above -(W, D & S) can be controlled using the C<warnings> pragma. - -If a message can be controlled by the C<warnings> pragma, its warning -category is included with the classification letter in the description -below. - -Optional warnings are enabled by using the C<warnings> pragma or the B<-w> -and B<-W> switches. Warnings may be captured by setting C<$SIG{__WARN__}> -to a reference to a routine that will be called on each warning instead -of printing it. See L<perlvar>. - -Severe warnings are always enabled, unless they are explicitly disabled -with the C<warnings> pragma or the B<-X> switch. - -Trappable errors may be trapped using the eval operator. See -L<perlfunc/eval>. In almost all cases, warnings may be selectively -disabled or promoted to fatal errors using the C<warnings> pragma. -See L<warnings>. - -The messages are in alphabetical order, without regard to upper or -lower-case. Some of these messages are generic. Spots that vary are -denoted with a %s or other printf-style escape. These escapes are -ignored by the alphabetical order, as are all characters other than -letters. To look up your message, just ignore anything that is not a -letter. - -=over 4 - -=item accept() on closed socket %s - -(W closed) You tried to do an accept on a closed socket. Did you forget -to check the return value of your socket() call? See -L<perlfunc/accept>. - -=item Allocation too large: %x - -(X) You can't allocate more than 64K on an MS-DOS machine. - -=item '%c' allowed only after types %s - -(F) The modifiers '!', '<' and '>' are allowed in pack() or unpack() only -after certain types. See L<perlfunc/pack>. - -=item Ambiguous call resolved as CORE::%s(), qualify as such or use & - -(W ambiguous) A subroutine you have declared has the same name as a Perl -keyword, and you have used the name without qualification for calling -one or the other. Perl decided to call the builtin because the -subroutine is not imported. - -To force interpretation as a subroutine call, either put an ampersand -before the subroutine name, or qualify the name with its package. -Alternatively, you can import the subroutine (or pretend that it's -imported with the C<use subs> pragma). - -To silently interpret it as the Perl operator, use the C<CORE::> prefix -on the operator (e.g. C<CORE::log($x)>) or declare the subroutine -to be an object method (see L<perlsub/"Subroutine Attributes"> or -L<attributes>). - -=item Ambiguous range in transliteration operator - -(F) You wrote something like C<tr/a-z-0//> which doesn't mean anything at -all. To include a C<-> character in a transliteration, put it either -first or last. (In the past, C<tr/a-z-0//> was synonymous with -C<tr/a-y//>, which was probably not what you would have expected.) - -=item Ambiguous use of %s resolved as %s - -(W ambiguous)(S) You said something that may not be interpreted the way -you thought. Normally it's pretty easy to disambiguate it by supplying -a missing quote, operator, parenthesis pair or declaration. - -=item Ambiguous use of %c resolved as operator %c - -(W ambiguous) C<%>, C<&>, and C<*> are both infix operators (modulus, -bitwise and, and multiplication) I<and> initial special characters -(denoting hashes, subroutines and typeglobs), and you said something -like C<*foo * foo> that might be interpreted as either of them. We -assumed you meant the infix operator, but please try to make it more -clear -- in the example given, you might write C<*foo * foo()> if you -really meant to multiply a glob by the result of calling a function. - -=item Ambiguous use of %c{%s} resolved to %c%s - -(W ambiguous) You wrote something like C<@{foo}>, which might be -asking for the variable C<@foo>, or it might be calling a function -named foo, and dereferencing it as an array reference. If you wanted -the variable, you can just write C<@foo>. If you wanted to call the -function, write C<@{foo()}> ... or you could just not have a variable -and a function with the same name, and save yourself a lot of trouble. - -=item Ambiguous use of %c{%s[...]} resolved to %c%s[...] - -=item Ambiguous use of %c{%s{...}} resolved to %c%s{...} - -(W ambiguous) You wrote something like C<${foo[2]}> (where foo represents -the name of a Perl keyword), which might be looking for element number -2 of the array named C<@foo>, in which case please write C<$foo[2]>, or you -might have meant to pass an anonymous arrayref to the function named -foo, and then do a scalar deref on the value it returns. If you meant -that, write C<${foo([2])}>. - -In regular expressions, the C<${foo[2]}> syntax is sometimes necessary -to disambiguate between array subscripts and character classes. -C</$length[2345]/>, for instance, will be interpreted as C<$length> followed -by the character class C<[2345]>. If an array subscript is what you -want, you can avoid the warning by changing C</${length[2345]}/> to the -unsightly C</${\$length[2345]}/>, by renaming your array to something -that does not coincide with a built-in keyword, or by simply turning -off warnings with C<no warnings 'ambiguous';>. - -=item Ambiguous use of -%s resolved as -&%s() - -(W ambiguous) You wrote something like C<-foo>, which might be the -string C<"-foo">, or a call to the function C<foo>, negated. If you meant -the string, just write C<"-foo">. If you meant the function call, -write C<-foo()>. - -=item Ambiguous use of 's//le...' resolved as 's// le...'; Rewrite as 's//el' if you meant 'use locale rules and evaluate rhs as an expression'. In Perl 5.18, it will be resolved the other way - -(W deprecated, ambiguous) You wrote a pattern match with substitution -immediately followed by "le". In Perl 5.16 and earlier, this is -resolved as meaning to take the result of the substitution, and see if -it is stringwise less-than-or-equal-to what follows in the expression. -Having the "le" immediately following a pattern is deprecated behavior, -so in Perl 5.18, this expression will be resolved as meaning to do the -pattern match using the rules of the current locale, and evaluate the -rhs as an expression when doing the substitution. In 5.14, and 5.16 if -you want the latter interpretation, you can simply write "el" instead. -But note that the C</l> modifier should not be used explicitly anyway; -you should use C<use locale> instead. See L<perllocale>. - -=item '|' and '<' may not both be specified on command line - -(F) An error peculiar to VMS. Perl does its own command line -redirection, and found that STDIN was a pipe, and that you also tried to -redirect STDIN using '<'. Only one STDIN stream to a customer, please. - -=item '|' and '>' may not both be specified on command line - -(F) An error peculiar to VMS. Perl does its own command line -redirection, and thinks you tried to redirect stdout both to a file and -into a pipe to another command. You need to choose one or the other, -though nothing's stopping you from piping into a program or Perl script -which 'splits' output into two streams, such as - - open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!"; - while (<STDIN>) { - print; - print OUT; - } - close OUT; - -=item Applying %s to %s will act on scalar(%s) - -(W misc) The pattern match (C<//>), substitution (C<s///>), and -transliteration (C<tr///>) operators work on scalar values. If you apply -one of them to an array or a hash, it will convert the array or hash to -a scalar value (the length of an array, or the population info of a -hash) and then work on that scalar value. This is probably not what -you meant to do. See L<perlfunc/grep> and L<perlfunc/map> for -alternatives. - -=item Arg too short for msgsnd - -(F) msgsnd() requires a string at least as long as sizeof(long). - -=item %s argument is not a HASH or ARRAY element or a subroutine - -(F) The argument to exists() must be a hash or array element or a -subroutine with an ampersand, such as: - - $foo{$bar} - $ref->{"susie"}[12] - &do_something - -=item %s argument is not a HASH or ARRAY element or slice - -(F) The argument to delete() must be either a hash or array element, -such as: - - $foo{$bar} - $ref->{"susie"}[12] - -or a hash or array slice, such as: - - @foo[$bar, $baz, $xyzzy] - @{$ref->[12]}{"susie", "queue"} - -=item %s argument is not a subroutine name - -(F) The argument to exists() for C<exists &sub> must be a subroutine -name, and not a subroutine call. C<exists &sub()> will generate this -error. - -=item Argument "%s" isn't numeric%s - -(W numeric) The indicated string was fed as an argument to an operator -that expected a numeric value instead. If you're fortunate the message -will identify which operator was so unfortunate. - -=item Argument list not closed for PerlIO layer "%s" - -(W layer) When pushing a layer with arguments onto the Perl I/O -system you forgot the ) that closes the argument list. (Layers -take care of transforming data between external and internal -representations.) Perl stopped parsing the layer list at this -point and did not attempt to push this layer. If your program -didn't explicitly request the failing operation, it may be the -result of the value of the environment variable PERLIO. - -=item Array @%s missing the @ in argument %d of %s() - -(D deprecated) Really old Perl let you omit the @ on array names in some -spots. This is now heavily deprecated. - -=item assertion botched: %s - -(X) The malloc package that comes with Perl had an internal failure. - -=item Assertion failed: file "%s" - -(X) A general assertion failed. The file in question must be examined. - -=item Assigning non-zero to $[ is no longer possible - -(F) When the "array_base" feature is disabled (e.g., under C<use v5.16;>) -the special variable C<$[>, which is deprecated, is now a fixed zero value. - -=item Assignment to both a list and a scalar - -(F) If you assign to a conditional operator, the 2nd and 3rd arguments -must either both be scalars or both be lists. Otherwise Perl won't -know which context to supply to the right side. - -=item A thread exited while %d threads were running - -(W threads)(S) When using threaded Perl, a thread (not necessarily -the main thread) exited while there were still other threads running. -Usually it's a good idea first to collect the return values of the -created threads by joining them, and only then to exit from the main -thread. See L<threads>. - -=item Attempt to access disallowed key '%s' in a restricted hash - -(F) The failing code has attempted to get or set a key which is not in -the current set of allowed keys of a restricted hash. - -=item Attempt to bless into a reference - -(F) The CLASSNAME argument to the bless() operator is expected to be -the name of the package to bless the resulting object into. You've -supplied instead a reference to something: perhaps you wrote - - bless $self, $proto; - -when you intended - - bless $self, ref($proto) || $proto; - -If you actually want to bless into the stringified version -of the reference supplied, you need to stringify it yourself, for -example by: - - bless $self, "$proto"; - -=item Attempt to clear deleted array - -(S debugging) An array was assigned to when it was being freed. -Freed values are not supposed to be visible to Perl code. This -can also happen if XS code calls C<av_clear> from a custom magic -callback on the array. - -=item Attempt to delete disallowed key '%s' from a restricted hash - -(F) The failing code attempted to delete from a restricted hash a key -which is not in its key set. - -=item Attempt to delete readonly key '%s' from a restricted hash - -(F) The failing code attempted to delete a key whose value has been -declared readonly from a restricted hash. - -=item Attempt to free non-arena SV: 0x%x - -(S internal) All SV objects are supposed to be allocated from arenas -that will be garbage collected on exit. An SV was discovered to be -outside any of those arenas. - -=item Attempt to free nonexistent shared string '%s'%s - -(S internal) Perl maintains a reference-counted internal table of -strings to optimize the storage and access of hash keys and other -strings. This indicates someone tried to decrement the reference count -of a string that can no longer be found in the table. - -=item Attempt to free temp prematurely: SV 0x%x - -(S debugging) Mortalized values are supposed to be freed by the -free_tmps() routine. This indicates that something else is freeing the -SV before the free_tmps() routine gets a chance, which means that the -free_tmps() routine will be freeing an unreferenced scalar when it does -try to free it. - -=item Attempt to free unreferenced glob pointers - -(S internal) The reference counts got screwed up on symbol aliases. - -=item Attempt to free unreferenced scalar: SV 0x%x - -(W internal) Perl went to decrement the reference count of a scalar to -see if it would go to 0, and discovered that it had already gone to 0 -earlier, and should have been freed, and in fact, probably was freed. -This could indicate that SvREFCNT_dec() was called too many times, or -that SvREFCNT_inc() was called too few times, or that the SV was -mortalized when it shouldn't have been, or that memory has been -corrupted. - -=item Attempt to join self - -(F) You tried to join a thread from within itself, which is an -impossible task. You may be joining the wrong thread, or you may need -to move the join() to some other thread. - -=item Attempt to pack pointer to temporary value - -(W pack) You tried to pass a temporary value (like the result of a -function, or a computed expression) to the "p" pack() template. This -means the result contains a pointer to a location that could become -invalid anytime, even before the end of the current statement. Use -literals or global values as arguments to the "p" pack() template to -avoid this warning. - -=item Attempt to reload %s aborted. - -(F) You tried to load a file with C<use> or C<require> that failed to -compile once already. Perl will not try to compile this file again -unless you delete its entry from %INC. See L<perlfunc/require> and -L<perlvar/%INC>. - -=item Attempt to set length of freed array - -(W) You tried to set the length of an array which has been freed. You -can do this by storing a reference to the scalar representing the last index -of an array and later assigning through that reference. For example - - $r = do {my @a; \$#a}; - $$r = 503 - -=item Attempt to use reference as lvalue in substr - -(W substr) You supplied a reference as the first argument to substr() -used as an lvalue, which is pretty strange. Perhaps you forgot to -dereference it first. See L<perlfunc/substr>. - -=item Attribute "locked" is deprecated - -(D deprecated) You have used the attributes pragma to modify the -"locked" attribute on a code reference. The :locked attribute is -obsolete, has had no effect since 5005 threads were removed, and -will be removed in a future release of Perl 5. - -=item Attribute "unique" is deprecated - -(D deprecated) You have used the attributes pragma to modify -the "unique" attribute on an array, hash or scalar reference. -The :unique attribute has had no effect since Perl 5.8.8, and -will be removed in a future release of Perl 5. - -=item av_reify called on tied array - -(S debugging) This indicates that something went wrong and Perl got I<very> -confused about C<@_> or C<@DB::args> being tied. - -=item Bad arg length for %s, is %u, should be %d - -(F) You passed a buffer of the wrong size to one of msgctl(), semctl() -or shmctl(). In C parlance, the correct sizes are, respectively, -S<sizeof(struct msqid_ds *)>, S<sizeof(struct semid_ds *)>, and -S<sizeof(struct shmid_ds *)>. - -=item Bad evalled substitution pattern - -(F) You've used the C</e> switch to evaluate the replacement for a -substitution, but perl found a syntax error in the code to evaluate, -most likely an unexpected right brace '}'. - -=item Bad filehandle: %s - -(F) A symbol was passed to something wanting a filehandle, but the -symbol has no filehandle associated with it. Perhaps you didn't do an -open(), or did it in another package. - -=item Bad free() ignored - -(S malloc) An internal routine called free() on something that had never -been malloc()ed in the first place. Mandatory, but can be disabled by -setting environment variable C<PERL_BADFREE> to 0. - -This message can be seen quite often with DB_File on systems with "hard" -dynamic linking, like C<AIX> and C<OS/2>. It is a bug of C<Berkeley DB> -which is left unnoticed if C<DB> uses I<forgiving> system malloc(). - -=item Bad hash - -(P) One of the internal hash routines was passed a null HV pointer. - -=item Badly placed ()'s - -(A) You've accidentally run your script through B<csh> instead -of Perl. Check the #! line, or manually feed your script into -Perl yourself. - -=item Bad name after %s - -(F) You started to name a symbol by using a package prefix, and then -didn't finish the symbol. In particular, you can't interpolate outside -of quotes, so - - $var = 'myvar'; - $sym = mypack::$var; - -is not the same as - - $var = 'myvar'; - $sym = "mypack::$var"; - -=item Bad plugin affecting keyword '%s' - -(F) An extension using the keyword plugin mechanism violated the -plugin API. - -=item Bad realloc() ignored - -(S malloc) An internal routine called realloc() on something that -had never been malloc()ed in the first place. Mandatory, but can -be disabled by setting the environment variable C<PERL_BADFREE> to 1. - -=item Bad symbol for array - -(P) An internal request asked to add an array entry to something that -wasn't a symbol table entry. - -=item Bad symbol for dirhandle - -(P) An internal request asked to add a dirhandle entry to something -that wasn't a symbol table entry. - -=item Bad symbol for filehandle - -(P) An internal request asked to add a filehandle entry to something -that wasn't a symbol table entry. - -=item Bad symbol for hash - -(P) An internal request asked to add a hash entry to something that -wasn't a symbol table entry. - -=item Bareword found in conditional - -(W bareword) The compiler found a bareword where it expected a -conditional, which often indicates that an || or && was parsed as part -of the last argument of the previous construct, for example: - - open FOO || die; - -It may also indicate a misspelled constant that has been interpreted as -a bareword: - - use constant TYPO => 1; - if (TYOP) { print "foo" } - -The C<strict> pragma is useful in avoiding such errors. - -=item Bareword "%s" not allowed while "strict subs" in use - -(F) With "strict subs" in use, a bareword is only allowed as a -subroutine identifier, in curly brackets or to the left of the "=>" -symbol. Perhaps you need to predeclare a subroutine? - -=item Bareword "%s" refers to nonexistent package - -(W bareword) You used a qualified bareword of the form C<Foo::>, but the -compiler saw no other uses of that namespace before that point. Perhaps -you need to predeclare a package? - -=item BEGIN failed--compilation aborted - -(F) An untrapped exception was raised while executing a BEGIN -subroutine. Compilation stops immediately and the interpreter is -exited. - -=item BEGIN not safe after errors--compilation aborted - -(F) Perl found a C<BEGIN {}> subroutine (or a C<use> directive, which -implies a C<BEGIN {}>) after one or more compilation errors had already -occurred. Since the intended environment for the C<BEGIN {}> could not -be guaranteed (due to the errors), and since subsequent code likely -depends on its correct operation, Perl just gave up. - -=item \1 better written as $1 - -(W syntax) Outside of patterns, backreferences live on as variables. -The use of backslashes is grandfathered on the right-hand side of a -substitution, but stylistically it's better to use the variable form -because other Perl programmers will expect it, and it works better if -there are more than 9 backreferences. - -=item Binary number > 0b11111111111111111111111111111111 non-portable - -(W portable) The binary number you specified is larger than 2**32-1 -(4294967295) and therefore non-portable between systems. See -L<perlport> for more on portability concerns. - -=item bind() on closed socket %s - -(W closed) You tried to do a bind on a closed socket. Did you forget to -check the return value of your socket() call? See L<perlfunc/bind>. - -=item binmode() on closed filehandle %s - -(W unopened) You tried binmode() on a filehandle that was never opened. -Check your control flow and number of arguments. - -=item "\b{" is deprecated; use "\b\{" instead - -=item "\B{" is deprecated; use "\B\{" instead - -(W deprecated, regexp) Use of an unescaped "{" immediately following a -C<\b> or C<\B> is now deprecated so as to reserve its use for Perl -itself in a future release. - -=item Bit vector size > 32 non-portable - -(W portable) Using bit vector sizes larger than 32 is non-portable. - -=item Bizarre copy of %s - -(P) Perl detected an attempt to copy an internal value that is not -copiable. - -=item Buffer overflow in prime_env_iter: %s - -(W internal) A warning peculiar to VMS. While Perl was preparing to -iterate over %ENV, it encountered a logical name or symbol definition -which was too long, so it was truncated to the string shown. - -=item Bizarre SvTYPE [%d] - -(P) When starting a new thread or return values from a thread, Perl -encountered an invalid data type. - -=item Callback called exit - -(F) A subroutine invoked from an external package via call_sv() -exited by calling exit. - -=item %s() called too early to check prototype - -(W prototype) You've called a function that has a prototype before the -parser saw a definition or declaration for it, and Perl could not check -that the call conforms to the prototype. You need to either add an -early prototype declaration for the subroutine in question, or move the -subroutine definition ahead of the call to get proper prototype -checking. Alternatively, if you are certain that you're calling the -function correctly, you may put an ampersand before the name to avoid -the warning. See L<perlsub>. - -=item Cannot compress integer in pack - -(F) An argument to pack("w",...) was too large to compress. The BER -compressed integer format can only be used with positive integers, and you -attempted to compress Infinity or a very large number (> 1e308). -See L<perlfunc/pack>. - -=item Cannot compress negative numbers in pack - -(F) An argument to pack("w",...) was negative. The BER compressed integer -format can only be used with positive integers. See L<perlfunc/pack>. - -=item Cannot convert a reference to %s to typeglob - -(F) You manipulated Perl's symbol table directly, stored a reference -in it, then tried to access that symbol via conventional Perl syntax. -The access triggers Perl to autovivify that typeglob, but it there is -no legal conversion from that type of reference to a typeglob. - -=item Cannot copy to %s - -(P) Perl detected an attempt to copy a value to an internal type that cannot -be directly assigned to. - -=item Cannot find encoding "%s" - -(S io) You tried to apply an encoding that did not exist to a filehandle, -either with open() or binmode(). - -=item Cannot set tied @DB::args - -(F) C<caller> tried to set C<@DB::args>, but found it tied. Tying C<@DB::args> -is not supported. (Before this error was added, it used to crash.) - -=item Cannot tie unreifiable array - -(P) You somehow managed to call C<tie> on an array that does not -keep a reference count on its arguments and cannot be made to -do so. Such arrays are not even supposed to be accessible to -Perl code, but are only used internally. - -=item Can only compress unsigned integers in pack - -(F) An argument to pack("w",...) was not an integer. The BER compressed -integer format can only be used with positive integers, and you attempted -to compress something else. See L<perlfunc/pack>. - -=item Can't bless non-reference value - -(F) Only hard references may be blessed. This is how Perl "enforces" -encapsulation of objects. See L<perlobj>. - -=item Can't "break" in a loop topicalizer - -(F) You called C<break>, but you're in a C<foreach> block rather than -a C<given> block. You probably meant to use C<next> or C<last>. - -=item Can't "break" outside a given block - -(F) You called C<break>, but you're not inside a C<given> block. - -=item Can't call method "%s" on an undefined value - -(F) You used the syntax of a method call, but the slot filled by the -object reference or package name contains an undefined value. Something -like this will reproduce the error: - - $BADREF = undef; - process $BADREF 1,2,3; - $BADREF->process(1,2,3); - -=item Can't call method "%s" on unblessed reference - -(F) A method call must know in what package it's supposed to run. It -ordinarily finds this out from the object reference you supply, but you -didn't supply an object reference in this case. A reference isn't an -object reference until it has been blessed. See L<perlobj>. - -=item Can't call method "%s" without a package or object reference - -(F) You used the syntax of a method call, but the slot filled by the -object reference or package name contains an expression that returns a -defined value which is neither an object reference nor a package name. -Something like this will reproduce the error: - - $BADREF = 42; - process $BADREF 1,2,3; - $BADREF->process(1,2,3); - -=item Can't chdir to %s - -(F) You called C<perl -x/foo/bar>, but C</foo/bar> is not a directory -that you can chdir to, possibly because it doesn't exist. - -=item Can't check filesystem of script "%s" for nosuid - -(P) For some reason you can't check the filesystem of the script for -nosuid. - -=item Can't coerce %s to %s in %s - -(F) Certain types of SVs, in particular real symbol table entries -(typeglobs), can't be forced to stop being what they are. So you can't -say things like: - - *foo += 1; - -You CAN say - - $foo = *foo; - $foo += 1; - -but then $foo no longer contains a glob. - -=item Can't "continue" outside a when block - -(F) You called C<continue>, but you're not inside a C<when> -or C<default> block. - -=item Can't create pipe mailbox - -(P) An error peculiar to VMS. The process is suffering from exhausted -quotas or other plumbing problems. - -=item Can't declare %s in "%s" - -(F) Only scalar, array, and hash variables may be declared as "my", "our" or -"state" variables. They must have ordinary identifiers as names. - -=item Can't "default" outside a topicalizer - -(F) You have used a C<default> block that is neither inside a -C<foreach> loop nor a C<given> block. (Note that this error is -issued on exit from the C<default> block, so you won't get the -error if you use an explicit C<continue>.) - -=item Can't do inplace edit: %s is not a regular file - -(S inplace) You tried to use the B<-i> switch on a special file, such as -a file in /dev, or a FIFO. The file was ignored. - -=item Can't do inplace edit on %s: %s - -(S inplace) The creation of the new file failed for the indicated -reason. - -=item Can't do inplace edit without backup - -(F) You're on a system such as MS-DOS that gets confused if you try -reading from a deleted (but still opened) file. You have to say -C<-i.bak>, or some such. - -=item Can't do inplace edit: %s would not be unique - -(S inplace) Your filesystem does not support filenames longer than 14 -characters and Perl was unable to create a unique filename during -inplace editing with the B<-i> switch. The file was ignored. - -=item Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ - -(F) Minima must be less than or equal to maxima. If you really -want your regexp to match something 0 times, just put {0}. The -<-- HERE shows in the regular expression about where the problem -was discovered. See L<perlre>. - -=item Can't do waitpid with flags - -(F) This machine doesn't have either waitpid() or wait4(), so only -waitpid() without flags is emulated. - -=item Can't emulate -%s on #! line - -(F) The #! line specifies a switch that doesn't make sense at this -point. For example, it'd be kind of silly to put a B<-x> on the #! -line. - -=item Can't %s %s-endian %ss on this platform - -(F) Your platform's byte-order is neither big-endian nor little-endian, -or it has a very strange pointer size. Packing and unpacking big- or -little-endian floating point values and pointers may not be possible. -See L<perlfunc/pack>. - -=item Can't exec "%s": %s - -(W exec) A system(), exec(), or piped open call could not execute the -named program for the indicated reason. Typical reasons include: the -permissions were wrong on the file, the file wasn't found in -C<$ENV{PATH}>, the executable in question was compiled for another -architecture, or the #! line in a script points to an interpreter that -can't be run for similar reasons. (Or maybe your system doesn't support -#! at all.) - -=item Can't exec %s - -(F) Perl was trying to execute the indicated program for you because -that's what the #! line said. If that's not what you wanted, you may -need to mention "perl" on the #! line somewhere. - -=item Can't execute %s - -(F) You used the B<-S> switch, but the copies of the script to execute -found in the PATH did not have correct permissions. - -=item Can't find an opnumber for "%s" - -(F) A string of a form C<CORE::word> was given to prototype(), but there -is no builtin with the name C<word>. - -=item Can't find %s character property "%s" - -(F) You used C<\p{}> or C<\P{}> but the character property by that name -could not be found. Maybe you misspelled the name of the property? -See L<perluniprops/Properties accessible through \p{} and \P{}> -for a complete list of available properties. - -=item Can't find label %s - -(F) You said to goto a label that isn't mentioned anywhere that it's -possible for us to go to. See L<perlfunc/goto>. - -=item Can't find %s on PATH - -(F) You used the B<-S> switch, but the script to execute could not be -found in the PATH. - -=item Can't find %s on PATH, '.' not in PATH - -(F) You used the B<-S> switch, but the script to execute could not be -found in the PATH, or at least not with the correct permissions. The -script exists in the current directory, but PATH prohibits running it. - -=item Can't find string terminator %s anywhere before EOF - -(F) Perl strings can stretch over multiple lines. This message means -that the closing delimiter was omitted. Because bracketed quotes count -nesting levels, the following is missing its final parenthesis: - - print q(The character '(' starts a side comment.); - -If you're getting this error from a here-document, you may have -included unseen whitespace before or after your closing tag or there -may not be a linebreak after it. A good programmer's editor will have -a way to help you find these characters (or lack of characters). See -L<perlop> for the full details on here-documents. - -=item Can't find Unicode property definition "%s" - -(F) You may have tried to use C<\p> which means a Unicode -property (for example C<\p{Lu}> matches all uppercase -letters). If you did mean to use a Unicode property, see -L<perluniprops/Properties accessible through \p{} and \P{}> -for a complete list of available properties. If you didn't -mean to use a Unicode property, escape the C<\p>, either by -C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, or -until C<\E>). - -=item Can't fork: %s - -(F) A fatal error occurred while trying to fork while opening a -pipeline. - -=item Can't fork, trying again in 5 seconds - -(W pipe) A fork in a piped open failed with EAGAIN and will be retried -after five seconds. - -=item Can't get filespec - stale stat buffer? - -(S) A warning peculiar to VMS. This arises because of the difference -between access checks under VMS and under the Unix model Perl assumes. -Under VMS, access checks are done by filename, rather than by bits in -the stat buffer, so that ACLs and other protections can be taken into -account. Unfortunately, Perl assumes that the stat buffer contains all -the necessary information, and passes it, instead of the filespec, to -the access-checking routine. It will try to retrieve the filespec using -the device name and FID present in the stat buffer, but this works only -if you haven't made a subsequent call to the CRTL stat() routine, -because the device name is overwritten with each call. If this warning -appears, the name lookup failed, and the access-checking routine gave up -and returned FALSE, just to be conservative. (Note: The access-checking -routine knows about the Perl C<stat> operator and file tests, so you -shouldn't ever see this warning in response to a Perl command; it arises -only if some internal code takes stat buffers lightly.) - -=item Can't get pipe mailbox device name - -(P) An error peculiar to VMS. After creating a mailbox to act as a -pipe, Perl can't retrieve its name for later use. - -=item Can't get SYSGEN parameter value for MAXBUF - -(P) An error peculiar to VMS. Perl asked $GETSYI how big you want your -mailbox buffers to be, and didn't get an answer. - -=item Can't "goto" into the middle of a foreach loop - -(F) A "goto" statement was executed to jump into the middle of a foreach -loop. You can't get there from here. See L<perlfunc/goto>. - -=item Can't "goto" out of a pseudo block - -(F) A "goto" statement was executed to jump out of what might look like -a block, except that it isn't a proper block. This usually occurs if -you tried to jump out of a sort() block or subroutine, which is a no-no. -See L<perlfunc/goto>. - -=item Can't goto subroutine from a sort sub (or similar callback) - -(F) The "goto subroutine" call can't be used to jump out of the -comparison sub for a sort(), or from a similar callback (such -as the reduce() function in List::Util). - -=item Can't goto subroutine from an eval-%s - -(F) The "goto subroutine" call can't be used to jump out of an eval -"string" or block. - -=item Can't goto subroutine outside a subroutine - -(F) The deeply magical "goto subroutine" call can only replace one -subroutine call for another. It can't manufacture one out of whole -cloth. In general you should be calling it out of only an AUTOLOAD -routine anyway. See L<perlfunc/goto>. - -=item Can't ignore signal CHLD, forcing to default - -(W signal) Perl has detected that it is being run with the SIGCHLD -signal (sometimes known as SIGCLD) disabled. Since disabling this -signal will interfere with proper determination of exit status of child -processes, Perl has reset the signal to its default value. This -situation typically indicates that the parent program under which Perl -may be running (e.g. cron) is being very careless. - -=item Can't kill a non-numeric process ID - -(F) Process identifiers must be (signed) integers. It is a fatal error to -attempt to kill() an undefined, empty-string or otherwise non-numeric -process identifier. - -=item Can't "last" outside a loop block - -(F) A "last" statement was executed to break out of the current block, -except that there's this itty bitty problem called there isn't a current -block. Note that an "if" or "else" block doesn't count as a "loopish" -block, as doesn't a block given to sort(), map() or grep(). You can -usually double the curlies to get the same effect though, because the -inner curlies will be considered a block that loops once. See -L<perlfunc/last>. - -=item Can't linearize anonymous symbol table - -(F) Perl tried to calculate the method resolution order (MRO) of a -package, but failed because the package stash has no name. - -=item Can't load '%s' for module %s - -(F) The module you tried to load failed to load a dynamic extension. -This may either mean that you upgraded your version of perl to one -that is incompatible with your old dynamic extensions (which is known -to happen between major versions of perl), or (more likely) that your -dynamic extension was built against an older version of the library -that is installed on your system. You may need to rebuild your old -dynamic extensions. - -=item Can't localize lexical variable %s - -(F) You used local on a variable name that was previously declared as a -lexical variable using "my" or "state". This is not allowed. If you -want to localize a package variable of the same name, qualify it with -the package name. - -=item Can't localize through a reference - -(F) You said something like C<local $$ref>, which Perl can't currently -handle, because when it goes to restore the old value of whatever $ref -pointed to after the scope of the local() is finished, it can't be sure -that $ref will still be a reference. - -=item Can't locate %s - -(F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be found. -Perl looks for the file in all the locations mentioned in @INC, unless -the file name included the full path to the file. Perhaps you need -to set the PERL5LIB or PERL5OPT environment variable to say where the -extra library is, or maybe the script needs to add the library name -to @INC. Or maybe you just misspelled the name of the file. See -L<perlfunc/require> and L<lib>. - -=item Can't locate auto/%s.al in @INC - -(F) A function (or method) was called in a package which allows -autoload, but there is no function to autoload. Most probable causes -are a misprint in a function/method name or a failure to C<AutoSplit> -the file, say, by doing C<make install>. - -=item Can't locate loadable object for module %s in @INC - -(F) The module you loaded is trying to load an external library, like -for example, F<foo.so> or F<bar.dll>, but the L<DynaLoader> module was -unable to locate this library. See L<DynaLoader>. - -=item Can't locate object method "%s" via package "%s" - -(F) You called a method correctly, and it correctly indicated a package -functioning as a class, but that package doesn't define that particular -method, nor does any of its base classes. See L<perlobj>. - -=item Can't locate package %s for @%s::ISA - -(W syntax) The @ISA array contained the name of another package that -doesn't seem to exist. - -=item Can't locate PerlIO%s - -(F) You tried to use in open() a PerlIO layer that does not exist, -e.g. open(FH, ">:nosuchlayer", "somefile"). - -=item Can't make list assignment to %ENV on this system - -(F) List assignment to %ENV is not supported on some systems, notably -VMS. - -=item Can't modify %s in %s - -(F) You aren't allowed to assign to the item indicated, or otherwise try -to change it, such as with an auto-increment. - -=item Can't modify nonexistent substring - -(P) The internal routine that does assignment to a substr() was handed -a NULL. - -=item Can't modify non-lvalue subroutine call - -(F) Subroutines meant to be used in lvalue context should be declared as -such. See L<perlsub/"Lvalue subroutines">. - -=item Can't msgrcv to read-only var - -(F) The target of a msgrcv must be modifiable to be used as a receive -buffer. - -=item Can't "next" outside a loop block - -(F) A "next" statement was executed to reiterate the current block, but -there isn't a current block. Note that an "if" or "else" block doesn't -count as a "loopish" block, as doesn't a block given to sort(), map() or -grep(). You can usually double the curlies to get the same effect -though, because the inner curlies will be considered a block that loops -once. See L<perlfunc/next>. - -=item Can't open %s - -(F) You tried to run a perl built with MAD support with -the PERL_XMLDUMP environment variable set, but the file -named by that variable could not be opened. - -=item Can't open %s: %s - -(S inplace) The implicit opening of a file through use of the C<< <> >> -filehandle, either implicitly under the C<-n> or C<-p> command-line -switches, or explicitly, failed for the indicated reason. Usually -this is because you don't have read permission for a file which -you named on the command line. - -(F) You tried to call perl with the B<-e> switch, but F</dev/null> (or -your operating system's equivalent) could not be opened. - -=item Can't open a reference - -(W io) You tried to open a scalar reference for reading or writing, -using the 3-arg open() syntax: - - open FH, '>', $ref; - -but your version of perl is compiled without perlio, and this form of -open is not supported. - -=item Can't open bidirectional pipe - -(W pipe) You tried to say C<open(CMD, "|cmd|")>, which is not supported. -You can try any of several modules in the Perl library to do this, such -as IPC::Open2. Alternately, direct the pipe's output to a file using -">", and then read it in under a different file handle. - -=item Can't open error file %s as stderr - -(F) An error peculiar to VMS. Perl does its own command line -redirection, and couldn't open the file specified after '2>' or '2>>' on -the command line for writing. - -=item Can't open input file %s as stdin - -(F) An error peculiar to VMS. Perl does its own command line -redirection, and couldn't open the file specified after '<' on the -command line for reading. - -=item Can't open output file %s as stdout - -(F) An error peculiar to VMS. Perl does its own command line -redirection, and couldn't open the file specified after '>' or '>>' on -the command line for writing. - -=item Can't open output pipe (name: %s) - -(P) An error peculiar to VMS. Perl does its own command line -redirection, and couldn't open the pipe into which to send data destined -for stdout. - -=item Can't open perl script "%s": %s - -(F) The script you specified can't be opened for the indicated reason. - -If you're debugging a script that uses #!, and normally relies on the -shell's $PATH search, the -S option causes perl to do that search, so -you don't have to type the path or C<`which $scriptname`>. - -=item Can't read CRTL environ - -(S) A warning peculiar to VMS. Perl tried to read an element of %ENV -from the CRTL's internal environment array and discovered the array was -missing. You need to figure out where your CRTL misplaced its environ -or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not -searched. - -=item Can't "redo" outside a loop block - -(F) A "redo" statement was executed to restart the current block, but -there isn't a current block. Note that an "if" or "else" block doesn't -count as a "loopish" block, as doesn't a block given to sort(), map() -or grep(). You can usually double the curlies to get the same effect -though, because the inner curlies will be considered a block that -loops once. See L<perlfunc/redo>. - -=item Can't remove %s: %s, skipping file - -(S inplace) You requested an inplace edit without creating a backup -file. Perl was unable to remove the original file to replace it with -the modified file. The file was left unmodified. - -=item Can't rename %s to %s: %s, skipping file - -(S inplace) The rename done by the B<-i> switch failed for some reason, -probably because you don't have write permission to the directory. - -=item Can't reopen input pipe (name: %s) in binary mode - -(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried -to reopen it to accept binary data. Alas, it failed. - -=item Can't reset %ENV on this system - -(F) You called C<reset('E')> or similar, which tried to reset -all variables in the current package beginning with "E". In -the main package, that includes %ENV. Resetting %ENV is not -supported on some systems, notably VMS. - -=item Can't resolve method "%s" overloading "%s" in package "%s" - -(F)(P) Error resolving overloading specified by a method name (as -opposed to a subroutine reference): no such method callable via the -package. If the method name is C<???>, this is an internal error. - -=item Can't return %s from lvalue subroutine - -(F) Perl detected an attempt to return illegal lvalues (such as -temporary or readonly values) from a subroutine used as an lvalue. This -is not allowed. - -=item Can't return outside a subroutine - -(F) The return statement was executed in mainline code, that is, where -there was no subroutine call to return out of. See L<perlsub>. - -=item Can't return %s to lvalue scalar context - -(F) You tried to return a complete array or hash from an lvalue -subroutine, but you called the subroutine in a way that made Perl -think you meant to return only one value. You probably meant to -write parentheses around the call to the subroutine, which tell -Perl that the call should be in list context. - -=item Can't stat script "%s" - -(P) For some reason you can't fstat() the script even though you have it -open already. Bizarre. - -=item Can't take log of %g - -(F) For ordinary real numbers, you can't take the logarithm of a -negative number or zero. There's a Math::Complex package that comes -standard with Perl, though, if you really want to do that for the -negative numbers. - -=item Can't take sqrt of %g - -(F) For ordinary real numbers, you can't take the square root of a -negative number. There's a Math::Complex package that comes standard -with Perl, though, if you really want to do that. - -=item Can't undef active subroutine - -(F) You can't undefine a routine that's currently running. You can, -however, redefine it while it's running, and you can even undef the -redefined subroutine while the old routine is running. Go figure. - -=item Can't upgrade %s (%d) to %d - -(P) The internal sv_upgrade routine adds "members" to an SV, making it -into a more specialized kind of SV. The top several SV types are so -specialized, however, that they cannot be interconverted. This message -indicates that such a conversion was attempted. - -=item Can't use '%c' after -mname - -(F) You tried to call perl with the B<-m> switch, but you put something -other than "=" after the module name. - -=item Can't use anonymous symbol table for method lookup - -(F) The internal routine that does method lookup was handed a symbol -table that doesn't have a name. Symbol tables can become anonymous -for example by undefining stashes: C<undef %Some::Package::>. - -=item Can't use an undefined value as %s reference - -(F) A value used as either a hard reference or a symbolic reference must -be a defined value. This helps to delurk some insidious errors. - -=item Can't use bareword ("%s") as %s ref while "strict refs" in use - -(F) Only hard references are allowed by "strict refs". Symbolic -references are disallowed. See L<perlref>. - -=item Can't use %! because Errno.pm is not available - -(F) The first time the C<%!> hash is used, perl automatically loads the -Errno.pm module. The Errno module is expected to tie the %! hash to -provide symbolic names for C<$!> errno values. - -=item Can't use both '<' and '>' after type '%c' in %s - -(F) A type cannot be forced to have both big-endian and little-endian -byte-order at the same time, so this combination of modifiers is not -allowed. See L<perlfunc/pack>. - -=item Can't use %s for loop variable - -(F) Only a simple scalar variable may be used as a loop variable on a -foreach. - -=item Can't use global %s in "%s" - -(F) You tried to declare a magical variable as a lexical variable. This -is not allowed, because the magic can be tied to only one location -(namely the global variable) and it would be incredibly confusing to -have variables in your program that looked like magical variables but -weren't. - -=item Can't use '%c' in a group with different byte-order in %s - -(F) You attempted to force a different byte-order on a type -that is already inside a group with a byte-order modifier. -For example you cannot force little-endianness on a type that -is inside a big-endian group. - -=item Can't use "my %s" in sort comparison - -(F) The global variables $a and $b are reserved for sort comparisons. -You mentioned $a or $b in the same line as the <=> or cmp operator, -and the variable had earlier been declared as a lexical variable. -Either qualify the sort variable with the package name, or rename the -lexical variable. - -=item Can't use %s ref as %s ref - -(F) You've mixed up your reference types. You have to dereference a -reference of the type needed. You can use the ref() function to -test the type of the reference, if need be. - -=item Can't use string ("%s") as %s ref while "strict refs" in use - -(F) Only hard references are allowed by "strict refs". Symbolic -references are disallowed. See L<perlref>. - -=item Can't use subscript on %s - -(F) The compiler tried to interpret a bracketed expression as a -subscript. But to the left of the brackets was an expression that -didn't look like a hash or array reference, or anything else subscriptable. - -=item Can't use \%c to mean $%c in expression - -(W syntax) In an ordinary expression, backslash is a unary operator that -creates a reference to its argument. The use of backslash to indicate a -backreference to a matched substring is valid only as part of a regular -expression pattern. Trying to do this in ordinary Perl code produces a -value that prints out looking like SCALAR(0xdecaf). Use the $1 form -instead. - -=item Can't weaken a nonreference - -(F) You attempted to weaken something that was not a reference. Only -references can be weakened. - -=item Can't "when" outside a topicalizer - -(F) You have used a when() block that is neither inside a C<foreach> -loop nor a C<given> block. (Note that this error is issued on exit -from the C<when> block, so you won't get the error if the match fails, -or if you use an explicit C<continue>.) - -=item Can't x= to read-only value - -(F) You tried to repeat a constant value (often the undefined value) -with an assignment operator, which implies modifying the value itself. -Perhaps you need to copy the value to a temporary, and repeat that. - -=item Character following "\c" must be ASCII - -(F)(W deprecated, syntax) In C<\cI<X>>, I<X> must be an ASCII character. -It is planned to make this fatal in all instances in Perl 5.18. In the -cases where it isn't fatal, the character this evaluates to is -derived by exclusive or'ing the code point of this character with 0x40. - -Note that non-alphabetic ASCII characters are discouraged here as well. - -=item Character in 'C' format wrapped in pack - -(W pack) You said - - pack("C", $x) - -where $x is either less than 0 or more than 255; the C<"C"> format is -only for encoding native operating system characters (ASCII, EBCDIC, -and so on) and not for Unicode characters, so Perl behaved as if you meant - - pack("C", $x & 255) - -If you actually want to pack Unicode codepoints, use the C<"U"> format -instead. - -=item Character in 'W' format wrapped in pack - -(W pack) You said - - pack("U0W", $x) - -where $x is either less than 0 or more than 255. However, C<U0>-mode -expects all values to fall in the interval [0, 255], so Perl behaved -as if you meant: - - pack("U0W", $x & 255) - -=item Character in 'c' format wrapped in pack - -(W pack) You said - - pack("c", $x) - -where $x is either less than -128 or more than 127; the C<"c"> format -is only for encoding native operating system characters (ASCII, EBCDIC, -and so on) and not for Unicode characters, so Perl behaved as if you meant - - pack("c", $x & 255); - -If you actually want to pack Unicode codepoints, use the C<"U"> format -instead. - -=item Character in '%c' format wrapped in unpack - -(W unpack) You tried something like - - unpack("H", "\x{2a1}") - -where the format expects to process a byte (a character with a value -below 256), but a higher value was provided instead. Perl uses the -value modulus 256 instead, as if you had provided: - - unpack("H", "\x{a1}") - -=item Character(s) in '%c' format wrapped in pack - -(W pack) You tried something like - - pack("u", "\x{1f3}b") - -where the format expects to process a sequence of bytes (character with a -value below 256), but some of the characters had a higher value. Perl -uses the character values modulus 256 instead, as if you had provided: - - pack("u", "\x{f3}b") - -=item Character(s) in '%c' format wrapped in unpack - -(W unpack) You tried something like - - unpack("s", "\x{1f3}b") - -where the format expects to process a sequence of bytes (character with a -value below 256), but some of the characters had a higher value. Perl -uses the character values modulus 256 instead, as if you had provided: - - unpack("s", "\x{f3}b") - -=item "\c{" is deprecated and is more clearly written as ";" - -(D deprecated, syntax) The C<\cI<X>> construct is intended to be a way -to specify non-printable characters. You used it with a "{" which -evaluates to ";", which is printable. It is planned to remove the -ability to specify a semi-colon this way in Perl 5.18. Just use a -semi-colon or a backslash-semi-colon without the "\c". - -=item "\c%c" is more clearly written simply as "%s" - -(W syntax) The C<\cI<X>> construct is intended to be a way to specify -non-printable characters. You used it for a printable one, which is better -written as simply itself, perhaps preceded by a backslash for non-word -characters. - -=item Cloning substitution context is unimplemented - -(F) Creating a new thread inside the C<s///> operator is not supported. - -=item close() on unopened filehandle %s - -(W unopened) You tried to close a filehandle that was never opened. - -=item closedir() attempted on invalid dirhandle %s - -(W io) The dirhandle you tried to close is either closed or not really -a dirhandle. Check your control flow. - -=item Closure prototype called - -(F) If a closure has attributes, the subroutine passed to an attribute -handler is the prototype that is cloned when a new closure is created. -This subroutine cannot be called. - -=item Code missing after '/' - -(F) You had a (sub-)template that ends with a '/'. There must be -another template code following the slash. See L<perlfunc/pack>. - -=item Code point 0x%X is not Unicode, may not be portable - -=item Code point 0x%X is not Unicode, all \p{} matches fail; all \P{} matches succeed - -(W utf8, non_unicode) You had a code point above the Unicode maximum -of U+10FFFF. - -Perl allows strings to contain a superset of Unicode code points, up -to the limit of what is storable in an unsigned integer on your system, -but these may not be accepted by other languages/systems. At one time, -it was legal in some standards to have code points up to 0x7FFF_FFFF, -but not higher. Code points above 0xFFFF_FFFF require larger than a -32 bit word. - -None of the Unicode or Perl-defined properties will match a non-Unicode -code point. For example, - - chr(0x7FF_FFFF) =~ /\p{Any}/ - -will not match, because the code point is not in Unicode. But - - chr(0x7FF_FFFF) =~ /\P{Any}/ - -will match. - -This may be counterintuitive at times, as both these fail: - - chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # Fails. - chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # Also fails! - -and both these succeed: - - chr(0x110000) =~ \P{ASCII_Hex_Digit=True} # Succeeds. - chr(0x110000) =~ \P{ASCII_Hex_Digit=False} # Also succeeds! - -=item %s: Command not found - -(A) You've accidentally run your script through B<csh> or another shell -shell instead of Perl. Check the #! line, or manually feed your script -into Perl yourself. The #! line at the top of your file could look like - - #!/usr/bin/perl -w - -=item Compilation failed in require - -(F) Perl could not compile a file specified in a C<require> statement. -Perl uses this generic message when none of the errors that it -encountered were severe enough to halt compilation immediately. - -=item Complex regular subexpression recursion limit (%d) exceeded - -(W regexp) The regular expression engine uses recursion in complex -situations where back-tracking is required. Recursion depth is limited -to 32766, or perhaps less in architectures where the stack cannot grow -arbitrarily. ("Simple" and "medium" situations are handled without -recursion and are not subject to a limit.) Try shortening the string -under examination; looping in Perl code (e.g. with C<while>) rather than -in the regular expression engine; or rewriting the regular expression so -that it is simpler or backtracks less. (See L<perlfaq2> for information -on I<Mastering Regular Expressions>.) - -=item cond_broadcast() called on unlocked variable - -(W threads) Within a thread-enabled program, you tried to -call cond_broadcast() on a variable which wasn't locked. -The cond_broadcast() function is used to wake up another thread -that is waiting in a cond_wait(). To ensure that the signal isn't -sent before the other thread has a chance to enter the wait, it -is usual for the signaling thread first to wait for a lock on -variable. This lock attempt will only succeed after the other -thread has entered cond_wait() and thus relinquished the lock. - -=item cond_signal() called on unlocked variable - -(W threads) Within a thread-enabled program, you tried to -call cond_signal() on a variable which wasn't locked. The -cond_signal() function is used to wake up another thread that -is waiting in a cond_wait(). To ensure that the signal isn't -sent before the other thread has a chance to enter the wait, it -is usual for the signaling thread first to wait for a lock on -variable. This lock attempt will only succeed after the other -thread has entered cond_wait() and thus relinquished the lock. - -=item connect() on closed socket %s - -(W closed) You tried to do a connect on a closed socket. Did you forget -to check the return value of your socket() call? See -L<perlfunc/connect>. - -=item Constant(%s)%s: %s - -(F) The parser found inconsistencies either while attempting to define -an overloaded constant, or when trying to find the character name -specified in the C<\N{...}> escape. Perhaps you forgot to load the -corresponding L<overload> pragma?. - -=item Constant(%s)%s: %s in regex; marked by <-- HERE in m/%s/ - -(F) The parser found inconsistencies while attempting to find -the character name specified in the C<\N{...}> escape. - -=item Constant is not %s reference - -(F) A constant value (perhaps declared using the C<use constant> pragma) -is being dereferenced, but it amounts to the wrong type of reference. -The message indicates the type of reference that was expected. This -usually indicates a syntax error in dereferencing the constant value. -See L<perlsub/"Constant Functions"> and L<constant>. - -=item Constant subroutine %s redefined - -(W redefine)(S) You redefined a subroutine which had previously -been eligible for inlining. See L<perlsub/"Constant Functions"> -for commentary and workarounds. - -=item Constant subroutine %s undefined - -(W misc) You undefined a subroutine which had previously been eligible -for inlining. See L<perlsub/"Constant Functions"> for commentary and -workarounds. - -=item Copy method did not return a reference - -(F) The method which overloads "=" is buggy. See -L<overload/Copy Constructor>. - -=item &CORE::%s cannot be called directly - -(F) You tried to call a subroutine in the C<CORE::> namespace -with C<&foo> syntax or through a reference. Some subroutines -in this package cannot yet be called that way, but must be -called as barewords. Something like this will work: - - BEGIN { *shove = \&CORE::push; } - shove @array, 1,2,3; # pushes on to @array - -=item CORE::%s is not a keyword - -(F) The CORE:: namespace is reserved for Perl keywords. - -=item corrupted regexp pointers - -(P) The regular expression engine got confused by what the regular -expression compiler gave it. - -=item corrupted regexp program - -(P) The regular expression engine got passed a regexp program without a -valid magic number. - -=item Corrupt malloc ptr 0x%x at 0x%x - -(P) The malloc package that comes with Perl had an internal failure. - -=item Count after length/code in unpack - -(F) You had an unpack template indicating a counted-length string, but -you have also specified an explicit size for the string. See -L<perlfunc/pack>. - -=item Deep recursion on anonymous subroutine - -=item Deep recursion on subroutine "%s" - -(W recursion) This subroutine has called itself (directly or indirectly) -100 times more than it has returned. This probably indicates an -infinite recursion, unless you're writing strange benchmark programs, in -which case it indicates something else. - -This threshold can be changed from 100, by recompiling the F<perl> binary, -setting the C pre-processor macro C<PERL_SUB_DEPTH_WARN> to the desired value. - -=item defined(@array) is deprecated - -(D deprecated) defined() is not usually useful on arrays because it -checks for an undefined I<scalar> value. If you want to see if the -array is empty, just use C<if (@array) { # not empty }> for example. - -=item defined(%hash) is deprecated - -(D deprecated) C<defined()> is not usually right on hashes and has been -discouraged since 5.004. - -Although C<defined %hash> is false on a plain not-yet-used hash, it -becomes true in several non-obvious circumstances, including iterators, -weak references, stash names, even remaining true after C<undef %hash>. -These things make C<defined %hash> fairly useless in practice. - -If a check for non-empty is what you wanted then just put it in boolean -context (see L<perldata/Scalar values>): - - if (%hash) { - # not empty - } - -If you had C<defined %Foo::Bar::QUUX> to check whether such a package -variable exists then that's never really been reliable, and isn't -a good way to enquire about the features of a package, or whether -it's loaded, etc. - - -=item (?(DEFINE)....) does not allow branches in regex; marked by <-- HERE in m/%s/ - -(F) You used something like C<(?(DEFINE)...|..)> which is illegal. The -most likely cause of this error is that you left out a parenthesis inside -of the C<....> part. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item %s defines neither package nor VERSION--version check failed - -(F) You said something like "use Module 42" but in the Module file -there are neither package declarations nor a C<$VERSION>. - -=item Delimiter for here document is too long - -(F) In a here document construct like C<<<FOO>, the label C<FOO> is too -long for Perl to handle. You have to be seriously twisted to write code -that triggers this error. - -=item Deprecated character in \N{...}; marked by <-- HERE in \N{%s<-- HERE %s - -(D deprecated) Just about anything is legal for the C<...> in C<\N{...}>. -But starting in 5.12, non-reasonable ones that don't look like names -are deprecated. A reasonable name begins with an alphabetic character -and continues with any combination of alphanumerics, dashes, spaces, -parentheses or colons. - -=item Deprecated use of my() in false conditional - -(D deprecated) You used a declaration similar to C<my $x if 0>. There -has been a long-standing bug in Perl that causes a lexical variable -not to be cleared at scope exit when its declaration includes a false -conditional. Some people have exploited this bug to achieve a kind of -static variable. Since we intend to fix this bug, we don't want people -relying on this behavior. You can achieve a similar static effect by -declaring the variable in a separate block outside the function, eg - - sub f { my $x if 0; return $x++ } - -becomes - - { my $x; sub f { return $x++ } } - -Beginning with perl 5.9.4, you can also use C<state> variables to have -lexicals that are initialized only once (see L<feature>): - - sub f { state $x; return $x++ } - -=item DESTROY created new reference to dead object '%s' - -(F) A DESTROY() method created a new reference to the object which is -just being DESTROYed. Perl is confused, and prefers to abort rather -than to create a dangling reference. - -=item Did not produce a valid header - -See Server error. - -=item %s did not return a true value - -(F) A required (or used) file must return a true value to indicate that -it compiled correctly and ran its initialization code correctly. It's -traditional to end such a file with a "1;", though any true value would -do. See L<perlfunc/require>. - -=item (Did you mean &%s instead?) - -(W misc) You probably referred to an imported subroutine &FOO as $FOO or -some such. - -=item (Did you mean "local" instead of "our"?) - -(W misc) Remember that "our" does not localize the declared global -variable. You have declared it again in the same lexical scope, which -seems superfluous. - -=item (Did you mean $ or @ instead of %?) - -(W) You probably said %hash{$key} when you meant $hash{$key} or -@hash{@keys}. On the other hand, maybe you just meant %hash and got -carried away. - -=item Died - -(F) You passed die() an empty string (the equivalent of C<die "">) or -you called it with no args and C<$@> was empty. - -=item Document contains no data - -See Server error. - -=item %s does not define %s::VERSION--version check failed - -(F) You said something like "use Module 42" but the Module did not -define a C<$VERSION.> - -=item '/' does not take a repeat count - -(F) You cannot put a repeat count of any kind right after the '/' code. -See L<perlfunc/pack>. - -=item Don't know how to handle magic of type '%s' - -(P) The internal handling of magical variables has been cursed. - -=item do_study: out of memory - -(P) This should have been caught by safemalloc() instead. - -=item (Do you need to predeclare %s?) - -(S syntax) This is an educated guess made in conjunction with the message -"%s found where operator expected". It often means a subroutine or module -name is being referenced that hasn't been declared yet. This may be -because of ordering problems in your file, or because of a missing -"sub", "package", "require", or "use" statement. If you're referencing -something that isn't defined yet, you don't actually have to define the -subroutine or package before the current location. You can use an empty -"sub foo;" or "package FOO;" to enter a "forward" declaration. - -=item dump() better written as CORE::dump() - -(W misc) You used the obsolescent C<dump()> built-in function, without fully -qualifying it as C<CORE::dump()>. Maybe it's a typo. See L<perlfunc/dump>. - -=item dump is not supported - -(F) Your machine doesn't support dump/undump. - -=item Duplicate free() ignored - -(S malloc) An internal routine called free() on something that had -already been freed. - -=item Duplicate modifier '%c' after '%c' in %s - -(W) You have applied the same modifier more than once after a type -in a pack template. See L<perlfunc/pack>. - -=item elseif should be elsif - -(S syntax) There is no keyword "elseif" in Perl because Larry thinks -it's ugly. Your code will be interpreted as an attempt to call a method -named "elseif" for the class returned by the following block. This is -unlikely to be what you want. - -=item Empty %s - -(F) C<\p> and C<\P> are used to introduce a named Unicode property, as -described in L<perlunicode> and L<perlre>. You used C<\p> or C<\P> in -a regular expression without specifying the property name. - -=item entering effective %s failed - -(F) While under the C<use filetest> pragma, switching the real and -effective uids or gids failed. - -=item %ENV is aliased to %s - -(F) You're running under taint mode, and the C<%ENV> variable has been -aliased to another hash, so it doesn't reflect anymore the state of the -program's environment. This is potentially insecure. - -=item Error converting file specification %s - -(F) An error peculiar to VMS. Because Perl may have to deal with file -specifications in either VMS or Unix syntax, it converts them to a -single form when it must operate on them directly. Either you've passed -an invalid file specification to Perl, or you've found a case the -conversion routines don't handle. Drat. - -=item %s: Eval-group in insecure regular expression - -(F) Perl detected tainted data when trying to compile a regular -expression that contains the C<(?{ ... })> zero-width assertion, which -is unsafe. See L<perlre/(?{ code })>, and L<perlsec>. - -=item %s: Eval-group not allowed at runtime, use re 'eval' - -(F) Perl tried to compile a regular expression containing the -C<(?{ ... })> zero-width assertion at run time, as it would when the -pattern contains interpolated values. Since that is a security risk, -it is not allowed. If you insist, you may still do this by using the -C<re 'eval'> pragma or by explicitly building the pattern from an -interpolated string at run time and using that in an eval(). See -L<perlre/(?{ code })>. - -=item %s: Eval-group not allowed, use re 'eval' - -(F) A regular expression contained the C<(?{ ... })> zero-width -assertion, but that construct is only allowed when the C<use re 'eval'> -pragma is in effect. See L<perlre/(?{ code })>. - -=item EVAL without pos change exceeded limit in regex; marked by <-- HERE in m/%s/ - -(F) You used a pattern that nested too many EVAL calls without consuming -any text. Restructure the pattern so that text is consumed. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Excessively long <> operator - -(F) The contents of a <> operator may not exceed the maximum size of a -Perl identifier. If you're just trying to glob a long list of -filenames, try using the glob() operator, or put the filenames into a -variable and glob that. - -=item exec? I'm not *that* kind of operating system - -(F) The C<exec> function is not implemented on some systems, e.g., Symbian -OS. See L<perlport>. - -=item Execution of %s aborted due to compilation errors. - -(F) The final summary message when a Perl compilation fails. - -=item Exiting eval via %s - -(W exiting) You are exiting an eval by unconventional means, such as a -goto, or a loop control statement. - -=item Exiting format via %s - -(W exiting) You are exiting a format by unconventional means, such as a -goto, or a loop control statement. - -=item Exiting pseudo-block via %s - -(W exiting) You are exiting a rather special block construct (like a -sort block or subroutine) by unconventional means, such as a goto, or a -loop control statement. See L<perlfunc/sort>. - -=item Exiting subroutine via %s - -(W exiting) You are exiting a subroutine by unconventional means, such -as a goto, or a loop control statement. - -=item Exiting substitution via %s - -(W exiting) You are exiting a substitution by unconventional means, such -as a return, a goto, or a loop control statement. - -=item Explicit blessing to '' (assuming package main) - -(W misc) You are blessing a reference to a zero length string. This has -the effect of blessing the reference into the package main. This is -usually not what you want. Consider providing a default target package, -e.g. bless($ref, $p || 'MyPackage'); - -=item %s: Expression syntax - -(A) You've accidentally run your script through B<csh> instead of Perl. -Check the #! line, or manually feed your script into Perl yourself. - -=item %s failed--call queue aborted - -(F) An untrapped exception was raised while executing a UNITCHECK, -CHECK, INIT, or END subroutine. Processing of the remainder of the -queue of such routines has been prematurely ended. - -=item False [] range "%s" in regex; marked by <-- HERE in m/%s/ - -(W regexp) A character class range must start and end at a literal -character, not another character class like C<\d> or C<[:alpha:]>. The "-" -in your false range is interpreted as a literal "-". Consider quoting the -"-", "\-". The <-- HERE shows in the regular expression about where the -problem was discovered. See L<perlre>. - -=item Fatal VMS error (status=%d) at %s, line %d - -(P) An error peculiar to VMS. Something untoward happened in a VMS -system service or RTL routine; Perl's exit status should provide more -details. The filename in "at %s" and the line number in "line %d" tell -you which section of the Perl source code is distressed. - -=item fcntl is not implemented - -(F) Your machine apparently doesn't implement fcntl(). What is this, a -PDP-11 or something? - -=item FETCHSIZE returned a negative value - -(F) A tied array claimed to have a negative number of elements, which -is not possible. - -=item Field too wide in 'u' format in pack - -(W pack) Each line in an uuencoded string start with a length indicator -which can't encode values above 63. So there is no point in asking for -a line length bigger than that. Perl will behave as if you specified -C<u63> as the format. - -=item Filehandle %s opened only for input - -(W io) You tried to write on a read-only filehandle. If you intended -it to be a read-write filehandle, you needed to open it with "+<" or -"+>" or "+>>" instead of with "<" or nothing. If you intended only to -write the file, use ">" or ">>". See L<perlfunc/open>. - -=item Filehandle %s opened only for output - -(W io) You tried to read from a filehandle opened only for writing, If -you intended it to be a read/write filehandle, you needed to open it -with "+<" or "+>" or "+>>" instead of with ">". If you intended only to -read from the file, use "<". See L<perlfunc/open>. Another possibility -is that you attempted to open filedescriptor 0 (also known as STDIN) for -output (maybe you closed STDIN earlier?). - -=item Filehandle %s reopened as %s only for input - -(W io) You opened for reading a filehandle that got the same filehandle id -as STDOUT or STDERR. This occurred because you closed STDOUT or STDERR -previously. - -=item Filehandle STDIN reopened as %s only for output - -(W io) You opened for writing a filehandle that got the same filehandle id -as STDIN. This occurred because you closed STDIN previously. - -=item Final $ should be \$ or $name - -(F) You must now decide whether the final $ in a string was meant to be -a literal dollar sign, or was meant to introduce a variable name that -happens to be missing. So you have to put either the backslash or the -name. - -=item flock() on closed filehandle %s - -(W closed) The filehandle you're attempting to flock() got itself closed -some time before now. Check your control flow. flock() operates on -filehandles. Are you attempting to call flock() on a dirhandle by the -same name? - -=item Format not terminated - -(F) A format must be terminated by a line with a solitary dot. Perl got -to the end of your file without finding such a line. - -=item Format %s redefined - -(W redefine) You redefined a format. To suppress this warning, say - - { - no warnings 'redefine'; - eval "format NAME =..."; - } - -=item Found = in conditional, should be == - -(W syntax) You said - - if ($foo = 123) - -when you meant - - if ($foo == 123) - -(or something like that). - -=item %s found where operator expected - -(S syntax) The Perl lexer knows whether to expect a term or an operator. -If it sees what it knows to be a term when it was expecting to see an -operator, it gives you this warning. Usually it indicates that an -operator or delimiter was omitted, such as a semicolon. - -=item gdbm store returned %d, errno %d, key "%s" - -(S) A warning from the GDBM_File extension that a store failed. - -=item gethostent not implemented - -(F) Your C library apparently doesn't implement gethostent(), probably -because if it did, it'd feel morally obligated to return every hostname -on the Internet. - -=item get%sname() on closed socket %s - -(W closed) You tried to get a socket or peer socket name on a closed -socket. Did you forget to check the return value of your socket() call? - -=item getpwnam returned invalid UIC %#o for user "%s" - -(S) A warning peculiar to VMS. The call to C<sys$getuai> underlying the -C<getpwnam> operator returned an invalid UIC. - -=item getsockopt() on closed socket %s - -(W closed) You tried to get a socket option on a closed socket. Did you -forget to check the return value of your socket() call? See -L<perlfunc/getsockopt>. - -=item Global symbol "%s" requires explicit package name - -(F) You've said "use strict" or "use strict vars", which indicates -that all variables must either be lexically scoped (using "my" or "state"), -declared beforehand using "our", or explicitly qualified to say -which package the global variable is in (using "::"). - -=item glob failed (%s) - -(S glob) Something went wrong with the external program(s) used -for C<glob> and C<< <*.c> >>. Usually, this means that you supplied a C<glob> -pattern that caused the external program to fail and exit with a -nonzero status. If the message indicates that the abnormal exit -resulted in a coredump, this may also mean that your csh (C shell) -is broken. If so, you should change all of the csh-related variables -in config.sh: If you have tcsh, make the variables refer to it as -if it were csh (e.g. C<full_csh='/usr/bin/tcsh'>); otherwise, make them -all empty (except that C<d_csh> should be C<'undef'>) so that Perl will -think csh is missing. In either case, after editing config.sh, run -C<./Configure -S> and rebuild Perl. - -=item Glob not terminated - -(F) The lexer saw a left angle bracket in a place where it was expecting -a term, so it's looking for the corresponding right angle bracket, and -not finding it. Chances are you left some needed parentheses out -earlier in the line, and you really meant a "less than". - -=item gmtime(%f) too large - -(W overflow) You called C<gmtime> with a number that was larger than -it can reliably handle and C<gmtime> probably returned the wrong -date. This warning is also triggered with NaN (the special -not-a-number value). - -=item gmtime(%f) too small - -(W overflow) You called C<gmtime> with a number that was smaller than -it can reliably handle and C<gmtime> probably returned the wrong date. - -=item Got an error from DosAllocMem - -(P) An error peculiar to OS/2. Most probably you're using an obsolete -version of Perl, and this should not happen anyway. - -=item goto must have label - -(F) Unlike with "next" or "last", you're not allowed to goto an -unspecified destination. See L<perlfunc/goto>. - -=item Goto undefined subroutine%s - -(F) You tried to call a subroutine with C<goto &sub> syntax, but -the indicated subroutine hasn't been defined, or if it was, it -has since been undefined. - -=item ()-group starts with a count - -(F) A ()-group started with a count. A count is supposed to follow -something: a template character or a ()-group. See L<perlfunc/pack>. - -=item %s had compilation errors. - -(F) The final summary message when a C<perl -c> fails. - -=item Had to create %s unexpectedly - -(S internal) A routine asked for a symbol from a symbol table that ought -to have existed already, but for some reason it didn't, and had to be -created on an emergency basis to prevent a core dump. - -=item Hash %%s missing the % in argument %d of %s() - -(D deprecated) Really old Perl let you omit the % on hash names in some -spots. This is now heavily deprecated. - -=item %s has too many errors - -(F) The parser has given up trying to parse the program after 10 errors. -Further error messages would likely be uninformative. - -=item Having no space between pattern and following word is deprecated - -(D syntax) - -You had a word that isn't a regex modifier immediately following -a pattern without an intervening space. If you are trying to use -the C</le> flags on a substitution, use C</el> instead. Otherwise, add -white space between the pattern and following word to eliminate -the warning. As an example of the latter, the two constructs: - - - $a =~ m/$foo/sand $bar - $a =~ m/$foo/s and $bar - -both currently mean the same thing, but it is planned to disallow -the first form in Perl 5.18. And, - - $a =~ m/$foo/and $bar - -will be disallowed too. - -=item Hexadecimal number > 0xffffffff non-portable - -(W portable) The hexadecimal number you specified is larger than 2**32-1 -(4294967295) and therefore non-portable between systems. See -L<perlport> for more on portability concerns. - -=item Identifier too long - -(F) Perl limits identifiers (names for variables, functions, etc.) to -about 250 characters for simple names, and somewhat more for compound -names (like C<$A::B>). You've exceeded Perl's limits. Future versions -of Perl are likely to eliminate these arbitrary limitations. - -=item Ignoring zero length \N{} in character class - -(W) Named Unicode character escapes C<(\N{...})> may return a zero-length -sequence. When such an escape is used in a character class its -behaviour is not well defined. Check that the correct escape has -been used, and the correct charname handler is in scope. - -=item Illegal binary digit %s - -(F) You used a digit other than 0 or 1 in a binary number. - -=item Illegal binary digit %s ignored - -(W digit) You may have tried to use a digit other than 0 or 1 in a -binary number. Interpretation of the binary number stopped before the -offending digit. - -=item Illegal character after '_' in prototype for %s : %s - -(W illegalproto) An illegal character was found in a prototype declaration. -Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +. - -=item Illegal character \%o (carriage return) - -(F) Perl normally treats carriage returns in the program text as it -would any other whitespace, which means you should never see this error -when Perl was built using standard options. For some reason, your -version of Perl appears to have been built without this support. Talk -to your Perl administrator. - -=item Illegal character in prototype for %s : %s - -(W illegalproto) An illegal character was found in a prototype declaration. -Legal characters in prototypes are $, @, %, *, ;, [, ], &, \, and +. - -=item Illegal declaration of anonymous subroutine - -(F) When using the C<sub> keyword to construct an anonymous subroutine, -you must always specify a block of code. See L<perlsub>. - -=item Illegal declaration of subroutine %s - -(F) A subroutine was not declared correctly. See L<perlsub>. - -=item Illegal division by zero - -(F) You tried to divide a number by 0. Either something was wrong in -your logic, or you need to put a conditional in to guard against -meaningless input. - -=item Illegal hexadecimal digit %s ignored - -(W digit) You may have tried to use a character other than 0 - 9 or -A - F, a - f in a hexadecimal number. Interpretation of the hexadecimal -number stopped before the illegal character. - -=item Illegal modulus zero - -(F) You tried to divide a number by 0 to get the remainder. Most -numbers don't take to this kindly. - -=item Illegal number of bits in vec - -(F) The number of bits in vec() (the third argument) must be a power of -two from 1 to 32 (or 64, if your platform supports that). - -=item Illegal octal digit %s - -(F) You used an 8 or 9 in an octal number. - -=item Illegal octal digit %s ignored - -(W digit) You may have tried to use an 8 or 9 in an octal number. -Interpretation of the octal number stopped before the 8 or 9. - -=item Illegal switch in PERL5OPT: -%c - -(X) The PERL5OPT environment variable may only be used to set the -following switches: B<-[CDIMUdmtw]>. - -=item Ill-formed CRTL environ value "%s" - -(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's -internal environ array, and encountered an element without the C<=> -delimiter used to separate keys from values. The element is ignored. - -=item Ill-formed message in prime_env_iter: |%s| - -(W internal) A warning peculiar to VMS. Perl tried to read a logical -name or CLI symbol definition when preparing to iterate over %ENV, and -didn't see the expected delimiter between key and value, so the line was -ignored. - -=item (in cleanup) %s - -(W misc) This prefix usually indicates that a DESTROY() method raised -the indicated exception. Since destructors are usually called by the -system at arbitrary points during execution, and often a vast number of -times, the warning is issued only once for any number of failures that -would otherwise result in the same message being repeated. - -Failure of user callbacks dispatched using the C<G_KEEPERR> flag could -also result in this warning. See L<perlcall/G_KEEPERR>. - -=item Inconsistent hierarchy during C3 merge of class '%s': merging failed on parent '%s' - -(F) The method resolution order (MRO) of the given class is not -C3-consistent, and you have enabled the C3 MRO for this class. See the C3 -documentation in L<mro> for more information. - -=item In EBCDIC the v-string components cannot exceed 2147483647 - -(F) An error peculiar to EBCDIC. Internally, v-strings are stored as -Unicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC -encoding is limited to code points no larger than 2147483647 (0x7FFFFFFF). - -=item Infinite recursion in regex; marked by <-- HERE in m/%s/ - -(F) You used a pattern that references itself without consuming any input -text. You should check the pattern to ensure that recursive patterns -either consume text or fail. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Initialization of state variables in list context currently forbidden - -(F) Currently the implementation of "state" only permits the -initialization of scalar variables in scalar context. Re-write -C<state ($a) = 42> as C<state $a = 42> to change from list to scalar -context. Constructions such as C<state (@a) = foo()> will be -supported in a future perl release. - -=item Insecure dependency in %s - -(F) You tried to do something that the tainting mechanism didn't like. -The tainting mechanism is turned on when you're running setuid or -setgid, or when you specify B<-T> to turn it on explicitly. The -tainting mechanism labels all data that's derived directly or indirectly -from the user, who is considered to be unworthy of your trust. If any -such data is used in a "dangerous" operation, you get this error. See -L<perlsec> for more information. - -=item Insecure directory in %s - -(F) You can't use system(), exec(), or a piped open in a setuid or -setgid script if C<$ENV{PATH}> contains a directory that is writable by -the world. Also, the PATH must not contain any relative directory. -See L<perlsec>. - -=item Insecure $ENV{%s} while running %s - -(F) You can't use system(), exec(), or a piped open in a setuid or -setgid script if any of C<$ENV{PATH}>, C<$ENV{IFS}>, C<$ENV{CDPATH}>, -C<$ENV{ENV}>, C<$ENV{BASH_ENV}> or C<$ENV{TERM}> are derived from data -supplied (or potentially supplied) by the user. The script must set -the path to a known value, using trustworthy data. See L<perlsec>. - -=item Insecure user-defined property %s - -(F) Perl detected tainted data when trying to compile a regular -expression that contains a call to a user-defined character property -function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>. -See L<perlunicode/User-Defined Character Properties> and L<perlsec>. - -=item Integer overflow in format string for %s - -(F) The indexes and widths specified in the format string of C<printf()> -or C<sprintf()> are too large. The numbers must not overflow the size of -integers for your architecture. - -=item Integer overflow in %s number - -(W overflow) The hexadecimal, octal or binary number you have specified -either as a literal or as an argument to hex() or oct() is too big for -your architecture, and has been converted to a floating point number. -On a 32-bit architecture the largest hexadecimal, octal or binary number -representable without overflow is 0xFFFFFFFF, 037777777777, or -0b11111111111111111111111111111111 respectively. Note that Perl -transparently promotes all numbers to a floating point representation -internally--subject to loss of precision errors in subsequent -operations. - -=item Integer overflow in version - -(F) Some portion of a version initialization is too large for the -size of integers for your architecture. This is not a warning -because there is no rational reason for a version to try and use a -element larger than typically 2**32. This is usually caused by -trying to use some odd mathematical operation as a version, like -100/9. - -=item Internal disaster in regex; marked by <-- HERE in m/%s/ - -(P) Something went badly wrong in the regular expression parser. -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Internal inconsistency in tracking vforks - -(S) A warning peculiar to VMS. Perl keeps track of the number of times -you've called C<fork> and C<exec>, to determine whether the current call -to C<exec> should affect the current script or a subprocess (see -L<perlvms/"exec LIST">). Somehow, this count has become scrambled, so -Perl is making a guess and treating this C<exec> as a request to -terminate the Perl script and execute the specified command. - -=item Internal urp in regex; marked by <-- HERE in m/%s/ - -(P) Something went badly awry in the regular expression parser. The -<-- HERE shows in the regular expression about where the problem was -discovered. - -=item %s (...) interpreted as function - -(W syntax) You've run afoul of the rule that says that any list operator -followed by parentheses turns into a function, with all the list -operators arguments found inside the parentheses. See -L<perlop/Terms and List Operators (Leftward)>. - -=item Invalid %s attribute: %s - -(F) The indicated attribute for a subroutine or variable was not recognized -by Perl or by a user-supplied handler. See L<attributes>. - -=item Invalid %s attributes: %s - -(F) The indicated attributes for a subroutine or variable were not -recognized by Perl or by a user-supplied handler. See L<attributes>. - -=item Invalid conversion in %s: "%s" - -(W printf) Perl does not understand the given format conversion. See -L<perlfunc/sprintf>. - -=item Invalid escape in the specified encoding in regex; marked by <-- HERE in m/%s/ - -(W regexp) The numeric escape (for example C<\xHH>) of value < 256 -didn't correspond to a single character through the conversion -from the encoding specified by the encoding pragma. -The escape was replaced with REPLACEMENT CHARACTER (U+FFFD) instead. -The <-- HERE shows in the regular expression about where the -escape was discovered. - -=item Invalid hexadecimal number in \N{U+...} - -(F) The character constant represented by C<...> is not a valid hexadecimal -number. Either it is empty, or you tried to use a character other than -0 - 9 or A - F, a - f in a hexadecimal number. - -=item Invalid module name %s with -%c option: contains single ':' - -(F) The module argument to perl's B<-m> and B<-M> command-line options -cannot contain single colons in the module name, but only in the -arguments after "=". In other words, B<-MFoo::Bar=:baz> is ok, but -B<-MFoo:Bar=baz> is not. - -=item Invalid mro name: '%s' - -(F) You tried to C<mro::set_mro("classname", "foo")> or C<use mro 'foo'>, -where C<foo> is not a valid method resolution order (MRO). Currently, -the only valid ones supported are C<dfs> and C<c3>, unless you have loaded -a module that is a MRO plugin. See L<mro> and L<perlmroapi>. - -=item invalid option -D%c, use -D'' to see choices - -(F) Perl was called with invalid debugger flags. Call perl with -the B<-D> option with no flags to see the list of acceptable values. -See also L<< perlrun/B<-D>I<letters> >>. - -=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/ - -(F) The range specified in a character class had a minimum character -greater than the maximum character. One possibility is that you forgot the -C<{}> from your ending C<\x{}> - C<\x> without the curly braces can go only -up to C<ff>. The <-- HERE shows in the regular expression about where the -problem was discovered. See L<perlre>. - -=item Invalid range "%s" in transliteration operator - -(F) The range specified in the tr/// or y/// operator had a minimum -character greater than the maximum character. See L<perlop>. - -=item Invalid separator character %s in attribute list - -(F) Something other than a colon or whitespace was seen between the -elements of an attribute list. If the previous attribute had a -parenthesised parameter list, perhaps that list was terminated too soon. -See L<attributes>. - -=item Invalid separator character %s in PerlIO layer specification %s - -(W layer) When pushing layers onto the Perl I/O system, something other -than a colon or whitespace was seen between the elements of a layer list. -If the previous attribute had a parenthesised parameter list, perhaps that -list was terminated too soon. - -=item Invalid strict version format (%s) - -(F) A version number did not meet the "strict" criteria for versions. -A "strict" version number is a positive decimal number (integer or -decimal-fraction) without exponentiation or else a dotted-decimal -v-string with a leading 'v' character and at least three components. -The parenthesized text indicates which criteria were not met. -See the L<version> module for more details on allowed version formats. - -=item Invalid type '%s' in %s - -(F) The given character is not a valid pack or unpack type. -See L<perlfunc/pack>. - -(W) The given character is not a valid pack or unpack type but used to be -silently ignored. - -=item Invalid version format (%s) - -(F) A version number did not meet the "lax" criteria for versions. -A "lax" version number is a positive decimal number (integer or -decimal-fraction) without exponentiation or else a dotted-decimal -v-string. If the v-string has fewer than three components, it -must have a leading 'v' character. Otherwise, the leading 'v' is -optional. Both decimal and dotted-decimal versions may have a -trailing "alpha" component separated by an underscore character -after a fractional or dotted-decimal component. The parenthesized -text indicates which criteria were not met. See the L<version> module -for more details on allowed version formats. - -=item Invalid version object - -(F) The internal structure of the version object was invalid. -Perhaps the internals were modified directly in some way or -an arbitrary reference was blessed into the "version" class. - -=item ioctl is not implemented - -(F) Your machine apparently doesn't implement ioctl(), which is pretty -strange for a machine that supports C. - -=item ioctl() on unopened %s - -(W unopened) You tried ioctl() on a filehandle that was never opened. -Check your control flow and number of arguments. - -=item IO layers (like '%s') unavailable - -(F) Your Perl has not been configured to have PerlIO, and therefore -you cannot use IO layers. To have PerlIO, Perl must be configured -with 'useperlio'. - -=item IO::Socket::atmark not implemented on this architecture - -(F) Your machine doesn't implement the sockatmark() functionality, -neither as a system call nor an ioctl call (SIOCATMARK). - -=item $* is no longer supported - -(D deprecated, syntax) The special variable C<$*>, deprecated in older -perls, has been removed as of 5.9.0 and is no longer supported. In -previous versions of perl the use of C<$*> enabled or disabled multi-line -matching within a string. - -Instead of using C<$*> you should use the C</m> (and maybe C</s>) regexp -modifiers. You can enable C</m> for a lexical scope (even a whole file) -with C<use re '/m'>. (In older versions: when C<$*> was set to a true value -then all regular expressions behaved as if they were written using C</m>.) - -=item $# is no longer supported - -(D deprecated, syntax) The special variable C<$#>, deprecated in older -perls, has been removed as of 5.9.3 and is no longer supported. You -should use the printf/sprintf functions instead. - -=item '%s' is not a code reference - -(W overload) The second (fourth, sixth, ...) argument of -overload::constant needs to be a code reference. Either -an anonymous subroutine, or a reference to a subroutine. - -=item '%s' is not an overloadable type - -(W overload) You tried to overload a constant type the overload package is -unaware of. - -=item junk on end of regexp - -(P) The regular expression parser is confused. - -=item Label not found for "last %s" - -(F) You named a loop to break out of, but you're not currently in a loop -of that name, not even if you count where you were called from. See -L<perlfunc/last>. - -=item Label not found for "next %s" - -(F) You named a loop to continue, but you're not currently in a loop of -that name, not even if you count where you were called from. See -L<perlfunc/last>. - -=item Label not found for "redo %s" - -(F) You named a loop to restart, but you're not currently in a loop of -that name, not even if you count where you were called from. See -L<perlfunc/last>. - -=item leaving effective %s failed - -(F) While under the C<use filetest> pragma, switching the real and -effective uids or gids failed. - -=item length/code after end of string in unpack - -(F) While unpacking, the string buffer was already used up when an unpack -length/code combination tried to obtain more data. This results in -an undefined value for the length. See L<perlfunc/pack>. - -=item length() used on %s - -(W syntax) You used length() on either an array or a hash when you -probably wanted a count of the items. - -Array size can be obtained by doing: - - scalar(@array); - -The number of items in a hash can be obtained by doing: - - scalar(keys %hash); - -=item Lexing code attempted to stuff non-Latin-1 character into Latin-1 input - -(F) An extension is attempting to insert text into the current parse -(using L<lex_stuff_pvn|perlapi/lex_stuff_pvn> or similar), but tried to insert a character that -couldn't be part of the current input. This is an inherent pitfall -of the stuffing mechanism, and one of the reasons to avoid it. Where -it is necessary to stuff, stuffing only plain ASCII is recommended. - -=item Lexing code internal error (%s) - -(F) Lexing code supplied by an extension violated the lexer's API in a -detectable way. - -=item listen() on closed socket %s - -(W closed) You tried to do a listen on a closed socket. Did you forget -to check the return value of your socket() call? See -L<perlfunc/listen>. - -=item List form of piped open not implemented - -(F) On some platforms, notably Windows, the three-or-more-arguments -form of C<open> does not support pipes, such as C<open($pipe, '|-', @args)>. -Use the two-argument C<open($pipe, '|prog arg1 arg2...')> form instead. - -=item localtime(%f) too large - -(W overflow) You called C<localtime> with a number that was larger -than it can reliably handle and C<localtime> probably returned the -wrong date. This warning is also triggered with NaN (the special -not-a-number value). - -=item localtime(%f) too small - -(W overflow) You called C<localtime> with a number that was smaller -than it can reliably handle and C<localtime> probably returned the -wrong date. - -=item Lookbehind longer than %d not implemented in regex m/%s/ - -(F) There is currently a limit on the length of string which lookbehind can -handle. This restriction may be eased in a future release. - -=item Lost precision when %s %f by 1 - -(W) The value you attempted to increment or decrement by one is too large -for the underlying floating point representation to store accurately, -hence the target of C<++> or C<--> is unchanged. Perl issues this warning -because it has already switched from integers to floating point when values -are too large for integers, and now even floating point is insufficient. -You may wish to switch to using L<Math::BigInt> explicitly. - -=item lstat() on filehandle%s - -(W io) You tried to do an lstat on a filehandle. What did you mean -by that? lstat() makes sense only on filenames. (Perl did a fstat() -instead on the filehandle.) - -=item lvalue attribute %s already-defined subroutine - -(W misc) Although L<attributes.pm|attributes> allows this, turning the lvalue -attribute on or off on a Perl subroutine that is already defined -does not always work properly. It may or may not do what you -want, depending on what code is inside the subroutine, with exact -details subject to change between Perl versions. Only do this -if you really know what you are doing. - -=item lvalue attribute ignored after the subroutine has been defined - -(W misc) Using the C<:lvalue> declarative syntax to make a Perl -subroutine an lvalue subroutine after it has been defined is -not permitted. To make the subroutine an lvalue subroutine, -add the lvalue attribute to the definition, or put the C<sub -foo :lvalue;> declaration before the definition. - -See also L<attributes.pm|attributes>. - -=item Malformed integer in [] in pack - -(F) Between the brackets enclosing a numeric repeat count only digits -are permitted. See L<perlfunc/pack>. - -=item Malformed integer in [] in unpack - -(F) Between the brackets enclosing a numeric repeat count only digits -are permitted. See L<perlfunc/pack>. - -=item Malformed PERLLIB_PREFIX - -(F) An error peculiar to OS/2. PERLLIB_PREFIX should be of the form - - prefix1;prefix2 - -or - prefix1 prefix2 - -with nonempty prefix1 and prefix2. If C<prefix1> is indeed a prefix of -a builtin library search path, prefix2 is substituted. The error may -appear if components are not found, or are too long. See -"PERLLIB_PREFIX" in L<perlos2>. - -=item Malformed prototype for %s: %s - -(F) You tried to use a function with a malformed prototype. The -syntax of function prototypes is given a brief compile-time check for -obvious errors like invalid characters. A more rigorous check is run -when the function is called. - -=item Malformed UTF-8 character (%s) - -(S utf8)(F) Perl detected a string that didn't comply with UTF-8 -encoding rules, even though it had the UTF8 flag on. - -One possible cause is that you set the UTF8 flag yourself for data that -you thought to be in UTF-8 but it wasn't (it was for example legacy -8-bit data). To guard against this, you can use Encode::decode_utf8. - -If you use the C<:encoding(UTF-8)> PerlIO layer for input, invalid byte -sequences are handled gracefully, but if you use C<:utf8>, the flag is -set without validating the data, possibly resulting in this error -message. - -See also L<Encode/"Handling Malformed Data">. - -=item Malformed UTF-8 returned by \N - -(F) The charnames handler returned malformed UTF-8. - -=item Malformed UTF-8 string in '%c' format in unpack - -(F) You tried to unpack something that didn't comply with UTF-8 encoding -rules and perl was unable to guess how to make more progress. - -=item Malformed UTF-8 string in pack - -(F) You tried to pack something that didn't comply with UTF-8 encoding -rules and perl was unable to guess how to make more progress. - -=item Malformed UTF-8 string in unpack - -(F) You tried to unpack something that didn't comply with UTF-8 encoding -rules and perl was unable to guess how to make more progress. - -=item Malformed UTF-16 surrogate - -(F) Perl thought it was reading UTF-16 encoded character data but while -doing it Perl met a malformed Unicode surrogate. - -=item %s matches null string many times in regex; marked by <-- HERE in m/%s/ - -(W regexp) The pattern you've specified would be an infinite loop if the -regular expression engine didn't specifically check for that. The <-- HERE -shows in the regular expression about where the problem was discovered. -See L<perlre>. - -=item Maximal count of pending signals (%u) exceeded - -(F) Perl aborted due to too high a number of signals pending. This -usually indicates that your operating system tried to deliver signals -too fast (with a very high priority), starving the perl process from -resources it would need to reach a point where it can process signals -safely. (See L<perlipc/"Deferred Signals (Safe Signals)">.) - -=item "%s" may clash with future reserved word - -(W) This warning may be due to running a perl5 script through a perl4 -interpreter, especially if the word that is being warned about is -"use" or "my". - -=item '%' may not be used in pack - -(F) You can't pack a string by supplying a checksum, because the -checksumming process loses information, and you can't go the other way. -See L<perlfunc/unpack>. - -=item Method for operation %s not found in package %s during blessing - -(F) An attempt was made to specify an entry in an overloading table that -doesn't resolve to a valid subroutine. See L<overload>. - -=item Method %s not permitted - -See Server error. - -=item Might be a runaway multi-line %s string starting on line %d - -(S) An advisory indicating that the previous error may have been caused -by a missing delimiter on a string or pattern, because it eventually -ended earlier on the current line. - -=item Misplaced _ in number - -(W syntax) An underscore (underbar) in a numeric constant did not -separate two digits. - -=item Missing argument in %s - -(W uninitialized) A printf-type format required more arguments than were -supplied. - -=item Missing argument to -%c - -(F) The argument to the indicated command line switch must follow -immediately after the switch, without intervening spaces. - -=item Missing braces on \N{} - -(F) Wrong syntax of character name literal C<\N{charname}> within -double-quotish context. This can also happen when there is a space -(or comment) between the C<\N> and the C<{> in a regex with the C</x> modifier. -This modifier does not change the requirement that the brace immediately -follow the C<\N>. - -=item Missing braces on \o{} - -(F) A C<\o> must be followed immediately by a C<{> in double-quotish context. - -=item Missing comma after first argument to %s function - -(F) While certain functions allow you to specify a filehandle or an -"indirect object" before the argument list, this ain't one of them. - -=item Missing command in piped open - -(W pipe) You used the C<open(FH, "| command")> or -C<open(FH, "command |")> construction, but the command was missing or -blank. - -=item Missing control char name in \c - -(F) A double-quoted string ended with "\c", without the required control -character name. - -=item Missing name in "my sub" - -(F) The reserved syntax for lexically scoped subroutines requires that -they have a name with which they can be found. - -=item Missing $ on loop variable - -(F) Apparently you've been programming in B<csh> too much. Variables -are always mentioned with the $ in Perl, unlike in the shells, where it -can vary from one line to the next. - -=item (Missing operator before %s?) - -(S syntax) This is an educated guess made in conjunction with the message -"%s found where operator expected". Often the missing operator is a comma. - -=item Missing right brace on %s - -(F) Missing right brace in C<\x{...}>, C<\p{...}>, C<\P{...}>, or C<\N{...}>. - -=item Missing right brace on \N{} or unescaped left brace after \N - -(F) C<\N> has two meanings. - -The traditional one has it followed by a name enclosed in braces, -meaning the character (or sequence of characters) given by that -name. Thus C<\N{ASTERISK}> is another way of writing C<*>, valid in both -double-quoted strings and regular expression patterns. In patterns, -it doesn't have the meaning an unescaped C<*> does. - -Starting in Perl 5.12.0, C<\N> also can have an additional meaning (only) -in patterns, namely to match a non-newline character. (This is short -for C<[^\n]>, and like C<.> but is not affected by the C</s> regex modifier.) - -This can lead to some ambiguities. When C<\N> is not followed immediately -by a left brace, Perl assumes the C<[^\n]> meaning. Also, if the braces -form a valid quantifier such as C<\N{3}> or C<\N{5,}>, Perl assumes that this -means to match the given quantity of non-newlines (in these examples, -3; and 5 or more, respectively). In all other case, where there is a -C<\N{> and a matching C<}>, Perl assumes that a character name is desired. - -However, if there is no matching C<}>, Perl doesn't know if it was -mistakenly omitted, or if C<[^\n]{> was desired, and raises this error. -If you meant the former, add the right brace; if you meant the latter, -escape the brace with a backslash, like so: C<\N\{> - -=item Missing right curly or square bracket - -(F) The lexer counted more opening curly or square brackets than closing -ones. As a general rule, you'll find it's missing near the place you -were last editing. - -=item (Missing semicolon on previous line?) - -(S syntax) This is an educated guess made in conjunction with the message -"%s found where operator expected". Don't automatically put a semicolon on -the previous line just because you saw this message. - -=item Modification of a read-only value attempted - -(F) You tried, directly or indirectly, to change the value of a -constant. You didn't, of course, try "2 = 1", because the compiler -catches that. But an easy way to do the same thing is: - - sub mod { $_[0] = 1 } - mod(2); - -Another way is to assign to a substr() that's off the end of the string. - -Yet another way is to assign to a C<foreach> loop I<VAR> when I<VAR> -is aliased to a constant in the look I<LIST>: - - $x = 1; - foreach my $n ($x, 2) { - $n *= 2; # modifies the $x, but fails on attempt to - } # modify the 2 - -=item Modification of non-creatable array value attempted, %s - -(F) You tried to make an array value spring into existence, and the -subscript was probably negative, even counting from end of the array -backwards. - -=item Modification of non-creatable hash value attempted, %s - -(P) You tried to make a hash value spring into existence, and it -couldn't be created for some peculiar reason. - -=item Module name must be constant - -(F) Only a bare module name is allowed as the first argument to a "use". - -=item Module name required with -%c option - -(F) The C<-M> or C<-m> options say that Perl should load some module, but -you omitted the name of the module. Consult L<perlrun> for full details -about C<-M> and C<-m>. - -=item More than one argument to '%s' open - -(F) The C<open> function has been asked to open multiple files. This -can happen if you are trying to open a pipe to a command that takes a -list of arguments, but have forgotten to specify a piped open mode. -See L<perlfunc/open> for details. - -=item msg%s not implemented - -(F) You don't have System V message IPC on your system. - -=item Multidimensional syntax %s not supported - -(W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>. -They're written like C<$foo[1][2][3]>, as in C. - -=item '/' must follow a numeric type in unpack - -(F) You had an unpack template that contained a '/', but this did not -follow some unpack specification producing a numeric value. -See L<perlfunc/pack>. - -=item "my sub" not yet implemented - -(F) Lexically scoped subroutines are not yet implemented. Don't try -that yet. - -=item "my" variable %s can't be in a package - -(F) Lexically scoped variables aren't in a package, so it doesn't make -sense to try to declare one with a package qualifier on the front. Use -local() if you want to localize a package variable. - -=item Name "%s::%s" used only once: possible typo - -(W once) Typographical errors often show up as unique variable names. -If you had a good reason for having a unique name, then just mention it -again somehow to suppress the message. The C<our> declaration is -provided for this purpose. - -NOTE: This warning detects symbols that have been used only once so $c, @c, -%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered -the same; if a program uses $c only once but also uses any of the others it -will not trigger this warning. - -=item \N in a character class must be a named character: \N{...} - -(F) The new (5.12) meaning of C<\N> as C<[^\n]> is not valid in a bracketed -character class, for the same reason that C<.> in a character class loses -its specialness: it matches almost everything, which is probably not -what you want. - -=item \N{NAME} must be resolved by the lexer - -(F) When compiling a regex pattern, an unresolved named character or -sequence was encountered. This can happen in any of several ways that -bypass the lexer, such as using single-quotish context, or an extra -backslash in double-quotish: - - $re = '\N{SPACE}'; # Wrong! - $re = "\\N{SPACE}"; # Wrong! - /$re/; - -Instead, use double-quotes with a single backslash: - - $re = "\N{SPACE}"; # ok - /$re/; - -The lexer can be bypassed as well by creating the pattern from smaller -components: - - $re = '\N'; - /${re}{SPACE}/; # Wrong! - -It's not a good idea to split a construct in the middle like this, and it -doesn't work here. Instead use the solution above. - -Finally, the message also can happen under the C</x> regex modifier when the -C<\N> is separated by spaces from the C<{>, in which case, remove the spaces. - - /\N {SPACE}/x; # Wrong! - /\N{SPACE}/x; # ok - -=item Negative '/' count in unpack - -(F) The length count obtained from a length/code unpack operation was -negative. See L<perlfunc/pack>. - -=item Negative length - -(F) You tried to do a read/write/send/recv operation with a buffer -length that is less than 0. This is difficult to imagine. - -=item Negative offset to vec in lvalue context - -(F) When C<vec> is called in an lvalue context, the second argument must be -greater than or equal to zero. - -=item Nested quantifiers in regex; marked by <-- HERE in m/%s/ - -(F) You can't quantify a quantifier without intervening parentheses. -So things like ** or +* or ?* are illegal. The <-- HERE shows in the -regular expression about where the problem was discovered. - -Note that the minimal matching quantifiers, C<*?>, C<+?>, and -C<??> appear to be nested quantifiers, but aren't. See L<perlre>. - -=item %s never introduced - -(S internal) The symbol in question was declared but somehow went out of -scope before it could possibly have been used. - -=item next::method/next::can/maybe::next::method cannot find enclosing method - -(F) C<next::method> needs to be called within the context of a -real method in a real package, and it could not find such a context. -See L<mro>. - -=item No %s allowed while running setuid - -(F) Certain operations are deemed to be too insecure for a setuid or -setgid script to even be allowed to attempt. Generally speaking there -will be another way to do what you want that is, if not secure, at least -securable. See L<perlsec>. - -=item No code specified for -%c - -(F) Perl's B<-e> and B<-E> command-line options require an argument. If -you want to run an empty program, pass the empty string as a separate -argument or run a program consisting of a single 0 or 1: - - perl -e "" - perl -e0 - perl -e1 - -=item No comma allowed after %s - -(F) A list operator that has a filehandle or "indirect object" is -not allowed to have a comma between that and the following arguments. -Otherwise it'd be just another one of the arguments. - -One possible cause for this is that you expected to have imported -a constant to your name space with B<use> or B<import> while no such -importing took place, it may for example be that your operating -system does not support that particular constant. Hopefully you did -use an explicit import list for the constants you expect to see; -please see L<perlfunc/use> and L<perlfunc/import>. While an -explicit import list would probably have caught this error earlier -it naturally does not remedy the fact that your operating system -still does not support that constant. Maybe you have a typo in -the constants of the symbol import list of B<use> or B<import> or in the -constant name at the line where this error was triggered? - -=item No command into which to pipe on command line - -(F) An error peculiar to VMS. Perl handles its own command line -redirection, and found a '|' at the end of the command line, so it -doesn't know where you want to pipe the output from this command. - -=item No DB::DB routine defined - -(F) The currently executing code was compiled with the B<-d> switch, but -for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::> -module) didn't define a routine to be called at the beginning of each -statement. - -=item No dbm on this machine - -(P) This is counted as an internal error, because every machine should -supply dbm nowadays, because Perl comes with SDBM. See L<SDBM_File>. - -=item No DB::sub routine defined - -(F) The currently executing code was compiled with the B<-d> switch, but -for some reason the current debugger (e.g. F<perl5db.pl> or a C<Devel::> -module) didn't define a C<DB::sub> routine to be called at the beginning -of each ordinary subroutine call. - -=item No directory specified for -I - -(F) The B<-I> command-line switch requires a directory name as part of the -I<same> argument. Use B<-Ilib>, for instance. B<-I lib> won't work. - -=item No error file after 2> or 2>> on command line - -(F) An error peculiar to VMS. Perl handles its own command line -redirection, and found a '2>' or a '2>>' on the command line, but can't -find the name of the file to which to write data destined for stderr. - -=item No group ending character '%c' found in template - -(F) A pack or unpack template has an opening '(' or '[' without its -matching counterpart. See L<perlfunc/pack>. - -=item No input file after < on command line - -(F) An error peculiar to VMS. Perl handles its own command line -redirection, and found a '<' on the command line, but can't find the -name of the file from which to read data for stdin. - -=item No next::method '%s' found for %s - -(F) C<next::method> found no further instances of this method name -in the remaining packages of the MRO of this class. If you don't want -it throwing an exception, use C<maybe::next::method> -or C<next::can>. See L<mro>. - -=item "no" not allowed in expression - -(F) The "no" keyword is recognized and executed at compile time, and -returns no useful value. See L<perlmod>. - -=item No output file after > on command line - -(F) An error peculiar to VMS. Perl handles its own command line -redirection, and found a lone '>' at the end of the command line, so it -doesn't know where you wanted to redirect stdout. - -=item No output file after > or >> on command line - -(F) An error peculiar to VMS. Perl handles its own command line -redirection, and found a '>' or a '>>' on the command line, but can't -find the name of the file to which to write data destined for stdout. - -=item No package name allowed for variable %s in "our" - -(F) Fully qualified variable names are not allowed in "our" -declarations, because that doesn't make much sense under existing -semantics. Such syntax is reserved for future extensions. - -=item No Perl script found in input - -(F) You called C<perl -x>, but no line was found in the file beginning -with #! and containing the word "perl". - -=item No setregid available - -(F) Configure didn't find anything resembling the setregid() call for -your system. - -=item No setreuid available - -(F) Configure didn't find anything resembling the setreuid() call for -your system. - -=item No such class field "%s" in variable %s of type %s - -(F) You tried to access a key from a hash through the indicated typed -variable but that key is not allowed by the package of the same type. -The indicated package has restricted the set of allowed keys using the -L<fields> pragma. - -=item No such class %s - -(F) You provided a class qualifier in a "my", "our" or "state" -declaration, but this class doesn't exist at this point in your program. - -=item No such hook: %s - -(F) You specified a signal hook that was not recognized by Perl. -Currently, Perl accepts C<__DIE__> and C<__WARN__> as valid signal hooks. - -=item No such pipe open - -(P) An error peculiar to VMS. The internal routine my_pclose() tried to -close a pipe which hadn't been opened. This should have been caught -earlier as an attempt to close an unopened filehandle. - -=item No such signal: SIG%s - -(W signal) You specified a signal name as a subscript to %SIG that was -not recognized. Say C<kill -l> in your shell to see the valid signal -names on your system. - -=item Not a CODE reference - -(F) Perl was trying to evaluate a reference to a code value (that is, a -subroutine), but found a reference to something else instead. You can -use the ref() function to find out what kind of ref it really was. See -also L<perlref>. - -=item Not a format reference - -(F) I'm not sure how you managed to generate a reference to an anonymous -format, but this indicates you did, and that it didn't exist. - -=item Not a GLOB reference - -(F) Perl was trying to evaluate a reference to a "typeglob" (that is, a -symbol table entry that looks like C<*foo>), but found a reference to -something else instead. You can use the ref() function to find out what -kind of ref it really was. See L<perlref>. - -=item Not a HASH reference - -(F) Perl was trying to evaluate a reference to a hash value, but found a -reference to something else instead. You can use the ref() function to -find out what kind of ref it really was. See L<perlref>. - -=item Not an ARRAY reference - -(F) Perl was trying to evaluate a reference to an array value, but found -a reference to something else instead. You can use the ref() function -to find out what kind of ref it really was. See L<perlref>. - -=item Not an unblessed ARRAY reference - -(F) You passed a reference to a blessed array to C<push>, C<shift> or -another array function. These only accept unblessed array references -or arrays beginning explicitly with C<@>. - -=item Not a SCALAR reference - -(F) Perl was trying to evaluate a reference to a scalar value, but found -a reference to something else instead. You can use the ref() function -to find out what kind of ref it really was. See L<perlref>. - -=item Not a subroutine reference - -(F) Perl was trying to evaluate a reference to a code value (that is, a -subroutine), but found a reference to something else instead. You can -use the ref() function to find out what kind of ref it really was. See -also L<perlref>. - -=item Not a subroutine reference in overload table - -(F) An attempt was made to specify an entry in an overloading table that -doesn't somehow point to a valid subroutine. See L<overload>. - -=item Not enough arguments for %s - -(F) The function requires more arguments than you specified. - -=item Not enough format arguments - -(W syntax) A format specified more picture fields than the next line -supplied. See L<perlform>. - -=item %s: not found - -(A) You've accidentally run your script through the Bourne shell instead -of Perl. Check the #! line, or manually feed your script into Perl -yourself. - -=item no UTC offset information; assuming local time is UTC - -(S) A warning peculiar to VMS. Perl was unable to find the local -timezone offset, so it's assuming that local system time is equivalent -to UTC. If it's not, define the logical name -F<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which -need to be added to UTC to get local time. - -=item Non-octal character '%c'. Resolved as "%s" - -(W digit) In parsing an octal numeric constant, a character was -unexpectedly encountered that isn't octal. The resulting value -is as indicated. - -=item Non-string passed as bitmask - -(W misc) A number has been passed as a bitmask argument to select(). -Use the vec() function to construct the file descriptor bitmasks for -select. See L<perlfunc/select>. - -=item Null filename used - -(F) You can't require the null filename, especially because on many -machines that means the current directory! See L<perlfunc/require>. - -=item NULL OP IN RUN - -(S debugging) Some internal routine called run() with a null opcode -pointer. - -=item Null picture in formline - -(F) The first argument to formline must be a valid format picture -specification. It was found to be empty, which probably means you -supplied it an uninitialized value. See L<perlform>. - -=item Null realloc - -(P) An attempt was made to realloc NULL. - -=item NULL regexp argument - -(P) The internal pattern matching routines blew it big time. - -=item NULL regexp parameter - -(P) The internal pattern matching routines are out of their gourd. - -=item Number too long - -(F) Perl limits the representation of decimal numbers in programs to -about 250 characters. You've exceeded that length. Future -versions of Perl are likely to eliminate this arbitrary limitation. In -the meantime, try using scientific notation (e.g. "1e6" instead of -"1_000_000"). - -=item Number with no digits - -(F) Perl was looking for a number but found nothing that looked like -a number. This happens, for example with C<\o{}>, with no number between -the braces. - -=item Octal number > 037777777777 non-portable - -(W portable) The octal number you specified is larger than 2**32-1 -(4294967295) and therefore non-portable between systems. See -L<perlport> for more on portability concerns. - -=item Odd number of arguments for overload::constant - -(W overload) The call to overload::constant contained an odd number of -arguments. The arguments should come in pairs. - -=item Odd number of elements in anonymous hash - -(W misc) You specified an odd number of elements to initialize a hash, -which is odd, because hashes come in key/value pairs. - -=item Odd number of elements in hash assignment - -(W misc) You specified an odd number of elements to initialize a hash, -which is odd, because hashes come in key/value pairs. - -=item Offset outside string - -(F)(W layer) You tried to do a read/write/send/recv/seek operation -with an offset pointing outside the buffer. This is difficult to -imagine. The sole exceptions to this are that zero padding will -take place when going past the end of the string when either -C<sysread()>ing a file, or when seeking past the end of a scalar opened -for I/O (in anticipation of future reads and to imitate the behaviour -with real files). - -=item %s() on unopened %s - -(W unopened) An I/O operation was attempted on a filehandle that was -never initialized. You need to do an open(), a sysopen(), or a socket() -call, or call a constructor from the FileHandle package. - -=item -%s on unopened filehandle %s - -(W unopened) You tried to invoke a file test operator on a filehandle -that isn't open. Check your control flow. See also L<perlfunc/-X>. - -=item oops: oopsAV - -(S internal) An internal warning that the grammar is screwed up. - -=item oops: oopsHV - -(S internal) An internal warning that the grammar is screwed up. - -=item Opening dirhandle %s also as a file - -(W io, deprecated) You used open() to associate a filehandle to -a symbol (glob or scalar) that already holds a dirhandle. -Although legal, this idiom might render your code confusing -and is deprecated. - -=item Opening filehandle %s also as a directory - -(W io, deprecated) You used opendir() to associate a dirhandle to -a symbol (glob or scalar) that already holds a filehandle. -Although legal, this idiom might render your code confusing -and is deprecated. - -=item Operation "%s": no method found, %s - -(F) An attempt was made to perform an overloaded operation for which no -handler was defined. While some handlers can be autogenerated in terms -of other handlers, there is no default handler for any operation, unless -the C<fallback> overloading key is specified to be true. See L<overload>. - -=item Operation "%s" returns its argument for non-Unicode code point 0x%X - -(W utf8, non_unicode) You performed an operation requiring Unicode -semantics on a code point that is not in Unicode, so what it should do -is not defined. Perl has chosen to have it do nothing, and warn you. - -If the operation shown is "ToFold", it means that case-insensitive -matching in a regular expression was done on the code point. - -If you know what you are doing you can turn off this warning by -C<no warnings 'non_unicode';>. - -=item Operation "%s" returns its argument for UTF-16 surrogate U+%X - -(W utf8, surrogate) You performed an operation requiring Unicode -semantics on a Unicode surrogate. Unicode frowns upon the use of -surrogates for anything but storing strings in UTF-16, but semantics -are (reluctantly) defined for the surrogates, and they are to do -nothing for this operation. Because the use of surrogates can be -dangerous, Perl warns. - -If the operation shown is "ToFold", it means that case-insensitive -matching in a regular expression was done on the code point. - -If you know what you are doing you can turn off this warning by -C<no warnings 'surrogate';>. - -=item Operator or semicolon missing before %s - -(S ambiguous) You used a variable or subroutine call where the parser -was expecting an operator. The parser has assumed you really meant to -use an operator, but this is highly likely to be incorrect. For -example, if you say "*foo *foo" it will be interpreted as if you said -"*foo * 'foo'". - -=item "our" variable %s redeclared - -(W misc) You seem to have already declared the same global once before -in the current lexical scope. - -=item Out of memory! - -(X) The malloc() function returned 0, indicating there was insufficient -remaining memory (or virtual memory) to satisfy the request. Perl has -no option but to exit immediately. - -At least in Unix you may be able to get past this by increasing your -process datasize limits: in csh/tcsh use C<limit> and -C<limit datasize n> (where C<n> is the number of kilobytes) to check -the current limits and change them, and in ksh/bash/zsh use C<ulimit -a> -and C<ulimit -d n>, respectively. - -=item Out of memory during %s extend - -(X) An attempt was made to extend an array, a list, or a string beyond -the largest possible memory allocation. - -=item Out of memory during "large" request for %s - -(F) The malloc() function returned 0, indicating there was insufficient -remaining memory (or virtual memory) to satisfy the request. However, -the request was judged large enough (compile-time default is 64K), so a -possibility to shut down by trapping this error is granted. - -=item Out of memory during request for %s - -(X)(F) The malloc() function returned 0, indicating there was -insufficient remaining memory (or virtual memory) to satisfy the -request. - -The request was judged to be small, so the possibility to trap it -depends on the way perl was compiled. By default it is not trappable. -However, if compiled for this, Perl may use the contents of C<$^M> as an -emergency pool after die()ing with this message. In this case the error -is trappable I<once>, and the error message will include the line and file -where the failed request happened. - -=item Out of memory during ridiculously large request - -(F) You can't allocate more than 2^31+"small amount" bytes. This error -is most likely to be caused by a typo in the Perl program. e.g., -C<$arr[time]> instead of C<$arr[$time]>. - -=item Out of memory for yacc stack - -(F) The yacc parser wanted to grow its stack so it could continue -parsing, but realloc() wouldn't give it more memory, virtual or -otherwise. - -=item '.' outside of string in pack - -(F) The argument to a '.' in your template tried to move the working -position to before the start of the packed string being built. - -=item '@' outside of string in unpack - -(F) You had a template that specified an absolute position outside -the string being unpacked. See L<perlfunc/pack>. - -=item '@' outside of string with malformed UTF-8 in unpack - -(F) You had a template that specified an absolute position outside -the string being unpacked. The string being unpacked was also invalid -UTF-8. See L<perlfunc/pack>. - -=item overload arg '%s' is invalid - -(W overload) The L<overload> pragma was passed an argument it did not -recognize. Did you mistype an operator? - -=item Overloaded dereference did not return a reference - -(F) An object with an overloaded dereference operator was dereferenced, -but the overloaded operation did not return a reference. See -L<overload>. - -=item Overloaded qr did not return a REGEXP - -(F) An object with a C<qr> overload was used as part of a match, but the -overloaded operation didn't return a compiled regexp. See L<overload>. - -=item %s package attribute may clash with future reserved word: %s - -(W reserved) A lowercase attribute name was used that had a -package-specific handler. That name might have a meaning to Perl itself -some day, even though it doesn't yet. Perhaps you should use a -mixed-case attribute name, instead. See L<attributes>. - -=item pack/unpack repeat count overflow - -(F) You can't specify a repeat count so large that it overflows your -signed integers. See L<perlfunc/pack>. - -=item page overflow - -(W io) A single call to write() produced more lines than can fit on a -page. See L<perlform>. - -=item panic: %s - -(P) An internal error. - -=item panic: attempt to call %s in %s - -(P) One of the file test operators entered a code branch that calls -an ACL related-function, but that function is not available on this -platform. Earlier checks mean that it should not be possible to -enter this branch on this platform. - -=item panic: ck_grep, type=%u - -(P) Failed an internal consistency check trying to compile a grep. - -=item panic: ck_split, type=%u - -(P) Failed an internal consistency check trying to compile a split. - -=item panic: corrupt saved stack index %ld - -(P) The savestack was requested to restore more localized values than -there are in the savestack. - -=item panic: del_backref - -(P) Failed an internal consistency check while trying to reset a weak -reference. - -=item panic: die %s - -(P) We popped the context stack to an eval context, and then discovered -it wasn't an eval context. - -=item panic: do_subst - -(P) The internal pp_subst() routine was called with invalid operational -data. - -=item panic: do_trans_%s - -(P) The internal do_trans routines were called with invalid operational -data. - -=item panic: fold_constants JMPENV_PUSH returned %d - -(P) While attempting folding constants an exception other than an C<eval> -failure was caught. - -=item panic: frexp - -(P) The library function frexp() failed, making printf("%f") impossible. - -=item panic: goto, type=%u, ix=%ld - -(P) We popped the context stack to a context with the specified label, -and then discovered it wasn't a context we know how to do a goto in. - -=item panic: gp_free failed to free glob pointer - -(P) The internal routine used to clear a typeglob's entries tried -repeatedly, but each time something re-created entries in the glob. -Most likely the glob contains an object with a reference back to -the glob and a destructor that adds a new object to the glob. - -=item panic: INTERPCASEMOD, %s - -(P) The lexer got into a bad state at a case modifier. - -=item panic: INTERPCONCAT, %s - -(P) The lexer got into a bad state parsing a string with brackets. - -=item panic: kid popen errno read - -(F) forked child returned an incomprehensible message about its errno. - -=item panic: last, type=%u - -(P) We popped the context stack to a block context, and then discovered -it wasn't a block context. - -=item panic: leave_scope clearsv - -(P) A writable lexical variable became read-only somehow within the -scope. - -=item panic: leave_scope inconsistency %u - -(P) The savestack probably got out of sync. At least, there was an -invalid enum on the top of it. - -=item panic: magic_killbackrefs - -(P) Failed an internal consistency check while trying to reset all weak -references to an object. - -=item panic: malloc, %s - -(P) Something requested a negative number of bytes of malloc. - -=item panic: memory wrap - -(P) Something tried to allocate more memory than possible. - -=item panic: pad_alloc, %p!=%p - -(P) The compiler got confused about which scratch pad it was allocating -and freeing temporaries and lexicals from. - -=item panic: pad_free curpad, %p!=%p - -(P) The compiler got confused about which scratch pad it was allocating -and freeing temporaries and lexicals from. - -=item panic: pad_free po - -(P) An invalid scratch pad offset was detected internally. - -=item panic: pad_reset curpad, %p!=%p - -(P) The compiler got confused about which scratch pad it was allocating -and freeing temporaries and lexicals from. - -=item panic: pad_sv po - -(P) An invalid scratch pad offset was detected internally. - -=item panic: pad_swipe curpad, %p!=%p - -(P) The compiler got confused about which scratch pad it was allocating -and freeing temporaries and lexicals from. - -=item panic: pad_swipe po - -(P) An invalid scratch pad offset was detected internally. - -=item panic: pp_iter, type=%u - -(P) The foreach iterator got called in a non-loop context frame. - -=item panic: pp_match%s - -(P) The internal pp_match() routine was called with invalid operational -data. - -=item panic: pp_split, pm=%p, s=%p - -(P) Something terrible went wrong in setting up for the split. - -=item panic: realloc, %s - -(P) Something requested a negative number of bytes of realloc. - -=item panic: reference miscount on nsv in sv_replace() (%d != 1) - -(P) The internal sv_replace() function was handed a new SV with a -reference count other than 1. - -=item panic: restartop in %s - -(P) Some internal routine requested a goto (or something like it), and -didn't supply the destination. - -=item panic: return, type=%u - -(P) We popped the context stack to a subroutine or eval context, and -then discovered it wasn't a subroutine or eval context. - -=item panic: scan_num, %s - -(P) scan_num() got called on something that wasn't a number. - -=item panic: sv_chop %s - -(P) The sv_chop() routine was passed a position that is not within the -scalar's string buffer. - -=item panic: sv_insert, midend=%p, bigend=%p - -(P) The sv_insert() routine was told to remove more string than there -was string. - -=item panic: strxfrm() gets absurd - a => %u, ab => %u - -(P) The interpreter's sanity check of the C function strxfrm() failed. -In your current locale the returned transformation of the string "ab" is -shorter than that of the string "a", which makes no sense. - -=item panic: top_env - -(P) The compiler attempted to do a goto, or something weird like that. - -=item panic: unimplemented op %s (#%d) called - -(P) The compiler is screwed up and attempted to use an op that isn't -permitted at run time. - -=item panic: utf16_to_utf8: odd bytelen - -(P) Something tried to call utf16_to_utf8 with an odd (as opposed -to even) byte length. - -=item panic: utf16_to_utf8_reversed: odd bytelen - -(P) Something tried to call utf16_to_utf8_reversed with an odd (as opposed -to even) byte length. - -=item panic: yylex, %s - -(P) The lexer got into a bad state while processing a case modifier. - -=item Parsing code internal error (%s) - -(F) Parsing code supplied by an extension violated the parser's API in -a detectable way. - -=item Pattern subroutine nesting without pos change exceeded limit in regex; marked by <-- HERE in m/%s/ - -(F) You used a pattern that uses too many nested subpattern calls without -consuming any text. Restructure the pattern so text is consumed before -the nesting limit is exceeded. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Parentheses missing around "%s" list - -(W parenthesis) You said something like - - my $foo, $bar = @_; - -when you meant - - my ($foo, $bar) = @_; - -Remember that "my", "our", "local" and "state" bind tighter than comma. - -=item C<-p> destination: %s - -(F) An error occurred during the implicit output invoked by the C<-p> -command-line switch. (This output goes to STDOUT unless you've -redirected it with select().) - -=item (perhaps you forgot to load "%s"?) - -(F) This is an educated guess made in conjunction with the message -"Can't locate object method \"%s\" via package \"%s\"". It often means -that a method requires a package that has not been loaded. - -=item Perl folding rules are not up-to-date for 0x%x; please use the perlbug utility to report - -(W regex, deprecated) You used a regular expression with -case-insensitive matching, and there is a bug in Perl in which the -built-in regular expression folding rules are not accurate. This may -lead to incorrect results. Please report this as a bug using the -"perlbug" utility. (This message is marked deprecated, so that it by -default will be turned-on.) - -=item Perl_my_%s() not available - -(F) Your platform has very uncommon byte-order and integer size, -so it was not possible to set up some or all fixed-width byte-order -conversion functions. This is only a problem when you're using the -'<' or '>' modifiers in (un)pack templates. See L<perlfunc/pack>. - -=item Perl %s required (did you mean %s?)--this is only %s, stopped - -(F) The code you are trying to run has asked for a newer version of -Perl than you are running. Perhaps C<use 5.10> was written instead -of C<use 5.010> or C<use v5.10>. Without the leading C<v>, the number is -interpreted as a decimal, with every three digits after the -decimal point representing a part of the version number. So 5.10 -is equivalent to v5.100. - -=item Perl %s required--this is only version %s, stopped - -(F) The module in question uses features of a version of Perl more -recent than the currently running version. How long has it been since -you upgraded, anyway? See L<perlfunc/require>. - -=item PERL_SH_DIR too long - -(F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the -C<sh>-shell in. See "PERL_SH_DIR" in L<perlos2>. - -=item PERL_SIGNALS illegal: "%s" - -See L<perlrun/PERL_SIGNALS> for legal values. - -=item Perls since %s too modern--this is %s, stopped - -(F) The code you are trying to run claims it will not run -on the version of Perl you are using because it is too new. -Maybe the code needs to be updated, or maybe it is simply -wrong and the version check should just be removed. - -=item perl: warning: Setting locale failed. - -(S) The whole warning message will look something like: - - perl: warning: Setting locale failed. - perl: warning: Please check that your locale settings: - LC_ALL = "En_US", - LANG = (unset) - are supported and installed on your system. - perl: warning: Falling back to the standard locale ("C"). - -Exactly what were the failed locale settings varies. In the above the -settings were that the LC_ALL was "En_US" and the LANG had no value. -This error means that Perl detected that you and/or your operating -system supplier and/or system administrator have set up the so-called -locale system but Perl could not use those settings. This was not -dead serious, fortunately: there is a "default locale" called "C" that -Perl can and will use, and the script will be run. Before you really -fix the problem, however, you will get the same error message each -time you run Perl. How to really fix the problem can be found in -L<perllocale> section B<LOCALE PROBLEMS>. - -=item pid %x not a child - -(W exec) A warning peculiar to VMS. Waitpid() was asked to wait for a -process which isn't a subprocess of the current process. While this is -fine from VMS' perspective, it's probably not what you intended. - -=item 'P' must have an explicit size in unpack - -(F) The unpack format P must have an explicit size, not "*". - -=item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/ - -(F) The class in the character class [: :] syntax is unknown. The <-- HERE -shows in the regular expression about where the problem was discovered. -Note that the POSIX character classes do B<not> have the C<is> prefix -the corresponding C interfaces have: in other words, it's C<[[:print:]]>, -not C<isprint>. See L<perlre>. - -=item POSIX getpgrp can't take an argument - -(F) Your system has POSIX getpgrp(), which takes no argument, unlike -the BSD version, which takes a pid. - -=item POSIX syntax [%s] belongs inside character classes in regex; marked by <-- HERE in m/%s/ - -(W regexp) The character class constructs [: :], [= =], and [. .] go -I<inside> character classes, the [] are part of the construct, for example: -/[012[:alpha:]345]/. Note that [= =] and [. .] are not currently -implemented; they are simply placeholders for future extensions and will -cause fatal errors. The <-- HERE shows in the regular expression about -where the problem was discovered. See L<perlre>. - -=item POSIX syntax [. .] is reserved for future extensions in regex; marked by <-- HERE in m/%s/ - -(F regexp) Within regular expression character classes ([]) the syntax -beginning with "[." and ending with ".]" is reserved for future extensions. -If you need to represent those character sequences inside a regular -expression character class, just quote the square brackets with the -backslash: "\[." and ".\]". The <-- HERE shows in the regular expression -about where the problem was discovered. See L<perlre>. - -=item POSIX syntax [= =] is reserved for future extensions in regex; marked by <-- HERE in m/%s/ - -(F) Within regular expression character classes ([]) the syntax beginning -with "[=" and ending with "=]" is reserved for future extensions. If you -need to represent those character sequences inside a regular expression -character class, just quote the square brackets with the backslash: "\[=" -and "=\]". The <-- HERE shows in the regular expression about where the -problem was discovered. See L<perlre>. - -=item Possible attempt to put comments in qw() list - -(W qw) qw() lists contain items separated by whitespace; as with literal -strings, comment characters are not ignored, but are instead treated as -literal data. (You may have used different delimiters than the -parentheses shown here; braces are also frequently used.) - -You probably wrote something like this: - - @list = qw( - a # a comment - b # another comment - ); - -when you should have written this: - - @list = qw( - a - b - ); - -If you really want comments, build your list the -old-fashioned way, with quotes and commas: - - @list = ( - 'a', # a comment - 'b', # another comment - ); - -=item Possible attempt to separate words with commas - -(W qw) qw() lists contain items separated by whitespace; therefore -commas aren't needed to separate the items. (You may have used -different delimiters than the parentheses shown here; braces are also -frequently used.) - -You probably wrote something like this: - - qw! a, b, c !; - -which puts literal commas into some of the list items. Write it without -commas if you don't want them to appear in your data: - - qw! a b c !; - -=item Possible memory corruption: %s overflowed 3rd argument - -(F) An ioctl() or fcntl() returned more than Perl was bargaining for. -Perl guesses a reasonable buffer size, but puts a sentinel byte at the -end of the buffer just in case. This sentinel byte got clobbered, and -Perl assumes that memory is now corrupted. See L<perlfunc/ioctl>. - -=item Possible precedence problem on bitwise %c operator - -(W precedence) Your program uses a bitwise logical operator in conjunction -with a numeric comparison operator, like this : - - if ($x & $y == 0) { ... } - -This expression is actually equivalent to C<$x & ($y == 0)>, due to the -higher precedence of C<==>. This is probably not what you want. (If you -really meant to write this, disable the warning, or, better, put the -parentheses explicitly and write C<$x & ($y == 0)>). - -=item Possible unintended interpolation of $\ in regex - -(W ambiguous) You said something like C<m/$\/> in a regex. -The regex C<m/foo$\s+bar/m> translates to: match the word 'foo', the output -record separator (see L<perlvar/$\>) and the letter 's' (one time or more) -followed by the word 'bar'. - -If this is what you intended then you can silence the warning by using -C<m/${\}/> (for example: C<m/foo${\}s+bar/>). - -If instead you intended to match the word 'foo' at the end of the line -followed by whitespace and the word 'bar' on the next line then you can use -C<m/$(?)\/> (for example: C<m/foo$(?)\s+bar/>). - -=item Possible unintended interpolation of %s in string - -(W ambiguous) You said something like '@foo' in a double-quoted string -but there was no array C<@foo> in scope at the time. If you wanted a -literal @foo, then write it as \@foo; otherwise find out what happened -to the array you apparently lost track of. - -=item Precedence problem: open %s should be open(%s) - -(S precedence) The old irregular construct - - open FOO || die; - -is now misinterpreted as - - open(FOO || die); - -because of the strict regularization of Perl 5's grammar into unary and -list operators. (The old open was a little of both.) You must put -parentheses around the filehandle, or use the new "or" operator instead -of "||". - -=item Premature end of script headers - -See Server error. - -=item printf() on closed filehandle %s - -(W closed) The filehandle you're writing to got itself closed sometime -before now. Check your control flow. - -=item print() on closed filehandle %s - -(W closed) The filehandle you're printing on got itself closed sometime -before now. Check your control flow. - -=item Process terminated by SIG%s - -(W) This is a standard message issued by OS/2 applications, while *nix -applications die in silence. It is considered a feature of the OS/2 -port. One can easily disable this by appropriate sighandlers, see -L<perlipc/"Signals">. See also "Process terminated by SIGTERM/SIGINT" -in L<perlos2>. - -=item Prototype after '%c' for %s : %s - -(W illegalproto) A character follows % or @ in a prototype. This is -useless, since % and @ gobble the rest of the subroutine arguments. - -=item Prototype mismatch: %s vs %s - -(S prototype) The subroutine being declared or defined had previously been -declared or defined with a different function prototype. - -=item Prototype not terminated - -(F) You've omitted the closing parenthesis in a function prototype -definition. - -=item \p{} uses Unicode rules, not locale rules - -(W) You compiled a regular expression that contained a Unicode property -match (C<\p> or C<\P>), but the regular expression is also being told to -use the run-time locale, not Unicode. Instead, use a POSIX character -class, which should know about the locale's rules. -(See L<perlrecharclass/POSIX Character Classes>.) - -Even if the run-time locale is ISO 8859-1 (Latin1), which is a subset of -Unicode, some properties will give results that are not valid for that -subset. - -Here are a couple of examples to help you see what's going on. If the -locale is ISO 8859-7, the character at code point 0xD7 is the "GREEK -CAPITAL LETTER CHI". But in Unicode that code point means the -"MULTIPLICATION SIGN" instead, and C<\p> always uses the Unicode -meaning. That means that C<\p{Alpha}> won't match, but C<[[:alpha:]]> -should. Only in the Latin1 locale are all the characters in the same -positions as they are in Unicode. But, even here, some properties give -incorrect results. An example is C<\p{Changes_When_Uppercased}> which -is true for "LATIN SMALL LETTER Y WITH DIAERESIS", but since the upper -case of that character is not in Latin1, in that locale it doesn't -change when upper cased. - -=item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/ - -(F) You started a regular expression with a quantifier. Backslash it if -you meant it literally. The <-- HERE shows in the regular expression -about where the problem was discovered. See L<perlre>. - -=item Quantifier in {,} bigger than %d in regex; marked by <-- HERE in m/%s/ - -(F) There is currently a limit to the size of the min and max values of -the {min,max} construct. The <-- HERE shows in the regular expression -about where the problem was discovered. See L<perlre>. - -=item Quantifier unexpected on zero-length expression; marked by <-- HERE in m/%s/ - -(W regexp) You applied a regular expression quantifier in a place where -it makes no sense, such as on a zero-width assertion. Try putting the -quantifier inside the assertion instead. For example, the way to match -"abc" provided that it is followed by three repetitions of "xyz" is -C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Range iterator outside integer range - -(F) One (or both) of the numeric arguments to the range operator ".." -are outside the range which can be represented by integers internally. -One possible workaround is to force Perl to use magical string increment -by prepending "0" to your numbers. - -=item readdir() attempted on invalid dirhandle %s - -(W io) The dirhandle you're reading from is either closed or not really -a dirhandle. Check your control flow. - -=item readline() on closed filehandle %s - -(W closed) The filehandle you're reading from got itself closed sometime -before now. Check your control flow. - -=item read() on closed filehandle %s - -(W closed) You tried to read from a closed filehandle. - -=item read() on unopened filehandle %s - -(W unopened) You tried to read from a filehandle that was never opened. - -=item Reallocation too large: %x - -(F) You can't allocate more than 64K on an MS-DOS machine. - -=item realloc() of freed memory ignored - -(S malloc) An internal routine called realloc() on something that had -already been freed. - -=item Recompile perl with B<-D>DEBUGGING to use B<-D> switch - -(F debugging) You can't use the B<-D> option unless the code to produce -the desired output is compiled into Perl, which entails some overhead, -which is why it's currently left out of your copy. - -=item Recursive call to Perl_load_module in PerlIO_find_layer - -(P) It is currently not permitted to load modules when creating -a filehandle inside an %INC hook. This can happen with C<open my -$fh, '<', \$scalar>, which implicitly loads PerlIO::scalar. Try -loading PerlIO::scalar explicitly first. - -=item Recursive inheritance detected in package '%s' - -(F) While calculating the method resolution order (MRO) of a package, Perl -believes it found an infinite loop in the C<@ISA> hierarchy. This is a -crude check that bails out after 100 levels of C<@ISA> depth. - -=item refcnt_dec: fd %d%s - -=item refcnt: fd %d%s - -=item refcnt_inc: fd %d%s - -(P) Perl's I/O implementation failed an internal consistency check. If -you see this message, something is very wrong. - -=item Reference found where even-sized list expected - -(W misc) You gave a single reference where Perl was expecting a list -with an even number of elements (for assignment to a hash). This -usually means that you used the anon hash constructor when you meant -to use parens. In any case, a hash requires key/value B<pairs>. - - %hash = { one => 1, two => 2, }; # WRONG - %hash = [ qw/ an anon array / ]; # WRONG - %hash = ( one => 1, two => 2, ); # right - %hash = qw( one 1 two 2 ); # also fine - -=item Reference is already weak - -(W misc) You have attempted to weaken a reference that is already weak. -Doing so has no effect. - -=item Reference to invalid group 0 - -(F) You used C<\g0> or similar in a regular expression. You may refer -to capturing parentheses only with strictly positive integers -(normal backreferences) or with strictly negative integers (relative -backreferences). Using 0 does not make sense. - -=item Reference to nonexistent group in regex; marked by <-- HERE in m/%s/ - -(F) You used something like C<\7> in your regular expression, but there are -not at least seven sets of capturing parentheses in the expression. If -you wanted to have the character with ordinal 7 inserted into the regular -expression, prepend zeroes to make it three digits long: C<\007> - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Reference to nonexistent named group in regex; marked by <-- HERE in m/%s/ - -(F) You used something like C<\k'NAME'> or C<< \k<NAME> >> in your regular -expression, but there is no corresponding named capturing parentheses -such as C<(?'NAME'...)> or C<< (?<NAME>...) >>. Check if the name has been -spelled correctly both in the backreference and the declaration. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item Reference to nonexistent or unclosed group in regex; marked by <-- HERE in m/%s/ - -(F) You used something like C<\g{-7}> in your regular expression, but there -are not at least seven sets of closed capturing parentheses in the -expression before where the C<\g{-7}> was located. - -The <-- HERE shows in the regular expression about where the problem was -discovered. - -=item regexp memory corruption - -(P) The regular expression engine got confused by what the regular -expression compiler gave it. - -=item Regexp modifier "/%c" may appear a maximum of twice - -=item Regexp modifier "/%c" may not appear twice - -(F syntax, regexp) The regular expression pattern had too many occurrences -of the specified modifier. Remove the extraneous ones. - -=item Regexp modifier "%c" may not appear after the "-" - -(F regexp) Turning off the given modifier has the side effect of turning -on another one. Perl currently doesn't allow this. Reword the regular -expression to use the modifier you want to turn on (and place it before -the minus), instead of the one you want to turn off. - -=item Regexp modifiers "/%c" and "/%c" are mutually exclusive - -(F syntax, regexp) The regular expression pattern had more than one of these -mutually exclusive modifiers. Retain only the modifier that is -supposed to be there. - -=item Regexp out of space - -(P) A "can't happen" error, because safemalloc() should have caught it -earlier. - -=item Repeated format line will never terminate (~~ and @# incompatible) - -(F) Your format contains the ~~ repeat-until-blank sequence and a -numeric field that will never go blank so that the repetition never -terminates. You might use ^# instead. See L<perlform>. - -=item Replacement list is longer than search list - -(W misc) You have used a replacement list that is longer than the -search list. So the additional elements in the replacement list -are meaningless. - -=item Reversed %s= operator - -(W syntax) You wrote your assignment operator backwards. The = must -always come last, to avoid ambiguity with subsequent unary operators. - -=item rewinddir() attempted on invalid dirhandle %s - -(W io) The dirhandle you tried to do a rewinddir() on is either closed or not -really a dirhandle. Check your control flow. - -=item Scalars leaked: %d - -(P) Something went wrong in Perl's internal bookkeeping of scalars: -not all scalar variables were deallocated by the time Perl exited. -What this usually indicates is a memory leak, which is of course bad, -especially if the Perl program is intended to be long-running. - -=item Scalar value @%s[%s] better written as $%s[%s] - -(W syntax) You've used an array slice (indicated by @) to select a -single element of an array. Generally it's better to ask for a scalar -value (indicated by $). The difference is that C<$foo[&bar]> always -behaves like a scalar, both when assigning to it and when evaluating its -argument, while C<@foo[&bar]> behaves like a list when you assign to it, -and provides a list context to its subscript, which can do weird things -if you're expecting only one subscript. - -On the other hand, if you were actually hoping to treat the array -element as a list, you need to look into how references work, because -Perl will not magically convert between scalars and lists for you. See -L<perlref>. - -=item Scalar value @%s{%s} better written as $%s{%s} - -(W syntax) You've used a hash slice (indicated by @) to select a single -element of a hash. Generally it's better to ask for a scalar value -(indicated by $). The difference is that C<$foo{&bar}> always behaves -like a scalar, both when assigning to it and when evaluating its -argument, while C<@foo{&bar}> behaves like a list when you assign to it, -and provides a list context to its subscript, which can do weird things -if you're expecting only one subscript. - -On the other hand, if you were actually hoping to treat the hash element -as a list, you need to look into how references work, because Perl will -not magically convert between scalars and lists for you. See -L<perlref>. - -=item Search pattern not terminated - -(F) The lexer couldn't find the final delimiter of a // or m{} -construct. Remember that bracketing delimiters count nesting level. -Missing the leading C<$> from a variable C<$m> may cause this error. - -Note that since Perl 5.9.0 a // can also be the I<defined-or> -construct, not just the empty search pattern. Therefore code written -in Perl 5.9.0 or later that uses the // as the I<defined-or> can be -misparsed by pre-5.9.0 Perls as a non-terminated search pattern. - -=item Search pattern not terminated or ternary operator parsed as search pattern - -(F) The lexer couldn't find the final delimiter of a C<?PATTERN?> -construct. - -The question mark is also used as part of the ternary operator (as in -C<foo ? 0 : 1>) leading to some ambiguous constructions being wrongly -parsed. One way to disambiguate the parsing is to put parentheses around -the conditional expression, i.e. C<(foo) ? 0 : 1>. - -=item seekdir() attempted on invalid dirhandle %s - -(W io) The dirhandle you are doing a seekdir() on is either closed or not -really a dirhandle. Check your control flow. - -=item %sseek() on unopened filehandle - -(W unopened) You tried to use the seek() or sysseek() function on a -filehandle that was either never opened or has since been closed. - -=item select not implemented - -(F) This machine doesn't implement the select() system call. - -=item Self-ties of arrays and hashes are not supported - -(F) Self-ties are of arrays and hashes are not supported in -the current implementation. - -=item Semicolon seems to be missing - -(W semicolon) A nearby syntax error was probably caused by a missing -semicolon, or possibly some other missing operator, such as a comma. - -=item semi-panic: attempt to dup freed string - -(S internal) The internal newSVsv() routine was called to duplicate a -scalar that had previously been marked as free. - -=item sem%s not implemented - -(F) You don't have System V semaphore IPC on your system. - -=item send() on closed socket %s - -(W closed) The socket you're sending to got itself closed sometime -before now. Check your control flow. - -=item Sequence (? incomplete in regex; marked by <-- HERE in m/%s/ - -(F) A regular expression ended with an incomplete extension (?. The -<-- HERE shows in the regular expression about where the problem was -discovered. See L<perlre>. - -=item Sequence (?%s...) not implemented in regex; marked by <-- HERE in m/%s/ - -(F) A proposed regular expression extension has the character reserved -but has not yet been written. The <-- HERE shows in the regular -expression about where the problem was discovered. See L<perlre>. - -=item Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ - -(F) You used a regular expression extension that doesn't make sense. The -<-- HERE shows in the regular expression about where the problem was -discovered. This happens when using the C<(?^...)> construct to tell -Perl to use the default regular expression modifiers, and you -redundantly specify a default modifier. For other -causes, see L<perlre>. - -=item Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/ - -(F) The regular expression expects a mandatory argument following the escape -sequence and this has been omitted or incorrectly written. - -=item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/ - -(F) A regular expression comment must be terminated by a closing -parenthesis. Embedded parentheses aren't allowed. The <-- HERE shows in -the regular expression about where the problem was discovered. See -L<perlre>. - -=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/ - -(F) If the contents of a (?{...}) clause contain braces, they -must balance for Perl to detect the end of the clause properly. -The <-- HERE shows in the regular expression about where the -problem was discovered. See L<perlre>. - -=item Z<>500 Server error - -See Server error. - -=item Server error - -(A) This is the error message generally seen in a browser window -when trying to run a CGI program (including SSI) over the web. The -actual error text varies widely from server to server. The most -frequently-seen variants are "500 Server error", "Method (something) -not permitted", "Document contains no data", "Premature end of script -headers", and "Did not produce a valid header". - -B<This is a CGI error, not a Perl error>. - -You need to make sure your script is executable, is accessible by -the user CGI is running the script under (which is probably not the -user account you tested it under), does not rely on any environment -variables (like PATH) from the user it isn't running under, and isn't -in a location where the CGI server can't find it, basically, more or -less. Please see the following for more information: - - http://www.perl.org/CGI_MetaFAQ.html - http://www.htmlhelp.org/faq/cgifaq.html - http://www.w3.org/Security/Faq/ - -You should also look at L<perlfaq9>. - -=item setegid() not implemented - -(F) You tried to assign to C<$)>, and your operating system doesn't -support the setegid() system call (or equivalent), or at least Configure -didn't think so. - -=item seteuid() not implemented - -(F) You tried to assign to C<< $> >>, and your operating system doesn't -support the seteuid() system call (or equivalent), or at least Configure -didn't think so. - -=item setpgrp can't take arguments - -(F) Your system has the setpgrp() from BSD 4.2, which takes no -arguments, unlike POSIX setpgid(), which takes a process ID and process -group ID. - -=item setrgid() not implemented - -(F) You tried to assign to C<$(>, and your operating system doesn't -support the setrgid() system call (or equivalent), or at least Configure -didn't think so. - -=item setruid() not implemented - -(F) You tried to assign to C<$<>, and your operating system doesn't -support the setruid() system call (or equivalent), or at least Configure -didn't think so. - -=item setsockopt() on closed socket %s - -(W closed) You tried to set a socket option on a closed socket. Did you -forget to check the return value of your socket() call? See -L<perlfunc/setsockopt>. - -=item shm%s not implemented - -(F) You don't have System V shared memory IPC on your system. - -=item !=~ should be !~ - -(W syntax) The non-matching operator is !~, not !=~. !=~ will be -interpreted as the != (numeric not equal) and ~ (1's complement) -operators: probably not what you intended. - -=item <> should be quotes - -(F) You wrote C<< require <file> >> when you should have written -C<require 'file'>. - -=item /%s/ should probably be written as "%s" - -(W syntax) You have used a pattern where Perl expected to find a string, -as in the first argument to C<join>. Perl will treat the true or false -result of matching the pattern against $_ as the string, which is -probably not what you had in mind. - -=item shutdown() on closed socket %s - -(W closed) You tried to do a shutdown on a closed socket. Seems a bit -superfluous. - -=item SIG%s handler "%s" not defined - -(W signal) The signal handler named in %SIG doesn't, in fact, exist. -Perhaps you put it into the wrong package? - -=item Smart matching a non-overloaded object breaks encapsulation - -(F) You should not use the C<~~> operator on an object that does not -overload it: Perl refuses to use the object's underlying structure for -the smart match. - -=item sort is now a reserved word - -(F) An ancient error message that almost nobody ever runs into anymore. -But before sort was a keyword, people sometimes used it as a filehandle. - -=item Sort subroutine didn't return single value - -(F) A sort comparison subroutine may not return a list value with more -or less than one element. See L<perlfunc/sort>. - -=item Source filters apply only to byte streams - -(F) You tried to activate a source filter (usually by loading a -source filter module) within a string passed to C<eval>. This is -not permitted under the C<unicode_eval> feature. Consider using -C<evalbytes> instead. See L<feature>. - -=item splice() offset past end of array - -(W misc) You attempted to specify an offset that was past the end of -the array passed to splice(). Splicing will instead commence at the -end of the array, rather than past it. If this isn't what you want, -try explicitly pre-extending the array by assigning $#array = $offset. -See L<perlfunc/splice>. - -=item Split loop - -(P) The split was looping infinitely. (Obviously, a split shouldn't -iterate more times than there are characters of input, which is what -happened.) See L<perlfunc/split>. - -=item Statement unlikely to be reached - -(W exec) You did an exec() with some statement after it other than a -die(). This is almost always an error, because exec() never returns -unless there was a failure. You probably wanted to use system() -instead, which does return. To suppress this warning, put the exec() in -a block by itself. - -=item "state" variable %s can't be in a package - -(F) Lexically scoped variables aren't in a package, so it doesn't make -sense to try to declare one with a package qualifier on the front. Use -local() if you want to localize a package variable. - -=item stat() on unopened filehandle %s - -(W unopened) You tried to use the stat() function on a filehandle that -was either never opened or has since been closed. - -=item Stub found while resolving method "%s" overloading "%s" in package "%s" - -(P) Overloading resolution over @ISA tree may be broken by importation -stubs. Stubs should never be implicitly created, but explicit calls to -C<can> may break this. - -=item Subroutine %s redefined - -(W redefine) You redefined a subroutine. To suppress this warning, say - - { - no warnings 'redefine'; - eval "sub name { ... }"; - } - -=item Substitution loop - -(P) The substitution was looping infinitely. (Obviously, a substitution -shouldn't iterate more times than there are characters of input, which -is what happened.) See the discussion of substitution in -L<perlop/"Regexp Quote-Like Operators">. - -=item Substitution pattern not terminated - -(F) The lexer couldn't find the interior delimiter of an s/// or s{}{} -construct. Remember that bracketing delimiters count nesting level. -Missing the leading C<$> from variable C<$s> may cause this error. - -=item Substitution replacement not terminated - -(F) The lexer couldn't find the final delimiter of an s/// or s{}{} -construct. Remember that bracketing delimiters count nesting level. -Missing the leading C<$> from variable C<$s> may cause this error. - -=item substr outside of string - -(W substr)(F) You tried to reference a substr() that pointed outside of -a string. That is, the absolute value of the offset was larger than the -length of the string. See L<perlfunc/substr>. This warning is fatal if -substr is used in an lvalue context (as the left hand side of an -assignment or as a subroutine argument for example). - -=item sv_upgrade from type %d down to type %d - -(P) Perl tried to force the upgrade of an SV to a type which was actually -inferior to its current type. - -=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/ - -(F) A (?(condition)if-clause|else-clause) construct can have at most -two branches (the if-clause and the else-clause). If you want one or -both to contain alternation, such as using C<this|that|other>, enclose -it in clustering parentheses: - - (?(condition)(?:this|that|other)|else-clause) - -The <-- HERE shows in the regular expression about where the problem -was discovered. See L<perlre>. - -=item Switch condition not recognized in regex; marked by <-- HERE in m/%s/ - -(F) If the argument to the (?(...)if-clause|else-clause) construct is -a number, it can be only a number. The <-- HERE shows in the regular -expression about where the problem was discovered. See L<perlre>. - -=item switching effective %s is not implemented - -(F) While under the C<use filetest> pragma, we cannot switch the real -and effective uids or gids. - -=item %s syntax OK - -(F) The final summary message when a C<perl -c> succeeds. - -=item syntax error - -(F) Probably means you had a syntax error. Common reasons include: - - A keyword is misspelled. - A semicolon is missing. - A comma is missing. - An opening or closing parenthesis is missing. - An opening or closing brace is missing. - A closing quote is missing. - -Often there will be another error message associated with the syntax -error giving more information. (Sometimes it helps to turn on B<-w>.) -The error message itself often tells you where it was in the line when -it decided to give up. Sometimes the actual error is several tokens -before this, because Perl is good at understanding random input. -Occasionally the line number may be misleading, and once in a blue moon -the only way to figure out what's triggering the error is to call -C<perl -c> repeatedly, chopping away half the program each time to see -if the error went away. Sort of the cybernetic version of S<20 questions>. - -=item syntax error at line %d: '%s' unexpected - -(A) You've accidentally run your script through the Bourne shell instead -of Perl. Check the #! line, or manually feed your script into Perl -yourself. - -=item syntax error in file %s at line %d, next 2 tokens "%s" - -(F) This error is likely to occur if you run a perl5 script through -a perl4 interpreter, especially if the next 2 tokens are "use strict" -or "my $var" or "our $var". - -=item sysread() on closed filehandle %s - -(W closed) You tried to read from a closed filehandle. - -=item sysread() on unopened filehandle %s - -(W unopened) You tried to read from a filehandle that was never opened. - -=item System V %s is not implemented on this machine - -(F) You tried to do something with a function beginning with "sem", -"shm", or "msg" but that System V IPC is not implemented in your -machine. In some machines the functionality can exist but be -unconfigured. Consult your system support. - -=item syswrite() on closed filehandle %s - -(W closed) The filehandle you're writing to got itself closed sometime -before now. Check your control flow. - -=item C<-T> and C<-B> not implemented on filehandles - -(F) Perl can't peek at the stdio buffer of filehandles when it doesn't -know about your kind of stdio. You'll have to use a filename instead. - -=item Target of goto is too deeply nested - -(F) You tried to use C<goto> to reach a label that was too deeply nested -for Perl to reach. Perl is doing you a favor by refusing. - -=item telldir() attempted on invalid dirhandle %s - -(W io) The dirhandle you tried to telldir() is either closed or not really -a dirhandle. Check your control flow. - -=item tell() on unopened filehandle - -(W unopened) You tried to use the tell() function on a filehandle that -was either never opened or has since been closed. - -=item That use of $[ is unsupported - -(F) Assignment to C<$[> is now strictly circumscribed, and interpreted -as a compiler directive. You may say only one of - - $[ = 0; - $[ = 1; - ... - local $[ = 0; - local $[ = 1; - ... - -This is to prevent the problem of one module changing the array base out -from under another module inadvertently. See L<perlvar/$[> and L<arybase>. - -=item The crypt() function is unimplemented due to excessive paranoia - -(F) Configure couldn't find the crypt() function on your machine, -probably because your vendor didn't supply it, probably because they -think the U.S. Government thinks it's a secret, or at least that they -will continue to pretend that it is. And if you quote me on that, I -will deny it. - -=item The %s function is unimplemented - -(F) The function indicated isn't implemented on this architecture, according -to the probings of Configure. - -=item The stat preceding %s wasn't an lstat - -(F) It makes no sense to test the current stat buffer for symbolic -linkhood if the last stat that wrote to the stat buffer already went -past the symlink to get to the real file. Use an actual filename -instead. - -=item The 'unique' attribute may only be applied to 'our' variables - -(F) This attribute was never supported on C<my> or C<sub> declarations. - -=item This Perl can't reset CRTL environ elements (%s) - -=item This Perl can't set CRTL environ elements (%s=%s) - -(W internal) Warnings peculiar to VMS. You tried to change or delete an -element of the CRTL's internal environ array, but your copy of Perl -wasn't built with a CRTL that contained the setenv() function. You'll -need to rebuild Perl with a CRTL that does, or redefine -F<PERL_ENV_TABLES> (see L<perlvms>) so that the environ array isn't the -target of the change to -%ENV which produced the warning. - -=item thread failed to start: %s - -(W threads)(S) The entry point function of threads->create() failed for some reason. - -=item times not implemented - -(F) Your version of the C library apparently doesn't do times(). I -suspect you're not running on Unix. - -=item "-T" is on the #! line, it must also be used on the command line - -(X) The #! line (or local equivalent) in a Perl script contains -the B<-T> option (or the B<-t> option), but Perl was not invoked with -B<-T> in its command line. This is an error because, by the time -Perl discovers a B<-T> in a script, it's too late to properly taint -everything from the environment. So Perl gives up. - -If the Perl script is being executed as a command using the #! -mechanism (or its local equivalent), this error can usually be -fixed by editing the #! line so that the B<-%c> option is a part of -Perl's first argument: e.g. change C<perl -n -%c> to C<perl -%c -n>. - -If the Perl script is being executed as C<perl scriptname>, then the -B<-%c> option must appear on the command line: C<perl -%c scriptname>. - -=item To%s: illegal mapping '%s' - -(F) You tried to define a customized To-mapping for lc(), lcfirst, -uc(), or ucfirst() (or their string-inlined versions), but you -specified an illegal mapping. -See L<perlunicode/"User-Defined Character Properties">. - -=item Too deeply nested ()-groups - -(F) Your template contains ()-groups with a ridiculously deep nesting level. - -=item Too few args to syscall - -(F) There has to be at least one argument to syscall() to specify the -system call to call, silly dilly. - -=item Too late for "-%s" option - -(X) The #! line (or local equivalent) in a Perl script contains the -B<-M>, B<-m> or B<-C> option. - -In the case of B<-M> and B<-m>, this is an error because those options -are not intended for use inside scripts. Use the C<use> pragma instead. - -The B<-C> option only works if it is specified on the command line as -well (with the same sequence of letters or numbers following). Either -specify this option on the command line, or, if your system supports -it, make your script executable and run it directly instead of passing -it to perl. - -=item Too late to run %s block - -(W void) A CHECK or INIT block is being defined during run time proper, -when the opportunity to run them has already passed. Perhaps you are -loading a file with C<require> or C<do> when you should be using C<use> -instead. Or perhaps you should put the C<require> or C<do> inside a -BEGIN block. - -=item Too many args to syscall - -(F) Perl supports a maximum of only 14 args to syscall(). - -=item Too many arguments for %s - -(F) The function requires fewer arguments than you specified. - -=item Too many )'s - -(A) You've accidentally run your script through B<csh> instead of Perl. -Check the #! line, or manually feed your script into Perl yourself. - -=item Too many ('s - -(A) You've accidentally run your script through B<csh> instead of Perl. -Check the #! line, or manually feed your script into Perl yourself. - -=item Trailing \ in regex m/%s/ - -(F) The regular expression ends with an unbackslashed backslash. -Backslash it. See L<perlre>. - -=item Transliteration pattern not terminated - -(F) The lexer couldn't find the interior delimiter of a tr/// or tr[][] -or y/// or y[][] construct. Missing the leading C<$> from variables -C<$tr> or C<$y> may cause this error. - -=item Transliteration replacement not terminated - -(F) The lexer couldn't find the final delimiter of a tr///, tr[][], -y/// or y[][] construct. - -=item '%s' trapped by operation mask - -(F) You tried to use an operator from a Safe compartment in which it's -disallowed. See L<Safe>. - -=item truncate not implemented - -(F) Your machine doesn't implement a file truncation mechanism that -Configure knows about. - -=item Type of arg %d to &CORE::%s must be %s - -(F) The subroutine in question in the CORE package requires its argument -to be a hard reference to data of the specified type. Overloading is -ignored, so a reference to an object that is not the specified type, but -nonetheless has overloading to handle it, will still not be accepted. - -=item Type of arg %d to %s must be %s (not %s) - -(F) This function requires the argument in that position to be of a -certain type. Arrays must be @NAME or C<@{EXPR}>. Hashes must be -%NAME or C<%{EXPR}>. No implicit dereferencing is allowed--use the -{EXPR} forms as an explicit dereference. See L<perlref>. - -=item Type of argument to %s must be unblessed hashref or arrayref - -(F) You called C<keys>, C<values> or C<each> with a scalar argument that -was not a reference to an unblessed hash or array. - -=item umask not implemented - -(F) Your machine doesn't implement the umask function and you tried to -use it to restrict permissions for yourself (EXPR & 0700). - -=item Unable to create sub named "%s" - -(F) You attempted to create or access a subroutine with an illegal name. - -=item Unbalanced context: %d more PUSHes than POPs - -(W internal) The exit code detected an internal inconsistency in how -many execution contexts were entered and left. - -=item Unbalanced saves: %d more saves than restores - -(W internal) The exit code detected an internal inconsistency in how -many values were temporarily localized. - -=item Unbalanced scopes: %d more ENTERs than LEAVEs - -(W internal) The exit code detected an internal inconsistency in how -many blocks were entered and left. - -=item Unbalanced string table refcount: (%d) for "%s" - -(W internal) On exit, Perl found some strings remaining in the shared -string table used for copy on write and for hash keys. The entries -should have been freed, so this indicates a bug somewhere. - -=item Unbalanced tmps: %d more allocs than frees - -(W internal) The exit code detected an internal inconsistency in how -many mortal scalars were allocated and freed. - -=item Undefined format "%s" called - -(F) The format indicated doesn't seem to exist. Perhaps it's really in -another package? See L<perlform>. - -=item Undefined sort subroutine "%s" called - -(F) The sort comparison routine specified doesn't seem to exist. -Perhaps it's in a different package? See L<perlfunc/sort>. - -=item Undefined subroutine &%s called - -(F) The subroutine indicated hasn't been defined, or if it was, it has -since been undefined. - -=item Undefined subroutine called - -(F) The anonymous subroutine you're trying to call hasn't been defined, -or if it was, it has since been undefined. - -=item Undefined subroutine in sort - -(F) The sort comparison routine specified is declared but doesn't seem -to have been defined yet. See L<perlfunc/sort>. - -=item Undefined top format "%s" called - -(F) The format indicated doesn't seem to exist. Perhaps it's really in -another package? See L<perlform>. - -=item Undefined value assigned to typeglob - -(W misc) An undefined value was assigned to a typeglob, a la -C<*foo = undef>. This does nothing. It's possible that you really mean -C<undef *foo>. - -=item %s: Undefined variable - -(A) You've accidentally run your script through B<csh> instead of Perl. -Check the #! line, or manually feed your script into Perl yourself. - -=item unexec of %s into %s failed! - -(F) The unexec() routine failed for some reason. See your local FSF -representative, who probably put it there in the first place. - -=item Unexpected constant lvalue entersub entry via type/targ %d:%d - -(P) When compiling a subroutine call in lvalue context, Perl failed an -internal consistency check. It encountered a malformed op tree. - -=item Unicode non-character U+%X is illegal for open interchange - -(W utf8, nonchar) Certain codepoints, such as U+FFFE and U+FFFF, are -defined by the Unicode standard to be non-characters. Those are -legal codepoints, but are reserved for internal use; so, applications -shouldn't attempt to exchange them. If you know what you are doing -you can turn off this warning by C<no warnings 'nonchar';>. - -=item Unicode surrogate U+%X is illegal in UTF-8 - -(W utf8, surrogate) You had a UTF-16 surrogate in a context where they are -not considered acceptable. These code points, between U+D800 and -U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl -internally allows all unsigned integer code points (up to the size limit -available on your platform), including surrogates. But these can cause -problems when being input or output, which is likely where this message -came from. If you really really know what you are doing you can turn -off this warning by C<no warnings 'surrogate';>. - -=item Unknown BYTEORDER - -(F) There are no byte-swapping functions for a machine with this byte -order. - -=item Unknown error - -(P) Perl was about to print an error message in C<$@>, but the C<$@> variable -did not exist, even after an attempt to create it. - -=item Unknown open() mode '%s' - -(F) The second argument of 3-argument open() is not among the list -of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, -C<< +> >>, C<<< +>> >>>, C<-|>, C<|->, C<< <& >>, C<< >& >>. - -=item Unknown PerlIO layer "%s" - -(W layer) An attempt was made to push an unknown layer onto the Perl I/O -system. (Layers take care of transforming data between external and -internal representations.) Note that some layers, such as C<mmap>, -are not supported in all environments. If your program didn't -explicitly request the failing operation, it may be the result of the -value of the environment variable PERLIO. - -=item Unknown process %x sent message to prime_env_iter: %s - -(P) An error peculiar to VMS. Perl was reading values for %ENV before -iterating over it, and someone else stuck a message in the stream of -data Perl expected. Someone's very confused, or perhaps trying to -subvert Perl's population of %ENV for nefarious purposes. - -=item Unknown "re" subpragma '%s' (known ones are: %s) - -(W) You tried to use an unknown subpragma of the "re" pragma. - -=item Unknown switch condition (?(%s in regex; marked by <-- HERE in m/%s/ - -(F) The condition part of a (?(condition)if-clause|else-clause) construct -is not known. The condition must be one of the following: - - (1) (2) ... true if 1st, 2nd, etc., capture matched - (<NAME>) ('NAME') true if named capture matched - (?=...) (?<=...) true if subpattern matches - (?!...) (?<!...) true if subpattern fails to match - (?{ CODE }) true if code returns a true value - (R) true if evaluating inside recursion - (R1) (R2) ... true if directly inside capture group 1, 2, etc. - (R&NAME) true if directly inside named capture - (DEFINE) always false; for defining named subpatterns - -The <-- HERE shows in the regular expression about where the problem was -discovered. See L<perlre>. - -=item Unknown Unicode option letter '%c' - -(F) You specified an unknown Unicode option. See L<perlrun> documentation -of the C<-C> switch for the list of known options. - -=item Unknown Unicode option value %x - -(F) You specified an unknown Unicode option. See L<perlrun> documentation -of the C<-C> switch for the list of known options. - -=item Unknown verb pattern '%s' in regex; marked by <-- HERE in m/%s/ - -(F) You either made a typo or have incorrectly put a C<*> quantifier -after an open brace in your pattern. Check the pattern and review -L<perlre> for details on legal verb patterns. - -=item Unknown warnings category '%s' - -(F) An error issued by the C<warnings> pragma. You specified a warnings -category that is unknown to perl at this point. - -Note that if you want to enable a warnings category registered by a -module (e.g. C<use warnings 'File::Find'>), you must have loaded this -module first. - -=item unmatched [ in regex; marked by <-- HERE in m/%s/ - -(F) The brackets around a character class must match. If you wish to -include a closing bracket in a character class, backslash it or put it -first. The <-- HERE shows in the regular expression about where the -problem was discovered. See L<perlre>. - -=item unmatched ( in regex; marked by <-- HERE in m/%s/ - -(F) Unbackslashed parentheses must always be balanced in regular -expressions. If you're a vi user, the % key is valuable for finding -the matching parenthesis. The <-- HERE shows in the regular expression -about where the problem was discovered. See L<perlre>. - -=item Unmatched right %s bracket - -(F) The lexer counted more closing curly or square brackets than opening -ones, so you're probably missing a matching opening bracket. As a -general rule, you'll find the missing one (so to speak) near the place -you were last editing. - -=item Unquoted string "%s" may clash with future reserved word - -(W reserved) You used a bareword that might someday be claimed as a -reserved word. It's best to put such a word in quotes, or capitalize it -somehow, or insert an underbar into it. You might also declare it as a -subroutine. - -=item Unrecognized character %s; marked by <-- HERE after %s near column %d - -(F) The Perl parser has no idea what to do with the specified character -in your Perl script (or eval) near the specified column. Perhaps you tried -to run a compressed script, a binary program, or a directory as a Perl program. - -=item Unrecognized escape \%c in character class passed through in regex; marked by <-- HERE in m/%s/ - -(W regexp) You used a backslash-character combination which is not -recognized by Perl inside character classes. The character was -understood literally, but this may change in a future version of Perl. -The <-- HERE shows in the regular expression about where the -escape was discovered. - -=item Unrecognized escape \%c passed through - -(W misc) You used a backslash-character combination which is not -recognized by Perl. The character was understood literally, but this may -change in a future version of Perl. - -=item Unrecognized escape \%s passed through in regex; marked by <-- HERE in m/%s/ - -(W regexp) You used a backslash-character combination which is not -recognized by Perl. The character(s) were understood literally, but -this may change in a future version of Perl. The <-- HERE shows in -the regular expression about where the escape was discovered. - -=item Unrecognized signal name "%s" - -(F) You specified a signal name to the kill() function that was not -recognized. Say C<kill -l> in your shell to see the valid signal names -on your system. - -=item Unrecognized switch: -%s (-h will show valid options) - -(F) You specified an illegal option to Perl. Don't do that. (If you -think you didn't do that, check the #! line to see if it's supplying the -bad switch on your behalf.) - -=item Unsuccessful %s on filename containing newline - -(W newline) A file operation was attempted on a filename, and that -operation failed, PROBABLY because the filename contained a newline, -PROBABLY because you forgot to chomp() it off. See L<perlfunc/chomp>. - -=item Unsupported directory function "%s" called - -(F) Your machine doesn't support opendir() and readdir(). - -=item Unsupported function %s - -(F) This machine doesn't implement the indicated function, apparently. -At least, Configure doesn't think so. - -=item Unsupported function fork - -(F) Your version of executable does not support forking. - -Note that under some systems, like OS/2, there may be different flavors -of Perl executables, some of which may support fork, some not. Try -changing the name you call Perl by to C<perl_>, C<perl__>, and so on. - -=item Unsupported script encoding %s - -(F) Your program file begins with a Unicode Byte Order Mark (BOM) which -declares it to be in a Unicode encoding that Perl cannot read. - -=item Unsupported socket function "%s" called - -(F) Your machine doesn't support the Berkeley socket mechanism, or at -least that's what Configure thought. - -=item Unterminated attribute list - -(F) The lexer found something other than a simple identifier at the -start of an attribute, and it wasn't a semicolon or the start of a -block. Perhaps you terminated the parameter list of the previous -attribute too soon. See L<attributes>. - -=item Unterminated attribute parameter in attribute list - -(F) The lexer saw an opening (left) parenthesis character while parsing -an attribute list, but the matching closing (right) parenthesis -character was not found. You may need to add (or remove) a backslash -character to get your parentheses to balance. See L<attributes>. - -=item Unterminated compressed integer - -(F) An argument to unpack("w",...) was incompatible with the BER -compressed integer format and could not be converted to an integer. -See L<perlfunc/pack>. - -=item Unterminated \g{...} pattern in regex; marked by <-- HERE in m/%s/ - -(F) You missed a close brace on a \g{..} pattern (group reference) in -a regular expression. Fix the pattern and retry. - -=item Unterminated <> operator - -(F) The lexer saw a left angle bracket in a place where it was expecting -a term, so it's looking for the corresponding right angle bracket, and -not finding it. Chances are you left some needed parentheses out -earlier in the line, and you really meant a "less than". - -=item Unterminated verb pattern argument in regex; marked by <-- HERE in m/%s/ - -(F) You used a pattern of the form C<(*VERB:ARG)> but did not terminate -the pattern with a C<)>. Fix the pattern and retry. - -=item Unterminated verb pattern in regex; marked by <-- HERE in m/%s/ - -(F) You used a pattern of the form C<(*VERB)> but did not terminate -the pattern with a C<)>. Fix the pattern and retry. - -=item untie attempted while %d inner references still exist - -(W untie) A copy of the object returned from C<tie> (or C<tied>) was -still valid when C<untie> was called. - -=item Usage: POSIX::%s(%s) - -(F) You called a POSIX function with incorrect arguments. -See L<POSIX/FUNCTIONS> for more information. - -=item Usage: Win32::%s(%s) - -(F) You called a Win32 function with incorrect arguments. -See L<Win32> for more information. - -=item $[ used in %s (did you mean $] ?) - -(W syntax) You used C<$[> in a comparison, such as: - - if ($[ > 5.006) { - ... - } - -You probably meant to use C<$]> instead. C<$[> is the base for indexing -arrays. C<$]> is the Perl version number in decimal. - -=item Useless assignment to a temporary - -(W misc) You assigned to an lvalue subroutine, but what -the subroutine returned was a temporary scalar about to -be discarded, so the assignment had no effect. - -=item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/ - -(W regexp) You have used an internal modifier such as (?-o) that has no -meaning unless removed from the entire regexp: - - if ($string =~ /(?-o)$pattern/o) { ... } - -must be written as - - if ($string =~ /$pattern/) { ... } - -The <-- HERE shows in the regular expression about -where the problem was discovered. See L<perlre>. - -=item Useless localization of %s - -(W syntax) The localization of lvalues such as C<local($x=10)> is legal, -but in fact the local() currently has no effect. This may change at -some point in the future, but in the meantime such code is discouraged. - -=item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/ - -(W regexp) You have used an internal modifier such as (?o) that has no -meaning unless applied to the entire regexp: - - if ($string =~ /(?o)$pattern/) { ... } - -must be written as - - if ($string =~ /$pattern/o) { ... } - -The <-- HERE shows in the regular expression about -where the problem was discovered. See L<perlre>. - -=item Useless use of /d modifier in transliteration operator - -(W misc) You have used the /d modifier where the searchlist has the -same length as the replacelist. See L<perlop> for more information -about the /d modifier. - -=item Useless use of \E - -(W misc) You have a \E in a double-quotish string without a C<\U>, -C<\L> or C<\Q> preceding it. - -=item Useless use of %s in void context - -(W void) You did something without a side effect in a context that does -nothing with the return value, such as a statement that doesn't return a -value from a block, or the left side of a scalar comma operator. Very -often this points not to stupidity on your part, but a failure of Perl -to parse your program the way you thought it would. For example, you'd -get this if you mixed up your C precedence with Python precedence and -said - - $one, $two = 1, 2; - -when you meant to say - - ($one, $two) = (1, 2); - -Another common error is to use ordinary parentheses to construct a list -reference when you should be using square or curly brackets, for -example, if you say - - $array = (1,2); - -when you should have said - - $array = [1,2]; - -The square brackets explicitly turn a list value into a scalar value, -while parentheses do not. So when a parenthesized list is evaluated in -a scalar context, the comma is treated like C's comma operator, which -throws away the left argument, which is not what you want. See -L<perlref> for more on this. - -This warning will not be issued for numerical constants equal to 0 or 1 -since they are often used in statements like - - 1 while sub_with_side_effects(); - -String constants that would normally evaluate to 0 or 1 are warned -about. - -=item Useless use of "re" pragma - -(W) You did C<use re;> without any arguments. That isn't very useful. - -=item Useless use of sort in scalar context - -(W void) You used sort in scalar context, as in : - - my $x = sort @y; - -This is not very useful, and perl currently optimizes this away. - -=item Useless use of %s with no values - -(W syntax) You used the push() or unshift() function with no arguments -apart from the array, like C<push(@x)> or C<unshift(@foo)>. That won't -usually have any effect on the array, so is completely useless. It's -possible in principle that push(@tied_array) could have some effect -if the array is tied to a class which implements a PUSH method. If so, -you can write it as C<push(@tied_array,())> to avoid this warning. - -=item "use" not allowed in expression - -(F) The "use" keyword is recognized and executed at compile time, and -returns no useful value. See L<perlmod>. - -=item Use of assignment to $[ is deprecated - -(D deprecated) The C<$[> variable (index of the first element in an array) -is deprecated. See L<perlvar/"$[">. - -=item Use of bare << to mean <<"" is deprecated - -(D deprecated) You are now encouraged to use the explicitly quoted -form if you wish to use an empty line as the terminator of the here-document. - -=item Use of comma-less variable list is deprecated - -(D deprecated) The values you give to a format should be -separated by commas, not just aligned on a line. - -=item Use of chdir('') or chdir(undef) as chdir() deprecated - -(D deprecated) chdir() with no arguments is documented to change to -$ENV{HOME} or $ENV{LOGDIR}. chdir(undef) and chdir('') share this -behavior, but that has been deprecated. In future versions they -will simply fail. - -Be careful to check that what you pass to chdir() is defined and not -blank, else you might find yourself in your home directory. - -=item Use of /c modifier is meaningless in s/// - -(W regexp) You used the /c modifier in a substitution. The /c -modifier is not presently meaningful in substitutions. - -=item Use of /c modifier is meaningless without /g - -(W regexp) You used the /c modifier with a regex operand, but didn't -use the /g modifier. Currently, /c is meaningful only when /g is -used. (This may change in the future.) - -=item Use of := for an empty attribute list is not allowed - -(F) The construction C<my $x := 42> used to parse as equivalent to -C<my $x : = 42> (applying an empty attribute list to C<$x>). -This construct was deprecated in 5.12.0, and has now been made a syntax -error, so C<:=> can be reclaimed as a new operator in the future. - -If you need an empty attribute list, for example in a code generator, add -a space before the C<=>. - -=item Use of freed value in iteration - -(F) Perhaps you modified the iterated array within the loop? -This error is typically caused by code like the following: - - @a = (3,4); - @a = () for (1,2,@a); - -You are not supposed to modify arrays while they are being iterated over. -For speed and efficiency reasons, Perl internally does not do full -reference-counting of iterated items, hence deleting such an item in the -middle of an iteration causes Perl to see a freed value. - -=item Use of *glob{FILEHANDLE} is deprecated - -(D deprecated) You are now encouraged to use the shorter *glob{IO} form -to access the filehandle slot within a typeglob. - -=item Use of /g modifier is meaningless in split - -(W regexp) You used the /g modifier on the pattern for a C<split> -operator. Since C<split> always tries to match the pattern -repeatedly, the C</g> has no effect. - -=item Use of "goto" to jump into a construct is deprecated - -(D deprecated) Using C<goto> to jump from an outer scope into an inner -scope is deprecated and should be avoided. - -=item Use of inherited AUTOLOAD for non-method %s() is deprecated - -(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> -subroutines are looked up as methods (using the C<@ISA> hierarchy) -even when the subroutines to be autoloaded were called as plain -functions (e.g. C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or -C<< $obj->bar() >>). - -This bug will be rectified in future by using method lookup only for -methods' C<AUTOLOAD>s. However, there is a significant base of existing -code that may be using the old behavior. So, as an interim step, Perl -currently issues an optional warning when non-methods use inherited -C<AUTOLOAD>s. - -The simple rule is: Inheritance will not work when autoloading -non-methods. The simple fix for old code is: In any module that used -to depend on inheriting C<AUTOLOAD> for non-methods from a base class -named C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during -startup. - -In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);> -you should remove AutoLoader from @ISA and change C<use AutoLoader;> to -C<use AutoLoader 'AUTOLOAD';>. - -=item Use of %s in printf format not supported - -(F) You attempted to use a feature of printf that is accessible from -only C. This usually means there's a better way to do it in Perl. - -=item Use of %s is deprecated - -(D deprecated) The construct indicated is no longer recommended for use, -generally because there's a better way to do it, and also because the -old way has bad side effects. - -=item Use of -l on filehandle %s - -(W io) A filehandle represents an opened file, and when you opened the file -it already went past any symlink you are presumably trying to look for. -The operation returned C<undef>. Use a filename instead. - -=item Use of %s on a handle without * is deprecated - -(D deprecated) You used C<tie>, C<tied> or C<untie> on a scalar but that scalar -happens to hold a typeglob, which means its filehandle will be tied. If -you mean to tie a handle, use an explicit * as in C<tie *$handle>. - -This was a long-standing bug that was removed in Perl 5.16, as there was -no way to tie the scalar itself when it held a typeglob, and no way to -untie a scalar that had had a typeglob assigned to it. If you see this -message, you must be using an older version. - -=item Use of ?PATTERN? without explicit operator is deprecated - -(D deprecated) You have written something like C<?\w?>, for a regular -expression that matches only once. Starting this term directly with -the question mark delimiter is now deprecated, so that the question mark -will be available for use in new operators in the future. Write C<m?\w?> -instead, explicitly using the C<m> operator: the question mark delimiter -still invokes match-once behaviour. - -=item Use of qw(...) as parentheses is deprecated - -(D deprecated) You have something like C<foreach $x qw(a b c) {...}>, -using a C<qw(...)> list literal where a parenthesised expression is -expected. Historically the parser fooled itself into thinking that -C<qw(...)> literals were always enclosed in parentheses, and as a result -you could sometimes omit parentheses around them. (You could never do -the C<foreach qw(a b c) {...}> that you might have expected, though.) -The parser no longer lies to itself in this way. Wrap the list literal -in parentheses, like C<foreach $x (qw(a b c)) {...}>. - -=item Use of reference "%s" as array index - -(W misc) You tried to use a reference as an array index; this probably -isn't what you mean, because references in numerical context tend -to be huge numbers, and so usually indicates programmer error. - -If you really do mean it, explicitly numify your reference, like so: -C<$array[0+$ref]>. This warning is not given for overloaded objects, -however, because you can overload the numification and stringification -operators and then you presumably know what you are doing. - -=item Use of reserved word "%s" is deprecated - -(D deprecated) The indicated bareword is a reserved word. Future -versions of perl may use it as a keyword, so you're better off either -explicitly quoting the word in a manner appropriate for its context of -use, or using a different name altogether. The warning can be -suppressed for subroutine names by either adding a C<&> prefix, or using -a package qualifier, e.g. C<&our()>, or C<Foo::our()>. - -=item Use of tainted arguments in %s is deprecated - -(W taint, deprecated) You have supplied C<system()> or C<exec()> with multiple -arguments and at least one of them is tainted. This used to be allowed -but will become a fatal error in a future version of perl. Untaint your -arguments. See L<perlsec>. - -=item Use of uninitialized value%s - -(W uninitialized) An undefined value was used as if it were already -defined. It was interpreted as a "" or a 0, but maybe it was a mistake. -To suppress this warning assign a defined value to your variables. - -To help you figure out what was undefined, perl will try to tell you -the name of the variable (if any) that was undefined. In some cases -it cannot do this, so it also tells you what operation you used the -undefined value in. Note, however, that perl optimizes your program -anid the operation displayed in the warning may not necessarily appear -literally in your program. For example, C<"that $foo"> is usually -optimized into C<"that " . $foo>, and the warning will refer to the -C<concatenation (.)> operator, even though there is no C<.> in -your program. - -=item Using a hash as a reference is deprecated - -(D deprecated) You tried to use a hash as a reference, as in -C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1 -used to allow this syntax, but shouldn't have. It is now -deprecated, and will be removed in a future version. - -=item Using an array as a reference is deprecated - -(D deprecated) You tried to use an array as a reference, as in -C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.6.1 used to -allow this syntax, but shouldn't have. It is now deprecated, -and will be removed in a future version. - -=item Using just the first character returned by \N{} in character class - -(W) A charnames handler may return a sequence of more than one character. -Currently all but the first one are discarded when used in a regular -expression pattern bracketed character class. - -=item Using !~ with %s doesn't make sense - -(F) Using the C<!~> operator with C<s///r>, C<tr///r> or C<y///r> is -currently reserved for future use, as the exact behaviour has not -been decided. (Simply returning the boolean opposite of the -modified string is usually not particularly useful.) - -=item UTF-16 surrogate U+%X - -(W utf8, surrogate) You had a UTF-16 surrogate in a context where they are -not considered acceptable. These code points, between U+D800 and -U+DFFF (inclusive), are used by Unicode only for UTF-16. However, Perl -internally allows all unsigned integer code points (up to the size limit -available on your platform), including surrogates. But these can cause -problems when being input or output, which is likely where this message -came from. If you really really know what you are doing you can turn -off this warning by C<no warnings 'surrogate';>. - -=item Value of %s can be "0"; test with defined() - -(W misc) In a conditional expression, you used <HANDLE>, <*> (glob), -C<each()>, or C<readdir()> as a boolean value. Each of these constructs -can return a value of "0"; that would make the conditional expression -false, which is probably not what you intended. When using these -constructs in conditional expressions, test their values with the -C<defined> operator. - -=item Value of CLI symbol "%s" too long - -(W misc) A warning peculiar to VMS. Perl tried to read the value of an -%ENV element from a CLI symbol table, and found a resultant string -longer than 1024 characters. The return value has been truncated to -1024 characters. - -=item Variable "%s" is not available - -(W closure) During compilation, an inner named subroutine or eval is -attempting to capture an outer lexical that is not currently available. -This can happen for one of two reasons. First, the outer lexical may be -declared in an outer anonymous subroutine that has not yet been created. -(Remember that named subs are created at compile time, while anonymous -subs are created at run-time.) For example, - - sub { my $a; sub f { $a } } - -At the time that f is created, it can't capture the current value of $a, -since the anonymous subroutine hasn't been created yet. Conversely, -the following won't give a warning since the anonymous subroutine has by -now been created and is live: - - sub { my $a; eval 'sub f { $a }' }->(); - -The second situation is caused by an eval accessing a variable that has -gone out of scope, for example, - - sub f { - my $a; - sub { eval '$a' } - } - f()->(); - -Here, when the '$a' in the eval is being compiled, f() is not currently being -executed, so its $a is not available for capture. - -=item Variable "%s" is not imported%s - -(W misc) With "use strict" in effect, you referred to a global variable -that you apparently thought was imported from another module, because -something else of the same name (usually a subroutine) is exported by -that module. It usually means you put the wrong funny character on the -front of your variable. - -=item Variable length lookbehind not implemented in m/%s/ - -(F) Lookbehind is allowed only for subexpressions whose length is fixed and -known at compile time. See L<perlre>. - -=item "%s" variable %s masks earlier declaration in same %s - -(W misc) A "my", "our" or "state" variable has been redeclared in the -current scope or statement, effectively eliminating all access to the -previous instance. This is almost always a typographical error. Note -that the earlier variable will still exist until the end of the scope -or until all closure referents to it are destroyed. - -=item Variable syntax - -(A) You've accidentally run your script through B<csh> instead -of Perl. Check the #! line, or manually feed your script into -Perl yourself. - -=item Variable "%s" will not stay shared - -(W closure) An inner (nested) I<named> subroutine is referencing a -lexical variable defined in an outer named subroutine. - -When the inner subroutine is called, it will see the value of -the outer subroutine's variable as it was before and during the *first* -call to the outer subroutine; in this case, after the first call to the -outer subroutine is complete, the inner and outer subroutines will no -longer share a common value for the variable. In other words, the -variable will no longer be shared. - -This problem can usually be solved by making the inner subroutine -anonymous, using the C<sub {}> syntax. When inner anonymous subs that -reference variables in outer subroutines are created, they -are automatically rebound to the current values of such variables. - -=item vector argument not supported with alpha versions - -(W internal) The %vd (s)printf format does not support version objects -with alpha parts. - -=item Verb pattern '%s' has a mandatory argument in regex; marked by <-- HERE in m/%s/ - -(F) You used a verb pattern that requires an argument. Supply an -argument or check that you are using the right verb. - -=item Verb pattern '%s' may not have an argument in regex; marked by <-- HERE in m/%s/ - -(F) You used a verb pattern that is not allowed an argument. Remove the -argument or check that you are using the right verb. - -=item Version number must be a constant number - -(P) The attempt to translate a C<use Module n.n LIST> statement into -its equivalent C<BEGIN> block found an internal inconsistency with -the version number. - -=item Version string '%s' contains invalid data; ignoring: '%s' - -(W misc) The version string contains invalid characters at the end, which -are being ignored. - -=item Warning: something's wrong - -(W) You passed warn() an empty string (the equivalent of C<warn "">) or -you called it with no args and C<$@> was empty. - -=item Warning: unable to close filehandle %s properly - -(S) The implicit close() done by an open() got an error indication on -the close(). This usually indicates your file system ran out of disk -space. - -=item Warning: Use of "%s" without parentheses is ambiguous - -(S ambiguous) You wrote a unary operator followed by something that -looks like a binary operator that could also have been interpreted as a -term or unary operator. For instance, if you know that the rand -function has a default argument of 1.0, and you write - - rand + 5; - -you may THINK you wrote the same thing as - - rand() + 5; - -but in actual fact, you got - - rand(+5); - -So put in parentheses to say what you really mean. - -=item Wide character in %s - -(S utf8) Perl met a wide character (>255) when it wasn't expecting -one. This warning is by default on for I/O (like print). The easiest -way to quiet this warning is simply to add the C<:utf8> layer to the -output, e.g. C<binmode STDOUT, ':utf8'>. Another way to turn off the -warning is to add C<no warnings 'utf8';> but that is often closer to -cheating. In general, you are supposed to explicitly mark the -filehandle with an encoding, see L<open> and L<perlfunc/binmode>. - -=item Within []-length '%c' not allowed - -(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> -only if C<TEMPLATE> always matches the same amount of packed bytes that -can be determined from the template alone. This is not possible if -it contains any of the codes @, /, U, u, w or a *-length. Redesign -the template. - -=item write() on closed filehandle %s - -(W closed) The filehandle you're writing to got itself closed sometime -before now. Check your control flow. - -=item %s "\x%X" does not map to Unicode - -(F) When reading in different encodings Perl tries to map everything -into Unicode characters. The bytes you read in are not legal in -this encoding, for example - - utf8 "\xE4" does not map to Unicode - -if you try to read in the a-diaereses Latin-1 as UTF-8. - -=item 'X' outside of string - -(F) You had a (un)pack template that specified a relative position before -the beginning of the string being (un)packed. See L<perlfunc/pack>. - -=item 'x' outside of string in unpack - -(F) You had a pack template that specified a relative position after -the end of the string being unpacked. See L<perlfunc/pack>. - -=item YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET! - -(F) And you probably never will, because you probably don't have the -sources to your kernel, and your vendor probably doesn't give a rip -about what you want. Your best bet is to put a setuid C wrapper around -your script. - -=item You need to quote "%s" - -(W syntax) You assigned a bareword as a signal handler name. -Unfortunately, you already have a subroutine of that name declared, -which means that Perl 5 will try to call the subroutine when the -assignment is executed, which is probably not what you want. (If it IS -what you want, put an & in front.) - -=item Your random numbers are not that random - -(F) When trying to initialise the random seed for hashes, Perl could -not get any randomness out of your system. This usually indicates -Something Very Wrong. - -=back - -=head1 SEE ALSO - -L<warnings>, L<perllexwarn>, L<diagnostics>. - -=cut |