RPA Toolkit
changed the swi interface, mostly search/replace
authorMartin Stoilov <martin@rpasearch.com>
Mon, 28 Mar 2011 06:04:21 +0000 (23:04 -0700)
committerMartin Stoilov <martin@rpasearch.com>
Mon, 28 Mar 2011 06:04:21 +0000 (23:04 -0700)
45 files changed:
rpa2/rpavm.c
rvm/rvmcpu.c
rvm/rvmcpu.h
testrpa2/common.h
testrpa2/rpacompiler-altexp.c
testrpa2/rpacompiler-class.c
testrpa2/rpacompiler-exp.c
testrpa2/rpacompiler-minusexp.c
testrpa2/rpacompiler-notexp.c
testrpa2/rpacompiler-rule.c
testrpa2/rpacompiler-rulealtrec.c
testrpa2/rpacompiler-ruleloop.c
testrpa2/rpacompiler-ruleloopcls.c
testrpa2/rpacompiler-rulerec.c
testrpa2/rpavm-matchchr.c
testrpa2/rpavm-matchrng.c
testrpa2/rpavm-mnode.c
tests/asm-add.c
tests/asm-adds.c
tests/asm-b.c
tests/asm-bitops.c
tests/asm-bl.c
tests/asm-callback.c
tests/asm-cast.c
tests/asm-clz.c
tests/asm-cmp.c
tests/asm-div.c
tests/asm-eadd.c
tests/asm-ecmp.c
tests/asm-esub.c
tests/asm-loadstore.c
tests/asm-mul.c
tests/asm-sbc.c
tests/asm-shiftops.c
tests/asm-stack.c
tests/codegen-test.c
tests/common.h
tests/funcarg-test.c
tests/loop-test.c
tests/regex-test.c
tests/rharray-test.c
tests/rpagen-test.c
tests/rvm-test.c
tests/speed-test.c
tests/string-test.c

index 41b8699..f4137b4 100644 (file)
@@ -543,7 +543,7 @@ static rvm_switable_t rpavm_swi_table[] = {
 rvmcpu_t *rpavm_cpu_create(rulong stacksize)
 {
        rvmcpu_t *cpu = rvm_cpu_create(stacksize);
-       rint tableid = rvm_cpu_addswitable(cpu, rpavm_swi_table);
+       rint tableid = rvm_cpu_addswitable(cpu, "rpavm_swi_table", rpavm_swi_table);
 
        if (tableid != RPAVM_SWI_TABLEID) {
                rpavm_cpu_destroy(cpu);
index ef39791..41c3ae5 100644 (file)
@@ -715,9 +715,9 @@ static void rvm_op_swi(rvmcpu_t *cpu, rvm_asmins_t *ins)
        ruint ntable = (ruint) RVM_SWI_TABLE(ins->swi);
        ruint nswi = (ruint) RVM_SWI_NUM(ins->swi);
 
-       if (r_array_length(cpu->switables) <= ntable)
+       if (r_harray_length(cpu->switables) <= ntable)
                RVM_ABORT(cpu, RVM_E_SWITABLE);
-       switable = r_array_index(cpu->switables, ntable, rvm_switable_t*);
+       switable = r_harray_index(cpu->switables, ntable, rvm_switable_t*);
        swi = switable[nswi].op;
        swi(cpu, ins);
 }
@@ -730,9 +730,9 @@ static void rvm_op_swiid(rvmcpu_t *cpu, rvm_asmins_t *ins)
        ruint ntable = (ruint) RVM_SWI_TABLE(RVM_CPUREG_GETU(cpu, ins->op1));
        ruint nswi = (ruint) RVM_SWI_NUM(RVM_CPUREG_GETU(cpu, ins->op1));
 
-       if (r_array_length(cpu->switables) <= ntable)
+       if (r_harray_length(cpu->switables) <= ntable)
                RVM_ABORT(cpu, RVM_E_SWITABLE);
-       switable = r_array_index(cpu->switables, ntable, rvm_switable_t*);
+       switable = r_harray_index(cpu->switables, ntable, rvm_switable_t*);
        swi = switable[nswi].op;
        swi(cpu, ins);
 }
@@ -1147,8 +1147,8 @@ int rvm_asm_dump_pi_to_str(rvmcpu_t *vm, rvm_asmins_t *pi, char *str, ruint size
                        ruint ntable = (ruint) RVM_SWI_TABLE(pi->swi);
                        ruint nswi = (ruint) RVM_SWI_NUM(pi->swi);
 
-                       if (ntable < r_array_length(vm->switables)) {
-                               switable = r_array_index(vm->switables, ntable, rvm_switable_t*);
+                       if (ntable < r_harray_length(vm->switables)) {
+                               switable = r_harray_index(vm->switables, ntable, rvm_switable_t*);
                                rvm_snprintf(szSwi, sizeof(szSwi) - 1, "(%s)",  switable[nswi].name ? switable[nswi].name : "unknown");
                        }
                }
@@ -1920,7 +1920,7 @@ rvmcpu_t *rvm_cpu_create(rulong stacksize)
                return ((void*)0);
        r_memset(cpu, 0, sizeof(*cpu));
        cpu->stacksize = stacksize;
-       cpu->switables = r_array_create(sizeof(rvm_switable_t*));
+       cpu->switables = r_harray_create(sizeof(rvm_switable_t*));
        cpu->stack = r_malloc(stacksize * sizeof(rvmreg_t));
        cpu->data = r_carray_create(sizeof(rvmreg_t));
        cpu->opmap = rvm_opmap_create();
@@ -1999,39 +1999,34 @@ rint rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off)
 }
 
 
