=head1 TITLE

Common vtable format for all variables

=head1 VERSION

=head2 CURRENT

   Maintainer: Dan Sugalski <dan@sidhe.org>
   Class: Internals
   PDD Number: 2
   Version: 1.3
   Status: Developing
   Last Modified: 27 July 2003
   PDD Format: 1
   Language: English

=head2 HISTORY

=over 4

=item 1.3

27 July 2003

=item 1.2

22 June 2002

=item 1.1

13 May 2002

=item 1.0

None. First version

=back

=head1 CHANGES

=over 4

=item 1.3

Added a number of missing method definitions. Many other minor cleanups.

=item 1.2

Many cleanups and clarifications.  Much detail added.  Many missing
methods added.

=item 1.1

Cleaned up the definition. It was a mess.

=item 1.0

None. First version

=back

=head1 ABSTRACT

This PDD presents the vtable entries, and their order, that all
variables MUST provide.

=head1 DESCRIPTION

All parrot variables hide their guts behind a magic parrot structure
generally referred to as a PMC, or Parrot Magic Cookie. Nothing outside
the core of parrot (in fact, nothing outside the data type's vtable
routines) should infer anything about a PMC (hence the Magic part).

The first parameter to any vtable routine should be the current interpreter.
The second parameter should be the PMC itself.

vtables are neat because they decouple the interface and
implementation of various object functions. This does mean, though,
that you need to either know what functions are available and what
they do, or have some method of finding out. It's faster if you know
which vtable entry does what, so that's the method parrot's using.

The actual vtable structure contains pointers to functions that
implement the methods for that particular vtable.  All pointers
must point to valid functions with appropriate prototypes.

=head1 IMPLEMENTATION

=head2 vtable functions

This is a list of each of the vtable methods, their prototypes, and
a description of the method.

The following functions are singleton functions. (There are no keyed
versions of these)

=over 4

=item void init(INTERP, PMC* self)

The init vtable method takes an unused PMC as a parameter and turns
it into a PMC appropriate for the class owning the vtable. Called as a
class method.  There is also a form that accepts a PMC initializer as
a third argument.

=item void init_pmc(INTERP, PMC* self, PMC* initializer)

This form of the init method takes a single initializer parameter. The
initializer is an array that contains keys and values. The meaning of
the keys and their corresponding values is left up to the PMC.

Keys are either strings or integers. If strings, the PMC is
responsible for figuring out what the string represents. If integers,
it means the meaning has been pre-figured based on meta-information
from the class.

For example, if a class has the known properties "Size", "Dimension"
and "Color", they may be assigned the values 100, 101, and 102. If the
creator of the PMC knows enough about the class to make the
translation to numbers it may; otherwise, the raw strings may be used. 
So, for the declaration:

   my @foo Size(12), Dimension(3), Color("Green");

the init array may be [100, 12, 101, 3, 102, "Green"] or ["Size", 12,
"Dimension", 3, "Color", "Green"]. Note that, in all cases, the array
is an array of PMCs. (So you get either an int PMC or a string PMC in
the list of keys).

=item void init_pmc_props(INTERP, PMC* self, PMC* initializer, PMC* properties)

XXX: what does this do?

=item void morph(INTERP, PMC* self, INTVAL type)

Turn the PMC into a PMC of type C<type>. If the morphing can't be
done in any reasonable way -- for instance if an integer is asked to turn 
into an Array -- then the PMC is first destroyed, then recreated as an 
empty PMC of the new type.

This method is primarily used when the interpreter has need of
coercing a PMC to a particular type, and isn't meant as a general
purpose casting tool. Compilers should only emit valid transformations.

=item void mark(INTERP, PMC* self)

Called by the DOD when it is sweeping through the PMCs and has detected
that this PMC is both alive and has a custom mark routine (as indicated
by the custom mark PMC flag). 

If a PMC has this flag set, then it is responsible for marking all buffers 
and PMCs under its control as alive. If it does not, those PMCs or buffers
may be collected later. This method does I<not> have to call the
C<mark> method on any PMCs it marks--the DOD system takes care of
that. (So no need to recurse into aggregate PMCs or anything of the sort).

This method may allocate no memory from Parrot, nor may it alter
Parrot's internal structures. It should have no side-effects from the
C level either.

This routine may B<not> throw an exception.

=item void destroy(INTERP, PMC* self)

This method is called by the DOD when it determines that a PMC is
dead and that the PMC has marked itself as having a destroy method.

When this method finishes, the PMC will be marked as dead. As such you
should make sure that you do I<not> leave any references to it in any
parrot structure by the end of the method.

This method may I<not> throw an exception. It will be ignored if it does.

=item PMC* getprop(INTERP, PMC* self, STRING* key)

Return the value from the property hash of B<self> keyed by B<key>. 
The key should not be NULL.

=item void setprop(INTERP, PMC* self, STRING* key, PMC* value)

Set the value in the property hash of B<self> that is keyed by B<key> to
the value of B<value>. The key should not be NULL.

=item void delprop(INTERP, PMC* self, STRING* key)

Delete the value from the property hash of B<self> keyed by B<key>. 
The key should not be NULL.

=item PMC* getprops(INTERP, PMC* self)

Return the entire property hash for B<self>.

=back

