perlapi.pod

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

=item sv_usepvn
X<sv_usepvn>

Tells an SV to use C<ptr> to find its string value. Implemented by
calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
magic. See C<sv_usepvn_flags>.

	void	sv_usepvn(SV* sv, char* ptr, STRLEN len)

=for hackers
Found in file mathoms.c

=item sv_usepvn_mg
X<sv_usepvn_mg>

Like C<sv_usepvn>, but also handles 'set' magic.

	void	sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)

=for hackers
Found in file mathoms.c

=item sv_uv
X<sv_uv>

A private implementation of the C<SvUVx> macro for compilers which can't
cope with complex macro expressions. Always use the macro instead.

	UV	sv_uv(SV* sv)

=for hackers
Found in file mathoms.c

=item unpack_str
X<unpack_str>

The engine implementing unpack() Perl function. Note: parameters strbeg, new_s
and ocnt are not used. This call should not be used, use unpackstring instead.

	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)

=for hackers
Found in file mathoms.c


=back

=head1 Functions in file pp_ctl.c


=over 8

=item find_runcv
X<find_runcv>

Locate the CV corresponding to the currently executing sub or eval.
If db_seqp is non_null, skip CVs that are in the DB package and populate
*db_seqp with the cop sequence number at the point that the DB:: code was
entered. (allows debuggers to eval in the scope of the breakpoint rather
than in the scope of the debugger itself).

	CV*	find_runcv(U32 *db_seqp)

=for hackers
Found in file pp_ctl.c


=back

=head1 Functions in file pp_pack.c


=over 8

=item packlist
X<packlist>

The engine implementing pack() Perl function.

	void	packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)

=for hackers
Found in file pp_pack.c

=item unpackstring
X<unpackstring>

The engine implementing unpack() Perl function. C<unpackstring> puts the
extracted list items on the stack and returns the number of elements.
Issue C<PUTBACK> before and C<SPAGAIN> after the call to this function.

	I32	unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)

=for hackers
Found in file pp_pack.c


=back

=head1 GV Functions

=over 8

=item GvSV
X<GvSV>

Return the SV from the GV.

	SV*	GvSV(GV* gv)

=for hackers
Found in file gv.h

=item gv_const_sv
X<gv_const_sv>

If C<gv> is a typeglob whose subroutine entry is a constant sub eligible for
inlining, or C<gv> is a placeholder reference that would be promoted to such
a typeglob, then returns the value returned by the sub.  Otherwise, returns
NULL.

	SV*	gv_const_sv(GV* gv)

=for hackers
Found in file gv.c

=item gv_fetchmeth
X<gv_fetchmeth>

Returns the glob with the given C<name> and a defined subroutine or
C<NULL>.  The glob lives in the given C<stash>, or in the stashes
accessible via @ISA and UNIVERSAL::.

The argument C<level> should be either 0 or -1.  If C<level==0>, as a
side-effect creates a glob with the given C<name> in the given C<stash>
which in the case of success contains an alias for the subroutine, and sets
up caching info for this glob.

This function grants C<"SUPER"> token as a postfix of the stash name. The
GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
visible to Perl code.  So when calling C<call_sv>, you should not use
the GV directly; instead, you should use the method's CV, which can be
obtained from the GV with the C<GvCV> macro.

	GV*	gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)

=for hackers
Found in file gv.c

=item gv_fetchmethod_autoload
X<gv_fetchmethod_autoload>

Returns the glob which contains the subroutine to call to invoke the method
on the C<stash>.  In fact in the presence of autoloading this may be the
glob for "AUTOLOAD".  In this case the corresponding variable $AUTOLOAD is
already setup.

The third parameter of C<gv_fetchmethod_autoload> determines whether
AUTOLOAD lookup is performed if the given method is not present: non-zero
means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD.
Calling C<gv_fetchmethod> is equivalent to calling C<gv_fetchmethod_autoload>
with a non-zero C<autoload> parameter.

These functions grant C<"SUPER"> 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 "AUTOLOAD", since at the later time the call may load a
different subroutine due to $AUTOLOAD changing its value. Use the glob
created via a side effect to do this.

These functions have the same side-effects and as C<gv_fetchmeth> with
C<level==0>.  C<name> should be writable if contains C<':'> or C<'
''>. The warning against passing the GV returned by C<gv_fetchmeth> to
C<call_sv> apply equally to these functions.

	GV*	gv_fetchmethod_autoload(HV* stash, const char* name, I32 autoload)

=for hackers
Found in file gv.c

=item gv_fetchmeth_autoload
X<gv_fetchmeth_autoload>

Same as gv_fetchmeth(), but looks for autoloaded subroutines too.
Returns a glob for the subroutine.

