RPA Toolkit
added refreg datatype to handle assignment by value or reference.
authorMartin Stoilov <martin@rpasearch.com>
Fri, 5 Nov 2010 00:27:09 +0000 (17:27 -0700)
committerMartin Stoilov <martin@rpasearch.com>
Fri, 5 Nov 2010 00:27:09 +0000 (17:27 -0700)
30 files changed:
rlib/build/linux/rlib.mk
rlib/rarray.c
rlib/rarray.h
rlib/rharray.c
rlib/rharray.h
rlib/rhash.c
rlib/rhash.h
rlib/robject.c [new file with mode: 0644]
rlib/robject.h [new file with mode: 0644]
rlib/rref.c
rlib/rref.h
rlib/rstring.c
rlib/rstring.h
rvm/rrefreg.c
rvm/rrefreg.h
rvm/rvmcpu.c
rvm/rvmcpu.h
rvm/rvmoperator.c
rvm/rvmoperatoradd.c
rvm/rvmoperatorcat.c
rvm/rvmoperatordiv.c
rvm/rvmoperatormul.c
rvm/rvmoperatorsub.c
rvm/rvmreg.c
rvm/rvmreg.h
tests/build/linux/robject-tests.mk
tests/funcarg-test.c [new file with mode: 0644]
tests/opmap-test.c
tests/rharray-test.c
tests/string-test.c

index e00d640..f23fc89 100644 (file)
@@ -4,6 +4,7 @@ RLIB_SO = $(OUTDIR)/librlib.so.1.0
 
 RLIB_OBJECTS = \
        $(OUTDIR)/rref.o \
+       $(OUTDIR)/robject.o \
        $(OUTDIR)/rmem.o \
        $(OUTDIR)/ratomic.o \
        $(OUTDIR)/rspinlock.o \
index fae3985..4139436 100644 (file)
@@ -37,15 +37,15 @@ void r_array_destroy(rarray_t *array)
 }
 
 
-static void r_refstub_destroy(rref_t *ref)
+static void r_objectstub_destroy(robject_t *ptr)
 {
-       r_array_destroy((rarray_t*)ref);
+       r_array_destroy((rarray_t*)ptr);
 }
 
 
-static rref_t *r_refstub_copy(const rref_t *ptr)
+static robject_t *r_objectstub_copy(const robject_t *ptr)
 {
-       return (rref_t*) r_array_copy((const rarray_t*)ptr);
+       return (robject_t*) r_array_copy((const rarray_t*)ptr);
 }
 
 
@@ -70,7 +70,7 @@ rarray_t *r_array_create(ruint elt_size)
                r_array_destroy(array);
                return NULL;
        }
-       r_ref_init(&array->ref, 1, RREF_TYPE_COW, r_refstub_destroy, r_refstub_copy);
+       r_object_init(&array->obj, R_OBJECT_ARRAY, r_objectstub_destroy, r_objectstub_copy);
        return array;
 }
 
index 3c95ef3..c19c651 100644 (file)
@@ -2,7 +2,7 @@
 #define _RARRAY_H_
 
 #include "rtypes.h"
-#include "rref.h"
+#include "robject.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -12,7 +12,7 @@ typedef struct rarray_s rarray_t;
 typedef void (*r_array_callback)(rarray_t *array);
 
 struct rarray_s {
-       rref_t ref;
+       robject_t obj;
        rpointer *data;
        ruint len;
        ruint alloc_len;
index 679b80c..b73bc29 100644 (file)
  *
  */
 
-static void r_refstub_destroy(rref_t *ref)
+static void r_objectstub_destroy(robject_t *ptr)
 {
-       r_harray_destroy((rharray_t*)ref);
+       r_harray_destroy((rharray_t*)ptr);
 }
 
 
-static rref_t *r_refstub_copy(const rref_t *ptr)
+static robject_t *r_objectstub_copy(const robject_t *ptr)
 {
-       return (rref_t*) r_harray_copy((const rharray_t*)ptr);
+       return (robject_t*) r_harray_copy((const rharray_t*)ptr);
 }
 
 /*
@@ -84,7 +84,7 @@ rharray_t *r_harray_create(ruint elt_size)
        harray->names->ondestroy = r_array_ondestroy_rstr;
        harray->names->oncopy = r_array_oncopy_rstr;
        harray->hash = r_hash_create(5, r_hash_rstrequal, r_hash_rstrhash);
-       r_ref_init(&harray->ref, 1, RREF_TYPE_COW, r_refstub_destroy, r_refstub_copy);
+       r_object_init(&harray->obj, R_OBJECT_HARRAY, r_objectstub_destroy, r_objectstub_copy);
        return harray;
 }
 
@@ -105,7 +105,7 @@ rharray_t *r_harray_copy(const rharray_t *src)
                n = r_array_index(harray->names, i, rstr_t*);
                r_hash_insert_indexval(harray->hash, (rconstpointer)n, i);
        }
-       r_ref_init(&harray->ref, 1, RREF_TYPE_COW, r_refstub_destroy, r_refstub_copy);
+       r_object_init(&harray->obj, R_OBJECT_HARRAY, r_objectstub_destroy, r_objectstub_copy);
        return harray;
 }
 
index 5f32bcd..e87aecf 100644 (file)
@@ -5,7 +5,7 @@
 #include "rarray.h"
 #include "rhash.h"
 #include "rstring.h"
-#include "rref.h"
+#include "robject.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -14,7 +14,7 @@ extern "C" {
 
 
 typedef struct rharray_s {
-       rref_t ref;
+       robject_t obj;
        rarray_t *members;
        rarray_t *names;
        rhash_t *hash;
index 59e5da7..d0e9401 100644 (file)
@@ -87,15 +87,15 @@ rboolean r_hash_rstrequal(rconstpointer key1, rconstpointer key2)
 }
 
 
-static void r_refstub_destroy(rref_t *ref)
+static void r_objectstub_destroy(robject_t *ptr)
 {
-       r_hash_destroy((rhash_t*)ref);
+       r_hash_destroy((rhash_t*)ptr);
 }
 
 
-static rref_t *r_refstub_copy(const rref_t *ptr)
+static robject_t *r_objectstub_copy(const robject_t *ptr)
 {
-       return (rref_t*) r_hash_copy((const rhash_t*)ptr);
+       return (robject_t*) r_hash_copy((const rhash_t*)ptr);
 }
 
 
@@ -111,7 +111,7 @@ rhash_t *r_hash_create(ruint nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfun
                r_hash_destroy(hash);
                return NULL;
        }
-       r_ref_init(&hash->ref, 1, RREF_TYPE_COW, r_refstub_destroy, r_refstub_copy);
+       r_object_init(&hash->obj, R_OBJECT_HASH, r_objectstub_destroy, r_objectstub_copy);
        return hash;
 }
 
index 44d8601..a51a8be 100644 (file)
@@ -2,7 +2,7 @@
 #define _RHASH_H_
 
 #include "rtypes.h"
-#include "rref.h"
+#include "robject.h"
 #include "rlist.h"
 
 #ifdef __cplusplus
@@ -17,7 +17,7 @@ typedef ruint (*r_hash_hashfun)(rconstpointer key);
 
 
 struct rhash_s {
-       rref_t ref;
+       robject_t obj;
        rlist_t *buckets;
        ruint nbits;
        r_hash_equalfunc eqfunc;
diff --git a/rlib/robject.c b/rlib/robject.c
new file mode 100644 (file)
index 0000000..92589f2
--- /dev/null
@@ -0,0 +1,37 @@
+#include "robject.h"
+
+
+void r_object_init(robject_t *obj, ruint32 type, r_object_destroyfun destroy, r_object_copyfun copy)
+{
+       obj->type = type;
+       obj->destroy = destroy;
+       obj->copy = copy;
+}
+
+
+robject_t *r_object_copy(const robject_t *obj)
+{
+       if (obj->copy)
+               return obj->copy(obj);
+       return NULL;
+}
+
+
+void r_object_destroy(robject_t *obj)
+{
+       r_object_destroyfun destroy = obj->destroy;
+       if (destroy)
+               destroy(obj);
+}
+
+
+void r_object_typeset(robject_t *obj, ruint32 type)
+{
+       obj->type = type;
+}
+
+
+ruint32 r_object_typeget(robject_t *obj)
+{
+       return obj->type;
+}
diff --git a/rlib/robject.h b/rlib/robject.h
new file mode 100644 (file)
index 0000000..a4352b0
--- /dev/null
@@ -0,0 +1,41 @@
+#ifndef _ROBJECT_H_
+#define _ROBJECT_H_
+
+#include "rtypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define R_OBJECT_UNKNOWN 0
+#define R_OBJECT_STRING 1
+#define R_OBJECT_ARRAY 2
+#define R_OBJECT_HARRAY 3
+#define R_OBJECT_HASH 3
+#define R_OBJECT_REFREG 4
+#define R_OBJECT_USER 256
+
+
+typedef struct robject_s robject_t;
+typedef void (*r_object_destroyfun)(robject_t *ptr);
+typedef robject_t* (*r_object_copyfun)(const robject_t *ptr);
+
+struct robject_s {
+       ruint32 type;
+       r_object_destroyfun destroy;
+       r_object_copyfun copy;
+};
+
+robject_t *r_object_copy(const robject_t *obj);
+void r_object_destroy(robject_t *obj);
+void r_object_init(robject_t *obj, ruint32 type, r_object_destroyfun destroy, r_object_copyfun copy);
+void r_object_typeset(robject_t *obj, ruint32 type);
+ruint32 r_object_typeget(robject_t *obj);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
index 0326758..e31e54b 100644 (file)
@@ -1,12 +1,11 @@
 #include "rref.h"
 
 
-void r_ref_init(rref_t *ref, ruint32 count, rref_type_t type, r_ref_destroyfun destroy, r_ref_copyfun copy)
+void r_ref_init(rref_t *ref, ruint32 count, ruint32 objtype, rref_type_t type, r_object_destroyfun destroy, r_object_copyfun copy)
 {
+       r_object_init(&ref->obj, objtype, destroy, copy);
        ref->count = count;
        ref->type = type;
-       ref->destroy = destroy;
-       ref->copy = copy;
        r_spinlock_init(&ref->lock);
 }
 
@@ -30,8 +29,14 @@ ruint32 r_ref_dec(rref_t *ref)
        r_spinlock_lock(&ref->lock);
        if (ref->count) {
                ref->count -= 1;
-               if (!ref->count && ref->destroy) {
-                       ref->destroy(ref);
+               if (!ref->count) {
+                       /*
+                        * No body else should be waiting on the spinlock
+                        * as this was apparently the last reference. There is
+                        * no need to unlock, just destroy the object.
+                        */
+                       r_object_destroy((robject_t*)ref);
+                       return 0;
                }
        }
        count = ref->count;
