(W) A warning (optional).
(D) A deprecation (optional).
- (S) A severe warning (mandatory).
+ (S) A severe warning (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).
-Optional warnings are enabled by using the B<-w> switch. 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>.
-Trappable errors may be trapped using the eval operator. See
-L<perlfunc/eval>.
+The majority of messages from the first three classifications above
+(W, D & S) can be controlled using the C<warnings> pragma.
-Some of these messages are generic. Spots that vary are denoted with a %s,
-just as in a printf format. Note that some messages start with a %s!
-The symbols C<"%(-?@> sort before the letters, while C<[> and C<\> sort after.
+If a message can be controlled by the C<warnings> pragma, its warning
+category is included with the classification letter in the description
+below.
-=over 4
+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>.
-=item "my" variable %s can't be in a package
+Default warnings are always enabled unless they are explicitly disabled
+with the C<warnings> pragma or the B<-X> switch.
-(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.
+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>.
-=item "my" variable %s masks earlier declaration in same %s
+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.
-(W) A lexical 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.
+=over 4
-=item "no" not allowed in expression
+=item accept() on closed socket %s
-(F) The "no" keyword is recognized and executed at compile time, and returns
-no useful value. See L<perlmod>.
+(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 "use" not allowed in expression
+=item Allocation too large: %lx
-(F) The "use" keyword is recognized and executed at compile time, and returns
-no useful value. See L<perlmod>.
+(X) You can't allocate more than 64K on an MS-DOS machine.
=item '!' allowed only after types %s
(F) The '!' is allowed in pack() and unpack() only after certain types.
See L<perlfunc/pack>.
-=item # cannot take a count
+=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
-(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>.
+(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.
-=item # must be followed by a, A or Z
+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).
-(F) You had an unpack template indicating a counted-length string,
-which must be followed by one of the letters a, A or Z
-to indicate what sort of string is to be unpacked.
-See L<perlfunc/pack>.
+To silently interpret it as the Perl operator, use the C<CORE::> prefix
+on the operator (e.g. C<CORE::log($x)>) or by declaring the subroutine
+to be an object method (see L<perlsub/"Subroutine Attributes"> or
+L<attributes>).
-=item # must be followed by a*, A* or Z*
+=item Ambiguous use of %s resolved as %s
-(F) You had an pack template indicating a counted-length string,
-Currently the only things that can have their length counted are a*, A* or Z*.
-See L<perlfunc/pack>.
+(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 # must follow a numeric type
+=item '|' and '<' may not both be specified on command line
-(F) You had an unpack template that contained a '#',
-but this did not follow some numeric unpack specification.
-See L<perlfunc/pack>.
+(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 % may only be used in unpack
+=item '|' and '>' may not both be specified on command line
-(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>.
+(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
-=item /%s/: Unrecognized escape \\%c passed through
+ open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!";
+ while (<STDIN>) {
+ print;
+ print OUT;
+ }
+ close OUT;
-(W) You used a backslash-character combination which is not recognized
-by Perl. This combination appears in an interpolated variable or a
-C<'>-delimited regular expression.
+=item Applying %s to %s will act on scalar(%s)
-=item %s (...) interpreted as function
+(W misc) The pattern match (//), substitution (s///), and
+transliteration (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.
-(W) 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 Args must match #! line
-=item %s() called too early to check prototype
+(F) The setuid emulator requires that the arguments Perl was invoked
+with match the arguments specified on the #! line. Since some systems
+impose a one-argument limit on the #! line, try combining switches;
+for example, turn C<-w -U> into C<-wU>.
-(W) 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 Arg too short for msgsnd
-=item %s argument is not a HASH element
+(F) msgsnd() requires a string at least as long as sizeof(long).
-(F) The argument to exists() must be a hash element, such as
+=item %s argument is not a HASH or ARRAY element
+
+(F) The argument to exists() must be a hash or array element, such as:
$foo{$bar}
- $ref->[12]->{"susie"}
+ $ref->{"susie"}[12]
-=item %s argument is not a HASH element or slice
+=item %s argument is not a HASH or ARRAY element or slice
-(F) The argument to delete() must be either a hash element, such as
+(F) The argument to delete() must be either a hash or array element,
+such as:
$foo{$bar}
- $ref->[12]->{"susie"}
+ $ref->{"susie"}[12]
-or a hash slice, such as
+or a hash or array slice, such as:
- @foo{$bar, $baz, $xyzzy}
+ @foo[$bar, $baz, $xyzzy]
@{$ref->[12]}{"susie", "queue"}
-=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 %s found where operator expected
-
-(S) 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 %s had compilation errors
-
-(F) The final summary message when a C<perl -c> fails.
-
-=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 %s matches null string many times
-
-(W) The pattern you've specified would be an infinite loop if the
-regular expression engine didn't specifically check for that. See L<perlre>.
-
-=item %s never introduced
-
-(S) The symbol in question was declared but somehow went out of scope
-before it could possibly have been used.
-
-=item %s syntax OK
-
-(F) The final summary message when a C<perl -c> succeeds.
-
-=item %s: Command not found
-
-(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: Expression syntax
+=item %s argument is not a subroutine name
-(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: 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 %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 (in cleanup) %s
-
-(W) 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 (Missing semicolon on previous line?)
-
-(S) 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 B<-P> not allowed for setuid/setgid script
-
-(F) The script would have to be opened by the C preprocessor by name,
-which provides a race condition that breaks security.
-
-=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 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 500 Server error
-
-See Server error.
-
-=item ?+* follows nothing in regexp
-
-(F) You started a regular expression with a quantifier. Backslash it
-if you meant it literally. See L<perlre>.
-
-=item @ outside of string
-
-(F) You had a pack template that specified an absolute position outside
-the string being unpacked. See L<perlfunc/pack>.
-
-=item <> should be quotes
-
-(F) You wrote C<require E<lt>fileE<gt>> when you should have written
-C<require 'file'>.
-
-=item accept() on closed fd
-
-(W) 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: %lx
-
-(X) You can't allocate more than 64K on an MS-DOS machine.
-
-=item Applying %s to %s will act on scalar(%s)
-
-(W) The pattern match (//), substitution (s///), and transliteration (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 Ambiguous use of %s resolved as %s
-
-(W)(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 call resolved as CORE::%s(), qualify as such or use &
-
-(W) 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 by declaring the subroutine
-to be an object method (see L<attrs>).
-
-=item Args must match #! line
-
-(F) The setuid emulator requires that the arguments Perl was invoked
-with match the arguments specified on the #! line. Since some systems
-impose a one-argument limit on the #! line, try combining switches;
-for example, turn C<-w -U> into C<-wU>.
+(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) The indicated string was fed as an argument to an operator that
-expected a numeric value instead. If you're fortunate the message
+(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 Array @%s missing the @ in argument %d of %s()
-(D) Really old Perl let you omit the @ on array names in some spots. This
-is now heavily deprecated.
+(D deprecated) Really old Perl let you omit the @ on array names in some
+spots. This is now heavily deprecated.
=item assertion botched: %s
=item Attempt to free non-arena SV: 0x%lx
-(P) 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.
+(P 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
-(P) 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.
+(P 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
-(W) 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.
+(W 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
-(P) The reference counts got screwed up on symbol aliases.
+(P internal) The reference counts got screwed up on symbol aliases.
=item Attempt to free unreferenced scalar
-(W) 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.
+(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.
+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) You tried to pass a temporary value (like the result of a
+(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
=item Attempt to use reference as lvalue in substr
-(W) You supplied a reference as the first argument to substr() used
-as an lvalue, which is pretty strange. Perhaps you forgot to
+(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 Bad arg length for %s, is %d, 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,
+(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 /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.
+(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) An internal routine called free() on something that had never been
-malloc()ed in the first place. Mandatory, but can be disabled by
+(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 1.
-This message can be quite often seen 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().
+This message can be quite often seen 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
pseudo-hash is not legal. Index values must be at 1 or greater.
See L<perlref>.
+=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
+(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;
$var = 'myvar';
$sym = "mypack::$var";
+=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 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
=item Bad symbol for filehandle
-(P) An internal request asked to add a filehandle entry to something that
-wasn't a symbol table entry.
+(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 Badly placed ()'s
+=item Bareword found in conditional
-(A) You've accidentally run your script through B<csh> instead
-of Perl. Check the #! line, or manually feed your script into
-Perl yourself.
+(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?
+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) 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?
+(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.
+(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.
+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) The binary number you specified is larger than 2**32-1
+(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 fd
-
-(W) 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 Bizarre copy of %s in %s
-
-(P) Perl detected an attempt to copy an internal value that is not copiable.
+=item bind() on closed socket %s
-=item Buffer overflow in prime_env_iter: %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>.
-(W) 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 Bit vector size > 32 non-portable
-=item Callback called exit
+(W portable) Using bit vector sizes larger than 32 is non-portable.
-(F) A subroutine invoked from an external package via perl_call_sv()
-exited by calling exit.
+=item Bizarre copy of %s in %s
-=item Can't "goto" outside a block
+(P) Perl detected an attempt to copy an internal value that is not
+copiable.
-(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 B<-P> not allowed for setuid/setgid script
-=item Can't "goto" into the middle of a foreach loop
+(F) The script would have to be opened by the C preprocessor by name,
+which provides a race condition that breaks security.
-(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 Buffer overflow in prime_env_iter: %s
-=item Can't "last" outside a block
+(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.
-(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(). 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 Callback called exit
-=item Can't "next" outside a block
+(F) A subroutine invoked from an external package via call_sv()
+exited by calling exit.
-(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(). 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 %s() called too early to check prototype
-=item Can't read CRTL environ
+(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>.
-(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 / cannot take a count
-=item Can't "redo" outside a 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(). 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>.
+(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 Can't bless non-reference value
=item Can't break at that line
-(S) A warning intended to only be printed while running within the debugger, indicating
-the line number specified wasn't the location of a statement that could
-be stopped at.
+(S internal) A warning intended to only be printed while running within
+the debugger, indicating the line number specified wasn't the location
+of a statement that could be stopped at.
=item Can't call method "%s" in empty package "%s"
functioning as a class, but that package doesn't have ANYTHING defined
in it, let alone methods. See L<perlobj>.
-=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
+=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 expression that returns
-a defined value which is neither an object reference nor a package name.
-Something like this will reproduce the error:
+object reference or package name contains an undefined value. Something
+like this will reproduce the error:
- $BADREF = 42;
+ $BADREF = undef;
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
-=item Can't call method "%s" on an undefined value
+=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 undefined value.
+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 = undef;
+ $BADREF = 42;
process $BADREF 1,2,3;
$BADREF->process(1,2,3);
(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"
+=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.
-(P) For some reason you can't check the filesystem of the script for nosuid.
+=item Can't coerce array into hash
+
+(F) You used an array where a hash was expected, but the array has no
+information on how to map from keys to array indices. You can do that
+only with arrays that have a hash reference at index 0.
=item Can't coerce %s to integer in %s
(F) Certain types of SVs, in particular real symbol table entries
(typeglobs), can't be forced to stop being what they are.
-=item Can't coerce array into hash
+=item Can't create pipe mailbox
-(F) You used an array where a hash was expected, but the array has no
-information on how to map from keys to array indices. You can do that
-only with arrays that have a hash reference at index 0.
+(P) An error peculiar to VMS. The process is suffering from exhausted
+quotas or other plumbing problems.
-=item Can't create pipe mailbox
+=item Can't declare class for non-scalar %s in "%s"
-(P) An error peculiar to VMS. The process is suffering from exhausted quotas
-or other plumbing problems.
+(S) Currently, only scalar variables can declared with a specific class
+qualifier in a "my" or "our" declaration. The semantics may be extended
+for other types of variables in future.
-=item Can't declare %s in my
+=item Can't declare %s in "%s"
+
+(F) Only scalar, array, and hash variables may be declared as "my" or
+"our" variables. They must have ordinary identifiers as names.
+
+=item Can't do inplace edit: %s is not a regular file
-(F) Only scalar, array, and hash variables may be declared as lexical variables.
-They must have ordinary identifiers as names.
+(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) The creation of the new file failed for the indicated reason.
+(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.
+(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 E<gt> 14 characters
+=item Can't do inplace edit: %s would not be unique
-(S) There isn't enough room in the filename to make a backup name for the file.
+(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 inplace edit: %s is not a regular file
+=item Can't do {n,m} with n > m
-(S) 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.
+(F) Minima must be less than or equal to maxima. If you really want
+your regexp to match something 0 times, just put {0}. See L<perlre>.
=item Can't do setegid!
-(P) The setegid() call failed for some reason in the setuid emulator
-of suidperl.
+(P) The setegid() call failed for some reason in the setuid emulator of
+suidperl.
=item Can't do seteuid!
=item Can't do setuid
-(F) This typically means that ordinary perl tried to exec suidperl to
-do setuid emulation, but couldn't exec it. It looks for a name of the
-form sperl5.000 in the same directory that the perl executable resides
-under the name perl5.000, typically /usr/local/bin on Unix machines.
-If the file is there, check the execute permissions. If it isn't, ask
-your sysadmin why he and/or she removed it.
+(F) This typically means that ordinary perl tried to exec suidperl to do
+setuid emulation, but couldn't exec it. It looks for a name of the form
+sperl5.000 in the same directory that the perl executable resides under
+the name perl5.000, typically /usr/local/bin on Unix machines. If the
+file is there, check the execute permissions. If it isn't, ask your
+sysadmin why he and/or she removed it.
=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 do {n,m} with n E<gt> m
-
-(F) Minima must be less than or equal to maxima. If you really want
-your regexp to match something 0 times, just put {0}. See L<perlre>.
+(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.
+(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 exec "%s": %s
-(W) An 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.)
+(W exec) An 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.
+(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.
+(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 %s on PATH, '.' not in PATH
+=item Can't find an opnumber for "%s"
-(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.
+(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 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.
+(F) You used the B<-S> switch, but the script to execute could not be
+found in the PATH.
-=item Can't find label %s
+=item Can't find %s on PATH, '.' not in PATH
-(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>.
+(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:
+(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. A good
-programmer's editor will have a way to help you find these characters.
+If you're getting this error from a here-document, you may have included
+unseen whitespace before or after your closing tag. A good programmer's
+editor will have a way to help you find these characters.
=item Can't fork
-(F) A fatal error occurred while trying to fork while opening a pipeline.
+(F) A fatal error occurred while trying to fork while opening a
+pipeline.
=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.)
+(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.
+(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 subroutine outside a subroutine
+=item Can't "goto" into the middle of a foreach loop
-(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>.
+(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 an eval-string
-(F) The "goto subroutine" call can't be used to jump out of an eval "string".
-(You can use it to jump out of an eval {BLOCK}, but you probably don't want to.)
+(F) The "goto subroutine" call can't be used to jump out of an eval
+"string". (You can use it to jump out of an eval {BLOCK}, but you
+probably don't want to.)
-=item Can't localize through a reference
+=item Can't goto subroutine outside a subroutine
-(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.
+(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 "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 localize lexical variable %s
=item Can't localize pseudo-hash element
-(F) You said something like C<local $ar-E<gt>{'key'}>, where $ar is
-a reference to a pseudo-hash. That hasn't been implemented yet, but
-you can get a similar effect by localizing the corresponding array
-element directly -- C<local $ar-E<gt>[$ar-E<gt>[0]{'key'}]>.
+(F) You said something like C<< local $ar->{'key'} >>, where $ar is a
+reference to a pseudo-hash. That hasn't been implemented yet, but you
+can get a similar effect by localizing the corresponding array element
+directly -- C<< local $ar->[$ar->[0]{'key'}] >>.
-=item Can't locate auto/%s.al in @INC
+=item Can't localize through a reference
-(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>.
+(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>.
+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 object method "%s" via package "%s"
=item Can't locate package %s for @%s::ISA
-(W) The @ISA array contained the name of another package that doesn't seem
-to exist.
+(W syntax) The @ISA array contained the name of another package that
+doesn't seem to exist.
=item Can't make list assignment to \%ENV on this system
-(F) List assignment to %ENV is not supported on some systems, notably VMS.
+(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.
+(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: %s
-(S) The implicit opening of a file through use of the C<E<lt>E<gt>>
+(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.
+is because you don't have read permission for a file which you named on
+the command line.
=item Can't open bidirectional pipe
-(W) 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 "E<gt>",
-and then read it in under a different file handle.
+(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 '2E<gt>' or '2E<gt>E<gt>' on the
-command line for writing.
+(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 'E<lt>' on the command line for reading.
+(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 'E<gt>' or 'E<gt>E<gt>' on the command
-line for writing.
+(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.
+(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.
+=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 redefine active sort subroutine %s
(F) Perl optimizes the internal handling of sort subroutines and keeps
-pointers into them. You tried to redefine one such sort subroutine when it
-was currently active, which is not allowed. If you really want to do
+pointers into them. You tried to redefine one such sort subroutine when
+it was currently active, which is not allowed. If you really want to do
this, you should write C<sort { &func } @x> instead of C<sort func @x>.
+=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) The rename done by the B<-i> switch failed for some reason, probably because
-you don't have write permission to the directory.
+(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.
+(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 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
+method name is C<???>, this is an internal error.
=item Can't reswap uid and euid
-(P) The setreuid() call failed for some reason in the setuid emulator
-of suidperl.
+(P) The setreuid() call failed for some reason in the setuid emulator of
+suidperl.
+
+=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
=item Can't stat script "%s"
-(P) For some reason you can't fstat() the script even though you have
-it open already. Bizarre.
+(P) For some reason you can't fstat() the script even though you have it
+open already. Bizarre.
=item Can't swap uid and euid
-(P) The setreuid() call failed for some reason in the setuid emulator
-of suidperl.
+(P) The setreuid() call failed for some reason in the setuid emulator of
+suidperl.
=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.
+standard with Perl, though, if you really want to do that for the
+negative numbers.
=item Can't take sqrt of %g
=item Can't upgrade that kind of scalar
-(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.
+(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 upgrade to undef
-(P) The undefined SV is the bottom of the totem pole, in the scheme
-of upgradability. Upgrading to undef indicates an error in the
-code calling sv_upgrade.
+(P) The undefined SV is the bottom of the totem pole, in the scheme of
+upgradability. Upgrading to undef indicates an error in the code
+calling sv_upgrade.
+
+=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
Errno.pm module. The Errno module is expected to tie the %! hash to
provide symbolic names for C<$!> errno values.
+=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 "my"
+
+(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 "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 E<lt>=E<gt> or cmp operator,
+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 Bad evalled substitution pattern
-
-(F) You've used the /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 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 %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 \1 to mean $1 in expression
-
-(W) 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 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 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 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 global %s in "my"
-
-(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.
+(F) Only hard references are allowed by "strict refs". Symbolic
+references are disallowed. See L<perlref>.
=item Can't use subscript on %s
subscript. But to the left of the brackets was an expression that
didn't look like an 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
=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.
+(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 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 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 method name is C<???>, this is an internal error.
-
-=item Character class [:%s:] unknown
-
-(F) The class in the character class [: :] syntax is unknown.
-
=item Character class syntax [%s] belongs inside character classes
-(W) The character class constructs [: :], [= =], and [. .] go
-I<inside> character classes, the [] are part of the construct,
-for example: /[012[:alpha:]345]/. Note that the last two constructs
-are not currently implemented, they are placeholders for future extensions.
+(W unsafe) 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.
=item Character class syntax [. .] is reserved for future extensions
-(W) 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 ".\]".
+(W 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 ".\]".
=item Character class syntax [= =] is reserved for future extensions
-(W) 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 "=\]".
+(W 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 "=\]".
+
+=item Character class [:%s:] unknown
+
+(F) The class in the character class [: :] syntax is unknown. See
+L<perlre>.
-=item chmod: mode argument is missing initial 0
+=item chmod() mode argument is missing initial 0
-(W) A novice will sometimes say
+(W chmod) A novice will sometimes say
chmod 777, $filename
-not realizing that 777 will be interpreted as a decimal number, equivalent
-to 01411. Octal constants are introduced with a leading 0 in Perl, as in C.
+not realizing that 777 will be interpreted as a decimal number,
+equivalent to 01411. Octal constants are introduced with a leading 0 in
+Perl, as in C.
-=item Close on unopened file E<lt>%sE<gt>
+=item Close on unopened file <%s>
-(W) You tried to close a filehandle that was never opened.
+(W unopened) You tried to close a filehandle that was never opened.
+
+=item %s: Command not found
+
+(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 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.
+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) 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
+(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<perlbook>
-for information on I<Mastering Regular Expressions>.)
+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<perlbook> for information
+on I<Mastering Regular Expressions>.)
-=item connect() on closed fd
+=item connect() on closed socket %s
-(W) 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>.
+(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
+
+(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 C<overload> or C<charnames> pragma? See L<charnames> and
+L<overload>.
=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.
+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
-(S) You redefined a subroutine which had previously been eligible for
-inlining. See L<perlsub/"Constant Functions"> for commentary and
-workarounds.
+(S|W redefine) 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
-(S) You undefined a subroutine which had previously been eligible for
-inlining. See L<perlsub/"Constant Functions"> for commentary and
+(W misc) You undefined a subroutine which had previously been eligible
+
for inlining. See L<perlsub/"Constant Functions"> for commentary and
workarounds.
-=item constant(%s): %%^H is not localized
+=item Copy method did not return a reference
-(F) When setting compile-time-lexicalized hash %^H one should set the
-corresponding bit of $^H as well.
+(F) The method which overloads "=" is buggy. See L<overload/Copy
+Constructor>.
-=item constant(%s): %s
+=item CORE::%s is not a keyword
-(F) Compile-time-substitutions (such as overloaded constants and
-character names) were not correctly set up.
+(F) The CORE:: namespace is reserved for Perl keywords.
-=item Copy method did not return a reference
+=item corrupted regexp pointers
-(F) The method which overloads "=" is buggy. See L<overload/Copy Constructor>.
+(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%lx at 0x%lx
(P) The malloc package that comes with Perl had an internal failure.
-=item corrupted regexp pointers
+=item C<-p> destination: %s
-(P) The regular expression engine got confused by what the regular
-expression compiler gave it.
+(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 corrupted regexp program
+=item C<-T> and C<-B> not implemented on filehandles
-(P) The regular expression engine got passed a regexp program without
-a valid magic number.
+(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 Deep recursion on subroutine "%s"
-(W) 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.
+(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.
=item defined(@array) is deprecated
-(D) 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.
+(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) defined() is not usually useful on hashes because it checks for an
-undefined I<scalar> value. If you want to see if the hash is empty,
-just use C<if (%hash) { # not empty }> for example.
+(D deprecated) defined() is not usually useful on hashes because it
+checks for an undefined I<scalar> value. If you want to see if the hash
+is empty, just use C<if (%hash) { # not empty }> for example.
=item Delimiter for here document is too long
-(F) In a here document construct like C<E<lt>E<lt>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.
+(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 Did you mean &%s instead?
+=item Did not produce a valid header
-(W) You probably referred to an imported subroutine &FOO as $FOO or some such.
+See Server error.
+
+=item %s did not return a true value
-=item Did you mean $ or @ instead of %?
+(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>.
-(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 (Did you mean &%s instead?)
+
+(W) 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 both C<$@> and C<$_> were empty.
-=item Do you need to predeclare %s?
+=item Document contains no data
-(S) 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.
+See Server error.
=item Don't know how to handle magic of type '%s'
(P) This should have been caught by safemalloc() instead.
+=item (Do you need to predeclare %s?)
+
+(S) 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 Duplicate free() ignored
-(S) An internal routine called free() on something that had already
-been freed.
+(S malloc) An internal routine called free() on something that had
+already been freed.
=item elseif should be elsif
-(S) 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
+(S) 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 END failed--cleanup aborted
-
-(F) An untrapped exception was raised while executing an END subroutine.
-The interpreter is immediately exited.
-
=item entering effective %s failed
(F) While under the C<use filetest> pragma, switching the real and
(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.
+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>.
+(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, use re 'eval'
+=item %s: Eval-group not allowed at run time
-(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 })>.
+(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 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 at run time
+=item %s: Eval-group not allowed, 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 explicitly building the pattern
-from an interpolated string at run time and using that in an eval().
-See L<perlre/(?{ code })>.
+(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 Excessively long <> operator
=item Exiting eval via %s
-(W) You are exiting an eval by unconventional means, such as
-a goto, or a loop control statement.
+(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 an eval by unconventional means, such as a
+goto, or a loop control statement.
=item Exiting pseudo-block via %s
-(W) 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>.
+(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) You are exiting a subroutine by unconventional means, such as
-a goto, or a loop control statement.
+(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) You are exiting a substitution by unconventional means, such as
-a return, a goto, or a loop control statement.
+(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) You are blessing a reference to a zero length string. This has
+(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');
+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 CHECK, INIT, or
+END subroutine. Processing of the remainder of the queue of such
+routines has been prematurely ended.
+
+=item false [] range "%s" in regexp
+
+(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 "-", "\-". See L<perlre>.
=item Fatal VMS error 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.
+(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
=item Filehandle %s never opened
-(W) An I/O operation was attempted on a filehandle that was never initialized.
-You need to do an open() or a socket() call, or call a constructor from
-the FileHandle package.
+(W unopened) An I/O operation was attempted on a filehandle that was
+never initialized. You need to do an open() or a socket() call, or call
+a constructor from the FileHandle package.
=item Filehandle %s opened only for input
-(W) 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
-"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If
-you intended only to write the file, use "E<gt>" or "E<gt>E<gt>". See
-L<perlfunc/open>.
+(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) 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
-"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If
-you intended only to read from the file, use "E<lt>". See
-L<perlfunc/open>.
+(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 "<" or nothing. If you
+intended only to read from the file, use "<". See L<perlfunc/open>.
=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.
+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 Final @ should be \@ or @name
-(F) You must now decide whether the final @ in a string was meant to be
-a literal "at" 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.
+(F) You must now decide whether the final @ in a string was meant to be
+a literal "at" 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 logic flow. flock() operates on
+filehandles. Are you attempting to call flock() on a dirhandle by the
+same name?
+
+=item ?+* follows nothing in regexp
+
+(F) You started a regular expression with a quantifier. Backslash it if
+you meant it literally. See L<perlre>.
+
+=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) You redefined a format. To suppress this warning, say
+(W redefine) You redefined a format. To suppress this warning, say
{
- no warning;
+ no warnings;
eval "format 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 Found = in conditional, should be ==
-(W) You said
+(W syntax) You said
if ($foo = 123)
(or something like that).
+=item %s found where operator expected
+
+(S) 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.
because if it did, it'd feel morally obligated to return every hostname
on the Internet.
-=item get{sock,peer}name() on closed fd
+=item get%sname() on closed socket %s
-(W) 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?
+(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 Glob not terminated
+=item getsockopt() on closed socket %s
-(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".
+(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 vars", which indicates that all variables
-must either be lexically scoped (using "my"), or explicitly qualified to
-say which package the global variable is in (using "::").
+must either be lexically scoped (using "my"), declared beforehand using
+"our", or explicitly qualified to say which package the global variable
+is in (using "::").
+
+=item glob failed (%s)
+
+(W 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 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 %s had compilation errors
+
+(F) The final summary message when a C<perl -c> fails.
+
=item Had to create %s unexpectedly
-(S) 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.
+(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) Really old Perl let you omit the % on hash names in some spots. This
-is now heavily deprecated.
+(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 Hexadecimal number > 0xffffffff non-portable
-(W) The hexadecimal number you specified is larger than 2**32-1
+(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.
(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.
+names (like C<$A::B>). You've exceeded Perl's limits. Future versions
+of Perl are likely to eliminate these arbitrary limitations.
-=item Ill-formed CRTL environ value "%s"
+=item Illegal binary digit %s
-(W) 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 spearate keys from values. The element is ignored.
+(F) You used a digit other than 0 or 1 in a binary number.
-=item Ill-formed message in prime_env_iter: |%s|
+=item Illegal binary digit %s ignored
-(W) 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.
+(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 %s (carriage return)
-(F) A carriage return character was found in the input. This is an
-error, and not a warning, because carriage return characters can break
-multi-line strings, including here documents (e.g., C<print E<lt>E<lt>EOF;>).
+(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.
-Under Unix, this error is usually caused by executing Perl code --
-either the main program, a module, or an eval'd string -- that was
-transferred over a network connection from a non-Unix system without
-properly converting the text file format.
-
-Under systems that use something other than '\n' to delimit lines of
-text, this error can also be caused by reading Perl code from a file
-handle that is in binary mode (as set by the C<binmode> operator).
+=item Illegal division by zero
-In either case, the Perl code in question will probably need to be
-converted with something like C<s/\x0D\x0A?/\n/g> before it can be
-executed.
+(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 division by zero
+=item Illegal hexadecimal digit %s ignored
-(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.
+(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.
+(F) You tried to divide a number by 0 to get the remainder. Most
+numbers don't take to this kindly.
-=item Illegal binary digit %s
+=item Illegal number of bits in vec
-(F) You used a digit other than 0 and 1 in a binary number.
+(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 a octal number.
-=item Illegal binary digit %s ignored
-
-(W) 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 octal digit %s ignored
-(W) You may have tried to use an 8 or 9 in a octal number. Interpretation
-of the octal number stopped before the 8 or 9.
-
-=item Illegal hexadecimal digit %s ignored
-
-(W) 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.
+(W digit) You may have tried to use an 8 or 9 in a octal number.
+Interpretation of the octal number stopped before the 8 or 9.
=item Illegal switch in PERL5OPT: %s
(X) The PERL5OPT environment variable may only be used to set the
following switches: B<-[DIMUdmw]>.
-=item In string, @%s now must be written as \@%s
+=item Ill-formed CRTL environ value "%s"
-(F) It used to be that Perl would try to guess whether you wanted an
-array interpolated or a literal @. It did this when the string was first
-used at runtime. Now strings are parsed at compile time, and ambiguous
-instances of @ must be disambiguated, either by prepending a backslash to
-indicate a literal, or by declaring (or using) the array within the
-program before the string (lexically). (Someday it will simply assume
-that an unbackslashed @ interpolates an array.)
+(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 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.
+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.
-See L<perlsec>.
+(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. See L<perlsec>.
=item Insecure $ENV{%s} while running %s
potentially supplied) by the user. The script must set the path to a
known value, using trustworthy data. See L<perlsec>.
+=item In string, @%s now must be written as \@%s
+
+(F) It used to be that Perl would try to guess whether you wanted an
+array interpolated or a literal @. It did this when the string was
+first used at runtime. Now strings are parsed at compile time, and
+ambiguous instances of @ must be disambiguated, either by prepending a
+backslash to indicate a literal, or by declaring (or using) the array
+within the program before the string (lexically). (Someday it will
+simply assume that an unbackslashed @ interpolates an array.)
+
=item Integer overflow in %s number
-(W) The hexadecimal, octal or binary number you have specified either
-as a literal in your code or as a scalar 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
+(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 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 disaster in regexp
(P) Something went badly wrong in the regular expression parser.
-=item glob failed (%s)
+=item Internal inconsistency in tracking vforks
-(W) Something went wrong with the external program(s) used for C<glob>
-and C<E<lt>*.cE<gt>>. 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.
+(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 regexp at /%s/
(P) Something went badly awry in the regular expression parser.
-=item invalid [] range in regexp
+=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
+
+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
+
+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 [] range "%s" in regexp
(F) The range specified in a character class had a minimum character
greater than the maximum character. See L<perlre>.
-=item Invalid conversion in %s: "%s"
+=item Invalid separator character %s in attribute list
-(W) Perl does not understand the given format conversion.
-See L<perlfunc/sprintf>.
+(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 type in pack: '%s'
(F) The given character is not a valid pack type. See L<perlfunc/pack>.
-(W) The given character is not a valid pack type but used to be silently
-ignored.
+(W pack) The given character is not a valid pack type but used to be
+silently ignored.
=item Invalid type in unpack: '%s'
-(F) The given character is not a valid unpack type. See L<perlfunc/unpack>.
-(W) The given character is not a valid unpack type but used to be silently
-ignored.
+(F) The given character is not a valid unpack type. See
+L<perlfunc/unpack>.
+(W unpack) The given character is not a valid unpack type but used to be
+silently ignored.
=item ioctl is not implemented
=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.
+(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) While under the C<use filetest> pragma, switching the real and
effective uids or gids failed.
-=item listen() on closed fd
+=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 Lvalue subs returning %s not implemented yet
+
+(F) Due to limitations in the current implementation, array and hash
+values cannot be returned in subroutines used in lvalue context. See
+L<perlsub/"Lvalue subroutines">.
+
+=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 F<README.os2>.
+
+=item %s matches null string many times
+
+(W regexp) The pattern you've specified would be an infinite loop if the
+regular expression engine didn't specifically check for that. See
+L<perlre>.
+
+=item % may only be used in unpack
-(W) 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>.
+(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
=item Misplaced _ in number
-(W) An underline in a decimal constant wasn't on a 3-digit boundary.
-
-=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.
+(W syntax) An underline in a decimal constant wasn't on a 3-digit boundary.
-=item Missing %sbrace%s on \C{}
+=item Missing %sbrace%s on \N{}
-(F) Wrong syntax of character name literal C<\C{charname}> within
+(F) Wrong syntax of character name literal C<\N{charname}> within
double-quotish context.
=item Missing comma after first argument to %s function
=item Missing command in piped open
-(W) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
-construction, but the command was missing or blank.
+(W pipe) You used the C<open(FH, "| command")> or
+C<open(FH, "command |")> construction, but the command was missing or
+blank.
-=item Missing operator before %s?
+=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) 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 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.
+(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) 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
=item Modification of non-creatable hash value attempted, subscript "%s"
-(P) You tried to make a hash value spring into existence, and it couldn't
-be created for some peculiar reason.
+(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 -M option
+
+(F) The C<-M> option says that Perl should load some module, but you
+omitted the name of the module. Consult L<perlrun> for full details
+about C<-M>.
+
=item msg%s not implemented
(F) You don't have System V message IPC on your system.
=item Multidimensional syntax %s not supported
-(W) Multidimensional arrays aren't written like C<$foo[1,2,3]>. They're written
-like C<$foo[1][2][3]>, as in C.
+(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 be followed by a*, A* or Z*
+
+(F) You had a pack template indicating a counted-length string,
+Currently the only things that can have their length counted are a*, A*
+or Z*. See L<perlfunc/pack>.
+
+=item / must be followed by a, A or Z
+
+(F) You had an unpack template indicating a counted-length string, which
+must be followed by one of the letters a, A or Z to indicate what sort
+of string is to be unpacked. See L<perlfunc/pack>.
+
+=item / must follow a numeric type
+
+(F) You had an unpack template that contained a '#', but this did not
+follow some numeric unpack specification. 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) 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<use vars> pragma is
-provided for just this purpose.
+(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.
=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.
+(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 nested *?+ in regexp
(F) You can't quantify a quantifier without intervening parentheses. So
things like ** or +* or ?* are illegal.
-Note, however, that the minimal matching quantifiers, C<*?>, C<+?>, and C<??> appear
-to be nested quantifiers, but aren't. See L<perlre>.
+Note, however, that the minimal matching quantifiers, C<*?>, C<+?>, and
+
C<??> appear to be nested quantifiers, but aren't. See L<perlre>.
-=item No #! line
+=item %s never introduced
-(F) The setuid emulator requires that scripts have a well-formed #! line
-even on machines that don't support the #! construct.
+(S internal) The symbol in question was declared but somehow went out of
+scope before it could possibly have been used.
=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>.
+(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 B<-e> allowed in setuid scripts
=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.
+(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 perl5db.pl file (or some facsimile thereof)
-didn't define a routine to be called at the beginning of each
-statement. Which is odd, because the file should have been required
-automatically, and should have blown up the require if it didn't parse
-right.
+(F) The currently executing code was compiled with the B<-d> switch, but
+for some reason the perl5db.pl file (or some facsimile thereof) didn't
+define a routine to be called at the beginning of each statement. Which
+is odd, because the file should have been required automatically, and
+should have blown up the require if it didn't parse right.
=item No dbm on this machine
didn't define a DB::sub routine to be called at the beginning of each
ordinary subroutine call.
-=item No error file after 2E<gt> or 2E<gt>E<gt> on command line
+=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 input file after < on command line
-(F) An error peculiar to VMS. Perl handles its own command line redirection,
-and found a '2E<gt>' or a '2E<gt>E<gt>' on the command line, but can't find
-the name of the file to which to write data destined for stderr.
+(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 input file after E<lt> on command line
+=item No #! line
+
+(F) The setuid emulator requires that scripts have a well-formed #! line
+even on machines that don't support the #! construct.
+
+=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 'E<lt>' on the command line, but can't find the name of the file
-from which to read data for stdin.
+(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 E<gt> on command line
+=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 lone 'E<gt>' at the end of the command line, so it doesn't know
-where you wanted to redirect stdout.
+(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 output file after E<gt> or E<gt>E<gt> on command line
+=item No package name allowed for variable %s in "our"
-(F) An error peculiar to VMS. Perl handles its own command line redirection,
-and found a 'E<gt>' or a 'E<gt>E<gt>' on the command line, but can't find the
-name of the file to which to write data destined for stdout.
+(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) Configure didn't find anything resembling the setreuid() call for
your system.
-=item No space allowed after B<-I>
+=item No space allowed after -%c
-(F) The argument to B<-I> must follow the B<-I> immediately with no
-intervening space.
+(F) The argument to the indicated command line switch must follow
+immediately after the switch, without intervening spaces.
-=item No such array field
+=item No %s specified for -%c
-(F) You tried to access an array as a hash, but the field name used is
-not defined. The hash at index 0 should map all valid field names to
-array indices for that to work.
-
-=item No such field "%s" in variable %s of type %s
-
-(F) You tried to access a field of a typed variable where the type
-does not know about the field name. The field names are looked up in
-the %FIELDS hash in the type package at compile time. The %FIELDS hash
-is usually set up with the 'fields' pragma.
+(F) The indicated command line switch needs a mandatory argument, but
+you haven't specified one.
=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.
+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
+=item No such pseudo-hash field "%s"
+
+(F) You tried to access an array as a hash, but the field name used is
+not defined. The hash at index 0 should map all valid field names to
+array indices for that to work.
-(W) 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 No such pseudo-hash field "%s" in variable %s of type %s
-=item no UTC offset information; assuming local time is UTC
+(F) You tried to access a field of a typed variable where the type does
+not know about the field name. The field names are looked up in the
+%FIELDS hash in the type package at compile time. The %FIELDS hash is
+%usually set up with the 'fields' pragma.
-(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 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.
+use the ref() function to find out what kind of ref it really was. See
+also L<perlref>.
=item Not a format reference
=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>.
+(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>.
+(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 a perl script
=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>.
+(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.
+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 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 enough arguments for %s
(F) The function requires more arguments than you specified.
=item Not enough format arguments
-(W) A format specified more picture fields than the next line supplied.
-See L<perlform>.
+(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 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>.
+(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
+
+(P debugging) Some internal routine called run() with a null opcode
+pointer.
=item Null picture in formline
specification. It was found to be empty, which probably means you
supplied it an uninitialized value. See L<perlform>.
-=item NULL OP IN RUN
-
-(P) Some internal routine called run() with a null opcode pointer.
-
=item Null realloc
(P) An attempt was made to realloc NULL.
=item Number too long
-(F) Perl limits the representation of decimal numbers in programs to about
-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").
+(F) Perl limits the representation of decimal numbers in programs to
+about 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 Octal number in vector unsupported
+
+(F) Numbers with a leading C<0> are not currently allowed in vectors.
+The octal number interpretation of such numbers may be supported in a
+future version.
=item Octal number > 037777777777 non-portable
-(W) 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.
+(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.
See also L<perlport> for writing portable code.
=item Odd number of elements in hash assignment
-(S) You specified an odd number of elements to initialize a hash, which
-is odd, because hashes come in key/value pairs.
+(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) You tried to do a read/write/send/recv operation with an offset
-pointing outside the buffer. This is difficult to imagine.
-The sole exception to this is that C<sysread()>ing past the buffer
-will extend the buffer and zero pad the new area.
+pointing outside the buffer. This is difficult to imagine. The sole
+exception to this is that C<sysread()>ing past the buffer will extend
+the buffer and zero pad the new area.
=item oops: oopsAV
-(S) An internal warning that the grammar is screwed up.
+(S internal) An internal warning that the grammar is screwed up.
=item oops: oopsHV
-(S) An internal warning that the grammar is screwed up.
+(S internal) An internal warning that the grammar is screwed up.
=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 C<fallback> overloading key is specified to be
-true. See L<overload>.
+(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
+C<fallback> overloading key is specified to be true. See L<overload>.
=item Operator or semicolon missing before %s
-(S) 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 Out of memory for yacc stack
+(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'".
-(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 "our" variable %s redeclared
-=item Out of memory during request for %s
+(W misc) You seem to have already declared the same global once before
+in the current lexical scope.
-(X|F) The malloc() function returned 0, indicating there was insufficient
-remaining memory (or virtual memory) to satisfy the request.
+=item Out of memory!
-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>.
+(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.
=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.
+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>.
=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]>.
+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
+
+(F) You had a pack template that specified an absolute position outside
+the string being unpacked. See L<perlfunc/pack>.
+
+=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 page overflow
-(W) A single call to write() produced more lines than can fit on a page.
-See L<perlform>.
+(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: ck_grep
=item panic: corrupt saved stack index
-(P) The savestack was requested to restore more localized values than there
-are in the savestack.
+(P) The savestack was requested to restore more localized values than
+there are in the savestack.
=item panic: del_backref
=item panic: do_match
-(P) The internal pp_match() routine was called with invalid operational data.
+(P) The internal pp_match() routine was called with invalid operational
+data.
=item panic: do_split
=item panic: do_subst
-(P) The internal pp_subst() routine was called with invalid operational data.
+(P) The internal pp_subst() routine was called with invalid operational
+data.
=item panic: do_trans
-(P) The internal do_trans() routine was called with invalid operational data.
+(P) The internal do_trans() routine was called with invalid operational
+data.
=item panic: frexp
=item panic: leave_scope clearsv
-(P) A writable lexical variable became read-only somehow within the scope.
+(P) A writable lexical variable became read-only somehow within the
+scope.
=item panic: leave_scope inconsistency
(P) The savestack probably got out of sync. At least, there was an
invalid enum on the top of it.
-=item panic: malloc
-
-(P) Something requested a negative number of bytes of malloc.
-
=item panic: magic_killbackrefs
(P) Failed an internal consistency check while trying to reset all weak
references to an object.
+=item panic: malloc
+
+(P) Something requested a negative number of bytes of malloc.
+
=item panic: mapstart
(P) The compiler is screwed up with respect to the map() function.
=item Parentheses missing around "%s" list
-(W) You said something like
+(W parenthesis) You said something like
my $foo, $bar = @_;
my ($foo, $bar) = @_;
-Remember that "my" and "local" bind closer than comma.
+Remember that "my", "our", and "local" bind tighter than comma.
+
+=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 %3.3f required--this is only version %s, stopped
+=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 F<README.os2>.
+
+=item perl: warning: Setting locale failed.
+
+(S) The whole warning message will look something like:
-(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>.
+ 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 system
+administrator have set up the so-called variable 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, 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 Permission denied
=item pid %x not a child
-(W) 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.
+(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 POSIX getpgrp can't take an argument
-(F) Your C compiler uses POSIX getpgrp(), which takes no argument, unlike
+(F) Your system has POSIX getpgrp(), which takes no argument, unlike
the BSD version, which takes a pid.
=item Possible attempt to put comments in qw() list
-(W) 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
+(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:
=item Possible attempt to separate words with commas
-(W) 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.)
+(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:
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 Y2K bug: %s
+
+(W y2k) You are concatenating the number 19 with another number, which
+could be a potential Year 2000 problem.
+
+=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
+
+(W deprecated) You have written something like this:
+
+ sub doit
+ {
+ use attrs qw(locked);
+ }
+
+You should use the new declaration syntax instead.
+
+ sub doit : locked
+ {
+ ...
+
+The C<use attrs> pragma is now obsolete, and is only provided for
+backward-compatibility. See L<perlsub/"Subroutine Attributes">.
+
=item Precedence problem: open %s should be open(%s)
-(S) The old irregular construct
+(S precedence) The old irregular construct
open FOO || die;
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 "||".
+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
-=item print on closed filehandle %s
+See Server error.
-(W) The filehandle you're printing on got itself closed sometime before now.
-Check your logic flow.
+=item printf() on closed filehandle %s
-=item printf on closed filehandle %s
+(W closed) The filehandle you're writing to got itself closed sometime
+before now. Check your logic flow.
-(W) The filehandle you're writing to got itself closed sometime before now.
-Check your logic flow.
+=item print() on closed filehandle %s
-=item Probable precedence problem on %s
+(W closed) The filehandle you're printing on got itself closed sometime
+before now. Check your logic flow.
-(W) 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:
+=item Process terminated by SIG%s
- open FOO || die;
+(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 F<README.os2>.
=item Prototype mismatch: %s vs %s
-(S) The subroutine being declared or defined had previously been declared
-or defined with a different function prototype.
+(S unsafe) The subroutine being declared or defined had previously been
+declared or defined with a different function prototype.
=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.
+One possible workaround is to force Perl to use magical string increment
+by prepending "0" to your numbers.
-=item Read on closed filehandle %s
+=item readline() on closed filehandle %s
-(W) The filehandle you're reading from got itself closed sometime before now.
-Check your logic flow.
+(W closed) The filehandle you're reading from got itself closed sometime
+before now. Check your logic flow.
=item Reallocation too large: %lx
(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) You can't use the B<-D> option unless the code to produce the
-desired output is compiled into Perl, which entails some overhead,
+(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 inheritance detected in package '%s'
=item Recursive inheritance detected while looking for method '%s' in package '%s'
-(F) More than 100 levels of inheritance were encountered while invoking a
-method. Probably indicates an unintended loop in your inheritance hierarchy.
+(F) More than 100 levels of inheritance were encountered while invoking
+a method. Probably indicates an unintended loop in your inheritance
+hierarchy.
=item Reference found where even-sized list expected
-(W) 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>.
+(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
=item Reference is already weak
-(W) You have attempted to weaken a reference that is already weak.
+(W misc) You have attempted to weaken a reference that is already weak.
Doing so has no effect.
=item Reference miscount in sv_replace()
-(W) The internal sv_replace() function was handed a new SV with a
-reference count of other than 1.
-
-=item regexp *+ operand could be empty
-
-(F) The part of the regexp subject to either the * or + quantifier
-could match an empty string.
+(W internal) The internal sv_replace() function was handed a new SV with
+a reference count of other than 1.
=item regexp memory corruption
(P) The regular expression engine got confused by what the regular
expression compiler gave it.
+=item regexp *+ operand could be empty
+
+(F) The part of the regexp subject to either the * or + quantifier could
+match an empty string.
+
=item regexp out of space
-(P) A "can't happen" error, because safemalloc() should have caught it earlier.
+(P) A "can't happen" error, because safemalloc() should have caught it
+earlier.
+
+=item Repeat count in pack overflows
+
+(F) You can't specify a repeat count so large that it overflows your
+signed integers. See L<perlfunc/pack>.
+
+=item Repeat count in unpack overflows
+
+(F) You can't specify a repeat count so large that it overflows your
+signed integers. See L<perlfunc/unpack>.
=item Reversed %s= operator
-(W) You wrote your assignment operator backwards. The = must always
-comes last, to avoid ambiguity with subsequent unary operators.
+(W syntax) You wrote your assignment operator backwards. The = must
+always comes last, to avoid ambiguity with subsequent unary operators.
=item Runaway format
=item Scalar value @%s[%s] better written as $%s[%s]
-(W) 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.
+(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
=item Scalar value @%s{%s} better written as $%s{%s}
-(W) 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
+(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 Script is not setuid/setgid in suidperl
=item %sseek() on unopened file
-(W) You tried to use the seek() or sysseek() function on a filehandle that
-was either never opened or has since been closed.
+(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 sem%s not implemented
+=item Semicolon seems to be missing
-(F) You don't have System V semaphore IPC on your system.
+(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) The internal newSVsv() routine was called to duplicate a scalar
-that had previously been marked as free.
+(S internal) The internal newSVsv() routine was called to duplicate a
+scalar that had previously been marked as free.
-=item Semicolon seems to be missing
+=item sem%s not implemented
-(W) A nearby syntax error was probably caused by a missing semicolon,
-or possibly some other missing operator, such as a comma.
+(F) You don't have System V semaphore IPC on your system.
-=item Send on closed socket
+=item send() on closed socket %s
-(W) The filehandle you're sending to got itself closed sometime before now.
-Check your logic flow.
+(W closed) The socket you're sending to got itself closed sometime
+before now. Check your logic flow.
=item Sequence (? incomplete
-(F) A regular expression ended with an incomplete extension (?.
-See L<perlre>.
-
-=item Sequence (?#... not terminated
-
-(F) A regular expression comment must be terminated by a closing
-parenthesis. Embedded parentheses aren't allowed. See L<perlre>.
+(F) A regular expression ended with an incomplete extension (?. See
+L<perlre>.
=item Sequence (?%s...) not implemented
(F) You used a regular expression extension that doesn't make sense.
See L<perlre>.
+=item Sequence (?#... not terminated
+
+(F) A regular expression comment must be terminated by a closing
+parenthesis. Embedded parentheses aren't allowed. See L<perlre>.
+
+=item 500 Server error
+
+See Server error.
+
=item Server error
-Also known as "500 Server error".
+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:
+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.com/CPAN/doc/FAQs/cgi/idiots-guide.html
http://www.perl.com/CPAN/doc/FAQs/cgi/perl-cgi-faq.html
=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.
+(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<$E<gt>>, and your operating system doesn't support
-the seteuid() system call (or equivalent), or at least Configure didn't
-think so.
+(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.
+(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<$E<lt>>, and your operating system doesn't support
-the setruid() system call (or equivalent), or at least Configure didn't
-think so.
+(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 Setuid/gid script is writable by world
-(F) The setuid emulator won't run a script that is writable by the world,
-because the world might have written on it already.
+(F) The setuid emulator won't run a script that is writable by the
+world, because the world might have written on it already.
=item shm%s not implemented
(F) You don't have System V shared memory IPC on your system.
-=item shutdown() on closed fd
+=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.
-(W) You tried to do a shutdown on a closed socket. Seems a bit superfluous.
+=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) The signal handler named in %SIG doesn't, in fact, exist. Perhaps you
-put it into the wrong package?
+(W signal) The signal handler named in %SIG doesn't, in fact, exist.
+Perhaps you put it into the wrong package?
=item sort is now a reserved word
=item Sort subroutine didn't return a numeric value
(F) A sort comparison routine must return a number. You probably blew
-it by not using C<E<lt>=E<gt>> or C<cmp>, or by not using them correctly.
+it by not using C<< <=> >> or C<cmp>, or by not using them correctly.
See L<perlfunc/sort>.
=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 split /^/ better written as split /^/m
-
-(W) Implicit translation of /^/ to mean /^/m in split is deprecated.
-
=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>.
+(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 Stat on unopened file E<lt>%sE<gt>
+=item Statement unlikely to be reached
-(W) You tried to use the stat() function (or an equivalent file test)
-on a filehandle that was either never opened or has since been closed.
+(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 Statement unlikely to be reached
+=item Stat on unopened file <%s>
-(W) 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.
+(W unopened) You tried to use the stat() function (or an equivalent file
+test) on a filehandle that was either never opened or has since been
+closed.
=item Strange *+?{} on zero-length expression
-(W) 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}/>.
+(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}/>.
=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 implicitely created, but explicit calls to C<can>
-may break this.
+(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) You redefined a subroutine. To suppress this warning, say
+(W redefine) You redefined a subroutine. To suppress this warning, say
{
- no warning;
+ no warnings;
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
+(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/"Quote and Quote-like Operators">.
=item Substitution pattern not terminated
=item substr outside of string
-(S),(W) 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
-mandatory if substr is used in an lvalue context (as the left hand side
-of an assignment or as a subroutine argument for example).
+(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 suidperl is no longer needed since %s
-(F) Your Perl was compiled with B<-D>SETUID_SCRIPTS_ARE_SECURE_NOW, but a
-version of the setuid emulator somehow got run anyway.
+(F) Your Perl was compiled with B<-D>SETUID_SCRIPTS_ARE_SECURE_NOW, but
+a version of the setuid emulator somehow got run anyway.
=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.
+(F) While under the C<use filetest> pragma, we cannot switch the real
+and effective uids or gids.
=item syntax error
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>.
+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.
+(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 %s syntax OK
+
+(F) The final summary message when a C<perl -c> succeeds.
=item System V %s is not implemented on this machine
machine. In some machines the functionality can exist but be
unconfigured. Consult your system support.
-=item Syswrite on closed filehandle
+=item syswrite() on closed filehandle %s
-(W) The filehandle you're writing to got itself closed sometime before now.
-Check your logic flow.
+(W closed) The filehandle you're writing to got itself closed sometime
+before now. Check your logic flow.
=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.
+(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 tell() on unopened file
-(W) You tried to use the tell() function on a filehandle that was either
-never opened or has since been closed.
+(W unopened) You tried to use the tell() function on a filehandle that
+was either never opened or has since been closed.
-=item Test on unopened file E<lt>%sE<gt>
+=item Test on unopened file <%s>
-(W) You tried to invoke a file test operator on a filehandle that isn't
-open. Check your logic. See also L<perlfunc/-X>.
+(W unopened) You tried to invoke a file test operator on a filehandle
+
that isn't open. Check your logic. See also L<perlfunc/-X>.
=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
+(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
+as a compiler directive. You may say only one of
$[ = 0;
$[ = 1;
local $[ = 1;
...
-This is to prevent the problem of one module changing the array base
-out from under another module inadvertently. See L<perlvar/$[>.
-
-=item The %s function is unimplemented
-
-The function indicated isn't implemented on this architecture, according
-to the probings of Configure.
+This is to prevent the problem of one module changing the array base out
+from under another module inadvertently. See L<perlvar/$[>.
=item The crypt() function is unimplemented due to excessive paranoia
will continue to pretend that it is. And if you quote me on that, I
will deny it.
+=item The %s function is unimplemented
+
+The function indicated isn't implemented on this architecture, according
+to the probings of Configure.
+
=item The stat preceding C<-l _> 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.
+(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 This Perl can't reset CRTL eviron elements (%s)
+=item This Perl can't reset CRTL environ elements (%s)
=item This Perl can't set CRTL environ elements (%s=%s)
-(W) 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
+(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 times not implemented
-(F) Your version of the C library apparently doesn't do times(). I suspect
-you're not running on Unix.
+(F) Your version of the C library apparently doesn't do times(). I
+suspect you're not running on Unix.
=item Too few args to syscall
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<-T> option is a part of Perl's
-
first argument: e.g. change C<perl -n -T> to C<perl -T -n>.
+mechanism (or its local equivalent), this error can usually be fixed by
+editing the #! line so that the B<-T> option is a part of Perl's first
+argument: e.g. change C<perl -n -T> to C<perl -T -n>.
If the Perl script is being executed as C<perl scriptname>, then the
B<-T> option must appear on the command line: C<perl -T scriptname>.
B<-M> or B<-m> option. This is an error because B<-M> and B<-m> options
are not intended for use inside scripts. Use the C<use> pragma instead.
-=item Too many ('s
-
-=item Too many )'s
+=item Too late to run %s block
-(A) You've accidentally run your script through B<csh> instead
-of Perl. Check the #! line, or manually feed your script into
-Perl yourself.
+(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) 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
+
=item trailing \ in regexp
-(F) The regular expression ends with an unbackslashed backslash. Backslash
-it. See L<perlre>.
+(F) The regular expression ends with an unbackslashed backslash.
+
Backslash it. See L<perlre>.
=item Transliteration pattern not terminated
=item umask: argument is missing initial 0
-(W) A umask of 222 is incorrect. It should be 0222, because octal
+(W umask) A umask of 222 is incorrect. It should be 0222, because octal
literals always start with 0 in Perl, as in C.
=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).
+(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"
=item Unbalanced context: %d more PUSHes than POPs
-(W) The exit code detected an internal inconsistency in how many execution
-contexts were entered and left.
+(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) The exit code detected an internal inconsistency in how many
-values were temporarily localized.
+(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) The exit code detected an internal inconsistency in how many blocks
-were entered and left.
+(W internal) The exit code detected an internal inconsistency in how
+many blocks were entered and left.
=item Unbalanced tmps: %d more allocs than frees
-(W) The exit code detected an internal inconsistency in how many mortal
-scalars were allocated and freed.
+(W internal) The exit code detected an internal inconsistency in how
+many mortal scalars were allocated and freed.
=item Undefined format "%s" called
=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>.
+(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.
+(F) The subroutine indicated hasn't been defined, or if it was, it has
+since been undefined.
=item Undefined subroutine called
=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>.
+(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
=item Undefined value assigned to typeglob
-(W) 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>.
+(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!
=item Unknown BYTEORDER
-(F) There are no byte-swapping functions for a machine with this byte order.
+(F) There are no byte-swapping functions for a machine with this byte
+order.
=item Unknown open() mode '%s'
-(F) The second argument of 3-arguments open is not one from the list
-of C<L<lt>>, C<L<gt>>, C<E<gt>E<gt>>, C<+L<lt>>, C<+L<gt>>,
-C<+E<gt>E<gt>>, C<-|>, C<|-> of possible open() modes.
+(F) The second argument of 3-argument open() is not among the list
+of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
+C<< +> >>, C<<< +>> >>>, C<-|>, C<|->.
=item Unknown process %x sent message to prime_env_iter: %s
data Perl expected. Someone's very confused, or perhaps trying to
subvert Perl's population of %ENV for nefarious purposes.
+=item unmatched [] in regexp
+
+(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. See L<perlre>.
+
=item unmatched () in regexp
(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. See L<perlre>.
+expressions. If you're a vi user, the % key is valuable for finding the
+matching parenthesis. 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 unmatched [] in regexp
-
-(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.
-See L<perlre>.
+(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) 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.
+(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
in your Perl script (or eval). Perhaps you tried to run a compressed
script, a binary program, or a directory as a Perl program.
+=item /%s/: Unrecognized escape \\%c in character class passed through
+
+(W regexp) You used a backslash-character combination which is not
+recognized by Perl inside character classes. The character was
+understood literally.
+
+=item /%s/: Unrecognized escape \\%c passed through
+
+(W regexp) You used a backslash-character combination which is not
+recognized by Perl. This combination appears in an interpolated
+variable or a C<'>-delimited regular expression. The character was
+understood literally.
+
=item Unrecognized escape \\%c passed through
-(W) You used a backslash-character combination which is not recognized
-by Perl.
+(W misc) You used a backslash-character combination which is not
+recognized by Perl.
=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.
+(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.)
+(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) A file operation was attempted on a filename, and that operation
-failed, PROBABLY because the filename contained a newline, PROBABLY
-because you forgot to chop() or chomp() it off. See L<perlfunc/chomp>.
+(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 chop() or 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 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 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 socket function "%s" called
(F) Your machine doesn't support the Berkeley socket mechanism, or at
least that's what Configure thought.
-=item Unterminated E<lt>E<gt> operator
+=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 <> 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".
+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 Use of $# is deprecated
+=item untie attempted while %d inner references still exist
-(D) This was an ill-advised attempt to emulate a poorly defined B<awk> feature.
-Use an explicit printf() or sprintf() instead.
+(W untie) A copy of the object returned from C<tie> (or C<tied>) was
+still valid when C<untie> was called.
-=item Use of $* is deprecated
+=item Useless use of %s in void context
-(D) This variable magically turned on multi-line pattern matching, both for
-you and for any luckless subroutine that you happen to call. You should
-use the new C<//m> and C<//s> modifiers now to do that without the dangerous
-action-at-a-distance effects of C<$*>.
+(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
-=item Use of %s in printf format not supported
+ $one, $two = 1, 2;
-(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.
+when you meant to say
+
+ ($one, $two) = (1, 2);
-=item Use of bare E<lt>E<lt> to mean E<lt>E<lt>"" is deprecated
+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
-(D) 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.
+ $array = (1,2);
-=item Use of implicit split to @_ is deprecated
+when you should have said
-(D) It makes a lot of work for the compiler when you clobber a
-subroutine's argument list, so it's better if you assign the results of
-a split() explicitly to an array (or list).
+ $array = [1,2];
-=item Use of inherited AUTOLOAD for non-method %s() is deprecated
+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.
-(D) 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-E<gt>bar()> or C<$obj-E<gt>bar()>).
+=item Useless use of "re" pragma
-This bug will be rectified in Perl 5.005, which will use 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 5.004 issues an optional warning when non-methods
-use inherited C<AUTOLOAD>s.
+(W) You did C<use re;> without any arguments. That isn't very useful.
-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.
+=item "use" not allowed in expression
-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';>.
+(F) The "use" keyword is recognized and executed at compile time, and
+returns no useful value. See L<perlmod>.
-=item Use of reserved word "%s" is deprecated
+=item Use of bare << to mean <<"" is deprecated
-(D) 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()>.
+(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 %s is deprecated
+=item Use of implicit split to @_ is deprecated
-(D) 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.
+(D deprecated) It makes a lot of work for the compiler when you clobber
+a subroutine's argument list, so it's better if you assign the results
+of a split() explicitly to an array (or list).
-=item Use of uninitialized value
+=item Use of inherited AUTOLOAD for non-method %s() is deprecated
-(W) 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.
+(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() >>).
-=item Useless use of "re" pragma
+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.
-(W) You did C<use re;> without any arguments. That isn't very useful.
+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.
-=item Useless use of %s in void context
+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';>.
-(W) 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
+=item Use of %s in printf format not supported
- $one, $two = 1, 2;
+(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.
-when you meant to say
+=item Use of $* is deprecated
- ($one, $two) = (1, 2);
+(D deprecated) This variable magically turned on multi-line pattern
+matching, both for you and for any luckless subroutine that you happen
+to call. You should use the new C<//m> and C<//s> modifiers now to do
+that without the dangerous action-at-a-distance effects of C<$*>.
-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
+=item Use of %s is deprecated
- $array = (1,2);
+(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.
-when you should have said
+=item Use of $# is deprecated
- $array = [1,2];
+(D deprecated) This was an ill-advised attempt to emulate a poorly
+defined B<awk> feature. Use an explicit printf() or sprintf() instead.
-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.
+=item Use of reserved word "%s" is deprecated
-=item untie attempted while %d inner references still exist
+(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 uninitialized value%s
-(W) A copy of the object returned from C<tie> (or C<tied>) was still
-valid when C<untie> was called.
+(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 tells you what operation
+you used the undefined value in. Note, however, that perl optimizes your
+program and 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 Value of %s can be "0"; test with defined()
-(W) 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.
+(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) 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.
+(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 imported%s
-(F) While "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.
+(F) While "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 "%s" variable %s masks earlier declaration in same %s
+
+(W misc) A "my" or "our" 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 "%s" may be unavailable
-(W) An inner (nested) I<anonymous> subroutine is inside a I<named>
-subroutine, and outside that is another subroutine; and the anonymous
-(innermost) subroutine is referencing a lexical variable defined in
-the outermost subroutine. For example:
+(W closure) An inner (nested) I<anonymous> subroutine is inside a
+I<named> subroutine, and outside that is another subroutine; and the
+anonymous (innermost) subroutine is referencing a lexical variable
+defined in the outermost subroutine. For example:
sub outermost { my $a; sub middle { sub { $a } } }
If the anonymous subroutine is called or referenced (directly or
-indirectly) from the outermost subroutine, it will share the variable
-as you would expect. But if the anonymous subroutine is called or
-referenced when the outermost subroutine is not active, it will see
-the value of the shared variable as it was before and during the
-*first* call to the outermost subroutine, which is probably not what
-you want.
-
-In these circumstances, it is usually best to make the middle
-subroutine anonymous, using the C<sub {}> syntax. Perl has specific
-support for shared variables in nested anonymous subroutines; a named
-subroutine in between interferes with this feature.
+indirectly) from the outermost subroutine, it will share the variable as
+you would expect. But if the anonymous subroutine is called or
+referenced when the outermost subroutine is not active, it will see the
+value of the shared variable as it was before and during the *first*
+call to the outermost subroutine, which is probably not what you want.
+
+In these circumstances, it is usually best to make the middle subroutine
+anonymous, using the C<sub {}> syntax. Perl has specific support for
+shared variables in nested anonymous subroutines; a named subroutine in
+between interferes with this feature.
+
+=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) An inner (nested) I<named> subroutine is referencing a lexical
-variable defined in an outer subroutine.
+(W closure) An inner (nested) I<named> subroutine is referencing a
+lexical variable defined in an outer subroutine.
When the inner subroutine is called, it will probably 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.
+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.
Furthermore, if the outer subroutine is anonymous and references a
lexical variable outside itself, then the outer and inner subroutines
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 called or referenced,
-they are automatically rebound to the current values of such
-variables.
-
-=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 perl: warning: Setting locale failed.
+reference variables in outer subroutines are called or referenced, they
+are automatically rebound to the current values of such variables.
-(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").
+=item Version number must be a constant number
-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 system
-administrator have set up the so-called variable 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, 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>.
+(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 Warning: something's wrong
=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.
+(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) 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
+(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;
So put in parentheses to say what you really mean.
-=item Write on closed filehandle %s
+=item write() on closed filehandle %s
-(W) The filehandle you're writing to got itself closed sometime before now.
-Check your logic flow.
+(W closed) The filehandle you're writing to got itself closed sometime
+before now. Check your logic flow.
=item X outside of string
=item Xsub "%s" called in sort
-(F) The use of an external subroutine as a sort comparison is not yet supported.
+(F) The use of an external subroutine as a sort comparison is not yet
+supported.
=item Xsub called in sort
-(F) The use of an external subroutine as a sort comparison is not yet supported.
+(F) The use of an external subroutine as a sort comparison is not yet
+supported.
=item You can't use C<-l> on a filehandle
-(F) 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.
+(F) 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.
Use a filename instead.
=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 use the wrapsuid script in
-the eg directory to put a setuid C wrapper around your script.
+about what you want. Your best bet is to use the wrapsuid script in the
+eg directory to put a setuid C wrapper around your script.
=item You need to quote "%s"
-(W) 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 [gs]etsockopt() on closed fd
-
-(W) You tried to get or set a socket option on a closed socket.
-Did you forget to check the return value of your socket() call?
-See L<perlfunc/getsockopt>.
-
-=item \1 better written as $1
-
-(W) 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 '|' and 'E<lt>' 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
-'E<lt>'. Only one STDIN stream to a customer, please.
-
-=item '|' and 'E<gt>' 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 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 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 F<README.os2>.
-
-=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 F<README.os2>.
-
-=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 F<README.os2>.
+(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.)
=back
+=cut
https://perl5.git.perl.org / perl5.git / blobdiff