ch33_01.htm

编程珍珠,里面很多好用的代码,大家可以参考学习呵呵,

or a hash or array slice, such as:
<blockquote>
<pre class="programlisting">@foo[$bar, $baz, $xyzzy]
@{$ref-&gt;[12]}{"susie", "queue"}</pre>
</blockquote>
</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">argument is not a subroutine name</tt></b>
</dt>
<dd>
<p>(F) The argument to <tt class="literal">exists</tt> for <tt class="literal">exists &amp;sub</tt> must be a subroutine
name, and not a subroutine call.  <tt class="literal">exists &amp;sub()</tt> will generate this error.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">did not return a true value</tt></b>
</dt>
<dd>
<p>(F) A <tt class="literal">require</tt>d (or <tt class="literal">use</tt>d) file must return a true value to indicate that
it compiled correctly and ran its initialization code correctly.  It's
traditional to end such a file with a <tt class="literal">1;</tt>, though any true value would
do.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">found where operator expected</tt></b>
</dt>
<dd>
<p>(S) The Perl lexer knows whether to expect a term or an operator.  If
it sees what it knows to be a term when it was expecting to see an
operator, it gives you this warning.  Usually it indicates that an
operator or delimiter was omitted, such as a semicolon.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">had compilation errors</tt></b>
</dt>
<dd>
<p>(F) The final summary message when a <em class="emphasis">perl -c</em> fails.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">has too many errors</tt></b>
</dt>
<dd>
<p>(F) The parser has given up trying to parse the program after 10
errors.  Further error messages would likely be uninformative.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">matches null string many times</tt></b>
</dt>
<dd>
<p>(W regexp) The pattern you've specified would be an infinite loop if the
regular expression engine didn't specifically check for that.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">never introduced</tt></b>
</dt>
<dd>
<p>(S internal) The symbol in question was declared but somehow went out of scope
before it could possibly have been used.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">package attribute may clash with future reserved word:</tt> <em class="replaceable">%s</em></b>
</dt>
<dd>
<p>(W reserved) A lowercase attribute name was used that had a
package-specific handler.  That name might have a meaning to Perl
itself some day, even though it doesn't yet.  Perhaps you should use a
mixed-case attribute name, instead.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em> <tt class="literal">syntax OK</tt></b>
</dt>
<dd>
<p>(F) The final summary message when a <tt class="command">perl -c</tt> succeeds.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em>: <tt class="literal">Command not found</tt></b>
</dt>
<dd>
<p>(A) You've accidentally run your script through <em class="emphasis">csh</em> instead
of Perl.  Check the <tt class="literal">#!</tt> line, or manually feed your script into
Perl yourself with <tt class="command">perl scriptname</tt>.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em><tt class="literal">: Expression syntax</tt></b>
</dt>
<dd>
<p>(A) You've accidentally run your script through <em class="emphasis">csh</em> instead
of Perl.  Check the <tt class="literal">#!</tt> line, or manually feed your script into
Perl yourself with <tt class="command">perl scriptname</tt>.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em><tt class="literal">: Undefined variable</tt></b>
</dt>
<dd>
<p>(A) You've accidentally run your script through <em class="emphasis">csh</em> instead
of Perl.  Check the <tt class="literal">#!</tt> line, or manually feed your script into
Perl yourself with <tt class="command">perl scriptname</tt>.</p>
</dd>


<dt>
<b><em class="replaceable">%s</em><tt class="literal">: not found</tt></b>
</dt>
<dd>
<p>(A) You've accidentally run your script through the Bourne shell
instead of Perl.  Check the <tt class="literal">#!</tt> line, or manually feed your script
Perl yourself with <tt class="command">perl scriptname</tt>.</p>
</dd>


<dt>
<b><tt class="literal">(in cleanup)</tt> <em class="replaceable">%s</em></b>
</dt>
<dd>
<p>(W misc) This prefix usually indicates that a <tt class="literal">DESTROY</tt> method raised
the indicated exception.  Since destructors are usually called by
the system at arbitrary points during execution, and often a vast
number of times, the warning is issued only once for any number
of failures that would otherwise result in the same message being
repeated.</p>

<p>Failure of user callbacks dispatched using the <tt class="literal">G_KEEPERR</tt> flag
could also result in this warning.  See <em class="emphasis">perlcall</em>(1).</p>
</dd>


