perlxs.1

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

\&     char *  s
\&     char    &c
.Ve
.PP
Both these \s-1XS\s0 declarations correspond to the \f(CW\*(C`char*\*(C'\fR C type, but they have
different semantics, see \*(L"The & Unary Operator\*(R".
.PP
It is convenient to think that the indirection operator
\&\f(CW\*(C`*\*(C'\fR should be considered as a part of the type and the address operator \f(CW\*(C`&\*(C'\fR
should be considered part of the variable.  See \*(L"The Typemap\*(R"
for more info about handling qualifiers and unary operators in C types.
.PP
The function name and the return type must be placed on
separate lines and should be flush left-adjusted.
.PP
.Vb 1
\&  INCORRECT                        CORRECT
\&
\&  double sin(x)                    double
\&    double x                       sin(x)
\&                                     double x
.Ve
.PP
The rest of the function description may be indented or left-adjusted. The
following example shows a function with its body left-adjusted.  Most
examples in this document will indent the body for better readability.
.PP
.Vb 1
\&  CORRECT
\&
\&  double
\&  sin(x)
\&  double x
.Ve
.PP
More complicated XSUBs may contain many other sections.  Each section of
an \s-1XSUB\s0 starts with the corresponding keyword, such as \s-1INIT:\s0 or \s-1CLEANUP:\s0.
However, the first two lines of an \s-1XSUB\s0 always contain the same data:
descriptions of the return type and the names of the function and its
parameters.  Whatever immediately follows these is considered to be
an \s-1INPUT:\s0 section unless explicitly marked with another keyword.
(See \*(L"The \s-1INPUT:\s0 Keyword\*(R".)
.PP
An \s-1XSUB\s0 section continues until another section-start keyword is found.
.Sh "The Argument Stack"
.IX Subsection "The Argument Stack"
The Perl argument stack is used to store the values which are
sent as parameters to the \s-1XSUB\s0 and to store the \s-1XSUB\s0's
return value(s).  In reality all Perl functions (including non-XSUB
ones) keep their values on this stack all the same time, each limited
to its own range of positions on the stack.  In this document the
first position on that stack which belongs to the active
function will be referred to as position 0 for that function.
.PP
XSUBs refer to their stack arguments with the macro \fB\s-1ST\s0(x)\fR, where \fIx\fR
refers to a position in this \s-1XSUB\s0's part of the stack.  Position 0 for that
function would be known to the \s-1XSUB\s0 as \s-1\fIST\s0\fR\|(0).  The \s-1XSUB\s0's incoming
parameters and outgoing return values always begin at \s-1\fIST\s0\fR\|(0).  For many
simple cases the \fBxsubpp\fR compiler will generate the code necessary to
handle the argument stack by embedding code fragments found in the
typemaps.  In more complex cases the programmer must supply the code.
.Sh "The \s-1RETVAL\s0 Variable"
.IX Subsection "The RETVAL Variable"
The \s-1RETVAL\s0 variable is a special C variable that is declared automatically
for you.  The C type of \s-1RETVAL\s0 matches the return type of the C library
function.  The \fBxsubpp\fR compiler will declare this variable in each \s-1XSUB\s0
with non\-\f(CW\*(C`void\*(C'\fR return type.  By default the generated C function
will use \s-1RETVAL\s0 to hold the return value of the C library function being
called.  In simple cases the value of \s-1RETVAL\s0 will be placed in \s-1\fIST\s0\fR\|(0) of
the argument stack where it can be received by Perl as the return value
of the \s-1XSUB\s0.
.PP
If the \s-1XSUB\s0 has a return type of \f(CW\*(C`void\*(C'\fR then the compiler will
not declare a \s-1RETVAL\s0 variable for that function.  When using
a \s-1PPCODE:\s0 section no manipulation of the \s-1RETVAL\s0 variable is required, the
section may use direct stack manipulation to place output values on the stack.
.PP
If \s-1PPCODE:\s0 directive is not used, \f(CW\*(C`void\*(C'\fR return value should be used
only for subroutines which do not return a value, \fIeven if\fR \s-1CODE:\s0
directive is used which sets \s-1\fIST\s0\fR\|(0) explicitly.
.PP
Older versions of this document recommended to use \f(CW\*(C`void\*(C'\fR return
value in such cases. It was discovered that this could lead to
segfaults in cases when \s-1XSUB\s0 was \fItruly\fR \f(CW\*(C`void\*(C'\fR. This practice is
now deprecated, and may be not supported at some future version. Use
the return value \f(CW\*(C`SV *\*(C'\fR in such cases. (Currently \f(CW\*(C`xsubpp\*(C'\fR contains
some heuristic code which tries to disambiguate between \*(L"truly-void\*(R"
and \*(L"old-practice-declared-as-void\*(R" functions. Hence your code is at
mercy of this heuristics unless you use \f(CW\*(C`SV *\*(C'\fR as return value.)
.Sh "Returning SVs, AVs and HVs through \s-1RETVAL\s0"
.IX Subsection "Returning SVs, AVs and HVs through RETVAL"
When you're using \s-1RETVAL\s0 to return an \f(CW\*(C`SV *\*(C'\fR, there's some magic
going on behind the scenes that should be mentioned. When you're
manipulating the argument stack using the \s-1ST\s0(x) macro, for example,
you usually have to pay special attention to reference counts. (For
more about reference counts, see perlguts.) To make your life
easier, the typemap file automatically makes \f(CW\*(C`RETVAL\*(C'\fR mortal when
you're returning an \f(CW\*(C`SV *\*(C'\fR. Thus, the following two XSUBs are more
or less equivalent:
.PP
.Vb 6
\&  void
\&  alpha()
\&      PPCODE:
\&          ST(0) = newSVpv("Hello World",0);
\&          sv_2mortal(ST(0));
\&          XSRETURN(1);
\&  
\&  SV *
\&  beta()
\&      CODE:
\&          RETVAL = newSVpv("Hello World",0);
\&      OUTPUT:
\&          RETVAL
.Ve
.PP
This is quite useful as it usually improves readability. While
this works fine for an \f(CW\*(C`SV *\*(C'\fR, it's unfortunately not as easy
to have \f(CW\*(C`AV *\*(C'\fR or \f(CW\*(C`HV *\*(C'\fR as a return value. You \fIshould\fR be
able to write:
.PP
.Vb 7
\&  AV *
\&  array()
\&      CODE:
\&          RETVAL = newAV();
\&          /* do something with RETVAL */
\&      OUTPUT:
\&          RETVAL
.Ve
.PP
But due to an unfixable bug (fixing it would break lots of existing
\&\s-1CPAN\s0 modules) in the typemap file, the reference count of the \f(CW\*(C`AV *\*(C'\fR
is not properly decremented. Thus, the above \s-1XSUB\s0 would leak memory
whenever it is being called. The same problem exists for \f(CW\*(C`HV *\*(C'\fR.
.PP
When you're returning an \f(CW\*(C`AV *\*(C'\fR or a \f(CW\*(C`HV *\*(C'\fR, you have make sure
their reference count is decremented by making the \s-1AV\s0 or \s-1HV\s0 mortal:
.PP
.Vb 8
\&  AV *
\&  array()
\&      CODE:
\&          RETVAL = newAV();
\&          sv_2mortal((SV*)RETVAL);
\&          /* do something with RETVAL */
\&      OUTPUT:
\&          RETVAL
.Ve
.PP
And also remember that you don't have to do this for an \f(CW\*(C`SV *\*(C'\fR.
.Sh "The \s-1MODULE\s0 Keyword"
.IX Subsection "The MODULE Keyword"
The \s-1MODULE\s0 keyword is used to start the \s-1XS\s0 code and to specify the package
of the functions which are being defined.  All text preceding the first
\&\s-1MODULE\s0 keyword is considered C code and is passed through to the output with
\&\s-1POD\s0 stripped, but otherwise untouched.  Every \s-1XS\s0 module will have a
bootstrap function which is used to hook the XSUBs into Perl.  The package
name of this bootstrap function will match the value of the last \s-1MODULE\s0
statement in the \s-1XS\s0 source files.  The value of \s-1MODULE\s0 should always remain
constant within the same \s-1XS\s0 file, though this is not required.
.PP
The following example will start the \s-1XS\s0 code and will place
all functions in a package named \s-1RPC\s0.
.PP
.Vb 1
\&     MODULE = RPC
.Ve
.Sh "The \s-1PACKAGE\s0 Keyword"
.IX Subsection "The PACKAGE Keyword"
When functions within an \s-1XS\s0 source file must be separated into packages
the \s-1PACKAGE\s0 keyword should be used.  This keyword is used with the \s-1MODULE\s0
keyword and must follow immediately after it when used.
.PP
.Vb 1
\&     MODULE = RPC  PACKAGE = RPC
\&
\&     [ XS code in package RPC ]
\&
\&     MODULE = RPC  PACKAGE = RPCB
\&
\&     [ XS code in package RPCB ]
\&
\&     MODULE = RPC  PACKAGE = RPC
\&
\&     [ XS code in package RPC ]
.Ve
.PP
The same package name can be used more than once, allowing for
non-contiguous code. This is useful if you have a stronger ordering
principle than package names.
.PP
Although this keyword is optional and in some cases provides redundant
information it should always be used.  This keyword will ensure that the
XSUBs appear in the desired package.
.Sh "The \s-1PREFIX\s0 Keyword"
.IX Subsection "The PREFIX Keyword"
The \s-1PREFIX\s0 keyword designates prefixes which should be
removed from the Perl function names.  If the C function is
\&\f(CW\*(C`rpcb_gettime()\*(C'\fR and the \s-1PREFIX\s0 value is \f(CW\*(C`rpcb_\*(C'\fR then Perl will
see this function as \f(CW\*(C`gettime()\*(C'\fR.
.PP
This keyword should follow the \s-1PACKAGE\s0 keyword when used.
If \s-1PACKAGE\s0 is not used then \s-1PREFIX\s0 should follow the \s-1MODULE\s0
keyword.
.PP
.Vb 1
\&     MODULE = RPC  PREFIX = rpc_
\&
\&     MODULE = RPC  PACKAGE = RPCB  PREFIX = rpcb_
.Ve
.Sh "The \s-1OUTPUT:\s0 Keyword"
.IX Subsection "The OUTPUT: Keyword"
The \s-1OUTPUT:\s0 keyword indicates that certain function parameters should be
updated (new values made visible to Perl) when the \s-1XSUB\s0 terminates or that
certain values should be returned to the calling Perl function.  For
simple functions which have no \s-1CODE:\s0 or \s-1PPCODE:\s0 section,
such as the \fIsin()\fR function above, the \s-1RETVAL\s0 variable is
automatically designated as an output value.  For more complex functions
the \fBxsubpp\fR compiler will need help to determine which variables are output
variables.
.PP
This keyword will normally be used to complement the \s-1CODE:\s0  keyword.
The \s-1RETVAL\s0 variable is not recognized as an output variable when the
\&\s-1CODE:\s0 keyword is present.  The \s-1OUTPUT:\s0  keyword is used in this
situation to tell the compiler that \s-1RETVAL\s0 really is an output
variable.
.PP
The \s-1OUTPUT:\s0 keyword can also be used to indicate that function parameters
are output variables.  This may be necessary when a parameter has been
modified within the function and the programmer would like the update to
be seen by Perl.
.PP
.Vb 6
\&     bool_t
\&     rpcb_gettime(host,timep)
\&          char *host
\&          time_t &timep
\&        OUTPUT:
\&          timep
.Ve
.PP
The \s-1OUTPUT:\s0 keyword will also allow an output parameter to
be mapped to a matching piece of code rather than to a
typemap.
.PP
.Vb 6
\&     bool_t
\&     rpcb_gettime(host,timep)
\&          char *host
\&          time_t &timep
\&        OUTPUT:
\&          timep sv_setnv(ST(1), (double)timep);
.Ve
.PP
\&\fBxsubpp\fR emits an automatic \f(CW\*(C`SvSETMAGIC()\*(C'\fR for all parameters in the
\&\s-1OUTPUT\s0 section of the \s-1XSUB\s0, except \s-1RETVAL\s0.  This is the usually desired
behavior, as it takes care of properly invoking 'set' magic on output
parameters (needed for hash or array element parameters that must be
created if they didn't exist).  If for some reason, this behavior is
not desired, the \s-1OUTPUT\s0 section may contain a \f(CW\*(C`SETMAGIC: DISABLE\*(C'\fR line
to disable it for the remainder of the parameters in the \s-1OUTPUT\s0 section.
Likewise,  \f(CW\*(C`SETMAGIC: ENABLE\*(C'\fR can be used to reenable it for the
remainder of the \s-1OUTPUT\s0 section.  See perlguts for more details
about 'set' magic.
.Sh "The \s-1NO_OUTPUT\s0 Keyword"
.IX Subsection "The NO_OUTPUT Keyword"
The \s-1NO_OUTPUT\s0 can be placed as the first token of the \s-1XSUB\s0.  This keyword
indicates that while the C subroutine we provide an interface to has
a non\-\f(CW\*(C`void\*(C'\fR return type, the return value of this C subroutine should not
be returned from the generated Perl subroutine.
.PP
With this keyword present \*(L"The \s-1RETVAL\s0 Variable\*(R" is created, and in the
generated call to the subroutine this variable is assigned to, but the value
of this variable is not going to be used in the auto-generated code.
.PP
This keyword makes sense only if \f(CW\*(C`RETVAL\*(C'\fR is going to be accessed by the
user-supplied code.  It is especially useful to make a function interface
more Perl-like, especially when the C return value is just an error condition
indicator.  For example,
.PP
.Vb 5
\&  NO_OUTPUT int
\&  delete_file(char *name)
\&    POSTCALL:
\&      if (RETVAL != 0)
\&          croak("Error %d while deleting file \*(Aq%s\*(Aq", RETVAL, name);
.Ve
.PP
Here the generated \s-1XS\s0 function returns nothing on success, and will \fIdie()\fR
with a meaningful error message on error.
.Sh "The \s-1CODE:\s0 Keyword"
.IX Subsection "The CODE: Keyword"
This keyword is used in more complicated XSUBs which require
special handling for the C function.  The \s-1RETVAL\s0 variable is
still declared, but it will not be returned unless it is specified
in the \s-1OUTPUT:\s0 section.
.PP
The following \s-1XSUB\s0 is for a C function which requires special handling of
its parameters.  The Perl usage is given first.
.PP
.Vb 1
\&     $status = rpcb_gettime( "localhost", $timep );
.Ve
.PP
The \s-1XSUB\s0 follows.
.PP
.Vb 9
\&     bool_t
\&     rpcb_gettime(host,timep)
\&          char *host
\&          time_t timep
\&        CODE:
\&               RETVAL = rpcb_gettime( host, &timep );
\&        OUTPUT:
\&          timep
\&          RETVAL
.Ve
.Sh "The \s-1INIT:\s0 Keyword"
.IX Subsection "The INIT: Keyword"
The \s-1INIT:\s0 keyword allows initialization to be inserted into the \s-1XSUB\s0 before
the compiler generates the call to the C function.  Unlike the \s-1CODE:\s0 keyword
above, this keyword does not affect the way the compiler handles \s-1RETVAL\s0.
.PP
.Vb 8
\&    bool_t
\&    rpcb_gettime(host,timep)
\&          char *host
\&          time_t &timep
\&        INIT:
\&          printf("# Host is %s\en", host );
\&        OUTPUT:
\&          timep
.Ve
.PP
Another use for the \s-1INIT:\s0 section is to check for preconditions before
making a call to the C function:
.PP
.Vb 9
\&    long long
\&    lldiv(a,b)
\&        long long a
\&        long long b
\&      INIT:
\&        if (a == 0 && b == 0)