The following functions have a plain form, a _keyed form, and
a _keyed_int form. The keyed forms take a KEY* or INTVAL* for I<each> PMC
parameter.  The KEY*/INTVAL* parameter for each PMC is NULL if there is no
key for that PMC; this means that that argument is unkeyed.

In some cases, the caller I<must> provide a non-NULL key.  Those cases are 
explicitly stated below.  In the other cases, you may have to implement the 
keyed vtable methods and check for a NULL B<self> key even if you are 
implementing a non-aggregate type.  If the B<self> key is non-NULL and the 
PMC class is a non-aggregate type, the _keyed_* methods should throw an 
exception.

If you do not implement the _keyed_int methods, the default will convert
the INTVAL into a KEY and call the corresponding _keyed method.

The keyed methods should I<NOT> assume that the key pointer will be
valid after the method exits.  The pointer may be to a
stack variable in the calling function.

=over 4

=item INTVAL type(INTERP, PMC* self)

Return the type of the PMC. Type is a unique tag associated with the
PMC when the PMC's class is loaded. Negative numbers are considered
interpreter-specific, non-public types.

=item INTVAL type_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL type_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the type of the PMC indexed by B<key>.  The B<key> parameter
is guaranteed not to be NULL for this method.

=item UINTVAL subtype(INTERP, PMC* self, INTVAL type)

Return the subtype of a PMC. (Note that this may be unimplemented,
and may go away). This is intended to return information about the
PMC--what type of number or string it is, whether it's a scalar, hash,
array, or list, and suchlike things.

=item UINTVAL subtype_keyed(INTERP, PMC* self, KEY* key, INTVAL type)

=item UINTVAL subtype_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL type)

Return the subtype of the PMC indexed by B<key>.  The B<key> parameter
is guaranteed not to be NULL for this method.

=item STRING* name(INTERP, PMC* self)

Return the name of the class for the PMC.

=item STRING* name_keyed(INTERP, PMC* self, KEY* key)

=item STRING* name_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the name of the class of the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void clone(INTERP, PMC* self, PMC *dest)

Make B<dest> a clone of yourself. B<dest> is a PMC of the same type,
created via B<pmc_new_noinit>.

=item void clone_keyed(INTERP, PMC* self, KEY* key, PMC *dest)

=item void clone_keyed_int(INTERP, PMC* self, INTVAL* key, PMC *dest)

Make B<dest> a clone of the PMC indexed by B<key>. If the PMC is fake,
for example we're asking for a clone of an element of an integer
array, this must return an appropriate real PMC that holds the fake
information.  The B<key> parameter is guaranteed not to be NULL for
this method.

=item PMC* find_method(INTERP, PMC* self, STRING* method_name)

Return a subroutine PMC for the passed method name. This subroutine
PMC may be cached, so the method I<must> return an equivalent sub PMC
each time, or be capable of dealing with the returned sub PMCs being
reused.

=item PMC* find_method_keyed(INTERP, PMC* self, KEY* key, STRING* method_name)

=item PMC* find_method_keyed_int(INTERP, PMC* self, INTVAL* key, STRING* method_name)

Return a subroutine PMC for the passed method name. This subroutine
PMC may be cached, so the method I<must> return an equivalent sub PMC
each time, or be capable of dealing with the returned sub PMCs being
reused.
The B<key> parameter is guaranteed not to be NULL for this method.

=item INTVAL get_integer(INTERP, PMC* self)

Return the native integer value of the PMC.

=item INTVAL get_integer_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL get_integer_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the native integer value of the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item FLOATVAL get_number(INTERP, PMC* self)

Return the native floating-point value of the PMC.

=item FLOATVAL get_number_keyed(INTERP, PMC* self, KEY* key)

=item FLOATVAL get_number_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the native floating-point value of the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item BIGNUM* get_bignum(INTERP, PMC* self)

Return the value of the PMC as a bignum.

=item BIGNUM* get_bignum_keyed(INTERP, PMC* self, KEY* key)

=item BIGNUM* get_bignum_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the bignum value of the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item STRING* get_string(INTERP, PMC* self)

Return the native string value of the PMC. This may be in the
encoding of the PMC's choice.

=item STRING* get_string_keyed(INTERP, PMC* self, KEY* key)

=item STRING* get_string_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the string value of the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item INTVAL get_bool(INTERP, PMC* self)

Return the constant TRUE if the PMC is true, or FALSE if the PMC is
false. The definition of truth for a given PMC will depend on the type
of the PMC: for a scalar, it may be as simple as 0 or "" being false,
and any other value being true. 

=item INTVAL get_bool_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL get_bool_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the constant TRUE if the PMC indexed by B<key> is true,
or FALSE if the PMC indexed by B<key> is false.
The B<key> parameter is guaranteed not to be NULL for this method.

=item INTVAL elements(INTERP, PMC* self)

Return the number of elements in the PMC.

=item INTVAL elements_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL elements_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the number of elements in the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item PMC* get_pmc(INTERP, PMC* self)

Return the PMC for this PMC. While this may seem nonsensical, it's
useful in several circumstances. If the thing being accessed may
return something odd, for example a reference, it may return a
value different from the PMC that get_pmc is being called on.

=item PMC* get_pmc_keyed(INTERP, PMC* self, KEY* key)

