Optional warnings are enabled by using the B<-w> switch. Warnings may
be captured by setting C<$SIG{__WARN__}> to a reference to a routine that
will be called on each warning instead of printing it. See L<perlvar>.
+
Trappable errors may be trapped using the eval operator. See
-L<perlfunc/eval>.
+L<perlfunc/eval>. In almost all cases, warnings may be selectively
+disabled or promoted to fatal errors using the C<warnings> pragma.
+See L<warnings>.
Some of these messages are generic. Spots that vary are denoted with a %s,
just as in a printf format. Note that some messages start with a %s!
-The symbols C<"%(-?@> sort before the letters, while C<[> and C<\> sort after.
+Since the messages are listed in alphabetical order, the symbols
+C<"%(-?@> sort before the letters, while C<[> and C<\> sort after.
=over 4
+=item "my sub" not yet implemented
+
+(F) Lexically scoped subroutines are not yet implemented. Don't try that
+yet.
+
=item "my" variable %s can't be in a package
(F) Lexically scoped variables aren't in a package, so it doesn't make sense
(F) The '!' is allowed in pack() and unpack() only after certain types.
See L<perlfunc/pack>.
+=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>.
+
+=item # must be followed by a, A or Z
+
+(F) You had an unpack template indicating a counted-length string,
+which must be followed by one of the letters a, A or Z
+to indicate what sort of string is to be unpacked.
+See L<perlfunc/pack>.
+
+=item # must be followed by a*, A* or Z*
+
+(F) You had an pack template indicating a counted-length string,
+Currently the only things that can have their length counted are a*, A* or Z*.
+See L<perlfunc/pack>.
+
+=item # must follow a numeric type
+
+(F) You had an unpack template that contained a '#',
+but this did not follow some numeric unpack specification.
+See L<perlfunc/pack>.
+
=item % 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>.
+=item Repeat count in pack overflows
+
+(F) You can't specify a repeat count so large that it overflows
+your signed integers. See L<perlfunc/pack>.
+
+=item Repeat count in unpack overflows
+
+(F) You can't specify a repeat count so large that it overflows
+your signed integers. See L<perlfunc/unpack>.
+
=item /%s/: Unrecognized escape \\%c passed through
(W) You used a backslash-character combination which is not recognized
by Perl. This combination appears in an interpolated variable or a
C<'>-delimited regular expression.
+=item /%s/ should probably be written as "%s"
+
+(W) You have used a pattern where Perl expected to find a string,
+like 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 %s (...) interpreted as function
(W) You've run afoul of the rule that says that any list operator followed
by parentheses turns into a function, with all the list operators arguments
found inside the parentheses. See L<perlop/Terms and List Operators (Leftward)>.
+=item %s() called too early to check prototype
+
+(W) You've called a function that has a prototype before the parser saw a
+definition or declaration for it, and Perl could not check that the call
+conforms to the prototype. You need to either add an early prototype
+declaration for the subroutine in question, or move the subroutine
+definition ahead of the call to get proper prototype checking. Alternatively,
+if you are certain that you're calling the function correctly, you may put
+an ampersand before the name to avoid the warning. See L<perlsub>.
+
=item %s argument is not a HASH element
(F) The argument to exists() must be a hash element, such as
(S) The symbol in question was declared but somehow went out of scope
before it could possibly have been used.
+=item %s package attribute may clash with future reserved word: %s
+
+(W) 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 %s syntax OK
(F) The final summary message when a C<perl -c> succeeds.
To silently interpret it as the Perl operator, use the C<CORE::> prefix
on the operator (e.g. C<CORE::log($x)>) or by declaring the subroutine
-to be an object method (see L<attrs>).
+to be an object method (see L<perlsub/"Subroutine Attributes">
+or L<attributes>).
=item Args must match #! line
SvREFCNT_inc() was called too few times, or that the SV was mortalized
when it shouldn't have been, or that memory has been corrupted.
+=item Attempt to join self
+
+(F) You tried to join a thread from within itself, which is an
+impossible task. You may be joining the wrong thread, or you may
+need to move the join() to some other thread.
+
=item Attempt to pack pointer to temporary value
(W) You tried to pass a temporary value (like the result of a
could not be guaranteed (due to the errors), and since subsequent code
likely depends on its correct operation, Perl just gave up.
+=item Binary number > 0b11111111111111111111111111111111 non-portable
+
+(W) The binary number you specified is larger than 2**32-1
+(4294967295) and therefore non-portable between systems. See
+L<perlport> for more on portability concerns.
+
=item bind() on closed fd
(W) You tried to do a bind on a closed socket. Did you forget to check
the return value of your socket() call? See L<perlfunc/bind>.
+=item Bit vector size > 32 non-portable
+
+(W) Using bit vector sizes larger than 32 is non-portable.
+
=item Bizarre copy of %s in %s
(P) Perl detected an attempt to copy an internal value that is not copiable.
from a deleted (but still opened) file. You have to say C<-i.bak>, or some
such.
-=item Can't do inplace edit: %s E<gt> 14 characters
+=item Can't do inplace edit: %s would not be unique
-(S) There isn't enough room in the filename to make a backup name for the file.
+(S) Your filesystem does not support filenames longer than 14
+characters and Perl was unable to create a unique filename during
+inplace editing with the B<-i> switch. The file was ignored.
=item Can't do inplace edit: %s is not a regular file
in a function/method name or a failure to C<AutoSplit> the file, say, by
doing C<make install>.
-=item Can't locate %s in @INC
+=item Can't locate %s
-(F) You said to do (or require, or use) a file that couldn't be found
-in any of the libraries mentioned in @INC. 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>.
+(F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be
+found. Perl looks for the file in all the locations mentioned in @INC,
+unless the file name included the full path to the file. Perhaps you need
+to set the PERL5LIB or PERL5OPT environment variable to say where the extra
+library is, or maybe the script needs to add the library name to @INC. Or
+maybe you just misspelled the name of the file. See L<perlfunc/require>
+and L<lib>.
=item Can't locate object method "%s" via package "%s"
(F) You aren't allowed to assign to the item indicated, or otherwise try to
change it, such as with an auto-increment.
+=item Can't modify non-lvalue subroutine call
+
+(F) Subroutines used in lvalue context should be marked as such, see
+L<perlsub/"Lvalue subroutines">.
+
=item Can't modify nonexistent substring
(P) The internal routine that does assignment to a substr() was handed
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 remove %s: %s, skipping file
+
+(S) You requested an inplace edit without creating a backup file. Perl
+was unable to remove the original file to replace it with the modified
+file. The file was left unmodified.
+
=item Can't rename %s to %s: %s, skipping file
-(S) The rename done by the B<-i> switch failed for some reason, probably because
-you don't have write permission to the directory.
+(S) The rename done by the B<-i> switch failed for some reason,
+probably because you don't have write permission to the directory.
=item Can't reopen input pipe (name: %s) in binary mode
(F) The return statement was executed in mainline code, that is, where
there was no subroutine call to return out of. See L<perlsub>.
+=item Can't return %s from lvalue subroutine
+
+(F) Perl detected an attempt to return illegal lvalues (such
+as temporary or readonly values) from a subroutine used as an lvalue.
+This is not allowed.
+
=item Can't stat script "%s"
(P) For some reason you can't fstat() the script even though you have
opposed to a subroutine reference): no such method callable via the
package. If method name is C<???>, this is an internal error.
+=item Character class [:%s:] unknown
+
+(F) The class in the character class [: :] syntax is unknown.
+
+=item Character class syntax [%s] belongs inside character classes
+
+(W) The character class constructs [: :], [= =], and [. .] go
+I<inside> character classes, the [] are part of the construct,
+for example: /[012[:alpha:]345]/. Note that the last two constructs
+are not currently implemented, they are placeholders for future extensions.
+
=item Character class syntax [. .] is reserved for future extensions
(W) Within regular expression character classes ([]) the syntax beginning
expression character class, just quote the square brackets with the
backslash: "\[." and ".\]".
-=item Character class syntax [: :] is reserved for future extensions
-
-(W) Within regular expression character classes ([]) the syntax beginning
-with "[:" and ending with ":]" is reserved for future extensions.
-If you need to represent those character sequences inside a regular
-expression character class, just quote the square brackets with the
-backslash: "\[:" and ":\]".
-
=item Character class syntax [= =] is reserved for future extensions
(W) Within regular expression character classes ([]) the syntax
inlining. See L<perlsub/"Constant Functions"> for commentary and
workarounds.
+=item constant(%s): %%^H is not localized
+
+(F) When setting compile-time-lexicalized hash %^H one should set the
+corresponding bit of $^H as well.
+
+=item constant(%s): %s
+
+(F) Compile-time-substitutions (such as overloaded constants and
+character names) were not correctly set up.
+
=item Copy method did not return a reference
(F) The method which overloads "=" is buggy. See L<overload/Copy Constructor>.
recursion, unless you're writing strange benchmark programs, in which
case it indicates something else.
+=item defined(@array) is deprecated
+
+(D) defined() is not usually useful on arrays because it checks for an
+undefined I<scalar> value. If you want to see if the array is empty,
+just use C<if (@array) { # not empty }> for example.
+
+=item defined(%hash) is deprecated
+
+(D) defined() is not usually useful on hashes because it checks for an
+undefined I<scalar> value. If you want to see if the hash is empty,
+just use C<if (%hash) { # not empty }> for example.
+
=item Delimiter for here document is too long
(F) In a here document construct like C<E<lt>E<lt>FOO>, the label
You need to do an open() or a socket() call, or call a constructor from
the FileHandle package.
-=item Filehandle %s opened for only input
+=item Filehandle %s opened only for input
(W) You tried to write on a read-only filehandle. If you
intended it to be a read-write filehandle, you needed to open it with
you intended only to write the file, use "E<gt>" or "E<gt>E<gt>". See
L<perlfunc/open>.
-=item Filehandle opened for only input
+=item Filehandle %s opened only for output
-(W) You tried to write on a read-only filehandle. If you
+(W) You tried to read from a filehandle opened only for writing. If you
intended it to be a read-write filehandle, you needed to open it with
"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If
-you intended only to write the file, use "E<gt>" or "E<gt>E<gt>". See
+you intended only to read from the file, use "E<lt>". See
L<perlfunc/open>.
=item Final $ should be \$ or $name
(W) You redefined a format. To suppress this warning, say
{
- local $^W = 0;
+ no warnings;
eval "format NAME =...";
}
(D) Really old Perl let you omit the % on hash names in some spots. This
is now heavily deprecated.
+=item Hexadecimal number > 0xffffffff non-portable
+
+(W) The hexadecimal number you specified is larger than 2**32-1
+(4294967295) and therefore non-portable between systems. See
+L<perlport> for more on portability concerns.
+
=item Identifier too long
(F) Perl limits identifiers (names for variables, functions, etc.) to
(W) You may have tried to use an 8 or 9 in a octal number. Interpretation
of the octal number stopped before the 8 or 9.
-=item Illegal hex digit %s ignored
+=item Illegal hexadecimal digit %s ignored
-(W) You may have tried to use a character other than 0 - 9 or A - F in a
-hexadecimal number. Interpretation of the hexadecimal number stopped
+(W) You may have tried to use a character other than 0 - 9 or A - F, a - f
+in a hexadecimal number. Interpretation of the hexadecimal number stopped
before the illegal character.
+=item Illegal number of bits in vec
+
+(F) The number of bits in vec() (the third argument) must be a power of
+two from 1 to 32 (or 64, if your platform supports that).
+
=item Illegal switch in PERL5OPT: %s
(X) The PERL5OPT environment variable may only be used to set the
=item Integer overflow in %s number
-(S) The literal hex, octal or binary number you have specified is
-too big for your architecture. On a 32-bit architecture the largest
-literal hex, octal or binary number representable without overflow
-is 0xFFFFFFFF, 037777777777, or 0b11111111111111111111111111111111
-respectively. Note that Perl transparently promotes decimal literals
-to a floating point representation internally--subject to loss of
-precision errors in subsequent operations--so this limit usually
-doesn't apply to decimal literals.
+(W) The hexadecimal, octal or binary number you have specified either
+as a literal in your code or as a scalar is too big for your
+architecture, and has been converted to a floating point number. On a
+32-bit architecture the largest hexadecimal, octal or binary number
+representable without overflow is 0xFFFFFFFF, 037777777777, or
+0b11111111111111111111111111111111 respectively. Note that Perl
+transparently promotes all numbers to a floating point representation
+internally--subject to loss of precision errors in subsequent
+operations.
=item Internal inconsistency in tracking vforks
(P) Something went badly awry in the regular expression parser.
+=item Invalid %s attribute: %s
+
+The indicated attribute for a subroutine or variable was not recognized
+by Perl or by a user-supplied handler. See L<attributes>.
+
+=item Invalid %s attributes: %s
+
+The indicated attributes for a subroutine or variable were not recognized
+by Perl or by a user-supplied handler. See L<attributes>.
+
=item invalid [] range in regexp
(F) The range specified in a character class had a minimum character
-greater than the maximum character. See L<perlre>.
+greater than the maximum character, or the range didn't start/end with
+a literal character. See L<perlre>.
=item Invalid conversion in %s: "%s"
(W) Perl does not understand the given format conversion.
See L<perlfunc/sprintf>.
+=item Invalid separator character %s in attribute list
+
+(F) Something other than a comma or whitespace was seen between the
+elements of an attribute list. If the previous attribute
+had a parenthesised parameter list, perhaps that list was terminated
+too soon. See L<attributes>.
+
=item Invalid type in pack: '%s'
(F) The given character is not a valid pack type. See L<perlfunc/pack>.
(W) You tried to do a listen on a closed socket. Did you forget to check
the return value of your socket() call? See L<perlfunc/listen>.
+=item Lvalue subs returning %s not implemented yet
+
+(F) Due to limitations in the current implementation, array and hash
+values cannot be returned in subroutines used in lvalue context.
+See L<perlsub/"Lvalue subroutines">.
+
=item Method for operation %s not found in package %s during blessing
(F) An attempt was made to specify an entry in an overloading table that
mentioned with the $ in Perl, unlike in the shells, where it can vary from
one line to the next.
+=item Missing %sbrace%s on \N{}
+
+(F) Wrong syntax of character name literal C<\N{charname}> within
+double-quotish context.
+
=item Missing comma after first argument to %s function
(F) While certain functions allow you to specify a filehandle or an
(W) Multidimensional arrays aren't written like C<$foo[1,2,3]>. They're written
like C<$foo[1][2][3]>, as in C.
+=item Missing name in "my sub"
+
+(F) The reserved syntax for lexically scoped subroutines requires that they
+have a name with which they can be found.
+
=item Name "%s::%s" used only once: possible typo
(W) Typographical errors often show up as unique variable names.
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 > 037777777777 non-portable
+
+(W) The octal number you specified is larger than 2**32-1 (4294967295)
+and therefore non-portable between systems. See L<perlport> for more
+on portability concerns.
+
+See also L<perlport> for writing portable code.
+
=item Odd number of elements in hash assignment
(S) You specified an odd number of elements to initialize a hash, which
One possible workaround is to force Perl to use magical string
increment by prepending "0" to your numbers.
-=item Read on closed filehandle E<lt>%sE<gt>
+=item Read on closed filehandle %s
(W) The filehandle you're reading from got itself closed sometime before now.
Check your logic flow.
(W) You redefined a subroutine. To suppress this warning, say
{
- local $^W = 0;
+ no warnings;
eval "sub name { ... }";
}
(F) There are no byte-swapping functions for a machine with this byte order.
+=item Unknown open() mode '%s'
+
+(F) The second argument of 3-arguments open is not one from the list
+of C<L<lt>>, C<L<gt>>, C<E<gt>E<gt>>, C<+L<lt>>, C<+L<gt>>,
+C<+E<gt>E<gt>>, C<-|>, C<|-> of possible open() modes.
+
=item Unknown process %x sent message to prime_env_iter: %s
(P) An error peculiar to VMS. Perl was reading values for %ENV before
finding it. Chances are you left some needed parentheses out earlier in
the line, and you really meant a "less than".
+=item Unterminated attribute parameter in attribute list
+
+(F) The lexer saw an opening (left) parenthesis character while parsing an
+attribute list, but the matching closing (right) parenthesis
+character was not found. You may need to add (or remove) a backslash
+character to get your parentheses to balance. See L<attributes>.
+
+=item Unterminated attribute list
+
+(F) The lexer found something other than a simple identifier at the start
+of an attribute, and it wasn't a semicolon or the start of a
+block. Perhaps you terminated the parameter list of the previous attribute
+too soon. See L<attributes>.
+
=item Use of $# is deprecated
(D) This was an ill-advised attempt to emulate a poorly defined B<awk> feature.
So put in parentheses to say what you really mean.
-=item Write on closed filehandle
+=item Write on closed filehandle %s
(W) The filehandle you're writing to got itself closed sometime before now.
Check your logic flow.
projects / p5sagit/p5-mst-13.2.git / blobdiff