Mass Deface
is an integer type (Size_t, usually defined as size_t in
F) guaranteed to be large enough to represent the size of
any string that perl can handle.
In the unlikely case of a SV requiring more complex initialisation, you
can create an empty SV with newSV(len). If C is 0 an empty SV of
type NULL is returned, else an SV of type PV is returned with len + 1 (for
the NUL) bytes of storage allocated, accessible via SvPVX. In both cases
the SV has the undef value.
SV *sv = newSV(0); /* no storage allocated */
SV *sv = newSV(10); /* 10 (+1) bytes of uninitialised storage
* allocated */
To change the value of an I SV, there are eight routines:
void sv_setiv(SV*, IV);
void sv_setuv(SV*, UV);
void sv_setnv(SV*, double);
void sv_setpv(SV*, const char*);
void sv_setpvn(SV*, const char*, STRLEN)
void sv_setpvf(SV*, const char*, ...);
void sv_vsetpvfn(SV*, const char*, STRLEN, va_list *,
SV **, I32, bool *);
void sv_setsv(SV*, SV*);
Notice that you can choose to specify the length of the string to be
assigned by using C, C, or C, or you may
allow Perl to calculate the length by using C or by specifying
0 as the second argument to C. Be warned, though, that Perl will
determine the string's length by using C, which depends on the
string terminating with a NUL character, and not otherwise containing
NULs.
The arguments of C are processed like C, and the
formatted output becomes the value.
C is an analogue of C, but it allows you to specify
either a pointer to a variable argument list or the address and length of
an array of SVs. The last argument points to a boolean; on return, if that
boolean is true, then locale-specific information has been used to format
the string, and the string's contents are therefore untrustworthy (see
L). This pointer may be NULL if that information is not
important. Note that this function requires you to specify the length of
the format.
The C functions are not generic enough to operate on values
that have "magic". See L later in this document.
All SVs that contain strings should be terminated with a NUL character.
If it is not NUL-terminated there is a risk of
core dumps and corruptions from code which passes the string to C
functions or system calls which expect a NUL-terminated string.
Perl's own functions typically add a trailing NUL for this reason.
Nevertheless, you should be very careful when you pass a string stored
in an SV to a C function or system call.
To access the actual value that an SV points to, you can use the macros:
SvIV(SV*)
SvUV(SV*)
SvNV(SV*)
SvPV(SV*, STRLEN len)
SvPV_nolen(SV*)
which will automatically coerce the actual scalar type into an IV, UV, double,
or string.
In the C macro, the length of the string returned is placed into the
variable C (this is a macro, so you do I use C<&len>). If you do
not care what the length of the data is, use the C macro.
Historically the C macro with the global variable C has been
used in this case. But that can be quite inefficient because C must
be accessed in thread-local storage in threaded Perl. In any case, remember
that Perl allows arbitrary strings of data that may both contain NULs and
might not be terminated by a NUL.
Also remember that C doesn't allow you to safely say C. It might work with your compiler, but it won't work for everyone.
Break this sort of statement up into separate assignments:
SV *s;
STRLEN len;
char *ptr;
ptr = SvPV(s, len);
foo(ptr, len);
If you want to know if the scalar value is TRUE, you can use:
SvTRUE(SV*)
Although Perl will automatically grow strings for you, if you need to force
Perl to allocate more memory for your SV, you can use the macro
SvGROW(SV*, STRLEN newlen)
which will determine if more memory needs to be allocated. If so, it will
call the function C. Note that C can only increase, not
decrease, the allocated memory of an SV and that it does not automatically
add space for the trailing NUL byte (perl's own string functions typically do
C).
If you have an SV and want to know what kind of data Perl thinks is stored
in it, you can use the following macros to check the type of SV you have.
SvIOK(SV*)
SvNOK(SV*)
SvPOK(SV*)
You can get and set the current length of the string stored in an SV with
the following macros:
SvCUR(SV*)
SvCUR_set(SV*, I32 val)
You can also get a pointer to the end of the string stored in the SV
with the macro:
SvEND(SV*)
But note that these last three macros are valid only if C is true.
If you want to append something to the end of string stored in an C,
you can use the following functions:
void sv_catpv(SV*, const char*);
void sv_catpvn(SV*, const char*, STRLEN);
void sv_catpvf(SV*, const char*, ...);
void sv_vcatpvfn(SV*, const char*, STRLEN, va_list *, SV **,
I32, bool);
void sv_catsv(SV*, SV*);
The first function calculates the length of the string to be appended by
using C. In the second, you specify the length of the string
yourself. The third function processes its arguments like C and
appends the formatted output. The fourth function works like C.
You can specify the address and length of an array of SVs instead of the
va_list argument. The fifth function extends the string stored in the first
SV with the string stored in the second SV. It also forces the second SV
to be interpreted as a string.
The C functions are not generic enough to operate on values that
have "magic". See L later in this document.
If you know the name of a scalar variable, you can get a pointer to its SV
by using the following:
SV* get_sv("package::varname", 0);
This returns NULL if the variable does not exist.
If you want to know if this variable (or any other SV) is actually C,
you can call:
SvOK(SV*)
The scalar C value is stored in an SV instance called C.
Its address can be used whenever an C is needed. Make sure that
you don't try to compare a random sv with C<&PL_sv_undef>. For example
when interfacing Perl code, it'll work correctly for:
foo(undef);
But won't work when called as:
$x = undef;
foo($x);
So to repeat always use SvOK() to check whether an sv is defined.
Also you have to be careful when using C<&PL_sv_undef> as a value in
AVs or HVs (see L).
There are also the two values C and C, which contain
boolean TRUE and FALSE values, respectively. Like C, their
addresses can be used whenever an C is needed.
Do not be fooled into thinking that C<(SV *) 0> is the same as C<&PL_sv_undef>.
Take this code:
SV* sv = (SV*) 0;
if (I-am-to-return-a-real-value) {
sv = sv_2mortal(newSViv(42));
}
sv_setsv(ST(0), sv);
This code tries to return a new SV (which contains the value 42) if it should
return a real value, or undef otherwise. Instead it has returned a NULL
pointer which, somewhere down the line, will cause a segmentation violation,
bus error, or just weird results. Change the zero to C<&PL_sv_undef> in the
first line and all will be well.
To free an SV that you've created, call C. Normally this
call is not necessary (see L).
=head2 Offsets
Perl provides the function C to efficiently remove characters
from the beginning of a string; you give it an SV and a pointer to
somewhere inside the PV, and it discards everything before the
pointer. The efficiency comes by means of a little hack: instead of
actually removing the characters, C sets the flag C
(offset OK) to signal to other functions that the offset hack is in
effect, and it puts the number of bytes chopped off into the IV field
of the SV. It then moves the PV pointer (called C) forward that
many bytes, and adjusts C and C.
Hence, at this point, the start of the buffer that we allocated lives
at C in memory and the PV pointer is pointing
into the middle of this allocated storage.
This is best demonstrated by example:
% ./perl -Ilib -MDevel::Peek -le '$a="12345"; $a=~s/.//; Dump($a)'
SV = PVIV(0x8128450) at 0x81340f0
REFCNT = 1
FLAGS = (POK,OOK,pPOK)
IV = 1 (OFFSET)
PV = 0x8135781 ( "1" . ) "2345"\0
CUR = 4
LEN = 5
Here the number of bytes chopped off (1) is put into IV, and
C helpfully reminds us that this is an offset. The
portion of the string between the "real" and the "fake" beginnings is
shown in parentheses, and the values of C and C reflect
the fake beginning, not the real one.
Something similar to the offset hack is performed on AVs to enable
efficient shifting and splicing off the beginning of the array; while
C points to the first element in the array that is visible from
Perl, C points to the real start of the C array. These are
usually the same, but a C operation can be carried out by
increasing C by one and decreasing C and C.
Again, the location of the real start of the C array only comes into
play when freeing the array. See C in F.
=head2 What's Really Stored in an SV?
Recall that the usual method of determining the type of scalar you have is
to use C macros. Because a scalar can be both a number and a string,
usually these macros will always return TRUE and calling the C
macros will do the appropriate conversion of string to integer/double or
integer/double to string.
If you I need to know if you have an integer, double, or string
pointer in an SV, you can use the following three macros instead:
SvIOKp(SV*)
SvNOKp(SV*)
SvPOKp(SV*)
These will tell you if you truly have an integer, double, or string pointer
stored in your SV. The "p" stands for private.
There are various ways in which the private and public flags may differ.
For example, a tied SV may have a valid underlying value in the IV slot
(so SvIOKp is true), but the data should be accessed via the FETCH
routine rather than directly, so SvIOK is false. Another is when
numeric conversion has occurred and precision has been lost: only the
private flag is set on 'lossy' values. So when an NV is converted to an
IV with loss, SvIOKp, SvNOKp and SvNOK will be set, while SvIOK wont be.
In general, though, it's best to use the C macros.
=head2 Working with AVs
There are two ways to create and load an AV. The first method creates an
empty AV:
AV* newAV();
The second method both creates the AV and initially populates it with SVs:
AV* av_make(I32 num, SV **ptr);
The second argument points to an array containing C C's. Once the
AV has been created, the SVs can be destroyed, if so desired.
Once the AV has been created, the following operations are possible on it:
void av_push(AV*, SV*);
SV* av_pop(AV*);
SV* av_shift(AV*);
void av_unshift(AV*, I32 num);
These should be familiar operations, with the exception of C.
This routine adds C elements at the front of the array with the C
value. You must then use C (described below) to assign values
to these new elements.
Here are some other functions:
I32 av_len(AV*);
SV** av_fetch(AV*, I32 key, I32 lval);
SV** av_store(AV*, I32 key, SV* val);
The C function returns the highest index value in an array (just
like $#array in Perl). If the array is empty, -1 is returned. The
C function returns the value at index C, but if C
is non-zero, then C will store an undef value at that index.
The C function stores the value C at index C, and does
not increment the reference count of C. Thus the caller is responsible
for taking care of that, and if C returns NULL, the caller will
have to decrement the reference count to avoid a memory leak. Note that
C and C both return C's, not C's as their
return value.
A few more:
void av_clear(AV*);
void av_undef(AV*);
void av_extend(AV*, I32 key);
The C function deletes all the elements in the AV* array, but
does not actually delete the array itself. The C function will
delete all the elements in the array plus the array itself. The
C function extends the array so that it contains at least C
elements. If C is less than the currently allocated length of the array,
then nothing is done.
If you know the name of an array variable, you can get a pointer to its AV
by using the following:
AV* get_av("package::varname", 0);
This returns NULL if the variable does not exist.
See L for more
information on how to use the array access functions on tied arrays.
=head2 Working with HVs
To create an HV, you use the following routine:
HV* newHV();
Once the HV has been created, the following operations are possible on it:
SV** hv_store(HV*, const char* key, U32 klen, SV* val, U32 hash);
SV** hv_fetch(HV*, const char* key, U32 klen, I32 lval);
The C parameter is the length of the key being passed in (Note that
you cannot pass 0 in as a value of C to tell Perl to measure the
length of the key). The C argument contains the SV pointer to the
scalar being stored, and C is the precomputed hash value (zero if
you want C to calculate it for you). The C parameter
indicates whether this fetch is actually a part of a store operation, in
which case a new undefined value will be added to the HV with the supplied
key and C will return as if the value had already existed.
Remember that C and C return C's and not just
C. To access the scalar value, you must first dereference the return
value. However, you should check to make sure that the return value is
not NULL before dereferencing it.
The first of these two functions checks if a hash table entry exists, and the
second deletes it.
bool hv_exists(HV*, const char* key, U32 klen);
SV* hv_delete(HV*, const char* key, U32 klen, I32 flags);
If C does not include the C flag then C will
create and return a mortal copy of the deleted value.
And more miscellaneous functions:
void hv_clear(HV*);
void hv_undef(HV*);
Like their AV counterparts, C deletes all the entries in the hash
table but does not actually delete the hash table. The C deletes
both the entries and the hash table itself.
Perl keeps the actual data in a linked list of structures with a typedef of HE.
These contain the actual key and value pointers (plus extra administrative
overhead). The key is a string pointer; the value is an C. However,
once you have an C, to get the actual key and value, use the routines
specified below.
I32 hv_iterinit(HV*);
/* Prepares starting point to traverse hash table */
HE* hv_iternext(HV*);
/* Get the next entry, and return a pointer to a
structure that has both the key and value */
char* hv_iterkey(HE* entry, I32* retlen);
/* Get the key from an HE structure and also return
the length of the key string */
SV* hv_iterval(HV*, HE* entry);
/* Return an SV pointer to the value of the HE
structure */
SV* hv_iternextsv(HV*, char** key, I32* retlen);
/* This convenience routine combines hv_iternext,
hv_iterkey, and hv_iterval. The key and retlen
arguments are return values for the key and its
length. The value is returned in the SV* argument */
If you know the name of a hash variable, you can get a pointer to its HV
by using the following:
HV* get_hv("package::varname", 0);
This returns NULL if the variable does not exist.
The hash algorithm is defined in the C macro:
hash = 0;
while (klen--)
hash = (hash * 33) + *key++;
hash = hash + (hash >> 5); /* after 5.6 */
The last step was added in version 5.6 to improve distribution of
lower bits in the resulting hash value.
See L for more
information on how to use the hash access functions on tied hashes.
=head2 Hash API Extensions
Beginning with version 5.004, the following functions are also supported:
HE* hv_fetch_ent (HV* tb, SV* key, I32 lval, U32 hash);
HE* hv_store_ent (HV* tb, SV* key, SV* val, U32 hash);
bool hv_exists_ent (HV* tb, SV* key, U32 hash);
SV* hv_delete_ent (HV* tb, SV* key, I32 flags, U32 hash);
SV* hv_iterkeysv (HE* entry);
Note that these functions take C keys, which simplifies writing
of extension code that deals with hash structures. These functions
also allow passing of C keys to C functions without forcing
you to stringify the keys (unlike the previous set of functions).
They also return and accept whole hash entries (C), making their
use more efficient (since the hash number for a particular string
doesn't have to be recomputed every time). See L for detailed
descriptions.
The following macros must always be used to access the contents of hash
entries. Note that the arguments to these macros must be simple
variables, since they may get evaluated more than once. See
L for detailed descriptions of these macros.
HePV(HE* he, STRLEN len)
HeVAL(HE* he)
HeHASH(HE* he)
HeSVKEY(HE* he)
HeSVKEY_force(HE* he)
HeSVKEY_set(HE* he, SV* sv)
These two lower level macros are defined, but must only be used when
dealing with keys that are not Cs:
HeKEY(HE* he)
HeKLEN(HE* he)
Note that both C and C do not increment the
reference count of the stored C, which is the caller's responsibility.
If these functions return a NULL value, the caller will usually have to
decrement the reference count of C to avoid a memory leak.
=head2 AVs, HVs and undefined values
Sometimes you have to store undefined values in AVs or HVs. Although
this may be a rare case, it can be tricky. That's because you're
used to using C<&PL_sv_undef> if you need an undefined SV.
For example, intuition tells you that this XS code:
AV *av = newAV();
av_store( av, 0, &PL_sv_undef );
is equivalent to this Perl code:
my @av;
$av[0] = undef;
Unfortunately, this isn't true. AVs use C<&PL_sv_undef> as a marker
for indicating that an array element has not yet been initialized.
Thus, C would be true for the above Perl code, but
false for the array generated by the XS code.
Other problems can occur when storing C<&PL_sv_undef> in HVs:
hv_store( hv, "key", 3, &PL_sv_undef, 0 );
This will indeed make the value C, but if you try to modify
the value of C, you'll get the following error:
Modification of non-creatable hash value attempted
In perl 5.8.0, C<&PL_sv_undef> was also used to mark placeholders
in restricted hashes. This caused such hash entries not to appear
when iterating over the hash or when checking for the keys
with the C function.
You can run into similar problems when you store C<&PL_sv_yes> or
C<&PL_sv_no> into AVs or HVs. Trying to modify such elements
will give you the following error:
Modification of a read-only value attempted
To make a long story short, you can use the special variables
C<&PL_sv_undef>, C<&PL_sv_yes> and C<&PL_sv_no> with AVs and
HVs, but you have to make sure you know what you're doing.
Generally, if you want to store an undefined value in an AV
or HV, you should not use C<&PL_sv_undef>, but rather create a
new undefined value using the C function, for example:
av_store( av, 42, newSV(0) );
hv_store( hv, "foo", 3, newSV(0), 0 );
=head2 References
References are a special type of scalar that point to other data types
(including other references).
To create a reference, use either of the following functions:
SV* newRV_inc((SV*) thing);
SV* newRV_noinc((SV*) thing);
The C argument can be any of an C, C, or C. The
functions are identical except that C increments the reference
count of the C, while C does not. For historical
reasons, C is a synonym for C.
Once you have a reference, you can use the following macro to dereference
the reference:
SvRV(SV*)
then call the appropriate routines, casting the returned C to either an
C or C, if required.
To determine if an SV is a reference, you can use the following macro:
SvROK(SV*)
To discover what type of value the reference refers to, use the following
macro and then check the return value.
SvTYPE(SvRV(SV*))
The most useful types that will be returned are:
SVt_IV Scalar
SVt_NV Scalar
SVt_PV Scalar
SVt_RV Scalar
SVt_PVAV Array
SVt_PVHV Hash
SVt_PVCV Code
SVt_PVGV Glob (possibly a file handle)
SVt_PVMG Blessed or Magical Scalar
See the F header file for more details.
=head2 Blessed References and Class Objects
References are also used to support object-oriented programming. In perl's
OO lexicon, an object is simply a reference that has been blessed into a
package (or class). Once blessed, the programmer may now use the reference
to access the various methods in the class.
A reference can be blessed into a package with the following function:
SV* sv_bless(SV* sv, HV* stash);
The C argument must be a reference value. The C argument
specifies which class the reference will belong to. See
L for information on converting class names into stashes.
/* Still under construction */
The following function upgrades rv to reference if not already one.
Creates a new SV for rv to point to. If C is non-null, the SV
is blessed into the specified class. SV is returned.
SV* newSVrv(SV* rv, const char* classname);
The following three functions copy integer, unsigned integer or double
into an SV whose reference is C. SV is blessed if C is
non-null.
SV* sv_setref_iv(SV* rv, const char* classname, IV iv);
SV* sv_setref_uv(SV* rv, const char* classname, UV uv);
SV* sv_setref_nv(SV* rv, const char* classname, NV iv);
The following function copies the pointer value (I) into an SV whose reference is rv. SV is blessed if C
is non-null.
SV* sv_setref_pv(SV* rv, const char* classname, void* pv);
The following function copies a string into an SV whose reference is C.
Set length to 0 to let Perl calculate the string length. SV is blessed if
C is non-null.
SV* sv_setref_pvn(SV* rv, const char* classname, char* pv,
STRLEN length);
The following function tests whether the SV is blessed into the specified
class. It does not check inheritance relationships.
int sv_isa(SV* sv, const char* name);
The following function tests whether the SV is a reference to a blessed object.
int sv_isobject(SV* sv);
The following function tests whether the SV is derived from the specified
class. SV can be either a reference to a blessed object or a string
containing a class name. This is the function implementing the
C functionality.
bool sv_derived_from(SV* sv, const char* name);
To check if you've got an object derived from a specific class you have
to write:
if (sv_isobject(sv) && sv_derived_from(sv, class)) { ... }
=head2 Creating New Variables
To create a new Perl variable with an undef value which can be accessed from
your Perl script, use the following routines, depending on the variable type.
SV* get_sv("package::varname", GV_ADD);
AV* get_av("package::varname", GV_ADD);
HV* get_hv("package::varname", GV_ADD);
Notice the use of GV_ADD as the second parameter. The new variable can now
be set, using the routines appropriate to the data type.
There are additional macros whose values may be bitwise OR'ed with the
C argument to enable certain extra features. Those bits are:
=over
=item GV_ADDMULTI
Marks the variable as multiply defined, thus preventing the:
Name used only once: possible typo
warning.
=item GV_ADDWARN
Issues the warning:
Had to create unexpectedly
if the variable did not exist before the function was called.
=back
If you do not specify a package name, the variable is created in the current
package.
=head2 Reference Counts and Mortality
Perl uses a reference count-driven garbage collection mechanism. SVs,
AVs, or HVs (xV for short in the following) start their life with a
reference count of 1. If the reference count of an xV ever drops to 0,
then it will be destroyed and its memory made available for reuse.
This normally doesn't happen at the Perl level unless a variable is
undef'ed or the last variable holding a reference to it is changed or
overwritten. At the internal level, however, reference counts can be
manipulated with the following macros:
int SvREFCNT(SV* sv);
SV* SvREFCNT_inc(SV* sv);
void SvREFCNT_dec(SV* sv);
However, there is one other function which manipulates the reference
count of its argument. The C function, you will recall,
creates a reference to the specified argument. As a side effect,
it increments the argument's reference count. If this is not what
you want, use C instead.
For example, imagine you want to return a reference from an XSUB function.
Inside the XSUB routine, you create an SV which initially has a reference
count of one. Then you call C, passing it the just-created SV.
This returns the reference as a new SV, but the reference count of the
SV you passed to C has been incremented to two. Now you
return the reference from the XSUB routine and forget about the SV.
But Perl hasn't! Whenever the returned reference is destroyed, the
reference count of the original SV is decreased to one and nothing happens.
The SV will hang around without any way to access it until Perl itself
terminates. This is a memory leak.
The correct procedure, then, is to use C instead of
C. Then, if and when the last reference is destroyed,
the reference count of the SV will go to zero and it will be destroyed,
stopping any memory leak.
There are some convenience functions available that can help with the
destruction of xVs. These functions introduce the concept of "mortality".
An xV that is mortal has had its reference count marked to be decremented,
but not actually decremented, until "a short time later". Generally the
term "short time later" means a single Perl statement, such as a call to
an XSUB function. The actual determinant for when mortal xVs have their
reference count decremented depends on two macros, SAVETMPS and FREETMPS.
See L and L for more details on these macros.
"Mortalization" then is at its simplest a deferred C.
However, if you mortalize a variable twice, the reference count will
later be decremented twice.
"Mortal" SVs are mainly used for SVs that are placed on perl's stack.
For example an SV which is created just to pass a number to a called sub
is made mortal to have it cleaned up automatically when it's popped off
the stack. Similarly, results returned by XSUBs (which are pushed on the
stack) are often made mortal.
To create a mortal variable, use the functions:
SV* sv_newmortal()
SV* sv_2mortal(SV*)
SV* sv_mortalcopy(SV*)
The first call creates a mortal SV (with no value), the second converts an existing
SV to a mortal SV (and thus defers a call to C), and the
third creates a mortal copy of an existing SV.
Because C gives the new SV no value, it must normally be given one
via C, C, etc. :
SV *tmp = sv_newmortal();
sv_setiv(tmp, an_integer);
As that is multiple C statements it is quite common so see this idiom instead:
SV *tmp = sv_2mortal(newSViv(an_integer));
You should be careful about creating mortal variables. Strange things
can happen if you make the same value mortal within multiple contexts,
or if you make a variable mortal multiple times. Thinking of "Mortalization"
as deferred C should help to minimize such problems.
For example if you are passing an SV which you I has a high enough REFCNT
to survive its use on the stack you need not do any mortalization.
If you are not sure then doing an C and C, or
making a C is safer.
The mortal routines are not just for SVs; AVs and HVs can be
made mortal by passing their address (type-casted to C) to the
C or C routines.
=head2 Stashes and Globs
A B is a hash that contains all variables that are defined
within a package. Each key of the stash is a symbol
name (shared by all the different types of objects that have the same
name), and each value in the hash table is a GV (Glob Value). This GV
in turn contains references to the various objects of that name,
including (but not limited to) the following:
Scalar Value
Array Value
Hash Value
I/O Handle
Format
Subroutine
There is a single stash called C that holds the items that exist
in the C package. To get at the items in other packages, append the
string "::" to the package name. The items in the C package are in
the stash C in PL_defstash. The items in the C package are
in the stash C in C's stash.
To get the stash pointer for a particular package, use the function:
HV* gv_stashpv(const char* name, I32 flags)
HV* gv_stashsv(SV*, I32 flags)
The first function takes a literal string, the second uses the string stored
in the SV. Remember that a stash is just a hash table, so you get back an
C. The C flag will create a new package if it is set to GV_ADD.
The name that C wants is the name of the package whose symbol table
you want. The default package is called C. If you have multiply nested
packages, pass their names to C, separated by C<::> as in the Perl
language itself.
Alternately, if you have an SV that is a blessed reference, you can find
out the stash pointer by using:
HV* SvSTASH(SvRV(SV*));
then use the following to get the package name itself:
char* HvNAME(HV* stash);
If you need to bless or re-bless an object you can use the following
function:
SV* sv_bless(SV*, HV* stash)
where the first argument, an C, must be a reference, and the second
argument is a stash. The returned C can now be used in the same way
as any other SV.
For more information on references and blessings, consult L.
=head2 Double-Typed SVs
Scalar variables normally contain only one type of value, an integer,
double, pointer, or reference. Perl will automatically convert the
actual scalar data from the stored type into the requested type.
Some scalar variables contain more than one type of scalar data. For
example, the variable C<$!> contains either the numeric value of C
or its string equivalent from either C or C.
To force multiple data values into an SV, you must do two things: use the
C routines to add the additional scalar type, then set a flag
so that Perl will believe it contains more than one type of data. The
four macros to set the flags are:
SvIOK_on
SvNOK_on
SvPOK_on
SvROK_on
The particular macro you must use depends on which C routine
you called first. This is because every C routine turns on
only the bit for the particular type of data being set, and turns off
all the rest.
For example, to create a new Perl variable called "dberror" that contains
both the numeric and descriptive string error values, you could use the
following code:
extern int dberror;
extern char *dberror_list;
SV* sv = get_sv("dberror", GV_ADD);
sv_setiv(sv, (IV) dberror);
sv_setpv(sv, dberror_list[dberror]);
SvIOK_on(sv);
If the order of C and C had been reversed, then the
macro C would need to be called instead of C.
=head2 Magic Variables
[This section still under construction. Ignore everything here. Post no
bills. Everything not permitted is forbidden.]
Any SV may be magical, that is, it has special features that a normal
SV does not have. These features are stored in the SV structure in a
linked list of C's, typedef'ed to C.
struct magic {
MAGIC* mg_moremagic;
MGVTBL* mg_virtual;
U16 mg_private;
char mg_type;
U8 mg_flags;
I32 mg_len;
SV* mg_obj;
char* mg_ptr;
};
Note this is current as of patchlevel 0, and could change at any time.
=head2 Assigning Magic
Perl adds magic to an SV using the sv_magic function:
void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen);
The C argument is a pointer to the SV that is to acquire a new magical
feature.
If C is not already magical, Perl uses the C macro to
convert C to type C. Perl then continues by adding new magic
to the beginning of the linked list of magical features. Any prior entry
of the same type of magic is deleted. Note that this can be overridden,
and multiple instances of the same type of magic can be associated with an
SV.
The C and C arguments are used to associate a string with
the magic, typically the name of a variable. C is stored in the
C field and if C is non-null then either a C copy of
C or C itself is stored in the C field, depending on
whether C is greater than zero or equal to zero respectively. As a
special case, if C<(name && namlen == HEf_SVKEY)> then C is assumed
to contain an C and is stored as-is with its REFCNT incremented.
The sv_magic function uses C to determine which, if any, predefined
"Magic Virtual Table" should be assigned to the C field.
See the L section below. The C argument is also
stored in the C field. The value of C should be chosen
from the set of macros C found in F. Note that before
these macros were added, Perl internals used to directly use character
literals, so you may occasionally come across old code or documentation
referring to 'U' magic rather than C for example.
The C argument is stored in the C field of the C
structure. If it is not the same as the C argument, the reference
count of the C object is incremented. If it is the same, or if
the C argument is C, or if it is a NULL pointer,
then C is merely stored, without the reference count being incremented.
See also C in L for a more flexible way to add magic
to an SV.
There is also a function to add magic to an C:
void hv_magic(HV *hv, GV *gv, int how);
This simply calls C and coerces the C argument into an C.
To remove the magic from an SV, call the function sv_unmagic:
int sv_unmagic(SV *sv, int type);
The C argument should be equal to the C value when the C