=item PMC* get_pmc_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the PMC indexed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item INTVAL is_same(INTERP, PMC* self, PMC* value)

Return TRUE if the PMCs are the same, and FALSE if
they're not. In this case, "the same" means identical at a low
level. For plain equality, use the is_equal method.

=item INTVAL is_same_keyed(INTERP, PMC* self, KEY* key, PMC* value, PMC* value_key)

=item INTVAL is_same_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Return TRUE if the PMC keyed by B<key> is the same as the
PMC in B<value> keyed by B<value_key>.  At least one of the
two keys is guaranteed not to be NULL.

=item void set_integer(INTERP, PMC* self, PMC* value)

Sets the PMC to the integer value of the PMC in B<value>.
What the PMC does with the passed in integer depends on the class.

=item void set_integer_native(INTERP, PMC* self, INTVAL value)

Sets the PMC to the integer value passed.

=item void set_integer_same(INTERP, PMC* self, PMC* value)

Sets the PMC to the integer value of the PMC in B<value>.
In this case, B<value> is guaranteed to be of the same type
as B<self> so optimizations may be made.

=item void set_integer_keyed(INTERP, PMC* self, KEY* key, INTVAL value)

=item void set_integer_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL value)

Sets the PMC indexed by B<key> to the integer value passed in B<value>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void set_number(INTERP, PMC* self, PMC* value)

Sets the PMC to the floating-point value of the PMC in B<value>.

=item void set_number_native(INTERP, PMC* self, FLOATVAL value)

Sets the PMC to the floating-point value passed.

=item void set_number_same(INTERP, PMC* self, PMC* value)

Sets the PMC to the floating-point value of the PMC in B<value>.
In this case, B<value> is guaranteed to be of the same type
as B<self> so optimizations may be made.

=item void set_number_keyed(INTERP, PMC* self, KEY* key, FLOATVAL value)

=item void set_number_keyed_int(INTERP, PMC* self, INTVAL* key, FLOATVAL value)

Sets the PMC indexed by B<key> to the floating-point value passed in B<value>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void set_bignum(INTERP, PMC* self, PMC* value)

Sets the PMC to the bignum value of B<value>.

=item void set_bignum_native(INTERP, PMC* self, BIGNUM* value)

Sets the PMC to the passed in bignum value.

=item void set_bignum_same(INTERP, PMC* self, PMC* value)

Sets the PMC to the bignum value of B<value>.
In this case, B<value> is guaranteed to be of the same type
as B<self> so optimizations may be made.

=item void set_bignum_keyed(INTERP, PMC* self, KEY* key, BIGNUM* value)

=item void set_bignum_keyed_int(INTERP, PMC* self, INTVAL* key, BIGNUM* value)

Sets the PMC indexed by B<key> to the bignum value passed in B<value>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void set_string(INTERP, PMC* self, PMC* value)

Sets the PMC to the string value of B<value>.

=item void set_string_native(INTERP, PMC* self, STRING* value)

Sets the PMC to the passed in string value.

=item void set_string_same(INTERP, PMC* self, PMC* value)

Sets the PMC to the string value of B<value>.
In this case, B<value> is guaranteed to be of the same type
as B<self> so optimizations may be made.

=item void set_string_keyed(INTERP, PMC* self, KEY* key, STRING* value)

=item void set_string_keyed_int(INTERP, PMC* self, INTVAL* key, STRING* value)

Sets the PMC indexed by B<key> to the string value passed in B<value>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void set_pmc(INTERP, PMC* self, PMC* value)

Sets the value of the PMC in B<self> to the value of the PMC in B<value>.

=item void set_pmc_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

=item void set_pmc_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Sets the value of the PMC keyed by B<key> to the value of the PMC
in B<value> keyed by B<value_key>.  At least one of the two keys
is guaranteed not to be NULL.

=item void set_same(INTERP, PMC* self, PMC* value)

A shortcut version of C<set_pmc> in those cases where the interpreter
knows the source and destination PMCs are of the same type.

=item void set_same_keyed(INTERP, PMC* self, KEY* key, PMC* value, PMC* value_key)

=item void set_same_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Sets the value keyed by B<key> to the value of B<value> keyed by B<value_key>.
Both B<self> and B<value> are guaranteed to be of the same type so optimizations
may be made.

At least one of the two keys is guaranteed not to be NULL.

Because the two PMCs are guaranteed to be of the same type, this method may
throw an exception if the PMC class is a non-aggregate type.

=item INTVAL pop_integer(INTERP, PMC* self)

Return the integer value of the last item on the list, removing that item.

=item INTVAL pop_integer_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL pop_integer_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the integer value of the last item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item FLOATVAL pop_float(INTERP, PMC* self)

Return the floating-point value of the last item on the list,
removing that item.

=item FLOATVAL pop_float_keyed(INTERP, PMC* self, KEY* key)

=item FLOATVAL pop_float_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the floating-point value of the last item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item BIGNUM* pop_bignum(INTERP, PMC* self)

Return the bignum value of the last item on the list,
removing that item.

=item BIGNUM* pop_bignum_keyed(INTERP, PMC* self, KEY* key)

=item BIGNUM* pop_bignum_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the bignum value of the last item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item STRING* pop_string(INTERP, PMC* self)

Return the string value of the last item on the list,
removing that item.

