At 1:10 PM -0600 8/12/02, Jonathan Sillito wrote: >Dan, some time ago you mentioned that you were preparing a position doc >on issues raised in the 'maybe-PATCH: sub/continuation/dlsym/coroutine >clean-up' thread. Are you nearly ready with that doc? Does this patch >(i.e. a scratchpad pmc) fit into what you have in mind?
D'oh! I'll try and get it out by the end of the week. >1) The Parrot_Sub struct in sub.h has its own user_stack and >control_stack. Why is this necessary? I think this is already covered. Thinko. :) >2) If they are necessary, then does that mean the caller needs to save >and restore their user_stack and control_stack? Nope. >3) Some of the caller save burden (and overhead?) could be minimized if >there was 'ret' vtable method that was called to do some clean up ... ok >so that is not a question just some random thought. I don't quite understand where a vtable ret method would help. While sub things are gotten to via PMC, they're not 'real' PMCs as such. >4) Parrot_Coroutine's 'init' is not longer used and can go away, I guess >I could remove it in a future patch ... ok so that's not a question >either. Init needs some additions. We need an init parameter. I'll get to that this week. >On Thu, 2002-08-08 at 14:29, Jonathan Sillito wrote: >> # 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) { >> } >> */ >> } -- Dan --------------------------------------"it's like this"------------------- Dan Sugalski even samurai [EMAIL PROTECTED] have teddy bears and even teddy bears get drunk