@@ -46,14 +51,6 @@ ruint32 r_ref_get(rref_t *ref)
 }
 
 
-rref_t *r_ref_copy(const rref_t *ref)
-{
-       if (ref->copy)
-               return ref->copy(ref);
-       return NULL;
-}
-
-
 void r_ref_typeset(rref_t *ref, rref_type_t type)
 {
        ref->type = type;
index d49cbd8..c625d3c 100644 (file)
@@ -3,6 +3,7 @@
 
 
 #include "rtypes.h"
+#include "robject.h"
 #include "rspinlock.h"
 
 #ifdef __cplusplus
@@ -15,24 +16,20 @@ typedef enum {
 } rref_type_t;
 
 typedef struct rref_s rref_t;
-typedef void (*r_ref_destroyfun)(rref_t *ptr);
-typedef rref_t* (*r_ref_copyfun)(const rref_t *ptr);
 
 struct rref_s {
+       robject_t obj;
        ruint32 count;
        rref_type_t type;
        rspinlock_t lock;
-       r_ref_destroyfun destroy;
-       r_ref_copyfun copy;
 };
 
 ruint32 r_ref_inc(rref_t *ref);
 ruint32 r_ref_dec(rref_t *ref);
 ruint32 r_ref_get(rref_t *ref);
-rref_t *r_ref_copy(const rref_t *ref);
 void r_ref_typeset(rref_t *ref, rref_type_t type);
 rref_type_t r_ref_typeget(rref_t *ref);
-void r_ref_init(rref_t *ref, ruint32 count, rref_type_t type, r_ref_destroyfun destroy, r_ref_copyfun copy);
+void r_ref_init(rref_t *ref, ruint32 count, ruint32 objtype, rref_type_t type, r_object_destroyfun destroy, r_object_copyfun copy);
 
 
 #ifdef __cplusplus
index 31b372d..a8fa75c 100644 (file)
@@ -4,6 +4,7 @@
 #include "rstring.h"
 #include "rmem.h"
 
+
 rint r_strcmp(const rchar *s1, const rchar *s2)
 {
        return strcmp(s1, s2);
@@ -78,15 +79,15 @@ rstr_t *r_rstrdup(const rchar *s, ruint size)
 }
 
 
-static void r_refstub_destroy(rref_t *ref)
+static void r_objectstub_destroy(robject_t *ptr)
 {
-       r_string_destroy((rstring_t*)ref);
+       r_string_destroy((rstring_t*)ptr);
 }
 
 
-static rref_t *r_refstub_copy(const rref_t *ptr)
+static robject_t *r_objectstub_copy(const robject_t *ptr)
 {
-       return (rref_t*) r_string_copy((const rstring_t*)ptr);
+       return (robject_t*) r_string_copy((const rstring_t*)ptr);
 }
 
 
@@ -99,7 +100,7 @@ rstring_t *r_string_create()
                r_string_destroy(string);
                return NULL;
        }
-       r_ref_init(&string->ref, 1, RREF_TYPE_COW, r_refstub_destroy, r_refstub_copy);
+       r_object_init(&string->obj, R_OBJECT_STRING, r_objectstub_destroy, r_objectstub_copy);
        return string;
 
 }
index 6950048..93106d1 100644 (file)
@@ -3,6 +3,7 @@
 
 
 #include "rtypes.h"
+#include "robject.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -31,7 +32,7 @@ rstr_t *r_rstrdup(const rchar *s, ruint size);
 
 
 typedef struct rstring_s {
-       rref_t ref;
+       robject_t obj;
        rstr_t s;
 } rstring_t;
 
index 2d04326..bfe6e06 100644 (file)
@@ -1,30 +1,57 @@
 #include "rrefreg.h"
-
+#include "rmem.h"
 
 rrefreg_t *r_refreg_create()
 {
-
-       return NULL;
+       rrefreg_t *refreg = (rrefreg_t*)r_malloc(sizeof(*refreg));
+       if (!refreg)
+               return NULL;
+       return r_refreg_init(refreg);
 }
 
 
-rrefreg_t *r_refreg_init(rrefreg_t *refreg)
+rrefreg_t *r_refreg_copy(const rrefreg_t* src)
 {
+       rrefreg_t *refreg = r_refreg_create();
+       if (!refreg)
+               return NULL;
+       rvm_reg_copy(&refreg->reg, &refreg->reg);
+       return refreg;
+}
 