=item STRING* pop_string_keyed(INTERP, PMC* self, KEY* key)

=item STRING* pop_string_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the string value of the last item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item PMC* pop_pmc(INTERP, PMC* self)

Return the PMC value of the last item on the list,
removing that item.

=item PMC* pop_pmc_keyed(INTERP, PMC* self, KEY* key)

=item PMC* pop_pmc_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the PMC value of the last item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void push_integer(INTERP, PMC* self, INTVAL value)

Add the passed in integer value to the end of the list.

=item void push_integer_keyed(INTERP, PMC* self, KEY* key, INTVAL value)

=item void push_integer_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL value)

Add the passed in integer value to the end of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void push_float(INTERP, PMC* self, FLOATVAL value)

Add the passed in floating-point number to the end of the list.

=item void push_float_keyed(INTERP, PMC* self, KEY* key, FLOATVAL value)

=item void push_float_keyed_int(INTERP, PMC* self, INTVAL* key, FLOATVAL value)

Add the passed in floating-point value to the end of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void push_bignum(INTERP, PMC* self, BIGNUM* value)

Add the passed in bignum to the end of the list.

=item void push_bignum_keyed(INTERP, PMC* self, KEY* key, BIGNUM* value)

=item void push_bignum_keyed_int(INTERP, PMC* self, INTVAL* key, BIGNUM* value)

Add the passed in bignum to the end of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void push_string(INTERP, PMC* self, STRING* value)

Add the passed in string to the end of the list.

=item void push_string_keyed(INTERP, PMC* self, KEY* key, STRING* value)

=item void push_string_keyed_int(INTERP, PMC* self, INTVAL* key, STRING* value)

Add the passed in string to the end of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void push_pmc(INTERP, PMC* self, PMC* value)

Add the passed in PMC to the end of the list.

=item void push_pmc_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

=item void push_pmc_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Add the passed in PMC to the end of the list keyed by B<key>.
At least one of the two keys is guaranteed not to be NULL.  If B<key> is
NULL then the method will use B<self>.  If B<value_key> is NULL then the
method will use B<value>.

=item INTVAL shift_integer(INTERP, PMC* self)

Return the integer value of the first item on the list, removing that item.

=item INTVAL shift_integer_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL shift_integer_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the integer value of the first item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item FLOATVAL shift_float(INTERP, PMC* self)

Return the floating-point value of the first item on the list,
removing that item.

=item FLOATVAL shift_float_keyed(INTERP, PMC* self, KEY* key)

=item FLOATVAL shift_float_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the floating-point value of the first item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item BIGNUM* shift_bignum(INTERP, PMC* self)

Return the bignum value of the first item on the list,
removing that item.

=item BIGNUM* shift_bignum_keyed(INTERP, PMC* self, KEY* key)

=item BIGNUM* shift_bignum_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the bignum value of the first item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item STRING* shift_string(INTERP, PMC* self)

Return the string value of the first item on the list,
removing that item.

=item STRING* shift_string_keyed(INTERP, PMC* self, KEY* key)

=item STRING* shift_string_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the string value of the first item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item PMC* shift_pmc(INTERP, PMC* self)

Return the PMC value of the first item on the list,
removing that item.

=item PMC* shift_pmc_keyed(INTERP, PMC* self, KEY* key)

=item PMC* shift_pmc_keyed_int(INTERP, PMC* self, INTVAL* key)

Return the PMC value of the first item of the list keyed by B<key>,
removing that item from the list.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void unshift_integer(INTERP, PMC* self, INTVAL value)

Add the passed in integer value to the beginning of the list.

=item void unshift_integer_keyed(INTERP, PMC* self, KEY* key, INTVAL value)

=item void unshift_integer_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL value)

Add the passed in integer value to the beginning of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void unshift_float(INTERP, PMC* self, FLOATVAL value)

Add the passed in floating-point number to the beginning of the list.

=item void unshift_float_keyed(INTERP, PMC* self, KEY* key, FLOATVAL value)

=item void unshift_float_keyed_int(INTERP, PMC* self, INTVAL* key, FLOATVAL value)

Add the passed in floating-point value to the beginning of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void unshift_bignum(INTERP, PMC* self, BIGNUM* value)

Add the passed in bignum to the beginning of the list.

=item void unshift_bignum_keyed(INTERP, PMC* self, KEY* key, BIGNUM* value)

=item void unshift_bignum_keyed_int(INTERP, PMC* self, INTVAL* key, BIGNUM* value)

Add the passed in bignum to the beginning of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void unshift_string(INTERP, PMC* self, STRING* value)

Add the passed in string to the beginning of the list.

=item void unshift_string_keyed(INTERP, PMC* self, KEY* key, STRING* value)

=item void unshift_string_keyed_int(INTERP, PMC* self, INTVAL* key, STRING* value)

Add the passed in string to the beginning of the list keyed by B<key>.
The B<key> parameter is guaranteed not to be NULL for this method.

=item void unshift_pmc(INTERP, PMC* self, PMC* value)

Add the passed in PMC to the beginning of the list.

=item void unshift_pmc_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

=item void unshift_pmc_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Add the passed in PMC to the beginning of the list keyed by B<key>.
At least one of the two keys is guaranteed not to be NULL.

=item void splice(INTERP, PMC* self, PMC* value, INTVAL offset, INTVAL count)

