work on RJS object introspection.

diff --git a/rjs/ecma262.rpa b/rjs/ecma262.rpa
index 3ac4cb0..18bdfee 100644 (file)
--- a/rjs/ecma262.rpa
+++ b/rjs/ecma262.rpa
@@ -89,6 +89,9 @@
 #!emitid DoWhileExpressionCompare              UID_DOWHILEEXPRESSIONCOMPARE            59
 #!emitid Program                                               UID_PROGRAM                                             60
 #!emitid StringLiteral                                 UID_STRINGLITERAL                                       61
+#!emitid UnaryExpressionDelete                 UID_UNARYEXPRESSIONDELETE                       62
+#!emitid IterationForIn                                        UID_ITERATIONFORIN                                      63
+#!emitid ForInInit                                             UID_FORININIT                                           64
 
 #!abort SC
 
@@ -252,9 +255,12 @@ PrefixExpressionOp                                 ::= <PrefixOperator> <LeftHandSideExpressionAddr>
 PrefixExpression                               ::= <PrefixExpressionOp> | <PostfixExpression>
 
 # 11.4 Unary Operators
-UnaryOperator                                  ::= '~' | '!' | ('+' - '++') | ('-' - '--') | 'delete' | 'void' | 'typeof'
+UnaryOperator                                  ::= '~' | '!' | ('+' - '++') | ('-' - '--') | 'void' | 'typeof'
 UnaryExpressionOp                      ::=     <S>? <UnaryOperator> <S>? <UnaryExpression>
-UnaryExpression                                ::=     <UnaryExpressionOp> | <PrefixExpression>
+UnaryExpressionDelete                  ::=     <S>? 'delete' <S>? <UnaryExpression>
+UnaryExpressionVoid                            ::=     <S>? 'void' <S>? <UnaryExpression>
+UnaryExpressionTypeof                  ::=     <S>? 'typeof' <S>? <UnaryExpression>
+UnaryExpression                                ::=     <UnaryExpressionOp> | <UnaryExpressionDelete> | <UnaryExpressionTypeof> |<UnaryExpressionVoid> | <PrefixExpression>
 
 
 # 11.5 Multiplicative Operators
@@ -355,6 +361,7 @@ VariableStatement                                   ::= 'var' <S>? <VariableDeclarationList> <SC>
 VariableDeclarationList                        ::= <VariableDeclaration> (<COMMA> <VariableDeclaration> )*
 VariableAllocate                                       ::= <IdentifierNoEmit>
 VariableAllocateAndInit                                ::= <IdentifierNoEmit>
+VariableAllocatePush                           ::= <IdentifierNoEmit>
 VariableDeclaration                                    ::= <VariableAllocateAndInit> <Initialiser> | <VariableAllocate>
 Initialiser                                                    ::= <EQ> <AssignmentExpression>
 
@@ -392,9 +399,14 @@ ForExpressionIncrement                             ::= <Expression>
 ForIterationStatement                          ::= <Statement>
 IterationFor                                           ::= 'for' <S>? '(' <S>? <ForExpressionInit>? <S>? ';' <S>? <ForExpressionCompare>? <S>? ';' <S>? <ForExpressionIncrement>? <S>? ')' <S>? <ForIterationStatement>
 
+# 12.6d Iteration for ( in )
+ForInIterator                                          ::= ('var' <S>? <VariableAllocateAndInit>) | <LeftHandSideExpressionAddr>
+ForInInit                                                      ::= <ForInIterator> <S>? 'in' <S>? <Expression>
+IterationForIn                                         ::= 'for' <S>? '(' <S>? <ForInInit> <S>? ')' <S>?  <Statement>
 
 IterationStatement                                     ::= <IterationWhile> |
                                                                                <IterationFor> |
+                                                                               <IterationForIn> |
                                                                        <IterationDo>
 
 # 12.9 The return Statement

