[svn:parrot] r42850 - branches/cs_csr_merge/src/call

bacek at svn.parrot.org bacek at svn.parrot.org
Wed Dec 2 09:17:15 UTC 2009


Author: bacek
Date: Wed Dec  2 09:17:14 2009
New Revision: 42850
URL: https://trac.parrot.org/parrot/changeset/42850

Log:
Copy CSR VTABLEs into src/call/args.c prepending csr_ prefix.

Modified:
   branches/cs_csr_merge/src/call/args.c

Modified: branches/cs_csr_merge/src/call/args.c
==============================================================================
--- branches/cs_csr_merge/src/call/args.c	Wed Dec  2 08:52:24 2009	(r42849)
+++ branches/cs_csr_merge/src/call/args.c	Wed Dec  2 09:17:14 2009	(r42850)
@@ -93,6 +93,34 @@
         __attribute__nonnull__(2);
 
 PARROT_CANNOT_RETURN_NULL
+static void ** csr_allocate_initial_values(PARROT_INTERP, ARGIN(PMC *self))
+        __attribute__nonnull__(1)
+        __attribute__nonnull__(2);
+
+static INTVAL csr_elements(PARROT_INTERP, ARGIN(PMC *self))
+        __attribute__nonnull__(1)
+        __attribute__nonnull__(2);
+
+PARROT_CANNOT_RETURN_NULL
+static void* csr_get_pointer_keyed_int(PARROT_INTERP,
+    ARGIN(PMC *self),
+    INTVAL key)
+        __attribute__nonnull__(1)
+        __attribute__nonnull__(2);
+
+static void csr_push_integer(PARROT_INTERP, ARGIN(PMC *self), INTVAL type)
+        __attribute__nonnull__(1)
+        __attribute__nonnull__(2);
+
+static void csr_set_pointer_keyed_int(PARROT_INTERP,
+    ARGIN(PMC *self),
+    INTVAL key,
+    ARGIN(void *value))
+        __attribute__nonnull__(1)
+        __attribute__nonnull__(2)
+        __attribute__nonnull__(4);
+
+PARROT_CANNOT_RETURN_NULL
 static void dissect_aggregate_arg(PARROT_INTERP,
     ARGMOD(PMC *call_object),
     ARGIN(PMC *aggregate))
@@ -350,6 +378,22 @@
 #define ASSERT_ARGS_clone_key_arg __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
        PARROT_ASSERT_ARG(interp) \
     , PARROT_ASSERT_ARG(key))
+#define ASSERT_ARGS_csr_allocate_initial_values __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
+       PARROT_ASSERT_ARG(interp) \
+    , PARROT_ASSERT_ARG(self))
+#define ASSERT_ARGS_csr_elements __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
+       PARROT_ASSERT_ARG(interp) \
+    , PARROT_ASSERT_ARG(self))
+#define ASSERT_ARGS_csr_get_pointer_keyed_int __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
+       PARROT_ASSERT_ARG(interp) \
+    , PARROT_ASSERT_ARG(self))
+#define ASSERT_ARGS_csr_push_integer __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
+       PARROT_ASSERT_ARG(interp) \
+    , PARROT_ASSERT_ARG(self))
+#define ASSERT_ARGS_csr_set_pointer_keyed_int __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
+       PARROT_ASSERT_ARG(interp) \
+    , PARROT_ASSERT_ARG(self) \
+    , PARROT_ASSERT_ARG(value))
 #define ASSERT_ARGS_dissect_aggregate_arg __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
        PARROT_ASSERT_ARG(interp) \
     , PARROT_ASSERT_ARG(call_object) \