Replace the B<count> PMCs at offset B<offset> from the beginning of
B<self> with the PMCs in the aggregate B<value>.

=item void splice_keyed(INTERP, PMC* self, KEY* key, PMC* value,
INTVAL offset, INTVAL count, KEY* value_key)

=item void splice_keyed_int(INTERP, PMC* self, INTVAL* key, PMC*
value, INTVAL *value_key, INTVAL offset, INTVAL count)

Replace the B<count> PMCs at offset B<offset> from the beginning of
the list in B<self> keyed by B<key> with the PMCs in the list in
B<value> keyed by B<value_key>.

B<NOTE>: the _keyed and _keyed_int variants of B<push>, B<pop>, B<shift>,
B<unshift> and B<splice> are not currently implemented and may go away.

=item void add(INTERP, PMC* self, PMC* value, PMC* dest)

=item void add_int(INTERP, PMC* self, INTVAL value, PMC* dest)

=item void add_bignum(INTERP, PMC* self, BIGNUM* value, PMC* dest)

=item void add_float(INTERP, PMC* self, FLOATVAL value, PMC* dest)

Add B<self> to B<value> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.

=item void add_same(INTERP, PMC* self, PMC* value, PMC* dest)

Add B<self> to B<value> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.  In this case, it is guaranteed that B<self> and B<value> are of
the same type.

=item void add_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void add_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Add the value in B<self> keyed by B<key> to the value in B<value> keyed by
B<value_key> and store the result in B<dest> keyed by B<dest_key>.

At least one of the three keys is guaranteed to not be NULL.

=item void subtract(INTERP, PMC* self, PMC* value, PMC* dest)

=item void subtract_int(INTERP, PMC* self, INTVAL value, PMC* dest)

=item void subtract_bignum(INTERP, PMC* self, BIGNUM* value, PMC* dest)

=item void subtract_float(INTERP, PMC* self, FLOATVAL value, PMC* dest)

Subtract B<value> from B<self> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be made.

=item void subtract_same(INTERP, PMC* self, PMC* value, PMC* dest)

Subtract B<value> from B<self> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.  In this case, it is guaranteed that B<self> and B<value> are of
the same type.

=item void subtract_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void subtract_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Subtract the value in B<value> keyed by B<key> from the value in B<self> 
keyed by B<value_key> and store the result in B<dest> keyed by B<dest_key>.

At least one of the three keys is guaranteed to not be NULL.

=item void multiply(INTERP, PMC* self, PMC* value, PMC* dest)

=item void multiply_int(INTERP, PMC* self, INTVAL value, PMC* dest)

=item void multiply_bignum(INTERP, PMC* self, BIGNUM* value, PMC* dest)

=item void multiply_float(INTERP, PMC* self, FLOATVAL value, PMC* dest)

Multiply B<value> by B<self> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.

=item void multiply_same(INTERP, PMC* self, PMC* value, PMC* dest)

Multiply B<value> by B<self> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.  In this case, it is guaranteed that B<self> and B<value> are of
the same type.

=item void multiply_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void multiply_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Multiply the value in B<self> keyed by B<key> by the value in B<value> keyed by
B<value_key> and store the result in B<dest> keyed by B<dest_key>.

At least one of the three keys is guaranteed to not be NULL.

=item void divide(INTERP, PMC* self, PMC* value, PMC* dest)

=item void divide_int(INTERP, PMC* self, INTVAL value, PMC* dest)

=item void divide_bignum(INTERP, PMC* self, BIGNUM* value, PMC* dest)

=item void divide_float(INTERP, PMC* self, FLOATVAL value, PMC* dest)

Divide B<self> by B<value> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.

=item void divide_same(INTERP, PMC* self, PMC* value, PMC* dest)

Divide B<self> by B<value> and store the result in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.  In this case, it is guaranteed that B<self> and B<value> are of
the same type.

=item void divide_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void divide_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Divide the value in B<self> keyed by B<key> by the value in B<value> keyed by
B<value_key> and store the result in B<dest> keyed by B<dest_key>.

At least one of the three keys is guaranteed to not be NULL.

=item void modulus(INTERP, PMC* self, PMC* value, PMC* dest)

=item void modulus_int(INTERP, PMC* self, INTVAL value, PMC* dest)

=item void modulus_bignum(INTERP, PMC* self, BIGNUM* value, PMC* dest)

=item void modulus_float(INTERP, PMC* self, FLOATVAL value, PMC* dest)

Divide B<self> by B<value> and store the remainder in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.

=item void modulus_same(INTERP, PMC* self, PMC* value, PMC* dest)

Divide B<self> by B<value> and store the remainder in B<dest>.  Note that
B<dest> may be equal to B<self>; in that case optimizations I<may> be
made.  In this case, it is guaranteed that B<self> and B<value> are of
the same type.

=item void modulus_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void modulus_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Divide the value in B<self> keyed by B<key> by the value in B<value> keyed by
B<value_key> and store the remainder in B<dest> keyed by B<dest_key>.

At least one of the three keys is guaranteed to not be NULL.

B<NOTE>: the _keyed and _keyed_int variants of B<add>, B<subtract>, 
B<multiply>, B<divide> and B<modulus> are not currently implemented and may 
go away.

=item void neg(INTERP, PMC* self, PMC* dest)