<dt>
<b><tt class="literal">(Missing semicolon on previous line?)</tt></b>
</dt>
<dd>
<p>(S) This is an educated guess made in conjunction with the message "<tt class="literal"></tt><em class="replaceable">%s</em><tt class="literal">found where operator expected</tt>."  Don't automatically put a semicolon on
the previous line just because you saw this message.</p>
</dd>


<dt>
<b><tt class="literal">-P not allowed for setuid/setgid script</tt></b>
</dt>
<dd>
<p>(F) The script would have to be opened by the C preprocessor by name,
which provides a race condition that breaks security.</p>
</dd>


<dt>
<b><tt class="literal">-T and -B not implemented on filehandles</tt></b>
</dt>
<dd>
<p>(F) Perl can't peek at the standard I/O buffer of filehandles when it doesn't
know about your kind of standard I/O.  You'll have to use a filename instead.</p>
</dd>


<dt>
<b><tt class="literal">-p destination:</tt> <em class="replaceable">%s</em></b>
</dt>
<dd>
<p>(F) An error occurred during the implicit output invoked by the <tt class="userinput"><b>-p</b></tt>
command-line switch.  (This output goes to <tt class="literal">STDOUT</tt> unless you've
redirected it with <tt class="literal">select</tt>.)</p>
</dd>


<dt>
<b><tt class="literal">500 Server error</tt></b>
</dt>
<dd>
<p>See <tt class="literal">Server error</tt>.</p>
</dd>


<dt>
<b><tt class="literal">?+* follows nothing in regexp</tt></b>
</dt>
<dd>
<p>(F) You started a regular expression with a quantifier.  Backslash it
if you meant it literally.</p>
</dd>


<dt>
<b><tt class="literal">@ outside of string</tt></b>
</dt>
<dd>
<p>(F) You had a pack template that specified an absolute position outside
the string being unpacked.</p>
</dd>


<dt>
<b><tt class="literal">&lt;&gt; should be quotes</tt></b>
</dt>
<dd>
<p>(F) You wrote <tt class="literal">require &lt;file&gt;</tt> when you should have written
<tt class="literal">require 'file'</tt>.</p>
</dd>


<dt>
<b><tt class="literal">\1 better written as $1</tt></b>
</dt>
<dd>
<p>(W syntax) Outside of patterns, backreferences live on as variables. The use of backslashes is grandfathered on the righthand side of a
substitution, but stylistically it's better to use the variable form
because other Perl programmers will expect it, and it works better if
there are more than nine backreferences.</p>
</dd>


<dt>
<b><tt class="literal">accept() on closed socket</tt> <em class="replaceable">%s</em></b>
</dt>
<dd>
<p>(W closed) You tried to do an accept on a closed socket.  Did you
forget to check the return value of your <tt class="literal">socket</tt> call?</p>
</dd>


<dt>
<b><tt class="literal">Allocation too large: %lx</tt></b>
</dt>
<dd>
<p>(X) You can't allocate more than 64K on an MS-DOS machine.</p>
</dd>