-       return NULL;
+
+void r_refreg_cleanup(rrefreg_t *refreg)
+{
+       rvm_reg_cleanup(&refreg->reg);
 }
 
 
-rrefreg_t *r_refreg_copy(const rrefreg_t *refreg)
+void r_refreg_destroy(rrefreg_t *refreg)
 {
+       if (refreg) {
+               r_refreg_cleanup(refreg);
+               r_free(refreg);
+       }
+}
+
 
-       return NULL;
+static void r_object_destroy_stub(robject_t *ptr)
+{
+       if (ptr)
+               r_refreg_destroy((rrefreg_t*)ptr);
 }
 
 
-void r_refreg_destroy(rrefreg_t *refreg)
+static robject_t *r_object_copy_stub(const robject_t *ptr)
 {
+       return (robject_t*) r_refreg_copy((const rrefreg_t*)ptr);
+}
 
 
+rrefreg_t *r_refreg_init(rrefreg_t *refreg)
+{
+       r_memset(refreg, 0, sizeof(*refreg));
+       r_ref_init(&refreg->ref, 1, R_OBJECT_REFREG, RREF_TYPE_COW, r_object_destroy_stub, r_object_copy_stub);
+       return refreg;
 }
 
index f561b23..1a9ea55 100644 (file)
@@ -2,23 +2,24 @@
 #define _RREFREG_H_
 
 #include "rvmcpu.h"
+#include "rvmreg.h"
 #include "rref.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 typedef struct rrefreg_s {
        rref_t ref;
        rvmreg_t reg;
 } rrefreg_t;
 
-
+#define REFREG2REG(__p__) ((rrefreg_t*)(__p__))->reg
+#define REFREG2REGPTR(__p__) &REFREG2REG(__p__)
 rrefreg_t *r_refreg_create();
-rrefreg_t *r_refreg_init(rrefreg_t *refreg);
-rrefreg_t *r_refreg_copy(const rrefreg_t *refreg);
 void r_refreg_destroy(rrefreg_t *refreg);
+rrefreg_t *r_refreg_init(rrefreg_t *refreg);
+rrefreg_t *r_refreg_copy(const rrefreg_t* src);
 
 
 #ifdef __cplusplus
index 55b6292..27bb0b2 100644 (file)
@@ -997,7 +997,7 @@ rvm_asmins_t rvm_asmd(rword opcode, rword op1, rword op2, rword op3, rdouble dat
        a.op2 = (unsigned char)op2;
        a.op3 = (unsigned char)op3;
        RVM_REG_GETD(&a.data) = data;
-       rvm_reg_settype(&a.data, RVM_DTYPE_DOUBLE);
+       RVM_REG_SETTYPE(&a.data, RVM_DTYPE_DOUBLE);
        return a;
 }
 
@@ -1012,7 +1012,7 @@ rvm_asmins_t rvm_asmp(rword opcode, rword op1, rword op2, rword op3, rpointer da
        a.op2 = (unsigned char)op2;
        a.op3 = (unsigned char)op3;
        RVM_REG_GETP(&a.data) = data;
-       rvm_reg_settype(&a.data, RVM_DTYPE_POINTER);
+       RVM_REG_SETTYPE(&a.data, RVM_DTYPE_POINTER);
        return a;
 }
 
@@ -1027,7 +1027,7 @@ rvm_asmins_t rvm_asmu(rword opcode, rword op1, rword op2, rword op3, rword data)
        a.op2 = (unsigned char)op2;
        a.op3 = (unsigned char)op3;
        RVM_REG_GETU(&a.data) = data;
-       rvm_reg_settype(&a.data, RVM_DTYPE_WORD);
+       RVM_REG_SETTYPE(&a.data, RVM_DTYPE_WORD);
        return a;
 }
 
@@ -1042,7 +1042,7 @@ rvm_asmins_t rvm_asml(rword opcode, rword op1, rword op2, rword op3, rlong data)
        a.op2 = (unsigned char)op2;
        a.op3 = (unsigned char)op3;
        RVM_REG_GETL(&a.data) = (rword)data;
-       rvm_reg_settype(&a.data, RVM_DTYPE_LONG);
+       RVM_REG_SETTYPE(&a.data, RVM_DTYPE_LONG);
        return a;
 }
 
@@ -1063,7 +1063,7 @@ rvm_asmins_t rvm_asmr(rword opcode, rword op1, rword op2, rword op3, rpointer pR
        a.op2 = (unsigned char)op2;
        a.op3 = (unsigned char)op3;
        RVM_REG_GETP(&a.data) = pReloc;
-       rvm_reg_settype(&a.data, RVM_DTYPE_RELOCPTR);
+       RVM_REG_SETTYPE(&a.data, RVM_DTYPE_RELOCPTR);
        return a;
 }
 
@@ -1078,7 +1078,7 @@ rvm_asmins_t rvm_asmx(rword opcode, rword op1, rword op2, rword op3, rpointer pR
        a.op2 = (unsigned char)op2;
        a.op3 = (unsigned char)op3;
        RVM_REG_GETP(&a.data) = pReloc;
-       rvm_reg_settype(&a.data, RVM_DTYPE_RELOCINDEX);
+       RVM_REG_SETTYPE(&a.data, RVM_DTYPE_RELOCINDEX);
        return a;
 }
 
@@ -1096,69 +1096,14 @@ void rvm_relocate(rvm_asmins_t *code, rsize_t size)
        rulong off;
 
        for (off = 0; off < size; off++, code++) {
-               if (RVM_REG_INFO(&code->data) == RVM_DTYPE_RELOCPTR) {
-                       RVM_REG_INFO(&code->data) = 0;
+               if (RVM_REG_GETTYPE(&code->data) == RVM_DTYPE_RELOCPTR) {
+                       RVM_REG_SETTYPE(&code->data, RVM_DTYPE_NONE);
                        reloc = *((rvm_asmins_t **)RVM_REG_GETP(&code->data));
                        RVM_REG_GETU(&code->data) = reloc - code;
-               } else if (RVM_REG_INFO(&code->data) == RVM_DTYPE_RELOCINDEX) {
-                       RVM_REG_INFO(&code->data) = 0;
+               } else if (RVM_REG_GETTYPE(&code->data) == RVM_DTYPE_RELOCINDEX) {
+                       RVM_REG_SETTYPE(&code->data, RVM_DTYPE_NONE);
                        relocindex = *((rulong *)RVM_REG_GETP(&code->data));
                        RVM_REG_GETU(&code->data) = relocindex - off;
                }
        }
 }