Negate the sign of B<self> and store the result in B<dest>.  Note that
B<self> and B<dest> may refer to the same PMC, in which case
optimizations I<may> be made.

=item void bitwise_or(INTERP, PMC* self, PMC* value, PMC* dest)

=item void bitwise_or_int(INTERP, PMC* self, INTVAL value, PMC* dest)

Calculate the bitwise-OR of B<self> and B<value> and store the result
in B<dest>.   Note that B<dest> may be equal to B<self>; in that case
optimizations I<may> be made.

=item void bitwise_or_same(INTERP, PMC* self, PMC* value, PMC* dest)

Calculate the bitwise-OR of B<self> and B<value> and store the result
in B<dest>.   Note that B<dest> may be equal to B<self>; in that case
optimizations I<may> be made.  In this case, it is guaranteed that
B<self> and B<value> are of the same type.

=item void bitwise_or_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void bitwise_or_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Calculate the bitwise-OR of B<self> keyed by B<key> and B<value> keyed
by B<value_key>, and store the result in B<dest_key>.

At least one of the keys is guaranteed to be non-NULL.

=item void bitwise_and(INTERP, PMC* self, PMC* value, PMC* dest)

=item void bitwise_and_int(INTERP, PMC* self, INTVAL value, PMC* dest)

Calculate the bitwise-AND of B<self> and B<value> and store the result
in B<dest>.   Note that B<dest> may be equal to B<self>; in that case
optimizations I<may> be made.

=item void bitwise_and_same(INTERP, PMC* self, PMC* value, PMC* dest)

Calculate the bitwise-AND of B<self> and B<value> and store the result
in B<dest>.   Note that B<dest> may be equal to B<self>; in that case
optimizations I<may> be made.  In this case, it is guaranteed that
B<self> and B<value> are of the same type.

=item void bitwise_and_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void bitwise_and_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Calculate the bitwise-AND of B<self> keyed by B<key> and B<value> keyed
by B<value_key>, and store the result in B<dest> keyed by B<dest_key>.

At least one of the keys is guaranteed to be non-NULL.

=item void bitwise_xor(INTERP, PMC* self, PMC* value, PMC* dest)

=item void bitwise_xor_int(INTERP, PMC* self, INTVAL value, PMC* dest)

Calculate the bitwise-XOR of B<self> and B<value> and store the result
in B<dest>.   Note that B<dest> may be equal to B<self>; in that case
optimizations I<may> be made.

=item void bitwise_xor_same(INTERP, PMC* self, PMC* value, PMC* dest)

Calculate the bitwise-XOR of B<self> and B<value> and store the result
in B<dest>.   Note that B<dest> may be equal to B<self>; in that case
optimizations I<may> be made.  In this case, it is guaranteed that
B<self> and B<value> are of the same type.

=item void bitwise_xor_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void bitwise_xor_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Calculate the bitwise-XOR of B<self> keyed by B<key> and B<value> keyed
by B<value_key>, and store the result in B<dest> keyed by B<dest_key>.

At least one of the keys is guaranteed to be non-NULL.

=item void bitwise_not(INTERP, PMC* self, PMC* dest)

Apply a bitwise negation to B<self> and store the result in B<dest>.
Note that B<self> and B<dest> may refer to the same PMC; in that case
optimizations I<may> be made.

=item void bitwise_not_keyed(INTERP, PMC* self, KEY* key, PMC* dest, KEY* dest_key)

=item void bitwise_not_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* dest, INTVAL* dest_key)

Apply a bitwise negation to B<self> keyed by B<key> and
store the result in B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void bitwise_shl(INTERP, PMC* self, PMC* value, PMC* dest)
=item void bitwise_shl_int(INTERP, PMC* self, INTVAL value, PMC* dest)

Apply a leftward shift of B<value> bits to the number stored in B<self>,
and place the resulting value in B<dest>. Note that B<self> and B<dest> may 
refer to the same PMC; in that case optimizations I<may> be made. 

=item void bitwise_shl_same(INTERP, PMC* self, PMC* value, PMC* dest)

Apply a leftward shift of B<value> bits to the number stored in B<self>,
and place the resulting value in B<dest>. Note that B<self> and B<dest> may 
refer to the same PMC; in that case optimizations I<may> be made. In this
case, it is guaranteed that B<self> and B<value> are of the same type.

=item void bitwise_shl_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void bitwise_shl_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Apply a leftward shift to the value in B<self> keyed by B<key>; the number of
bits by which to shift is taken from the value in B<value> keyed by 
B<value_key>. Store the result in B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void bitwise_shr(INTERP, PMC* self, PMC* value, PMC* dest)
=item void bitwise_shr_int(INTERP, PMC* self, INTVAL value, PMC* dest)

Applies a rightward shift of B<value> bits to the number stored in B<self>,
and places the resulting value in B<dest>. Note that B<self> and B<dest> may 
refer to the same PMC; in that case optimizations I<may> be made. 

=item void bitwise_shr_same(INTERP, PMC* self, PMC* value, PMC* dest)

Applies a rightward shift of B<value> bits to the number stored in B<self>,
and places the resulting value in B<dest>. Note that B<self> and B<dest> may 
refer to the same PMC; in that case optimizations I<may> be made. In this
case, it is guaranteed that B<self> and B<value> are of the same type.