For an autoloaded subroutine without a GV, will create a GV even
if C<level < 0>.  For an autoloaded subroutine without a stub, GvCV()
of the result may be zero.

	GV*	gv_fetchmeth_autoload(HV* stash, const char* name, STRLEN len, I32 level)

=for hackers
Found in file gv.c

=item gv_stashpv
X<gv_stashpv>

Returns a pointer to the stash for a specified package.  Uses C<strlen> to
determine the length of C<name>, then calls C<gv_stashpvn()>.

	HV*	gv_stashpv(const char* name, I32 flags)

=for hackers
Found in file gv.c

=item gv_stashpvn
X<gv_stashpvn>

Returns a pointer to the stash for a specified package.  The C<namelen>
parameter indicates the length of the C<name>, in bytes.  C<flags> is passed
to C<gv_fetchpvn_flags()>, so if set to C<GV_ADD> then the package will be
created if it does not already exist.  If the package does not exist and
C<flags> is 0 (or any other setting that does not create packages) then NULL
is returned.


	HV*	gv_stashpvn(const char* name, U32 namelen, I32 flags)

=for hackers
Found in file gv.c

=item gv_stashpvs
X<gv_stashpvs>

Like C<gv_stashpvn>, but takes a literal string instead of a string/length pair.

	HV*	gv_stashpvs(const char* name, I32 create)

=for hackers
Found in file handy.h

=item gv_stashsv
X<gv_stashsv>

Returns a pointer to the stash for a specified package.  See C<gv_stashpvn>.

	HV*	gv_stashsv(SV* sv, I32 flags)

=for hackers
Found in file gv.c


=back

=head1 Handy Values

=over 8

=item Nullav
X<Nullav>

Null AV pointer.

=for hackers
Found in file av.h

=item Nullch
X<Nullch>

Null character pointer.

=for hackers
Found in file handy.h

=item Nullcv
X<Nullcv>

Null CV pointer.

=for hackers
Found in file cv.h

=item Nullhv
X<Nullhv>

Null HV pointer.

=for hackers
Found in file hv.h

=item Nullsv
X<Nullsv>

Null SV pointer.

=for hackers
Found in file handy.h


=back

=head1 Hash Manipulation Functions

=over 8

=item get_hv
X<get_hv>

Returns the HV of the specified Perl hash.  If C<create> is set and the
Perl variable does not exist then it will be created.  If C<create> is not
set and the variable does not exist then NULL is returned.

NOTE: the perl_ form of this function is deprecated.

	HV*	get_hv(const char* name, I32 create)

=for hackers
Found in file perl.c

=item HEf_SVKEY
X<HEf_SVKEY>

This flag, used in the length slot of hash entries and magic structures,
specifies the structure contains an C<SV*> pointer where a C<char*> pointer
is to be expected. (For information only--not to be used).

=for hackers
Found in file hv.h

=item HeHASH
X<HeHASH>

Returns the computed hash stored in the hash entry.

	U32	HeHASH(HE* he)

=for hackers
Found in file hv.h

=item HeKEY
X<HeKEY>

Returns the actual pointer stored in the key slot of the hash entry. The
pointer may be either C<char*> or C<SV*>, depending on the value of
C<HeKLEN()>.  Can be assigned to.  The C<HePV()> or C<HeSVKEY()> macros are
usually preferable for finding the value of a key.

	void*	HeKEY(HE* he)

=for hackers
Found in file hv.h

=item HeKLEN
X<HeKLEN>

If this is negative, and amounts to C<HEf_SVKEY>, it indicates the entry
holds an C<SV*> key.  Otherwise, holds the actual length of the key.  Can
be assigned to. The C<HePV()> macro is usually preferable for finding key
lengths.

	STRLEN	HeKLEN(HE* he)

=for hackers
Found in file hv.h

=item HePV
X<HePV>

Returns the key slot of the hash entry as a C<char*> value, doing any
necessary dereferencing of possibly C<SV*> keys.  The length of the string
is placed in C<len> (this is a macro, so do I<not> use C<&len>).  If you do
not care about what the length of the key is, you may use the global
variable C<PL_na>, though this is rather less efficient than using a local
variable.  Remember though, that hash keys in perl are free to contain
embedded nulls, so using C<strlen()> or similar is not a good way to find
the length of hash keys. This is very similar to the C<SvPV()> macro
described elsewhere in this document.

	char*	HePV(HE* he, STRLEN len)

=for hackers
Found in file hv.h

=item HeSVKEY
X<HeSVKEY>

Returns the key as an C<SV*>, or C<NULL> if the hash entry does not
contain an C<SV*> key.

	SV*	HeSVKEY(HE* he)

=for hackers
Found in file hv.h

=item HeSVKEY_force
X<HeSVKEY_force>

Returns the key as an C<SV*>.  Will create and return a temporary mortal
C<SV*> if the hash entry contains only a C<char*> key.

	SV*	HeSVKEY_force(HE* he)