<dt>
<b><tt class="literal">Applying</tt> <em class="replaceable">%s</em> <tt class="literal">to</tt> <em class="replaceable">%s</em> <tt class="literal">will act on scalar(</tt><em class="replaceable">%s</em><tt class="literal">)</tt></b>
</dt>
<dd>
<p>(W misc) The pattern match (<tt class="literal">//</tt>), substitution (<tt class="literal">s///</tt>), and
transliteration (<tt class="literal">tr///</tt>) operators work on scalar values.  If you
apply one of them to an array or a hash, it will convert the array or
hash to a scalar value--the length of an array or the population
info of a hash--and then work on that scalar value.  This is
probably not what you meant to do.</p>
</dd>


<dt>
<b><tt class="literal">Arg too short for msgsnd</tt></b>
</dt>
<dd>
<p>(F) <tt class="literal">msgsnd</tt> requires a string at least as long as <tt class="literal">sizeof(long)</tt>.</p>
</dd>


<dt>
<b><tt class="literal">Ambiguous use of</tt> <em class="replaceable">%s</em> <tt class="literal">resolved as</tt> <em class="replaceable">%s</em></b>
</dt>
<dd>
<p>(W ambiguous|S) You said something that may not be interpreted the way
you thought.  Normally it's pretty easy to disambiguate it by supplying
a missing quote, operator, pair of parentheses, or declaration.</p>
</dd>


<dt>
<b><tt class="literal">Ambiguous call resolved as CORE::</tt><em class="replaceable">%s</em><tt class="literal">(), qualify as such or use &amp;</tt></b>
</dt>
<dd>
<p>(W ambiguous) A subroutine you have declared has the same name as a
Perl keyword, and you have used the name without qualification for
calling one or the other.  Perl decided to call the built-in because
the subroutine is not imported.</p>

<p>To force interpretation as a subroutine call, either put an ampersand
before the subroutine name or qualify the name with its 
package. Alternatively, you can import the subroutine (or pretend that it's
imported with the <tt class="literal">use subs</tt> pragma).</p>

<p>To silently interpret it as the Perl operator, use the <tt class="literal">CORE::</tt> prefix
on the operator (e.g., <tt class="literal">CORE::log($x)</tt>) or declare the subroutine
to be an object method.</p>
</dd>


<dt>
<b><tt class="literal">Args must match #! line</tt></b>
</dt>
<dd>
<p>(F) The setuid emulator requires that the arguments Perl was invoked
with match the arguments specified on the <tt class="literal">#!</tt> line.  Since some
systems impose a one-argument limit on the <tt class="literal">#!</tt> line, try combining
switches; for example, turn <tt class="userinput"><b>-w -U</b></tt> into <tt class="userinput"><b>-wU</b></tt>.</p>
</dd>


<dt>
<b><tt class="literal">Argument "</tt><em class="replaceable">%s</em><tt class="literal">" isn't numeric</tt></b>
</dt>
<dd>
<p>(W numeric) The indicated string was fed as an argument to an operator
that expected a numeric value instead.  If you're fortunate, the
message will identify which operator was so unfortunate.</p>
</dd>


<dt>
<b><tt class="literal">Array @</tt><em class="replaceable">%s</em> <tt class="literal">missing the @ in argument</tt> <em class="replaceable">%d</em><tt class="literal"> of</tt> <em class="replaceable">%s</em><tt class="literal">()</tt></b>
</dt>
<dd>
<p>(D deprecated) Really old Perls let you omit the <tt class="literal">@</tt> on array names in
some spots.  This is now heavily deprecated.</p>
</dd>


<dt>
<b><tt class="literal">assertion botched:</tt> <em class="replaceable">%s</em></b>
</dt>
<dd>
<p>(P) The <tt class="literal">malloc</tt> package that comes with Perl had an internal failure.</p>
</dd>


<dt>
<b><tt class="literal">Assertion failed: file "</tt><em class="replaceable">%s</em><tt class="literal">"</tt></b>
</dt>
<dd>
<p>(P) A general assertion failed.  The file in question must be examined.</p>
</dd>


<dt>
<b><tt class="literal">Assignment to both a list and a scalar</tt></b>
</dt>
<dd>
<p>(F) If you assign to a conditional operator, the second and third
arguments must either both be scalars or both be lists.  Otherwise,
Perl won't know which context to supply to the right side.</p>
</dd>


<dt>
<b><tt class="literal">Attempt to free non-arena SV: 0x%lx</tt></b>
</dt>
<dd>
<p>(P internal) All SV objects are supposed to be allocated from arenas that will
be garbage collected on exit.  An SV was discovered to be outside any
of those arenas.</p>
</dd>


<dt>
<b><tt class="literal">Attempt to free nonexistent shared string</tt></b>
</dt>
<dd>
<p>(P internal) Perl maintains a reference-counted internal table of
strings to optimize the storage and access of hash keys and other
strings.  This message indicates that someone tried to decrement the reference
count of a string that can no longer be found in the table.</p>
</dd>


<dt>
<b><tt class="literal">Attempt to free temp prematurely</tt></b>
</dt>
<dd>
<p>(W debugging) Mortalized values are supposed to be freed by the
internal <tt class="literal">free_tmps</tt> routine.  This message indicates that something else is
freeing the SV before the <tt class="literal">free_tmps</tt> routine gets a chance, which