perl561delta.1

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

during the global destruction phase.
.PP
Diagnostics emitted from code running in threads other than the main
thread are now accompanied by the thread \s-1ID\s0.
.PP
Embedded null characters in diagnostics now actually show up.  They
used to truncate the message in prior versions.
.PP
\&\f(CW$foo::a\fR and \f(CW$foo::b\fR are now exempt from \*(L"possible typo\*(R" warnings only
if \fIsort()\fR is encountered in package \f(CW\*(C`foo\*(C'\fR.
.PP
Unrecognized alphabetic escapes encountered when parsing quote
constructs now generate a warning, since they may take on new
semantics in later versions of Perl.
.PP
Many diagnostics now report the internal operation in which the warning
was provoked, like so:
.PP
.Vb 2
\&    Use of uninitialized value in concatenation (.) at (eval 1) line 1.
\&    Use of uninitialized value in print at (eval 1) line 1.
.Ve
.PP
Diagnostics  that occur within eval may also report the file and line
number where the eval is located, in addition to the eval sequence
number and the line number within the evaluated text itself.  For
example:
.PP
.Vb 1
\&    Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF
.Ve
.Sh "Diagnostics follow \s-1STDERR\s0"
.IX Subsection "Diagnostics follow STDERR"
Diagnostic output now goes to whichever file the \f(CW\*(C`STDERR\*(C'\fR handle
is pointing at, instead of always going to the underlying C runtime
library's \f(CW\*(C`stderr\*(C'\fR.
.Sh "More consistent close-on-exec behavior"
.IX Subsection "More consistent close-on-exec behavior"
On systems that support a close-on-exec flag on filehandles, the
flag is now set for any handles created by \fIpipe()\fR, \fIsocketpair()\fR,
\&\fIsocket()\fR, and \fIaccept()\fR, if that is warranted by the value of $^F
that may be in effect.  Earlier versions neglected to set the flag
for handles created with these operators.  See \*(L"pipe\*(R" in perlfunc,
\&\*(L"socketpair\*(R" in perlfunc, \*(L"socket\*(R" in perlfunc, \*(L"accept\*(R" in perlfunc,
and \*(L"$^F\*(R" in perlvar.
.Sh "\fIsyswrite()\fP ease-of-use"
.IX Subsection "syswrite() ease-of-use"
The length argument of \f(CW\*(C`syswrite()\*(C'\fR has become optional.
.Sh "Better syntax checks on parenthesized unary operators"
.IX Subsection "Better syntax checks on parenthesized unary operators"
Expressions such as:
.PP
.Vb 3
\&    print defined(&foo,&bar,&baz);
\&    print uc("foo","bar","baz");
\&    undef($foo,&bar);
.Ve
.PP
used to be accidentally allowed in earlier versions, and produced
unpredictable behaviour.  Some produced ancillary warnings
when used in this way; others silently did the wrong thing.
.PP
The parenthesized forms of most unary operators that expect a single
argument now ensure that they are not called with more than one
argument, making the cases shown above syntax errors.  The usual
behaviour of:
.PP
.Vb 3
\&    print defined &foo, &bar, &baz;
\&    print uc "foo", "bar", "baz";
\&    undef $foo, &bar;
.Ve
.PP
remains unchanged.  See perlop.
.Sh "Bit operators support full native integer width"
.IX Subsection "Bit operators support full native integer width"
The bit operators (& | ^ ~ << >>) now operate on the full native
integral width (the exact size of which is available in \f(CW$Config\fR{ivsize}).
For example, if your platform is either natively 64\-bit or if Perl
has been configured to use 64\-bit integers, these operations apply
to 8 bytes (as opposed to 4 bytes on 32\-bit platforms).
For portability, be sure to mask off the excess bits in the result of
unary \f(CW\*(C`~\*(C'\fR, e.g., \f(CW\*(C`~$x & 0xffffffff\*(C'\fR.
.Sh "Improved security features"
.IX Subsection "Improved security features"
More potentially unsafe operations taint their results for improved
security.
.PP
The \f(CW\*(C`passwd\*(C'\fR and \f(CW\*(C`shell\*(C'\fR fields returned by the \fIgetpwent()\fR, \fIgetpwnam()\fR,
and \fIgetpwuid()\fR are now tainted, because the user can affect their own
encrypted password and login shell.
.PP
The variable modified by \fIshmread()\fR, and messages returned by \fImsgrcv()\fR
(and its object-oriented interface IPC::SysV::Msg::rcv) are also tainted,
because other untrusted processes can modify messages and shared memory
segments for their own nefarious purposes.
.Sh "More functional bareword prototype (*)"
.IX Subsection "More functional bareword prototype (*)"
Bareword prototypes have been rationalized to enable them to be used
to override builtins that accept barewords and interpret them in
a special way, such as \f(CW\*(C`require\*(C'\fR or \f(CW\*(C`do\*(C'\fR.
.PP
Arguments prototyped as \f(CW\*(C`*\*(C'\fR will now be visible within the subroutine
as either a simple scalar or as a reference to a typeglob.
See \*(L"Prototypes\*(R" in perlsub.
.ie n .Sh """require""\fP and \f(CW""do"" may be overridden"
.el .Sh "\f(CWrequire\fP and \f(CWdo\fP may be overridden"
.IX Subsection "require and do may be overridden"
\&\f(CW\*(C`require\*(C'\fR and \f(CW\*(C`do \*(Aqfile\*(Aq\*(C'\fR operations may be overridden locally
by importing subroutines of the same name into the current package 
(or globally by importing them into the \s-1CORE::GLOBAL::\s0 namespace).
Overriding \f(CW\*(C`require\*(C'\fR will also affect \f(CW\*(C`use\*(C'\fR, provided the override
is visible at compile-time.
See \*(L"Overriding Built-in Functions\*(R" in perlsub.
.Sh "$^X variables may now have names longer than one character"
.IX Subsection "$^X variables may now have names longer than one character"
Formerly, $^X was synonymous with ${\*(L"\ecX\*(R"}, but $^XY was a syntax
error.  Now variable names that begin with a control character may be
arbitrarily long.  However, for compatibility reasons, these variables
\&\fImust\fR be written with explicit braces, as \f(CW\*(C`${^XY}\*(C'\fR for example.
\&\f(CW\*(C`${^XYZ}\*(C'\fR is synonymous with ${\*(L"\ecXYZ\*(R"}.  Variable names with more
than one control character, such as \f(CW\*(C`${^XY^Z}\*(C'\fR, are illegal.
.PP
The old syntax has not changed.  As before, `^X' may be either a
literal control-X character or the two-character sequence `caret' plus
`X'.  When braces are omitted, the variable name stops after the
control character.  Thus \f(CW"$^XYZ"\fR continues to be synonymous with
\&\f(CW\*(C`$^X . "YZ"\*(C'\fR as before.
.PP
As before, lexical variables may not have names beginning with control
characters.  As before, variables whose names begin with a control
character are always forced to be in package `main'.  All such variables
are reserved for future extensions, except those that begin with
\&\f(CW\*(C`^_\*(C'\fR, which may be used by user programs and are guaranteed not to
acquire special meaning in any future version of Perl.
.ie n .Sh "New variable $^C reflects ""\-c"" switch"
.el .Sh "New variable $^C reflects \f(CW\-c\fP switch"
.IX Subsection "New variable $^C reflects -c switch"
\&\f(CW$^C\fR has a boolean value that reflects whether perl is being run
in compile-only mode (i.e. via the \f(CW\*(C`\-c\*(C'\fR switch).  Since
\&\s-1BEGIN\s0 blocks are executed under such conditions, this variable
enables perl code to determine whether actions that make sense
only during normal running are warranted.  See perlvar.
.Sh "New variable $^V contains Perl version as a string"
.IX Subsection "New variable $^V contains Perl version as a string"
\&\f(CW$^V\fR contains the Perl version number as a string composed of
characters whose ordinals match the version numbers, i.e. v5.6.0.
This may be used in string comparisons.
.PP
See \f(CW\*(C`Support for strings represented as a vector of ordinals\*(C'\fR for an
example.
.Sh "Optional Y2K warnings"
.IX Subsection "Optional Y2K warnings"
If Perl is built with the cpp macro \f(CW\*(C`PERL_Y2KWARN\*(C'\fR defined,
it emits optional warnings when concatenating the number 19
with another number.
.PP
This behavior must be specifically enabled when running Configure.
See \fI\s-1INSTALL\s0\fR and \fI\s-1README\s0.Y2K\fR.
.Sh "Arrays now always interpolate into double-quoted strings"
.IX Subsection "Arrays now always interpolate into double-quoted strings"
In double-quoted strings, arrays now interpolate, no matter what.  The
behavior in earlier versions of perl 5 was that arrays would interpolate
into strings if the array had been mentioned before the string was
compiled, and otherwise Perl would raise a fatal compile-time error.
In versions 5.000 through 5.003, the error was
.PP
.Vb 1
\&        Literal @example now requires backslash
.Ve
.PP
In versions 5.004_01 through 5.6.0, the error was
.PP
.Vb 1
\&        In string, @example now must be written as \e@example
.Ve
.PP
The idea here was to get people into the habit of writing
\&\f(CW"fred\[e-mail]"\fR when they wanted a literal \f(CW\*(C`@\*(C'\fR sign, just as
they have always written \f(CW"Give me back my \e$5"\fR when they wanted a
literal \f(CW\*(C`$\*(C'\fR sign.
.PP
Starting with 5.6.1, when Perl now sees an \f(CW\*(C`@\*(C'\fR sign in a
double-quoted string, it \fIalways\fR attempts to interpolate an array,
regardless of whether or not the array has been used or declared
already.  The fatal error has been downgraded to an optional warning:
.PP
.Vb 1
\&        Possible unintended interpolation of @example in string
.Ve
.PP
This warns you that \f(CW"[e-mail]"\fR is going to turn into
\&\f(CW\*(C`fred.com\*(C'\fR if you don't backslash the \f(CW\*(C`@\*(C'\fR.
See http://www.plover.com/~mjd/perl/at\-error.html for more details
about the history here.
.Sh "@\- and @+ provide starting/ending offsets of regex submatches"
.IX Subsection "@- and @+ provide starting/ending offsets of regex submatches"
The new magic variables @\- and @+ provide the starting and ending
offsets, respectively, of $&, \f(CW$1\fR, \f(CW$2\fR, etc.  See perlvar for
details.
.SH "Modules and Pragmata"
.IX Header "Modules and Pragmata"
.Sh "Modules"
.IX Subsection "Modules"
.IP "attributes" 4
.IX Item "attributes"
While used internally by Perl as a pragma, this module also
provides a way to fetch subroutine and variable attributes.
See attributes.
.IP "B" 4
.IX Item "B"
The Perl Compiler suite has been extensively reworked for this
release.  More of the standard Perl test suite passes when run
under the Compiler, but there is still a significant way to
go to achieve production quality compiled executables.
.Sp
.Vb 3
\&    NOTE: The Compiler suite remains highly experimental.  The
\&    generated code may not be correct, even when it manages to execute
\&    without errors.
.Ve
.IP "Benchmark" 4
.IX Item "Benchmark"
Overall, Benchmark results exhibit lower average error and better timing
accuracy.
.Sp
You can now run tests for \fIn\fR seconds instead of guessing the right
number of tests to run: e.g., timethese(\-5, ...) will run each 
code for at least 5 \s-1CPU\s0 seconds.  Zero as the \*(L"number of repetitions\*(R"
means \*(L"for at least 3 \s-1CPU\s0 seconds\*(R".  The output format has also
changed.  For example:
.Sp
.Vb 1
\&   use Benchmark;$x=3;timethese(\-5,{a=>sub{$x*$x},b=>sub{$x**2}})
.Ve
.Sp
will now output something like this:
.Sp
.Vb 3
\&   Benchmark: running a, b, each for at least 5 CPU seconds...
\&            a:  5 wallclock secs ( 5.77 usr +  0.00 sys =  5.77 CPU) @ 200551.91/s (n=1156516)
\&            b:  4 wallclock secs ( 5.00 usr +  0.02 sys =  5.02 CPU) @ 159605.18/s (n=800686)
.Ve
.Sp
New features: \*(L"each for at least N \s-1CPU\s0 seconds...\*(R", \*(L"wallclock secs\*(R",
and the \*(L"@ operations/CPU second (n=operations)\*(R".
.Sp
\&\fItimethese()\fR now returns a reference to a hash of Benchmark objects containing
the test results, keyed on the names of the tests.
.Sp
\&\fItimethis()\fR now returns the iterations field in the Benchmark result object
instead of 0.
.Sp
\&\fItimethese()\fR, \fItimethis()\fR, and the new \fIcmpthese()\fR (see below) can also take
a format specifier of 'none' to suppress output.
.Sp
A new function \fIcountit()\fR is just like \fItimeit()\fR except that it takes a
\&\s-1TIME\s0 instead of a \s-1COUNT\s0.
.Sp
A new function \fIcmpthese()\fR prints a chart comparing the results of each test
returned from a \fItimethese()\fR call.  For each possible pair of tests, the
percentage speed difference (iters/sec or seconds/iter) is shown.
.Sp
For other details, see Benchmark.
.IP "ByteLoader" 4
.IX Item "ByteLoader"
The ByteLoader is a dedicated extension to generate and run
Perl bytecode.  See ByteLoader.
.IP "constant" 4
.IX Item "constant"
References can now be used.
.Sp
The new version also allows a leading underscore in constant names, but
disallows a double leading underscore (as in \*(L"_\|_LINE_\|_\*(R").  Some other names
are disallowed or warned against, including \s-1BEGIN\s0, \s-1END\s0, etc.  Some names
which were forced into main:: used to fail silently in some cases; now they're
fatal (outside of main::) and an optional warning (inside of main::).
The ability to detect whether a constant had been set with a given name has
been added.
.Sp
See constant.
.IP "charnames" 4
.IX Item "charnames"
This pragma implements the \f(CW\*(C`\eN\*(C'\fR string escape.  See charnames.
.IP "Data::Dumper" 4
.IX Item "Data::Dumper"
A \f(CW\*(C`Maxdepth\*(C'\fR setting can be specified to avoid venturing
too deeply into deep data structures.  See Data::Dumper.
.Sp
The \s-1XSUB\s0 implementation of \fIDump()\fR is now automatically called if the
\&\f(CW\*(C`Useqq\*(C'\fR setting is not in use.
.Sp
Dumping \f(CW\*(C`qr//\*(C'\fR objects works correctly.
.IP "\s-1DB\s0" 4
.IX Item "DB"
\&\f(CW\*(C`DB\*(C'\fR is an experimental module that exposes a cle