diff --git a/rjs/rjscompiler.c b/rjs/rjscompiler.c
index f7d6780..2d2506f 100644 (file)
--- a/rjs/rjscompiler.c
+++ b/rjs/rjscompiler.c
@@ -279,6 +279,8 @@ long rjs_compiler_record2unaryopcode(rparecord_t *prec)
                return RVM_ENOT;
        else if (r_stringncmp("!", input,  size))
                return RVM_ELNOT;
+       else
+               return RVM_NOP;
 
        return -1;
 }
@@ -652,6 +654,33 @@ error:
 }
 
 
+int rjs_compiler_rh_unaryexpressiondelete(rjs_compiler_t *co, rarray_t *records, long rec)
+{
+       rparecord_t *prec;
+       rjs_coctx_operation_t ctx;
+
+       r_memset(&ctx, 0, sizeof(ctx));
+       ctx.base.type = RJS_COCTX_DELETE;
+       r_array_push(co->coctx, &ctx, rjs_coctx_t*);
+
+       prec = (rparecord_t *)r_array_slot(records, rec);
+       rjs_compiler_debughead(co, records, rec);
+       rjs_compiler_debugtail(co, records, rec);
+       if (rjs_compiler_playchildrecords(co, records, rec) < 0)
+               goto error;
+       rec = rpa_recordtree_get(records, rec, RPA_RECORD_END);
+       prec = (rparecord_t *)r_array_slot(records, rec);
+       rjs_compiler_debughead(co, records, rec);
+       rjs_compiler_debugtail(co, records, rec);
+       r_array_removelast(co->coctx);
+       return 0;
+
+error:
+       r_array_removelast(co->coctx);
+       return -1;
+}
+
+
 int rjs_compiler_rh_assignmentexpressionop(rjs_compiler_t *co, rarray_t *records, long rec)
 {
        rparecord_t *prec;
@@ -723,7 +752,10 @@ int rjs_compiler_rh_memberexpressiondotop(rjs_compiler_t *co, rarray_t *records,
 
        } else {
                rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPLKUP, R0, R1, R2, 0));        // Get the offset of the element at offset R0
-               rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPLDR, R0, R1, R0, 0)); // Get the value of the element at offset R0
+               if (ctx && ctx->type == RJS_COCTX_DELETE)
+                       rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPDEL, R0, R1, R0, 0));         // Get the result of deletion in R0
+               else
+                       rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPLDR, R0, R1, R0, 0));         // Get the value of the element at offset R0
        }
        rjs_compiler_debugtail(co, records, rec);
        return 0;
@@ -754,7 +786,10 @@ int rjs_compiler_rh_memberexpressionindexop(rjs_compiler_t *co, rarray_t *record
        } else {
                rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));    // Supposedly an Array
                rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPLKUP, R0, R1, R0, 0));        // R1 Array
-               rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPLDR, R0, R1, R0, 0)); // Get the value of the element at offset R0
+               if (ctx && ctx->type == RJS_COCTX_DELETE)
+                       rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPDEL, R0, R1, R0, 0));         // Get the result of deletion in R0
+               else
+                       rvm_codegen_addins(co->cg, rvm_asm(RVM_MAPLDR, R0, R1, R0, 0));         // Get the value of the element at offset R0
        }
        rjs_compiler_debugtail(co, records, rec);
        return 0;
@@ -1149,6 +1184,82 @@ error:
 }
 
 
