perlguts.1

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

\&
\&    int  (*svt_copy)(SV *sv, MAGIC* mg, SV *nsv, const char *name, int namlen);
\&    int  (*svt_dup)(MAGIC *mg, CLONE_PARAMS *param);
\&    int  (*svt_local)(SV *nsv, MAGIC *mg);
.Ve
.PP
This \s-1MGVTBL\s0 structure is set at compile-time in \fIperl.h\fR and there are
currently 19 types (or 21 with overloading turned on).  These different
structures contain pointers to various routines that perform additional
actions depending on which function is being called.
.PP
.Vb 7
\&    Function pointer    Action taken
\&    \-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-    \-\-\-\-\-\-\-\-\-\-\-\-
\&    svt_get             Do something before the value of the SV is retrieved.
\&    svt_set             Do something after the SV is assigned a value.
\&    svt_len             Report on the SV\*(Aqs length.
\&    svt_clear           Clear something the SV represents.
\&    svt_free            Free any extra storage associated with the SV.
\&
\&    svt_copy            copy tied variable magic to a tied element
\&    svt_dup             duplicate a magic structure during thread cloning
\&    svt_local           copy magic to local value during \*(Aqlocal\*(Aq
.Ve
.PP
For instance, the \s-1MGVTBL\s0 structure called \f(CW\*(C`vtbl_sv\*(C'\fR (which corresponds
to an \f(CW\*(C`mg_type\*(C'\fR of \f(CW\*(C`PERL_MAGIC_sv\*(C'\fR) contains:
.PP
.Vb 1
\&    { magic_get, magic_set, magic_len, 0, 0 }
.Ve
.PP
Thus, when an \s-1SV\s0 is determined to be magical and of type \f(CW\*(C`PERL_MAGIC_sv\*(C'\fR,
if a get operation is being performed, the routine \f(CW\*(C`magic_get\*(C'\fR is
called.  All the various routines for the various magical types begin
with \f(CW\*(C`magic_\*(C'\fR.  \s-1NOTE:\s0 the magic routines are not considered part of
the Perl \s-1API\s0, and may not be exported by the Perl library.
.PP
The last three slots are a recent addition, and for source code
compatibility they are only checked for if one of the three flags
MGf_COPY, MGf_DUP or MGf_LOCAL is set in mg_flags. This means that most
code can continue declaring a vtable as a 5\-element value. These three are
currently used exclusively by the threading code, and are highly subject
to change.
.PP
The current kinds of Magic Virtual Tables are:
.PP
.Vb 10
\&    mg_type
\&    (old\-style char and macro)   MGVTBL          Type of magic
\&    \-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-   \-\-\-\-\-\-          \-\-\-\-\-\-\-\-\-\-\-\-\-
\&    \e0 PERL_MAGIC_sv             vtbl_sv         Special scalar variable
\&    A  PERL_MAGIC_overload       vtbl_amagic     %OVERLOAD hash
\&    a  PERL_MAGIC_overload_elem  vtbl_amagicelem %OVERLOAD hash element
\&    c  PERL_MAGIC_overload_table (none)          Holds overload table (AMT)
\&                                                 on stash
\&    B  PERL_MAGIC_bm             vtbl_bm         Boyer\-Moore (fast string search)
\&    D  PERL_MAGIC_regdata        vtbl_regdata    Regex match position data
\&                                                 (@+ and @\- vars)
\&    d  PERL_MAGIC_regdatum       vtbl_regdatum   Regex match position data
\&                                                 element
\&    E  PERL_MAGIC_env            vtbl_env        %ENV hash
\&    e  PERL_MAGIC_envelem        vtbl_envelem    %ENV hash element
\&    f  PERL_MAGIC_fm             vtbl_fm         Formline (\*(Aqcompiled\*(Aq format)
\&    g  PERL_MAGIC_regex_global   vtbl_mglob      m//g target / study()ed string
\&    H  PERL_MAGIC_hints          vtbl_sig        %^H hash
\&    h  PERL_MAGIC_hintselem      vtbl_hintselem  %^H hash element
\&    I  PERL_MAGIC_isa            vtbl_isa        @ISA array
\&    i  PERL_MAGIC_isaelem        vtbl_isaelem    @ISA array element
\&    k  PERL_MAGIC_nkeys          vtbl_nkeys      scalar(keys()) lvalue
\&    L  PERL_MAGIC_dbfile         (none)          Debugger %_<filename
\&    l  PERL_MAGIC_dbline         vtbl_dbline     Debugger %_<filename element
\&    o  PERL_MAGIC_collxfrm       vtbl_collxfrm   Locale collate transformation
\&    P  PERL_MAGIC_tied           vtbl_pack       Tied array or hash
\&    p  PERL_MAGIC_tiedelem       vtbl_packelem   Tied array or hash element
\&    q  PERL_MAGIC_tiedscalar     vtbl_packelem   Tied scalar or handle
\&    r  PERL_MAGIC_qr             vtbl_qr         precompiled qr// regex
\&    S  PERL_MAGIC_sig            vtbl_sig        %SIG hash
\&    s  PERL_MAGIC_sigelem        vtbl_sigelem    %SIG hash element
\&    t  PERL_MAGIC_taint          vtbl_taint      Taintedness
\&    U  PERL_MAGIC_uvar           vtbl_uvar       Available for use by extensions
\&    v  PERL_MAGIC_vec            vtbl_vec        vec() lvalue
\&    V  PERL_MAGIC_vstring        (none)          v\-string scalars
\&    w  PERL_MAGIC_utf8           vtbl_utf8       UTF\-8 length+offset cache
\&    x  PERL_MAGIC_substr         vtbl_substr     substr() lvalue
\&    y  PERL_MAGIC_defelem        vtbl_defelem    Shadow "foreach" iterator
\&                                                 variable / smart parameter
\&                                                 vivification
\&    #  PERL_MAGIC_arylen         vtbl_arylen     Array length ($#ary)
\&    .  PERL_MAGIC_pos            vtbl_pos        pos() lvalue
\&    <  PERL_MAGIC_backref        vtbl_backref    back pointer to a weak ref 
\&    ~  PERL_MAGIC_ext            (none)          Available for use by extensions
\&    :  PERL_MAGIC_symtab         (none)          hash used as symbol table
\&    %  PERL_MAGIC_rhash          (none)          hash used as restricted hash
\&    @  PERL_MAGIC_arylen_p       vtbl_arylen_p   pointer to $#a from @a
.Ve
.PP
When an uppercase and lowercase letter both exist in the table, then the
uppercase letter is typically used to represent some kind of composite type
(a list or a hash), and the lowercase letter is used to represent an element
of that composite type. Some internals code makes use of this case
relationship.  However, 'v' and 'V' (vec and v\-string) are in no way related.
.PP
The \f(CW\*(C`PERL_MAGIC_ext\*(C'\fR and \f(CW\*(C`PERL_MAGIC_uvar\*(C'\fR magic types are defined
specifically for use by extensions and will not be used by perl itself.
Extensions can use \f(CW\*(C`PERL_MAGIC_ext\*(C'\fR magic to 'attach' private information
to variables (typically objects).  This is especially useful because
there is no way for normal perl code to corrupt this private information
(unlike using extra elements of a hash object).
.PP
Similarly, \f(CW\*(C`PERL_MAGIC_uvar\*(C'\fR magic can be used much like \fItie()\fR to call a
C function any time a scalar's value is used or changed.  The \f(CW\*(C`MAGIC\*(C'\fR's
\&\f(CW\*(C`mg_ptr\*(C'\fR field points to a \f(CW\*(C`ufuncs\*(C'\fR structure:
.PP
.Vb 5
\&    struct ufuncs {
\&        I32 (*uf_val)(pTHX_ IV, SV*);
\&        I32 (*uf_set)(pTHX_ IV, SV*);
\&        IV uf_index;
\&    };
.Ve
.PP
When the \s-1SV\s0 is read from or written to, the \f(CW\*(C`uf_val\*(C'\fR or \f(CW\*(C`uf_set\*(C'\fR
function will be called with \f(CW\*(C`uf_index\*(C'\fR as the first arg and a pointer to
the \s-1SV\s0 as the second.  A simple example of how to add \f(CW\*(C`PERL_MAGIC_uvar\*(C'\fR
magic is shown below.  Note that the ufuncs structure is copied by
sv_magic, so you can safely allocate it on the stack.
.PP
.Vb 10
\&    void
\&    Umagic(sv)
\&        SV *sv;
\&    PREINIT:
\&        struct ufuncs uf;
\&    CODE:
\&        uf.uf_val   = &my_get_fn;
\&        uf.uf_set   = &my_set_fn;
\&        uf.uf_index = 0;
\&        sv_magic(sv, 0, PERL_MAGIC_uvar, (char*)&uf, sizeof(uf));
.Ve
.PP
Attaching \f(CW\*(C`PERL_MAGIC_uvar\*(C'\fR to arrays is permissible but has no effect.
.PP
For hashes there is a specialized hook that gives control over hash
keys (but not values).  This hook calls \f(CW\*(C`PERL_MAGIC_uvar\*(C'\fR 'get' magic
if the \*(L"set\*(R" function in the \f(CW\*(C`ufuncs\*(C'\fR structure is \s-1NULL\s0.  The hook
is activated whenever the hash is accessed with a key specified as
an \f(CW\*(C`SV\*(C'\fR through the functions \f(CW\*(C`hv_store_ent\*(C'\fR, \f(CW\*(C`hv_fetch_ent\*(C'\fR,
\&\f(CW\*(C`hv_delete_ent\*(C'\fR, and \f(CW\*(C`hv_exists_ent\*(C'\fR.  Accessing the key as a string
through the functions without the \f(CW\*(C`..._ent\*(C'\fR suffix circumvents the
hook.  See \*(L"Guts\*(R" in Hash::Util::Fieldhash for a detailed description.
.PP
Note that because multiple extensions may be using \f(CW\*(C`PERL_MAGIC_ext\*(C'\fR
or \f(CW\*(C`PERL_MAGIC_uvar\*(C'\fR magic, it is important for extensions to take
extra care to avoid conflict.  Typically only using the magic on
objects blessed into the same class as the extension is sufficient.
For \f(CW\*(C`PERL_MAGIC_ext\*(C'\fR magic, it may also be appropriate to add an I32
\&'signature' at the top of the private data area and check that.
.PP
Also note that the \f(CW\*(C`sv_set*()\*(C'\fR and \f(CW\*(C`sv_cat*()\*(C'\fR functions described
earlier do \fBnot\fR invoke 'set' magic on their targets.  This must
be done by the user either by calling the \f(CW\*(C`SvSETMAGIC()\*(C'\fR macro after
calling these functions, or by using one of the \f(CW\*(C`sv_set*_mg()\*(C'\fR or
\&\f(CW\*(C`sv_cat*_mg()\*(C'\fR functions.  Similarly, generic C code must call the
\&\f(CW\*(C`SvGETMAGIC()\*(C'\fR macro to invoke any 'get' magic if they use an \s-1SV\s0
obtained from external sources in functions that don't handle magic.
See perlapi for a description of these functions.
For example, calls to the \f(CW\*(C`sv_cat*()\*(C'\fR functions typically need to be
followed by \f(CW\*(C`SvSETMAGIC()\*(C'\fR, but they don't need a prior \f(CW\*(C`SvGETMAGIC()\*(C'\fR
since their implementation handles 'get' magic.
.Sh "Finding Magic"
.IX Subsection "Finding Magic"
.Vb 1
\&    MAGIC* mg_find(SV*, int type); /* Finds the magic pointer of that type */
.Ve
.PP
This routine returns a pointer to the \f(CW\*(C`MAGIC\*(C'\fR structure stored in the \s-1SV\s0.
If the \s-1SV\s0 does not have that magical feature, \f(CW\*(C`NULL\*(C'\fR is returned.  Also,
if the \s-1SV\s0 is not of type SVt_PVMG, Perl may core dump.
.PP
.Vb 1
\&    int mg_copy(SV* sv, SV* nsv, const char* key, STRLEN klen);
.Ve
.PP
This routine checks to see what types of magic \f(CW\*(C`sv\*(C'\fR has.  If the mg_type
field is an uppercase letter, then the mg_obj is copied to \f(CW\*(C`nsv\*(C'\fR, but
the mg_type field is changed to be the lowercase letter.
.Sh "Understanding the Magic of Tied Hashes and Arrays"
.IX Subsection "Understanding the Magic of Tied Hashes and Arrays"
Tied hashes and arrays are magical beasts of the \f(CW\*(C`PERL_MAGIC_tied\*(C'\fR
magic type.
.PP
\&\s-1WARNING:\s0 As of the 5.004 release, proper usage of the array and hash
access functions requires understanding a few caveats.  Some
of these caveats are actually considered bugs in the \s-1API\s0, to be fixed
in later releases, and are bracketed with [\s-1MAYCHANGE\s0] below. If
you find yourself actually applying such information in this section, be
aware that the behavior may change in the future, umm, without warning.
.PP
The perl tie function associates a variable with an object that implements
the various \s-1GET\s0, \s-1SET\s0, etc methods.  To perform the equivalent of the perl
tie function from an \s-1XSUB\s0, you must mimic this behaviour.  The code below
carries out the necessary steps \- firstly it creates a new hash, and then
creates a second hash which it blesses into the class which will implement
the tie methods. Lastly it ties the two hashes together, and returns a
reference to the new tied hash.  Note that the code below does \s-1NOT\s0 call the
\&\s-1TIEHASH\s0 method in the MyTie class \-
see \*(L"Calling Perl Routines from within C Programs\*(R" for details on how
to do this.
.PP
.Vb 10
\&    SV*
\&    mytie()
\&    PREINIT:
\&        HV *hash;
\&        HV *stash;
\&        SV *tie;
\&    CODE:
\&        hash = newHV();
\&        tie = newRV_noinc((SV*)newHV());
\&        stash = gv_stashpv("MyTie", GV_ADD);
\&        sv_bless(tie, stash);
\&        hv_magic(hash, (GV*)tie, PERL_MAGIC_tied);
\&        RETVAL = newRV_noinc(hash);
\&    OUTPUT:
\&        RETVAL
.Ve
.PP
The \f(CW\*(C`av_store\*(C'\fR function, when given a tied array argument, merely
copies the magic of the array onto the value to be \*(L"stored\*(R", using
\&\f(CW\*(C`mg_copy\*(C'\fR.  It may also return \s-1NULL\s0, indicating that the value did not
actually need to be stored in the array.  [\s-1MAYCHANGE\s0] After a call to
\&\f(CW\*(C`av_store\*(C'\fR on a tied array, the caller will usually need to call
\&\f(CW\*(C`mg_set(val)\*(C'\fR to actually invoke the perl level \*(L"\s-1STORE\s0\*(R" method on the
\&\s-1TIEARRAY\s0 object.  If \f(CW\*(C`av_store\*(C'\fR did return \s-1NULL\s0, a call to
\&\f(CW\*(C`SvREFCNT_dec(val)\*(C'\fR will also be usually necessary to avoid a memory
leak. [/MAYCHANGE]
.PP
The previous paragraph is applicable verbatim to tied hash access using the
\&\f(CW\*(C`hv_store\*(C'\fR and \f(CW\*(C`hv_store_ent\*(C'\fR functions as well.
.PP
\&\f(CW\*(C`av_fetch\*(C'\fR and the corresponding hash functions \f(CW\*(C`hv_fetch\*(C'\fR and
\&\f(CW\*(C`hv_fetch_ent\*(C'\fR actually return an undefined mortal value whose magic
has been initialized using \f(CW\*(C`mg_copy\*(C'\fR.  Note the value so returned does not
need to be deallocated, as it is already mortal.  [\s-1MAYCHANGE\s0] But you will
need to call \f(CW\*(C`mg_get()\*(C'\fR on the returned value in order to actually invoke
the perl level \*(L"\s-1FETCH\s0\*(R" method on the underlying \s-1TIE\s0 object.  Similarly,
you may also call \f(CW\*(C`mg_set()\*(C'\fR on the return value after possibly assigning
a suitable value to it using \f(CW\*(C`sv_setsv\*(C'\fR,  which will invoke the \*(L"\s-1STORE\s0\*(R"
method on the \s-1TIE\s0 object. [/MAYCHANGE]
.PP
[\s-1MAYCHANGE\s0]
In other words, the array or hash fetch/store functions don't really
fetch and store actual values in the case of tied arrays and hashes.  They
merely call \f(CW\*(C`mg_copy\*(C'\fR to attach magic to the values that were meant to be
\&\*(L"stored\*(R" or \*(L"fetched\*(R".  Later calls to \f(CW\*(C`mg_get\*(C'\fR and \f(CW\*(C`mg_set\*(C'\fR actually
do the job of invoking the \s-1TIE\s0 methods on the underlying objects.  Thus
the magic mechanism currently implements a kind of lazy access to arrays
and hashes.
.PP
Currently (as of perl version 5.004), use of the hash and array access
functions requires the user to be aware of whether they are operating on
\&\*(L"normal\*(R" hashes and arrays, or on their tied variants.  The \s-1API\s0 may be
changed to provide more transparent access to both tied and normal data
types in future versions.
[/MAYCHANGE]
.PP
You would do well to understand that the \s-1TIEARRAY\s0 and \s-1TIEHASH\s0 interfaces
are mere sugar to invoke some perl method calls while using the uniform hash
and array syntax.  The use of this sugar imposes some overhead (typically
about two to four extra opcodes per \s-1FETCH/STORE\s0 operation, in addition to
the creation of all the mortal variables required to invoke the methods).
This overhead will be comparatively small if the \s-1TIE\s0 methods are themselves
substantial, but if they are only a few statements long, the overhead
will not be insignificant.
.Sh "Localizing changes"
.IX Subsection "Localizing changes"
Perl has a very handy construction
.PP
.Vb 4
\&  {
\&    local $var = 2;
\&    ...
\&  }
.Ve
.PP
This construction is \fIapproximately\fR equivalent to
.PP
.Vb 6
\&  {
\&    my $oldvar = $var;
\&    $var = 2;
\&    ...
\&    $var = $oldvar;
\&  }
.Ve
.PP
The biggest difference is that the first construction would
reinstate the initial value of \f(CW$var\fR, irrespective of how control exits
the block: \f(CW\*(C`goto\*(C'\fR, \f(CW\*(C`return\*(C'\fR, \f(CW\*(C`die\*(C'\fR/\f(CW\*(C`eval\*(C'\fR, etc. It is a little bit
more efficient as well.
.PP
There is a way to achieve a similar task from C via Perl \s-1API:\s0 create a
\&\fIpseudo-block\fR, and arrange for some changes to be automatically
undone at the end of it, either explicit, or via a non-local exit (via
\&\fIdie()\fR). A \fIblock\fR\-like construct is created by a pair of
\&\f(CW\*(C`ENTER\*(C'\fR/\f(CW\*(C`LEAVE\*(C'\fR macros (see \*(L"Returning a Scalar\*(R" in perlcall).
Such a construct may be created specially for some important