-
-
-void rvm_reg_settype(rvmreg_t *r, ruint type)
-{
-       r->info &= ~RVM_DTYPE_MASK;
-       r->info |= type & RVM_DTYPE_MASK;
-}
-
-
-ruint rvm_reg_gettype(rvmreg_t *r)
-{
-       return (r->info & RVM_DTYPE_MASK);
-}
-
-
-void rvm_reg_setinfo(rvmreg_t *r, ruint info)
-{
-       r->info = info;
-}
-
-
-ruint rvm_reg_getinfo(rvmreg_t *r)
-{
-       return r->info;
-}
-
-
-rboolean rvm_reg_flagtst(rvmreg_t *r, ruint32 flag)
-{
-       return (r->info & flag) ? TRUE : FALSE;
-}
-
-
-void rvm_reg_flagset(rvmreg_t *r, ruint32 flag)
-{
-       r->info |= flag;
-}
-
-
-void rvm_reg_flagclr(rvmreg_t *r, ruint32 flag)
-{
-       r->info &= ~flag;
-}
-
-
-void rvm_reg_setlong(rvmreg_t *r, rlong l)
-{
-       RVM_REG_SETL(r, l);
-}
-
-
-void rvm_reg_setdouble(rvmreg_t *r, rdouble d)
-{
-       RVM_REG_SETD(r, d);
-}
index 9fdc783..214643e 100644 (file)
@@ -42,7 +42,7 @@ enum {
        RVM_ADC,                /* Add: op1 = op2 + op3 + C, update the status register */
        RVM_AND,                /* Bitwise AND: op1 = op2 & op3, update status register */
        RVM_BIC,                /* Bit Clear: op1 = op2 & ~op3, update status register */
-       RVM_CLZ,                /* Count Leading Zeros: op1 = leading_zeros(op2) */
+       RVM_CLZ,                /* Count rvm_reg_settypeLeading Zeros: op1 = leading_zeros(op2) */
        RVM_CMN,                /* Compare Negative: status register is updated based on the result: op1 + op2 */
        RVM_EOR,                /* XOR: op1 = op2 ^ op3, update the status register */
        RVM_SUB,
@@ -95,7 +95,8 @@ enum {
 };
 
 
-#define RVM_DTYPE_WORD 0
+#define RVM_DTYPE_NONE 0
+#define RVM_DTYPE_WORD RVM_DTYPE_NONE
 #define RVM_DTYPE_LONG 1
 #define RVM_DTYPE_DOUBLE 2
 #define RVM_DTYPE_BOOLEAN 3
@@ -103,7 +104,7 @@ enum {
 #define RVM_DTYPE_STRING 5
 #define RVM_DTYPE_ARRAY 6
 #define RVM_DTYPE_HARRAY 7
-#define RVM_DTYPE_REFPTR 8                     /* Reference pointer, points to another rvmreg_t value */
+#define RVM_DTYPE_REFREG 8                     /* Reference pointer, points to another rrefreg_t object */
 #define RVM_DTYPE_POINTER 9                    /* Generic pointer, it can point to any memory object */
 #define RVM_DTYPE_RELOCPTR 14          /* Relocation, using pointers */
 #define RVM_DTYPE_RELOCINDEX 15                /* Relocation, using offsets */
@@ -113,9 +114,9 @@ enum {
 #define RVM_DTYPE_MAX (RVM_DTYPE_MASK)
 #define RVM_DTYPE_USERDEF(__n__) (RVM_DTYPE_USER + (__n__))
 
-#define RVM_INFOBIT_ALL ((ruint32)-1)
-#define RVM_INFOBIT_REFOBJECT (1 << 8)
-
+#define RVM_INFOBIT_ROBJECT (1 << 0)
+#define RVM_INFOBIT_LAST (1 << 15)
+#define RVM_INFOBIT_ALL (RVM_INFOBIT_ROBJECT | RVM_INFOBIT_LAST)
 
 #define RVM_REGISTER_BITS (8 * sizeof(rword))
 #define RVM_SIGN_BIT (1LU << (RVM_REGISTER_BITS - 1))
@@ -169,42 +170,48 @@ do { \
 #define RVM_CPUREG_GET(__cpu__, __r__) (__cpu__)->r[(__r__)]
 #define RVM_CPUREG_SET(__cpu__, __r__, __val__) do { (__cpu__)->r[(__r__)] = (rvmreg_t)(__val__); } while (0)
 
+#define RVM_REG_GETTYPE(__r__) (__r__)->type
+#define RVM_REG_SETTYPE(__r__, __val__) do { (__r__)->type = (__val__); } while(0);
+#define RVM_CPUREG_GETTYPE(__cpu__, __r__) RVM_CPUREG_GETTYPE(RVM_CPUREG_PTR(__cpu__, __r__))
+#define RVM_CPUREG_SETTYPE(__cpu__, __r__, __val__) RVM_REG_SETTYPE(RVM_CPUREG_PTR(__cpu__, __r__), __val__)
+
+#define RVM_REG_TSTFLAG(__r__, __flag__) ((__r__)->flags & (__flag__)) ? TRUE : FALSE
+#define RVM_REG_SETFLAG(__r__, __flag__) do { (__r__)->flags |= (__flag__); } while (0)
+#define RVM_REG_CLRFLAG(__r__, __flag__) do { (__r__)->flags &= ~(__flag__); } while (0)
+#define RVM_CPUREG_GETFLAG(__cpu__, __r__, __flag__) RVM_REG_TSTFLAG(RVM_CPUREG_PTR(__cpu__, __r__), __flag__)
+#define RVM_CPUREG_SETFLAG(__cpu__, __r__, __flag__) RVM_REG_SETFLAG(RVM_CPUREG_PTR(__cpu__, __r__), __flag__)
+#define RVM_CPUREG_CLRFLAG(__cpu__, __r__, __flag__) RVM_REG_CLRFLAG(RVM_CPUREG_PTR(__cpu__, __r__), __flag__)
+
 #define RVM_REG_GETU(__r__) (__r__)->v.w
-#define RVM_REG_SETU(__r__, __val__) do { (__r__)->v.w = (rword)(__val__); rvm_reg_setinfo((__r__), RVM_DTYPE_WORD);} while (0)
+#define RVM_REG_SETU(__r__, __val__) do { (__r__)->v.w = (rword)(__val__); } while (0)
 #define RVM_CPUREG_GETU(__cpu__, __r__) RVM_CPUREG_PTR(__cpu__, __r__)->v.w
 #define RVM_CPUREG_SETU(__cpu__, __r__, __val__) RVM_REG_SETU(RVM_CPUREG_PTR(__cpu__, __r__), __val__)
 
 #define RVM_REG_GETL(__r__) (__r__)->v.l
-#define RVM_REG_SETL(__r__, __val__) do { (__r__)->v.l = (rlong)(__val__); rvm_reg_setinfo((__r__), RVM_DTYPE_LONG);} while (0)
+#define RVM_REG_SETL(__r__, __val__) do { (__r__)->v.l = (rlong)(__val__); } while (0)
 #define RVM_CPUREG_GETL(__cpu__, __r__) RVM_CPUREG_PTR(__cpu__, __r__)->v.l
 #define RVM_CPUREG_SETL(__cpu__, __r__, __val__) RVM_REG_SETL(RVM_CPUREG_PTR(__cpu__, __r__), __val__)
 
 #define RVM_REG_GETP(__r__) (__r__)->v.p
-#define RVM_REG_SETP(__r__, __val__) do { (__r__)->v.p = (rpointer)(__val__); rvm_reg_setinfo((__r__), RVM_DTYPE_POINTER);} while (0)
+#define RVM_REG_SETP(__r__, __val__) do { (__r__)->v.p = (rpointer)(__val__); } while (0)
 #define RVM_CPUREG_GETP(__cpu__, __r__) RVM_CPUREG_PTR(__cpu__, __r__)->v.p
 #define RVM_CPUREG_SETP(__cpu__, __r__, __val__) RVM_REG_SETP(RVM_CPUREG_PTR(__cpu__, __r__), __val__)
 
 #define RVM_REG_GETD(__r__) (__r__)->v.d
-#define RVM_REG_SETD(__r__, __val__) do { (__r__)->v.d = (rdouble)(__val__); rvm_reg_setinfo((__r__), RVM_DTYPE_DOUBLE);} while (0)
+#define RVM_REG_SETD(__r__, __val__) do { (__r__)->v.d = (rdouble)(__val__); } while (0)
 #define RVM_CPUREG_GETD(__cpu__, __r__) RVM_CPUREG_PTR(__cpu__, __r__)->v.d
 #define RVM_CPUREG_SETD(__cpu__, __r__, __val__) RVM_REG_SETD(RVM_CPUREG_PTR(__cpu__, __r__), __val__)
 
 #define RVM_REG_GETIP(__r__) (rvm_asmins_t*)((__r__)->v.p)
-#define RVM_REG_SETIP(__r__, __val__) do { (__r__)->v.p = (rpointer)(__val__); rvm_reg_setinfo((__r__), RVM_DTYPE_POINTER);} while (0)
+#define RVM_REG_SETIP(__r__, __val__) do { (__r__)->v.p = (rpointer)(__val__); } while (0)
 #define RVM_CPUREG_GETIP(__cpu__, __r__) ((rvm_asmins_t*)RVM_CPUREG_PTR(__cpu__, __r__)->v.p)
 #define RVM_CPUREG_SETIP(__cpu__, __r__, __val__) RVM_REG_SETIP(RVM_CPUREG_PTR(__cpu__, __r__), __val__)
 #define RVM_CPUREG_INCIP(__cpu__, __r__, __val__) do {rvm_asmins_t *p = RVM_CPUREG_GETIP(__cpu__, __r__); (__cpu__)->r[(__r__)].v.p = (rpointer)(p + (__val__)); } while (0)
 
-#define RVM_REG_SETPVAL(__r__, __ptr__, __info__) do { (__r__)->v.p = (rpointer)(__ptr__); rvm_reg_setinfo((__r__), __info__);} while (0)
-#define RVM_REG_SETSTR(__r__, __ptr__) do { RVM_REG_SETPVAL((__r__), (__ptr__), RVM_INFOBIT_REFOBJECT|RVM_DTYPE_STRING);} while (0)
-#define RVM_REG_SETARRAY(__r__, __ptr__) do { RVM_REG_SETPVAL((__r__), (__ptr__), RVM_INFOBIT_REFOBJECT|RVM_DTYPE_ARRAY);} while (0)
-#define RVM_REG_SETHARRAY(__r__, __ptr__) do { RVM_REG_SETPVAL((__r__), (__ptr__), RVM_INFOBIT_REFOBJECT|RVM_DTYPE_HARRAY);} while (0)
-
-#define RVM_REG_INFO(__r__) (__r__)->info
 #define RVM_REG_SIZE(__r__) (__r__)->size
-#define RVM_REG_REF(__r__) do { if (rvm_reg_flagtst((__r__), RVM_INFOBIT_REFOBJECT)) r_ref_inc((rref_t*)RVM_REG_GETP(__r__));} while (0)
-#define RVM_REG_UNREF(__r__) do { if (rvm_reg_flagtst((__r__), RVM_INFOBIT_REFOBJECT)) r_ref_dec((rref_t*)RVM_REG_GETP(__r__));} while (0)
-#define RVM_REG_CLEAR(__r__) do { (__r__)->v.w = 0UL;  rvm_reg_setinfo((__r__), 0); } while (0)
+//#define RVM_REG_REF(__r__) do { if (rvm_reg_gettype(__r__) == RVM_DTYPE_REFREG) r_ref_inc((rref_t*)RVM_REG_GETP(__r__));} while (0)
+//#define RVM_REG_UNREF(__r__) do { if (rvm_reg_gettype(__r__) == RVM_DTYPE_REFREG) r_ref_dec((rref_t*)RVM_REG_GETP(__r__));} while (0)
+#define RVM_REG_CLEAR(__r__) do { (__r__)->v.w = 0UL; (__r__)->type = 0; (__r__)->flags = 0;  } while (0)
 
 #define RVM_SWI_TABLE(__op__) ((__op__) >> 16)
 #define RVM_SWI_NUM(__op__) ((__op__) & ((1 << 16) - 1))
@@ -236,7 +243,8 @@ typedef struct rvmreg_s {
                rdouble d;
                ruint8 c[RVM_MIN_REGSIZE];
        } v;
-       ruint32 info;
+       ruint16 type;
+       ruint16 flags;
        ruint32 size;
 } rvmreg_t;
 
@@ -277,15 +285,6 @@ rvm_asmins_t rvm_asmr(rword opcode, rword op1, rword op2, rword op3, rpointer pR
 rvm_asmins_t rvm_asmx(rword opcode, rword op1, rword op2, rword op3, rpointer pReloc);
 rvm_asmins_t rvm_asmd(rword opcode, rword op1, rword op2, rword op3, rdouble data);
 void rvm_asm_dump(rvm_asmins_t *pi, ruint count);
-void rvm_reg_settype(rvmreg_t *r, ruint type);
-ruint rvm_reg_gettype(rvmreg_t *r);
-void rvm_reg_setinfo(rvmreg_t *r, ruint info);
-ruint rvm_reg_getinfo(rvmreg_t *r);
-rboolean rvm_reg_flagtst(rvmreg_t *r, ruint32 flag);
-void rvm_reg_flagset(rvmreg_t *r, ruint32 flag);
-void rvm_reg_flagclr(rvmreg_t *r, ruint32 flag);
-void rvm_reg_setlong(rvmreg_t *r, rlong l);
-void rvm_reg_setdouble(rvmreg_t *r, rdouble d);
 
 
 #ifdef __cplusplus
index 83ced21..e272b80 100644 (file)
@@ -83,7 +83,7 @@ void rvm_opmap_invoke_binary_handler(rvm_opmap_t *opmap, rushort opid, rvmcpu_t
 {
        rvm_ophandler_t *h;
        rvm_opinfo_t *opinfo;
-       ruint index = RVM_OP_HANDLER(arg1->info & RVM_DTYPE_MASK, arg2->info & RVM_DTYPE_MASK);
+       ruint index = RVM_OP_HANDLER(RVM_REG_GETTYPE(arg1), RVM_REG_GETTYPE(arg2));
 
        if (opid >= opmap->operators->len)
                goto error;
@@ -104,7 +104,7 @@ void rvm_opmap_invoke_unary_handler(rvm_opmap_t *opmap, rushort opid, rvmcpu_t *
 {
        rvm_ophandler_t *h;
        rvm_opinfo_t *opinfo;
-       ruint index = RVM_UNARY_HANDLER(arg->info & RVM_DTYPE_MASK);
+       ruint index = RVM_UNARY_HANDLER(RVM_REG_GETTYPE(arg));
 
        if (opid >= opmap->operators->len)
                goto error;
index 39ac764..eb79993 100644 (file)
@@ -1,4 +1,5 @@
 #include "rvmoperatoradd.h"
+#include "rvmreg.h"
 
 
 void rvm_op_add_long_long(rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg1, const rvmreg_t *arg2)
index bd451bc..e279a72 100644 (file)
@@ -1,15 +1,17 @@
 #include "rvmoperatorcat.h"
 #include "rstring.h"
+#include "rvmreg.h"
 
 
 void rvm_op_cat_string_string(rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg1, const rvmreg_t *arg2)
 {
-       rstring_t *s1 = (rstring_t*)arg1->v.p;
-       rstring_t *s2 = (rstring_t*)arg2->v.p;
+       rstring_t *s1 = (rstring_t*)RVM_REG_GETP(arg1);
+       rstring_t *s2 = (rstring_t*)RVM_REG_GETP(arg2);
        rstring_t *dst;
 
        dst = r_string_create_from_rstr(&s1->s);
        r_string_cat(dst, &s2->s);
-       RVM_REG_UNREF(res);
-       RVM_REG_SETSTR(res, dst);
+       RVM_REG_SETP(res, dst);
+       rvm_reg_setflag(res, RVM_DTYPE_STRING);
+       rvm_reg_setflag(res, RVM_INFOBIT_ROBJECT);
 }
index 988fc56..ae15a7f 100644 (file)
@@ -1,4 +1,5 @@
 #include "rvmoperatordiv.h"
+#include "rvmreg.h"
 
 
 void rvm_op_div_long_long(rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg1, const rvmreg_t *arg2)
index 261a7d4..b6b5146 100644 (file)
@@ -1,4 +1,5 @@
 #include "rvmoperatormul.h"
+#include "rvmreg.h"
 
 
 void rvm_op_mul_long_long(rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg1, const rvmreg_t *arg2)
index 72d0391..e8ff3c8 100644 (file)
@@ -1,4 +1,5 @@
 #include "rvmoperatorsub.h"
+#include "rvmreg.h"
 
 
 void rvm_op_sub_long_long(rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg1, const rvmreg_t *arg2)
index a5de6d9..7f58097 100644 (file)
@@ -1,18 +1,17 @@
+#include "rmem.h"
 #include "rvmreg.h"
+#include "rrefreg.h"
+#include "rref.h"
 
 
 static void r_array_oncopy_rvmreg(rarray_t *array)
 {
        ruint index;
-       ruint info;
        rvmreg_t *r;
 
-
        for (index = 0; index < array->len; index++) {
                r = (rvmreg_t *)r_array_slot(array, index);
-               info = rvm_reg_getinfo(r);
-               if (rvm_reg_flagtst(r, RVM_INFOBIT_REFOBJECT))
-                       RVM_REG_SETPVAL(r, r_ref_copy(RVM_REG_GETP(r)), info);
+               rvm_reg_copy(r, r);
        }
 }
 
@@ -22,13 +21,9 @@ static void r_array_ondestroy_rvmreg(rarray_t *array)
        ruint index;
        rvmreg_t *r;
 
-
        for (index = 0; index < array->len; index++) {
                r = (rvmreg_t *)r_array_slot(array, index);
-               if (rvm_reg_flagtst(r, RVM_INFOBIT_REFOBJECT)) {
-                       r_ref_dec(RVM_REG_GETP(r));
-                       RVM_REG_CLEAR(r);
-               }
+               rvm_reg_cleanup(r);
        }
 }
 
@@ -58,7 +53,10 @@ rharray_t *r_harray_create_rvmreg()
 rvmreg_t rvm_reg_create_string_ansi(const rchar *s)
 {
        rvmreg_t r;
-       RVM_REG_SETSTR(&r, r_string_create_from_ansistr(s));
+       r_memset(&r, 0, sizeof(r));
+       RVM_REG_SETP(&r, r_string_create_from_ansistr(s));
+       RVM_REG_SETTYPE(&r, RVM_DTYPE_STRING);
+       RVM_REG_SETFLAG(&r, RVM_INFOBIT_ROBJECT);
        return r;
 }
 
@@ -66,7 +64,20 @@ rvmreg_t rvm_reg_create_string_ansi(const rchar *s)
 rvmreg_t rvm_reg_create_string(const rstr_t *s)
 {
        rvmreg_t r;
-       RVM_REG_SETSTR(&r, r_string_create_from_rstr(s));
+       r_memset(&r, 0, sizeof(r));
+       RVM_REG_SETP(&r, r_string_create_from_rstr(s));
+       RVM_REG_SETTYPE(&r, RVM_DTYPE_STRING);
+       RVM_REG_SETFLAG(&r, RVM_INFOBIT_ROBJECT);
+       return r;
+}
+
+rvmreg_t rvm_reg_create_refreg()
+{
+       rvmreg_t r;
+       r_memset(&r, 0, sizeof(r));
+       RVM_REG_SETP(&r, r_refreg_create());
+       RVM_REG_SETTYPE(&r, RVM_DTYPE_REFREG);
+       RVM_REG_SETFLAG(&r, RVM_INFOBIT_ROBJECT);
        return r;
 }
 
@@ -74,7 +85,8 @@ rvmreg_t rvm_reg_create_string(const rstr_t *s)
 rvmreg_t rvm_reg_create_array()
 {
        rvmreg_t r;
-       RVM_REG_SETARRAY(&r, r_array_create_rvmreg());
+       r_memset(&r, 0, sizeof(r));
+       rvm_reg_setarray(&r, r_array_create_rvmreg());
        return r;
 }
 
@@ -82,15 +94,41 @@ rvmreg_t rvm_reg_create_array()
 rvmreg_t rvm_reg_create_harray()
 {
        rvmreg_t r;
-       RVM_REG_SETHARRAY(&r, r_harray_create_rvmreg());
+       r_memset(&r, 0, sizeof(r));
+       rvm_reg_setharray(&r, r_harray_create_rvmreg());
        return r;
 }
 
+void rvm_reg_setstring(rvmreg_t *r, rstring_t *ptr)
+{
+       RVM_REG_SETP(r, ptr);
+       RVM_REG_SETTYPE(r, RVM_DTYPE_STRING);
+       RVM_REG_SETFLAG(r, RVM_INFOBIT_ROBJECT);
+}
+
+
+void rvm_reg_setarray(rvmreg_t *r, rarray_t *ptr)
+{
+       RVM_REG_SETP(r, ptr);
+       RVM_REG_SETTYPE(r, RVM_DTYPE_ARRAY);
+       RVM_REG_SETFLAG(r, RVM_INFOBIT_ROBJECT);
+}
+
+
+void rvm_reg_setharray(rvmreg_t *r, rharray_t *ptr)
+{
+       RVM_REG_SETP(r, ptr);
+       RVM_REG_SETTYPE(r, RVM_DTYPE_HARRAY);
+       RVM_REG_SETFLAG(r, RVM_INFOBIT_ROBJECT);
+}
+
 
 rvmreg_t rvm_reg_create_double(rdouble d)
 {
        rvmreg_t r;
+       r_memset(&r, 0, sizeof(r));
        RVM_REG_SETD(&r, d);
+       RVM_REG_SETTYPE(&r, RVM_DTYPE_DOUBLE);
        return r;
 }
 
@@ -98,6 +136,108 @@ rvmreg_t rvm_reg_create_double(rdouble d)
 rvmreg_t rvm_reg_create_long(rlong l)
 {
        rvmreg_t r;
-       RVM_REG_SETL(&r, l);
+       r_memset(&r, 0, sizeof(r));
+       rvm_reg_setlong(&r, l);
        return r;
 }
+
+
+void rvm_reg_cleanup(rvmreg_t *reg)
+{
+       if (rvm_reg_gettype(reg) == RVM_DTYPE_REFREG)
+               r_ref_dec((rref_t*)RVM_REG_GETP(reg));
+       else if (rvm_reg_tstflag(reg, RVM_INFOBIT_ROBJECT)) {
+               r_object_destroy((robject_t*)RVM_REG_GETP(reg));
+       }
+       RVM_REG_CLEAR(reg);
+}
+
+
+rvmreg_t *rvm_reg_copy(rvmreg_t *dst, const rvmreg_t *src)
+{
+       if (dst != src)
+               *dst = *src;
+       if (rvm_reg_tstflag(dst, RVM_INFOBIT_ROBJECT))
+               dst->v.p = r_object_copy(dst->v.p);
+       return dst;
+}
+
+
+rvmreg_t *rvm_reg_refer(rvmreg_t *dst, const rvmreg_t *src)
+{
+       if (rvm_reg_gettype(dst) == RVM_DTYPE_REFREG) {
+               if (dst != src)
+                       *dst = *src;
+               r_ref_inc((rref_t*)RVM_REG_GETP(dst));
+               return dst;
+       }
+       return NULL;
+}
+
+
+void rvm_reg_settype(rvmreg_t *r, ruint type)
+{
+       RVM_REG_SETTYPE(r, type);
+}
+
+
+ruint rvm_reg_gettype(const rvmreg_t *r)
+{
+       return RVM_REG_GETTYPE(r);
+}
+
+
+rboolean rvm_reg_tstflag(const rvmreg_t *r, ruint16 flag)
+{
+       return RVM_REG_TSTFLAG(r, flag);
+}
+
+
+void rvm_reg_setflag(rvmreg_t *r, ruint16 flag)
+{
+       RVM_REG_SETFLAG(r, flag);
+}
+
+
+void rvm_reg_clrflag(rvmreg_t *r, ruint16 flag)
+{
+       RVM_REG_CLRFLAG(r, flag);
+}
+
+
+void rvm_reg_setlong(rvmreg_t *r, rlong l)
+{
+       RVM_REG_SETL(r, l);
+       RVM_REG_SETTYPE(r, RVM_DTYPE_LONG);
+       RVM_REG_CLRFLAG(r, RVM_INFOBIT_ALL);
+}
+
+
+void rvm_reg_setdouble(rvmreg_t *r, rdouble d)
+{
+       RVM_REG_SETD(r, d);
+       RVM_REG_SETTYPE(r, RVM_DTYPE_DOUBLE);
+       RVM_REG_CLRFLAG(r, RVM_INFOBIT_ALL);
+
+}
+
+
+void rvm_reg_setrefreg(rvmreg_t *r, struct rrefreg_s *ptr)
+{
+       RVM_REG_SETP(r, ptr);
+       RVM_REG_SETTYPE(r, RVM_DTYPE_REFREG);
+       RVM_REG_SETFLAG(r, RVM_INFOBIT_ROBJECT);
+}
+
+
+void rvm_reg_convert_to_refreg(rvmreg_t *reg)
+{
+       rrefreg_t * refreg = NULL;
+
+       if (rvm_reg_gettype(reg) == RVM_DTYPE_REFREG)
+               return;
+       refreg = r_refreg_create();
+       *REFREG2REGPTR(refreg) = *reg;
+       RVM_REG_CLEAR(reg);
+       rvm_reg_setrefreg(reg, refreg);
+}
index 068124e..aae6782 100644 (file)
@@ -2,22 +2,45 @@
 #define _RVMREG_H_
 
 #include "rvmcpu.h"
+#include "robject.h"
 #include "rarray.h"
 #include "rharray.h"
+#include "rstring.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+
+/* Create array with rvmreg elements */
 rarray_t *r_array_create_rvmreg();
+/* Create harray with rvmreg elements */
 rharray_t *r_harray_create_rvmreg();
 
 rvmreg_t rvm_reg_create_string_ansi(const rchar *s);
 rvmreg_t rvm_reg_create_string(const rstr_t *s);
 rvmreg_t rvm_reg_create_array();
 rvmreg_t rvm_reg_create_harray();
+rvmreg_t rvm_reg_create_refreg();
 rvmreg_t rvm_reg_create_double(rdouble d);
 rvmreg_t rvm_reg_create_long(rlong l);
+void rvm_reg_cleanup(rvmreg_t *reg);
+rvmreg_t *rvm_reg_copy(rvmreg_t *dst, const rvmreg_t *src);
+rvmreg_t *rvm_reg_refer(rvmreg_t *dst, const rvmreg_t *src);
+void rvm_reg_settype(rvmreg_t *r, ruint type);
+ruint rvm_reg_gettype(const rvmreg_t *r);
+rboolean rvm_reg_tstflag(const rvmreg_t *r, ruint16 flag);
+void rvm_reg_setflag(rvmreg_t *r, ruint16 flag);
+void rvm_reg_clrflag(rvmreg_t *r, ruint16 flag);
+void rvm_reg_setlong(rvmreg_t *r, rlong l);
+void rvm_reg_setdouble(rvmreg_t *r, rdouble d);
+void rvm_reg_setstring(rvmreg_t *r, rstring_t *ptr);
+void rvm_reg_setarray(rvmreg_t *r, rarray_t *ptr);
+void rvm_reg_setharray(rvmreg_t *r, rharray_t *ptr);
+void rvm_reg_convert_to_refreg(rvmreg_t *r);
+
+struct rrefreg_s;
+void rvm_reg_setrefreg(rvmreg_t *r, struct rrefreg_s *ptr);
 
 
 #ifdef __cplusplus
index e9d9e82..38d7051 100644 (file)
@@ -10,6 +10,7 @@ LIBS += -lrvm -lrlib -lpthread --static
 
 
 TESTS  = \
+       $(OUTDIR)/funcarg-test \
        $(OUTDIR)/codegen-test \
        $(OUTDIR)/codemap-test \
        $(OUTDIR)/opmap-test \
diff --git a/tests/funcarg-test.c b/tests/funcarg-test.c
new file mode 100644 (file)
index 0000000..3368305
--- /dev/null
@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "rrefreg.h"
+#include "rvmcpu.h"
+#include "rvmcodegen.h"
+#include "rvmcodemap.h"
+
+
+static void test_swi_print_r(rvmcpu_t *cpu, rvm_asmins_t *ins)
+{
+       rvmreg_t *r = RVM_CPUREG_PTR(cpu, ins->op2);
+
+       if (rvm_reg_gettype(r) == RVM_DTYPE_REFREG)
+               r = REFREG2REGPTR(RVM_REG_GETP(r));
+       if (rvm_reg_gettype(r) == RVM_DTYPE_WORD)
+               fprintf(stdout, "R%d = %ld\n", ins->op2, RVM_REG_GETL(r));
+       else if (rvm_reg_gettype(r) == RVM_DTYPE_LONG)
+               fprintf(stdout, "R%d = %ld\n", ins->op2, RVM_REG_GETL(r));
+       else if (rvm_reg_gettype(r) == RVM_DTYPE_DOUBLE)
+               fprintf(stdout, "R%d = %5.2f\n", ins->op2, RVM_REG_GETD(r));
+       else if (rvm_reg_gettype(r) == RVM_DTYPE_STRING)
+               fprintf(stdout, "R%d = %s\n", ins->op2, ((rstring_t*) RVM_REG_GETP(r))->s.str);
+       else
+               fprintf(stdout, "R%d = Unknown type\n", ins->op2);
+}
+
+
+static rvm_switable_t switable[] = {
+               {"print", test_swi_print_r},
+               {NULL, NULL},
+};
+
+
+int main(int argc, char *argv[])
+{
+       rvmcpu_t *cpu;
+       rvm_codegen_t *cg;
+       ruint ntable;
+
+       cg = rvm_codegen_create();
+       cpu = rvm_cpu_create();
+       ntable = rvmcpu_switable_add(cpu, switable);
+
+       rvm_codemap_invalid_add_s(cg->codemap, "add2");
+
+       rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 7));
+       rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
+       rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 8));
+       rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
+       rvm_codegen_addins(cg, rvm_asmx(RVM_BL,  DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "add2")->index));
+       rvm_codegen_addins(cg, rvm_asm(RVM_SWI, DA, R0, XX, rvm_cpu_getswi(cpu, "print")));
+
+       rvm_codegen_addins(cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
+
+       rvm_codegen_funcstart_s(cg, "add2", 2);
+       rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R0, FP, DA, 1));
+       rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R1, FP, DA, 2));
+       rvm_codegen_addins(cg, rvm_asm(RVM_ADD, R0, R0, R1, 0));
+       rvm_codegen_funcend(cg);
+
+       rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
+       rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
+       rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
+
+       rvm_relocate(rvm_codegen_getcode(cg, 0), rvm_codegen_getcodesize(cg));
+
+
+//     rvm_asm_dump(rvm_codegen_getcode(cg, 0), rvm_codegen_getcodesize(cg));
+
+       rvm_cpu_exec_debug(cpu, rvm_codegen_getcode(cg, 0), 0);
+       rvm_cpu_destroy(cpu);
+       rvm_codegen_destroy(cg);
+
+
+       fprintf(stdout, "It works!\n");
+       return 0;
+}
index eb22289..b528501 100644 (file)
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "rvmcpu.h"
+#include "rvmreg.h"
 #include "rvmoperator.h"
 #include "rvmoperatoradd.h"
 #include "rvmoperatorsub.h"