-rint rvm_cpu_getswi(rvmcpu_t *cpu, const rchar *swiname, rsize_t size)
+rint rvm_cpu_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size)
 {
-       rint ntable, nswi;
+       rint nswi;
        rvm_switable_t *swientry;
+       rlong ntable = r_harray_lookup_s(cpu->switables, tabname);
 
-       for (ntable = 0; ntable < r_array_length(cpu->switables); ntable++) {
-               swientry = r_array_index(cpu->switables, ntable, rvm_switable_t*);
-               for (nswi = 0; swientry[nswi].name; nswi++) {
-                       if (r_strncmp(swientry[nswi].name, swiname, size) == 0 && r_strlen(swientry[nswi].name) == size)
-                               return (rint)RVM_SWI_ID(ntable, nswi);
-               }
+       if (ntable < 0)
+               return -1;
+       swientry = r_harray_index(cpu->switables, ntable, rvm_switable_t*);
+       if (!swientry)
+               return -1;
+       for (nswi = 0; swientry[nswi].name; nswi++) {
+               if (r_strncmp(swientry[nswi].name, swiname, size) == 0 && r_strlen(swientry[nswi].name) == size)
+                       return (rint)RVM_SWI_ID(ntable, nswi);
        }
-
        return -1;
 }
 
 
-rint rvm_cpu_getswi_s(rvmcpu_t *cpu, const rchar *swiname)
+rint rvm_cpu_swilookup_s(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname)
 {
-       return rvm_cpu_getswi(cpu, swiname, r_strlen(swiname));
+       return rvm_cpu_swilookup(cpu, tabname, swiname, r_strlen(swiname));
 }
 
 
-rint rvm_cpu_addswitable(rvmcpu_t *cpu, rvm_switable_t *switable)
+rint rvm_cpu_addswitable(rvmcpu_t *cpu, const rchar *tabname, rvm_switable_t *switable)
 {
-       rint nswi;
-
-       for (nswi = 0; switable[nswi].name; nswi++) {
-               if (rvm_cpu_getswi_s(cpu, switable[nswi].name) >= 0)
-                       return -1;
-       }
-
-       return r_array_add(cpu->switables, &switable);
+       return r_harray_replace_s(cpu->switables, tabname, &switable);
 }
 
 
index f9155bf..1cf147d 100644 (file)
@@ -311,7 +311,7 @@ struct rvmcpu_s {
        rword status;
        rword error;
        rword abort;
-       rarray_t *switables;
+       rharray_t *switables;
        rulong stacksize;
        void *stack;
        rcarray_t *data;
@@ -331,11 +331,11 @@ struct rvmcpu_s {
 rvmcpu_t *rvm_cpu_create_default();
 rvmcpu_t *rvm_cpu_create(rulong stacksize);
 void rvm_cpu_destroy(rvmcpu_t * vm);
-rint rvm_cpu_addswitable(rvmcpu_t * cpu, rvm_switable_t *switalbe);
 rint rvm_cpu_exec(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
 rint rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
-rint rvm_cpu_getswi(rvmcpu_t *cpu, const rchar *swiname, rsize_t size);
-rint rvm_cpu_getswi_s(rvmcpu_t *cpu, const rchar *swiname);
+rint rvm_cpu_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size);
+rint rvm_cpu_swilookup_s(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname);
+rint rvm_cpu_addswitable(rvmcpu_t * cpu, const rchar *tabname, rvm_switable_t *switalbe);
 rvmreg_t *rvm_cpu_alloc_global(rvmcpu_t *cpu);
 int rvm_cpu_setreg(rvmcpu_t *cpu, rword regnum, const rvmreg_t *src);
 rvmreg_t *rvm_cpu_getreg(rvmcpu_t *cpu, rword regnum);
index f3ad3be..f00a240 100644 (file)
@@ -8,13 +8,13 @@
        do { rvm_codegen_addins(code, rvm_asm(RVM_MOV, R8, DA, XX, reg)); \
                 rvm_codegen_addins(code, rvm_asm(RVM_MOV, R9, DA, XX, val)); \
                 rvm_codegen_addins(code, rvm_asmp(RVM_MOV, R10, DA, XX, msg)); \
-                rvm_codegen_addins(code, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(stat->cpu, "rvm_vmtest_check_reg")), XX, XX, R0, 0)); \
+                rvm_codegen_addins(code, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(stat->cpu, "common_table", "rvm_vmtest_check_reg")), XX, XX, R0, 0)); \
                 rvm_codegen_addins(code, rvm_asm(RVM_NOP, XX, XX, XX, 0)); } while (0)
 
 #define VMTEST_STATUS(code, val, msg) \
        do { rvm_codegen_addins(code, rvm_asm(RVM_MOV, R9, DA, XX, val)); \
                 rvm_codegen_addins(code, rvm_asmp(RVM_MOV, R10, DA, XX, msg)); \
-                rvm_codegen_addins(code, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(stat->cpu, "rvm_vmtest_check_status")), XX, XX, R0, 0)); \
+                rvm_codegen_addins(code, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(stat->cpu, "common_table", "rvm_vmtest_check_status")), XX, XX, R0, 0)); \
                 rvm_codegen_addins(code, rvm_asm(RVM_NOP, XX, XX, XX, 0)); } while (0)
 
 
