# New Ticket Created by Jonathan Sillito
# Please include the string: [perl #16087]
# in the subject line of all future correspondence about this issue.
# <URL: http://rt.perl.org/rt2/Ticket/Display.html?id=16087 >
The main purpose of this patch is to give scratchpads a pointer to their
parent pad. In the process I added a Scratchpad pmc that uses its data
pointer to point to a PerlHash (temporarily) and uses its cache pointer
to point to its parent. I am not sure about this use of the cache
pointer, but it is only used internally so it should be easy to change.
The scratchpad.pmc file is attached, the important bits (so far) are the
init(), mark(), set_pmc_keyed() and get_pmc_keyed() vtable methods.
The attached patch has the following effects:
- changes lexical ops in core.ops to use Scratchpad pmc.
- adds Scratchpad to enum in include/parrot/pmc.h
- adds Parrot_Scratchpad_class_init(enum_class_Scratchpad); to
global_setup.c
- adds additional test to t/op/lexicals.t
- fixes examples/assembly/lexicals.pasm (reverses PMC and string
arguments to store_lex op).
MISSING
-------
Access by integer index, I am waiting for a way to pass a pad descriptor
(or at least the number of lexicals to go in the pad) to the init vtable
method.
There is no integration with subs/coroutines/continuations. I will add
this if people think this approach is reasonable.
Comments?
--
Jonathan Sillito
-- attachment 1 ------------------------------------------------------
url: http://rt.perl.org/rt2/attach/33293/27417/874baa/lexicals.patch
-- attachment 2 ------------------------------------------------------
url: http://rt.perl.org/rt2/attach/33293/27418/a51da2/scratchpad.pmc
Index: core.ops
===================================================================
RCS file: /cvs/public/parrot/core.ops,v
retrieving revision 1.195
diff -u -r1.195 core.ops
--- core.ops 7 Aug 2002 04:01:24 -0000 1.195
+++ core.ops 8 Aug 2002 20:19:54 -0000
@@ -3662,8 +3662,8 @@
=cut
op new_pad() {
- PMC* hash = pmc_new(interpreter, enum_class_PerlHash);
- stack_push(interpreter, &interpreter->ctx.pad_stack, hash, STACK_ENTRY_DESTINATION, STACK_CLEANUP_NULL);
+ PMC * pad = pmc_new(interpreter, enum_class_Scratchpad);
+ stack_push(interpreter, &interpreter->ctx.pad_stack, pad, STACK_ENTRY_DESTINATION, STACK_CLEANUP_NULL);
goto NEXT();
}
@@ -3674,24 +3674,22 @@
}
op store_lex(in STR, in PMC) {
- PMC * hash = NULL;
+ PMC * pad;
KEY key;
Stack_entry_type type = 0;
MAKE_KEY(key, $1, enum_key_string, struct_val);
- hash = (PMC *)stack_peek(interpreter, interpreter->ctx.pad_stack, &type);
- hash->vtable->set_pmc_keyed(interpreter, hash, NULL, $2, &key);
+ pad = (PMC *)stack_peek(interpreter, interpreter->ctx.pad_stack, &type);
+ pad->vtable->set_pmc_keyed(interpreter, pad, NULL, $2, &key);
goto NEXT();
}
op find_lex(out PMC, in STR) {
- PMC * hash = NULL;
+ PMC * pad;
KEY key;
Stack_entry_type type = 0;
MAKE_KEY(key, $2, enum_key_string, struct_val);
- hash = (PMC *)stack_peek(interpreter, interpreter->ctx.pad_stack, &type);
- $1 = hash->vtable->get_pmc_keyed(interpreter, hash, &key);
-
- /* FIXME: should the not found case be an internal_exception ? */
+ pad = (PMC *)stack_peek(interpreter, interpreter->ctx.pad_stack, &type);
+ $1 = pad->vtable->get_pmc_keyed(interpreter, pad, &key);
goto NEXT();
}
Index: global_setup.c
===================================================================
RCS file: /cvs/public/parrot/global_setup.c,v
retrieving revision 1.31
diff -u -r1.31 global_setup.c
--- global_setup.c 4 Aug 2002 22:54:31 -0000 1.31
+++ global_setup.c 8 Aug 2002 20:19:54 -0000
@@ -34,6 +34,7 @@
Parrot_Coroutine_class_init(enum_class_Coroutine);
Parrot_CSub_class_init(enum_class_CSub);
Parrot_Continuation_class_init(enum_class_Continuation);
+ Parrot_Scratchpad_class_init(enum_class_Scratchpad);
/* Now register the names of the PMCs */
Index: include/parrot/pmc.h
===================================================================
RCS file: /cvs/public/parrot/include/parrot/pmc.h,v
retrieving revision 1.34
diff -u -r1.34 pmc.h
--- include/parrot/pmc.h 4 Aug 2002 22:56:06 -0000 1.34
+++ include/parrot/pmc.h 8 Aug 2002 20:19:54 -0000
@@ -27,6 +27,7 @@
enum_class_Coroutine,
enum_class_Continuation,
enum_class_CSub,
+ enum_class_Scratchpad,
enum_class_max = 100
};
VAR_SCOPE VTABLE Parrot_base_vtables[enum_class_max];
Index: t/op/lexicals.t
===================================================================
RCS file: /cvs/public/parrot/t/op/lexicals.t,v
retrieving revision 1.2
diff -u -r1.2 lexicals.t
--- t/op/lexicals.t 6 Aug 2002 22:42:35 -0000 1.2
+++ t/op/lexicals.t 8 Aug 2002 20:19:54 -0000
@@ -1,6 +1,6 @@
#! perl -w
-use Parrot::Test tests => 2;
+use Parrot::Test tests => 3;
output_is(<<CODE, <<OUTPUT, "simple store and fetch");
new_pad
@@ -53,6 +53,27 @@
0
2
0
+OUTPUT
+
+output_is(<<CODE, <<OUTPUT, "undefined lexicals");
+ new P0, .PerlInt
+ set P0, 30
+
+ # outer most lexical scope
+ new_pad
+
+ # nested lexical scope
+ new_pad
+ store_lex "a", P0
+ pop_pad
+
+ # should be undefined (printing undef does nothing)
+ find_lex P2, "a"
+ print P2
+ print "\\n"
+ end
+CODE
+
OUTPUT
1;
Index: examples/assembly/lexical.pasm
===================================================================
RCS file: /cvs/public/parrot/examples/assembly/lexical.pasm,v
retrieving revision 1.1
diff -u -r1.1 lexical.pasm
--- examples/assembly/lexical.pasm 31 Jul 2002 02:48:49 -0000 1.1
+++ examples/assembly/lexical.pasm 8 Aug 2002 20:19:54 -0000
@@ -15,14 +15,14 @@
# outer most lexical scope
new_pad
-store_lex P0, "a"
+store_lex "a", P0
find_lex P3, "a"
print P3 # prints 0
print "\n"
new_pad
-store_lex P1, "b"
-store_lex P1, "a"
+store_lex "b", P1
+store_lex "a", P1
find_lex P3, "a"
print P3 # prints 1
/* Scratchpad.pmc
* Copyright: (When this is determined...it will go here)
* CVS Info
* $Id$
* Overview:
* These are the vtable functions for the Scratchpad base class
* Data Structure and Algorithms:
* SELF->data stores the lexicals
* SELF->cache points to the parent Scratchpad, if there is one
* and is NULL otherwise
* History:
* Initial revision by sillito 2002/08/08
* Notes:
* References:
*/
#include "parrot/parrot.h"
pmclass Scratchpad {
void init () {
/* get parent */
PMC * parent;
Stack_entry_type type = 0;
parent = (PMC *)stack_peek(interpreter,
interpreter->ctx.pad_stack, &type);
SELF->cache.pmc_val = parent;
/* temporarily using a hash to store lexicals */
SELF->data = pmc_new(interpreter, enum_class_PerlHash);
SELF->flags |= (PMC_is_PMC_ptr_FLAG | PMC_custom_mark_FLAG);
}
void init_pmc (PMC* initializer) {
}
void morph (INTVAL type) {
}
PMC* mark (PMC* tail) {
/*
* this assumes that the data pointer points to something
* with a customer mark routine, which hash does ...
*/
tail = ((PMC *)SELF->data)->vtable->mark(interpreter,
SELF->data, tail);
if (SELF->cache.pmc_val) {
tail = Parrot_Scratchpad_mark(interpreter, SELF->cache.pmc_val, tail);
}
return tail;
}
void destroy () {
}
INTVAL type () {
return enum_class_Scratchpad;
}
/*
INTVAL type_keyed (KEY* key) {
}
INTVAL type_keyed_int (INTVAL* key) {
}
UINTVAL subtype (INTVAL type) {
}
UINTVAL subtype_keyed (KEY* key, INTVAL type) {
}
UINTVAL subtype_keyed_int (INTVAL* key, INTVAL type) {
}
*/
STRING* name () {
return whoami;
}
/*
STRING* name_keyed (KEY* key) {
}
STRING* name_keyed_int (INTVAL* key) {
}
PMC* clone () {
}
PMC* clone_keyed (KEY* key) {
}
PMC* clone_keyed_int (INTVAL* key) {
}
PMC* find_method (STRING* method_name) {
}
PMC* find_method_keyed (KEY* key, STRING* method_name) {
}
PMC* find_method_keyed_int (INTVAL* key, STRING* method_name) {
}
INTVAL get_integer () {
}
INTVAL get_integer_keyed (KEY* key) {
}
INTVAL get_integer_keyed_int (INTVAL* key) {
}
FLOATVAL get_number () {
}
FLOATVAL get_number_keyed (KEY* key) {
}
FLOATVAL get_number_keyed_int (INTVAL* key) {
}
BIGNUM* get_bignum () {
}
BIGNUM* get_bignum_keyed (KEY* key) {
}
BIGNUM* get_bignum_keyed_int (INTVAL* key) {
}
STRING* get_string () {
}
STRING* get_string_keyed (KEY* key) {
}
STRING* get_string_keyed_int (INTVAL* key) {
}
INTVAL get_bool () {
}
INTVAL get_bool_keyed (KEY* key) {
}
INTVAL get_bool_keyed_int (INTVAL* key) {
}
INTVAL elements () {
}
INTVAL elements_keyed (KEY* key) {
}
INTVAL elements_keyed_int (INTVAL* key) {
}
PMC* get_pmc () {
}
*/
PMC* get_pmc_keyed (KEY* key) {
PMC * value;
value = ((PMC *)SELF->data)->vtable->get_pmc_keyed(interpreter,
SELF->data, key);
if (value->vtable->type(interpreter, value) == enum_class_PerlUndef &&
SELF->cache.pmc_val) {
value = SELF->cache.pmc_val->vtable->get_pmc_keyed(interpreter,
SELF->cache.pmc_val, key);
}
return value;
}
/* implement this for getting lexicals by position
PMC* get_pmc_keyed_int (INTVAL* key) {
}
*/
/*
INTVAL is_same (PMC* value) {
}
INTVAL is_same_keyed (KEY* key, PMC* value, KEY* value_key) {
}
INTVAL is_same_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
void set_integer (PMC* value) {
}
void set_integer_native (INTVAL value) {
}
void set_integer_same (PMC* value) {
}
void set_integer_keyed (KEY* key, INTVAL value) {
}
void set_integer_keyed_int (INTVAL* key, INTVAL value) {
}
void set_number (PMC* value) {
}
void set_number_native (FLOATVAL value) {
}
void set_number_same (PMC* value) {
}
void set_number_keyed (KEY* key, FLOATVAL value) {
}
void set_number_keyed_int (INTVAL* key, FLOATVAL value) {
}
void set_bignum (PMC* value) {
}
void set_bignum_native (BIGNUM* value) {
}
void set_bignum_same (PMC* value) {
}
void set_bignum_keyed (KEY* key, BIGNUM* value) {
}
void set_bignum_keyed_int (INTVAL* key, BIGNUM* value) {
}
void set_string (PMC* value) {
}
void set_string_native (STRING* value) {
}
void set_string_unicode (STRING* value) {
}
void set_string_other (STRING* value) {
}
void set_string_same (PMC* value) {
}
void set_string_keyed (KEY* key, STRING* value) {
}
void set_string_keyed_int (INTVAL* key, STRING* value) {
}
void set_pmc (PMC* value) {
}
*/
void set_pmc_keyed (KEY* key, PMC* value, KEY* value_key) {
((PMC *)SELF->data)->vtable->set_pmc_keyed(interpreter,
SELF->data, key, value, value_key);
}
/*
void set_pmc_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
void set_same (PMC* value) {
}
void set_same_keyed (KEY* key, PMC* value, KEY* value_key) {
}
void set_same_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
INTVAL pop_integer () {
}
INTVAL pop_integer_keyed (KEY* key) {
}
INTVAL pop_integer_keyed_int (INTVAL* key) {
}
FLOATVAL pop_float () {
}
FLOATVAL pop_float_keyed (KEY* key) {
}
FLOATVAL pop_float_keyed_int (INTVAL* key) {
}
BIGNUM* pop_bignum () {
}
BIGNUM* pop_bignum_keyed (KEY* key) {
}
BIGNUM* pop_bignum_keyed_int (INTVAL* key) {
}
STRING* pop_string () {
}
STRING* pop_string_keyed (KEY* key) {
}
STRING* pop_string_keyed_int (INTVAL* key) {
}
PMC* pop_pmc () {
}
PMC* pop_pmc_keyed (KEY* key) {
}
PMC* pop_pmc_keyed_int (INTVAL* key) {
}
void push_integer (INTVAL value) {
}
void push_integer_keyed (KEY* key, INTVAL value) {
}
void push_integer_keyed_int (INTVAL* key, INTVAL value) {
}
void push_float (FLOATVAL value) {
}
void push_float_keyed (KEY* key, FLOATVAL value) {
}
void push_float_keyed_int (INTVAL* key, FLOATVAL value) {
}
void push_bignum (BIGNUM* value) {
}
void push_bignum_keyed (KEY* key, BIGNUM* value) {
}
void push_bignum_keyed_int (INTVAL* key, BIGNUM* value) {
}
void push_string (STRING* value) {
}
void push_string_keyed (KEY* key, STRING* value) {
}
void push_string_keyed_int (INTVAL* key, STRING* value) {
}
void push_pmc (PMC* value) {
}
void push_pmc_keyed (KEY* key, PMC* value, KEY* value_key) {
}
void push_pmc_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
INTVAL shift_integer () {
}
INTVAL shift_integer_keyed (KEY* key) {
}
INTVAL shift_integer_keyed_int (INTVAL* key) {
}
FLOATVAL shift_float () {
}
FLOATVAL shift_float_keyed (KEY* key) {
}
FLOATVAL shift_float_keyed_int (INTVAL* key) {
}
BIGNUM* shift_bignum () {
}
BIGNUM* shift_bignum_keyed (KEY* key) {
}
BIGNUM* shift_bignum_keyed_int (INTVAL* key) {
}
STRING* shift_string () {
}
STRING* shift_string_keyed (KEY* key) {
}
STRING* shift_string_keyed_int (INTVAL* key) {
}
PMC* shift_pmc () {
}
PMC* shift_pmc_keyed (KEY* key) {
}
PMC* shift_pmc_keyed_int (INTVAL* key) {
}
void unshift_integer (INTVAL value) {
}
void unshift_integer_keyed (KEY* key, INTVAL value) {
}
void unshift_integer_keyed_int (INTVAL* key, INTVAL value) {
}
void unshift_float (FLOATVAL value) {
}
void unshift_float_keyed (KEY* key, FLOATVAL value) {
}
void unshift_float_keyed_int (INTVAL* key, FLOATVAL value) {
}
void unshift_bignum (BIGNUM* value) {
}
void unshift_bignum_keyed (KEY* key, BIGNUM* value) {
}
void unshift_bignum_keyed_int (INTVAL* key, BIGNUM* value) {
}
void unshift_string (STRING* value) {
}
void unshift_string_keyed (KEY* key, STRING* value) {
}
void unshift_string_keyed_int (INTVAL* key, STRING* value) {
}
void unshift_pmc (PMC* value) {
}
void unshift_pmc_keyed (KEY* key, PMC* value, KEY* value_key) {
}
void unshift_pmc_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
void add (PMC* value, PMC* dest) {
}
void add_int (INTVAL value, PMC* dest) {
}
void add_bignum (BIGNUM* value, PMC* dest) {
}
void add_float (FLOATVAL value, PMC* dest) {
}
void add_same (PMC* value, PMC* dest) {
}
void add_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key) {
}
void add_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest, INTVAL*
dest_key) {
}
void subtract (PMC* value, PMC* dest) {
}
void subtract_int (INTVAL value, PMC* dest) {
}
void subtract_bignum (BIGNUM* value, PMC* dest) {
}
void subtract_float (FLOATVAL value, PMC* dest) {
}
void subtract_same (PMC* value, PMC* dest) {
}
void subtract_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void subtract_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void multiply (PMC* value, PMC* dest) {
}
void multiply_int (INTVAL value, PMC* dest) {
}
void multiply_bignum (BIGNUM* value, PMC* dest) {
}
void multiply_float (FLOATVAL value, PMC* dest) {
}
void multiply_same (PMC* value, PMC* dest) {
}
void multiply_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void multiply_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void divide (PMC* value, PMC* dest) {
}
void divide_int (INTVAL value, PMC* dest) {
}
void divide_bignum (BIGNUM* value, PMC* dest) {
}
void divide_float (FLOATVAL value, PMC* dest) {
}
void divide_same (PMC* value, PMC* dest) {
}
void divide_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)
{
}
void divide_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void modulus (PMC* value, PMC* dest) {
}
void modulus_int (INTVAL value, PMC* dest) {
}
void modulus_bignum (BIGNUM* value, PMC* dest) {
}
void modulus_float (FLOATVAL value, PMC* dest) {
}
void modulus_same (PMC* value, PMC* dest) {
}
void modulus_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void modulus_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void neg (PMC* dest) {
}
void neg_keyed (KEY* key, PMC* dest, KEY* dest_key) {
}
void neg_keyed_int (INTVAL* key, PMC* dest, INTVAL* dest_key) {
}
void bitwise_or (PMC* value, PMC* dest) {
}
void bitwise_or_int (INTVAL value, PMC* dest) {
}
void bitwise_or_same (PMC* value, PMC* dest) {
}
void bitwise_or_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void bitwise_or_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void bitwise_and (PMC* value, PMC* dest) {
}
void bitwise_and_int (INTVAL value, PMC* dest) {
}
void bitwise_and_same (PMC* value, PMC* dest) {
}
void bitwise_and_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void bitwise_and_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void bitwise_xor (PMC* value, PMC* dest) {
}
void bitwise_xor_int (INTVAL value, PMC* dest) {
}
void bitwise_xor_same (PMC* value, PMC* dest) {
}
void bitwise_xor_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void bitwise_xor_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void bitwise_not (PMC* dest) {
}
void bitwise_not_keyed (KEY* key, PMC* dest, KEY* dest_key) {
}
void bitwise_not_keyed_int (INTVAL* key, PMC* dest, INTVAL* dest_key) {
}
void bitwise_shl (PMC* value, PMC* dest) {
}
void bitwise_shl_int (INTVAL value, PMC* dest) {
}
void bitwise_shl_same (PMC* value, PMC* dest) {
}
void bitwise_shl_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void bitwise_shl_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void bitwise_shr (PMC* value, PMC* dest) {
}
void bitwise_shr_int (INTVAL value, PMC* dest) {
}
void bitwise_shr_same (PMC* value, PMC* dest) {
}
void bitwise_shr_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void bitwise_shr_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void concatenate (PMC* value, PMC* dest) {
}
void concatenate_native (STRING* value, PMC* dest) {
}
void concatenate_unicode (STRING* value, PMC* dest) {
}
void concatenate_other (STRING* value, PMC* dest) {
}
void concatenate_same (PMC* value, PMC* dest) {
}
void concatenate_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void concatenate_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
INTVAL is_equal (PMC* value) {
}
INTVAL is_equal_keyed (KEY* key, PMC* value, KEY* value_key) {
}
INTVAL is_equal_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
INTVAL cmp (PMC* value) {
}
INTVAL cmp_keyed (KEY* key, PMC* value, KEY* value_key) {
}
INTVAL cmp_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
INTVAL cmp_num (PMC* value) {
}
INTVAL cmp_num_keyed (KEY* key, PMC* value, KEY* value_key) {
}
INTVAL cmp_num_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
INTVAL cmp_string (PMC* value) {
}
INTVAL cmp_string_keyed (KEY* key, PMC* value, KEY* value_key) {
}
INTVAL cmp_string_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key) {
}
void logical_or (PMC* value, PMC* dest) {
}
void logical_or_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void logical_or_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void logical_and (PMC* value, PMC* dest) {
}
void logical_and_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void logical_and_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void logical_xor (PMC* value, PMC* dest) {
}
void logical_xor_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY*
dest_key) {
}
void logical_xor_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void logical_not (PMC* dest) {
}
void logical_not_keyed (KEY* key, PMC* dest, KEY* dest_key) {
}
void logical_not_keyed_int (INTVAL* key, PMC* dest, INTVAL* dest_key) {
}
void repeat (PMC* value, PMC* dest) {
}
void repeat_int (INTVAL value, PMC* dest) {
}
void repeat_keyed (KEY* key, PMC* value, KEY* value_key, PMC* dest, KEY* dest_key)
{
}
void repeat_keyed_int (INTVAL* key, PMC* value, INTVAL* value_key, PMC* dest,
INTVAL* dest_key) {
}
void repeat_int_keyed (KEY* key, INTVAL value, PMC* dest, KEY* dest_key) {
}
void repeat_int_keyed_int (INTVAL* key, INTVAL value, PMC* dest, INTVAL* dest_key)
{
}
void increment () {
}
void increment_keyed (KEY* key) {
}
void increment_keyed_int (INTVAL* key) {
}
void decrement () {
}
void decrement_keyed (KEY* key) {
}
void decrement_keyed_int (INTVAL* key) {
}
INTVAL exists_keyed (KEY* key) {
}
INTVAL exists_keyed_int (INTVAL* key) {
}
INTVAL defined () {
}
INTVAL defined_keyed (KEY* key) {
}
INTVAL defined_keyed_int (INTVAL* key) {
}
void delete_keyed (KEY* key) {
}
void delete_keyed_int (INTVAL* key) {
}
KEY* nextkey_keyed (KEY* key) {
}
KEY* nextkey_keyed_int (INTVAL* key) {
}
void substr (INTVAL offset, INTVAL length, PMC* dest) {
}
void substr_keyed (KEY* key, INTVAL offset, INTVAL length, PMC* dest, KEY*
dest_key) {
}
void substr_keyed_int (INTVAL* key, INTVAL offset, INTVAL length, PMC* dest,
INTVAL* dest_key) {
}
STRING* substr_str (INTVAL offset, INTVAL length) {
}
STRING* substr_str_keyed (KEY* key, INTVAL offset, INTVAL length) {
}
STRING* substr_str_keyed_int (INTVAL* key, INTVAL offset, INTVAL length) {
}
void* invoke (void* next) {
}
*/
}