index c8b035b..976fea5 100644 (file)
@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include "rvmcodegen.h"
 #include "rvmreg.h"
+#include "rrefreg.h"
 
 #include "rstring.h"
 #include "rmem.h"
 
 static void test_swi_print_r(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
-       if (rvm_reg_gettype(RVM_CPUREG_PTR(cpu, ins->op2)) == RVM_DTYPE_LONG)
-               fprintf(stdout, "R%d = %ld\n", ins->op2, RVM_CPUREG_GETL(cpu, ins->op2));
-       else if (rvm_reg_gettype(RVM_CPUREG_PTR(cpu, ins->op2)) == RVM_DTYPE_DOUBLE)
-               fprintf(stdout, "R%d = %5.2f\n", ins->op2, RVM_CPUREG_GETD(cpu, ins->op2));
-       else if (rvm_reg_gettype(RVM_CPUREG_PTR(cpu, ins->op2)) == RVM_DTYPE_STRING)
-               fprintf(stdout, "R%d = %s\n", ins->op2, ((rstring_t*) RVM_CPUREG_GETP(cpu, ins->op2))->s.str);
+       rvmreg_t *r = RVM_CPUREG_PTR(cpu, ins->op2);
+
+       if (rvm_reg_gettype(r) == RVM_DTYPE_REFREG)
+               r = REFREG2REGPTR(RVM_REG_GETP(r));
+       if (rvm_reg_gettype(r) == RVM_DTYPE_LONG)
+               fprintf(stdout, "R%d = %ld\n", ins->op2, RVM_REG_GETL(r));
+       else if (rvm_reg_gettype(r) == RVM_DTYPE_DOUBLE)
+               fprintf(stdout, "R%d = %5.2f\n", ins->op2, RVM_REG_GETD(r));
+       else if (rvm_reg_gettype(r) == RVM_DTYPE_STRING)
+               fprintf(stdout, "R%d = %s\n", ins->op2, ((rstring_t*) RVM_REG_GETP(r))->s.str);
        else
                fprintf(stdout, "R%d = Unknown type\n", ins->op2);
 }