=item void bitwise_shr_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void bitwise_shr_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Apply a rightward shift to the value in B<self> keyed by B<key>; the number of
bits by which to shift is taken from the value in B<value> keyed by 
B<value_key>. Store the result in B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

B<NOTE>: the _keyed and _keyed_int variants of the B<bitwise> methods are
not currently implemented and may go away.

=item void concatenate(INTERP, PMC* self, PMC* value, PMC* dest)

=item void concatenate_native(INTERP, PMC* self, STRING* value, PMC* dest)

Concatenate the strings in B<self> and B<value> and store the result
in B<dest>.
Note that B<self> and B<dest> may refer to the same PMC; in that case
optimizations I<may> be made.

=item void concatenate_same(INTERP, PMC* self, PMC* value, PMC* dest)

Concatenate the strings in B<self> and B<value> and store the result
in B<dest>.
Note that B<self> and B<dest> may refer to the same PMC; in that case
optimizations I<may> be made.  In this case, B<self> and B<value>
are guaranteed to be of the same type.

=item void concatenate_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void concatenate_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Concatenate the string in B<value> keyed by B<value_key> onto the string in 
B<self> keyed by B<key> and store the result in B<dest> keyed by B<dest_key>.

At least one of the three keys is guaranteed to not be NULL.

=item INTVAL is_equal(INTERP, PMC* self, PMC* value)

Return TRUE if the two PMCs are generically equivalent, or
FALSE if they aren't.

=item INTVAL is_equal_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

Return TRUE if the PMC at B<self> keyed by B<key> is generally
equivalent to the PMC at B<value> keyed by B<value_key>, or
FALSE if they aren't.

=item INTVAL cmp(INTERP, PMC* self, PMC* value)

Compare the two PMCs as PMCs (whatever that means for the class).
Return -1 if B<self> is smaller, 0 if the two are equal, and 1
if B<value> is smaller.

=item INTVAL cmp_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

=item INTVAL cmp_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Compare the PMC at B<self> keyed by B<key> with the PMC at B<value> keyed by
B<value_key> as PMCs (whatever that means for the class).
Return -1 if B<self> is smaller, 0 if the two are equal, and 1
if B<value> is smaller.

At least one key is guaranteed to be non-NULL.

=item INTVAL cmp_num(INTERP, PMC* self, PMC* value)

Compare the two PMCs numerically.
Return -1 if B<self> is smaller, 0 if the two are equal, and 1
if B<value> is smaller.

=item INTVAL cmp_num_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

=item INTVAL cmp_num_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Compare the PMC at B<self> keyed by B<key> with the PMC at B<value> keyed by
B<value_key> numerically.
Return -1 if B<self> is smaller, 0 if the two are equal, and 1
if B<value> is smaller.

At least one key is guaranteed to be non-NULL.

=item INTVAL cmp_string(INTERP, PMC* self, PMC* value)

Compare the two PMCs as strings.
Return -1 if B<self> is smaller, 0 if the two are equal, and 1
if B<value> is smaller.

=item INTVAL cmp_string_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key)

=item INTVAL cmp_string_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key)

Compare the PMC at B<self> keyed by B<key> with the PMC at B<value> keyed by
B<value_key> numerically.
Return -1 if B<self> is smaller, 0 if the two are equal, and 1
if B<value> is smaller.

At least one key is guaranteed to be non-NULL.

=item void logical_or(INTERP, PMC* self, PMC* value, PMC* dest)

Do a short-circuiting logical-OR of B<self> and B<value>, storing
the winner in B<dest>.

=item void logical_or_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void logical_or_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Do a short-circuiting logical-OR of B<self> keyed by B<key> and
B<value> keyed by B<value_key>, storing the winner in B<dest> keyed
by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void logical_and(INTERP, PMC* self, PMC* value, PMC* dest)

Do a short-circuiting logical-AND of B<self> and B<value>, storing
the winner in dest.

=item void logical_and_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void logical_and_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Do a short-circuiting logical-AND of B<self> keyed by B<key> and
B<value> keyed by B<value_key>, storing the winner in B<dest> keyed
by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void logical_xor(INTERP, PMC* self, PMC* value, PMC* dest)

If exactly one of B<self> or B<value> is true, store it in B<dest>.  Else
set B<dest> to be false.

=item void logical_xor_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void logical_xor_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

If exactly one of B<self> keyed by B<key> or B<value> keyed by B<value_key>
is true, store it in B<dest> keyed by B<dest_key>.  Else set B<dest>
keyed by B<dest_key> to be false.

At least one key is guaranteed to be non-NULL.

=item void logical_not(INTERP, PMC* self, PMC* dest)

Do a logical-NOT on B<self> and stores the result in B<dest>.

=item void logical_not_keyed(INTERP, PMC* self, KEY* key, PMC* dest, KEY* dest_key)

=item void logical_not_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* dest, INTVAL* dest_key)

Do a logical-NOT on B<self> keyed by B<key> and stores the result
in B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void repeat(INTERP, PMC* self, PMC* value, PMC* dest)

=item void repeat_int(INTERP, PMC* self, INTVAL value, PMC* dest)

Repeat the string value of B<self> B<value> times and store the
resultant string in B<dest>.

=item void repeat_keyed(INTERP, PMC* self, KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)