+int rjs_compiler_rh_iterationforin(rjs_compiler_t *co, rarray_t *records, long rec)
+{
+       rparecord_t *prec;
+       rjs_coctx_iteration_t ctx;
+
+       r_memset(&ctx, 0, sizeof(ctx));
+       ctx.base.type = RJS_COCTX_ITERATION;
+       ctx.start = rvm_codegen_getcodesize(co->cg);
+       ctx.iterationidx = rvm_codegen_invalid_addlabel_s(co->cg, NULL);
+       ctx.continueidx = rvm_codegen_invalid_addlabel_s(co->cg, NULL);
+       ctx.endidx = rvm_codegen_invalid_addlabel_s(co->cg, NULL);
+       r_array_push(co->coctx, &ctx, rjs_coctx_t*);
+       rvm_scope_push(co->scope);
+       prec = (rparecord_t *)r_array_slot(records, rec);
+       rjs_compiler_debughead(co, records, rec);
+       rjs_compiler_debugtail(co, records, rec);
+
+       if (rjs_compiler_playchildrecords(co, records, rec) < 0)
+               goto error;
+
+       rec = rpa_recordtree_get(records, rec, RPA_RECORD_END);
+       prec = (rparecord_t *)r_array_slot(records, rec);
+       rjs_compiler_debughead(co, records, rec);
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, ctx.iterationidx, rvm_asm(RVM_B, DA, XX, XX, 0));
+       rvm_codegen_redefinelabel_default(co->cg, ctx.endidx);
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_SUB, SP, SP, DA, 3));
+       rjs_compiler_debugtail(co, records, rec);
+       rvm_scope_pop(co->scope);
+       r_array_removelast(co->coctx);
+       return 0;
+
+error:
+       rvm_scope_pop(co->scope);
+       r_array_removelast(co->coctx);
+       return -1;
+}
+
+
+int rjs_compiler_rh_forininit(rjs_compiler_t *co, rarray_t *records, long rec)
+{
+       rjs_coctx_iteration_t *ctx = (rjs_coctx_iteration_t *)rjs_compiler_getctx(co, RJS_COCTX_ITERATION);
+       rparecord_t *prec;
+       prec = (rparecord_t *)r_array_slot(records, rec);
+       rjs_compiler_debughead(co, records, rec);
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_PUSH, DA, XX, XX, -1));
+       rjs_compiler_debugtail(co, records, rec);
+
+       if (rjs_compiler_playchildrecords(co, records, rec) < 0)
+               goto error;
+
+       rec = rpa_recordtree_get(records, rec, RPA_RECORD_END);
+       prec = (rparecord_t *)r_array_slot(records, rec);
+       rjs_compiler_debughead(co, records, rec);
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSH, R0, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asm(RVM_TYPE, R0, R0, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_CMP, R0, DA, XX, RVM_DTYPE_JSOBJECT));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, ctx->endidx, rvm_asm(RVM_BNEQ, DA, XX, XX, 0));
+       rvm_codegen_redefinelabel_default(co->cg, ctx->iterationidx);
+       rvm_codegen_redefinelabel_default(co->cg, ctx->continueidx);
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_LDS, R0, SP, DA, -2));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_LDS, R1, SP, DA, 0));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_LDS, R2, SP, DA, -1));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_MAPNEXT, R0, R1, R0, 0));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_CMP, R0, DA, XX, 0));
+       rvm_codegen_index_addrelocins(co->cg, RVM_RELOC_BRANCH, ctx->endidx, rvm_asm(RVM_BLES, DA, XX, XX, 0));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_STS, R0, SP, DA, -2));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_MAPKEYLDR, R0, R1, R0, 0));
+       rvm_codegen_addins(co->cg, rvm_asml(RVM_STRR, R0, R2, XX, 0));
+       rjs_compiler_debugtail(co, records, rec);
+       return 0;
+
+error:
+       return -1;
+}
+
+
 int rjs_compiler_rh_iterationwhile(rjs_compiler_t *co, rarray_t *records, long rec)
 {
        rparecord_t *prec;
@@ -1654,6 +1765,8 @@ rjs_compiler_t *rjs_compiler_create(rvmcpu_t *cpu)
        co->handlers[UID_ITERATIONDO] = rjs_compiler_rh_iterationdo;
        co->handlers[UID_ITERATIONWHILE] = rjs_compiler_rh_iterationwhile;
        co->handlers[UID_ITERATIONFOR] = rjs_compiler_rh_iterationfor;
+       co->handlers[UID_ITERATIONFORIN] = rjs_compiler_rh_iterationforin;
+       co->handlers[UID_FORININIT] = rjs_compiler_rh_forininit;
        co->handlers[UID_DOWHILEEXPRESSIONCOMPARE] = rjs_compiler_rh_dowhileexpressioncompare;
        co->handlers[UID_WHILEEXPRESSIONCOMPARE] = rjs_compiler_rh_forexpressioncompare;
        co->handlers[UID_FOREXPRESSIONCOMPARE] = rjs_compiler_rh_forexpressioncompare;
@@ -1663,6 +1776,7 @@ rjs_compiler_t *rjs_compiler_create(rvmcpu_t *cpu)
        co->handlers[UID_THIS] = rjs_compiler_rh_this;
        co->handlers[UID_NEWEXPRESSIONCALL] = rjs_compiler_rh_newexpressioncall;
        co->handlers[UID_UNARYEXPRESSIONOP] = rjs_compiler_rh_unaryexpressionop;
+       co->handlers[UID_UNARYEXPRESSIONDELETE] = rjs_compiler_rh_unaryexpressiondelete;
        co->handlers[UID_BINARYOPERATOR] = rjs_compiler_rh_binaryoperator;
        co->handlers[UID_UNARYOPERATOR] = rjs_compiler_rh_unaryoperator;
        co->handlers[UID_BREAKSTATEMENT] = rjs_compiler_rh_break;

diff --git a/rjs/rjscompiler.h b/rjs/rjscompiler.h
index ec4037b..6675342 100644 (file)
--- a/rjs/rjscompiler.h
+++ b/rjs/rjscompiler.h
@@ -45,6 +45,7 @@ extern "C" {
 #define RJS_COCTX_IFSTATEMENT (1 << 4)
 #define RJS_COCTX_ITERATION (1 << 5)
 #define RJS_COCTX_OPERATION (1 << 5)
+#define RJS_COCTX_DELETE (1 << 6)
 
 
 typedef struct rjs_coctx_s {

diff --git a/rjs/rjsuids.h b/rjs/rjsuids.h
index 9672fbe..e0f9f76 100644 (file)
--- a/rjs/rjsuids.h
+++ b/rjs/rjsuids.h
@@ -1,23 +1,3 @@
-/*
- *  Regular Pattern Analyzer (RPA)
- *  Copyright (c) 2009-2010 Martin Stoilov
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- *  Martin Stoilov <martin@rpasearch.com>
- */
-
 #define UID_SYNTAXERROR 1
 #define UID_BINARYOPERATOR 2
 #define UID_ADDITIVEOPERATOR 2
@@ -96,3 +76,6 @@
 #define UID_DOWHILEEXPRESSIONCOMPARE 59
 #define UID_PROGRAM 60
 #define UID_STRINGLITERAL 61
+#define UID_UNARYEXPRESSIONDELETE 62
+#define UID_ITERATIONFORIN 63
+#define UID_FORININIT 64

diff --git a/rlib/rmap.c b/rlib/rmap.c
index 036de1b..e3df07a 100644 (file)
--- a/rlib/rmap.c
+++ b/rlib/rmap.c
@@ -102,8 +102,6 @@ void r_map_cleanup(robject_t *obj)
        }
        while (!r_list_empty(&map->inactive)) {
                node = r_list_entry(r_list_first(&map->inactive), r_mapnode_t, active);
-               if (!r_object_gcget((robject_t*)node->key))
-                       r_string_destroy(node->key);
                r_list_del(&node->active);
        }
 

diff --git a/rlib/rmap.h b/rlib/rmap.h
index a4072bd..c3366e1 100644 (file)
--- a/rlib/rmap.h
+++ b/rlib/rmap.h
@@ -64,7 +64,7 @@ long r_map_add_l(rmap_t *map, long name, rconstpointer pval);
  * The following functions allow the created keys (rstring_t objects) to be added to
  * GC list and not being destroyed by the rmap_t, but leave it to the users of rmap_t
  * to decide when to destroy those keys. These is useful for scripting languages with
- * GC memory management. Another possibility would be to get the key as a rstrit_t* and
+ * GC memory management. Another possibility would be to get the key as a rstr_t* and
  * make rmap_t completely get out of the memory management business.
  */
 long r_map_gckey_add(rmap_t *map, rgc_t* gc, const char *name, unsigned int namesize, rconstpointer pval);

diff --git a/rvm/rvmcpu.c b/rvm/rvmcpu.c
index 6964659..1683649 100644 (file)
--- a/rvm/rvmcpu.c
+++ b/rvm/rvmcpu.c
@@ -153,12 +153,15 @@ static const char *stropcalls[] = {
        "STA",
        "MAPALLOC",
        "MAPADDR",
+       "MAPKEYLDR",
        "MAPLDR",
        "MAPSTR",
+       "MAPDEL",
        "MAPLKUP",
        "MAPADD",
        "MAPLKUPADD",
-       "UNKNOWN",
+       "MAPNEXT",
+       "MAPPREV",
        "UNKNOWN",
        "UNKNOWN",
        "UNKNOWN",
@@ -1631,6 +1634,25 @@ static void rvm_op_maplookupadd(rvmcpu_t *cpu, rvm_asmins_t *ins)
 }
 
 
+static void rvm_op_mapdel(rvmcpu_t *cpu, rvm_asmins_t *ins)
+{
+       int ret;
+       long index;
+       rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
+       rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
+       rvmreg_t tmp = rvm_reg_create_signed(0);
+       rmap_t *a = NULL;
+
+       rvm_opmap_invoke_binary_handler(cpu->opmap, RVM_OPID_CAST, cpu, &tmp, RVM_CPUREG_PTR(cpu, ins->op3), &tmp);
+       index = (long)RVM_REG_GETL(&tmp);
+       if (rvm_reg_gettype(arg2) != RVM_DTYPE_JSOBJECT)
+               RVM_ABORT(cpu, RVM_E_NOTOBJECT);
+       a = (rmap_t*)RVM_REG_GETP(arg2);
+       ret = r_map_delete(a, index);
+       rvm_reg_setboolean(arg1, ret == 0 ? 1 : 0);
+}
+
+
 static void rvm_op_mapaddr(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
        rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
@@ -1678,6 +1700,76 @@ static void rvm_op_mapldr(rvmcpu_t *cpu, rvm_asmins_t *ins)
 }
 
 
+static void rvm_op_mapkeyldr(rvmcpu_t *cpu, rvm_asmins_t *ins)
+{
+       rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
+       rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
+       rvmreg_t tmp = rvm_reg_create_signed(0);
+       rmap_t *a = NULL;
+       rstring_t *key;
+       long index;
+
+       rvm_opmap_invoke_binary_handler(cpu->opmap, RVM_OPID_CAST, cpu, &tmp, RVM_CPUREG_PTR(cpu, ins->op3), &tmp);
+       index = (long)RVM_REG_GETL(&tmp);
+       if (rvm_reg_gettype(arg2) != RVM_DTYPE_JSOBJECT)
+               RVM_ABORT(cpu, RVM_E_NOTOBJECT);
+       a = (rmap_t*)RVM_REG_GETP(arg2);
+       key = r_map_key(a, index);
+       if (!key) {
+               RVM_REG_CLEAR(arg1);
+               RVM_REG_SETTYPE(arg1, RVM_DTYPE_UNDEF);
+       } else {
+               rvm_reg_setstring(arg1, key);
+       }
+}
+
+
+static void rvm_op_mapnext(rvmcpu_t *cpu, rvm_asmins_t *ins)
+{
+       rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
+       rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
+       rvmreg_t tmp = rvm_reg_create_signed(0);
+       rmap_t *a = NULL;
+       long index;
+
+       rvm_opmap_invoke_binary_handler(cpu->opmap, RVM_OPID_CAST, cpu, &tmp, RVM_CPUREG_PTR(cpu, ins->op3), &tmp);
+       index = (long)RVM_REG_GETL(&tmp);
+       if (rvm_reg_gettype(arg2) != RVM_DTYPE_JSOBJECT)
+               RVM_ABORT(cpu, RVM_E_NOTOBJECT);
+       a = (rmap_t*)RVM_REG_GETP(arg2);
+       if (index < 0)
+               index = r_map_first(a);
+       else
+               index = r_map_next(a, index);
+       RVM_REG_CLEAR(arg1);
+       RVM_REG_SETTYPE(arg1, RVM_DTYPE_SINGED);
+       RVM_REG_SETL(arg1, index);
+}
+
+
+static void rvm_op_mapprev(rvmcpu_t *cpu, rvm_asmins_t *ins)
+{
+       rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
+       rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
+       rvmreg_t tmp = rvm_reg_create_signed(0);
+       rmap_t *a = NULL;
+       long index;
+
+       rvm_opmap_invoke_binary_handler(cpu->opmap, RVM_OPID_CAST, cpu, &tmp, RVM_CPUREG_PTR(cpu, ins->op3), &tmp);
+       index = (long)RVM_REG_GETL(&tmp);
+       if (rvm_reg_gettype(arg2) != RVM_DTYPE_JSOBJECT)
+               RVM_ABORT(cpu, RVM_E_NOTOBJECT);
+       a = (rmap_t*)RVM_REG_GETP(arg2);
+       if (index < 0)
+               index = r_map_last(a);
+       else
+               index = r_map_prev(a, index);
+       RVM_REG_CLEAR(arg1);
+       RVM_REG_SETTYPE(arg1, RVM_DTYPE_SINGED);
+       RVM_REG_SETL(arg1, index);
+}
+
+
 static void rvm_op_mapstr(rvmcpu_t *cpu, rvm_asmins_t *ins)
 {
        rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
@@ -1874,11 +1966,15 @@ static rvm_cpu_op ops[] = {
        rvm_op_sta,                     // RVM_STA
        rvm_op_mapalloc,        // RVM_MAPALLOC
        rvm_op_mapaddr,         // RVM_MAPADDR,
+       rvm_op_mapkeyldr,       // RVM_MAPKEYLDR,
        rvm_op_mapldr,          // RVM_MAPLDR,
        rvm_op_mapstr,          // RVM_MAPSTR,
+       rvm_op_mapdel,          // RVM_MAPDEL,
        rvm_op_maplookup,       // RVM_MAPLKUP,
        rvm_op_mapadd,          // RVM_MAPADD,
        rvm_op_maplookupadd,// RVM_MAPLKUPADD,
+       rvm_op_mapnext,         // RVM_MAPNEXT,
+       rvm_op_mapprev,         // RVM_MAPPREV,
        (void*) 0,
        (void*) 0,
        (void*) 0,

diff --git a/rvm/rvmcpu.h b/rvm/rvmcpu.h
index 5a285dd..d4d0e3c 100644 (file)
--- a/rvm/rvmcpu.h
+++ b/rvm/rvmcpu.h
@@ -157,11 +157,15 @@ enum {
        RVM_STA,                /* op1 is the source, op2 is the array, op3 is the offset */
        RVM_MAPALLOC,
        RVM_MAPADDR,
+       RVM_MAPKEYLDR,
        RVM_MAPLDR,
        RVM_MAPSTR,
+       RVM_MAPDEL,
        RVM_MAPLKUP,
        RVM_MAPADD,
        RVM_MAPLKUPADD,
+       RVM_MAPNEXT,
+       RVM_MAPPREV,
 };