=for hackers
Found in file hv.h

=item HeSVKEY_set
X<HeSVKEY_set>

Sets the key to a given C<SV*>, taking care to set the appropriate flags to
indicate the presence of an C<SV*> key, and returns the same
C<SV*>.

	SV*	HeSVKEY_set(HE* he, SV* sv)

=for hackers
Found in file hv.h

=item HeVAL
X<HeVAL>

Returns the value slot (type C<SV*>) stored in the hash entry.

	SV*	HeVAL(HE* he)

=for hackers
Found in file hv.h

=item HvNAME
X<HvNAME>

Returns the package name of a stash, or NULL if C<stash> isn't a stash.
See C<SvSTASH>, C<CvSTASH>.

	char*	HvNAME(HV* stash)

=for hackers
Found in file hv.h

=item hv_assert
X<hv_assert>

Check that a hash is in an internally consistent state.

	void	hv_assert(HV* tb)

=for hackers
Found in file hv.c

=item hv_clear
X<hv_clear>

Clears a hash, making it empty.

	void	hv_clear(HV* tb)

=for hackers
Found in file hv.c

=item hv_clear_placeholders
X<hv_clear_placeholders>

Clears any placeholders from a hash.  If a restricted hash has any of its keys
marked as readonly and the key is subsequently deleted, the key is not actually
deleted but is marked by assigning it a value of &PL_sv_placeholder.  This tags
it so it will be ignored by future operations such as iterating over the hash,
but will still allow the hash to have a value reassigned to the key at some
future point.  This function clears any such placeholder keys from the hash.
See Hash::Util::lock_keys() for an example of its use.

	void	hv_clear_placeholders(HV* hb)

=for hackers
Found in file hv.c

=item hv_delete
X<hv_delete>

Deletes a key/value pair in the hash.  The value SV is removed from the
hash and returned to the caller.  The C<klen> is the length of the key.
The C<flags> value will normally be zero; if set to G_DISCARD then NULL
will be returned.

	SV*	hv_delete(HV* tb, const char* key, I32 klen, I32 flags)

=for hackers
Found in file hv.c

=item hv_delete_ent
X<hv_delete_ent>

Deletes a key/value pair in the hash.  The value SV is removed from the
hash and returned to the caller.  The C<flags> value will normally be zero;
if set to G_DISCARD then NULL will be returned.  C<hash> can be a valid
precomputed hash value, or 0 to ask for it to be computed.

	SV*	hv_delete_ent(HV* tb, SV* key, I32 flags, U32 hash)

=for hackers
Found in file hv.c

=item hv_exists
X<hv_exists>

Returns a boolean indicating whether the specified hash key exists.  The
C<klen> is the length of the key.

	bool	hv_exists(HV* tb, const char* key, I32 klen)

=for hackers
Found in file hv.c

=item hv_exists_ent
X<hv_exists_ent>

Returns a boolean indicating whether the specified hash key exists. C<hash>
can be a valid precomputed hash value, or 0 to ask for it to be
computed.

	bool	hv_exists_ent(HV* tb, SV* key, U32 hash)

=for hackers
Found in file hv.c

=item hv_fetch
X<hv_fetch>

Returns the SV which corresponds to the specified key in the hash.  The
C<klen> is the length of the key.  If C<lval> is set then the fetch will be
part of a store.  Check that the return value is non-null before
dereferencing it to an C<SV*>.

See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
information on how to use this function on tied hashes.

	SV**	hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)

=for hackers
Found in file hv.c

=item hv_fetchs
X<hv_fetchs>

Like C<hv_fetch>, but takes a literal string instead of a string/length pair.

	SV**	hv_fetchs(HV* tb, const char* key, I32 lval)

=for hackers
Found in file handy.h

=item hv_fetch_ent
X<hv_fetch_ent>

Returns the hash entry which corresponds to the specified key in the hash.
C<hash> must be a valid precomputed hash number for the given C<key>, or 0
if you want the function to compute it.  IF C<lval> is set then the fetch
will be part of a store.  Make sure the return value is non-null before
accessing it.  The return value when C<tb> is a tied hash is a pointer to a
static location, so be sure to make a copy of the structure if you need to
store it somewhere.

See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
information on how to use this function on tied hashes.

	HE*	hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash)

=for hackers
Found in file hv.c

=item hv_iterinit
X<hv_iterinit>

Prepares a starting point to traverse a hash table.  Returns the number of
keys in the hash (i.e. the same as C<HvKEYS(tb)>).  The return value is
currently only meaningful for hashes without tie magic.

NOTE: Before version 5.004_65, C<hv_iterinit> used to return the number of
hash buckets that happen to be in use.  If you still need that esoteric
value, you can get it through the macro C<HvFILL(tb)>.


	I32	hv_iterinit(HV* tb)

=for hackers
Found in file hv.c