perlapi.1

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

.Ve
.Sp
Escapes at most the first \*(L"count\*(R" chars of pv and puts the results into
dsv such that the size of the escaped string will not exceed \*(L"max\*(R" chars
and will not contain any incomplete escape sequences.
.Sp
If flags contains \s-1PERL_PV_ESCAPE_QUOTE\s0 then any double quotes in the string
will also be escaped.
.Sp
Normally the \s-1SV\s0 will be cleared before the escaped string is prepared,
but when \s-1PERL_PV_ESCAPE_NOCLEAR\s0 is set this will not occur.
.Sp
If \s-1PERL_PV_ESCAPE_UNI\s0 is set then the input string is treated as Unicode,
if \s-1PERL_PV_ESCAPE_UNI_DETECT\s0 is set then the input string is scanned
using \f(CW\*(C`is_utf8_string()\*(C'\fR to determine if it is Unicode.
.Sp
If \s-1PERL_PV_ESCAPE_ALL\s0 is set then all input chars will be output
using \f(CW\*(C`\ex01F1\*(C'\fR style escapes, otherwise only chars above 255 will be
escaped using this style, other non printable chars will use octal or
common escaped patterns like \f(CW\*(C`\en\*(C'\fR. If \s-1PERL_PV_ESCAPE_NOBACKSLASH\s0
then all chars below 255 will be treated as printable and 
will be output as literals.
.Sp
If \s-1PERL_PV_ESCAPE_FIRSTCHAR\s0 is set then only the first char of the
string will be escaped, regardles of max. If the string is utf8 and 
the chars value is >255 then it will be returned as a plain hex 
sequence. Thus the output will either be a single char, 
an octal escape sequence, a special escape like \f(CW\*(C`\en\*(C'\fR or a 3 or 
more digit hex value.
.Sp
If \s-1PERL_PV_ESCAPE_RE\s0 is set then the escape char used will be a '%' and
not a '\e\e'. This is because regexes very often contain backslashed
sequences, whereas '%' is not a particularly common character in patterns.
.Sp
Returns a pointer to the escaped text as held by dsv.
.Sp
\&\s-1NOTE:\s0 the perl_ form of this function is deprecated.
.Sp
.Vb 1
\&        char*   pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)
.Ve
.IP "pv_pretty" 8
.IX Xref "pv_pretty"
.IX Item "pv_pretty"
.Vb 3
\&           |const STRLEN count|const STRLEN max\e
\&           |const char const *start_color| const char const *end_color\e
\&           |const U32 flags
.Ve
.Sp
Converts a string into something presentable, handling escaping via
\&\fIpv_escape()\fR and supporting quoting and ellipses.
.Sp
If the \s-1PERL_PV_PRETTY_QUOTE\s0 flag is set then the result will be 
double quoted with any double quotes in the string escaped. Otherwise
if the \s-1PERL_PV_PRETTY_LTGT\s0 flag is set then the result be wrapped in
angle brackets.
.Sp
If the \s-1PERL_PV_PRETTY_ELLIPSES\s0 flag is set and not all characters in
string were output then an ellipsis \f(CW\*(C`...\*(C'\fR will be appended to the
string. Note that this happens \s-1AFTER\s0 it has been quoted.
.Sp
If start_color is non-null then it will be inserted after the opening
quote (if there is one) but before the escaped text. If end_color
is non-null then it will be inserted after the escaped text but before
any quotes or ellipses.
.Sp
Returns a pointer to the prettified text as held by dsv.
.Sp
\&\s-1NOTE:\s0 the perl_ form of this function is deprecated.
.Sp
.Vb 1
\&        char*   pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)
.Ve
.SH "Functions in file mathoms.c"
.IX Header "Functions in file mathoms.c"
.IP "gv_fetchmethod" 8
.IX Xref "gv_fetchmethod"
.IX Item "gv_fetchmethod"
See gv_fetchmethod_autoload.
.Sp
.Vb 1
\&        GV*     gv_fetchmethod(HV* stash, const char* name)
.Ve
.IP "pack_cat" 8
.IX Xref "pack_cat"
.IX Item "pack_cat"
The engine implementing \fIpack()\fR Perl function. Note: parameters next_in_list and
flags are not used. This call should not be used; use packlist instead.
.Sp
.Vb 1
\&        void    pack_cat(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
.Ve
.IP "sv_2pvbyte_nolen" 8
.IX Xref "sv_2pvbyte_nolen"
.IX Item "sv_2pvbyte_nolen"
Return a pointer to the byte-encoded representation of the \s-1SV\s0.
May cause the \s-1SV\s0 to be downgraded from \s-1UTF\-8\s0 as a side-effect.
.Sp
Usually accessed via the \f(CW\*(C`SvPVbyte_nolen\*(C'\fR macro.
.Sp
.Vb 1
\&        char*   sv_2pvbyte_nolen(SV* sv)
.Ve
.IP "sv_2pvutf8_nolen" 8
.IX Xref "sv_2pvutf8_nolen"
.IX Item "sv_2pvutf8_nolen"
Return a pointer to the UTF\-8\-encoded representation of the \s-1SV\s0.
May cause the \s-1SV\s0 to be upgraded to \s-1UTF\-8\s0 as a side-effect.
.Sp
Usually accessed via the \f(CW\*(C`SvPVutf8_nolen\*(C'\fR macro.
.Sp
.Vb 1
\&        char*   sv_2pvutf8_nolen(SV* sv)
.Ve
.IP "sv_2pv_nolen" 8
.IX Xref "sv_2pv_nolen"
.IX Item "sv_2pv_nolen"
Like \f(CW\*(C`sv_2pv()\*(C'\fR, but doesn't return the length too. You should usually
use the macro wrapper \f(CW\*(C`SvPV_nolen(sv)\*(C'\fR instead.
	char*	sv_2pv_nolen(SV* sv)
.IP "sv_catpvn_mg" 8
.IX Xref "sv_catpvn_mg"
.IX Item "sv_catpvn_mg"
Like \f(CW\*(C`sv_catpvn\*(C'\fR, but also handles 'set' magic.
.Sp
.Vb 1
\&        void    sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)
.Ve
.IP "sv_catsv_mg" 8
.IX Xref "sv_catsv_mg"
.IX Item "sv_catsv_mg"
Like \f(CW\*(C`sv_catsv\*(C'\fR, but also handles 'set' magic.
.Sp
.Vb 1
\&        void    sv_catsv_mg(SV *dstr, SV *sstr)
.Ve
.IP "sv_force_normal" 8
.IX Xref "sv_force_normal"
.IX Item "sv_force_normal"
Undo various types of fakery on an \s-1SV:\s0 if the \s-1PV\s0 is a shared string, make
a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
an xpvmg. See also \f(CW\*(C`sv_force_normal_flags\*(C'\fR.
.Sp
.Vb 1
\&        void    sv_force_normal(SV *sv)
.Ve
.IP "sv_iv" 8
.IX Xref "sv_iv"
.IX Item "sv_iv"
A private implementation of the \f(CW\*(C`SvIVx\*(C'\fR macro for compilers which can't
cope with complex macro expressions. Always use the macro instead.
.Sp
.Vb 1
\&        IV      sv_iv(SV* sv)
.Ve
.IP "sv_nolocking" 8
.IX Xref "sv_nolocking"
.IX Item "sv_nolocking"
Dummy routine which \*(L"locks\*(R" an \s-1SV\s0 when there is no locking module present.
Exists to avoid test for a \s-1NULL\s0 function pointer and because it could
potentially warn under some level of strict-ness.
.Sp
\&\*(L"Superseded\*(R" by \fIsv_nosharing()\fR.
.Sp
.Vb 1
\&        void    sv_nolocking(SV *sv)
.Ve
.IP "sv_nounlocking" 8
.IX Xref "sv_nounlocking"
.IX Item "sv_nounlocking"
Dummy routine which \*(L"unlocks\*(R" an \s-1SV\s0 when there is no locking module present.
Exists to avoid test for a \s-1NULL\s0 function pointer and because it could
potentially warn under some level of strict-ness.
.Sp
\&\*(L"Superseded\*(R" by \fIsv_nosharing()\fR.
.Sp
.Vb 1
\&        void    sv_nounlocking(SV *sv)
.Ve
.IP "sv_nv" 8
.IX Xref "sv_nv"
.IX Item "sv_nv"
A private implementation of the \f(CW\*(C`SvNVx\*(C'\fR macro for compilers which can't
cope with complex macro expressions. Always use the macro instead.
.Sp
.Vb 1
\&        NV      sv_nv(SV* sv)
.Ve
.IP "sv_pv" 8
.IX Xref "sv_pv"
.IX Item "sv_pv"
Use the \f(CW\*(C`SvPV_nolen\*(C'\fR macro instead
.Sp
.Vb 1
\&        char*   sv_pv(SV *sv)
.Ve
.IP "sv_pvbyte" 8
.IX Xref "sv_pvbyte"
.IX Item "sv_pvbyte"
Use \f(CW\*(C`SvPVbyte_nolen\*(C'\fR instead.
.Sp
.Vb 1
\&        char*   sv_pvbyte(SV *sv)
.Ve
.IP "sv_pvbyten" 8
.IX Xref "sv_pvbyten"
.IX Item "sv_pvbyten"
A private implementation of the \f(CW\*(C`SvPVbyte\*(C'\fR macro for compilers
which can't cope with complex macro expressions. Always use the macro
instead.
.Sp
.Vb 1
\&        char*   sv_pvbyten(SV *sv, STRLEN *len)
.Ve
.IP "sv_pvn" 8
.IX Xref "sv_pvn"
.IX Item "sv_pvn"
A private implementation of the \f(CW\*(C`SvPV\*(C'\fR macro for compilers which can't
cope with complex macro expressions. Always use the macro instead.
.Sp
.Vb 1
\&        char*   sv_pvn(SV *sv, STRLEN *len)
.Ve
.IP "sv_pvutf8" 8
.IX Xref "sv_pvutf8"
.IX Item "sv_pvutf8"
Use the \f(CW\*(C`SvPVutf8_nolen\*(C'\fR macro instead
.Sp
.Vb 1
\&        char*   sv_pvutf8(SV *sv)
.Ve
.IP "sv_pvutf8n" 8
.IX Xref "sv_pvutf8n"
.IX Item "sv_pvutf8n"
A private implementation of the \f(CW\*(C`SvPVutf8\*(C'\fR macro for compilers
which can't cope with complex macro expressions. Always use the macro
instead.
.Sp
.Vb 1
\&        char*   sv_pvutf8n(SV *sv, STRLEN *len)
.Ve
.IP "sv_taint" 8
.IX Xref "sv_taint"
.IX Item "sv_taint"
Taint an \s-1SV\s0. Use \f(CW\*(C`SvTAINTED_on\*(C'\fR instead.
	void	sv_taint(SV* sv)
.IP "sv_unref" 8
.IX Xref "sv_unref"
.IX Item "sv_unref"
Unsets the \s-1RV\s0 status of the \s-1SV\s0, and decrements the reference count of
whatever was being referenced by the \s-1RV\s0.  This can almost be thought of
as a reversal of \f(CW\*(C`newSVrv\*(C'\fR.  This is \f(CW\*(C`sv_unref_flags\*(C'\fR with the \f(CW\*(C`flag\*(C'\fR
being zero.  See \f(CW\*(C`SvROK_off\*(C'\fR.
.Sp
.Vb 1
\&        void    sv_unref(SV* sv)
.Ve
.IP "sv_usepvn" 8
.IX Xref "sv_usepvn"
.IX Item "sv_usepvn"
Tells an \s-1SV\s0 to use \f(CW\*(C`ptr\*(C'\fR to find its string value. Implemented by
calling \f(CW\*(C`sv_usepvn_flags\*(C'\fR with \f(CW\*(C`flags\*(C'\fR of 0, hence does not handle 'set'
magic. See \f(CW\*(C`sv_usepvn_flags\*(C'\fR.
.Sp
.Vb 1
\&        void    sv_usepvn(SV* sv, char* ptr, STRLEN len)
.Ve
.IP "sv_usepvn_mg" 8
.IX Xref "sv_usepvn_mg"
.IX Item "sv_usepvn_mg"
Like \f(CW\*(C`sv_usepvn\*(C'\fR, but also handles 'set' magic.
.Sp
.Vb 1
\&        void    sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)
.Ve
.IP "sv_uv" 8
.IX Xref "sv_uv"
.IX Item "sv_uv"
A private implementation of the \f(CW\*(C`SvUVx\*(C'\fR macro for compilers which can't
cope with complex macro expressions. Always use the macro instead.
.Sp
.Vb 1
\&        UV      sv_uv(SV* sv)
.Ve
.IP "unpack_str" 8
.IX Xref "unpack_str"
.IX Item "unpack_str"
The engine implementing \fIunpack()\fR Perl function. Note: parameters strbeg, new_s
and ocnt are not used. This call should not be used, use unpackstring instead.
.Sp
.Vb 1
\&        I32     unpack_str(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)
.Ve
.SH "Functions in file pp_ctl.c"
.IX Header "Functions in file pp_ctl.c"
.IP "find_runcv" 8
.IX Xref "find_runcv"
.IX Item "find_runcv"
Locate the \s-1CV\s0 corresponding to the currently executing sub or eval.
If db_seqp is non_null, skip CVs that are in the \s-1DB\s0 package and populate
*db_seqp with the cop sequence number at the point that the \s-1DB::\s0 code was
entered. (allows debuggers to eval in the scope of the breakpoint rather
than in the scope of the debugger itself).
.Sp
.Vb 1
\&        CV*     find_runcv(U32 *db_seqp)
.Ve
.SH "Functions in file pp_pack.c"
.IX Header "Functions in file pp_pack.c"
.IP "packlist" 8
.IX Xref "packlist"
.IX Item "packlist"
The engine implementing \fIpack()\fR Perl function.
.Sp
.Vb 1
\&        void    packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)
.Ve
.IP "unpackstring" 8
.IX Xref "unpackstring"
.IX Item "unpackstring"
The engine implementing \fIunpack()\fR Perl function. \f(CW\*(C`unpackstring\*(C'\fR puts the
extracted list items on the stack and returns the number of elements.
Issue \f(CW\*(C`PUTBACK\*(C'\fR before and \f(CW\*(C`SPAGAIN\*(C'\fR after the call to this function.
.Sp
.Vb 1
\&        I32     unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)
.Ve
.SH "GV Functions"
.IX Header "GV Functions"
.IP "GvSV" 8
.IX Xref "GvSV"
.IX Item "GvSV"
Return the \s-1SV\s0 from the \s-1GV\s0.
.Sp
.Vb 1
\&        SV*     GvSV(GV* gv)
.Ve
.IP "gv_const_sv" 8
.IX Xref "gv_const_sv"
.IX Item "gv_const_sv"
If \f(CW\*(C`gv\*(C'\fR is a typeglob whose subroutine entry is a constant sub eligible for
inlining, or \f(CW\*(C`gv\*(C'\fR is a placeholder reference that would be promoted to such
a typeglob, then returns the value returned by the sub.  Otherwise, returns
\&\s-1NULL\s0.
.Sp
.Vb 1
\&        SV*     gv_const_sv(GV* gv)
.Ve
.IP "gv_fetchmeth" 8
.IX Xref "gv_fetchmeth"
.IX Item "gv_fetchmeth"
Returns the glob with the given \f(CW\*(C`name\*(C'\fR and a defined subroutine or
\&\f(CW\*(C`NULL\*(C'\fR.  The glob lives in the given \f(CW\*(C`stash\*(C'\fR, or in the stashes
accessible via \f(CW@ISA\fR and \s-1UNIVERSAL::\s0.
.Sp
The argument \f(CW\*(C`level\*(C'\fR should be either 0 or \-1.  If \f(CW\*(C`level==0\*(C'\fR, as a
side-effect creates a glob with the given \f(CW\*(C`name\*(C'\fR in the given \f(CW\*(C`stash\*(C'\fR
which in the case of success contains an alias for the subroutine, and sets
up caching info for this glob.
.Sp
This function grants \f(CW"SUPER"\fR token as a postfix of the stash name. The
\&\s-1GV\s0 returned from \f(CW\*(C`gv_fetchmeth\*(C'\fR may be a method cache entry, which is not
visible to Perl code.  So when calling \f(CW\*(C`call_sv\*(C'\fR, you should not use
the \s-1GV\s0 directly; instead, you should use the method's \s-1CV\s0, which can be
obtained from the \s-1GV\s0 with the \f(CW\*(C`GvCV\*(C'\fR macro.
.Sp
.Vb 1
\&        GV*     gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)
.Ve
.IP "gv_fetchmethod_autoload" 8
.IX Xref "gv_fetchmethod_autoload"
.IX Item "gv_fetchmethod_autoload"
Returns the glob which contains the subroutine to call to invoke the method
on the \f(CW\*(C`stash\*(C'\fR.  In fact in the presence of autoloading this may be the
glob for \*(L"\s-1AUTOLOAD\s0\*(R".  In this case the corresponding variable \f(CW$AUTOLOAD\fR is
already setup.
.Sp
The third parameter of \f(CW\*(C`gv_fetchmethod_autoload\*(C'\fR determines whether
\&\s-1AUTOLOAD\s0 lookup is performed if the given method is not present: non-zero
means yes, look for \s-1AUTOLOAD\s0; zero means no, don't look for \s-1AUTOLOAD\s0.
Calling \f(CW\*(C`gv_fetchmethod\*(C'\fR is equivalent to calling \f(CW\*(C`gv_fetchmethod_autoload\*(C'\fR
with a non-zero \f(CW\*(C`autoload\*(C'\fR parameter.
.Sp
These functions grant \f(CW"SUPER"\fR token as a prefix of the method name. Note
that if you want to keep the returned glob for a long time, you need to
check for it being \*(L"\s-1AUTOLOAD\s0\*(R", since at the later time the call may load a
different subroutine due to \f(CW$AUTOLOAD\fR changing its value. Use the glob
created via a side effect to do this.
.Sp
These functions have the same side-effects and as \f(CW\*(C`gv_fetchmeth\*(C'\fR with
\&\f(CW\*(C`level==0\*(C'\fR.  \f(CW\*(C`name\*(C'\fR should be writable if contains \f(CW\*(Aq:\*(Aq\fR or \f(CW\*(Aq
\&\*(Aq\*(Aq\fR. The warning against passing the \s-1GV\s0 returned by \f(CW\*(C`gv_fetchmeth\*(C'\fR to
\&\f(CW\*(C`call_sv\*(C'\fR apply equally to these functions.
.Sp
.Vb 1
\&        GV*     gv_fetchmethod_autoload(HV* stash, const char* name, I32 autoload)
.Ve
.IP "gv_fetchmeth_autoload" 8
.IX Xref "gv_fetchmeth_autoload"
.IX Item "gv_fetchmeth_autoload"