1N/Aperldiag - various Perl diagnostics
1N/AThese messages are classified as follows (listed in increasing order of
1N/A (W) A warning (optional).
1N/A (D) A deprecation (optional).
1N/A (S) A severe warning (default).
1N/A (F) A fatal error (trappable).
1N/A (P) An internal error you should never see (trappable).
1N/A (X) A very fatal error (nontrappable).
1N/A (A) An alien error message (not generated by Perl).
1N/AThe majority of messages from the first three classifications above
1N/A(W, D & S) can be controlled using the C<warnings> pragma.
1N/AIf a message can be controlled by the C<warnings> pragma, its warning
1N/Acategory is included with the classification letter in the description
1N/AOptional warnings are enabled by using the C<warnings> pragma or the B<-w>
1N/Aand B<-W> switches. Warnings may be captured by setting C<$SIG{__WARN__}>
1N/Ato a reference to a routine that will be called on each warning instead
1N/Aof printing it. See L<perlvar>.
1N/ADefault warnings are always enabled unless they are explicitly disabled
1N/Awith the C<warnings> pragma or the B<-X> switch.
1N/ATrappable errors may be trapped using the eval operator. See
1N/Adisabled or promoted to fatal errors using the C<warnings> pragma.
1N/AThe messages are in alphabetical order, without regard to upper or
1N/Alower-case. Some of these messages are generic. Spots that vary are
1N/Adenoted with a %s or other printf-style escape. These escapes are
1N/Aignored by the alphabetical order, as are all characters other than
1N/Aletters. To look up your message, just ignore anything that is not a
1N/A=item accept() on closed socket %s
1N/A(W closed) You tried to do an accept on a closed socket. Did you forget
1N/Ato check the return value of your socket() call? See
1N/A=item Allocation too large: %lx
1N/A(X) You can't allocate more than 64K on an MS-DOS machine.
1N/A=item '!' allowed only after types %s
1N/A(F) The '!' is allowed in pack() or unpack() only after certain types.
1N/A=item Ambiguous call resolved as CORE::%s(), qualify as such or use &
1N/A(W ambiguous) A subroutine you have declared has the same name as a Perl
1N/Akeyword, and you have used the name without qualification for calling
1N/Aone or the other. Perl decided to call the builtin because the
1N/Asubroutine is not imported.
1N/ATo force interpretation as a subroutine call, either put an ampersand
1N/Abefore the subroutine name, or qualify the name with its package.
1N/AAlternatively, you can import the subroutine (or pretend that it's
1N/Aimported with the C<use subs> pragma).
1N/ATo silently interpret it as the Perl operator, use the C<CORE::> prefix
1N/Aon the operator (
e.g. C<CORE::log($x)>) or declare the subroutine
1N/Ato be an object method (see L<perlsub/"Subroutine Attributes"> or
1N/A=item Ambiguous range in transliteration operator
1N/A(F) You wrote something like C<
tr/a-z-0//> which doesn't mean anything at
1N/Aall. To include a C<-> character in a transliteration, put it either
1N/Afirst or last. (In the past, C<
tr/a-z-0//> was synonymous with
1N/AC<
tr/a-y//>, which was probably not what you would have expected.)
1N/A=item Ambiguous use of %s resolved as %s
1N/A(W ambiguous)(S) You said something that may not be interpreted the way
1N/Ayou thought. Normally it's pretty easy to disambiguate it by supplying
1N/Aa missing quote, operator, parenthesis pair or declaration.
1N/A=item '|' and '<' may not both be specified on command line
1N/A(F) An error peculiar to VMS. Perl does its own command line
1N/Aredirection, and found that STDIN was a pipe, and that you also tried to
1N/Aredirect STDIN using '<'. Only one STDIN stream to a customer, please.
1N/A=item '|' and '>' may not both be specified on command line
1N/A(F) An error peculiar to VMS. Perl does its own command line
1N/Aredirection, and thinks you tried to redirect stdout both to a file and
1N/Ainto a pipe to another command. You need to choose one or the other,
1N/Athough nothing's stopping you from piping into a program or Perl script
1N/Awhich 'splits' output into two streams, such as
1N/A open(OUT,">$ARGV[0]") or die "Can't write to $ARGV[0]: $!";
1N/A=item Applying %s to %s will act on scalar(%s)
1N/A(W misc) The pattern match (C<//>), substitution (C<s///>), and
1N/Atransliteration (C<tr///>) operators work on scalar values. If you apply
1N/Aone of them to an array or a hash, it will convert the array or hash to
1N/Aa scalar value -- the length of an array, or the population info of a
1N/Ahash -- and then work on that scalar value. This is probably not what
1N/A=item Args must match #! line
1N/A(F) The setuid emulator requires that the arguments Perl was invoked
1N/Awith match the arguments specified on the #! line. Since some systems
1N/Aimpose a one-argument limit on the #! line, try combining switches;
1N/Afor example, turn C<-w -U> into C<-wU>.
1N/A=item Arg too short for msgsnd
1N/A(F) msgsnd() requires a string at least as long as sizeof(long).
1N/A=item %s argument is not a HASH or ARRAY element
1N/A(F) The argument to exists() must be a hash or array element, such as:
1N/A=item %s argument is not a HASH or ARRAY element or slice
1N/A(F) The argument to delete() must be either a hash or array element,
1N/Aor a hash or array slice, such as:
1N/A @foo[$bar, $baz, $xyzzy]
1N/A @{$ref->[12]}{"susie", "queue"}
1N/A=item %s argument is not a subroutine name
1N/A(F) The argument to exists() for C<exists &sub> must be a subroutine
1N/Aname, and not a subroutine call. C<exists &sub()> will generate this
1N/A=item Argument "%s" isn't numeric%s
1N/A(W numeric) The indicated string was fed as an argument to an operator
1N/Athat expected a numeric value instead. If you're fortunate the message
1N/Awill identify which operator was so unfortunate.
1N/A=item Argument list not closed for PerlIO layer "%s"
1N/A(W layer) When pushing a layer with arguments onto the Perl I/O system you
1N/Aforgot the ) that closes the argument list. (Layers take care of transforming
1N/Adata between external and internal representations.) Perl stopped parsing
1N/Athe layer list at this point and did not attempt to push this layer.
1N/AIf your program didn't explicitly request the failing operation, it may be
1N/Athe result of the value of the environment variable PERLIO.
1N/A=item Array @%s missing the @ in argument %d of %s()
1N/A(D deprecated) Really old Perl let you omit the @ on array names in some
1N/Aspots. This is now heavily deprecated.
1N/A=item assertion botched: %s
1N/A(P) The malloc package that comes with Perl had an internal failure.
1N/A=item Assertion failed: file "%s"
1N/A(P) A general assertion failed. The file in question must be examined.
1N/A=item Assignment to both a list and a scalar
1N/A(F) If you assign to a conditional operator, the 2nd and 3rd arguments
1N/Amust either both be scalars or both be lists. Otherwise Perl won't
1N/Aknow which context to supply to the right side.
1N/A=item A thread exited while %d threads were running
1N/A(W) When using threaded Perl, a thread (not necessarily the main
1N/Athread) exited while there were still other threads running.
1N/AUsually it's a good idea to first collect the return values of the
1N/Acreated threads by joining them, and only then exit from the main
1N/Athread. See L<threads>.
1N/A=item Attempt to access disallowed key '%s' in a restricted hash
1N/A(F) The failing code has attempted to get or set a key which is not in
1N/Athe current set of allowed keys of a restricted hash.
1N/A=item Attempt to bless into a reference
1N/A(F) The CLASSNAME argument to the bless() operator is expected to be
1N/Athe name of the package to bless the resulting object into. You've
1N/Asupplied instead a reference to something: perhaps you wrote
1N/A bless $self, $proto;
1N/A bless $self, ref($proto) || $proto;
1N/AIf you actually want to bless into the stringified version
1N/Aof the reference supplied, you need to stringify it yourself, for
1N/A bless $self, "$proto";
1N/A=item Attempt to delete disallowed key '%s' from a restricted hash
1N/A(F) The failing code attempted to delete from a restricted hash a key
1N/Awhich is not in its key set.
1N/A=item Attempt to delete readonly key '%s' from a restricted hash
1N/A(F) The failing code attempted to delete a key whose value has been
1N/Adeclared readonly from a restricted hash.
1N/A=item Attempt to free non-arena SV: 0x%lx
1N/A(P internal) All SV objects are supposed to be allocated from arenas
1N/Athat will be garbage collected on exit. An SV was discovered to be
1N/Aoutside any of those arenas.
1N/A=item Attempt to free nonexistent shared string
1N/A(P internal) Perl maintains a reference counted internal table of
1N/Astrings to optimize the storage and access of hash keys and other
1N/Astrings. This indicates someone tried to decrement the reference count
1N/Aof a string that can no longer be found in the table.
1N/A=item Attempt to free temp prematurely
1N/A(W debugging) Mortalized values are supposed to be freed by the
1N/Afree_tmps() routine. This indicates that something else is freeing the
1N/ASV before the free_tmps() routine gets a chance, which means that the
1N/Afree_tmps() routine will be freeing an unreferenced scalar when it does
1N/A=item Attempt to free unreferenced glob pointers
1N/A(P internal) The reference counts got screwed up on symbol aliases.
1N/A=item Attempt to free unreferenced scalar
1N/A(W internal) Perl went to decrement the reference count of a scalar to
1N/Asee if it would go to 0, and discovered that it had already gone to 0
1N/Aearlier, and should have been freed, and in fact, probably was freed.
1N/AThis could indicate that SvREFCNT_dec() was called too many times, or
1N/Athat SvREFCNT_inc() was called too few times, or that the SV was
1N/Amortalized when it shouldn't have been, or that memory has been
1N/A=item Attempt to join self
1N/A(F) You tried to join a thread from within itself, which is an
1N/Aimpossible task. You may be joining the wrong thread, or you may need
1N/Ato move the join() to some other thread.
1N/A=item Attempt to pack pointer to temporary value
1N/A(W pack) You tried to pass a temporary value (like the result of a
1N/Afunction, or a computed expression) to the "p" pack() template. This
1N/Ameans the result contains a pointer to a location that could become
1N/Ainvalid anytime, even before the end of the current statement. Use
1N/Aliterals or global values as arguments to the "p" pack() template to
1N/A=item Attempt to use reference as lvalue in substr
1N/A(W substr) You supplied a reference as the first argument to substr()
1N/Aused as an lvalue, which is pretty strange. Perhaps you forgot to
1N/A=item Bad arg length for %s, is %d, should be %s
1N/A(F) You passed a buffer of the wrong size to one of msgctl(), semctl()
1N/Aor shmctl(). In C parlance, the correct sizes are, respectively,
1N/AS<sizeof(struct msqid_ds *)>, S<sizeof(struct semid_ds *)>, and
1N/AS<sizeof(struct shmid_ds *)>.
1N/A=item Bad evalled substitution pattern
1N/A(F) You've used the C</e> switch to evaluate the replacement for a
1N/Asubstitution, but perl found a syntax error in the code to evaluate,
1N/Amost likely an unexpected right brace '}'.
1N/A=item Bad filehandle: %s
1N/A(F) A symbol was passed to something wanting a filehandle, but the
1N/Asymbol has no filehandle associated with it. Perhaps you didn't do an
1N/Aopen(), or did it in another package.
1N/A=item Bad free() ignored
1N/A(S malloc) An internal routine called free() on something that had never
1N/Abeen malloc()ed in the first place. Mandatory, but can be disabled by
1N/Asetting environment variable C<PERL_BADFREE> to 0.
1N/AThis message can be seen quite often with DB_File on systems with "hard"
1N/Adynamic linking, like C<AIX> and C<OS/2>. It is a bug of C<Berkeley DB>
1N/Awhich is left unnoticed if C<DB> uses I<forgiving> system malloc().
1N/A(P) One of the internal hash routines was passed a null HV pointer.
1N/A=item Bad index while coercing array into hash
1N/A(F) The index looked up in the hash found as the 0'th element of a
1N/Apseudo-hash is not legal. Index values must be at 1 or greater.
1N/A=item Badly placed ()'s
1N/A(A) You've accidentally run your script through B<csh> instead
1N/Aof Perl. Check the #! line, or manually feed your script into
1N/A=item Bad name after %s::
1N/A(F) You started to name a symbol by using a package prefix, and then
1N/Adidn't finish the symbol. In particular, you can't interpolate outside
1N/A $sym = mypack::$var;
1N/A $sym = "mypack::$var";
1N/A=item Bad realloc() ignored
1N/A(S malloc) An internal routine called realloc() on something that had
1N/Anever been malloc()ed in the first place. Mandatory, but can be disabled
1N/Aby setting environment variable C<PERL_BADFREE> to 1.
1N/A=item Bad symbol for array
1N/A(P) An internal request asked to add an array entry to something that
1N/Awasn't a symbol table entry.
1N/A=item Bad symbol for filehandle
1N/A(P) An internal request asked to add a filehandle entry to something
1N/Athat wasn't a symbol table entry.
1N/A=item Bad symbol for hash
1N/A(P) An internal request asked to add a hash entry to something that
1N/Awasn't a symbol table entry.
1N/A=item Bareword found in conditional
1N/A(W bareword) The compiler found a bareword where it expected a
1N/Aconditional, which often indicates that an || or && was parsed as part
1N/Aof the last argument of the previous construct, for example:
1N/AIt may also indicate a misspelled constant that has been interpreted as
1N/A use constant TYPO => 1;
1N/A if (TYOP) { print "foo" }
1N/AThe C<strict> pragma is useful in avoiding such errors.
1N/A=item Bareword "%s" not allowed while "strict subs" in use
1N/A(F) With "strict subs" in use, a bareword is only allowed as a
1N/Asubroutine identifier, in curly brackets or to the left of the "=>"
1N/Asymbol. Perhaps you need to predeclare a subroutine?
1N/A=item Bareword "%s" refers to nonexistent package
1N/A(W bareword) You used a qualified bareword of the form C<Foo::>, but the
1N/Acompiler saw no other uses of that namespace before that point. Perhaps
1N/Ayou need to predeclare a package?
1N/A=item BEGIN failed--compilation aborted
1N/A(F) An untrapped exception was raised while executing a BEGIN
1N/Asubroutine. Compilation stops immediately and the interpreter is
1N/A=item BEGIN not safe after errors--compilation aborted
1N/A(F) Perl found a C<BEGIN {}> subroutine (or a C<use> directive, which
1N/Aimplies a C<BEGIN {}>) after one or more compilation errors had already
1N/Aoccurred. Since the intended environment for the C<BEGIN {}> could not
1N/Abe guaranteed (due to the errors), and since subsequent code likely
1N/Adepends on its correct operation, Perl just gave up.
1N/A=item \1 better written as $1
1N/A(W syntax) Outside of patterns, backreferences live on as variables.
1N/AThe use of backslashes is grandfathered on the right-hand side of a
1N/Asubstitution, but stylistically it's better to use the variable form
1N/Abecause other Perl programmers will expect it, and it works better if
1N/Athere are more than 9 backreferences.
1N/A=item Binary number > 0b11111111111111111111111111111111 non-portable
1N/A(W portable) The binary number you specified is larger than 2**32-1
1N/A(4294967295) and therefore non-portable between systems. See
1N/AL<perlport> for more on portability concerns.
1N/A=item bind() on closed socket %s
1N/A(W closed) You tried to do a bind on a closed socket. Did you forget to
1N/A=item binmode() on closed filehandle %s
1N/A(W unopened) You tried binmode() on a filehandle that was never opened.
1N/ACheck you control flow and number of arguments.
1N/A=item Bit vector size > 32 non-portable
1N/A(W portable) Using bit vector sizes larger than 32 is non-portable.
1N/A=item Bizarre copy of %s in %s
1N/A(P) Perl detected an attempt to copy an internal value that is not
1N/A=item Buffer overflow in prime_env_iter: %s
1N/A(W internal) A warning peculiar to VMS. While Perl was preparing to
1N/Aiterate over %ENV, it encountered a logical name or symbol definition
1N/Awhich was too long, so it was truncated to the string shown.
1N/A=item Callback called exit
1N/A(F) A subroutine invoked from an external package via call_sv()
1N/Aexited by calling exit.
1N/A=item %s() called too early to check prototype
1N/A(W prototype) You've called a function that has a prototype before the
1N/Aparser saw a definition or declaration for it, and Perl could not check
1N/Athat the call conforms to the prototype. You need to either add an
1N/Aearly prototype declaration for the subroutine in question, or move the
1N/Asubroutine definition ahead of the call to get proper prototype
1N/Achecking. Alternatively, if you are certain that you're calling the
1N/Afunction correctly, you may put an ampersand before the name to avoid
1N/Athe warning. See L<perlsub>.
1N/A=item Cannot compress integer in pack
1N/A(F) An argument to pack("w",...) was too large to compress. The BER
1N/Acompressed integer format can only be used with positive integers, and you
1N/Aattempted to compress Infinity or a very large number (> 1e308).
1N/A=item Cannot compress negative numbers in pack
1N/A(F) An argument to pack("w",...) was negative. The BER compressed integer
1N/A=item Can only compress unsigned integers in pack
1N/A(F) An argument to pack("w",...) was not an integer. The BER compressed
1N/Ainteger format can only be used with positive integers, and you attempted
1N/A=item Can't bless non-reference value
1N/A(F) Only hard references may be blessed. This is how Perl "enforces"
1N/Aencapsulation of objects. See L<perlobj>.
1N/A=item Can't call method "%s" in empty package "%s"
1N/A(F) You called a method correctly, and it correctly indicated a package
1N/Afunctioning as a class, but that package doesn't have ANYTHING defined
1N/Ain it, let alone methods. See L<perlobj>.
1N/A=item Can't call method "%s" on an undefined value
1N/A(F) You used the syntax of a method call, but the slot filled by the
1N/Aobject reference or package name contains an undefined value. Something
1N/Alike this will reproduce the error:
1N/A process $BADREF 1,2,3;
1N/A $BADREF->process(1,2,3);
1N/A=item Can't call method "%s" on unblessed reference
1N/A(F) A method call must know in what package it's supposed to run. It
1N/Aordinarily finds this out from the object reference you supply, but you
1N/Adidn't supply an object reference in this case. A reference isn't an
1N/Aobject reference until it has been blessed. See L<perlobj>.
1N/A=item Can't call method "%s" without a package or object reference
1N/A(F) You used the syntax of a method call, but the slot filled by the
1N/Aobject reference or package name contains an expression that returns a
1N/Adefined value which is neither an object reference nor a package name.
1N/ASomething like this will reproduce the error:
1N/A process $BADREF 1,2,3;
1N/A $BADREF->process(1,2,3);
1N/A=item Can't chdir to %s
1N/Athat you can chdir to, possibly because it doesn't exist.
1N/A=item Can't check filesystem of script "%s" for nosuid
1N/A(P) For some reason you can't check the filesystem of the script for
1N/A=item Can't coerce array into hash
1N/A(F) You used an array where a hash was expected, but the array has no
1N/Ainformation on how to map from keys to array indices. You can do that
1N/Aonly with arrays that have a hash reference at index 0.
1N/A=item Can't coerce %s to integer in %s
1N/A(F) Certain types of SVs, in particular real symbol table entries
1N/A(typeglobs), can't be forced to stop being what they are. So you can't
1N/Abut then $foo no longer contains a glob.
1N/A=item Can't coerce %s to number in %s
1N/A(F) Certain types of SVs, in particular real symbol table entries
1N/A(typeglobs), can't be forced to stop being what they are.
1N/A=item Can't coerce %s to string in %s
1N/A(F) Certain types of SVs, in particular real symbol table entries
1N/A(typeglobs), can't be forced to stop being what they are.
1N/A=item Can't create pipe mailbox
1N/A(P) An error peculiar to VMS. The process is suffering from exhausted
1N/Aquotas or other plumbing problems.
1N/A=item Can't declare class for non-scalar %s in "%s"
1N/A(F) Currently, only scalar variables can be declared with a specific
1N/Aclass qualifier in a "my" or "our" declaration. The semantics may be
1N/Aextended for other types of variables in future.
1N/A=item Can't declare %s in "%s"
1N/A(F) Only scalar, array, and hash variables may be declared as "my" or
1N/A"our" variables. They must have ordinary identifiers as names.
1N/A=item Can't do inplace edit: %s is not a regular file
1N/A(S inplace) You tried to use the B<-i> switch on a special file, such as
1N/Aa file in /dev, or a FIFO. The file was ignored.
1N/A=item Can't do inplace edit on %s: %s
1N/A(S inplace) The creation of the new file failed for the indicated
1N/A=item Can't do inplace edit without backup
1N/A(F) You're on a system such as MS-DOS that gets confused if you try
1N/Areading from a deleted (but still opened) file. You have to say
1N/A=item Can't do inplace edit: %s would not be unique
1N/A(S inplace) Your filesystem does not support filenames longer than 14
1N/Acharacters and Perl was unable to create a unique filename during
1N/Ainplace editing with the B<-i> switch. The file was ignored.
1N/A=item Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/
1N/A(F) Minima must be less than or equal to maxima. If you really want your
1N/Aregexp to match something 0 times, just put {0}. The <-- HERE shows in the
1N/Aregular expression about where the problem was discovered. See L<perlre>.
1N/A=item Can't do setegid!
1N/A(P) The setegid() call failed for some reason in the setuid emulator of
1N/A=item Can't do seteuid!
1N/A(P) The setuid emulator of suidperl failed for some reason.
1N/A=item Can't do setuid
1N/A(F) This typically means that ordinary perl tried to exec suidperl to do
1N/Asetuid emulation, but couldn't exec it. It looks for a name of the form
1N/Asperl5.000 in the same directory that the perl executable resides under
1N/Afile is there, check the execute permissions. If it isn't, ask your
1N/A=item Can't do waitpid with flags
1N/A(F) This machine doesn't have either waitpid() or wait4(), so only
1N/Awaitpid() without flags is emulated.
1N/A=item Can't emulate -%s on #! line
1N/A(F) The #! line specifies a switch that doesn't make sense at this
1N/Apoint. For example, it'd be kind of silly to put a B<-x> on the #!
1N/A=item Can't exec "%s": %s
1N/A(W exec) A system(), exec(), or piped open call could not execute the
1N/Anamed program for the indicated reason. Typical reasons include: the
1N/Apermissions were wrong on the file, the file wasn't found in
1N/AC<$ENV{PATH}>, the executable in question was compiled for another
1N/Aarchitecture, or the #! line in a script points to an interpreter that
1N/Acan't be run for similar reasons. (Or maybe your system doesn't support
1N/A(F) Perl was trying to execute the indicated program for you because
1N/Athat's what the #! line said. If that's not what you wanted, you may
1N/Aneed to mention "perl" on the #! line somewhere.
1N/A=item Can't execute %s
1N/A(F) You used the B<-S> switch, but the copies of the script to execute
1N/Afound in the PATH did not have correct permissions.
1N/A=item Can't find an opnumber for "%s"
1N/A(F) A string of a form C<CORE::word> was given to prototype(), but there
1N/Ais no builtin with the name C<word>.
1N/A=item Can't find %s character property "%s"
1N/A(F) You used C<\p{}> or C<\P{}> but the character property by that name
1N/Acould not be found. Maybe you misspelled the name of the property
1N/A(remember that the names of character properties consist only of
1N/Aalphanumeric characters), or maybe you forgot the C<Is> or C<In> prefix?
1N/A=item Can't find label %s
1N/A(F) You said to goto a label that isn't mentioned anywhere that it's
1N/A=item Can't find %s on PATH
1N/A(F) You used the B<-S> switch, but the script to execute could not be
1N/A=item Can't find %s on PATH, '.' not in PATH
1N/A(F) You used the B<-S> switch, but the script to execute could not be
1N/Afound in the PATH, or at least not with the correct permissions. The
1N/Ascript exists in the current directory, but PATH prohibits running it.
1N/A=item Can't find %s property definition %s
1N/A(F) You may have tried to use C<\p> which means a Unicode property (for
1N/Aexample C<\p{Lu}> is all uppercase letters). If you did mean to use a
1N/AUnicode property, see L<perlunicode> for the list of known properties.
1N/AIf you didn't mean to use a Unicode property, escape the C<\p>, either
1N/Aby C<\\p> (just the C<\p>) or by C<\Q\p> (the rest of the string, until
1N/A=item Can't find string terminator %s anywhere before EOF
1N/A(F) Perl strings can stretch over multiple lines. This message means
1N/Athat the closing delimiter was omitted. Because bracketed quotes count
1N/Anesting levels, the following is missing its final parenthesis:
1N/A print q(The character '(' starts a side comment.);
1N/AIf you're getting this error from a here-document, you may have included
1N/Aunseen whitespace before or after your closing tag. A good programmer's
1N/Aeditor will have a way to help you find these characters.
1N/A(F) A fatal error occurred while trying to fork while opening a
1N/A=item Can't get filespec - stale stat buffer?
1N/A(S) A warning peculiar to VMS. This arises because of the difference
1N/Abetween access checks under VMS and under the Unix model Perl assumes.
1N/AUnder VMS, access checks are done by filename, rather than by bits in
1N/Athe stat buffer, so that ACLs and other protections can be taken into
1N/Aaccount. Unfortunately, Perl assumes that the stat buffer contains all
1N/Athe necessary information, and passes it, instead of the filespec, to
1N/Athe access checking routine. It will try to retrieve the filespec using
1N/Athe device name and FID present in the stat buffer, but this works only
1N/Aif you haven't made a subsequent call to the CRTL stat() routine,
1N/Abecause the device name is overwritten with each call. If this warning
1N/Aappears, the name lookup failed, and the access checking routine gave up
1N/Aand returned FALSE, just to be conservative. (Note: The access checking
1N/Aroutine knows about the Perl C<stat> operator and file tests, so you
1N/Ashouldn't ever see this warning in response to a Perl command; it arises
1N/Aonly if some internal code takes stat buffers lightly.)
1N/A=item Can't get pipe mailbox device name
1N/A(P) An error peculiar to VMS. After creating a mailbox to act as a
1N/Apipe, Perl can't retrieve its name for later use.
1N/A=item Can't get SYSGEN parameter value for MAXBUF
1N/A(P) An error peculiar to VMS. Perl asked $GETSYI how big you want your
1N/Amailbox buffers to be, and didn't get an answer.
1N/A=item Can't "goto" into the middle of a foreach loop
1N/A(F) A "goto" statement was executed to jump into the middle of a foreach
1N/A=item Can't "goto" out of a pseudo block
1N/A(F) A "goto" statement was executed to jump out of what might look like
1N/Aa block, except that it isn't a proper block. This usually occurs if
1N/Ayou tried to jump out of a sort() block or subroutine, which is a no-no.
1N/A=item Can't goto subroutine from an eval-string
1N/A(F) The "goto subroutine" call can't be used to jump out of an eval
1N/A"string". (You can use it to jump out of an eval {BLOCK}, but you
1N/Aprobably don't want to.)
1N/A=item Can't goto subroutine outside a subroutine
1N/A(F) The deeply magical "goto subroutine" call can only replace one
1N/Asubroutine call for another. It can't manufacture one out of whole
1N/Acloth. In general you should be calling it out of only an AUTOLOAD
1N/A=item Can't ignore signal CHLD, forcing to default
1N/A(W signal) Perl has detected that it is being run with the SIGCHLD
1N/Asignal (sometimes known as SIGCLD) disabled. Since disabling this
1N/Asignal will interfere with proper determination of exit status of child
1N/Aprocesses, Perl has reset the signal to its default value. This
1N/Asituation typically indicates that the parent program under which Perl
1N/Amay be running (
e.g. cron) is being very careless.
1N/A=item Can't "last" outside a loop block
1N/A(F) A "last" statement was executed to break out of the current block,
1N/Aexcept that there's this itty bitty problem called there isn't a current
1N/Ablock. Note that an "if" or "else" block doesn't count as a "loopish"
1N/Ablock, as doesn't a block given to sort(), map() or grep(). You can
1N/Ausually double the curlies to get the same effect though, because the
1N/Ainner curlies will be considered a block that loops once. See
1N/A=item Can't localize lexical variable %s
1N/A(F) You used local on a variable name that was previously declared as a
1N/Alexical variable using "my". This is not allowed. If you want to
1N/Alocalize a package variable of the same name, qualify it with the
1N/A=item Can't localize pseudo-hash element
1N/A(F) You said something like C<< local $ar->{'key'} >>, where $ar is a
1N/Areference to a pseudo-hash. That hasn't been implemented yet, but you
1N/Acan get a similar effect by localizing the corresponding array element
1N/Adirectly -- C<< local $ar->[$ar->[0]{'key'}] >>.
1N/A=item Can't localize through a reference
1N/A(F) You said something like C<local $$ref>, which Perl can't currently
1N/Ahandle, because when it goes to restore the old value of whatever $ref
1N/Apointed to after the scope of the local() is finished, it can't be sure
1N/Athat $ref will still be a reference.
1N/A=item Can't locate %s
1N/A(F) You said to C<do> (or C<require>, or C<use>) a file that couldn't be
1N/Afound. Perl looks for the file in all the locations mentioned in @INC,
1N/Aunless the file name included the full path to the file. Perhaps you
1N/Aneed to set the PERL5LIB or PERL5OPT environment variable to say where
1N/Athe extra library is, or maybe the script needs to add the library name
1N/Ato @INC. Or maybe you just misspelled the name of the file. See
1N/A=item Can't locate auto/%
s.al in @INC
1N/A(F) A function (or method) was called in a package which allows
1N/Aautoload, but there is no function to autoload. Most probable causes
1N/Athe file, say, by doing C<make install>.
1N/A=item Can't locate object method "%s" via package "%s"
1N/A(F) You called a method correctly, and it correctly indicated a package
1N/Afunctioning as a class, but that package doesn't define that particular
1N/Amethod, nor does any of its base classes. See L<perlobj>.
1N/A=item Can't locate package %s for @%s::ISA
1N/A(W syntax) The @ISA array contained the name of another package that
1N/Adoesn't seem to exist.
1N/A=item Can't locate PerlIO%s
1N/A(F) You tried to use in open() a PerlIO layer that does not exist,
1N/Ae.g. open(FH, ">:nosuchlayer", "somefile").
1N/A=item Can't make list assignment to \%ENV on this system
1N/A(F) List assignment to %ENV is not supported on some systems, notably
1N/A=item Can't modify %s in %s
1N/A(F) You aren't allowed to assign to the item indicated, or otherwise try
1N/Ato change it, such as with an auto-increment.
1N/A=item Can't modify nonexistent substring
1N/A(P) The internal routine that does assignment to a substr() was handed
1N/A=item Can't modify non-lvalue subroutine call
1N/A(F) Subroutines meant to be used in lvalue context should be declared as
1N/Asuch, see L<perlsub/"Lvalue subroutines">.
1N/A=item Can't msgrcv to read-only var
1N/A(F) The target of a msgrcv must be modifiable to be used as a receive
1N/A=item Can't "next" outside a loop block
1N/A(F) A "next" statement was executed to reiterate the current block, but
1N/Athere isn't a current block. Note that an "if" or "else" block doesn't
1N/Acount as a "loopish" block, as doesn't a block given to sort(), map() or
1N/Agrep(). You can usually double the curlies to get the same effect
1N/Athough, because the inner curlies will be considered a block that loops
1N/A=item Can't open %s: %s
1N/A(S inplace) The implicit opening of a file through use of the C<< <> >>
1N/Afilehandle, either implicitly under the C<-n> or C<-p> command-line
1N/Aswitches, or explicitly, failed for the indicated reason. Usually this
1N/Ais because you don't have read permission for a file which you named on
1N/A=item Can't open a reference
1N/A(W io) You tried to open a scalar reference for reading or writing,
1N/Ausing the 3-arg open() syntax :
1N/Abut your version of perl is compiled without perlio, and this form of
1N/Aopen is not supported.
1N/A=item Can't open bidirectional pipe
1N/A(W pipe) You tried to say C<open(CMD, "|cmd|")>, which is not supported.
1N/AYou can try any of several modules in the Perl library to do this, such
1N/Aas IPC::Open2. Alternately, direct the pipe's output to a file using
1N/A">", and then read it in under a different file handle.
1N/A=item Can't open error file %s as stderr
1N/A(F) An error peculiar to VMS. Perl does its own command line
1N/Aredirection, and couldn't open the file specified after '2>' or '2>>' on
1N/Athe command line for writing.
1N/A=item Can't open input file %s as stdin
1N/A(F) An error peculiar to VMS. Perl does its own command line
1N/Aredirection, and couldn't open the file specified after '<' on the
1N/Acommand line for reading.
1N/A=item Can't open output file %s as stdout
1N/A(F) An error peculiar to VMS. Perl does its own command line
1N/Aredirection, and couldn't open the file specified after '>' or '>>' on
1N/Athe command line for writing.
1N/A=item Can't open output pipe (name: %s)
1N/A(P) An error peculiar to VMS. Perl does its own command line
1N/Aredirection, and couldn't open the pipe into which to send data destined
1N/A=item Can't open perl script%s
1N/A(F) The script you specified can't be opened for the indicated reason.
1N/A=item Can't read CRTL environ
1N/A(S) A warning peculiar to VMS. Perl tried to read an element of %ENV
1N/Afrom the CRTL's internal environment array and discovered the array was
1N/Amissing. You need to figure out where your CRTL misplaced its environ
1N/Aor define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not
1N/A=item Can't redefine active sort subroutine %s
1N/A(F) Perl optimizes the internal handling of sort subroutines and keeps
1N/Apointers into them. You tried to redefine one such sort subroutine when
1N/Ait was currently active, which is not allowed. If you really want to do
1N/Athis, you should write C<sort { &func } @x> instead of C<sort func @x>.
1N/A=item Can't "redo" outside a loop block
1N/A(F) A "redo" statement was executed to restart the current block, but
1N/Athere isn't a current block. Note that an "if" or "else" block doesn't
1N/Acount as a "loopish" block, as doesn't a block given to sort(), map()
1N/Aor grep(). You can usually double the curlies to get the same effect
1N/Athough, because the inner curlies will be considered a block that
1N/A=item Can't remove %s: %s, skipping file
1N/A(S inplace) You requested an inplace edit without creating a backup
1N/Afile. Perl was unable to remove the original file to replace it with
1N/Athe modified file. The file was left unmodified.
1N/A=item Can't rename %s to %s: %s, skipping file
1N/A(S inplace) The rename done by the B<-i> switch failed for some reason,
1N/Aprobably because you don't have write permission to the directory.
1N/A=item Can't reopen input pipe (name: %s) in binary mode
1N/A(P) An error peculiar to VMS. Perl thought stdin was a pipe, and tried
1N/Ato reopen it to accept binary data. Alas, it failed.
1N/A=item Can't resolve method `%s' overloading `%s' in package `%s'
1N/A(F|P) Error resolving overloading specified by a method name (as opposed
1N/Ato a subroutine reference): no such method callable via the package. If
1N/Amethod name is C<???>, this is an internal error.
1N/A=item Can't reswap uid and euid
1N/A(P) The setreuid() call failed for some reason in the setuid emulator of
1N/A=item Can't return %s from lvalue subroutine
1N/A(F) Perl detected an attempt to return illegal lvalues (such as
1N/Atemporary or readonly values) from a subroutine used as an lvalue. This
1N/A=item Can't return outside a subroutine
1N/A(F) The return statement was executed in mainline code, that is, where
1N/Athere was no subroutine call to return out of. See L<perlsub>.
1N/A=item Can't return %s to lvalue scalar context
1N/A(F) You tried to return a complete array or hash from an lvalue subroutine,
1N/Abut you called the subroutine in a way that made Perl think you meant
1N/Ato return only one value. You probably meant to write parentheses around
1N/Athe call to the subroutine, which tell Perl that the call should be in
1N/A=item Can't stat script "%s"
1N/A(P) For some reason you can't fstat() the script even though you have it
1N/Aopen already. Bizarre.
1N/A=item Can't swap uid and euid
1N/A(P) The setreuid() call failed for some reason in the setuid emulator of
1N/A=item Can't take log of %g
1N/A(F) For ordinary real numbers, you can't take the logarithm of a
1N/Anegative number or zero. There's a Math::Complex package that comes
1N/Astandard with Perl, though, if you really want to do that for the
1N/A=item Can't take sqrt of %g
1N/A(F) For ordinary real numbers, you can't take the square root of a
1N/Anegative number. There's a Math::Complex package that comes standard
1N/Awith Perl, though, if you really want to do that.
1N/A=item Can't undef active subroutine
1N/A(F) You can't undefine a routine that's currently running. You can,
1N/Ahowever, redefine it while it's running, and you can even undef the
1N/Aredefined subroutine while the old routine is running. Go figure.
1N/A(F) You tried to unshift an "unreal" array that can't be unshifted, such
1N/Aas the main Perl stack.
1N/A=item Can't upgrade that kind of scalar
1N/A(P) The internal sv_upgrade routine adds "members" to an SV, making it
1N/Ainto a more specialized kind of SV. The top several SV types are so
1N/Aspecialized, however, that they cannot be interconverted. This message
1N/Aindicates that such a conversion was attempted.
1N/A=item Can't upgrade to undef
1N/A(P) The undefined SV is the bottom of the totem pole, in the scheme of
1N/Aupgradability. Upgrading to undef indicates an error in the code
1N/A=item Can't use anonymous symbol table for method lookup
1N/A(P) The internal routine that does method lookup was handed a symbol
1N/Atable that doesn't have a name. Symbol tables can become anonymous
1N/Afor example by undefining stashes: C<undef %Some::Package::>.
1N/A=item Can't use an undefined value as %s reference
1N/A(F) A value used as either a hard reference or a symbolic reference must
1N/Abe a defined value. This helps to delurk some insidious errors.
1N/A=item Can't use bareword ("%s") as %s ref while "strict refs" in use
1N/A(F) Only hard references are allowed by "strict refs". Symbolic
1N/Areferences are disallowed. See L<perlref>.
1N/A(F) The first time the %! hash is used, perl automatically loads the
1N/AErrno.pm module. The Errno module is expected to tie the %! hash to
1N/Aprovide symbolic names for C<$!> errno values.
1N/A=item Can't use %s for loop variable
1N/A(F) Only a simple scalar variable may be used as a loop variable on a
1N/A=item Can't use global %s in "my"
1N/A(F) You tried to declare a magical variable as a lexical variable. This
1N/Ais not allowed, because the magic can be tied to only one location
1N/A(namely the global variable) and it would be incredibly confusing to
1N/Ahave variables in your program that looked like magical variables but
1N/A=item Can't use "my %s" in sort comparison
1N/A(F) The global variables $a and $b are reserved for sort comparisons.
1N/AYou mentioned $a or $b in the same line as the <=> or cmp operator,
1N/Aand the variable had earlier been declared as a lexical variable.
1N/AEither qualify the sort variable with the package name, or rename the
1N/A=item Can't use %s ref as %s ref
1N/A(F) You've mixed up your reference types. You have to dereference a
1N/Areference of the type needed. You can use the ref() function to
1N/Atest the type of the reference, if need be.
1N/A=item Can't use string ("%s") as %s ref while "strict refs" in use
1N/A(F) Only hard references are allowed by "strict refs". Symbolic
1N/Areferences are disallowed. See L<perlref>.
1N/A=item Can't use subscript on %s
1N/A(F) The compiler tried to interpret a bracketed expression as a
1N/Asubscript. But to the left of the brackets was an expression that
1N/Adidn't look like an array reference, or anything else subscriptable.
1N/A=item Can't use \%c to mean $%c in expression
1N/A(W syntax) In an ordinary expression, backslash is a unary operator that
1N/Acreates a reference to its argument. The use of backslash to indicate a
1N/Abackreference to a matched substring is valid only as part of a regular
1N/Aexpression pattern. Trying to do this in ordinary Perl code produces a
1N/Avalue that prints out looking like SCALAR(0xdecaf). Use the $1 form
1N/A=item Can't weaken a nonreference
1N/A(F) You attempted to weaken something that was not a reference. Only
1N/Areferences can be weakened.
1N/A=item Can't x= to read-only value
1N/A(F) You tried to repeat a constant value (often the undefined value)
1N/Awith an assignment operator, which implies modifying the value itself.
1N/APerhaps you need to copy the value to a temporary, and repeat that.
1N/A=item Character in "C" format wrapped in pack
1N/Awhere $x is either less than 0 or more than 255; the C<"C"> format is
1N/Aonly for encoding native operating system characters (ASCII, EBCDIC,
1N/Aand so on) and not for Unicode characters, so Perl behaved as if you meant
1N/AIf you actually want to pack Unicode codepoints, use the C<"U"> format
1N/A=item Character in "c" format wrapped in pack
1N/Awhere $x is either less than -128 or more than 127; the C<"c"> format
1N/Ais only for encoding native operating system characters (ASCII, EBCDIC,
1N/Aand so on) and not for Unicode characters, so Perl behaved as if you meant
1N/A pack("c", $x & 255);
1N/AIf you actually want to pack Unicode codepoints, use the C<"U"> format
1N/A=item close() on unopened filehandle %s
1N/A(W unopened) You tried to close a filehandle that was never opened.
1N/A=item Code missing after '/'
1N/A(F) You had a (sub-)template that ends with a '/'. There must be another
1N/A=item %s: Command not found
1N/A(A) You've accidentally run your script through B<csh> instead of Perl.
1N/ACheck the #! line, or manually feed your script into Perl yourself.
1N/A=item Compilation failed in require
1N/A(F) Perl could not compile a file specified in a C<require> statement.
1N/APerl uses this generic message when none of the errors that it
1N/Aencountered were severe enough to halt compilation immediately.
1N/A=item Complex regular subexpression recursion limit (%d) exceeded
1N/A(W regexp) The regular expression engine uses recursion in complex
1N/Asituations where back-tracking is required. Recursion depth is limited
1N/Ato 32766, or perhaps less in architectures where the stack cannot grow
1N/Aarbitrarily. ("Simple" and "medium" situations are handled without
1N/Arecursion and are not subject to a limit.) Try shortening the string
1N/Aunder examination; looping in Perl code (
e.g. with C<while>) rather than
1N/Ain the regular expression engine; or rewriting the regular expression so
1N/Athat it is simpler or backtracks less. (See L<perlfaq2> for information
1N/Aon I<Mastering Regular Expressions>.)
1N/A=item cond_broadcast() called on unlocked variable
1N/A(W threads) Within a thread-enabled program, you tried to call
1N/Acond_broadcast() on a variable which wasn't locked. The cond_broadcast()
1N/Afunction is used to wake up another thread that is waiting in a
1N/Acond_wait(). To ensure that the signal isn't sent before the other thread
1N/Ahas a chance to enter the wait, it is usual for the signaling thread to
1N/Afirst wait for a lock on variable. This lock attempt will only succeed
1N/Aafter the other thread has entered cond_wait() and thus relinquished the
1N/A=item cond_signal() called on unlocked variable
1N/A(W threads) Within a thread-enabled program, you tried to call
1N/Acond_signal() on a variable which wasn't locked. The cond_signal()
1N/Afunction is used to wake up another thread that is waiting in a
1N/Acond_wait(). To ensure that the signal isn't sent before the other thread
1N/Ahas a chance to enter the wait, it is usual for the signaling thread to
1N/Afirst wait for a lock on variable. This lock attempt will only succeed
1N/Aafter the other thread has entered cond_wait() and thus relinquished the
1N/A=item connect() on closed socket %s
1N/A(W closed) You tried to do a connect on a closed socket. Did you forget
1N/Ato check the return value of your socket() call? See
1N/A=item Constant(%s)%s: %s
1N/A(F) The parser found inconsistencies either while attempting to define
1N/Aan overloaded constant, or when trying to find the character name
1N/Aspecified in the C<\N{...}> escape. Perhaps you forgot to load the
1N/Acorresponding C<overload> or C<charnames> pragma? See L<charnames> and
1N/A=item Constant is not %s reference
1N/A(F) A constant value (perhaps declared using the C<use constant> pragma)
1N/Ais being dereferenced, but it amounts to the wrong type of reference.
1N/AThe message indicates the type of reference that was expected. This
1N/Ausually indicates a syntax error in dereferencing the constant value.
1N/ASee L<perlsub/"Constant Functions"> and L<constant>.
1N/A=item Constant subroutine %s redefined
1N/A(S) You redefined a subroutine which had previously been
1N/Aeligible for inlining. See L<perlsub/"Constant Functions"> for
1N/Acommentary and workarounds.
1N/A=item Constant subroutine %s undefined
1N/A(W misc) You undefined a subroutine which had previously been eligible
1N/Afor inlining. See L<perlsub/"Constant Functions"> for commentary and
1N/A=item Copy method did not return a reference
1N/A(F) The method which overloads "=" is buggy. See
1N/A=item CORE::%s is not a keyword
1N/A(F) The CORE:: namespace is reserved for Perl keywords.
1N/A=item corrupted regexp pointers
1N/A(P) The regular expression engine got confused by what the regular
1N/Aexpression compiler gave it.
1N/A=item corrupted regexp program
1N/A(P) The regular expression engine got passed a regexp program without a
1N/A=item Corrupt malloc ptr 0x%lx at 0x%lx
1N/A(P) The malloc package that comes with Perl had an internal failure.
1N/A(F) You had an unpack template indicating a counted-length string, but
1N/Ayou have also specified an explicit size for the string. See
1N/A=item Deep recursion on subroutine "%s"
1N/A(W recursion) This subroutine has called itself (directly or indirectly)
1N/A100 times more than it has returned. This probably indicates an
1N/Ainfinite recursion, unless you're writing strange benchmark programs, in
1N/Awhich case it indicates something else.
1N/A=item defined(@array) is deprecated
1N/A(D deprecated) defined() is not usually useful on arrays because it
1N/Achecks for an undefined I<scalar> value. If you want to see if the
1N/Aarray is empty, just use C<if (@array) { # not empty }> for example.
1N/A=item defined(%hash) is deprecated
1N/A(D deprecated) defined() is not usually useful on hashes because it
1N/Achecks for an undefined I<scalar> value. If you want to see if the hash
1N/Ais empty, just use C<if (%hash) { # not empty }> for example.
1N/A=item %s defines neither package nor VERSION--version check failed
1N/A(F) You said something like "use Module 42" but in the Module file
1N/Athere are neither package declarations nor a C<$VERSION>.
1N/A=item Delimiter for here document is too long
1N/A(F) In a here document construct like C<<<FOO>, the label C<FOO> is too
1N/Along for Perl to handle. You have to be seriously twisted to write code
1N/Athat triggers this error.
1N/A=item DESTROY created new reference to dead object '%s'
1N/A(F) A DESTROY() method created a new reference to the object which is
1N/Ajust being DESTROYed. Perl is confused, and prefers to abort rather than
1N/Ato create a dangling reference.
1N/A=item Did not produce a valid header
1N/A=item %s did not return a true value
1N/A(F) A required (or used) file must return a true value to indicate that
1N/Ait compiled correctly and ran its initialization code correctly. It's
1N/Atraditional to end such a file with a "1;", though any true value would
1N/A=item (Did you mean &%s instead?)
1N/A(W) You probably referred to an imported subroutine &FOO as $FOO or some
1N/A=item (Did you mean "local" instead of "our"?)
1N/A(W misc) Remember that "our" does not localize the declared global
1N/Avariable. You have declared it again in the same lexical scope, which
1N/A=item (Did you mean $ or @ instead of %?)
1N/A(W) You probably said %hash{$key} when you meant $hash{$key} or
1N/A@hash{@keys}. On the other hand, maybe you just meant %hash and got
1N/A(F) You passed die() an empty string (the equivalent of C<die "">) or
1N/Ayou called it with no args and both C<$@> and C<$_> were empty.
1N/A=item Document contains no data
1N/A=item %s does not define %s::VERSION--version check failed
1N/A(F) You said something like "use Module 42" but the Module did not
1N/Adefine a C<$VERSION.>
1N/A=item '/' does not take a repeat count
1N/A(F) You cannot put a repeat count of any kind right after the '/' code.
1N/A=item Don't know how to handle magic of type '%s'
1N/A(P) The internal handling of magical variables has been cursed.
1N/A=item do_study: out of memory
1N/A(P) This should have been caught by safemalloc() instead.
1N/A=item (Do you need to predeclare %s?)
1N/A(S syntax) This is an educated guess made in conjunction with the message
1N/A"%s found where operator expected". It often means a subroutine or module
1N/Aname is being referenced that hasn't been declared yet. This may be
1N/Abecause of ordering problems in your file, or because of a missing
1N/A"sub", "package", "require", or "use" statement. If you're referencing
1N/Asomething that isn't defined yet, you don't actually have to define the
1N/Asubroutine or package before the current location. You can use an empty
1N/A"sub foo;" or "package FOO;" to enter a "forward" declaration.
1N/A=item dump() better written as CORE::dump()
1N/A(W misc) You used the obsolescent C<dump()> built-in function, without fully
1N/A=item Duplicate free() ignored
1N/A(S malloc) An internal routine called free() on something that had
1N/A=item elseif should be elsif
1N/A(S syntax) There is no keyword "elseif" in Perl because Larry thinks it's
1N/Augly. Your code will be interpreted as an attempt to call a method named
1N/A"elseif" for the class returned by the following block. This is
1N/Aunlikely to be what you want.
1N/A(F) C<\p> and C<\P> are used to introduce a named Unicode property, as
1N/Adescribed in L<perlunicode> and L<perlre>. You used C<\p> or C<\P> in
1N/Aa regular expression without specifying the property name.
1N/A=item entering effective %s failed
1N/A(F) While under the C<use filetest> pragma, switching the real and
1N/Aeffective uids or gids failed.
1N/A=item Error converting file specification %s
1N/A(F) An error peculiar to VMS. Because Perl may have to deal with file
1N/Aspecifications in either VMS or Unix syntax, it converts them to a
1N/Asingle form when it must operate on them directly. Either you've passed
1N/Aan invalid file specification to Perl, or you've found a case the
1N/Aconversion routines don't handle. Drat.
1N/A=item %s: Eval-group in insecure regular expression
1N/A(F) Perl detected tainted data when trying to compile a regular
1N/Aexpression that contains the C<(?{ ... })> zero-width assertion, which
1N/Ais unsafe. See L<perlre/(?{ code })>, and L<perlsec>.
1N/A=item %s: Eval-group not allowed at run time
1N/A(F) Perl tried to compile a regular expression containing the
1N/AC<(?{ ... })> zero-width assertion at run time, as it would when the
1N/Apattern contains interpolated values. Since that is a security risk, it
1N/Ais not allowed. If you insist, you may still do this by explicitly
1N/Abuilding the pattern from an interpolated string at run time and using
1N/Athat in an eval(). See L<perlre/(?{ code })>.
1N/A=item %s: Eval-group not allowed, use re 'eval'
1N/A(F) A regular expression contained the C<(?{ ... })> zero-width
1N/Aassertion, but that construct is only allowed when the C<use re 'eval'>
1N/Apragma is in effect. See L<perlre/(?{ code })>.
1N/A=item Excessively long <> operator
1N/A(F) The contents of a <> operator may not exceed the maximum size of a
1N/APerl identifier. If you're just trying to glob a long list of
1N/Afilenames, try using the glob() operator, or put the filenames into a
1N/Avariable and glob that.
1N/A=item exec? I'm not *that* kind of operating system
1N/A(F) The C<exec> function is not implemented in MacPerl. See L<perlport>.
1N/A=item Execution of %s aborted due to compilation errors
1N/A(F) The final summary message when a Perl compilation fails.
1N/A=item Exiting eval via %s
1N/A(W exiting) You are exiting an eval by unconventional means, such as a
1N/Agoto, or a loop control statement.
1N/A=item Exiting format via %s
1N/A(W exiting) You are exiting a format by unconventional means, such as a
1N/Agoto, or a loop control statement.
1N/A=item Exiting pseudo-block via %s
1N/A(W exiting) You are exiting a rather special block construct (like a
1N/Asort block or subroutine) by unconventional means, such as a goto, or a
1N/A=item Exiting subroutine via %s
1N/A(W exiting) You are exiting a subroutine by unconventional means, such
1N/Aas a goto, or a loop control statement.
1N/A=item Exiting substitution via %s
1N/A(W exiting) You are exiting a substitution by unconventional means, such
1N/Aas a return, a goto, or a loop control statement.
1N/A=item Explicit blessing to '' (assuming package main)
1N/A(W misc) You are blessing a reference to a zero length string. This has
1N/Athe effect of blessing the reference into the package main. This is
1N/Ausually not what you want. Consider providing a default target package,
1N/Ae.g. bless($ref, $p || 'MyPackage');
1N/A=item %s: Expression syntax
1N/A(A) You've accidentally run your script through B<csh> instead of Perl.
1N/ACheck the #! line, or manually feed your script into Perl yourself.
1N/A=item %s failed--call queue aborted
1N/A(F) An untrapped exception was raised while executing a CHECK, INIT, or
1N/AEND subroutine. Processing of the remainder of the queue of such
1N/Aroutines has been prematurely ended.
1N/A=item False [] range "%s" in regex; marked by <-- HERE in m/%s/
1N/A(W regexp) A character class range must start and end at a literal
1N/Acharacter, not another character class like C<\d> or C<[:alpha:]>. The "-"
1N/Ain your false range is interpreted as a literal "-". Consider quoting the
1N/A"-", "\-". The <-- HERE shows in the regular expression about where the
1N/Aproblem was discovered. See L<perlre>.
1N/A=item Fatal VMS error at %s, line %d
1N/A(P) An error peculiar to VMS. Something untoward happened in a VMS
1N/Asystem service or RTL routine; Perl's exit status should provide more
1N/Adetails. The filename in "at %s" and the line number in "line %d" tell
1N/Ayou which section of the Perl source code is distressed.
1N/A=item fcntl is not implemented
1N/A(F) Your machine apparently doesn't implement fcntl(). What is this, a
1N/A=item Filehandle %s opened only for input
1N/A(W io) You tried to write on a read-only filehandle. If you intended
1N/Ait to be a read-write filehandle, you needed to open it with "+<" or
1N/A"+>" or "+>>" instead of with "<" or nothing. If you intended only to
1N/A=item Filehandle %s opened only for output
1N/A(W io) You tried to read from a filehandle opened only for writing, If
1N/Ayou intended it to be a
read/write filehandle, you needed to open it
1N/Awith "+<" or "+>" or "+>>" instead of with "<" or nothing. If you
1N/AAnother possibility is that you attempted to open filedescriptor 0
1N/A(also known as STDIN) for output (maybe you closed STDIN earlier?).
1N/A=item Filehandle %s reopened as %s only for input
1N/A(W io) You opened for reading a filehandle that got the same filehandle id
1N/Aas STDOUT or STDERR. This occured because you closed STDOUT or STDERR
1N/A=item Filehandle STDIN reopened as %s only for output
1N/A(W io) You opened for writing a filehandle that got the same filehandle id
1N/Aas STDIN. This occured because you closed STDIN previously.
1N/A=item Final $ should be \$ or $name
1N/A(F) You must now decide whether the final $ in a string was meant to be
1N/Aa literal dollar sign, or was meant to introduce a variable name that
1N/Ahappens to be missing. So you have to put either the backslash or the
1N/A=item flock() on closed filehandle %s
1N/A(W closed) The filehandle you're attempting to flock() got itself closed
1N/Asome time before now. Check your control flow. flock() operates on
1N/Afilehandles. Are you attempting to call flock() on a dirhandle by the
1N/A=item Format not terminated
1N/A(F) A format must be terminated by a line with a solitary dot. Perl got
1N/Ato the end of your file without finding such a line.
1N/A=item Format %s redefined
1N/A(W redefine) You redefined a format. To suppress this warning, say
1N/A no warnings 'redefine';
1N/A eval "format NAME =...";
1N/A=item Found = in conditional, should be ==
1N/A(or something like that).
1N/A=item %s found where operator expected
1N/A(S syntax) The Perl lexer knows whether to expect a term or an operator.
1N/AIf it sees what it knows to be a term when it was expecting to see an
1N/Aoperator, it gives you this warning. Usually it indicates that an
1N/Aoperator or delimiter was omitted, such as a semicolon.
1N/A=item gdbm store returned %d, errno %d, key "%s"
1N/A(S) A warning from the GDBM_File extension that a store failed.
1N/A=item gethostent not implemented
1N/A(F) Your C library apparently doesn't implement gethostent(), probably
1N/Abecause if it did, it'd feel morally obligated to return every hostname
1N/A=item get%sname() on closed socket %s
1N/A(W closed) You tried to get a socket or peer socket name on a closed
1N/Asocket. Did you forget to check the return value of your socket() call?
1N/A=item getpwnam returned invalid UIC %#o for user "%s"
1N/A(S) A warning peculiar to VMS. The call to C<sys$getuai> underlying the
1N/AC<getpwnam> operator returned an invalid UIC.
1N/A=item getsockopt() on closed socket %s
1N/A(W closed) You tried to get a socket option on a closed socket. Did you
1N/Aforget to check the return value of your socket() call? See
1N/A=item Global symbol "%s" requires explicit package name
1N/A(F) You've said "use strict vars", which indicates that all variables
1N/Amust either be lexically scoped (using "my"), declared beforehand using
1N/A"our", or explicitly qualified to say which package the global variable
1N/A=item glob failed (%s)
1N/A(W glob) Something went wrong with the external program(s) used for
1N/AC<glob> and C<< <*.c> >>. Usually, this means that you supplied a
1N/AC<glob> pattern that caused the external program to fail and exit with a
1N/Anonzero status. If the message indicates that the abnormal exit
1N/Aresulted in a coredump, this may also mean that your csh (C shell) is
1N/Abroken. If so, you should change all of the csh-related variables in
1N/Aconfig.sh: If you have tcsh, make the variables refer to it as if it
1N/Aempty (except that C<d_csh> should be C<'undef'>) so that Perl will
1N/Athink csh is missing. In either case, after editing
config.sh, run
1N/AC<./Configure -S> and rebuild Perl.
1N/A=item Glob not terminated
1N/A(F) The lexer saw a left angle bracket in a place where it was expecting
1N/Aa term, so it's looking for the corresponding right angle bracket, and
1N/Anot finding it. Chances are you left some needed parentheses out
1N/Aearlier in the line, and you really meant a "less than".
1N/A=item Got an error from DosAllocMem
1N/A(P) An error peculiar to OS/2. Most probably you're using an obsolete
1N/Aversion of Perl, and this should not happen anyway.
1N/A=item goto must have label
1N/A(F) Unlike with "next" or "last", you're not allowed to goto an
1N/A=item ()-group starts with a count
1N/A(F) A ()-group started with a count. A count is
1N/Asupposed to follow something: a template character or a ()-group.
1N/A=item %s had compilation errors
1N/A(F) The final summary message when a C<perl -c> fails.
1N/A=item Had to create %s unexpectedly
1N/A(S internal) A routine asked for a symbol from a symbol table that ought
1N/Ato have existed already, but for some reason it didn't, and had to be
1N/Acreated on an emergency basis to prevent a core dump.
1N/A=item Hash %%s missing the % in argument %d of %s()
1N/A(D deprecated) Really old Perl let you omit the % on hash names in some
1N/Aspots. This is now heavily deprecated.
1N/A=item %s has too many errors
1N/A(F) The parser has given up trying to parse the program after 10 errors.
1N/AFurther error messages would likely be uninformative.
1N/A=item Hexadecimal number > 0xffffffff non-portable
1N/A(W portable) The hexadecimal number you specified is larger than 2**32-1
1N/A(4294967295) and therefore non-portable between systems. See
1N/AL<perlport> for more on portability concerns.
1N/A=item Identifier too long
1N/A(F) Perl limits identifiers (names for variables, functions, etc.) to
1N/Aabout 250 characters for simple names, and somewhat more for compound
1N/Anames (like C<$A::B>). You've exceeded Perl's limits. Future versions
1N/Aof Perl are likely to eliminate these arbitrary limitations.
1N/A=item Illegal binary digit %s
1N/A(F) You used a digit other than 0 or 1 in a binary number.
1N/A=item Illegal binary digit %s ignored
1N/A(W digit) You may have tried to use a digit other than 0 or 1 in a
1N/Abinary number. Interpretation of the binary number stopped before the
1N/A=item Illegal character %s (carriage return)
1N/A(F) Perl normally treats carriage returns in the program text as it
1N/Awould any other whitespace, which means you should never see this error
1N/Awhen Perl was built using standard options. For some reason, your
1N/Aversion of Perl appears to have been built without this support. Talk
1N/Ato your Perl administrator.
1N/A=item Illegal character in prototype for %s : %s
1N/A(W syntax) An illegal character was found in a prototype declaration. Legal
1N/Acharacters in prototypes are $, @, %, *, ;, [, ], &, and \.
1N/A=item Illegal declaration of anonymous subroutine
1N/A(F) When using the C<sub> keyword to construct an anonymous subroutine,
1N/Ayou must always specify a block of code. See L<perlsub>.
1N/A=item Illegal division by zero
1N/A(F) You tried to divide a number by 0. Either something was wrong in
1N/Ayour logic, or you need to put a conditional in to guard against
1N/A=item Illegal hexadecimal digit %s ignored
1N/A(W digit) You may have tried to use a character other than 0 - 9 or
1N/AA - F, a - f in a hexadecimal number. Interpretation of the hexadecimal
1N/Anumber stopped before the illegal character.
1N/A=item Illegal modulus zero
1N/A(F) You tried to divide a number by 0 to get the remainder. Most
1N/Anumbers don't take to this kindly.
1N/A=item Illegal number of bits in vec
1N/A(F) The number of bits in vec() (the third argument) must be a power of
1N/Atwo from 1 to 32 (or 64, if your platform supports that).
1N/A=item Illegal octal digit %s
1N/A(F) You used an 8 or 9 in an octal number.
1N/A=item Illegal octal digit %s ignored
1N/A(W digit) You may have tried to use an 8 or 9 in an octal number.
1N/AInterpretation of the octal number stopped before the 8 or 9.
1N/A=item Illegal switch in PERL5OPT: %s
1N/A(X) The PERL5OPT environment variable may only be used to set the
1N/Afollowing switches: B<-[DIMUdmtw]>.
1N/A=item Ill-formed CRTL environ value "%s"
1N/A(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's
1N/Ainternal environ array, and encountered an element without the C<=>
1N/Adelimiter used to separate keys from values. The element is ignored.
1N/A=item Ill-formed message in prime_env_iter: |%s|
1N/A(W internal) A warning peculiar to VMS. Perl tried to read a logical
1N/Aname or CLI symbol definition when preparing to iterate over %ENV, and
1N/Adidn't see the expected delimiter between key and value, so the line was
1N/A=item (in cleanup) %s
1N/A(W misc) This prefix usually indicates that a DESTROY() method raised
1N/Athe indicated exception. Since destructors are usually called by the
1N/Asystem at arbitrary points during execution, and often a vast number of
1N/Atimes, the warning is issued only once for any number of failures that
1N/Awould otherwise result in the same message being repeated.
1N/AFailure of user callbacks dispatched using the C<G_KEEPERR> flag could
1N/A=item In EBCDIC the v-string components cannot exceed 2147483647
1N/A(F) An error peculiar to EBCDIC. Internally, v-strings are stored as
1N/AUnicode code points, and encoded in EBCDIC as UTF-EBCDIC. The UTF-EBCDIC
1N/Aencoding is limited to code points no larger than 2147483647 (0x7FFFFFFF).
1N/A=item Insecure dependency in %s
1N/A(F) You tried to do something that the tainting mechanism didn't like.
1N/AThe tainting mechanism is turned on when you're running setuid or
1N/Asetgid, or when you specify B<-T> to turn it on explicitly. The
1N/Atainting mechanism labels all data that's derived directly or indirectly
1N/Afrom the user, who is considered to be unworthy of your trust. If any
1N/Asuch data is used in a "dangerous" operation, you get this error. See
1N/AL<perlsec> for more information.
1N/A=item Insecure directory in %s
1N/A(F) You can't use system(), exec(), or a piped open in a setuid or
1N/Asetgid script if C<$ENV{PATH}> contains a directory that is writable by
1N/Athe world. See L<perlsec>.
1N/A=item Insecure $ENV{%s} while running %s
1N/A(F) You can't use system(), exec(), or a piped open in a setuid or
1N/Asetgid script if any of C<$ENV{PATH}>, C<$ENV{IFS}>, C<$ENV{CDPATH}>,
1N/AC<$ENV{ENV}>, C<$ENV{BASH_ENV}> or C<$ENV{TERM}> are derived from data
1N/Asupplied (or potentially supplied) by the user. The script must set
1N/Athe path to a known value, using trustworthy data. See L<perlsec>.
1N/A=item Integer overflow in %s number
1N/A(W overflow) The hexadecimal, octal or binary number you have specified
1N/Aeither as a literal or as an argument to hex() or oct() is too big for
1N/Ayour architecture, and has been converted to a floating point number.
1N/AOn a 32-bit architecture the largest hexadecimal, octal or binary number
1N/Arepresentable without overflow is 0xFFFFFFFF, 037777777777, or
1N/A0b11111111111111111111111111111111 respectively. Note that Perl
1N/Atransparently promotes all numbers to a floating point representation
1N/Ainternally--subject to loss of precision errors in subsequent
1N/A=item Internal disaster in regex; marked by <-- HERE in m/%s/
1N/A(P) Something went badly wrong in the regular expression parser.
1N/AThe <-- HERE shows in the regular expression about where the problem was
1N/A=item Internal inconsistency in tracking vforks
1N/A(S) A warning peculiar to VMS. Perl keeps track of the number of times
1N/Ayou've called C<fork> and C<exec>, to determine whether the current call
1N/Ato C<exec> should affect the current script or a subprocess (see
1N/AL<perlvms/"exec LIST">). Somehow, this count has become scrambled, so
1N/APerl is making a guess and treating this C<exec> as a request to
1N/Aterminate the Perl script and execute the specified command.
1N/A=item Internal urp in regex; marked by <-- HERE in m/%s/
1N/A(P) Something went badly awry in the regular expression parser. The
1N/A<-- HERE shows in the regular expression about where the problem was
1N/A=item %s (...) interpreted as function
1N/A(W syntax) You've run afoul of the rule that says that any list operator
1N/Afollowed by parentheses turns into a function, with all the list
1N/Aoperators arguments found inside the parentheses. See
1N/A=item Invalid %s attribute: %s
1N/AThe indicated attribute for a subroutine or variable was not recognized
1N/Aby Perl or by a user-supplied handler. See L<attributes>.
1N/A=item Invalid %s attributes: %s
1N/AThe indicated attributes for a subroutine or variable were not
1N/Arecognized by Perl or by a user-supplied handler. See L<attributes>.
1N/A=item Invalid conversion in %s: "%s"
1N/A(W printf) Perl does not understand the given format conversion. See
1N/A=item Invalid [] range "%s" in regex; marked by <-- HERE in m/%s/
1N/A(F) The range specified in a character class had a minimum character
1N/Agreater than the maximum character. One possibility is that you forgot the
1N/AC<{}> from your ending C<\x{}> - C<\x> without the curly braces can go only
1N/Aup to C<ff>. The <-- HERE shows in the regular expression about where the
1N/Aproblem was discovered. See L<perlre>.
1N/A=item Invalid range "%s" in transliteration operator
1N/A(F) The range specified in the tr/// or y/// operator had a minimum
1N/Acharacter greater than the maximum character. See L<perlop>.
1N/A=item Invalid separator character %s in attribute list
1N/A(F) Something other than a colon or whitespace was seen between the
1N/Aelements of an attribute list. If the previous attribute had a
1N/Aparenthesised parameter list, perhaps that list was terminated too soon.
1N/A=item Invalid separator character %s in PerlIO layer specification %s
1N/A(W layer) When pushing layers onto the Perl I/O system, something other than a
1N/Acolon or whitespace was seen between the elements of a layer list.
1N/AIf the previous attribute had a parenthesised parameter list, perhaps that
1N/Alist was terminated too soon.
1N/A=item Invalid type '%s' in %s
1N/A(F) The given character is not a valid pack or unpack type.
1N/A(W) The given character is not a valid pack or unpack type but used to be
1N/A=item ioctl is not implemented
1N/A(F) Your machine apparently doesn't implement ioctl(), which is pretty
1N/Astrange for a machine that supports C.
1N/A=item ioctl() on unopened %s
1N/A(W unopened) You tried ioctl() on a filehandle that was never opened.
1N/ACheck you control flow and number of arguments.
1N/A=item IO layers (like "%s") unavailable
1N/A(F) Your Perl has not been configured to have PerlIO, and therefore
1N/Ayou cannot use IO layers. To have PerlIO Perl must be configured
1N/A=item IO::Socket::atmark not implemented on this architecture
1N/A(F) Your machine doesn't implement the sockatmark() functionality,
1N/Aneither as a system call or an ioctl call (SIOCATMARK).
1N/A=item `%s' is not a code reference
1N/A(W overload) The second (fourth, sixth, ...) argument of overload::constant
1N/Aneeds to be a code reference. Either an anonymous subroutine, or a reference
1N/A=item `%s' is not an overloadable type
1N/A(W overload) You tried to overload a constant type the overload package is
1N/A=item junk on end of regexp
1N/A(P) The regular expression parser is confused.
1N/A=item Label not found for "last %s"
1N/A(F) You named a loop to break out of, but you're not currently in a loop
1N/Aof that name, not even if you count where you were called from. See
1N/A=item Label not found for "next %s"
1N/A(F) You named a loop to continue, but you're not currently in a loop of
1N/Athat name, not even if you count where you were called from. See
1N/A=item Label not found for "redo %s"
1N/A(F) You named a loop to restart, but you're not currently in a loop of
1N/Athat name, not even if you count where you were called from. See
1N/A=item leaving effective %s failed
1N/A(F) While under the C<use filetest> pragma, switching the real and
1N/Aeffective uids or gids failed.
1N/A(F) While unpacking, the string buffer was alread used up when an unpack
1N/A=item listen() on closed socket %s
1N/A(W closed) You tried to do a listen on a closed socket. Did you forget
1N/Ato check the return value of your socket() call? See
1N/A=item Lookbehind longer than %d not implemented in regex; marked by <-- HERE in m/%s/
1N/A(F) There is currently a limit on the length of string which lookbehind can
1N/Ahandle. This restriction may be eased in a future release. The <-- HERE
1N/Ashows in the regular expression about where the problem was discovered.
1N/A=item lstat() on filehandle %s
1N/A(W io) You tried to do an lstat on a filehandle. What did you mean
1N/Aby that? lstat() makes sense only on filenames. (Perl did a fstat()
1N/Ainstead on the filehandle.)
1N/A=item Lvalue subs returning %s not implemented yet
1N/A(F) Due to limitations in the current implementation, array and hash
1N/Avalues cannot be returned in subroutines used in lvalue context. See
1N/AL<perlsub/"Lvalue subroutines">.
1N/A=item Malformed integer in [] in pack
1N/A(F) Between the brackets enclosing a numeric repeat count only digits
1N/A=item Malformed integer in [] in unpack
1N/A(F) Between the brackets enclosing a numeric repeat count only digits
1N/A=item Malformed PERLLIB_PREFIX
1N/A(F) An error peculiar to OS/2. PERLLIB_PREFIX should be of the form
1N/Awith nonempty prefix1 and prefix2. If C<prefix1> is indeed a prefix of
1N/Aa builtin library search path, prefix2 is substituted. The error may
1N/Aappear if components are not found, or are too long. See
1N/A"PERLLIB_PREFIX" in L<perlos2>.
1N/A=item Malformed prototype for %s: %s
1N/A(F) You tried to use a function with a malformed prototype. The
1N/Asyntax of function prototypes is given a brief compile-time check for
1N/Aobvious errors like invalid characters. A more rigorous check is run
1N/Awhen the function is called.
1N/A=item Malformed UTF-8 character (%s)
1N/APerl detected something that didn't comply with UTF-8 encoding rules.
1N/AOne possible cause is that you read in data that you thought to be in
1N/AUTF-8 but it wasn't (it was for example legacy 8-bit data). Another
1N/Apossibility is careless use of utf8::upgrade().
1N/A=item Malformed UTF-16 surrogate
1N/APerl thought it was reading UTF-16 encoded character data but while
1N/Adoing it Perl met a malformed Unicode surrogate.
1N/A=item %s matches null string many times in regex; marked by <-- HERE in m/%s/
1N/A(W regexp) The pattern you've specified would be an infinite loop if the
1N/Aregular expression engine didn't specifically check for that. The <-- HERE
1N/Ashows in the regular expression about where the problem was discovered.
1N/A=item "%s" may clash with future reserved word
1N/A(W) This warning may be due to running a perl5 script through a perl4
1N/Ainterpreter, especially if the word that is being warned about is
1N/A=item % may not be used in pack
1N/A(F) You can't pack a string by supplying a checksum, because the
1N/Achecksumming process loses information, and you can't go the other way.
1N/A=item Method for operation %s not found in package %s during blessing
1N/A(F) An attempt was made to specify an entry in an overloading table that
1N/Adoesn't resolve to a valid subroutine. See L<overload>.
1N/A=item Method %s not permitted
1N/A=item Might be a runaway multi-line %s string starting on line %d
1N/A(S) An advisory indicating that the previous error may have been caused
1N/Aby a missing delimiter on a string or pattern, because it eventually
1N/Aended earlier on the current line.
1N/A=item Misplaced _ in number
1N/A(W syntax) An underscore (underbar) in a numeric constant did not
1N/A=item Missing %sbrace%s on \N{}
1N/A(F) Wrong syntax of character name literal C<\N{charname}> within
1N/Adouble-quotish context.
1N/A=item Missing comma after first argument to %s function
1N/A(F) While certain functions allow you to specify a filehandle or an
1N/A"indirect object" before the argument list, this ain't one of them.
1N/A=item Missing command in piped open
1N/A(W pipe) You used the C<open(FH, "| command")> or
1N/AC<open(FH, "command |")> construction, but the command was missing or
1N/A=item Missing control char name in \c
1N/A(F) A double-quoted string ended with "\c", without the required control
1N/A=item Missing name in "my sub"
1N/A(F) The reserved syntax for lexically scoped subroutines requires that
1N/Athey have a name with which they can be found.
1N/A=item Missing $ on loop variable
1N/A(F) Apparently you've been programming in B<csh> too much. Variables
1N/Aare always mentioned with the $ in Perl, unlike in the shells, where it
1N/Acan vary from one line to the next.
1N/A=item (Missing operator before %s?)
1N/A(S syntax) This is an educated guess made in conjunction with the message
1N/A"%s found where operator expected". Often the missing operator is a comma.
1N/A=item Missing right brace on %s
1N/A(F) Missing right brace in C<\p{...}> or C<\P{...}>.
1N/A=item Missing right curly or square bracket
1N/A(F) The lexer counted more opening curly or square brackets than closing
1N/Aones. As a general rule, you'll find it's missing near the place you
1N/A=item (Missing semicolon on previous line?)
1N/A(S syntax) This is an educated guess made in conjunction with the message
1N/A"%s found where operator expected". Don't automatically put a semicolon on
1N/Athe previous line just because you saw this message.
1N/A=item Modification of a read-only value attempted
1N/A(F) You tried, directly or indirectly, to change the value of a
1N/Aconstant. You didn't, of course, try "2 = 1", because the compiler
1N/Acatches that. But an easy way to do the same thing is:
1N/A sub mod { $_[0] = 1 }
1N/AAnother way is to assign to a substr() that's off the end of the string.
1N/AYet another way is to assign to a C<foreach> loop I<VAR> when I<VAR>
1N/Ais aliased to a constant in the look I<LIST>:
1N/A foreach my $n ($x, 2) {
1N/A $n *= 2; # modifies the $x, but fails on attempt to modify the 2
1N/A=item Modification of non-creatable array value attempted, %s
1N/A(F) You tried to make an array value spring into existence, and the
1N/Asubscript was probably negative, even counting from end of the array
1N/A=item Modification of non-creatable hash value attempted, %s
1N/A(P) You tried to make a hash value spring into existence, and it
1N/Acouldn't be created for some peculiar reason.
1N/A=item Module name must be constant
1N/A(F) Only a bare module name is allowed as the first argument to a "use".
1N/A=item Module name required with -%c option
1N/A(F) The C<-M> or C<-m> options say that Perl should load some module, but
1N/Ayou omitted the name of the module. Consult L<perlrun> for full details
1N/Aabout C<-M> and C<-m>.
1N/A=item More than one argument to open
1N/A(F) The C<open> function has been asked to open multiple files. This
1N/Acan happen if you are trying to open a pipe to a command that takes a
1N/Alist of arguments, but have forgotten to specify a piped open mode.
1N/A=item msg%s not implemented
1N/A(F) You don't have System V message IPC on your system.
1N/A=item Multidimensional syntax %s not supported
1N/A(W syntax) Multidimensional arrays aren't written like C<$foo[1,2,3]>.
1N/AThey're written like C<$foo[1][2][3]>, as in C.
1N/A=item '/' must be followed by 'a*', 'A*' or 'Z*'
1N/A(F) You had a pack template indicating a counted-length string,
1N/ACurrently the only things that can have their length counted are a*, A*
1N/A=item '/' must follow a numeric type in unpack
1N/A(F) You had an unpack template that contained a '/', but this did not
1N/Afollow some unpack specification producing a numeric value.
1N/A=item "my sub" not yet implemented
1N/A(F) Lexically scoped subroutines are not yet implemented. Don't try
1N/A=item "my" variable %s can't be in a package
1N/A(F) Lexically scoped variables aren't in a package, so it doesn't make
1N/Asense to try to declare one with a package qualifier on the front. Use
1N/Alocal() if you want to localize a package variable.
1N/A=item Name "%s::%s" used only once: possible typo
1N/A(W once) Typographical errors often show up as unique variable names.
1N/AIf you had a good reason for having a unique name, then just mention it
1N/Aagain somehow to suppress the message. The C<our> declaration is
1N/Aprovided for this purpose.
1N/ANOTE: This warning detects symbols that have been used only once so $c, @c,
1N/A%c, *c, &c, sub c{}, c(), and c (the filehandle or format) are considered
1N/Athe same; if a program uses $c only once but also uses any of the others it
1N/Awill not trigger this warning.
1N/A=item Negative '/' count in unpack
1N/A=item Negative length
1N/Alength that is less than 0. This is difficult to imagine.
1N/A=item Negative offset to vec in lvalue context
1N/A(F) When C<vec> is called in an lvalue context, the second argument must be
1N/Agreater than or equal to zero.
1N/A=item Nested quantifiers in regex; marked by <-- HERE in m/%s/
1N/A(F) You can't quantify a quantifier without intervening parentheses. So
1N/Athings like ** or +* or ?* are illegal. The <-- HERE shows in the regular
1N/Aexpression about where the problem was discovered.
1N/ANote that the minimal matching quantifiers, C<*?>, C<+?>, and
1N/AC<??> appear to be nested quantifiers, but aren't. See L<perlre>.
1N/A=item %s never introduced
1N/A(S internal) The symbol in question was declared but somehow went out of
1N/Ascope before it could possibly have been used.
1N/A=item Newline in left-justified string for %s
1N/A(W printf) There is a newline in a string to be left justified by
1N/AC<printf> or C<sprintf>.
1N/AThe padding spaces will appear after the newline, which is probably not
1N/Awhat you wanted. Usually you should remove the newline from the string
1N/Aand put formatting characters in the C<sprintf> format.
1N/A=item No %s allowed while running setuid
1N/A(F) Certain operations are deemed to be too insecure for a setuid or
1N/Asetgid script to even be allowed to attempt. Generally speaking there
1N/Awill be another way to do what you want that is, if not secure, at least
1N/Asecurable. See L<perlsec>.
1N/A=item No comma allowed after %s
1N/A(F) A list operator that has a filehandle or "indirect object" is not
1N/Aallowed to have a comma between that and the following arguments.
1N/AOtherwise it'd be just another one of the arguments.
1N/AOne possible cause for this is that you expected to have imported a
1N/Aconstant to your name space with B<use> or B<import> while no such
1N/Aimporting took place, it may for example be that your operating system
1N/Adoes not support that particular constant. Hopefully you did use an
1N/Aexplicit import list for the constants you expect to see, please see
1N/Awould probably have caught this error earlier it naturally does not
1N/Aremedy the fact that your operating system still does not support that
1N/Aconstant. Maybe you have a typo in the constants of the symbol import
1N/Alist of B<use> or B<import> or in the constant name at the line where
1N/Athis error was triggered?
1N/A=item No command into which to pipe on command line
1N/A(F) An error peculiar to VMS. Perl handles its own command line
1N/Aredirection, and found a '|' at the end of the command line, so it
1N/Adoesn't know where you want to pipe the output from this command.
1N/A=item No DB::DB routine defined
1N/A(F) The currently executing code was compiled with the B<-d> switch, but
1N/Afor some reason the
perl5db.pl file (or some facsimile thereof) didn't
1N/Adefine a routine to be called at the beginning of each statement. Which
1N/Ais odd, because the file should have been required automatically, and
1N/Ashould have blown up the require if it didn't parse right.
1N/A=item No dbm on this machine
1N/A(P) This is counted as an internal error, because every machine should
1N/Asupply dbm nowadays, because Perl comes with SDBM. See L<SDBM_File>.
1N/A=item No DBsub routine
1N/A(F) The currently executing code was compiled with the B<-d> switch,
1N/Abut for some reason the
perl5db.pl file (or some facsimile thereof)
1N/Adidn't define a DB::sub routine to be called at the beginning of each
1N/Aordinary subroutine call.
1N/A=item No B<-e> allowed in setuid scripts
1N/A(F) A setuid script can't be specified by the user.
1N/A=item No error file after 2> or 2>> on command line
1N/A(F) An error peculiar to VMS. Perl handles its own command line
1N/Aredirection, and found a '2>' or a '2>>' on the command line, but can't
1N/Afind the name of the file to which to write data destined for stderr.
1N/A=item No group ending character '%c' found in template
1N/A(F) A pack or unpack template has an opening '(' or '[' without its
1N/A=item No input file after < on command line
1N/A(F) An error peculiar to VMS. Perl handles its own command line
1N/Aredirection, and found a '<' on the command line, but can't find the
1N/Aname of the file from which to read data for stdin.
1N/A(F) The setuid emulator requires that scripts have a well-formed #! line
1N/Aeven on machines that don't support the #! construct.
1N/A=item "no" not allowed in expression
1N/A(F) The "no" keyword is recognized and executed at compile time, and
1N/Areturns no useful value. See L<perlmod>.
1N/A=item No output file after > on command line
1N/A(F) An error peculiar to VMS. Perl handles its own command line
1N/Aredirection, and found a lone '>' at the end of the command line, so it
1N/Adoesn't know where you wanted to redirect stdout.
1N/A=item No output file after > or >> on command line
1N/A(F) An error peculiar to VMS. Perl handles its own command line
1N/Aredirection, and found a '>' or a '>>' on the command line, but can't
1N/Afind the name of the file to which to write data destined for stdout.
1N/A=item No package name allowed for variable %s in "our"
1N/A(F) Fully qualified variable names are not allowed in "our"
1N/Adeclarations, because that doesn't make much sense under existing
1N/Asemantics. Such syntax is reserved for future extensions.
1N/A=item No Perl script found in input
1N/A(F) You called C<perl -x>, but no line was found in the file beginning
1N/Awith #! and containing the word "perl".
1N/A=item No setregid available
1N/A(F) Configure didn't find anything resembling the setregid() call for
1N/A=item No setreuid available
1N/A(F) Configure didn't find anything resembling the setreuid() call for
1N/A=item No space allowed after -%c
1N/A(F) The argument to the indicated command line switch must follow
1N/Aimmediately after the switch, without intervening spaces.
1N/A=item No %s specified for -%c
1N/A(F) The indicated command line switch needs a mandatory argument, but
1N/Ayou haven't specified one.
1N/A=item No such class %s
1N/A(F) You provided a class qualifier in a "my" or "our" declaration, but
1N/Athis class doesn't exist at this point in your program.
1N/A=item No such pipe open
1N/A(P) An error peculiar to VMS. The internal routine my_pclose() tried to
1N/Aclose a pipe which hadn't been opened. This should have been caught
1N/Aearlier as an attempt to close an unopened filehandle.
1N/A=item No such pseudo-hash field "%s"
1N/A(F) You tried to access an array as a hash, but the field name used is
1N/Anot defined. The hash at index 0 should map all valid field names to
1N/Aarray indices for that to work.
1N/A=item No such pseudo-hash field "%s" in variable %s of type %s
1N/A(F) You tried to access a field of a typed variable where the type does
1N/Anot know about the field name. The field names are looked up in the
1N/A%FIELDS hash in the type package at compile time. The %FIELDS hash is
1N/A%usually set up with the 'fields' pragma.
1N/A=item No such signal: SIG%s
1N/A(W signal) You specified a signal name as a subscript to %SIG that was
1N/Anot recognized. Say C<kill -l> in your shell to see the valid signal
1N/Anames on your system.
1N/A=item Not a CODE reference
1N/A(F) Perl was trying to evaluate a reference to a code value (that is, a
1N/Asubroutine), but found a reference to something else instead. You can
1N/Ause the ref() function to find out what kind of ref it really was. See
1N/A=item Not a format reference
1N/A(F) I'm not sure how you managed to generate a reference to an anonymous
1N/Aformat, but this indicates you did, and that it didn't exist.
1N/A=item Not a GLOB reference
1N/A(F) Perl was trying to evaluate a reference to a "typeglob" (that is, a
1N/Asymbol table entry that looks like C<*foo>), but found a reference to
1N/Asomething else instead. You can use the ref() function to find out what
1N/Akind of ref it really was. See L<perlref>.
1N/A=item Not a HASH reference
1N/A(F) Perl was trying to evaluate a reference to a hash value, but found a
1N/Areference to something else instead. You can use the ref() function to
1N/Afind out what kind of ref it really was. See L<perlref>.
1N/A=item Not an ARRAY reference
1N/A(F) Perl was trying to evaluate a reference to an array value, but found
1N/Aa reference to something else instead. You can use the ref() function
1N/Ato find out what kind of ref it really was. See L<perlref>.
1N/A=item Not a perl script
1N/A(F) The setuid emulator requires that scripts have a well-formed #! line
1N/Aeven on machines that don't support the #! construct. The line must
1N/A=item Not a SCALAR reference
1N/A(F) Perl was trying to evaluate a reference to a scalar value, but found
1N/Aa reference to something else instead. You can use the ref() function
1N/Ato find out what kind of ref it really was. See L<perlref>.
1N/A=item Not a subroutine reference
1N/A(F) Perl was trying to evaluate a reference to a code value (that is, a
1N/Asubroutine), but found a reference to something else instead. You can
1N/Ause the ref() function to find out what kind of ref it really was. See
1N/A=item Not a subroutine reference in overload table
1N/A(F) An attempt was made to specify an entry in an overloading table that
1N/Adoesn't somehow point to a valid subroutine. See L<overload>.
1N/A=item Not enough arguments for %s
1N/A(F) The function requires more arguments than you specified.
1N/A=item Not enough format arguments
1N/A(W syntax) A format specified more picture fields than the next line
1N/Asupplied. See L<perlform>.
1N/A(A) You've accidentally run your script through the Bourne shell instead
1N/Aof Perl. Check the #! line, or manually feed your script into Perl
1N/A=item no UTC offset information; assuming local time is UTC
1N/A(S) A warning peculiar to VMS. Perl was unable to find the local
1N/Atimezone offset, so it's assuming that local system time is equivalent
1N/Ato UTC. If it's not, define the logical name
1N/AF<SYS$TIMEZONE_DIFFERENTIAL> to translate to the number of seconds which
1N/Aneed to be added to UTC to get local time.
1N/A=item Null filename used
1N/A(F) You can't require the null filename, especially because on many
1N/A(P debugging) Some internal routine called run() with a null opcode
1N/A=item Null picture in formline
1N/A(F) The first argument to formline must be a valid format picture
1N/Aspecification. It was found to be empty, which probably means you
1N/Asupplied it an uninitialized value. See L<perlform>.
1N/A(P) An attempt was made to realloc NULL.
1N/A=item NULL regexp argument
1N/A(P) The internal pattern matching routines blew it big time.
1N/A=item NULL regexp parameter
1N/A(P) The internal pattern matching routines are out of their gourd.
1N/A=item Number too long
1N/A(F) Perl limits the representation of decimal numbers in programs to
1N/Aabout 250 characters. You've exceeded that length. Future
1N/Aversions of Perl are likely to eliminate this arbitrary limitation. In
1N/Athe meantime, try using scientific notation (
e.g. "1e6" instead of
1N/A=item Octal number in vector unsupported
1N/A(F) Numbers with a leading C<0> are not currently allowed in vectors.
1N/AThe octal number interpretation of such numbers may be supported in a
1N/A=item Octal number > 037777777777 non-portable
1N/A(W portable) The octal number you specified is larger than 2**32-1
1N/A(4294967295) and therefore non-portable between systems. See
1N/AL<perlport> for more on portability concerns.
1N/ASee also L<perlport> for writing portable code.
1N/A=item Odd number of arguments for overload::constant
1N/A(W overload) The call to overload::constant contained an odd number of
1N/Aarguments. The arguments should come in pairs.
1N/A=item Odd number of elements in anonymous hash
1N/A(W misc) You specified an odd number of elements to initialize a hash,
1N/A=item Odd number of elements in hash assignment
1N/A(W misc) You specified an odd number of elements to initialize a hash,
1N/A=item Offset outside string
1N/Apointing outside the buffer. This is difficult to imagine. The sole
1N/Aexception to this is that C<sysread()>ing past the buffer will extend
1N/Athe buffer and zero pad the new area.
1N/A=item %s() on unopened %s
1N/A(W unopened) An I/O operation was attempted on a filehandle that was
1N/Anever initialized. You need to do an open(), a sysopen(), or a socket()
1N/Acall, or call a constructor from the FileHandle package.
1N/A=item -%s on unopened filehandle %s
1N/A(W unopened) You tried to invoke a file test operator on a filehandle
1N/Athat isn't open. Check your control flow. See also L<perlfunc/-X>.
1N/A(S internal) An internal warning that the grammar is screwed up.
1N/A(S internal) An internal warning that the grammar is screwed up.
1N/A=item Operation `%s': no method found, %s
1N/A(F) An attempt was made to perform an overloaded operation for which no
1N/Ahandler was defined. While some handlers can be autogenerated in terms
1N/Aof other handlers, there is no default handler for any operation, unless
1N/AC<fallback> overloading key is specified to be true. See L<overload>.
1N/A=item Operator or semicolon missing before %s
1N/A(S ambiguous) You used a variable or subroutine call where the parser
1N/Awas expecting an operator. The parser has assumed you really meant to
1N/Ause an operator, but this is highly likely to be incorrect. For
1N/Aexample, if you say "*foo *foo" it will be interpreted as if you said
1N/A=item "our" variable %s redeclared
1N/A(W misc) You seem to have already declared the same global once before
1N/Ain the current lexical scope.
1N/A(X) The malloc() function returned 0, indicating there was insufficient
1N/Aremaining memory (or virtual memory) to satisfy the request. Perl has
1N/Ano option but to exit immediately.
1N/AAt least in Unix you may be able to get past this by increasing your
1N/AC<limit datasize n> (where C<n> is the number of kilobytes) to check
1N/Aand C<ulimit -d n>, respectively.
1N/A=item Out of memory during "large" request for %s
1N/A(F) The malloc() function returned 0, indicating there was insufficient
1N/Aremaining memory (or virtual memory) to satisfy the request. However,
1N/Athe request was judged large enough (compile-time default is 64K), so a
1N/Apossibility to shut down by trapping this error is granted.
1N/A=item Out of memory during request for %s
1N/A(X|F) The malloc() function returned 0, indicating there was
1N/Ainsufficient remaining memory (or virtual memory) to satisfy the
1N/AThe request was judged to be small, so the possibility to trap it
1N/Adepends on the way perl was compiled. By default it is not trappable.
1N/AHowever, if compiled for this, Perl may use the contents of C<$^M> as an
1N/Aemergency pool after die()ing with this message. In this case the error
1N/Ais trappable I<once>, and the error message will include the line and file
1N/Awhere the failed request happened.
1N/A=item Out of memory during ridiculously large request
1N/A(F) You can't allocate more than 2^31+"small amount" bytes. This error
1N/Ais most likely to be caused by a typo in the Perl program.
e.g.,
1N/AC<$arr[time]> instead of C<$arr[$time]>.
1N/A=item Out of memory for yacc stack
1N/A(F) The yacc parser wanted to grow its stack so it could continue
1N/Aparsing, but realloc() wouldn't give it more memory, virtual or
1N/A=item '@' outside of string in unpack
1N/A(F) You had a template that specified an absolute position outside
1N/A=item %s package attribute may clash with future reserved word: %s
1N/A(W reserved) A lowercase attribute name was used that had a
1N/Apackage-specific handler. That name might have a meaning to Perl itself
1N/Asome day, even though it doesn't yet. Perhaps you should use a
1N/Amixed-case attribute name, instead. See L<attributes>.
1N/A(F) You can't specify a repeat count so large that it overflows your
1N/A(W io) A single call to write() produced more lines than can fit on a
1N/Apage. See L<perlform>.
1N/A(P) An internal error.
1N/A=item panic: array extend
1N/A(P) An attempt was made to extend an array beyond the largest possible
1N/A(P) Failed an internal consistency check trying to compile a grep.
1N/A=item panic: ck_split
1N/A(P) Failed an internal consistency check trying to compile a split.
1N/A=item panic: corrupt saved stack index
1N/A(P) The savestack was requested to restore more localized values than
1N/Athere are in the savestack.
1N/A=item panic: del_backref
1N/A(P) Failed an internal consistency check while trying to reset a weak
1N/A=item panic: Devel::DProf inconsistent subroutine return
1N/A(P) Devel::DProf called a subroutine that exited using goto(LABEL),
1N/Alast(LABEL) or next(LABEL). Leaving that way a subroutine called from
1N/Aan XSUB will lead very probably to a crash of the interpreter. This is
1N/Aa bug that will hopefully one day get fixed.
1N/A(P) We popped the context stack to an eval context, and then discovered
1N/Ait wasn't an eval context.
1N/A=item panic: do_subst
1N/A(P) The internal pp_subst() routine was called with invalid operational
1N/A=item panic: do_trans_%s
1N/A(P) The internal do_trans routines were called with invalid operational
1N/A(P) The library function frexp() failed, making printf("%f") impossible.
1N/A(P) We popped the context stack to a context with the specified label,
1N/Aand then discovered it wasn't a context we know how to do a goto in.
1N/A=item panic: INTERPCASEMOD
1N/A(P) The lexer got into a bad state at a case modifier.
1N/A=item panic: INTERPCONCAT
1N/A(P) The lexer got into a bad state parsing a string with brackets.
1N/A=item panic: kid popen errno read
1N/A(F) forked child returned an incomprehensible message about its errno.
1N/A(P) We popped the context stack to a block context, and then discovered
1N/Ait wasn't a block context.
1N/A=item panic: leave_scope clearsv
1N/A(P) A writable lexical variable became read-only somehow within the
1N/A=item panic: leave_scope inconsistency
1N/A(P) The savestack probably got out of sync. At least, there was an
1N/Ainvalid enum on the top of it.
1N/A=item panic: list extend
1N/A(P) An attempt was made to extend a list beyond the largest possible
1N/A=item panic: magic_killbackrefs
1N/A(P) Failed an internal consistency check while trying to reset all weak
1N/Areferences to an object.
1N/A(P) Something requested a negative number of bytes of malloc.
1N/A=item panic: mapstart
1N/A(P) The compiler is screwed up with respect to the map() function.
1N/A=item panic: memory wrap
1N/A(P) Something tried to allocate more memory than possible.
1N/A=item panic: null array
1N/A(P) One of the internal array routines was passed a null AV pointer.
1N/A=item panic: pad_alloc
1N/A(P) The compiler got confused about which scratch pad it was allocating
1N/Aand freeing temporaries and lexicals from.
1N/A=item panic: pad_free curpad
1N/A(P) The compiler got confused about which scratch pad it was allocating
1N/Aand freeing temporaries and lexicals from.
1N/A=item panic: pad_free po
1N/A(P) An invalid scratch pad offset was detected internally.
1N/A=item panic: pad_reset curpad
1N/A(P) The compiler got confused about which scratch pad it was allocating
1N/Aand freeing temporaries and lexicals from.
1N/A=item panic: pad_sv po
1N/A(P) An invalid scratch pad offset was detected internally.
1N/A=item panic: pad_swipe curpad
1N/A(P) The compiler got confused about which scratch pad it was allocating
1N/Aand freeing temporaries and lexicals from.
1N/A=item panic: pad_swipe po
1N/A(P) An invalid scratch pad offset was detected internally.
1N/A(P) The foreach iterator got called in a non-loop context frame.
1N/A=item panic: pp_match%s
1N/A(P) The internal pp_match() routine was called with invalid operational
1N/A=item panic: pp_split
1N/A(P) Something terrible went wrong in setting up for the split.
1N/A(P) Something requested a negative number of bytes of realloc.
1N/A=item panic: restartop
1N/A(P) Some internal routine requested a goto (or something like it), and
1N/Adidn't supply the destination.
1N/A(P) We popped the context stack to a subroutine or eval context, and
1N/Athen discovered it wasn't a subroutine or eval context.
1N/A=item panic: scan_num
1N/A(P) scan_num() got called on something that wasn't a number.
1N/A=item panic: string extend
1N/A(P) An attempt was made to extend a string beyond the largest possible
1N/A=item panic: sv_insert
1N/A(P) The sv_insert() routine was told to remove more string than there
1N/A(P) The compiler attempted to do a goto, or something weird like that.
1N/A=item panic: utf16_to_utf8: odd bytelen
1N/A(P) Something tried to call utf16_to_utf8 with an odd (as opposed
1N/Ato even) byte length.
1N/A(P) The lexer got into a bad state while processing a case modifier.
1N/A=item Parentheses missing around "%s" list
1N/A(W parenthesis) You said something like
1N/A my ($foo, $bar) = @_;
1N/ARemember that "my", "our", and "local" bind tighter than comma.
1N/A=item C<-p> destination: %s
1N/A(F) An error occurred during the implicit output invoked by the C<-p>
1N/Acommand-line switch. (This output goes to STDOUT unless you've
1N/Aredirected it with select().)
1N/A=item (perhaps you forgot to load "%s"?)
1N/A(F) This is an educated guess made in conjunction with the message
1N/A"Can't locate object method \"%s\" via package \"%s\"". It often means
1N/Athat a method requires a package that has not been loaded.
1N/A=item Perl %s required--this is only version %s, stopped
1N/A(F) The module in question uses features of a version of Perl more
1N/Arecent than the currently running version. How long has it been since
1N/A=item PERL_SH_DIR too long
1N/A(F) An error peculiar to OS/2. PERL_SH_DIR is the directory to find the
1N/AC<sh>-shell in. See "PERL_SH_DIR" in L<perlos2>.
1N/A=item PERL_SIGNALS illegal: "%s"
1N/A=item perl: warning: Setting locale failed.
1N/A(S) The whole warning message will look something like:
1N/A perl: warning: Setting locale failed.
1N/A perl: warning: Please check that your locale settings:
1N/A are supported and installed on your system.
1N/A perl: warning: Falling back to the standard locale ("C").
1N/AExactly what were the failed locale settings varies. In the above the
1N/Asettings were that the LC_ALL was "En_US" and the LANG had no value.
1N/AThis error means that Perl detected that you
and/or your operating
1N/Asystem supplier
and/or system administrator have set up the so-called
1N/Alocale system but Perl could not use those settings. This was not
1N/Adead serious, fortunately: there is a "default locale" called "C" that
1N/APerl can and will use, the script will be run. Before you really fix
1N/Athe problem, however, you will get the same error message each time
1N/Ayou run Perl. How to really fix the problem can be found in
1N/AL<perllocale> section B<LOCALE PROBLEMS>.
1N/A=item Permission denied
1N/A(F) The setuid emulator in suidperl decided you were up to no good.
1N/A=item pid %x not a child
1N/A(W exec) A warning peculiar to VMS. Waitpid() was asked to wait for a
1N/Aprocess which isn't a subprocess of the current process. While this is
1N/Afine from VMS' perspective, it's probably not what you intended.
1N/A=item 'P' must have an explicit size in unpack
1N/A(F) The unpack format P must have an explicit size, not "*".
1N/A(F) The script would have to be opened by the C preprocessor by name,
1N/Awhich provides a race condition that breaks security.
1N/A=item POSIX class [:%s:] unknown in regex; marked by <-- HERE in m/%s/
1N/A(F) The class in the character class [: :] syntax is unknown. The <-- HERE
1N/Ashows in the regular expression about where the problem was discovered.
1N/ANote that the POSIX character classes do B<not> have the C<is> prefix
1N/Athe corresponding C interfaces have: in other words, it's C<[[:print:]]>,
1N/Anot C<isprint>. See L<perlre>.
1N/A=item POSIX getpgrp can't take an argument
1N/A(F) Your system has POSIX getpgrp(), which takes no argument, unlike
1N/Athe BSD version, which takes a pid.
1N/A=item POSIX syntax [%s] belongs inside character classes in regex; marked by <-- HERE in m/%s/
1N/A(W regexp) The character class constructs [: :], [= =], and [. .] go
1N/AI<inside> character classes, the [] are part of the construct, for example:
1N/A/[012[:alpha:]345]/. Note that [= =] and [. .] are not currently
1N/Aimplemented; they are simply placeholders for future extensions and will
1N/Acause fatal errors. The <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item POSIX syntax [. .] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
1N/A(F regexp) Within regular expression character classes ([]) the syntax
1N/Abeginning with "[." and ending with ".]" is reserved for future extensions.
1N/AIf you need to represent those character sequences inside a regular
1N/Aexpression character class, just quote the square brackets with the
1N/Abackslash: "\[." and ".\]". The <-- HERE shows in the regular expression
1N/Aabout where the problem was discovered. See L<perlre>.
1N/A=item POSIX syntax [= =] is reserved for future extensions in regex; marked by <-- HERE in m/%s/
1N/A(F) Within regular expression character classes ([]) the syntax beginning
1N/Awith "[=" and ending with "=]" is reserved for future extensions. If you
1N/Aneed to represent those character sequences inside a regular expression
1N/Acharacter class, just quote the square brackets with the backslash: "\[="
1N/Aand "=\]". The <-- HERE shows in the regular expression about where the
1N/Aproblem was discovered. See L<perlre>.
1N/A=item Possible attempt to put comments in qw() list
1N/A(W qw) qw() lists contain items separated by whitespace; as with literal
1N/Astrings, comment characters are not ignored, but are instead treated as
1N/Aliteral data. (You may have used different delimiters than the
1N/Aparentheses shown here; braces are also frequently used.)
1N/AYou probably wrote something like this:
1N/Awhen you should have written this:
1N/AIf you really want comments, build your list the
1N/Aold-fashioned way, with quotes and commas:
1N/A 'b', # another comment
1N/A=item Possible attempt to separate words with commas
1N/A(W qw) qw() lists contain items separated by whitespace; therefore
1N/Acommas aren't needed to separate the items. (You may have used
1N/Adifferent delimiters than the parentheses shown here; braces are also
1N/AYou probably wrote something like this:
1N/Awhich puts literal commas into some of the list items. Write it without
1N/Acommas if you don't want them to appear in your data:
1N/A=item Possible memory corruption: %s overflowed 3rd argument
1N/A(F) An ioctl() or fcntl() returned more than Perl was bargaining for.
1N/APerl guesses a reasonable buffer size, but puts a sentinel byte at the
1N/Aend of the buffer just in case. This sentinel byte got clobbered, and
1N/A=item Possible precedence problem on bitwise %c operator
1N/A(W precedence) Your program uses a bitwise logical operator in conjunction
1N/Awith a numeric comparison operator, like this :
1N/A if ($x & $y == 0) { ... }
1N/AThis expression is actually equivalent to C<$x & ($y == 0)>, due to the
1N/Ahigher precedence of C<==>. This is probably not what you want. (If you
1N/Areally meant to write this, disable the warning, or, better, put the
1N/Aparentheses explicitly and write C<$x & ($y == 0)>).
1N/A=item Possible unintended interpolation of %s in string
1N/A(W ambiguous) You said something like `@foo' in a double-quoted string
1N/Abut there was no array C<@foo> in scope at the time. If you wanted a
1N/Aliteral @foo, then write it as \@foo; otherwise find out what happened
1N/Ato the array you apparently lost track of.
1N/A=item Possible Y2K bug: %s
1N/A(W y2k) You are concatenating the number 19 with another number, which
1N/Acould be a potential Year 2000 problem.
1N/A=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
1N/A(D deprecated) You have written something like this:
1N/A use attrs qw(locked);
1N/AYou should use the new declaration syntax instead.
1N/AThe C<use attrs> pragma is now obsolete, and is only provided for
1N/Abackward-compatibility. See L<perlsub/"Subroutine Attributes">.
1N/A=item Precedence problem: open %s should be open(%s)
1N/A(S precedence) The old irregular construct
1N/Ais now misinterpreted as
1N/Abecause of the strict regularization of Perl 5's grammar into unary and
1N/Alist operators. (The old open was a little of both.) You must put
1N/Aparentheses around the filehandle, or use the new "or" operator instead
1N/A=item Premature end of script headers
1N/A=item printf() on closed filehandle %s
1N/A(W closed) The filehandle you're writing to got itself closed sometime
1N/Abefore now. Check your control flow.
1N/A=item print() on closed filehandle %s
1N/A(W closed) The filehandle you're printing on got itself closed sometime
1N/Abefore now. Check your control flow.
1N/A=item Process terminated by SIG%s
1N/A(W) This is a standard message issued by OS/2 applications, while *nix
1N/Aapplications die in silence. It is considered a feature of the OS/2
1N/Aport. One can easily disable this by appropriate sighandlers, see
1N/A=item Prototype mismatch: %s vs %s
1N/A(S prototype) The subroutine being declared or defined had previously been
1N/Adeclared or defined with a different function prototype.
1N/A=item Prototype not terminated
1N/A(F) You've omitted the closing parenthesis in a function prototype
1N/A=item Pseudo-hashes are deprecated
1N/A(D deprecated) Pseudo-hashes were deprecated in Perl 5.8.0 and they
1N/Awill be removed in Perl 5.10.0, see L<perl58delta> for more details.
1N/AYou can continue to use the C<fields> pragma.
1N/A=item Quantifier follows nothing in regex; marked by <-- HERE in m/%s/
1N/A(F) You started a regular expression with a quantifier. Backslash it if you
1N/Ameant it literally. The <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item Quantifier in {,} bigger than %d in regex; marked by <-- HERE in m/%s/
1N/A(F) There is currently a limit to the size of the min and max values of the
1N/A{min,max} construct. The <-- HERE shows in the regular expression about where
1N/Athe problem was discovered. See L<perlre>.
1N/A=item Quantifier unexpected on zero-length expression; marked by <-- HERE in m/%s/
1N/A(W regexp) You applied a regular expression quantifier in a place where
1N/Ait makes no sense, such as on a zero-width assertion. Try putting the
1N/Aquantifier inside the assertion instead. For example, the way to match
1N/A"abc" provided that it is followed by three repetitions of "xyz" is
1N/AC</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
1N/AThe <-- HERE shows in the regular expression about where the problem was
1N/A=item Range iterator outside integer range
1N/A(F) One (or both) of the numeric arguments to the range operator ".."
1N/Aare outside the range which can be represented by integers internally.
1N/AOne possible workaround is to force Perl to use magical string increment
1N/Aby prepending "0" to your numbers.
1N/A=item readline() on closed filehandle %s
1N/A(W closed) The filehandle you're reading from got itself closed sometime
1N/Abefore now. Check your control flow.
1N/A=item read() on closed filehandle %s
1N/A(W closed) You tried to read from a closed filehandle.
1N/A=item read() on unopened filehandle %s
1N/A(W unopened) You tried to read from a filehandle that was never opened.
1N/A=item Reallocation too large: %lx
1N/A(F) You can't allocate more than 64K on an MS-DOS machine.
1N/A=item realloc() of freed memory ignored
1N/A(S malloc) An internal routine called realloc() on something that had
1N/A=item Recompile perl with B<-D>DEBUGGING to use B<-D> switch
1N/A(F debugging) You can't use the B<-D> option unless the code to produce
1N/Athe desired output is compiled into Perl, which entails some overhead,
1N/Awhich is why it's currently left out of your copy.
1N/A=item Recursive inheritance detected in package '%s'
1N/A(F) More than 100 levels of inheritance were used. Probably indicates
1N/Aan unintended loop in your inheritance hierarchy.
1N/A=item Recursive inheritance detected while looking for method %s
1N/A(F) More than 100 levels of inheritance were encountered while invoking
1N/Aa method. Probably indicates an unintended loop in your inheritance
1N/A=item Reference found where even-sized list expected
1N/A(W misc) You gave a single reference where Perl was expecting a list
1N/Awith an even number of elements (for assignment to a hash). This usually
1N/Ameans that you used the anon hash constructor when you meant to use
1N/A %hash = { one => 1, two => 2, }; # WRONG
1N/A %hash = [ qw/ an anon array / ]; # WRONG
1N/A %hash = ( one => 1, two => 2, ); # right
1N/A %hash = qw( one 1 two 2 ); # also fine
1N/A=item Reference is already weak
1N/A(W misc) You have attempted to weaken a reference that is already weak.
1N/ADoing so has no effect.
1N/A=item Reference miscount in sv_replace()
1N/A(W internal) The internal sv_replace() function was handed a new SV with
1N/Aa reference count of other than 1.
1N/A=item Reference to nonexistent group in regex; marked by <-- HERE in m/%s/
1N/A(F) You used something like C<\7> in your regular expression, but there are
1N/Anot at least seven sets of capturing parentheses in the expression. If you
1N/Awanted to have the character with value 7 inserted into the regular expression,
1N/Aprepend a zero to make the number at least two digits: C<\07>
1N/AThe <-- HERE shows in the regular expression about where the problem was
1N/A=item regexp memory corruption
1N/A(P) The regular expression engine got confused by what the regular
1N/Aexpression compiler gave it.
1N/A=item Regexp out of space
1N/A(P) A "can't happen" error, because safemalloc() should have caught it
1N/A=item Repeated format line will never terminate (~~ and @# incompatible)
1N/A(F) Your format containes the ~~ repeat-until-blank sequence and a
1N/Anumeric field that will never go blank so that the repetition never
1N/Aterminates. You might use ^# instead. See L<perlform>.
1N/A=item Reversed %s= operator
1N/A(W syntax) You wrote your assignment operator backwards. The = must
1N/Aalways comes last, to avoid ambiguity with subsequent unary operators.
1N/A(F) Your format contained the ~~ repeat-until-blank sequence, but it
1N/Aproduced 200 lines at once, and the 200th line looked exactly like the
1N/A199th line. Apparently you didn't arrange for the arguments to exhaust
1N/Athemselves, either by using ^ instead of @ (for scalar variables), or by
1N/Ashifting or popping (for array variables). See L<perlform>.
1N/A=item Scalars leaked: %d
1N/A(P) Something went wrong in Perl's internal bookkeeping of scalars:
1N/Anot all scalar variables were deallocated by the time Perl exited.
1N/AWhat this usually indicates is a memory leak, which is of course bad,
1N/Aespecially if the Perl program is intended to be long-running.
1N/A=item Scalar value @%s[%s] better written as $%s[%s]
1N/A(W syntax) You've used an array slice (indicated by @) to select a
1N/Asingle element of an array. Generally it's better to ask for a scalar
1N/Avalue (indicated by $). The difference is that C<$foo[&bar]> always
1N/Abehaves like a scalar, both when assigning to it and when evaluating its
1N/Aargument, while C<@foo[&bar]> behaves like a list when you assign to it,
1N/Aand provides a list context to its subscript, which can do weird things
1N/Aif you're expecting only one subscript.
1N/AOn the other hand, if you were actually hoping to treat the array
1N/Aelement as a list, you need to look into how references work, because
1N/APerl will not magically convert between scalars and lists for you. See
1N/A=item Scalar value @%s{%s} better written as $%s{%s}
1N/A(W syntax) You've used a hash slice (indicated by @) to select a single
1N/Aelement of a hash. Generally it's better to ask for a scalar value
1N/A(indicated by $). The difference is that C<$foo{&bar}> always behaves
1N/Alike a scalar, both when assigning to it and when evaluating its
1N/Aargument, while C<@foo{&bar}> behaves like a list when you assign to it,
1N/Aand provides a list context to its subscript, which can do weird things
1N/Aif you're expecting only one subscript.
1N/AOn the other hand, if you were actually hoping to treat the hash element
1N/Aas a list, you need to look into how references work, because Perl will
1N/Anot magically convert between scalars and lists for you. See
1N/A(F) Oddly, the suidperl program was invoked on a script without a setuid
1N/Aor setgid bit set. This doesn't make much sense.
1N/A=item Search pattern not terminated
1N/A(F) The lexer couldn't find the final delimiter of a // or m{}
1N/Aconstruct. Remember that bracketing delimiters count nesting level.
1N/AMissing the leading C<$> from a variable C<$m> may cause this error.
1N/ANote that since Perl 5.9.0 a // can also be the I<defined-or>
1N/Aconstruct, not just the empty search pattern. Therefore code written
1N/Ain Perl 5.9.0 or later that uses the // as the I<defined-or> can be
1N/Amisparsed by pre-5.9.0 Perls as a non-terminated search pattern.
1N/A=item %sseek() on unopened filehandle
1N/A(W unopened) You tried to use the seek() or sysseek() function on a
1N/Afilehandle that was either never opened or has since been closed.
1N/A=item select not implemented
1N/A(F) This machine doesn't implement the select() system call.
1N/A=item Self-ties of arrays and hashes are not supported
1N/A(F) Self-ties are of arrays and hashes are not supported in
1N/Athe current implementation.
1N/A=item Semicolon seems to be missing
1N/A(W semicolon) A nearby syntax error was probably caused by a missing
1N/Asemicolon, or possibly some other missing operator, such as a comma.
1N/A=item semi-panic: attempt to dup freed string
1N/A(S internal) The internal newSVsv() routine was called to duplicate a
1N/Ascalar that had previously been marked as free.
1N/A=item sem%s not implemented
1N/A(F) You don't have System V semaphore IPC on your system.
1N/A=item send() on closed socket %s
1N/A(W closed) The socket you're sending to got itself closed sometime
1N/Abefore now. Check your control flow.
1N/A=item Sequence (? incomplete in regex; marked by <-- HERE in m/%s/
1N/A(F) A regular expression ended with an incomplete extension (?. The <-- HERE
1N/Ashows in the regular expression about where the problem was discovered. See
1N/A=item Sequence (?%s...) not implemented in regex; marked by <-- HERE in m/%s/
1N/A(F) A proposed regular expression extension has the character reserved but
1N/Ahas not yet been written. The <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/
1N/A(F) You used a regular expression extension that doesn't make sense. The
1N/A<-- HERE shows in the regular expression about where the problem was
1N/Adiscovered. See L<perlre>.
1N/A=item Sequence (?#... not terminated in regex; marked by <-- HERE in m/%s/
1N/A(F) A regular expression comment must be terminated by a closing
1N/Aparenthesis. Embedded parentheses aren't allowed. The <-- HERE shows in
1N/Athe regular expression about where the problem was discovered. See
1N/A=item Sequence (?{...}) not terminated or not {}-balanced in regex; marked by <-- HERE in m/%s/
1N/A(F) If the contents of a (?{...}) clause contains braces, they must balance
1N/Afor Perl to properly detect the end of the clause. The <-- HERE shows in
1N/Athe regular expression about where the problem was discovered. See
1N/A=item 500 Server error
1N/AThis is the error message generally seen in a browser window when trying
1N/Ato run a CGI program (including SSI) over the web. The actual error text
1N/Avaries widely from server to server. The most frequently-seen variants
1N/Aare "500 Server error", "Method (something) not permitted", "Document
1N/Acontains no data", "Premature end of script headers", and "Did not
1N/Aproduce a valid header".
1N/AB<This is a CGI error, not a Perl error>.
1N/AYou need to make sure your script is executable, is accessible by the
1N/Auser CGI is running the script under (which is probably not the user
1N/Aaccount you tested it under), does not rely on any environment variables
1N/A(like PATH) from the user it isn't running under, and isn't in a
1N/Alocation where the CGI server can't find it, basically, more or less.
1N/APlease see the following for more information:
1N/AYou should also look at L<perlfaq9>.
1N/A=item setegid() not implemented
1N/A(F) You tried to assign to C<$)>, and your operating system doesn't
1N/Asupport the setegid() system call (or equivalent), or at least Configure
1N/A=item seteuid() not implemented
1N/A(F) You tried to assign to C<< $> >>, and your operating system doesn't
1N/Asupport the seteuid() system call (or equivalent), or at least Configure
1N/A=item setpgrp can't take arguments
1N/A(F) Your system has the setpgrp() from BSD 4.2, which takes no
1N/Aarguments, unlike POSIX setpgid(), which takes a process ID and process
1N/A=item setrgid() not implemented
1N/A(F) You tried to assign to C<$(>, and your operating system doesn't
1N/Asupport the setrgid() system call (or equivalent), or at least Configure
1N/A=item setruid() not implemented
1N/A(F) You tried to assign to C<$<>, and your operating system doesn't
1N/Asupport the setruid() system call (or equivalent), or at least Configure
1N/A=item setsockopt() on closed socket %s
1N/A(W closed) You tried to set a socket option on a closed socket. Did you
1N/Aforget to check the return value of your socket() call? See
1N/A(F) The setuid emulator won't run a script that is writable by the
1N/Aworld, because the world might have written on it already.
1N/A=item shm%s not implemented
1N/A(F) You don't have System V shared memory IPC on your system.
1N/A=item <> should be quotes
1N/A(F) You wrote C<< require <file> >> when you should have written
1N/A=item /%s/ should probably be written as "%s"
1N/A(W syntax) You have used a pattern where Perl expected to find a string,
1N/Aas in the first argument to C<join>. Perl will treat the true or false
1N/Aresult of matching the pattern against $_ as the string, which is
1N/Aprobably not what you had in mind.
1N/A=item shutdown() on closed socket %s
1N/A(W closed) You tried to do a shutdown on a closed socket. Seems a bit
1N/A=item SIG%s handler "%s" not defined
1N/A(W signal) The signal handler named in %SIG doesn't, in fact, exist.
1N/APerhaps you put it into the wrong package?
1N/A=item sort is now a reserved word
1N/A(F) An ancient error message that almost nobody ever runs into anymore.
1N/ABut before sort was a keyword, people sometimes used it as a filehandle.
1N/A=item Sort subroutine didn't return a numeric value
1N/A(F) A sort comparison routine must return a number. You probably blew
1N/Ait by not using C<< <=> >> or C<cmp>, or by not using them correctly.
1N/A=item Sort subroutine didn't return single value
1N/A(F) A sort comparison subroutine may not return a list value with more
1N/A=item splice() offset past end of array
1N/A(W misc) You attempted to specify an offset that was past the end of
1N/Athe array passed to splice(). Splicing will instead commence at the end
1N/Aof the array, rather than past it. If this isn't what you want, try
1N/Aexplicitly pre-extending the array by assigning $#array = $offset. See
1N/A(P) The split was looping infinitely. (Obviously, a split shouldn't
1N/Aiterate more times than there are characters of input, which is what
1N/A=item Statement unlikely to be reached
1N/A(W exec) You did an exec() with some statement after it other than a
1N/Adie(). This is almost always an error, because exec() never returns
1N/Aunless there was a failure. You probably wanted to use system()
1N/Ainstead, which does return. To suppress this warning, put the exec() in
1N/A=item stat() on unopened filehandle %s
1N/A(W unopened) You tried to use the stat() function on a filehandle that
1N/Awas either never opened or has since been closed.
1N/A=item Stub found while resolving method `%s' overloading %s
1N/A(P) Overloading resolution over @ISA tree may be broken by importation
1N/Astubs. Stubs should never be implicitly created, but explicit calls to
1N/AC<can> may break this.
1N/A=item Subroutine %s redefined
1N/A(W redefine) You redefined a subroutine. To suppress this warning, say
1N/A no warnings 'redefine';
1N/A eval "sub name { ... }";
1N/A=item Substitution loop
1N/A(P) The substitution was looping infinitely. (Obviously, a substitution
1N/Ashouldn't iterate more times than there are characters of input, which
1N/Ais what happened.) See the discussion of substitution in
1N/AL<perlop/"Quote and Quote-like Operators">.
1N/A=item Substitution pattern not terminated
1N/A(F) The lexer couldn't find the interior delimiter of an s/// or s{}{}
1N/Aconstruct. Remember that bracketing delimiters count nesting level.
1N/AMissing the leading C<$> from variable C<$s> may cause this error.
1N/A=item Substitution replacement not terminated
1N/A(F) The lexer couldn't find the final delimiter of an s/// or s{}{}
1N/Aconstruct. Remember that bracketing delimiters count nesting level.
1N/AMissing the leading C<$> from variable C<$s> may cause this error.
1N/A=item substr outside of string
1N/A(W substr),(F) You tried to reference a substr() that pointed outside of
1N/Aa string. That is, the absolute value of the offset was larger than the
1N/Asubstr is used in an lvalue context (as the left hand side of an
1N/Aassignment or as a subroutine argument for example).
1N/A=item suidperl is no longer needed since %s
1N/A(F) Your Perl was compiled with B<-D>SETUID_SCRIPTS_ARE_SECURE_NOW, but
1N/Aa version of the setuid emulator somehow got run anyway.
1N/A=item Switch (?(condition)... contains too many branches in regex; marked by <-- HERE in m/%s/
1N/A(F) A (?(condition)if-clause|else-clause) construct can have at most two
1N/Abranches (the if-clause and the else-clause). If you want one or both to
1N/Acontain alternation, such as using C<this|that|other>, enclose it in
1N/Aclustering parentheses:
1N/A (?(condition)(?:this|that|other)|else-clause)
1N/AThe <-- HERE shows in the regular expression about where the problem was
1N/Adiscovered. See L<perlre>.
1N/A=item Switch condition not recognized in regex; marked by <-- HERE in m/%s/
1N/A(F) If the argument to the (?(...)if-clause|else-clause) construct is a
1N/Anumber, it can be only a number. The <-- HERE shows in the regular expression
1N/Aabout where the problem was discovered. See L<perlre>.
1N/A=item switching effective %s is not implemented
1N/A(F) While under the C<use filetest> pragma, we cannot switch the real
1N/Aand effective uids or gids.
1N/A(F) The final summary message when a C<perl -c> succeeds.
1N/A(F) Probably means you had a syntax error. Common reasons include:
1N/A A keyword is misspelled.
1N/A A semicolon is missing.
1N/A An opening or closing parenthesis is missing.
1N/A An opening or closing brace is missing.
1N/A A closing quote is missing.
1N/AOften there will be another error message associated with the syntax
1N/Aerror giving more information. (Sometimes it helps to turn on B<-w>.)
1N/AThe error message itself often tells you where it was in the line when
1N/Ait decided to give up. Sometimes the actual error is several tokens
1N/Abefore this, because Perl is good at understanding random input.
1N/AOccasionally the line number may be misleading, and once in a blue moon
1N/Athe only way to figure out what's triggering the error is to call
1N/AC<perl -c> repeatedly, chopping away half the program each time to see
1N/Aif the error went away. Sort of the cybernetic version of S<20
1N/A=item syntax error at line %d: `%s' unexpected
1N/A(A) You've accidentally run your script through the Bourne shell instead
1N/Aof Perl. Check the #! line, or manually feed your script into Perl
1N/A=item syntax error in file %s at line %d, next 2 tokens "%s"
1N/A(F) This error is likely to occur if you run a perl5 script through
1N/Aa perl4 interpreter, especially if the next 2 tokens are "use strict"
1N/Aor "my $var" or "our $var".
1N/A=item sysread() on closed filehandle %s
1N/A(W closed) You tried to read from a closed filehandle.
1N/A=item sysread() on unopened filehandle %s
1N/A(W unopened) You tried to read from a filehandle that was never opened.
1N/A=item System V %s is not implemented on this machine
1N/A(F) You tried to do something with a function beginning with "sem",
1N/A"shm", or "msg" but that System V IPC is not implemented in your
1N/Amachine. In some machines the functionality can exist but be
1N/Aunconfigured. Consult your system support.
1N/A=item syswrite() on closed filehandle %s
1N/A(W closed) The filehandle you're writing to got itself closed sometime
1N/Abefore now. Check your control flow.
1N/A=item C<-T> and C<-B> not implemented on filehandles
1N/A(F) Perl can't peek at the stdio buffer of filehandles when it doesn't
1N/Aknow about your kind of stdio. You'll have to use a filename instead.
1N/A=item Target of goto is too deeply nested
1N/A(F) You tried to use C<goto> to reach a label that was too deeply nested
1N/Afor Perl to reach. Perl is doing you a favor by refusing.
1N/A=item tell() on unopened filehandle
1N/A(W unopened) You tried to use the tell() function on a filehandle that
1N/Awas either never opened or has since been closed.
1N/A=item That use of $[ is unsupported
1N/A(F) Assignment to C<$[> is now strictly circumscribed, and interpreted
1N/Aas a compiler directive. You may say only one of
1N/AThis is to prevent the problem of one module changing the array base out
1N/Afrom under another module inadvertently. See L<perlvar/$[>.
1N/A=item The crypt() function is unimplemented due to excessive paranoia
1N/A(F) Configure couldn't find the crypt() function on your machine,
1N/Aprobably because your vendor didn't supply it, probably because they
1N/Athink the
U.S. Government thinks it's a secret, or at least that they
1N/Awill continue to pretend that it is. And if you quote me on that, I
1N/A=item The %s function is unimplemented
1N/AThe function indicated isn't implemented on this architecture, according
1N/Ato the probings of Configure.
1N/A=item The stat preceding %s wasn't an lstat
1N/A(F) It makes no sense to test the current stat buffer for symbolic
1N/Alinkhood if the last stat that wrote to the stat buffer already went
1N/Apast the symlink to get to the real file. Use an actual filename
1N/A=item The 'unique' attribute may only be applied to 'our' variables
1N/A(F) Currently this attribute is not supported on C<my> or C<sub>
1N/A=item This Perl can't reset CRTL environ elements (%s)
1N/A=item This Perl can't set CRTL environ elements (%s=%s)
1N/A(W internal) Warnings peculiar to VMS. You tried to change or delete an
1N/Aelement of the CRTL's internal environ array, but your copy of Perl
1N/Awasn't built with a CRTL that contained the setenv() function. You'll
1N/Aneed to rebuild Perl with a CRTL that does, or redefine
1N/AF<PERL_ENV_TABLES> (see L<perlvms>) so that the environ array isn't the
1N/Atarget of the change to
1N/A%ENV which produced the warning.
1N/A=item thread failed to start: %s
1N/A(F) The entry point function of threads->create() failed for some reason.
1N/A=item 5.005 threads are deprecated
1N/A(D deprecated) The 5.005-style threads (activated by C<use Thread;>)
1N/Aare deprecated and one should use the new ithreads instead,
1N/Asee L<perl58delta> for more details.
1N/A=item Tied variable freed while still in use
1N/A(F) An access method for a tied variable (
e.g. FETCH) did something to
1N/Afree the variable. Since continuing the current operation is likely
1N/Ato result in a coredump, Perl is bailing out instead.
1N/A=item times not implemented
1N/A(F) Your version of the C library apparently doesn't do times(). I
1N/Asuspect you're not running on Unix.
1N/A=item To%s: illegal mapping '%s'
1N/A(F) You tried to define a customized To-mapping for lc(), lcfirst,
1N/Auc(), or ucfirst() (or their string-inlined versions), but you
1N/Aspecified an illegal mapping.
1N/ASee L<perlunicode/"User-Defined Character Properties">.
1N/A=item Too deeply nested ()-groups
1N/A(F) Your template contains ()-groups with a ridiculously deep nesting level.
1N/A=item Too few args to syscall
1N/A(F) There has to be at least one argument to syscall() to specify the
1N/Asystem call to call, silly dilly.
1N/A=item Too late for "-%s" option
1N/A(X) The #! line (or local equivalent) in a Perl script contains the
1N/AB<-M> or B<-m> option. This is an error because B<-M> and B<-m> options
1N/Aare not intended for use inside scripts. Use the C<use> pragma instead.
1N/A=item Too late for "B<-T>" option
1N/A(X) The #! line (or local equivalent) in a Perl script contains the
1N/AB<-T> option, but Perl was not invoked with B<-T> in its command line.
1N/AThis is an error because, by the time Perl discovers a B<-T> in a
1N/Ascript, it's too late to properly taint everything from the environment.
1N/AIf the Perl script is being executed as a command using the #!
1N/Amechanism (or its local equivalent), this error can usually be fixed by
1N/Aediting the #! line so that the B<-T> option is a part of Perl's first
1N/Aargument:
e.g. change C<perl -n -T> to C<perl -T -n>.
1N/AIf the Perl script is being executed as C<perl scriptname>, then the
1N/AB<-T> option must appear on the command line: C<perl -T scriptname>.
1N/A=item Too late to run %s block
1N/A(W void) A CHECK or INIT block is being defined during run time proper,
1N/Awhen the opportunity to run them has already passed. Perhaps you are
1N/Aloading a file with C<require> or C<do> when you should be using C<use>
1N/Ainstead. Or perhaps you should put the C<require> or C<do> inside a
1N/A=item Too many args to syscall
1N/A(F) Perl supports a maximum of only 14 args to syscall().
1N/A=item Too many arguments for %s
1N/A(F) The function requires fewer arguments than you specified.
1N/A(A) You've accidentally run your script through B<csh> instead of Perl.
1N/ACheck the #! line, or manually feed your script into Perl yourself.
1N/A(A) You've accidentally run your script through B<csh> instead of Perl.
1N/ACheck the #! line, or manually feed your script into Perl yourself.
1N/A=item Trailing \ in regex m/%s/
1N/A(F) The regular expression ends with an unbackslashed backslash.
1N/ABackslash it. See L<perlre>.
1N/A=item Transliteration pattern not terminated
1N/A(F) The lexer couldn't find the interior delimiter of a tr/// or tr[][]
1N/Aor y/// or y[][] construct. Missing the leading C<$> from variables
1N/AC<$tr> or C<$y> may cause this error.
1N/A=item Transliteration replacement not terminated
1N/A(F) The lexer couldn't find the final delimiter of a tr/// or tr[][]
1N/A=item '%s' trapped by operation mask
1N/A(F) You tried to use an operator from a Safe compartment in which it's
1N/Adisallowed. See L<Safe>.
1N/A=item truncate not implemented
1N/A(F) Your machine doesn't implement a file truncation mechanism that
1N/AConfigure knows about.
1N/A=item Type of arg %d to %s must be %s (not %s)
1N/A(F) This function requires the argument in that position to be of a
1N/Acertain type. Arrays must be @NAME or C<@{EXPR}>. Hashes must be
1N/A%NAME or C<%{EXPR}>. No implicit dereferencing is allowed--use the
1N/A{EXPR} forms as an explicit dereference. See L<perlref>.
1N/A=item umask not implemented
1N/A(F) Your machine doesn't implement the umask function and you tried to
1N/Ause it to restrict permissions for yourself (EXPR & 0700).
1N/A=item Unable to create sub named "%s"
1N/A(F) You attempted to create or access a subroutine with an illegal name.
1N/A=item Unbalanced context: %d more PUSHes than POPs
1N/A(W internal) The exit code detected an internal inconsistency in how
1N/Amany execution contexts were entered and left.
1N/A=item Unbalanced saves: %d more saves than restores
1N/A(W internal) The exit code detected an internal inconsistency in how
1N/Amany values were temporarily localized.
1N/A=item Unbalanced scopes: %d more ENTERs than LEAVEs
1N/A(W internal) The exit code detected an internal inconsistency in how
1N/Amany blocks were entered and left.
1N/A=item Unbalanced tmps: %d more allocs than frees
1N/A(W internal) The exit code detected an internal inconsistency in how
1N/Amany mortal scalars were allocated and freed.
1N/A=item Undefined format "%s" called
1N/A(F) The format indicated doesn't seem to exist. Perhaps it's really in
1N/Aanother package? See L<perlform>.
1N/A=item Undefined sort subroutine "%s" called
1N/A(F) The sort comparison routine specified doesn't seem to exist.
1N/A=item Undefined subroutine &%s called
1N/A(F) The subroutine indicated hasn't been defined, or if it was, it has
1N/Asince been undefined.
1N/A=item Undefined subroutine called
1N/A(F) The anonymous subroutine you're trying to call hasn't been defined,
1N/Aor if it was, it has since been undefined.
1N/A=item Undefined subroutine in sort
1N/A(F) The sort comparison routine specified is declared but doesn't seem
1N/A=item Undefined top format "%s" called
1N/A(F) The format indicated doesn't seem to exist. Perhaps it's really in
1N/Aanother package? See L<perlform>.
1N/A=item Undefined value assigned to typeglob
1N/A(W misc) An undefined value was assigned to a typeglob, a la
1N/AC<*foo = undef>. This does nothing. It's possible that you really mean
1N/A=item %s: Undefined variable
1N/A(A) You've accidentally run your script through B<csh> instead of Perl.
1N/ACheck the #! line, or manually feed your script into Perl yourself.
1N/A=item unexec of %s into %s failed!
1N/A(F) The unexec() routine failed for some reason. See your local FSF
1N/Arepresentative, who probably put it there in the first place.
1N/A=item Unicode character %s is illegal
1N/A(W utf8) Certain Unicode characters have been designated off-limits by
1N/Athe Unicode standard and should not be generated. If you really know
1N/Awhat you are doing you can turn off this warning by C<no warnings 'utf8';>.
1N/A=item Unknown BYTEORDER
1N/A(F) There are no byte-swapping functions for a machine with this byte
1N/A=item Unknown open() mode '%s'
1N/A(F) The second argument of 3-argument open() is not among the list
1N/Aof valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
1N/AC<< +> >>, C<<< +>> >>>, C<-|>, C<|->, C<< <& >>, C<< >& >>.
1N/A=item Unknown PerlIO layer "%s"
1N/A(W layer) An attempt was made to push an unknown layer onto the Perl I/O
1N/Asystem. (Layers take care of transforming data between external and
1N/Ainternal representations.) Note that some layers, such as C<mmap>,
1N/Aare not supported in all environments. If your program didn't
1N/Aexplicitly request the failing operation, it may be the result of the
1N/Avalue of the environment variable PERLIO.
1N/A=item Unknown process %x sent message to prime_env_iter: %s
1N/A(P) An error peculiar to VMS. Perl was reading values for %ENV before
1N/Aiterating over it, and someone else stuck a message in the stream of
1N/Adata Perl expected. Someone's very confused, or perhaps trying to
1N/Asubvert Perl's population of %ENV for nefarious purposes.
1N/A=item Unknown "re" subpragma '%s' (known ones are: %s)
1N/AYou tried to use an unknown subpragma of the "re" pragma.
1N/A=item Unknown switch condition (?(%.2s in regex; marked by <-- HERE in m/%s/
1N/A(F) The condition part of a (?(condition)if-clause|else-clause) construct
1N/Ais not known. The condition may be lookahead or lookbehind (the condition
1N/Ais true if the lookahead or lookbehind is true), a (?{...}) construct (the
1N/Acondition is true if the code evaluates to a true value), or a number (the
1N/Acondition is true if the set of capturing parentheses named by the number
1N/AThe <-- HERE shows in the regular expression about where the problem was
1N/Adiscovered. See L<perlre>.
1N/A=item Unknown Unicode option letter '%c'
1N/AYou specified an unknown Unicode option. See L<perlrun> documentation
1N/Aof the C<-C> switch for the list of known options.
1N/A=item Unknown Unicode option value %x
1N/AYou specified an unknown Unicode option. See L<perlrun> documentation
1N/Aof the C<-C> switch for the list of known options.
1N/A=item Unknown warnings category '%s'
1N/A(F) An error issued by the C<warnings> pragma. You specified a warnings
1N/Acategory that is unknown to perl at this point.
1N/ANote that if you want to enable a warnings category registered by a module
1N/A(
e.g. C<use warnings 'File::Find'>), you must have imported this module
1N/A=item unmatched [ in regex; marked by <-- HERE in m/%s/
1N/A(F) The brackets around a character class must match. If you wish to
1N/Ainclude a closing bracket in a character class, backslash it or put it
1N/Afirst. The <-- HERE shows in the regular expression about where the problem
1N/Awas discovered. See L<perlre>.
1N/A=item unmatched ( in regex; marked by <-- HERE in m/%s/
1N/A(F) Unbackslashed parentheses must always be balanced in regular
1N/Aexpressions. If you're a vi user, the % key is valuable for finding the
1N/Amatching parenthesis. The <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item Unmatched right %s bracket
1N/A(F) The lexer counted more closing curly or square brackets than opening
1N/Aones, so you're probably missing a matching opening bracket. As a
1N/Ageneral rule, you'll find the missing one (so to speak) near the place
1N/Ayou were last editing.
1N/A=item Unquoted string "%s" may clash with future reserved word
1N/A(W reserved) You used a bareword that might someday be claimed as a
1N/Areserved word. It's best to put such a word in quotes, or capitalize it
1N/Asomehow, or insert an underbar into it. You might also declare it as a
1N/A=item Unrecognized character %s
1N/A(F) The Perl parser has no idea what to do with the specified character
1N/Ain your Perl script (or eval). Perhaps you tried to run a compressed
1N/Ascript, a binary program, or a directory as a Perl program.
1N/A=item /%s/: Unrecognized escape \\%c in character class passed through
1N/A(W regexp) You used a backslash-character combination which is not
1N/Arecognized by Perl inside character classes. The character was
1N/Aunderstood literally.
1N/A=item Unrecognized escape \\%c passed through
1N/A(W misc) You used a backslash-character combination which is not
1N/A=item Unrecognized escape \\%c passed through in regex; marked by <-- HERE in m/%s/
1N/A(W regexp) You used a backslash-character combination which is not
1N/Arecognized by Perl. This combination appears in an interpolated variable or
1N/Aa C<'>-delimited regular expression. The character was understood
1N/Aliterally. The <-- HERE shows in the regular expression about where the
1N/Aescape was discovered.
1N/A=item Unrecognized signal name "%s"
1N/A(F) You specified a signal name to the kill() function that was not
1N/Arecognized. Say C<kill -l> in your shell to see the valid signal names
1N/A=item Unrecognized switch: -%s (-h will show valid options)
1N/A(F) You specified an illegal option to Perl. Don't do that. (If you
1N/Athink you didn't do that, check the #! line to see if it's supplying the
1N/Abad switch on your behalf.)
1N/A=item Unsuccessful %s on filename containing newline
1N/A(W newline) A file operation was attempted on a filename, and that
1N/Aoperation failed, PROBABLY because the filename contained a newline,
1N/A=item Unsupported directory function "%s" called
1N/A(F) Your machine doesn't support opendir() and readdir().
1N/A=item Unsupported function %s
1N/A(F) This machine doesn't implement the indicated function, apparently.
1N/AAt least, Configure doesn't think so.
1N/A=item Unsupported function fork
1N/A(F) Your version of executable does not support forking.
1N/ANote that under some systems, like OS/2, there may be different flavors
1N/Aof Perl executables, some of which may support fork, some not. Try
1N/Achanging the name you call Perl by to C<perl_>, C<perl__>, and so on.
1N/A=item Unsupported script encoding %s
1N/A(F) Your program file begins with a Unicode Byte Order Mark (BOM) which
1N/Adeclares it to be in a Unicode encoding that Perl cannot read.
1N/A=item Unsupported socket function "%s" called
1N/A(F) Your machine doesn't support the Berkeley socket mechanism, or at
1N/Aleast that's what Configure thought.
1N/A=item Unterminated attribute list
1N/A(F) The lexer found something other than a simple identifier at the
1N/Astart of an attribute, and it wasn't a semicolon or the start of a
1N/Ablock. Perhaps you terminated the parameter list of the previous
1N/Aattribute too soon. See L<attributes>.
1N/A=item Unterminated attribute parameter in attribute list
1N/A(F) The lexer saw an opening (left) parenthesis character while parsing
1N/Aan attribute list, but the matching closing (right) parenthesis
1N/Acharacter was not found. You may need to add (or remove) a backslash
1N/Acharacter to get your parentheses to balance. See L<attributes>.
1N/A=item Unterminated compressed integer
1N/A(F) An argument to unpack("w",...) was incompatible with the BER
1N/Acompressed integer format and could not be converted to an integer.
1N/A=item Unterminated <> operator
1N/A(F) The lexer saw a left angle bracket in a place where it was expecting
1N/Aa term, so it's looking for the corresponding right angle bracket, and
1N/Anot finding it. Chances are you left some needed parentheses out
1N/Aearlier in the line, and you really meant a "less than".
1N/A=item untie attempted while %d inner references still exist
1N/A(W untie) A copy of the object returned from C<tie> (or C<tied>) was
1N/Astill valid when C<untie> was called.
1N/A=item Usage: POSIX::%s(%s)
1N/A(F) You called a POSIX function with incorrect arguments.
1N/A=item Usage: Win32::%s(%s)
1N/A(F) You called a Win32 function with incorrect arguments.
1N/ASee L<Win32> for more information.
1N/A=item Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/
1N/A(W regexp) You have used an internal modifier such as (?-o) that has no
1N/Ameaning unless removed from the entire regexp:
1N/A if ($string =~ /(?-o)$pattern/o) { ... }
1N/A if ($string =~ /$pattern/) { ... }
1N/AThe <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item Useless (?%s) - use /%s modifier in regex; marked by <-- HERE in m/%s/
1N/A(W regexp) You have used an internal modifier such as (?o) that has no
1N/Ameaning unless applied to the entire regexp:
1N/A if ($string =~ /(?o)$pattern/) { ... }
1N/A if ($string =~ /$pattern/o) { ... }
1N/AThe <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item Useless use of %s in void context
1N/A(W void) You did something without a side effect in a context that does
1N/Anothing with the return value, such as a statement that doesn't return a
1N/Avalue from a block, or the left side of a scalar comma operator. Very
1N/Aoften this points not to stupidity on your part, but a failure of Perl
1N/Ato parse your program the way you thought it would. For example, you'd
1N/Aget this if you mixed up your C precedence with Python precedence and
1N/Awhen you meant to say
1N/A ($one, $two) = (1, 2);
1N/AAnother common error is to use ordinary parentheses to construct a list
1N/Areference when you should be using square or curly brackets, for
1N/Awhen you should have said
1N/AThe square brackets explicitly turn a list value into a scalar value,
1N/Awhile parentheses do not. So when a parenthesized list is evaluated in
1N/Aa scalar context, the comma is treated like C's comma operator, which
1N/Athrows away the left argument, which is not what you want. See
1N/AL<perlref> for more on this.
1N/AThis warning will not be issued for numerical constants equal to 0 or 1
1N/Asince they are often used in statements like
1N/A 1 while sub_with_side_effects() ;
1N/AString constants that would normally evaluate to 0 or 1 are warned
1N/A=item Useless use of "re" pragma
1N/A(W) You did C<use re;> without any arguments. That isn't very useful.
1N/A=item Useless use of sort in scalar context
1N/A(W void) You used sort in scalar context, as in :
1N/AThis is not very useful, and perl currently optimizes this away.
1N/A=item Useless use of %s with no values
1N/A(W syntax) You used the push() or unshift() function with no arguments
1N/Aapart from the array, like C<push(@x)> or C<unshift(@foo)>. That won't
1N/Ausually have any effect on the array, so is completely useless. It's
1N/Apossible in principle that push(@tied_array) could have some effect
1N/Aif the array is tied to a class which implements a PUSH method. If so,
1N/Ayou can write it as C<push(@tied_array,())> to avoid this warning.
1N/A=item "use" not allowed in expression
1N/A(F) The "use" keyword is recognized and executed at compile time, and
1N/Areturns no useful value. See L<perlmod>.
1N/A=item Use of bare << to mean <<"" is deprecated
1N/A(D deprecated) You are now encouraged to use the explicitly quoted form
1N/Aif you wish to use an empty line as the terminator of the here-document.
1N/A=item Use of chdir('') or chdir(undef) as chdir() deprecated
1N/A(D deprecated) chdir() with no arguments is documented to change to
1N/A$ENV{HOME} or $ENV{LOGDIR}. chdir(undef) and chdir('') share this
1N/Abehavior, but that has been deprecated. In future versions they
1N/ABe careful to check that what you pass to chdir() is defined and not
1N/Ablank, else you might find yourself in your home directory.
1N/A=item Use of /c modifier is meaningless in s///
1N/A(W regexp) You used the /c modifier in a substitution. The /c
1N/Amodifier is not presently meaningful in substitutions.
1N/A=item Use of /c modifier is meaningless without /g
1N/A(W regexp) You used the /c modifier with a regex operand, but didn't
1N/Ause the /g modifier. Currently, /c is meaningful only when /g is
1N/Aused. (This may change in the future.)
1N/A=item Use of freed value in iteration
1N/A(F) Perhaps you modified the iterated array within the loop?
1N/AThis error is typically caused by code like the following:
1N/A @a = () for (1,2,@a);
1N/AYou are not supposed to modify arrays while they are being iterated over.
1N/AFor speed and efficiency reasons, Perl internally does not do full
1N/Areference-counting of iterated items, hence deleting such an item in the
1N/Amiddle of an iteration causes Perl to see a freed value.
1N/A=item Use of *glob{FILEHANDLE} is deprecated
1N/A(D deprecated) You are now encouraged to use the shorter *glob{IO} form
1N/Ato access the filehandle slot within a typeglob.
1N/A=item Use of /g modifier is meaningless in split
1N/A(W regexp) You used the /g modifier on the pattern for a C<split>
1N/Aoperator. Since C<split> always tries to match the pattern
1N/Arepeatedly, the C</g> has no effect.
1N/A=item Use of implicit split to @_ is deprecated
1N/A(D deprecated) It makes a lot of work for the compiler when you clobber
1N/Aa subroutine's argument list, so it's better if you assign the results
1N/Aof a split() explicitly to an array (or list).
1N/A=item Use of inherited AUTOLOAD for non-method %s() is deprecated
1N/A(D deprecated) As an (ahem) accidental feature, C<AUTOLOAD> subroutines
1N/Aare looked up as methods (using the C<@ISA> hierarchy) even when the
1N/Asubroutines to be autoloaded were called as plain functions (
e.g. 1N/AC<Foo::bar()>), not as methods (
e.g. C<< Foo->bar() >> or C<<
1N/AThis bug will be rectified in future by using method lookup only for
1N/Amethods' C<AUTOLOAD>s. However, there is a significant base of existing
1N/Acode that may be using the old behavior. So, as an interim step, Perl
1N/Acurrently issues an optional warning when non-methods use inherited
1N/AThe simple rule is: Inheritance will not work when autoloading
1N/Anon-methods. The simple fix for old code is: In any module that used
1N/Ato depend on inheriting C<AUTOLOAD> for non-methods from a base class
1N/Anamed C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during
1N/AIn code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);>
1N/Ayou should remove AutoLoader from @ISA and change C<use AutoLoader;> to
1N/AC<use AutoLoader 'AUTOLOAD';>.
1N/A=item Use of %s in printf format not supported
1N/A(F) You attempted to use a feature of printf that is accessible from
1N/Aonly C. This usually means there's a better way to do it in Perl.
1N/A=item Use of $* is deprecated
1N/A(D deprecated) This variable magically turned on multi-line pattern
1N/Amatching, both for you and for any luckless subroutine that you happen
1N/Ato call. You should use the new C<//m> and C<//s> modifiers now to do
1N/Athat without the dangerous action-at-a-distance effects of C<$*>.
1N/A=item Use of $# is deprecated
1N/A(D deprecated) This was an ill-advised attempt to emulate a poorly
1N/Adefined B<awk> feature. Use an explicit printf() or sprintf() instead.
1N/A=item Use of %s is deprecated
1N/A(D deprecated) The construct indicated is no longer recommended for use,
1N/Agenerally because there's a better way to do it, and also because the
1N/Aold way has bad side effects.
1N/A=item Use of -l on filehandle %s
1N/A(W io) A filehandle represents an opened file, and when you opened the file
1N/Ait already went past any symlink you are presumably trying to look for.
1N/AThe operation returned C<undef>. Use a filename instead.
1N/A=item Use of "package" with no arguments is deprecated
1N/A(D deprecated) You used the C<package> keyword without specifying a package
1N/Aname. So no namespace is current at all. Using this can cause many
1N/Aotherwise reasonable constructs to fail in baffling ways. C<use strict;>
1N/A=item Use of reference "%s" as array index
1N/A(W misc) You tried to use a reference as an array index; this probably
1N/Aisn't what you mean, because references in numerical context tend
1N/Ato be huge numbers, and so usually indicates programmer error.
1N/AIf you really do mean it, explicitly numify your reference, like so:
1N/AC<$array[0+$ref]>. This warning is not given for overloaded objects,
1N/Aeither, because you can overload the numification and stringification
1N/Aoperators and then you assumedly know what you are doing.
1N/A=item Use of reserved word "%s" is deprecated
1N/A(D deprecated) The indicated bareword is a reserved word. Future
1N/Aversions of perl may use it as a keyword, so you're better off either
1N/Aexplicitly quoting the word in a manner appropriate for its context of
1N/Ause, or using a different name altogether. The warning can be
1N/Asuppressed for subroutine names by either adding a C<&> prefix, or using
1N/Aa package qualifier,
e.g. C<&our()>, or C<Foo::our()>.
1N/A=item Use of tainted arguments in %s is deprecated
1N/A(W taint, deprecated) You have supplied C<system()> or C<exec()> with multiple
1N/Aarguments and at least one of them is tainted. This used to be allowed
1N/Abut will become a fatal error in a future version of perl. Untaint your
1N/Aarguments. See L<perlsec>.
1N/A=item Use of uninitialized value%s
1N/A(W uninitialized) An undefined value was used as if it were already
1N/Adefined. It was interpreted as a "" or a 0, but maybe it was a mistake.
1N/ATo suppress this warning assign a defined value to your variables.
1N/ATo help you figure out what was undefined, perl tells you what operation
1N/Ayou used the undefined value in. Note, however, that perl optimizes your
1N/Aprogram and the operation displayed in the warning may not necessarily
1N/Aappear literally in your program. For example, C<"that $foo"> is
1N/Ausually optimized into C<"that " . $foo>, and the warning will refer to
1N/Athe C<concatenation (.)> operator, even though there is no C<.> in your
1N/A=item Using a hash as a reference is deprecated
1N/A(D deprecated) You tried to use a hash as a reference, as in
1N/AC<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl <= 5.6.1
1N/Aused to allow this syntax, but shouldn't have. It is now deprecated, and will
1N/Abe removed in a future version.
1N/A=item Using an array as a reference is deprecated
1N/A(D deprecated) You tried to use an array as a reference, as in
1N/AC<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl <= 5.6.1 used to
1N/Aallow this syntax, but shouldn't have. It is now deprecated, and will be
1N/Aremoved in a future version.
1N/A=item UTF-16 surrogate %s
1N/A(W utf8) You tried to generate half of an UTF-16 surrogate by
1N/Arequesting a Unicode character between the code points 0xD800 and
1N/A0xDFFF (inclusive). That range is reserved exclusively for the use of
1N/AUTF-16 encoding (by having two 16-bit UCS-2 characters); but Perl
1N/Aencodes its characters in UTF-8, so what you got is a very illegal
1N/Acharacter. If you really know what you are doing you can turn off
1N/Athis warning by C<no warnings 'utf8';>.
1N/A=item Value of %s can be "0"; test with defined()
1N/A(W misc) In a conditional expression, you used <HANDLE>, <*> (glob),
1N/AC<each()>, or C<readdir()> as a boolean value. Each of these constructs
1N/Acan return a value of "0"; that would make the conditional expression
1N/Afalse, which is probably not what you intended. When using these
1N/Aconstructs in conditional expressions, test their values with the
1N/A=item Value of CLI symbol "%s" too long
1N/A(W misc) A warning peculiar to VMS. Perl tried to read the value of an
1N/A%ENV element from a CLI symbol table, and found a resultant string
1N/Alonger than 1024 characters. The return value has been truncated to
1N/A=item Variable "%s" is not imported%s
1N/A(F) While "use strict" in effect, you referred to a global variable that
1N/Ayou apparently thought was imported from another module, because
1N/Asomething else of the same name (usually a subroutine) is exported by
1N/Athat module. It usually means you put the wrong funny character on the
1N/Afront of your variable.
1N/A=item Variable length lookbehind not implemented in regex; marked by <-- HERE in m/%s/
1N/A(F) Lookbehind is allowed only for subexpressions whose length is fixed and
1N/Aknown at compile time. The <-- HERE shows in the regular expression about
1N/Awhere the problem was discovered. See L<perlre>.
1N/A=item "%s" variable %s masks earlier declaration in same %s
1N/A(W misc) A "my" or "our" variable has been redeclared in the current
1N/Ascope or statement, effectively eliminating all access to the previous
1N/Ainstance. This is almost always a typographical error. Note that the
1N/Aearlier variable will still exist until the end of the scope or until
1N/Aall closure referents to it are destroyed.
1N/A=item Variable "%s" may be unavailable
1N/A(W closure) An inner (nested) I<anonymous> subroutine is inside a
1N/AI<named> subroutine, and outside that is another subroutine; and the
1N/Aanonymous (innermost) subroutine is referencing a lexical variable
1N/Adefined in the outermost subroutine. For example:
1N/A sub outermost { my $a; sub middle { sub { $a } } }
1N/AIf the anonymous subroutine is called or referenced (directly or
1N/Aindirectly) from the outermost subroutine, it will share the variable as
1N/Ayou would expect. But if the anonymous subroutine is called or
1N/Areferenced when the outermost subroutine is not active, it will see the
1N/Avalue of the shared variable as it was before and during the *first*
1N/Acall to the outermost subroutine, which is probably not what you want.
1N/AIn these circumstances, it is usually best to make the middle subroutine
1N/Aanonymous, using the C<sub {}> syntax. Perl has specific support for
1N/Ashared variables in nested anonymous subroutines; a named subroutine in
1N/Abetween interferes with this feature.
1N/A=item Variable syntax
1N/A(A) You've accidentally run your script through B<csh> instead
1N/Aof Perl. Check the #! line, or manually feed your script into
1N/A=item Variable "%s" will not stay shared
1N/A(W closure) An inner (nested) I<named> subroutine is referencing a
1N/Alexical variable defined in an outer subroutine.
1N/AWhen the inner subroutine is called, it will probably see the value of
1N/Athe outer subroutine's variable as it was before and during the *first*
1N/Acall to the outer subroutine; in this case, after the first call to the
1N/Aouter subroutine is complete, the inner and outer subroutines will no
1N/Alonger share a common value for the variable. In other words, the
1N/Avariable will no longer be shared.
1N/AFurthermore, if the outer subroutine is anonymous and references a
1N/Alexical variable outside itself, then the outer and inner subroutines
1N/Awill I<never> share the given variable.
1N/AThis problem can usually be solved by making the inner subroutine
1N/Aanonymous, using the C<sub {}> syntax. When inner anonymous subs that
1N/Areference variables in outer subroutines are called or referenced, they
1N/Aare automatically rebound to the current values of such variables.
1N/A=item Version number must be a constant number
1N/A(P) The attempt to translate a C<use Module
n.n LIST> statement into
1N/Aits equivalent C<BEGIN> block found an internal inconsistency with
1N/A=item Warning: something's wrong
1N/A(W) You passed warn() an empty string (the equivalent of C<warn "">) or
1N/Ayou called it with no args and C<$_> was empty.
1N/A=item Warning: unable to close filehandle %s properly
1N/A(S) The implicit close() done by an open() got an error indication on
1N/Athe close(). This usually indicates your file system ran out of disk
1N/A=item Warning: Use of "%s" without parentheses is ambiguous
1N/A(S ambiguous) You wrote a unary operator followed by something that
1N/Alooks like a binary operator that could also have been interpreted as a
1N/Aterm or unary operator. For instance, if you know that the rand
1N/Afunction has a default argument of 1.0, and you write
1N/Ayou may THINK you wrote the same thing as
1N/Abut in actual fact, you got
1N/ASo put in parentheses to say what you really mean.
1N/A=item Wide character in %s
1N/A(W utf8) Perl met a wide character (>255) when it wasn't expecting
1N/Aone. This warning is by default on for I/O (like print). The easiest
1N/Away to quiet this warning is simply to add the C<:utf8> layer to the
1N/Aoutput,
e.g. C<binmode STDOUT, ':utf8'>. Another way to turn off the
1N/Awarning is to add C<no warnings 'utf8';> but that is often closer to
1N/Acheating. In general, you are supposed to explicitly mark the
1N/A=item Within []-length '%c' not allowed
1N/A(F) The count in the (un)pack template may be replaced by C<[TEMPLATE]> only if
1N/AC<TEMPLATE> always matches the same amount of packed bytes that can be
1N/Adetermined from the template alone. This is not possible if it contains an
1N/Aof the codes @, /, U, u, w or a *-length. Redesign the template.
1N/A=item write() on closed filehandle %s
1N/A(W closed) The filehandle you're writing to got itself closed sometime
1N/Abefore now. Check your control flow.
1N/A=item %s "\x%s" does not map to Unicode
1N/AWhen reading in different encodings Perl tries to map everything
1N/Ainto Unicode characters. The bytes you read in are not legal in
1N/Athis encoding, for example
1N/A utf8 "\xE4" does not map to Unicode
1N/Aif you try to read in the a-diaereses Latin-1 as UTF-8.
1N/A=item 'X' outside of string
1N/A(F) You had a (un)pack template that specified a relative position before
1N/A=item 'x' outside of string in unpack
1N/A(F) You had a pack template that specified a relative position after
1N/A=item Xsub "%s" called in sort
1N/A(F) The use of an external subroutine as a sort comparison is not yet
1N/A=item Xsub called in sort
1N/A(F) The use of an external subroutine as a sort comparison is not yet
1N/A=item YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!
1N/A(F) And you probably never will, because you probably don't have the
1N/Asources to your kernel, and your vendor probably doesn't give a rip
1N/Aabout what you want. Your best bet is to put a setuid C wrapper around
1N/A=item You need to quote "%s"
1N/A(W syntax) You assigned a bareword as a signal handler name.
1N/AUnfortunately, you already have a subroutine of that name declared,
1N/Awhich means that Perl 5 will try to call the subroutine when the
1N/Aassignment is executed, which is probably not what you want. (If it IS
1N/Awhat you want, put an & in front.)
1N/A=item Your random numbers are not that random
1N/A(F) When trying to initialise the random seed for hashes, Perl could
1N/Anot get any randomness out of your system. This usually indicates
1N/ASomething Very Wrong.