index 28fb9e8..150927e 100644 (file)
@@ -80,7 +80,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index c1f9ab0..4957fe8 100644 (file)
@@ -126,7 +126,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index f1d5b05..1ece701 100644 (file)
@@ -149,7 +149,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index 59410e8..e188fd5 100644 (file)
@@ -89,7 +89,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index 0adba8c..3fc7704 100644 (file)
@@ -149,7 +149,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index e64c038..b0c4ce4 100644 (file)
@@ -102,7 +102,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index f63b477..6352724 100644 (file)
@@ -136,7 +136,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+30);
 
index 83d552b..18b57d6 100644 (file)
@@ -119,7 +119,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+50);
 
index 828412d..5afa470 100644 (file)
@@ -298,7 +298,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        mainoff = rvm_codegen_addins(co->cg, rvm_asml(RVM_NOP, XX, XX, XX, -1));
 
index d7736e7..bfea3c8 100644 (file)
@@ -78,7 +78,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index 70ff15b..a0d80bb 100644 (file)
@@ -67,7 +67,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+3);
 
index 4b2d8e1..6125a71 100644 (file)
@@ -65,7 +65,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+3);
 
index 343a4a8..111795f 100644 (file)
@@ -129,7 +129,7 @@ int main(int argc, char *argv[])
 
        co = rpa_compiler_create();
        stat = rpa_stat_create(NULL, 4096);
-       rvm_cpu_addswitable(stat->cpu, common_calltable);
+       rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
 
        rpa_stat_init(stat, teststr, teststr, teststr+12);
 
index fc5379e..06d3cf4 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
        vmcode[off++] = rvm_asm(RVM_ADD, R0, R1, R0, 0);
index 9f1d99d..84c14dd 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, -2);
        vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, -3);
index 13ae247..fba9eee 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
        vmcode[off++] = rvm_asm(RVM_B,   DA, XX, XX, 3);
        vmcode[off++] = rvm_asm(RVM_ADD, R0, R0, R1, 0);