@@ -2748,6 +2792,332 @@
 
 /*
 
+VTABLE functions from CallSignatureReturns. TODO Rename them appropriately.
+
+*/
+
+/* mask off lower two bits (1 + 2 = 3) for pointer tags */
+#define TAG_BITS 3
+#define UNTAG_CELL(c) INTVAL2PTR(void *, (PTR2INTVAL(c)) & ~TAG_BITS)
+#define CELL_TYPE_MASK(c) (PTR2INTVAL(c)) & TAG_BITS
+
+/*
+
+=item C<static void ** csr_allocate_initial_values(PARROT_INTERP, PMC *self)>
+
+Allocate initial storage for returns in CallSignature.
+
+=cut
+*/
+
+PARROT_CANNOT_RETURN_NULL
+static void **
+csr_allocate_initial_values(PARROT_INTERP, ARGIN(PMC *self))
+{
+    void **values = (void **)Parrot_gc_allocate_fixed_size_storage(interp,
+                                 8 * sizeof (void *));
+
+    SETATTR_CallSignature_returns_resize_threshold(interp, self, 8);
+    return values;
+}
+
+/*
+
+=item C<void csr_set_integer_native(INTVAL size)>
+
+Resizes the array to C<size> elements.
+
+=cut
+
+*/
+
+static void
+csr_set_integer_native(PARROT_INTERP, ARGIN(PMC *self), INTVAL size) {
+    void    **values = NULL;
+    INTVAL    resize_threshold;
+
+    GETATTR_CallSignature_returns_values(interp, self, values);
+    GETATTR_CallSignature_returns_resize_threshold(interp, self, resize_threshold);
+
+    /* Empty. Allocate 8 elements (arbitary number) */
+    if (!values) {
+        values = csr_allocate_initial_values(interp, self);
+        SETATTR_CallSignature_returns_values(interp, self, values);
+        SETATTR_CallSignature_returns_size(interp, self, size);
+    }
+    else if (size <= resize_threshold) {
+        SETATTR_CallSignature_returns_size(interp, self, size);
+        return;
+    }
+    else {
+        void   *old_values;
+        INTVAL  cur = resize_threshold;
+
+        /* Switch to system allocator */
+        if (cur == 8) {
+            old_values = values;
+            values     = mem_allocate_n_typed(8, void *);
+            memcpy(values, old_values, 8 * sizeof (void *));
+            Parrot_gc_free_fixed_size_storage(interp,
+                8 * sizeof (void *), old_values);
+        }
+
+        if (cur < 8192)
+            cur = size < 2 * cur ? 2 * cur : size;
+        else {
+            INTVAL needed = size - cur;
+            cur          += needed + 4096;
+            cur          &= ~0xfff;
+        }
+
+        mem_realloc_n_typed(values, cur, void *);
+
+        SETATTR_CallSignature_returns_values(interp, self, values);
+        SETATTR_CallSignature_returns_size(interp, self, size);
+        SETATTR_CallSignature_returns_resize_threshold(interp, self, cur);
+    }
+}
+
+/*
+
+=item C<static INTVAL csr_elements(PARROT_INTERP, PMC *self)>
+
+Returns the number of returns values.
+
+=cut
+
+*/
+
+static INTVAL
+csr_elements(PARROT_INTERP, ARGIN(PMC *self)) {
+    INTVAL size;
+    GETATTR_CallSignature_returns_size(interp, self, size);
+    return size;
+}
+
+/*
+
+=item C<static void csr_set_pointer_keyed_int(PARROT_INTERP, PMC *self, INTVAL
+key, void *value)>
+
+Sets the pointer at position key.  The pointer should point to a storage
+location for a return value -- it must be a pointer to an INTVAL, FLOATVAL,
+PMC, or STRING storage location.
+
+=cut
+
+*/
+
+static void
+csr_set_pointer_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key, ARGIN(void *value)) {
+    void   **values;
+    INTVAL   size;
+
+    GETATTR_CallSignature_returns_values(interp, self, values);
+    GETATTR_CallSignature_returns_size(interp,   self, size);
+
+    if (!values) {
+        if (key < 8) {
+            values = csr_allocate_initial_values(interp, self);
+            SETATTR_CallSignature_returns_values(interp, self, values);
+            SETATTR_CallSignature_returns_size(interp, self, key + 1);
+        }
+        else {
+            csr_set_integer_native(interp, self, key + 1);
+            GETATTR_CallSignature_returns_values(interp, self, values);
+        }
+    }
+    else if (key >= size)
+        csr_set_integer_native(interp, self, key + 1);
+
+    values[key] = value;
+}
+
+/*
+
+=item C<static void csr_push_integer(PARROT_INTERP, PMC *self, INTVAL type)>
+
+Set type of last pushed pointer.
+
+=cut
+
+*/
+
+static void
+csr_push_integer(PARROT_INTERP, ARGIN(PMC *self), INTVAL type) {
+    void  **values;
+    INTVAL  idx;
+
+    GETATTR_CallSignature_returns_size(interp, self, idx);
+
+    /* last index is size - 1, of course */
+    idx--;
+
+    PARROT_ASSERT((type >= 0 && type < 4) || !"Wrong pointer type");
+
+    GETATTR_CallSignature_returns_values(interp, self, values);
+
+    values[idx] = INTVAL2PTR(void *,
+        PTR2INTVAL(UNTAG_CELL(values[idx])) | type);
+}
+
+
+/*
+
+=item C<void csr_set_integer_keyed_int(INTVAL key, INTVAL value)>
+
+=item C<void csr_set_number_keyed_int(INTVAL key, FLOATVAL value)>
+
+=item C<void csr_set_string_keyed_int(INTVAL key, STRING *value)>
+
+=item C<void csr_set_pmc_keyed_int(INTVAL key, PMC *value)>
+
+Sets the value of the element at index C<key> to C<value>, casting if
+necessary.
+
+=cut
+
+*/
+
+static void
+csr_set_integer_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key, INTVAL value) {
+    void *cell = csr_get_pointer_keyed_int(interp, self, key);
+    void *ptr  = UNTAG_CELL(cell);
+
+    switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
+        case PARROT_ARG_INTVAL:
+            *(INTVAL *)ptr = value;
+            break;
+        case PARROT_ARG_FLOATVAL:
+            *(FLOATVAL *)ptr = value;
+            break;
+        case PARROT_ARG_STRING:
+            *(STRING **)ptr = Parrot_str_from_int(interp, value);
+            break;
+        case PARROT_ARG_PMC:
+            *(PMC **)ptr = get_integer_pmc(interp, value);
+            break;
+        default:
+            PARROT_ASSERT(!"Impossible type");
+    }
+}
+
+static void
+csr_set_number_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key, FLOATVAL value) {
+    void *cell = csr_get_pointer_keyed_int(interp, self, key);
+    void *ptr  = UNTAG_CELL(cell);
+
+    switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
+        case PARROT_ARG_INTVAL:
+            *(INTVAL *)ptr = value;
+            break;
+        case PARROT_ARG_FLOATVAL:
+            *(FLOATVAL *)ptr = value;
+            break;
+        case PARROT_ARG_STRING:
+            *(STRING **)ptr = Parrot_str_from_num(interp, value);
+            break;
+        case PARROT_ARG_PMC:
+            *(PMC **)ptr = get_number_pmc(interp, value);
+            break;
+        default:
+            PARROT_ASSERT(!"Impossible type");
+    }
+}
+
+static void
+csr_set_string_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key, STRING *value) {
+    void *cell = csr_get_pointer_keyed_int(interp, self, key);
+    void *ptr  = UNTAG_CELL(cell);
+
+    switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
+        case PARROT_ARG_INTVAL:
+            *(INTVAL *)ptr = Parrot_str_to_int(interp, value);
+            break;
+        case PARROT_ARG_FLOATVAL:
+            *(FLOATVAL *)ptr = Parrot_str_to_num(interp, value);
+            break;
+        case PARROT_ARG_STRING:
+            *(STRING **)ptr = value;
+            break;
+        case PARROT_ARG_PMC:
+            *(PMC **)ptr = STRING_IS_NULL(value) ?
+                PMCNULL :
+                get_string_pmc(interp, value);
+            break;
+        default:
+            PARROT_ASSERT(!"Impossible type");
+    }
+}
+
+static void
+csr_set_pmc_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key, PMC *value) {
+    void *cell = csr_get_pointer_keyed_int(interp, self, key);
+    void *ptr  = UNTAG_CELL(cell);
+
+    switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
+        case PARROT_ARG_INTVAL:
+            *(INTVAL *)ptr = VTABLE_get_integer(interp, value);
+            break;
+        case PARROT_ARG_FLOATVAL:
+            *(FLOATVAL *)ptr = VTABLE_get_number(interp, value);
+            break;
+        case PARROT_ARG_STRING:
+            *(STRING **)ptr = VTABLE_get_string(interp, value);
+            break;
+        case PARROT_ARG_PMC:
+            *(PMC **)ptr = value;
+            break;
+        default:
+            PARROT_ASSERT(!"Impossible type");
+    }
+}
+
+/*
+
+=item C<void *csr_get_string_keyed_int(INTVAL key)>
+
+Gets raw pointer for result.
+
+=cut
+
+*/
+
+PARROT_CANNOT_RETURN_NULL
+static STRING*
+csr_get_string_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key) {
+    void *cell  = csr_get_pointer_keyed_int(interp, self, key);
+    void *ptr   = UNTAG_CELL(cell);
+    return (STRING *)ptr;
+}
+
+
+/*
+
+=item C<static void* csr_get_pointer_keyed_int(PARROT_INTERP, PMC *self, INTVAL
+key)>
+
+Gets raw pointer for result.
+
+=cut
+
+*/
+
+PARROT_CANNOT_RETURN_NULL
+static void*
+csr_get_pointer_keyed_int(PARROT_INTERP, ARGIN(PMC *self), INTVAL key) {
+    void   **values;
+    INTVAL   size;
+
+    GETATTR_CallSignature_returns_size(interp, self, size);
+    PARROT_ASSERT((key < size) || !"Wrong index");
+
+    GETATTR_CallSignature_returns_values(interp, self, values);
+    return values[key];
+}
+
+/*
+
 =back
 
 =head1 SEE ALSO


More information about the parrot-commits mailing list