=item void repeat_keyed_int(INTERP, PMC* self, INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL* dest_key)

Repeat the string in B<self> keyed by B<key> by the quantity
of B<value> keyed by B<value_key> and store the result in
B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void repeat_int_keyed(INTERP, PMC* self, KEY* key, INTVAL value, PMC* dest, KEY* dest_key)

=item void repeat_int_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL value, PMC* dest, INTVAL* dest_key)

Repeat the string in B<self> keyed by B<key> B<value> times
and store the result in B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item void increment(INTERP, PMC* self)

Auto-increment the PMC.

=item void increment_keyed(INTERP, PMC* self, KEY* key)

=item void increment_keyed_int(INTERP, PMC* self, INTVAL* key)

Auto-increment the PMC keyed by B<key>.  The key is
guaranteed to be non-NULL.

=item void decrement(INTERP, PMC* self)

Auto-decrement the PMC.

=item void decrement_keyed(INTERP, PMC* self, KEY* key)

=item void decrement_keyed_int(INTERP, PMC* self, INTVAL* key)

Auto-decrement the PMC keyed by B<key>.  The key is
guaranteed to be non-NULL.

=item INTVAL exists_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL exists_keyed_int(INTERP, PMC* self, INTVAL* key)

This is only valid for keyed access. Return TRUE if the key exists
in the aggregate being queried; otherwise, return FALSE.

The key is guaranteed to be non-NULL.

=item INTVAL defined(INTERP, PMC* self)

Check to see if the PMC is defined. Return TRUE if it is; otherwise,
return FALSE.

=item INTVAL defined_keyed(INTERP, PMC* self, KEY* key)

=item INTVAL defined_keyed_int(INTERP, PMC* self, INTVAL* key)

Return TRUE if the value of B<self> keyed by B<key> is defined;
otherwise, return FALSE.

The key is guaranteed to be non-NULL.

=item void delete_keyed(INTERP, PMC* self, KEY* key)

=item void delete_keyed_int(INTERP, PMC* self, INTVAL* key)

Delete the specified entry from the aggregate.

The key is guaranteed to be non-NULL.

=item KEY* nextkey_keyed(INTERP, PMC* self, KEY* key)

=item KEY* nextkey_keyed_int(INTERP, PMC* self, INTVAL* key)

Given the passed in key for the PMC, return the next key.

The key is guaranteed to be non-NULL.

=item void substr(INTERP, PMC* self, INTVAL offset, INTVAL length, PMC* dest)

Place the value of the substring of B<self> at offset B<offset> and with
length B<length> into B<dest>.

=item void substr_keyed(INTERP, PMC* self, KEY* key, INTVAL offset, INTVAL length, PMC* dest, KEY* dest_key)

=item void substr_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL offset, INTVAL length, PMC* dest, INTVAL* dest_key)

Place the value of the substring of B<self> keyed by B<key> into
B<dest> keyed by B<dest_key>.

At least one key is guaranteed to be non-NULL.

=item STRING* substr_str(INTERP, PMC* self, INTVAL offset, INTVAL length)

Return the substring of B<self> at offset B<offset> and with length B<length>.

=item STRING* substr_str_keyed(INTERP, PMC* self, KEY* key, INTVAL offset, INTVAL length)

=item STRING* substr_str_keyed_int(INTERP, PMC* self, INTVAL* key, INTVAL offset, INTVAL length)

Return a substring with offset B<offset> and with length B<length> of the 
string in B<self> that is keyed by B<key>.

The key is guaranteed to be not NULL.

=item void* invoke(INTERP, PMC* self, void* next)
=item void* invoke_pmc(INTERP, PMC* self, PMC* sub, void* next)

Invoke the subroutine/method in the given PMC.

It should set up the environment for the sub, and should return the 
location at which operation flow should continue after the subroutine
returns. (Note that this will generally be the address of the next 
instruction).

It is B<NOT> responsible for preserving any of the current context;
the caller should have preserved anything that they want preserved
before calling this method.

See F<pdd03_calling_conventions.pod> for more details.

XXX: I still don't understand what *next does.
XXX: Is invoke_pmc used?

=item INTVAL can(INTERP, PMC* self, STRING* method)

Determine whether the PMC can perform the method specified by name in
B<method>. Returns TRUE if it can; otherwise, returns FALSE.

=item INTVAL can_keyed(INTERP, PMC* self, PMC* key, STRING* method)
=item INTVAL can_keyed_int(INTERP, PMC* self, INTVAL key, STRING* method)

Determine whether the PMC in B<self> keyed by B<key> can perform the method 
specified by name in B<method>. Returns TRUE if it can; otherwise, returns 
FALSE.

=item INTVAL does(INTERP, PMC* self, STRING* method)

Determine whether the PMC implements the interface specified by name in 
B<method>. Returns TRUE if it can; otherwise, returns FALSE.

=item INTVAL does_keyed(INTERP, PMC* self, PMC* key, STRING* method)
=item INTVAL does_keyed_int(INTERP, PMC* self, INTVAL key, STRING* method)

Determine whether the PMC in B<self> keyed by B<key> implements the interface 
specified by name in B<method>. Returns TRUE if it can; otherwise, returns 
FALSE.

See also F<pdd15_objects.pod>.

=back

=cut