index 89c0532..0ee7475 100644 (file)
@@ -9,7 +9,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 1);
index 280e533..255d6ee 100644 (file)
@@ -15,7 +15,7 @@ int main(int argc, char *argv[])
        rvm_codemap_t *codemap = rvm_codemap_create();
        rvm_relocmap_t *relocmap = rvm_relocmap_create();
 
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
        rvm_relocmap_add(relocmap, RVM_RELOC_BRANCH, off, rvm_codemap_lookup_s(codemap, "l_main"));
        vmcode[off++]   = rvm_asm(RVM_B,   DA, XX, XX, 0);
index 1633997..607e750 100644 (file)
@@ -30,18 +30,18 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
 
-       table1 = rvm_cpu_addswitable(vm, calltable);
-       table2 = rvm_cpu_addswitable(vm, calltable);
-       table3 = rvm_cpu_addswitable(vm, calltable);
-       if (table2 != -1 || table3 != -1) {
+       table1 = rvm_cpu_addswitable(vm, "calltable", calltable);
+       table2 = rvm_cpu_addswitable(vm, "calltable", calltable);
+       table3 = rvm_cpu_addswitable(vm, "calltable", calltable);
+       if (table2 != 0 || table3 != 0) {
                fprintf(stdout, "rvm_cpu_addswitable: FAILED\n");
        }
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
        vmcode[off++] = rvm_asm(RVM_ADD, R0, R1, R0, 0);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_callback_one")), XX, XX, XX, 0);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_callback_two")), XX, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "calltable", "rvm_callback_one")), XX, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "calltable", "rvm_callback_two")), XX, XX, XX, 0);
        vmcode[off++] = rvm_asm(RVM_OPSWI(RVM_SWI_ID(table1, 0)), XX, XX, XX, 0);
        vmcode[off++] = rvm_asm(RVM_EXT, R0, XX, XX, 0);
        fprintf(stdout, "sizeof rvm_asmins_t is: %d:\n", (unsigned int) sizeof(rvm_asmins_t));
index 7a1faa3..a47f2a7 100644 (file)
@@ -38,26 +38,26 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
-       rvm_cpu_addswitable(vm, switable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
+       rvm_cpu_addswitable(vm, "switable", switable);
        vmcode[off++] = rvm_asmp(RVM_LDRR, R0, DA, XX, &d1);
        vmcode[off++] = rvm_asm(RVM_TYPE, R1, R0, XX, 0);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "print")), R1, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "switable", "print")), R1, XX, XX, 0);
        vmcode[off++] = rvm_asm(RVM_CAST, R0, R0, DA, RVM_DTYPE_UNSIGNED);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
        vmcode[off++] = rvm_asm(RVM_ADD, R0, R1, R0, 0);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "print")), R0, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "switable", "print")), R0, XX, XX, 0);
        VMTEST_REG(vmcode, off, 0, 3, "CAST");
        VMTEST_STATUS(vmcode, off, 0, "CAST STATUS");
 
        vmcode[off++] = rvm_asmp(RVM_LDRR, R0, DA, XX, &d2);
        vmcode[off++] = rvm_asm(RVM_TYPE, R1, R0, XX, 0);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "print")), R1, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "switable", "print")), R1, XX, XX, 0);
        vmcode[off++] = rvm_asm(RVM_CAST, R0, R0, DA, RVM_DTYPE_LONG);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "print")), R0, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "switable", "print")), R0, XX, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
        vmcode[off++] = rvm_asm(RVM_ADD, R0, R1, R0, 0);
-       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "print")), R0, XX, XX, 0);
+       vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "switable", "print")), R0, XX, XX, 0);
        VMTEST_REG(vmcode, off, 0, 1, "CAST");
        VMTEST_STATUS(vmcode, off, 0, "CAST STATUS");
 
index cc35608..7e6c829 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_CLZ, R0, R0, XX, 0);
index 5b62191..0277af7 100644 (file)
@@ -9,7 +9,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 2);
index fd949b6..4198c32 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 3);
        vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_DIV, R0, R1, R2, 0);
index ae0cd9e..9558ea3 100644 (file)
@@ -14,7 +14,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
 
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
index 4f19306..6f6dadd 100644 (file)
@@ -12,7 +12,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 8);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 1);
index 49d8d54..eb7a23e 100644 (file)
@@ -15,7 +15,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
        vmcode[off++] = rvm_asmp(RVM_LDRR, R1, DA, XX, &d1s);
index 6430261..30f66ad 100644 (file)
@@ -11,7 +11,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
 
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asmp(RVM_LDR, R0, DA, XX, &s);
        VMTEST_REG(vmcode, off, 0, -2, "LDR");
        vmcode[off++] = rvm_asmp(RVM_LDRB, R0, DA, XX, &s);
