=item accept() on closed socket %s
-(W closed) You tried to do an accept on a closed socket. Did you forget to
-check the return value of your socket() call? See L<perlfunc/accept>.
+(W closed) You tried to do an accept on a closed socket. Did you forget
+to check the return value of your socket() call? See
+L<perlfunc/accept>.
=item Allocation too large: %lx
=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
(W ambiguous) A subroutine you have declared has the same name as a Perl
-keyword, and you have used the name without qualification for calling one or
-the other. Perl decided to call the builtin because the subroutine is not
-imported.
+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.
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>).
+to be an object method (see L<perlsub/"Subroutine Attributes"> or
+L<attributes>).
=item Ambiguous use of %s resolved as %s
=item '|' and '<' may not both be specified on command line
-(F) An error peculiar to VMS. Perl does its own command line redirection, and
-found that STDIN was a pipe, and that you also tried to redirect STDIN using
-'<'. Only one STDIN stream to a customer, please.
+(F) An error peculiar to VMS. Perl does its own command line
+redirection, and found that STDIN was a pipe, and that you also tried to
+redirect STDIN using '<'. Only one STDIN stream to a customer, please.
=item '|' and '>' may not both be specified on command line
-(F) An error peculiar to VMS. Perl does its own command line redirection, and
-thinks you tried to redirect stdout both to a file and into a pipe to another
-command. You need to choose one or the other, though nothing's stopping you
-from piping into a program or Perl script which 'splits' output into two
-streams, such as
+(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>) {
=item Applying %s to %s will act on scalar(%s)
-(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 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.
=item Args must match #! line
=item %s argument is not a HASH or ARRAY element or slice
-(F) The argument to delete() must be either a hash or array element, such as:
+(F) The argument to delete() must be either a hash or array element,
+such as:
$foo{$bar}
$ref->{"susie"}[12]
=item %s argument is not a subroutine name
(F) The argument to exists() for C<exists &sub> must be a subroutine
-name, and not a subroutine call. C<exists &sub()> will generate this error.
+name, and not a subroutine call. C<exists &sub()> will generate this
+error.
=item Argument "%s" isn't numeric%s
-(W numeric) The indicated string was fed as an argument to an operator that
-expected a numeric value instead. If you're fortunate the message will
-identify which operator was so unfortunate.
+(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()
=item Attempt to free non-arena SV: 0x%lx
-(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.
+(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 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.
+(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 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.
+(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
=item Attempt to free unreferenced scalar
-(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.
+(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 pack) You tried to pass a temporary value (like the result of a function,
-or a computed expression) to the "p" pack() template. This means the result
-contains a pointer to a location that could become invalid anytime, even
-before the end of the current statement. Use literals or global values as
-arguments to the "p" pack() template to avoid this warning.
+(W pack) You tried to pass a temporary value (like the result of a
+function, or a computed expression) to the "p" pack() template. This
+means the result contains a pointer to a location that could become
+invalid anytime, even before the end of the current statement. Use
+literals or global values as arguments to the "p" pack() template to
+avoid this warning.
=item Attempt to use reference as lvalue in substr
-(W substr) You supplied a reference as the first argument to substr() used as
-an lvalue, which is pretty strange. Perhaps you forgot to dereference it
-first. See L<perlfunc/substr>.
+(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 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 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.
+(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().
+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
=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;
=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.
+(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
=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
=item Bareword found in conditional
-(W bareword) The compiler found a bareword where it expected a conditional,
-which often indicates that an || or && was parsed as part of the last argument
-of the previous construct, for example:
+(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:
+It may also indicate a misspelled constant that has been interpreted as
+a bareword:
use constant TYPO => 1;
if (TYOP) { print "foo" }
=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 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?
+(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.
+(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
=item bind() on closed socket %s
-(W closed) You tried to do a bind on a closed socket. Did you forget to check
-the return value of your socket() call? See L<perlfunc/bind>.
+(W closed) You tried to do a bind on a closed socket. Did you forget to
+check the return value of your socket() call? See L<perlfunc/bind>.
=item Bit vector size > 32 non-portable
=item Bizarre copy of %s in %s
-(P) Perl detected an attempt to copy an internal value that is not copiable.
+(P) Perl detected an attempt to copy an internal value that is not
+copiable.
=item B<-P> not allowed for setuid/setgid script
=item Buffer overflow in prime_env_iter: %s
-(W internal) A warning peculiar to VMS. While Perl was preparing to iterate
-over %ENV, it encountered a logical name or symbol definition which was too
-long, so it was truncated to the string shown.
+(W internal) A warning peculiar to VMS. While Perl was preparing to
+iterate over %ENV, it encountered a logical name or symbol definition
+which was too long, so it was truncated to the string shown.
=item Callback called exit
=item %s() called too early to check prototype
-(W prototype) You've called a function that has a prototype before the parser
-saw a definition or declaration for it, and Perl could not check that the call
-conforms to the prototype. You need to either add an early prototype
-declaration for the subroutine in question, or move the subroutine definition
-ahead of the call to get proper prototype checking. Alternatively, if you are
-certain that you're calling the function correctly, you may put an ampersand
-before the name to avoid the warning. See L<perlsub>.
+(W prototype) You've called a function that has a prototype before the
+parser saw a definition or declaration for it, and Perl could not check
+that the call conforms to the prototype. You need to either add an
+early prototype declaration for the subroutine in question, or move the
+subroutine definition ahead of the call to get proper prototype
+checking. Alternatively, if you are certain that you're calling the
+function correctly, you may put an ampersand before the name to avoid
+the warning. See L<perlsub>.
=item / cannot take a count
-(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>.
+(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 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.
+(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"
=item Can't call method "%s" on an undefined value
(F) You used the syntax of a method call, but the slot filled by the
-object reference or package name contains an undefined value.
-Something like this will reproduce the error:
+object reference or package name contains an undefined value. Something
+like this will reproduce the error:
$BADREF = undef;
process $BADREF 1,2,3;
=item Can't call method "%s" on unblessed reference
(F) A method call must know in what package it's supposed to run. It
-ordinarily finds this out from the object reference you supply, but
-you didn't supply an object reference in this case. A reference isn't
-an object reference until it has been blessed. See L<perlobj>.
+ordinarily finds this out from the object reference you supply, but you
+didn't supply an object reference in this case. A reference isn't an
+object reference until it has been blessed. See L<perlobj>.
=item Can't call method "%s" without a package or object reference
(F) You used the syntax of a method call, but the slot filled by the
-object reference or package name contains an expression that returns
-a defined value which is neither an object reference nor a package name.
+object reference or package name contains an expression that returns a
+defined value which is neither an object reference nor a package name.
Something like this will reproduce the error:
$BADREF = 42;
=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
=item Can't create pipe mailbox
-(P) An error peculiar to VMS. The process is suffering from exhausted quotas
-or other plumbing problems.
+(P) An error peculiar to VMS. The process is suffering from exhausted
+quotas or other plumbing problems.
=item Can't declare class for non-scalar %s in "%s"
=item Can't do inplace edit: %s is not a regular file
-(S inplace) You tried to use the B<-i> switch on a special file, such as a file in
-/dev, or a FIFO. The file was ignored.
+(S inplace) You tried to use the B<-i> switch on a special file, such as
+a file in /dev, or a FIFO. The file was ignored.
=item Can't do inplace edit on %s: %s
-(S inplace) The creation of the new file failed for the indicated reason.
+(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 would not be unique
=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.
+(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 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.)
+(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 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>.
+(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>.
+(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 %s on PATH, '.' not in PATH
-(F) You used the B<-S> switch, but the script to execute could not be found
-in the PATH, or at least not with the correct permissions. The script
-exists in the current directory, but PATH prohibits running it.
+(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
=item Can't "goto" into the middle of a foreach loop
-(F) A "goto" statement was executed to jump into the middle of a
-foreach loop. You can't get there from here. See L<perlfunc/goto>.
+(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>.
+(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 goto subroutine outside a subroutine
-(F) The deeply magical "goto subroutine" call can only replace one subroutine
-call for another. It can't manufacture one out of whole cloth. In general
-you should be calling it out of only an AUTOLOAD routine anyway. See
-L<perlfunc/goto>.
+(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.
+(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>.
+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->{'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'}] >>.
+(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 localize through a reference
(F) You said something like C<local $$ref>, which Perl can't currently
handle, because when it goes to restore the old value of whatever $ref
-pointed to after the scope of the local() is finished, it can't be
-sure that $ref will still be a reference.
+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>.
+(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 syntax) 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
(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>.
+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 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 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.
+(W pipe) You tried to say C<open(CMD, "|cmd|")>, which is not supported.
+You can try any of several modules in the Perl library to do this, such
+as IPC::Open2. Alternately, direct the pipe's output to a file using
+">", and then read it in under a different file handle.
=item Can't open error file %s as stderr
-(F) An error peculiar to VMS. Perl does its own command line redirection, and
-couldn't open the file specified after '2>' or '2>>' on the
-command line for writing.
+(F) An error peculiar to VMS. Perl does its own command line
+redirection, and couldn't open the file specified after '2>' or '2>>' on
+the command line for writing.
=item Can't open input file %s as stdin
-(F) An error peculiar to VMS. Perl does its own command line redirection, and
-couldn't open the file specified after '<' on the command line for reading.
+(F) An error peculiar to VMS. Perl does its own command line
+redirection, and couldn't open the file specified after '<' on the
+command line for reading.
=item Can't open output file %s as stdout
-(F) An error peculiar to VMS. Perl does its own command line redirection, and
-couldn't open the file specified after '>' or '>>' on the command
-line for writing.
+(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
(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.
+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
=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.
+(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
=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.
+(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.
+(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
=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>.
+(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
=item Can't use %s for loop variable
-(F) Only a simple scalar variable may be used as a loop variable on a foreach.
+(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
+(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
=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>.
+(F) Only hard references are allowed by "strict refs". Symbolic
+references are disallowed. See L<perlref>.
=item Can't use subscript on %s
(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.
+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
=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 Character class syntax [%s] belongs inside character classes
(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.
+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 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
-".\]".
+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 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
-"=\]".
+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>.
+(F) The class in the character class [: :] syntax is unknown. See
+L<perlre>.
=item chmod() mode argument is missing initial 0
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 <%s>
=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.
+(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 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>.)
+(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>.)
=item connect() on closed socket %s
-(W closed) You tried to do a connect on a closed socket. Did you forget to
-check the return value of your socket() call? See L<perlfunc/connect>.
+(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>.
+(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|W redefine) 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
-(W misc) You undefined a subroutine which had previously been eligible for
-inlining. See L<perlsub/"Constant Functions"> for commentary and workarounds.
+(W misc) You undefined a subroutine which had previously been eligible
+for inlining. See L<perlsub/"Constant Functions"> for commentary and
+workarounds.
=item Copy method did not return a reference
-(F) The method which overloads "=" is buggy. See L<overload/Copy Constructor>.
+(F) The method which overloads "=" is buggy. See L<overload/Copy
+Constructor>.
=item CORE::%s is not a keyword
=item corrupted regexp program
-(P) The regular expression engine got passed a regexp program without
-a valid magic number.
+(P) The regular expression engine got passed a regexp program without a
+valid magic number.
=item Corrupt malloc ptr 0x%lx at 0x%lx
=item Deep recursion on subroutine "%s"
-(W recursion) This subroutine has called itself (directly or indirectly) 100
-times more than it has returned. This probably indicates an infinite
-recursion, unless you're writing strange benchmark programs, in which case it
-indicates something else.
+(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 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.
+(D deprecated) defined() is not usually useful on arrays because it
+checks for an undefined I<scalar> value. If you want to see if the
+array is empty, just use C<if (@array) { # not empty }> for example.
=item defined(%hash) is deprecated
-(D deprecated) 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<<<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 not produce a valid header
=item (Did you mean &%s instead?)
-(W) You probably referred to an imported subroutine &FOO as $FOO or some such.
+(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.
+(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.
+(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
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.
+"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 malloc) 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 entering effective %s failed
(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 at run time
-(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) 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, use re 'eval'
-(F) A regular expression contained the C<(?{ ... })> zero-width assertion,
-but that construct is only allowed when the C<use re 'eval'> pragma is
-in effect. See L<perlre/(?{ code })>.
+(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 exiting) 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.
+(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 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>.
+(W exiting) You are exiting a rather special block construct (like a
+sort block or subroutine) by unconventional means, such as a goto, or a
+loop control statement. See L<perlfunc/sort>.
=item Exiting subroutine via %s
-(W exiting) You are exiting a subroutine by unconventional means, such as a
-goto, or a loop control statement.
+(W exiting) You are exiting a subroutine by unconventional means, such
+as a goto, or a loop control statement.
=item Exiting substitution via %s
-(W exiting) You are exiting a substitution by unconventional means, such as a
-return, a goto, or a loop control statement.
+(W exiting) You are exiting a substitution by unconventional means, such
+as a return, a goto, or a loop control statement.
=item Explicit blessing to '' (assuming package main)
-(W misc) You are blessing a reference to a zero length string. This has the
-effect of blessing the reference into the package main. This is usually not
-what you want. Consider providing a default target package, e.g. bless($ref,
-$p || 'MyPackage');
+(W misc) You are blessing a reference to a zero length string. This has
+the effect of blessing the reference into the package main. This is
+usually not what you want. Consider providing a default target package,
+e.g. bless($ref, $p || 'MyPackage');
=item %s: Expression syntax
-(A) You've accidentally run your script through B<csh> instead
-of Perl. Check the #! line, or manually feed your script into
-Perl yourself.
+(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
=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>.
+(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 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.
+(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 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>.
+(W io) You tried to write on a read-only filehandle. If you intended it
+to be a read-write filehandle, you needed to open it with "+<" or "+>"
+or "+>>" instead of with "<" or nothing. If you intended only to write
+the file, use ">" or ">>". See L<perlfunc/open>.
=item Filehandle %s opened only for output
-(W io) You tried to read from a filehandle opened only for writing. If you
-intended it to be a read/write filehandle, you needed to open it with "+<" or
-"+>" or "+>>" instead of with "<" or nothing. If you intended only to read
-from the file, use "<". 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.
+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?
+(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>.
+(F) You started a regular expression with a quantifier. Backslash it if
+you meant it literally. See L<perlre>.
=item Format not terminated
=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.
+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"
=item get%sname() on closed socket %s
-(W closed) You tried to get a socket or peer socket name on a closed socket.
-Did you forget to check the return value of your socket() call?
+(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"
=item getsockopt() on closed socket %s
-(W closed) You tried to get a socket option on a closed socket. Did
-you forget to check the return value of your socket() call? See
+(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
=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
+(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".
+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
=item Had to create %s unexpectedly
-(S internal) A routine asked for a symbol from a symbol table that ought to have
-existed already, but for some reason it didn't, and had to be created on
-an emergency basis to prevent a core dump.
+(S internal) A routine asked for a symbol from a symbol table that ought
+to have existed already, but for some reason it didn't, and had to be
+created on an emergency basis to prevent a core dump.
=item Hash %%s missing the % in argument %d of %s()
-(D deprecated) Really old Perl let you omit the % on hash names in some spots.
-This is now heavily deprecated.
+(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) 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 Illegal binary digit %s
=item Illegal binary digit %s ignored
-(W digit) You may have tried to use a digit other than 0 or 1 in a binary
-number. Interpretation of the binary number stopped before the offending
-digit.
+(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) 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.
+would any other whitespace, which means you should never see this error
+when Perl was built using standard options. For some reason, your
+version of Perl appears to have been built without this support. Talk
+to your Perl administrator.
=item Illegal division by zero
-(F) You tried to divide a number by 0. Either something was wrong in your
-logic, or you need to put a conditional in to guard against meaningless input.
+(F) You tried to divide a number by 0. Either something was wrong in
+your logic, or you need to put a conditional in to guard against
+meaningless input.
=item Illegal hexadecimal digit %s ignored
-(W digit) You may have tried to use a character other than 0 - 9 or A - F,
-a - f in a hexadecimal number. Interpretation of the hexadecimal number
-stopped before the illegal character.
+(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 number of bits in vec
=item Ill-formed CRTL environ value "%s"
(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's
-internal environ array, and encountered an element without the C<=> delimiter
-used to separate keys from values. The element is ignored.
+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.
+(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.
+(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>.
+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
=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.)
+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 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
+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
=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.
+(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/
=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)>.
+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
=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>.
+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>.
+(W printf) Perl does not understand the given format conversion. See
+L<perlfunc/sprintf>.
=item invalid [] range "%s" in regexp
=item Invalid separator character %s in attribute list
(F) Something other than a colon or whitespace was seen between the
-elements of an attribute list. If the previous attribute
-had a parenthesised parameter list, perhaps that list was terminated
-too soon. See L<attributes>.
+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 pack) 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>.
+(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 Label not found for "last %s"
-(F) You named a loop to break out of, but you're not currently in a
-loop of that name, not even if you count where you were called from.
-See L<perlfunc/last>.
+(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"
=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>.
+(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">.
+values cannot be returned in subroutines used in lvalue context. See
+L<perlsub/"Lvalue subroutines">.
=item Malformed PERLLIB_PREFIX
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
+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>.
+regular expression engine didn't specifically check for that. See
+L<perlre>.
=item % may only be used in unpack
(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>.
+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
=item Missing command in piped open
-(W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
-construction, but the command was missing or blank.
+(W pipe) You used the C<open(FH, "| command")> or
+C<open(FH, "command |")> construction, but the command was missing or
+blank.
=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.
+(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.
+(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?)
=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?)
=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
=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>.
+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>.
+(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>.
+(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.
+(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.
+(F) Lexically scoped variables aren't in a package, so it doesn't make
+sense to try to declare one with a package qualifier on the front. Use
+local() if you want to localize a package variable.
=item Name "%s::%s" used only once: possible typo
(W once) Typographical errors often show up as unique variable names.
-If you had a good reason for having a unique name, then just mention
-it again somehow to suppress the message. The C<our> declaration is
+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 %s never introduced
-(S internal) The symbol in question was declared but somehow went out of scope
-before it could possibly have been used.
+(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
=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.
+(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 '<' 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 '<' on the command line, but can't find the
+name of the file from which to read data for stdin.
=item No #! line
=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>.
+(F) The "no" keyword is recognized and executed at compile time, and
+returns no useful value. See L<perlmod>.
=item No output file after > on command line
-(F) An error peculiar to VMS. Perl handles its own command line redirection,
-and found a lone '>' at the end of the command line, so it doesn't know
-where you wanted to redirect stdout.
+(F) An error peculiar to VMS. Perl handles its own command line
+redirection, and found a lone '>' at the end of the command line, so it
+doesn't know where you wanted to redirect stdout.
=item No output file after > or >> on command line
-(F) An error peculiar to VMS. Perl handles its own command line redirection,
-and found a '>' or a '>>' on the command line, but can't find the
-name of the file to which to write data destined for stdout.
+(F) An error peculiar to VMS. Perl handles its own command line
+redirection, and found a '>' or a '>>' on the command line, but can't
+find the name of the file to which to write data destined for stdout.
=item No package name allowed for variable %s in "our"
-(F) Fully qualified variable names are not allowed in "our" declarations,
-because that doesn't make much sense under existing semantics. Such
-syntax is reserved for future extensions.
+(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
=item No space allowed after -%c
-(F) The argument to the indicated command line switch must follow immediately
-after the switch, without intervening spaces.
+(F) The argument to the indicated command line switch must follow
+immediately after the switch, without intervening spaces.
=item No %s specified for -%c
=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 pseudo-hash field "%s"
=item No such pseudo-hash 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) 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.
=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.
+(W signal) You specified a signal name as a subscript to %SIG that was
+not recognized. Say C<kill -l> in your shell to see the valid signal
+names on your system.
=item Not a CODE reference
(F) Perl was trying to evaluate a reference to a code value (that is, a
subroutine), but found a reference to something else instead. You can
-use the ref() function to find out what kind of ref it really was.
-See also L<perlref>.
+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>.
+(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.
-See also L<perlref>.
+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
=item Not enough format arguments
-(W syntax) 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.
+(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.
+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.
+(P debugging) Some internal routine called run() with a null opcode
+pointer.
=item Null picture in formline
=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.
+(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 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.
+(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
-(W misc) 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
=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 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'".
+(S ambiguous) You used a variable or subroutine call where the parser
+was expecting an operator. The parser has assumed you really meant to
+use an operator, but this is highly likely to be incorrect. For
+example, if you say "*foo *foo" it will be interpreted as if you said
+"*foo * 'foo'".
=item "our" variable %s redeclared
-(W misc) You seem to have already declared the same global once before in the
-current lexical scope.
+(W misc) You seem to have already declared the same global once before
+in the current lexical scope.
=item Out of memory!
(X) The malloc() function returned 0, indicating there was insufficient
-remaining memory (or virtual memory) to satisfy the request. Perl
-has no option but to exit immediately.
+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.
+(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>.
+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.
+(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
=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>.
+(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 io) 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
=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
=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>.
+(F) The module in question uses features of a version of Perl more
+recent than the currently running version. How long has it been since
+you upgraded, anyway? See L<perlfunc/require>.
=item PERL_SH_DIR too long
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>.
+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 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.
+(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
(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.)
+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) 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:
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 printf() on closed filehandle %s
-(W closed) 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 print() on closed filehandle %s
-(W closed) The filehandle you're printing on got itself closed sometime before
-now. Check your logic flow.
+(W closed) The filehandle you're printing on got itself closed sometime
+before now. Check your logic flow.
=item Process terminated by SIG%s
=item Prototype mismatch: %s vs %s
-(S unsafe) 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 readline() on closed filehandle %s
=item realloc() of freed memory ignored
-(S malloc) An internal routine called realloc() on something that had already
-been freed.
+(S malloc) An internal routine called realloc() on something that had
+already been freed.
=item Recompile perl with B<-D>DEBUGGING to use B<-D> switch
-(F debugging) You can't use the B<-D> option unless the code to produce the
-desired output is compiled into Perl, which entails some overhead,
+(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 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>.
+(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 miscount in sv_replace()
-(W internal) The internal sv_replace() function was handed a new SV with a
-reference count of other than 1.
+(W internal) The internal sv_replace() function was handed a new SV with
+a reference count of other than 1.
=item regexp memory corruption
=item regexp *+ operand could be empty
-(F) The part of the regexp subject to either the * or + quantifier
-could match an empty string.
+(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>.
+(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>.
+(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 syntax) 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 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.
+(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 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
+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 unopened) 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
=item semi-panic: attempt to dup freed string
-(S internal) The internal newSVsv() routine was called to duplicate a scalar
-that had previously been marked as free.
+(S internal) The internal newSVsv() routine was called to duplicate a
+scalar that had previously been marked as free.
=item sem%s not implemented
=item send() on closed socket %s
-(W closed) The socket 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>.
+(F) A regular expression ended with an incomplete extension (?. See
+L<perlre>.
=item Sequence (?%s...) not implemented
=item 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".
+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<< $> >>, 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.
+(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<$<>, 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
+(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
=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.
+as in the first argument to C<join>. Perl will treat the true or false
+result of matching the pattern against $_ as the string, which is
+probably not what you had in mind.
=item shutdown() on closed socket %s
=item SIG%s handler "%s" not defined
-(W signal) The signal handler named in %SIG doesn't, in fact, exist. Perhaps
-you put it into the wrong package?
+(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 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 Statement unlikely to be reached
-(W exec) You did an exec() with some statement after it other than a die().
-This is almost always an error, because exec() never returns unless
-there was a failure. You probably wanted to use system() instead,
-which does return. To suppress this warning, put the exec() in a block
-by itself.
+(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 Stat on unopened file <%s>
-(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.
+(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 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}/>.
+(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 implicitly 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
=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
-(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).
+(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
=item syswrite() on closed filehandle %s
-(W closed) 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 unopened) 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 <%s>
-(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>.
+(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/$[>.
+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
=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 environ elements (%s)
=item This Perl can't set CRTL environ elements (%s=%s)
(W internal) Warnings peculiar to VMS. You tried to change or delete an
-element of the CRTL's internal environ array, but your copy of Perl wasn't
-built with a CRTL that contained the setenv() function. You'll need to
-rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see
-L<perlvms>) so that the environ array isn't the target of the change to
+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>.
(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.
+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
=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.
+(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 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 internal) 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 internal) 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 internal) 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 internal) 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 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>.
+(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.
+(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'
=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>.
+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.
+(F) The lexer counted more closing curly or square brackets than opening
+ones, so you're probably missing a matching opening bracket. As a
+general rule, you'll find the missing one (so to speak) near the place
+you were last editing.
=item Unquoted string "%s" may clash with future reserved word
-(W reserved) You used a bareword that might someday be claimed as a reserved
-word. It's best to put such a word in quotes, or capitalize it somehow, or
-insert an underbar into it. You might also declare it as a subroutine.
+(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
=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.
+(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.
+(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 misc) 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 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>.
+(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 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.
+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
=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>.
+(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
+(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 untie attempted while %d inner references still exist
-(W untie) A copy of the object returned from C<tie> (or C<tied>) was still
-valid when C<untie> was called.
+(W untie) A copy of the object returned from C<tie> (or C<tied>) was
+still valid when C<untie> was called.
=item Useless use of %s in void context
(W void) You did something without a side effect in a context that does
-nothing with the return value, such as a statement that doesn't return a value
-from a block, or the left side of a scalar comma operator. Very often this
-points not to stupidity on your part, but a failure of Perl to parse your
-program the way you thought it would. For example, you'd get this if you
-mixed up your C precedence with Python precedence and said
+nothing with the return value, such as a statement that doesn't return a
+value from a block, or the left side of a scalar comma operator. Very
+often this points not to stupidity on your part, but a failure of Perl
+to parse your program the way you thought it would. For example, you'd
+get this if you mixed up your C precedence with Python precedence and
+said
$one, $two = 1, 2;
=item "use" not allowed in expression
-(F) The "use" keyword is recognized and executed at compile time, and returns
-no useful value. See L<perlmod>.
+(F) The "use" keyword is recognized and executed at compile time, and
+returns no useful value. See L<perlmod>.
=item Use of bare << to mean <<"" is deprecated
-(D deprecated) You are now encouraged to use the explicitly quoted form if you
-wish to use an empty line as the terminator of the here-document.
+(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 implicit split to @_ is deprecated
-(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).
+(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 inherited AUTOLOAD for non-method %s() is deprecated
-(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines are
-looked up as methods (using the C<@ISA> hierarchy) even when the subroutines
-to be autoloaded were called as plain functions (e.g. C<Foo::bar()>),
-not as methods (e.g. C<< Foo->bar() >> or C<< $obj->bar() >>).
+(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
+are looked up as methods (using the C<@ISA> hierarchy) even when the
+subroutines to be autoloaded were called as plain functions (e.g.
+C<Foo::bar()>), not as methods (e.g. C<< Foo->bar() >> or C<<
+$obj->bar() >>).
-This bug will be rectified in future by using method lookup only for methods'
-C<AUTOLOAD>s. However, there is a significant base of existing code that may
-be using the old behavior. So, as an interim step, Perl currently issues an
-optional warning when non-methods use inherited C<AUTOLOAD>s.
+This bug will be rectified in future by using method lookup only for
+methods' C<AUTOLOAD>s. However, there is a significant base of existing
+code that may be using the old behavior. So, as an interim step, Perl
+currently issues an optional warning when non-methods use inherited
+C<AUTOLOAD>s.
The simple rule is: Inheritance will not work when autoloading
-non-methods. The simple fix for old code is: In any module that used to
-depend on inheriting C<AUTOLOAD> for non-methods from a base class named
-C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during startup.
+non-methods. The simple fix for old code is: In any module that used
+to depend on inheriting C<AUTOLOAD> for non-methods from a base class
+named C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during
+startup.
-In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);> you
-should remove AutoLoader from @ISA and change C<use AutoLoader;> to
+In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);>
+you should remove AutoLoader from @ISA and change C<use AutoLoader;> to
C<use AutoLoader 'AUTOLOAD';>.
=item Use of %s in printf format not supported
=item Use of $* is deprecated
-(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<$*>.
+(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<$*>.
=item Use of %s is deprecated
(D deprecated) The construct indicated is no longer recommended for use,
-generally because there's a better way to do it, and also because the old way
-has bad side effects.
+generally because there's a better way to do it, and also because the
+old way has bad side effects.
=item Use of $# is deprecated
-(D deprecated) This was an ill-advised attempt to emulate a poorly defined
-B<awk> feature. Use an explicit printf() or sprintf() instead.
+(D deprecated) This was an ill-advised attempt to emulate a poorly
+defined B<awk> feature. Use an explicit printf() or sprintf() instead.
=item Use of reserved word "%s" is deprecated
-(D deprecated) The indicated bareword is a reserved word. Future versions of
-perl may use it as a keyword, so you're better off either explicitly quoting
-the word in a manner appropriate for its context of use, or using a different
-name altogether. The warning can be suppressed for subroutine names by either
-adding a C<&> prefix, or using a package qualifier, e.g. C<&our()>, or
-C<Foo::our()>.
+(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 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.
+(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.
=item Value of %s can be "0"; test with defined()
(W misc) In a conditional expression, you used <HANDLE>, <*> (glob),
-C<each()>, or C<readdir()> as a boolean value. Each of these constructs can
-return a value of "0"; that would make the conditional expression false, which
-is probably not what you intended. When using these constructs in conditional
-expressions, test their values with the C<defined> operator.
+C<each()>, or C<readdir()> as a boolean value. Each of these constructs
+can return a value of "0"; that would make the conditional expression
+false, which is probably not what you intended. When using these
+constructs in conditional expressions, test their values with the
+C<defined> operator.
=item Value of CLI symbol "%s" too long
-(W misc) A warning peculiar to VMS. Perl tried to read the value of an %ENV
-element from a CLI symbol table, and found a resultant string longer than 1024
-characters. The return value has been truncated to 1024 characters.
+(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.
+(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 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:
+(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
=item Variable "%s" will not stay shared
-(W closure) 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.
+reference variables in outer subroutines are called or referenced, they
+are automatically rebound to the current values of such variables.
=item Version number must be a constant number
=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 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
+(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;
=item write() on closed filehandle %s
-(W closed) 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 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.)
+(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
projects / p5sagit/p5-mst-13.2.git / commitdiff