@@ -24,8 +29,7 @@ static void test_swi_print_r(rvmcpu_t *cpu, rvm_asmins_t *ins)
 
 static void test_swi_unref(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
-       if (rvm_reg_flagtst(RVM_CPUREG_PTR(cpu, ins->op2), RVM_INFOBIT_REFOBJECT))
-               r_ref_dec((rref_t*)RVM_CPUREG_GETP(cpu, ins->op2));
+
 }
 
 
@@ -38,7 +42,7 @@ static rvm_switable_t switable[] = {
 
 int main(int argc, char *argv[])
 {
-       rvmreg_t ag, rh, rt;
+       rvmreg_t ag, rh, rt, rh_copy;
        rharray_t *na, *nc;
        rvm_codegen_t *cg;
        rhash_node_t *node;
@@ -51,25 +55,29 @@ int main(int argc, char *argv[])
        ag = rvm_reg_create_double(4.55);
        rh = rvm_reg_create_string_ansi("Hello World");
        rt = rvm_reg_create_long(55);
+       rvm_reg_convert_to_refreg(&rh);
+       rvm_reg_refer(&rh_copy, &rh);
+
 
        na = r_harray_create_rvmreg();
        r_harray_add_s(na, "again", &ag);
-       r_harray_add_s(na, "again", &rh);
        r_harray_add_s(na, "hello", &rh);
+       r_harray_add_s(na, "hellocopy", &rh_copy);
        r_harray_add_s(na, "there", NULL);
        r_harray_set(na, r_harray_lookup_s(na, "there"), &rt);
-       nc = (rharray_t*)r_ref_copy(&na->ref);
+       nc = (rharray_t*)r_object_copy(&na->obj);
 
        fprintf(stdout, "lookup 'missing': %ld\n", r_harray_lookup_s(nc, "missing"));
        for (node = r_harray_nodelookup_s(nc, NULL, "again"); node; node = r_harray_nodelookup_s(nc, node, "again"))
                fprintf(stdout, "lookup 'again': %ld\n", r_hash_indexval(node));
        fprintf(stdout, "lookup 'hello': %ld\n", r_harray_lookup_s(nc, "hello"));
+       fprintf(stdout, "lookup 'hellocopy': %ld\n", r_harray_lookup_s(nc, "hellocopy"));
        fprintf(stdout, "lookup 'there': %ld\n", r_harray_lookup_s(nc, "there"));
 
        /*
         * Load the content of rh to R0
         */
-       rvm_codegen_addins(cg, rvm_asmp(RVM_LDRR, R0, DA, XX, &rh));
+       rvm_codegen_addins(cg, rvm_asmp(RVM_LDRR, R0, DA, XX, &rh_copy));
 
        /*
         * Lookup the array member "again" and load the content to R1
@@ -91,8 +99,9 @@ int main(int argc, char *argv[])
        rvm_codegen_destroy(cg);
 
 
-       r_ref_dec((rref_t*)na);
-       r_ref_dec((rref_t*)nc);
+//     rvm_reg_cleanup(&rh_copy);
+       r_object_destroy((robject_t*)na);
+       r_object_destroy((robject_t*)nc);
        fprintf(stdout, "Max alloc mem: %ld\n", r_debug_get_maxmem());
        fprintf(stdout, "Leaked mem: %ld\n", r_debug_get_allocmem());
        return 0;
index 0015224..8aa2dfe 100644 (file)
@@ -4,6 +4,7 @@
 #include "rstring.h"
 #include "rmem.h"
 #include "rvmcpu.h"
+#include "rvmreg.h"
 #include "rvmoperator.h"
 #include "rvmoperatoradd.h"
 #include "rvmoperatorsub.h"
@@ -39,19 +40,13 @@ static void test_swi_print_r(rvmcpu_t *cpu, rvm_asmins_t *ins)
 
 static void test_swi_strinit(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
-       char *p = (char*) RVM_CPUREG_GETP(cpu, ins->op2);
-       long size = RVM_CPUREG_GETL(cpu, ins->op3);
-       rstr_t str = {p, size};
-       RVM_CPUREG_SETP(cpu, R0, (void*)r_string_create_from_rstr(&str));
-       rvm_reg_flagset(RVM_CPUREG_PTR(cpu, R0), RVM_INFOBIT_REFOBJECT);
-       rvm_reg_settype(RVM_CPUREG_PTR(cpu, R0), RVM_DTYPE_STRING);
+
 }
 
 
 static void test_swi_unref(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
-       if (rvm_reg_flagtst(RVM_CPUREG_PTR(cpu, ins->op2), RVM_INFOBIT_REFOBJECT))
-               r_ref_dec((rref_t*)RVM_CPUREG_GETP(cpu, ins->op2));
+
 }