index bf09c38..f75da20 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 3);
        vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_MUL, R0, R1, R2, 0);
index 56b18c5..2a57408 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 3);
        vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_SBC, R0, R1, R2, 0);
index fe34365..6adb1bf 100644 (file)
@@ -10,7 +10,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[256];
        rvmcpu_t *vm = rvm_cpu_create_default();
        
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 1);
        vmcode[off++] = rvm_asm(RVM_LSL, R0, R1, DA, 3);
        vmcode[off++] = rvm_asm(RVM_LSR, R0, R0, DA, 3);
index 5c4c44b..9bc46b5 100644 (file)
@@ -9,7 +9,7 @@ int main(int argc, char *argv[])
        rvm_asmins_t vmcode[1024];
        rvmcpu_t *vm = rvm_cpu_create_default();
 
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
        vmcode[off++] = rvm_asm(RVM_PUSH, DA, XX, XX, 1);
        vmcode[off++] = rvm_asm(RVM_PUSH, DA, XX, XX, 2);
        vmcode[off++] = rvm_asm(RVM_POP, R1, XX, XX, 0);
index 2ca9e5e..a71dcbf 100644 (file)
@@ -26,7 +26,7 @@ int main(int argc, char *argv[])
 
        cg = rvm_codegen_create();
        cpu = rvm_cpu_create_default();
-       ntable = rvm_cpu_addswitable(cpu, switable);
+       ntable = rvm_cpu_addswitable(cpu, "switable", switable);
 
        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));
index 086dba6..7410e61 100644 (file)
@@ -9,7 +9,7 @@
                 code[index++] = rvm_asm(RVM_MOV, R9, DA, XX, val); \
                 code[index++] = rvm_asm(RVM_PRN, reg, XX, XX, 0); \
                 code[index++] = rvm_asmp(RVM_MOV, R10, DA, XX, msg); \
-                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
+                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "common_table", "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
                 code[index++] = rvm_asm(RVM_NOP, XX, XX, XX, 0); } while (0)
 
 #define VMTEST_REGL(code, index, reg, val, msg) \
@@ -17,7 +17,7 @@
                 code[index++] = rvm_asml(RVM_MOV, R9, DA, XX, val); \
                 code[index++] = rvm_asm(RVM_PRN, reg, XX, XX, 0); \
                 code[index++] = rvm_asmp(RVM_MOV, R10, DA, XX, msg); \
-                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
+                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "common_table", "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
                 code[index++] = rvm_asm(RVM_NOP, XX, XX, XX, 0); } while (0)
 
 #define VMTEST_REGD(code, index, reg, val, msg) \
@@ -25,7 +25,7 @@
                 code[index++] = rvm_asmd(RVM_MOV, R9, DA, XX, val); \
                 code[index++] = rvm_asm(RVM_PRN, reg, XX, XX, 0); \
                 code[index++] = rvm_asmp(RVM_MOV, R10, DA, XX, msg); \
-                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
+                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "common_table", "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
                 code[index++] = rvm_asm(RVM_NOP, XX, XX, XX, 0); } while (0)
 
 
                 code[index++] = rvm_asmp(RVM_LDRR, R9, DA, XX, pval); \
                 code[index++] = rvm_asm(RVM_PRN, R9, XX, XX, 0); \
                 code[index++] = rvm_asmp(RVM_MOV, R10, DA, XX, msg); \
-                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
+                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "common_table", "rvm_vmtest_check_reg")), XX, XX, R0, 0); \
                 code[index++] = rvm_asm(RVM_NOP, XX, XX, XX, 0); } while (0)
 
 
 #define VMTEST_STATUS(code, index, val, msg) \
        do { code[index++] = rvm_asm(RVM_MOV, R9, DA, XX, val); \
                 code[index++] = rvm_asmp(RVM_MOV, R10, DA, XX, msg); \
-                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(vm, "rvm_vmtest_check_status")), XX, XX, R0, 0); \
+                code[index++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(vm, "common_table", "rvm_vmtest_check_status")), XX, XX, R0, 0); \
                 code[index++] = rvm_asm(RVM_NOP, XX, XX, XX, 0); } while (0)
 
 
