Clears an array, making it empty. Does not free the memory used by the
array itself.
- void av_clear(AV* ar)
+ void av_clear(AV *av)
=for hackers
Found in file av.c
deleted element. If C<flags> equals C<G_DISCARD>, the element is freed
and null is returned.
- SV* av_delete(AV* ar, I32 key, I32 flags)
+ SV* av_delete(AV *av, I32 key, I32 flags)
=for hackers
Found in file av.c
This relies on the fact that uninitialized array elements are set to
C<&PL_sv_undef>.
- bool av_exists(AV* ar, I32 key)
+ bool av_exists(AV *av, I32 key)
=for hackers
Found in file av.c
Pre-extend an array. The C<key> is the index to which the array should be
extended.
- void av_extend(AV* ar, I32 key)
+ void av_extend(AV *av, I32 key)
=for hackers
Found in file av.c
See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
more information on how to use this function on tied arrays.
- SV** av_fetch(AV* ar, I32 key, I32 lval)
+ SV** av_fetch(AV *av, I32 key, I32 lval)
=for hackers
Found in file av.c
was longer, then the excess elements are freed. C<av_fill(av, -1)> is
the same as C<av_clear(av)>.
- void av_fill(AV* ar, I32 fill)
+ void av_fill(AV *av, I32 fill)
=for hackers
Found in file av.c
Returns the highest index in the array. The number of elements in the
array is C<av_len(av) + 1>. Returns -1 if the array is empty.
- I32 av_len(const AV* ar)
+ I32 av_len(const AV *av)
=for hackers
Found in file av.c
into the array, so they may be freed after the call to av_make. The new AV
will have a reference count of 1.
- AV* av_make(I32 size, SV** svp)
+ AV* av_make(I32 size, SV **strp)
=for hackers
Found in file av.c
Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array
is empty.
- SV* av_pop(AV* ar)
+ SV* av_pop(AV *av)
=for hackers
Found in file av.c
Pushes an SV onto the end of the array. The array will grow automatically
to accommodate the addition.
- void av_push(AV* ar, SV* val)
+ void av_push(AV *av, SV *val)
=for hackers
Found in file av.c
=item av_shift
X<av_shift>
-Shifts an SV off the beginning of the array.
+Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the
+array is empty.
- SV* av_shift(AV* ar)
+ SV* av_shift(AV *av)
=for hackers
Found in file av.c
See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
more information on how to use this function on tied arrays.
- SV** av_store(AV* ar, I32 key, SV* val)
+ SV** av_store(AV *av, I32 key, SV *val)
=for hackers
Found in file av.c
Undefines the array. Frees the memory used by the array itself.
- void av_undef(AV* ar)
+ void av_undef(AV *av)
=for hackers
Found in file av.c
array. The array will grow automatically to accommodate the addition. You
must then use C<av_store> to assign values to these new elements.
- void av_unshift(AV* ar, I32 num)
+ void av_unshift(AV *av, I32 num)
=for hackers
Found in file av.c
AV* newAV()
=for hackers
-Found in file av.c
+Found in file av.h
=item sortsv
X<sortsv>
NOTE: the perl_ form of this function is deprecated.
- I32 call_sv(SV* sv, I32 flags)
+ I32 call_sv(SV* sv, VOL I32 flags)
=for hackers
Found in file perl.c
and then throw it away and return to the original one,
you don't need to do anything.
- PerlInterpreter* perl_clone(PerlInterpreter* interp, UV flags)
+ PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags)
=for hackers
Found in file sv.c
Initializes a new Perl interpreter. See L<perlembed>.
- void perl_construct(PerlInterpreter* interp)
+ void perl_construct(PerlInterpreter *my_perl)
=for hackers
Found in file perl.c
Shuts down a Perl interpreter. See L<perlembed>.
- int perl_destruct(PerlInterpreter* interp)
+ int perl_destruct(PerlInterpreter *my_perl)
=for hackers
Found in file perl.c
Releases a Perl interpreter. See L<perlembed>.
- void perl_free(PerlInterpreter* interp)
+ void perl_free(PerlInterpreter *my_perl)
=for hackers
Found in file perl.c
Tells a Perl interpreter to parse a Perl script. See L<perlembed>.
- int perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env)
+ int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env)
=for hackers
Found in file perl.c
Tells a Perl interpreter to run. See L<perlembed>.
- int perl_run(PerlInterpreter* interp)
+ int perl_run(PerlInterpreter *my_perl)
=for hackers
Found in file perl.c
Normally the SV will be cleared before the escaped string is prepared,
but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur.
-If PERL_PV_ESCAPE_UNI is set then the input string is treated as unicode,
+If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode,
if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned
-using C<is_utf8_string()> to determine if it is unicode.
+using C<is_utf8_string()> to determine if it is Unicode.
If PERL_PV_ESCAPE_ALL is set then all input chars will be output
using C<\x01F1> style escapes, otherwise only chars above 255 will be
|const U32 flags
Converts a string into something presentable, handling escaping via
-pv_escape() and supporting quoting and elipses.
+pv_escape() and supporting quoting and ellipses.
If the PERL_PV_PRETTY_QUOTE flag is set then the result will be
double quoted with any double quotes in the string escaped. Otherwise
if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in
angle brackets.
-If the PERL_PV_PRETTY_ELIPSES flag is set and not all characters in
-string were output then an elipses C<...> will be appended to the
+If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in
+string were output then an ellipsis C<...> will be appended to the
string. Note that this happens AFTER it has been quoted.
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 elipses.
+any quotes or ellipses.
Returns a pointer to the prettified text as held by dsv.
Like C<sv_catsv>, but also handles 'set' magic.
- void sv_catsv_mg(SV *dstr, SV *sstr)
+ void sv_catsv_mg(SV *dsv, SV *ssv)
=for hackers
Found in file mathoms.c
which can't cope with complex macro expressions. Always use the macro
instead.
- char* sv_pvbyten(SV *sv, STRLEN *len)
+ char* sv_pvbyten(SV *sv, STRLEN *lp)
=for hackers
Found in file mathoms.c
A private implementation of the C<SvPV> macro for compilers which can't
cope with complex macro expressions. Always use the macro instead.
- char* sv_pvn(SV *sv, STRLEN *len)
+ char* sv_pvn(SV *sv, STRLEN *lp)
=for hackers
Found in file mathoms.c
which can't cope with complex macro expressions. Always use the macro
instead.
- char* sv_pvutf8n(SV *sv, STRLEN *len)
+ char* sv_pvutf8n(SV *sv, STRLEN *lp)
=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
=back
-=head1 Global Variables
-
-=over 8
-
-=item PL_modglobal
-X<PL_modglobal>
-
-C<PL_modglobal> is a general purpose, interpreter global HV for use by
-extensions that need to keep information on a per-interpreter basis.
-In a pinch, it can also be used as a symbol table for extensions
-to share data among each other. It is a good idea to use keys
-prefixed by the package name of the extension that owns the data.
-
- HV* PL_modglobal
-
-=for hackers
-Found in file intrpvar.h
-
-=item PL_na
-X<PL_na>
-
-A convenience variable which is typically used with C<SvPV> when one
-doesn't care about the length of the string. It is usually more efficient
-to either declare a local variable and use that instead or to use the
-C<SvPV_nolen> macro.
-
- STRLEN PL_na
-
-=for hackers
-Found in file thrdvar.h
-
-=item PL_sv_no
-X<PL_sv_no>
-
-This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as
-C<&PL_sv_no>.
-
- SV PL_sv_no
-
-=for hackers
-Found in file intrpvar.h
-
-=item PL_sv_undef
-X<PL_sv_undef>
-
-This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>.
-
- SV PL_sv_undef
-
-=for hackers
-Found in file intrpvar.h
-
-=item PL_sv_yes
-X<PL_sv_yes>
-
-This is the C<true> SV. See C<PL_sv_no>. Always refer to this as
-C<&PL_sv_yes>.
-
- SV PL_sv_yes
-
-=for hackers
-Found in file intrpvar.h
-
-
-=back
-
=head1 GV Functions
=over 8
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. Similarly for all the searched stashes.
+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
Null AV pointer.
+(deprecated - use C<(AV *)NULL> instead)
+
=for hackers
Found in file av.h
=item Nullch
X<Nullch>
-Null character pointer.
+Null character pointer. (No longer available when C<PERL_CORE> is defined.)
=for hackers
Found in file handy.h
Null CV pointer.
+(deprecated - use C<(CV *)NULL> instead)
+
=for hackers
Found in file cv.h
Null HV pointer.
+(deprecated - use C<(HV *)NULL> instead)
+
=for hackers
Found in file hv.h
=item Nullsv
X<Nullsv>
-Null SV pointer.
+Null SV pointer. (No longer available when C<PERL_CORE> is defined.)
=for hackers
Found in file handy.h
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.
+described elsewhere in this document. See also C<HeUTF8>.
+
+If you are using C<HePV> to get values to pass to C<newSVpvn()> to create a
+new SV, you should consider using C<newSVhek(HeKEY_hek(he))> as it is more
+efficient.
char* HePV(HE* he, STRLEN len)
=for hackers
Found in file hv.h
+=item HeUTF8
+X<HeUTF8>
+
+Returns whether the C<char *> value returned by C<HePV> is encoded in UTF-8,
+doing any necessary dereferencing of possibly C<SV*> keys. The value returned
+will be 0 or non-0, not necessarily 1 (or even a value with any low bits set),
+so B<do not> blindly assign this to a C<bool> variable, as C<bool> may be a
+typedef for C<char>.
+
+ char* HeUTF8(HE* he, STRLEN len)
+
+=for hackers
+Found in file hv.h
+
=item HeVAL
X<HeVAL>
Check that a hash is in an internally consistent state.
- void hv_assert(HV* tb)
+ void hv_assert(HV *hv)
=for hackers
Found in file hv.c
Clears a hash, making it empty.
- void hv_clear(HV* tb)
+ void hv_clear(HV *hv)
=for hackers
Found in file hv.c
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)
+ void hv_clear_placeholders(HV *hv)
=for hackers
Found in file hv.c
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)
+ SV* hv_delete(HV *hv, const char *key, I32 klen, I32 flags)
=for hackers
Found in file hv.c
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)
+ SV* hv_delete_ent(HV *hv, SV *keysv, I32 flags, U32 hash)
=for hackers
Found in file hv.c
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)
+ bool hv_exists(HV *hv, const char *key, I32 klen)
=for hackers
Found in file hv.c
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)
+ bool hv_exists_ent(HV *hv, SV *keysv, U32 hash)
=for hackers
Found in file hv.c
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)
+ SV** hv_fetch(HV *hv, const char *key, I32 klen, I32 lval)
=for hackers
Found in file hv.c
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)
+ HE* hv_fetch_ent(HV *hv, SV *keysv, I32 lval, U32 hash)
=for hackers
Found in file hv.c
value, you can get it through the macro C<HvFILL(tb)>.
- I32 hv_iterinit(HV* tb)
+ I32 hv_iterinit(HV *hv)
=for hackers
Found in file hv.c
your iterator immediately else the entry will leak - call C<hv_iternext> to
trigger the resource deallocation.
- HE* hv_iternext(HV* tb)
+ HE* hv_iternext(HV *hv)
=for hackers
Found in file hv.c
Performs an C<hv_iternext>, C<hv_iterkey>, and C<hv_iterval> in one
operation.
- SV* hv_iternextsv(HV* hv, char** key, I32* retlen)
+ SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)
=for hackers
Found in file hv.c
NOTE: this function is experimental and may change or be
removed without notice.
- HE* hv_iternext_flags(HV* tb, I32 flags)
+ HE* hv_iternext_flags(HV *hv, I32 flags)
=for hackers
Found in file hv.c
Returns the value from the current position of the hash iterator. See
C<hv_iterkey>.
- SV* hv_iterval(HV* tb, HE* entry)
+ SV* hv_iterval(HV *hv, HE *entry)
=for hackers
Found in file hv.c
Adds magic to a hash. See C<sv_magic>.
- void hv_magic(HV* hv, GV* gv, int how)
+ void hv_magic(HV *hv, GV *gv, int how)
=for hackers
Found in file hv.c
Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied.
- SV* hv_scalar(HV* hv)
+ SV* hv_scalar(HV *hv)
=for hackers
Found in file hv.c
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_store(HV* tb, const char* key, I32 klen, SV* val, U32 hash)
+ SV** hv_store(HV *hv, const char *key, I32 klen, SV *val, U32 hash)
=for hackers
Found in file hv.c
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_store_ent(HV* tb, SV* key, SV* val, U32 hash)
+ HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)
=for hackers
Found in file hv.c
Undefines the hash.
- void hv_undef(HV* tb)
+ void hv_undef(HV *hv)
=for hackers
Found in file hv.c
HV* newHV()
=for hackers
-Found in file hv.c
+Found in file hv.h
=back
Copies the magic from one SV to another. See C<sv_magic>.
- int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)
+ int mg_copy(SV *sv, SV *nsv, const char *key, I32 klen)
=for hackers
Found in file mg.c
does not have to be fbm_compiled, but the search will not be as fast
then.
- char* fbm_instr(unsigned char* big, unsigned char* bigend, SV* littlesv, U32 flags)
+ char* fbm_instr(unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags)
=for hackers
Found in file util.c
should be interpreted as if it had multiple decimals, even if
it doesn't.
- const char* scan_version(const char *vstr, SV *sv, bool qv)
+ const char* scan_version(const char *s, SV *rv, bool qv)
=for hackers
Found in file util.c
=for hackers
Found in file handy.h
+=item sv_destroyable
+X<sv_destroyable>
+
+Dummy routine which reports that object can be destroyed when there is no
+sharing module present. It ignores its single SV argument, and returns
+'true'. Exists to avoid test for a NULL function pointer and because it
+could potentially warn under some level of strict-ness.
+
+ bool sv_destroyable(SV *sv)
+
+=for hackers
+Found in file util.c
+
=item sv_nosharing
X<sv_nosharing>
Version object aware cmp. Both operands must already have been
converted into version objects.
- int vcmp(SV *lvs, SV *rvs)
+ int vcmp(SV *lhv, SV *rhv)
=for hackers
Found in file util.c
=back
+=head1 MRO Functions
+
+=over 8
+
+=item mro_get_linear_isa
+X<mro_get_linear_isa>
+
+Returns either C<mro_get_linear_isa_c3> or
+C<mro_get_linear_isa_dfs> for the given stash,
+dependant upon which MRO is in effect
+for that stash. The return value is a
+read-only AV*.
+
+You are responsible for C<SvREFCNT_inc()> on the
+return value if you plan to store it anywhere
+semi-permanently (otherwise it might be deleted
+out from under you the next time the cache is
+invalidated).
+
+ AV* mro_get_linear_isa(HV* stash)
+
+=for hackers
+Found in file mro.c
+
+=item mro_method_changed_in
+X<mro_method_changed_in>
+
+Invalidates method caching on any child classes
+of the given stash, so that they might notice
+the changes in this one.
+
+Ideally, all instances of C<PL_sub_generation++> in
+perl source outside of C<mro.c> should be
+replaced by calls to this.
+
+Perl automatically handles most of the common
+ways a method might be redefined. However, there
+are a few ways you could change a method in a stash
+without the cache code noticing, in which case you
+need to call this method afterwards:
+
+1) Directly manipulating the stash HV entries from
+XS code.
+
+2) Assigning a reference to a readonly scalar
+constant into a stash entry in order to create
+a constant subroutine (like constant.pm
+does).
+
+This same method is available from pure perl
+via, C<mro::method_changed_in(classname)>.
+
+ void mro_method_changed_in(HV* stash)
+
+=for hackers
+Found in file mro.c
+
+
+=back
+
=head1 Multicall Functions
=over 8
=back
+=head1 Per-Interpreter Variables
+
+=over 8
+
+=item PL_modglobal
+X<PL_modglobal>
+
+C<PL_modglobal> is a general purpose, interpreter global HV for use by
+extensions that need to keep information on a per-interpreter basis.
+In a pinch, it can also be used as a symbol table for extensions
+to share data among each other. It is a good idea to use keys
+prefixed by the package name of the extension that owns the data.
+
+ HV* PL_modglobal
+
+=for hackers
+Found in file intrpvar.h
+
+=item PL_na
+X<PL_na>
+
+A convenience variable which is typically used with C<SvPV> when one
+doesn't care about the length of the string. It is usually more efficient
+to either declare a local variable and use that instead or to use the
+C<SvPV_nolen> macro.
+
+ STRLEN PL_na
+
+=for hackers
+Found in file intrpvar.h
+
+=item PL_sv_no
+X<PL_sv_no>
+
+This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as
+C<&PL_sv_no>.
+
+ SV PL_sv_no
+
+=for hackers
+Found in file intrpvar.h
+
+=item PL_sv_undef
+X<PL_sv_undef>
+
+This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>.
+
+ SV PL_sv_undef
+
+=for hackers
+Found in file intrpvar.h
+
+=item PL_sv_yes
+X<PL_sv_yes>
+
+This is the C<true> SV. See C<PL_sv_no>. Always refer to this as
+C<&PL_sv_yes>.
+
+ SV PL_sv_yes
+
+=for hackers
+Found in file intrpvar.h
+
+
+=back
+
+=head1 REGEXP Functions
+
+=over 8
+
+=item SvRX
+X<SvRX>
+
+Convenience macro to get the REGEXP from a SV. This is approximately
+equivalent to the following snippet:
+
+ if (SvMAGICAL(sv))
+ mg_get(sv);
+ if (SvROK(sv) &&
+ (tmpsv = (SV*)SvRV(sv)) &&
+ SvTYPE(tmpsv) == SVt_PVMG &&
+ (tmpmg = mg_find(tmpsv, PERL_MAGIC_qr)))
+ {
+ return (REGEXP *)tmpmg->mg_obj;
+ }
+
+NULL will be returned if a REGEXP* is not found.
+
+ REGEXP * SvRX(SV *sv)
+
+=for hackers
+Found in file regexp.h
+
+=item SvRXOK
+X<SvRXOK>
+
+Returns a boolean indicating whether the SV contains qr magic
+(PERL_MAGIC_qr).
+
+If you want to do something with the REGEXP* later use SvRX instead
+and check for NULL.
+
+ bool SvRXOK(SV* sv)
+
+=for hackers
+Found in file regexp.h
+
+
+=back
+
=head1 Simple Exception Handling Macros
=over 8
X<mPUSHi>
Push an integer onto the stack. The stack must have room for this element.
-Handles 'set' magic. Does not use C<TARG>. See also C<PUSHi>, C<mXPUSHi>
-and C<XPUSHi>.
+Does not use C<TARG>. See also C<PUSHi>, C<mXPUSHi> and C<XPUSHi>.
void mPUSHi(IV iv)
X<mPUSHn>
Push a double onto the stack. The stack must have room for this element.
-Handles 'set' magic. Does not use C<TARG>. See also C<PUSHn>, C<mXPUSHn>
-and C<XPUSHn>.
+Does not use C<TARG>. See also C<PUSHn>, C<mXPUSHn> and C<XPUSHn>.
void mPUSHn(NV nv)
X<mPUSHp>
Push a string onto the stack. The stack must have room for this element.
-The C<len> indicates the length of the string. Handles 'set' magic. Does
-
not use C<TARG>. See also C<PUSHp>, C<mXPUSHp> and C<XPUSHp>.
+The C<len> indicates the length of the string. Does not use C<TARG>.
+See also C<PUSHp>, C<mXPUSHp> and C<XPUSHp>.
void mPUSHp(char* str, STRLEN len)
=for hackers
Found in file pp.h
+=item mPUSHs
+X<mPUSHs>
+
+Push an SV onto the stack and mortalizes the SV. The stack must have room
+for this element. Does not use C<TARG>. See also C<PUSHs> and C<mXPUSHs>.
+
+ void mPUSHs(SV* sv)
+
+=for hackers
+Found in file pp.h
+
=item mPUSHu
X<mPUSHu>
Push an unsigned integer onto the stack. The stack must have room for this
-element. Handles 'set' magic. Does not use C<TARG>. See also C<PUSHu>,
-C<mXPUSHu> and C<XPUSHu>.
+element. Does not use C<TARG>. See also C<PUSHu>, C<mXPUSHu> and C<XPUSHu>.
void mPUSHu(UV uv)
=item mXPUSHi
X<mXPUSHi>
-Push an integer onto the stack, extending the stack if necessary. Handles
-'set' magic. Does not use C<TARG>. See also C<XPUSHi>, C<mPUSHi> and
-C<PUSHi>.
+Push an integer onto the stack, extending the stack if necessary.
+Does not use C<TARG>. See also C<XPUSHi>, C<mPUSHi> and C<PUSHi>.
void mXPUSHi(IV iv)
=item mXPUSHn
X<mXPUSHn>
-Push a double onto the stack, extending the stack if necessary. Handles
-'set' magic. Does not use C<TARG>. See also C<XPUSHn>, C<mPUSHn> and
-C<PUSHn>.
+Push a double onto the stack, extending the stack if necessary.
+Does not use C<TARG>. See also C<XPUSHn>, C<mPUSHn> and C<PUSHn>.
void mXPUSHn(NV nv)
X<mXPUSHp>
Push a string onto the stack, extending the stack if necessary. The C<len>
-indicates the length of the string. Handles 'set' magic. Does not use
-C<
TARG>. See also C<XPUSHp>, C<mPUSHp> and C<PUSHp>.
+indicates the length of the string. Does not use C<TARG>. See also C<XPUSHp>,
+C<mPUSHp> and C<PUSHp>.
void mXPUSHp(char* str, STRLEN len)
=for hackers
Found in file pp.h
+=item mXPUSHs
+X<mXPUSHs>
+
+Push an SV onto the stack, extending the stack if necessary and mortalizes
+the SV. Does not use C<TARG>. See also C<XPUSHs> and C<mPUSHs>.
+
+ void mXPUSHs(SV* sv)
+
+=for hackers
+Found in file pp.h
+
=item mXPUSHu
X<mXPUSHu>
Push an unsigned integer onto the stack, extending the stack if necessary.
-Handles 'set' magic. Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu>
-and C<PUSHu>.
+Does not use C<TARG>. See also C<XPUSHu>, C<mPUSHu> and C<PUSHu>.
void mXPUSHu(UV uv)
X<PUSHmortal>
Push a new mortal SV onto the stack. The stack must have room for this
-element. Does not handle 'set' magic. Does not use C<TARG>. See also
-C<PUSHs>, C<XPUSHmortal> and C<XPUSHs>.
+element. Does not use C<TARG>. See also C<PUSHs>, C<XPUSHmortal> and C<XPUSHs>.
void PUSHmortal()
=item XPUSHmortal
X<XPUSHmortal>
-Push a new mortal SV onto the stack, extending the stack if necessary. Does
-not handle 'set' magic. Does not use C<TARG>. See also C<XPUSHs>,
-C<PUSHmortal> and C<PUSHs>.
+Push a new mortal SV onto the stack, extending the stack if necessary.
+Does not use C<TARG>. See also C<XPUSHs>, C<PUSHmortal> and C<PUSHs>.
void XPUSHmortal()
=over 8
+=item croak_xs_usage
+X<croak_xs_usage>
+
+A specialised variant of C<croak()> for emitting the usage message for xsubs
+
+ croak_xs_usage(cv, "eee_yow");
+
+works out the package name and subroutine name from C<cv>, and then calls
+C<croak()>. Hence if C<cv> is C<&ouch::awk>, it would call C<croak> as:
+
+ Perl_croak(aTHX_ "Usage %s::%s(%s)", "ouch" "awk", "eee_yow");
+
+ void croak_xs_usage(const CV *const cv, const char *const params)
+
+=for hackers
+Found in file universal.c
+
=item get_sv
X<get_sv>
=for hackers
Found in file sv.h
+=item newSVpvn_utf8
+X<newSVpvn_utf8>
+
+Creates a new SV and copies a string into it. If utf8 is true, calls
+C<SvUTF8_on> on the new SV. Implemented as a wrapper around C<newSVpvn_flags>.
+
+ SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)
+
+=for hackers
+Found in file sv.h
+
=item SvCUR
X<SvCUR>
X<SvIVx>
Coerces the given SV to an integer and returns it. Guarantees to evaluate
-sv only once. Use the more efficient C<SvIV> otherwise.
+C<sv> only once. Only use this if C<sv> is an expression with side effects,
+otherwise use the more efficient C<SvIV>.
IV SvIVx(SV* sv)
X<SvNVx>
Coerces the given SV to a double and returns it. Guarantees to evaluate
-sv only once. Use the more efficient C<SvNV> otherwise.
+C<sv> only once. Only use this if C<sv> is an expression with side effects,
+otherwise use the more efficient C<SvNV>.
NV SvNVx(SV* sv)
=item SvOOK
X<SvOOK>
-Returns a U32 indicating whether the SvIVX is a valid offset value for
-the SvPVX. This hack is used internally to speed up removal of characters
-from the beginning of a SvPV. When SvOOK is true, then the start of the
-allocated string buffer is really (SvPVX - SvIVX).
+Returns a U32 indicating whether the pointer to the string buffer is offset.
+This hack is used internally to speed up removal of characters from the
+beginning of a SvPV. When SvOOK is true, then the start of the
+allocated string buffer is actually C<SvOOK_offset()> bytes before SvPVX.
+This offset used to be stored in SvIVX, but is now stored within the spare
+part of the buffer.
U32 SvOOK(SV* sv)
=for hackers
Found in file sv.h
+=item SvOOK_offset
+X<SvOOK_offset>
+
+Reads into I<len> the offset from SvPVX back to the true start of the
+allocated buffer, which will be non-zero if C<sv_chop> has been used to
+efficiently remove characters from start of the buffer. Implemented as a
+macro, which takes the address of I<len>, which must be of type C<STRLEN>.
+Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false.
+
+ void SvOOK_offset(NN SV*sv, STRLEN len)
+
+=for hackers
+Found in file sv.h
+
=item SvPOK
X<SvPOK>
=item SvPVx
X<SvPVx>
-A version of C<SvPV> which guarantees to evaluate sv only once.
+A version of C<SvPV> which guarantees to evaluate C<sv> only once.
+Only use this if C<sv> is an expression with side effects, otherwise use the
+more efficient C<SvPVX>.
char* SvPVx(SV* sv, STRLEN len)
=item SvREFCNT_inc_simple
X<SvREFCNT_inc_simple>
-Same as SvREFCNT_inc, but can only be used with simple variables, not
-expressions or pointer dereferences. Since we don't have to store a
-temporary value, it's faster.
+Same as SvREFCNT_inc, but can only be used with expressions without side
+effects. Since we don't have to store a temporary value, it's faster.
SV* SvREFCNT_inc_simple(SV* sv)
X<SvUVx>
Coerces the given SV to an unsigned integer and returns it. Guarantees to
-evaluate sv only once. Use the more efficient C<SvUV> otherwise.
+C<sv> only once. Only use this if C<sv> is an expression with side effects,
+otherwise use the more efficient C<SvUV>.
UV SvUVx(SV* sv)
I<at the C level>. To check derivation at the Perl level, call C<isa()> as a
normal Perl method.
- bool sv_derived_from(SV* sv, const char* name)
+ bool sv_derived_from(SV* sv, const char *const name)
=for hackers
Found in file universal.c
Returns a boolean indicating whether the SV performs a specific, named role.
The SV can be a Perl object or the name of a Perl class.
- bool sv_does(SV* sv, const char* name)
+ bool sv_does(SV* sv, const char *const name)
=for hackers
Found in file universal.c
C<Inf> and C<Infinity> are treated as numbers (so will not issue a
non-numeric warning), even if your atof() doesn't grok them.
- I32 looks_like_number(SV* sv)
+ I32 looks_like_number(SV *const sv)
=for hackers
Found in file sv.c
Creates an RV wrapper for an SV. The reference count for the original
SV is B<not> incremented.
- SV* newRV_noinc(SV* sv)
+ SV* newRV_noinc(SV *const sv)
=for hackers
Found in file sv.c
L<perlhack/PERL_MEM_LOG>). The older API is still there for use in XS
modules supporting older perls.
- SV* newSV(STRLEN len)
+ SV* newSV(const STRLEN len)
=for hackers
Found in file sv.c
point to the shared string table where possible. Returns a new (undefined)
SV if the hek is NULL.
- SV* newSVhek(const HEK *hek)
+ SV* newSVhek(const HEK *const hek)
=for hackers
Found in file sv.c
Creates a new SV and copies an integer into it. The reference count for the
SV is set to 1.
- SV* newSViv(IV i)
+ SV* newSViv(const IV i)
=for hackers
Found in file sv.c
Creates a new SV and copies a floating point value into it.
The reference count for the SV is set to 1.
- SV* newSVnv(NV n)
+ SV* newSVnv(const NV n)
=for hackers
Found in file sv.c
SV is set to 1. If C<len> is zero, Perl will compute the length using
strlen(). For efficiency, consider using C<newSVpvn> instead.
- SV* newSVpv(const char* s, STRLEN len)
+ SV* newSVpv(const char *const s, const STRLEN len)
=for hackers
Found in file sv.c
Creates a new SV and initializes it with the string formatted like
C<sprintf>.
- SV* newSVpvf(const char* pat, ...)
+ SV* newSVpvf(const char *const pat, ...)
=for hackers
Found in file sv.c
string. You are responsible for ensuring that the source string is at least
C<len> bytes long. If the C<s> argument is NULL the new SV will be undefined.
- SV* newSVpvn(const char* s, STRLEN len)
+ SV* newSVpvn(const char *const s, const STRLEN len)
+
+=for hackers
+Found in file sv.c
+
+=item newSVpvn_flags
+X<newSVpvn_flags>
+
+Creates a new SV and copies a string into it. The reference count for the
+SV is set to 1. Note that if C<len> is zero, Perl will create a zero length
+string. You are responsible for ensuring that the source string is at least
+C<len> bytes long. If the C<s> argument is NULL the new SV will be undefined.
+Currently the only flag bits accepted are C<SVf_UTF8> and C<SVs_TEMP>.
+If C<SVs_TEMP> is set, then C<sv2mortal()> is called on the result before
+returning. If C<SVf_UTF8> is set, then it will be set on the new SV.
+C<newSVpvn_utf8()> is a convenience wrapper for this function, defined as
+
+ #define newSVpvn_utf8(s, len, u) \
+ newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
+
+ SV* newSVpvn_flags(const char *const s, const STRLEN len, const U32 flags)
=for hackers
Found in file sv.c
Creates a new SV with its SvPVX_const pointing to a shared string in the string
table. If the string does not already exist in the table, it is created
-first. Turns on READONLY and FAKE. The string's hash is stored in the UV
-slot of the SV; if the C<hash> parameter is non-zero, that value is used;
-otherwise the hash is computed. The idea here is that as the string table
-is used for shared hash keys these strings will have SvPVX_const == HeKEY and
-hash lookup will avoid string compare.
+first. Turns on READONLY and FAKE. If the C<hash> parameter is non-zero, that
+value is used; otherwise the hash is computed. The string's hash can be later
+be retrieved from the SV with the C<SvSHARED_HASH()> macro. The idea here is
+that as the string table is used for shared hash keys these strings will have
+SvPVX_const == HeKEY and hash lookup will avoid string compare.
SV* newSVpvn_share(const char* s, I32 len, U32 hash)
=for hackers
Found in file handy.h
+=item newSVpvs_flags
+X<newSVpvs_flags>
+
+Like C<newSVpvn_flags>, but takes a literal string instead of a string/length
+pair.
+
+ SV* newSVpvs_flags(const char* s, U32 flags)
+
+=for hackers
+Found in file handy.h
+
=item newSVpvs_share
X<newSVpvs_share>
be blessed in the specified package. The new SV is returned and its
reference count is 1.
- SV* newSVrv(SV* rv, const char* classname)
+ SV* newSVrv(SV *const rv, const char *const classname)
=for hackers
Found in file sv.c
Creates a new SV which is an exact duplicate of the original SV.
(Uses C<sv_setsv>).
- SV* newSVsv(SV* old)
+ SV* newSVsv(SV *const old)
=for hackers
Found in file sv.c
Creates a new SV and copies an unsigned integer into it.
The reference count for the SV is set to 1.
- SV* newSVuv(UV u)
+ SV* newSVuv(const UV u)
=for hackers
Found in file sv.c
=item newSV_type
X<newSV_type>
-Creates a new SV, of the type specificied. The reference count for the new SV
+Creates a new SV, of the type specified. The reference count for the new SV
is set to 1.
- SV* newSV_type(svtype type)
+ SV* newSV_type(const svtype type)
=for hackers
Found in file sv.c
This function is only called on magical items, and is only used by
sv_true() or its macro equivalent.
- bool sv_2bool(SV* sv)
+ bool sv_2bool(SV *const sv)
=for hackers
Found in file sv.c
possible to set C<*st> and C<*gvp> to the stash and GV associated with it.
The flags in C<lref> are passed to sv_fetchsv.
- CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)
+ CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, const I32 lref)
=for hackers
Found in file sv.c
GV; or the recursive result if we're an RV; or the IO slot of the symbol
named after the PV if we're a string.
- IO* sv_2io(SV* sv)
+ IO* sv_2io(SV *const sv)
=for hackers
Found in file sv.c
conversion. If flags includes SV_GMAGIC, does an mg_get() first.
Normally used via the C<SvIV(sv)> and C<SvIVx(sv)> macros.
- IV sv_2iv_flags(SV* sv, I32 flags)
+ IV sv_2iv_flags(SV *const sv, const I32 flags)
=for hackers
Found in file sv.c
string buffer can be "stolen" if this SV is copied. See also C<sv_newmortal>
and C<sv_mortalcopy>.
- SV* sv_2mortal(SV* sv)
+ SV* sv_2mortal(SV *const sv)
=for hackers
Found in file sv.c
conversion, magic etc. Normally used via the C<SvNV(sv)> and C<SvNVx(sv)>
macros.
- NV sv_2nv(SV* sv)
+ NV sv_2nv(SV *const sv)
=for hackers
Found in file sv.c
Usually accessed via the C<SvPVbyte> macro.
- char* sv_2pvbyte(SV* sv, STRLEN* lp)
+ char* sv_2pvbyte(SV *const sv, STRLEN *const lp)
=for hackers
Found in file sv.c
Usually accessed via the C<SvPVutf8> macro.
- char* sv_2pvutf8(SV* sv, STRLEN* lp)
+ char* sv_2pvutf8(SV *const sv, STRLEN *const lp)
=for hackers
Found in file sv.c
Normally invoked via the C<SvPV_flags> macro. C<sv_2pv()> and C<sv_2pv_nomg>
usually end up here too.
- char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)
+ char* sv_2pv_flags(SV *const sv, STRLEN *const lp, const I32 flags)
=for hackers
Found in file sv.c
conversion. If flags includes SV_GMAGIC, does an mg_get() first.
Normally used via the C<SvUV(sv)> and C<SvUVx(sv)> macros.
- UV sv_2uv_flags(SV* sv, I32 flags)
+ UV sv_2uv_flags(SV *const sv, const I32 flags)
=for hackers
Found in file sv.c
Remove any string offset. You should normally use the C<SvOOK_off> macro
wrapper instead.
- int sv_backoff(SV* sv)
+ int sv_backoff(SV *const sv)
=for hackers
Found in file sv.c
must be designated by its stash (see C<gv_stashpv()>). The reference count
of the SV is unaffected.
- SV* sv_bless(SV* sv, HV* stash)
+ SV* sv_bless(SV *const sv, HV *const stash)
=for hackers
Found in file sv.c
If the SV has the UTF-8 status set, then the bytes appended should be
valid UTF-8. Handles 'get' magic, but not 'set' magic. See C<sv_catpv_mg>.
- void sv_catpv(SV* sv, const char* ptr)
+ void sv_catpv(SV *const sv, const char* ptr)
=for hackers
Found in file sv.c
C<sv_catpvf_mg>. If the original SV was UTF-8, the pattern should be
valid UTF-8; if the original SV was bytes, the pattern should be too.
- void sv_catpvf(SV* sv, const char* pat, ...)
+ void sv_catpvf(SV *const sv, const char *const pat, ...)
=for hackers
Found in file sv.c
Like C<sv_catpvf>, but also handles 'set' magic.
- void sv_catpvf_mg(SV *sv, const char* pat, ...)
+ void sv_catpvf_mg(SV *const sv, const char *const pat, ...)
=for hackers
Found in file sv.c
status set, then the bytes appended should be valid UTF-8.
Handles 'get' magic, but not 'set' magic. See C<sv_catpvn_mg>.
- void sv_catpvn(SV* sv, const char* ptr, STRLEN len)
+ void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)
=for hackers
Found in file sv.c
appropriate, else not. C<sv_catpvn> and C<sv_catpvn_nomg> are implemented
in terms of this function.
- void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)
+ void sv_catpvn_flags(SV *const dstr, const char *sstr, const STRLEN len, const I32 flags)
=for hackers
Found in file sv.c
Like C<sv_catpv>, but also handles 'set' magic.
- void sv_catpv_mg(SV *sv, const char *ptr)
+ void sv_catpv_mg(SV *const sv, const char *const ptr)
=for hackers
Found in file sv.c
SV C<dsv>. Modifies C<dsv> but not C<ssv>. Handles 'get' magic, but
not 'set' magic. See C<sv_catsv_mg>.
- void sv_catsv(SV* dsv, SV* ssv)
+ void sv_catsv(SV *dstr, SV *sstr)
=for hackers
Found in file sv.c
bit set, will C<mg_get> on the SVs if appropriate, else not. C<sv_catsv>
and C<sv_catsv_nomg> are implemented in terms of this function.
- void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)
+ void sv_catsv_flags(SV *const dsv, SV *const ssv, const I32 flags)
=for hackers
Found in file sv.c
Beware: after this function returns, C<ptr> and SvPVX_const(sv) may no longer
refer to the same chunk of data.
- void sv_chop(SV* sv, const char* ptr)
+ void sv_chop(SV *const sv, const char *const ptr)
=for hackers
Found in file sv.c
you'll want to call C<sv_free()> (or its macro wrapper C<SvREFCNT_dec>)
instead.
- void sv_clear(SV* sv)
+ void sv_clear(SV *const sv)
=for hackers
Found in file sv.c
C<sv2>. Is UTF-8 and 'use bytes' aware, handles get magic, and will
coerce its args to strings if necessary. See also C<sv_cmp_locale>.
- I32 sv_cmp(SV* sv1, SV* sv2)
+ I32 sv_cmp(SV *const sv1, SV *const sv2)
=for hackers
Found in file sv.c
Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and
'use bytes' aware, handles get magic, and will coerce its args to strings
-if necessary. See also C<sv_cmp_locale>. See also C<sv_cmp>.
+if necessary. See also C<sv_cmp>.
- I32 sv_cmp_locale(SV* sv1, SV* sv2)
+ I32 sv_cmp_locale(SV *const sv1, SV *const sv2)
=for hackers
Found in file sv.c
memory comparison can be used to compare the data according to the locale
settings.
- char* sv_collxfrm(SV* sv, STRLEN* nxp)
+ char* sv_collxfrm(SV *const sv, STRLEN *const nxp)
=for hackers
Found in file sv.c
string. Mostly uses sv_2pv_flags to do its work, except when that
would lose the UTF-8'ness of the PV.
- void sv_copypv(SV* dsv, SV* ssv)
+ void sv_copypv(SV *const dsv, SV *const ssv)
=for hackers
Found in file sv.c
Auto-decrement of the value in the SV, doing string to numeric conversion
if necessary. Handles 'get' magic.
- void sv_dec(SV* sv)
+ void sv_dec(SV *const sv)
=for hackers
Found in file sv.c
C<sv_unref_flags()> when unrefing. C<sv_force_normal> calls this function
with flags set to 0.
- void sv_force_normal_flags(SV *sv, U32 flags)
+ void sv_force_normal_flags(SV *const sv, const U32 flags)
=for hackers
Found in file sv.c
the body; finally, deallocate the SV's head itself.
Normally called via a wrapper macro C<SvREFCNT_dec>.
- void sv_free(SV* sv)
+ void sv_free(SV *const sv)
=for hackers
Found in file sv.c
Get a line from the filehandle and store it into the SV, optionally
appending to the currently-stored string.
- char* sv_gets(SV* sv, PerlIO* fp, I32 append)
+ char* sv_gets(SV *const sv, PerlIO *const fp, I32 append)
=for hackers
Found in file sv.c
upgrades the SV to C<SVt_PV>. Returns a pointer to the character buffer.
Use the C<SvGROW> wrapper instead.
- char* sv_grow(SV* sv, STRLEN newlen)
+ char* sv_grow(SV *const sv, STRLEN newlen)
=for hackers
Found in file sv.c
Auto-increment of the value in the SV, doing string to numeric conversion
if necessary. Handles 'get' magic.
- void sv_inc(SV* sv)
+ void sv_inc(SV *const sv)
=for hackers
Found in file sv.c
X<sv_insert>
Inserts a string at the specified offset/length within the SV. Similar to
-the Perl substr() function.
+the Perl substr() function. Handles get magic.
+
+ void sv_insert(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen)
+
+=for hackers
+Found in file sv.c
+
+=item sv_insert_flags
+X<sv_insert_flags>
+
+Same as C<sv_insert>, but the extra C<flags> are passed the C<SvPV_force_flags> that applies to C<bigstr>.
- void sv_insert(SV* bigsv, STRLEN offset, STRLEN len, const char* little, STRLEN littlelen)
+ void sv_insert_flags(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags)
=for hackers
Found in file sv.c
class. This does not check for subtypes; use C<sv_derived_from> to verify
an inheritance relationship.
- int sv_isa(SV* sv, const char* name)
+ int sv_isa(SV* sv, const char *const name)
=for hackers
Found in file sv.c
Returns the length of the string in the SV. Handles magic and type
coercion. See also C<SvCUR>, which gives raw access to the xpv_cur slot.
- STRLEN sv_len(SV* sv)
+ STRLEN sv_len(SV *const sv)
=for hackers
Found in file sv.c
Returns the number of characters in the string in an SV, counting wide
UTF-8 bytes as a single character. Handles magic and type coercion.
- STRLEN sv_len_utf8(SV* sv)
+ STRLEN sv_len_utf8(SV *const sv)
=for hackers
Found in file sv.c
You need to use C<sv_magicext> to add magic to SvREADONLY SVs and also
to add more than one instance of the same 'how'.
- void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)
+ void sv_magic(SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)
=for hackers
Found in file sv.c
(This is now used as a subroutine by C<sv_magic>.)
- MAGIC * sv_magicext(SV* sv, SV* obj, int how, const MGVTBL *vtbl, const char* name, I32 namlen)
+ MAGIC * sv_magicext(SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen)
=for hackers
Found in file sv.c
explicit call to FREETMPS, or by an implicit call at places such as
statement boundaries. See also C<sv_newmortal> and C<sv_2mortal>.
- SV* sv_mortalcopy(SV* oldsv)
+ SV* sv_mortalcopy(SV *const oldsv)
=for hackers
Found in file sv.c
Increment an SV's reference count. Use the C<SvREFCNT_inc()> wrapper
instead.
- SV* sv_newref(SV* sv)
+ SV* sv_newref(SV *const sv)
=for hackers
Found in file sv.c
start of the string, to a count of the equivalent number of UTF-8 chars.
Handles magic and type coercion.
- void sv_pos_b2u(SV* sv, I32* offsetp)
+ void sv_pos_b2u(SV *const sv, I32 *const offsetp)
=for hackers
Found in file sv.c
the offset, rather than from the start of the string. Handles magic and
type coercion.
- void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)
+ void sv_pos_u2b(SV *const sv, I32 *const offsetp, I32 *const lenp)
=for hackers
Found in file sv.c
The backend for the C<SvPVbytex_force> macro. Always use the macro instead.
- char* sv_pvbyten_force(SV* sv, STRLEN* lp)
+ char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)
=for hackers
Found in file sv.c
You normally want to use the various wrapper macros instead: see
C<SvPV_force> and C<SvPV_force_nomg>
- char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)
+ char* sv_pvn_force_flags(SV *const sv, STRLEN *const lp, const I32 flags)
=for hackers
Found in file sv.c
The backend for the C<SvPVutf8x_force> macro. Always use the macro instead.
- char* sv_pvutf8n_force(SV* sv, STRLEN* lp)
+ char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)
=for hackers
Found in file sv.c
Returns a string describing what the SV is a reference to.
- const char* sv_reftype(const SV* sv, int ob)
+ const char* sv_reftype(const SV *const sv, const int ob)
=for hackers
Found in file sv.c
Note that this is a rather specialist SV copying operation; most of the
time you'll want to use C<sv_setsv> or one of its many macro front-ends.
- void sv_replace(SV* sv, SV* nsv)
+ void sv_replace(SV *const sv, SV *const nsv)
=for hackers
Found in file sv.c
Underlying implementation for the C<reset> Perl function.
Note that the perl-level function is vaguely deprecated.
- void sv_reset(const char* s, HV* stash)
+ void sv_reset(const char* s, HV *const stash)
=for hackers
Found in file sv.c
associated with that magic. If the RV is magical, set magic will be
called after the RV is cleared.
- SV* sv_rvweaken(SV *sv)
+ SV* sv_rvweaken(SV *const sv)
=for hackers
Found in file sv.c
Copies an integer into the given SV, upgrading first if necessary.
Does not handle 'set' magic. See also C<sv_setiv_mg>.
- void sv_setiv(SV* sv, IV num)
+ void sv_setiv(SV *const sv, const IV num)
=for hackers
Found in file sv.c
Like C<sv_setiv>, but also handles 'set' magic.
- void sv_setiv_mg(SV *sv, IV i)
+ void sv_setiv_mg(SV *const sv, const IV i)
=for hackers
Found in file sv.c
Copies a double into the given SV, upgrading first if necessary.
Does not handle 'set' magic. See also C<sv_setnv_mg>.
- void sv_setnv(SV* sv, NV num)
+ void sv_setnv(SV *const sv, const NV num)
=for hackers
Found in file sv.c
Like C<sv_setnv>, but also handles 'set' magic.
- void sv_setnv_mg(SV *sv, NV num)
+ void sv_setnv_mg(SV *const sv, const NV num)
=for hackers
Found in file sv.c
Copies a string into an SV. The string must be null-terminated. Does not
handle 'set' magic. See C<sv_setpv_mg>.
- void sv_setpv(SV* sv, const char* ptr)
+ void sv_setpv(SV *const sv, const char *const ptr)
=for hackers
Found in file sv.c
Works like C<sv_catpvf> but copies the text into the SV instead of
appending it. Does not handle 'set' magic. See C<sv_setpvf_mg>.
- void sv_setpvf(SV* sv, const char* pat, ...)
+ void sv_setpvf(SV *const sv, const char *const pat, ...)
=for hackers
Found in file sv.c
Like C<sv_setpvf>, but also handles 'set' magic.
- void sv_setpvf_mg(SV *sv, const char* pat, ...)
+ void sv_setpvf_mg(SV *const sv, const char *const pat, ...)
=for hackers
Found in file sv.c
Copies an integer into the given SV, also updating its string value.
Does not handle 'set' magic. See C<sv_setpviv_mg>.
- void sv_setpviv(SV* sv, IV num)
+ void sv_setpviv(SV *const sv, const IV num)
=for hackers
Found in file sv.c
Like C<sv_setpviv>, but also handles 'set' magic.
- void sv_setpviv_mg(SV *sv, IV iv)
+ void sv_setpviv_mg(SV *const sv, const IV iv)
=for hackers
Found in file sv.c
bytes to be copied. If the C<ptr> argument is NULL the SV will become
undefined. Does not handle 'set' magic. See C<sv_setpvn_mg>.
- void sv_setpvn(SV* sv, const char* ptr, STRLEN len)
+ void sv_setpvn(SV *const sv, const char *const ptr, const STRLEN len)
=for hackers
Found in file sv.c
Like C<sv_setpvn>, but also handles 'set' magic.
- void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)
+ void sv_setpvn_mg(SV *const sv, const char *const ptr, const STRLEN len)
=for hackers
Found in file sv.c
Like C<sv_setpv>, but also handles 'set' magic.
- void sv_setpv_mg(SV *sv, const char *ptr)
+ void sv_setpv_mg(SV *const sv, const char *const ptr)
=for hackers
Found in file sv.c
blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
will have a reference count of 1, and the RV will be returned.
- SV* sv_setref_iv(SV* rv, const char* classname, IV iv)
+ SV* sv_setref_iv(SV *const rv, const char *const classname, const IV iv)
=for hackers
Found in file sv.c
blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
will have a reference count of 1, and the RV will be returned.
- SV* sv_setref_nv(SV* rv, const char* classname, NV nv)
+ SV* sv_setref_nv(SV *const rv, const char *const classname, const NV nv)
=for hackers
Found in file sv.c
Note that C<sv_setref_pvn> copies the string while this copies the pointer.
- SV* sv_setref_pv(SV* rv, const char* classname, void* pv)
+ SV* sv_setref_pv(SV *const rv, const char *const classname, void *const pv)
=for hackers
Found in file sv.c
Note that C<sv_setref_pv> copies the pointer while this copies the string.
- SV* sv_setref_pvn(SV* rv, const char* classname, const char* pv, STRLEN n)
+ SV* sv_setref_pvn(SV *const rv, const char *const classname, const char *const pv, const STRLEN n)
=for hackers
Found in file sv.c
blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
will have a reference count of 1, and the RV will be returned.
- SV* sv_setref_uv(SV* rv, const char* classname, UV uv)
+ SV* sv_setref_uv(SV *const rv, const char *const classname, const UV uv)
=for hackers
Found in file sv.c
C<SvSetSV>, C<SvSetSV_nosteal>, C<SvSetMagicSV> and
C<SvSetMagicSV_nosteal>.
- void sv_setsv(SV* dsv, SV* ssv)
+ void sv_setsv(SV *dstr, SV *sstr)
=for hackers
Found in file sv.c
This is the primary function for copying scalars, and most other
copy-ish functions and macros use this underneath.
- void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)
+ void sv_setsv_flags(SV *dstr, SV *sstr, const I32 flags)
=for hackers
Found in file sv.c
Like C<sv_setsv>, but also handles 'set' magic.
- void sv_setsv_mg(SV *dstr, SV *sstr)
+ void sv_setsv_mg(SV *const dstr, SV *const sstr)
=for hackers
Found in file sv.c
Copies an unsigned integer into the given SV, upgrading first if necessary.
Does not handle 'set' magic. See also C<sv_setuv_mg>.
- void sv_setuv(SV* sv, UV num)
+ void sv_setuv(SV *const sv, const UV num)
=for hackers
Found in file sv.c
Like C<sv_setuv>, but also handles 'set' magic.
- void sv_setuv_mg(SV *sv, UV u)
+ void sv_setuv_mg(SV *const sv, const UV u)
=for hackers
Found in file sv.c
X<sv_tainted>
Test an SV for taintedness. Use C<SvTAINTED> instead.
- bool sv_tainted(SV* sv)
+ bool sv_tainted(SV *const sv)
=for hackers
Found in file sv.c
Use the C<SvTRUE> macro instead, which may call C<sv_true()> or may
instead use an in-line version.
- I32 sv_true(SV *sv)
+ I32 sv_true(SV *const sv)
=for hackers
Found in file sv.c
Removes all magic of type C<type> from an SV.
- int sv_unmagic(SV* sv, int type)
+ int sv_unmagic(SV *const sv, const int type)
=for hackers
Found in file sv.c
different from one or the reference being a readonly SV).
See C<SvROK_off>.
- void sv_unref_flags(SV* sv, U32 flags)
+ void sv_unref_flags(SV *const ref, const U32 flags)
=for hackers
Found in file sv.c
X<sv_untaint>
Untaint an SV. Use C<SvTAINTED_off> instead.
- void sv_untaint(SV* sv)
+ void sv_untaint(SV *const sv)
=for hackers
Found in file sv.c
SV, then copies across as much information as possible from the old body.
You generally want to use the C<SvUPGRADE> macro wrapper. See also C<svtype>.
- void sv_upgrade(SV* sv, svtype new_type)
+ void sv_upgrade(SV *const sv, svtype new_type)
=for hackers
Found in file sv.c
will be skipped. (i.e. the buffer is actually at least 1 byte longer than
C<len>, and already meets the requirements for storing in C<SvPVX>)
- void sv_usepvn_flags(SV* sv, char* ptr, STRLEN len, U32 flags)
+ void sv_usepvn_flags(SV *const sv, char* ptr, const STRLEN len, const U32 flags)
=for hackers
Found in file sv.c
NOTE: this function is experimental and may change or be
removed without notice.
- bool sv_utf8_decode(SV *sv)
+ bool sv_utf8_decode(SV *const sv)
=for hackers
Found in file sv.c
NOTE: this function is experimental and may change or be
removed without notice.
- bool sv_utf8_downgrade(SV *sv, bool fail_ok)
+ bool sv_utf8_downgrade(SV *const sv, const bool fail_ok)
=for hackers
Found in file sv.c
Converts the PV of an SV to UTF-8, but then turns the C<SvUTF8>
flag off so that it looks like octets again.
- void sv_utf8_encode(SV *sv)
+ void sv_utf8_encode(SV *const sv)
=for hackers
Found in file sv.c
This is not as a general purpose byte encoding to Unicode interface:
use the Encode extension for that.
- STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)
+ STRLEN sv_utf8_upgrade_flags(SV *const sv, const I32 flags)
=for hackers
Found in file sv.c
Usually used via its frontend C<sv_catpvf>.
- void sv_vcatpvf(SV* sv, const char* pat, va_list* args)
+ void sv_vcatpvf(SV *const sv, const char *const pat, va_list *const args)
=for hackers
Found in file sv.c
Usually used via one of its frontends C<sv_vcatpvf> and C<sv_vcatpvf_mg>.
- void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
+ void sv_vcatpvfn(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)
=for hackers
Found in file sv.c
Usually used via its frontend C<sv_catpvf_mg>.
- void sv_vcatpvf_mg(SV* sv, const char* pat, va_list* args)
+ void sv_vcatpvf_mg(SV *const sv, const char *const pat, va_list *const args)
=for hackers
Found in file sv.c
Usually used via its frontend C<sv_setpvf>.
- void sv_vsetpvf(SV* sv, const char* pat, va_list* args)
+ void sv_vsetpvf(SV *const sv, const char *const pat, va_list *const args)
=for hackers
Found in file sv.c
Usually used via one of its frontends C<sv_vsetpvf> and C<sv_vsetpvf_mg>.
- void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
+ void sv_vsetpvfn(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)
=for hackers
Found in file sv.c
Usually used via its frontend C<sv_setpvf_mg>.
- void sv_vsetpvf_mg(SV* sv, const char* pat, va_list* args)
+ void sv_vsetpvf_mg(SV *const sv, const char *const pat, va_list *const args)
=for hackers
Found in file sv.c
instead of upper/lowercasing both the characters, see
http://www.unicode.org/unicode/reports/tr21/ (Case Mappings).
- I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)
+ I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)
=for hackers
Found in file utf8.c
UTF-8 character. The actual number of bytes in the UTF-8 character
will be returned if it is valid, otherwise 0.
- STRLEN is_utf8_char(const U8 *p)
+ STRLEN is_utf8_char(const U8 *s)
=for hackers
Found in file utf8.c
X<utf8n_to_uvuni>
Bottom level UTF-8 decode routine.
-Returns the unicode code point value of the first character in the string C<s>
+Returns the Unicode code point value of the first character in the string C<s>
which is assumed to be in UTF-8 encoding and no longer than C<curlen>;
C<retlen> will be set to the length, in bytes, of that character.
https://perl5.git.perl.org / perl5.git / blobdiff