index 684ff28..37fcc91 100644 (file)
@@ -38,7 +38,7 @@ int main(int argc, char *argv[])
 
        cg = rvm_codegen_create();
        cpu = rvm_cpu_create_default();
-       ntable = rvm_cpu_addswitable(cpu, switable);
+       ntable = rvm_cpu_addswitable(cpu, "switable", switable);
 
        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));
@@ -46,7 +46,7 @@ int main(int argc, char *argv[])
        rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
        rvm_codegen_addrelocins_s(cg, RVM_RELOC_BRANCH, "add2", rvm_asm(RVM_BL,  DA, XX, XX, 0));
 
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R0, XX, XX, 0));
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "print")), R0, XX, XX, 0));
 
        rvm_codegen_addins(cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
 
index bfa2691..f9acb21 100644 (file)
@@ -39,8 +39,8 @@ int main(int argc, char *argv[])
                iter = atol(argv[1]);
        }
 
-       rvm_cpu_addswitable(vm, calltable);
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "calltable", calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
        vmcode[off++] = rvm_asm(RVM_MOV, R4, DA, XX, 0);
        vmcode[off++] = rvm_asm(RVM_MOV, R5, DA, XX, iter);
@@ -51,7 +51,7 @@ int main(int argc, char *argv[])
 //     vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 1);
 //     vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 2);
 //     vmcode[off++] = rvm_asm(RVM_EADD, R0, R1, R2, 0);
-//     vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_getswi(vm, "rvm_eadd")), R0, R1, R2, 0);
+//     vmcode[off++] = rvm_asm(RVM_OPSWI(rvm_cpu_swilookup(vm, "rvm_eadd")), R0, R1, R2, 0);
 //     vmcode[off++] = rvm_asm(RVM_PUSH, DA, XX, XX, 1);
 //     vmcode[off++] = rvm_asm(RVM_POP, R1, XX, XX, 0);
        vmcode[off++] = rvm_asm(RVM_PUSH, R4, XX, XX, 0);
index 96fb3ea..172e343 100644 (file)
@@ -800,7 +800,7 @@ int main(int argc, char *argv[])
        co = rpa_compiler_create();
        cpu = rvm_cpu_create_default();
        cpu->userdata1 = stat = rpa_stat_create();
-       regextable = rvm_cpu_addswitable(cpu, switable);
+       regextable = rvm_cpu_addswitable(vm, "switable", switable);
 
        for (i = 1; i < argc; i++) {
                if (r_strcmp(argv[i], "-L") == 0) {
index 6180ee4..d482d57 100644 (file)
@@ -47,7 +47,7 @@ int main(int argc, char *argv[])
 
        r_memset(&rh_copy, 0, sizeof(rh_copy));
        cpu = rvm_cpu_create_default();
-       rvm_cpu_addswitable(cpu, switable);
+       rvm_cpu_addswitable(cpu, "switable", switable);
        cg = rvm_codegen_create();
 
        ag = rvm_reg_create_double(4.55);
@@ -80,8 +80,8 @@ int main(int argc, char *argv[])
         */
        rvm_codegen_addins(cg, rvm_asmp(RVM_LDRR, R1, DA, XX, r_harray_get(nc, r_harray_lookup_s(nc, "again"))));
 
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R0, XX, XX, 0));      // print
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R1, XX, XX, 0));      // print
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "print")), R0, XX, XX, 0));       // print
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "print")), R1, XX, XX, 0));       // print
 
        /*
         * Lookup the array member "there" and load the content to R2
@@ -99,7 +99,7 @@ int main(int argc, char *argv[])
 //     rvm_codegen_addins(cg, rvm_asm(RVM_KEYLOOKUPADD, R0, R1, R2, 0));
        rvm_codegen_addins(cg, rvm_asm(RVM_LDA, R0, R1, R0, 0));
 
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R0, XX, XX, 0));      // print
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "print")), R0, XX, XX, 0));       // print
        rvm_codegen_addins(cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
 
        rvm_cpu_exec_debug(cpu, rvm_codegen_getcode(cg, 0), 0);
index 09754c2..740b0b2 100644 (file)
@@ -339,7 +339,7 @@ int codegen_opcode_unary_callback(rpa_stat_handle stat, const char *name, void *
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
 
        if (r_stringncmp("-", input, size))
-               r_array_push(co->opcodes, RVM_OPSWI(rvm_cpu_getswi_s(co->cpu, "RVM_SWI_NEG")), ruint);
+               r_array_push(co->opcodes, RVM_OPSWI(rvm_cpu_swilookup_s(co->cpu, "RVM_SWI_NEG")), ruint);
        else if (r_stringncmp("+", input, size))
                r_array_push(co->opcodes, RVM_NOP, ruint);
        else if (r_stringncmp("!", input, size))
@@ -826,7 +826,7 @@ int codegen_h_arrayelementvalue_callback(rpa_stat_handle stat, const char *name,
 int codegen_swiidexist_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
-       rint swi = rvm_cpu_getswi(co->cpu, input, size);
+       rint swi = rvm_cpu_swilookup(co->cpu, input, size);
 
        if (swi < 0)
                return 0;
@@ -840,7 +840,7 @@ int codegen_swiid_callback(rpa_stat_handle stat, const char *name, void *userdat
 {
        rvm_compiler_t *co = (rvm_compiler_t *)userdata;
        rulong off = rvm_codegen_getcodesize(co->cg);
-       rint swi = rvm_cpu_getswi(co->cpu, input, size);
+       rint swi = rvm_cpu_swilookup(co->cpu, input, size);
 
        if (swi < 0)
                return 0;
@@ -1836,7 +1836,7 @@ int main(int argc, char *argv[])
        rvm_compiler_t *co = rvm_compiler_create(dbex);
 
        cpu = rvm_cpu_create_default();
-       ntable = rvm_cpu_addswitable(cpu, switable);
+       ntable = rvm_cpu_addswitable(vm, "switable", switable);
        rvm_cpu_addswitable(cpu, switable_js);
        co->cpu = cpu;
 
index 9048396..c4cc283 100644 (file)
@@ -36,7 +36,7 @@ int main(int argc, char *argv[])
        ruint ntable;
 
        cpu = rvm_cpu_create_default();
-       ntable = rvm_cpu_addswitable(cpu, switable);
+       ntable = rvm_cpu_addswitable(cpu, "switable", switable);
 
        code[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
        code[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
index 78d2bd0..577d8b8 100644 (file)
@@ -39,8 +39,8 @@ int main(int argc, char *argv[])
                iter = atol(argv[1]);
        }
 
-       rvm_cpu_addswitable(vm, calltable);
-       rvm_cpu_addswitable(vm, common_calltable);
+       rvm_cpu_addswitable(vm, "calltable", calltable);
+       rvm_cpu_addswitable(vm, "common_table", common_calltable);
 
        vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 0);
        for (i = 0; i < 25; i++)
index 1d9c27b..91ae625 100644 (file)
@@ -83,7 +83,7 @@ int main(int argc, char *argv[])
 
        rvm_codemap_invalid_add_s(cg->codemap, "str_init");
        rvm_codemap_invalid_add_s(cg->codemap, "str_to_double");
-       ntable = rvm_cpu_addswitable(cpu, switable);
+       ntable = rvm_cpu_addswitable(cpu, "switable", switable);
 
        rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R0, DA, XX, hello));
        rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
@@ -100,24 +100,24 @@ int main(int argc, char *argv[])
        rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R8, R0, XX, 0));
 
        rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R0, R7, XX, 0));
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "cat")), R0, R0, R8, 0));
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "cat")), R0, R0, R8, 0));
        rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R7, R0, XX, 0));
 
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R7, XX, XX, 0));      // print
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R8, XX, XX, 0));      // print
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "unref")), R7, XX, XX, 0));      // unref
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "unref")), R8, XX, XX, 0));      // unref
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "print")), R7, XX, XX, 0));       // print
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "print")), R8, XX, XX, 0));       // print
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "unref")), R7, XX, XX, 0));       // unref
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "unref")), R8, XX, XX, 0));       // unref
        rvm_codegen_addins(cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
 
        rvm_codegen_funcstart_s(cg, "str_init", 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_OPSWI(rvm_cpu_getswi_s(cpu, "str_init")), R0, R1, XX, 0));
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "str_init")), R0, R1, XX, 0));
        rvm_codegen_funcend(cg);
 
        rvm_codegen_funcstart_s(cg, "str_to_double", 1);
        rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R0, FP, DA, 1));
-       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "str_to_double")), R0, R0, XX, 0));
+       rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_swilookup_s(cpu, "switable", "str_to_double")), R0, R0, XX, 0));
        rvm_codegen_funcend(cg);
 
        if (rvm_codegen_relocate(cg, &err) < 0) {