cleanup

Compiler.c

@@ -252,22 +252,22 @@ static void cReference(Variable* v, int dimension) {
 
 static void cLoadRef(Variable* v) {
     switch(dtAsInt(v->type)) {
-        case DT_INT: cAddOperation(OP_REF_LOAD_INT); break;
-        case DT_BOOL: cAddOperation(OP_REF_LOAD_BOOL); break;
-        case DT_FLOAT: cAddOperation(OP_REF_LOAD_FLOAT); break;
+        case DT_INT: cAddOperation(OP_LOAD_INT); break;
+        case DT_BOOL: cAddOperation(OP_LOAD_BOOL); break;
+        case DT_FLOAT: cAddOperation(OP_LOAD_FLOAT); break;
         case DT_STRUCT:
             {
                 Struct* st = dtGetStruct(&structs, v->type);
                 if(st == NULL) {
                     cError("compiler struct error");
                 }
-                cAddOperation(OP_REF_LOAD);
+                cAddOperation(OP_LOAD);
                 cAddInt(dtGetSize(v->type, &structs));
                 break;
             }
         default:
             if(dtIsPointer(v->type)) {
-                cAddOperation(OP_REF_LOAD_INT);
+                cAddOperation(OP_LOAD_INT);
             } else {
                 cError("cannot load type %s", cGetName(v->type));
             }
@@ -295,10 +295,10 @@ static DataType cPostChange(Variable* v, int change, const char* name) {
     if(!dtCompare(v->type, dtInt())) {
         cError("%s needs an int", name);
     }
-    cAddOperation(OP_REF_LOAD_INT);
+    cAddOperation(OP_LOAD_INT);
     cReference(v, 0);
     cAddOperation(OP_DUPLICATE_REFERENCE);
-    cAddOperation(OP_REF_LOAD_INT);
+    cAddOperation(OP_LOAD_INT);
     cAddOperation(OP_PUSH_INT);
     cAddInt(change);
     cAddOperation(OP_ADD_INT);
@@ -373,12 +373,12 @@ static DataType cPreChange(int change, const char* name) {
     }
     cAddOperation(OP_DUPLICATE_REFERENCE);
     cAddOperation(OP_DUPLICATE_REFERENCE);
-    cAddOperation(OP_REF_LOAD_INT);
+    cAddOperation(OP_LOAD_INT);
     cAddOperation(OP_PUSH_INT);
     cAddInt(change);
     cAddOperation(OP_ADD_INT);
     cAddOperation(OP_STORE_INT);
-    cAddOperation(OP_REF_LOAD_INT);
+    cAddOperation(OP_LOAD_INT);
     return dtInt();
 }
 
@@ -618,7 +618,7 @@ static void cAddPostLineChange(Variable* v, int change, const char* name) {
         cError("%s needs an int", name);
     }
     cAddOperation(OP_DUPLICATE_REFERENCE);
-    cAddOperation(OP_REF_LOAD_INT);
+    cAddOperation(OP_LOAD_INT);
     cAddOperation(OP_PUSH_INT);
     cAddInt(change);
     cAddOperation(OP_ADD_INT);

utils/ByteCodePrinter.c

@@ -108,10 +108,8 @@ static void btPrintFloat(const char* op) {
 #define PRINT_OP_INT2(op) PRINT_OP_BASE(op, Int2)
 #define PRINT_NUMBER_OP(op) PRINT_OP(OP_##op##_INT) PRINT_OP(OP_##op##_FLOAT)
 #define PRINT_TYPES(TYPE)                                                      \
-    PRINT_OP_INT(OP_LOAD_##TYPE);                                              \
     PRINT_OP(OP_STORE_##TYPE);                                                 \
-    PRINT_OP(OP_REF_LOAD_##TYPE);                                              \
-    PRINT_OP(OP_REF_STORE_##TYPE);                                             \
+    PRINT_OP(OP_LOAD_##TYPE);                                                  \
     PRINT_OP_INT(OP_RETURN_##TYPE);                                            \
     PRINT_OP(OP_EQUAL_##TYPE);
 
@@ -121,7 +119,7 @@ static void btConsumeOperation() {
         PRINT_TYPES(INT);
         PRINT_TYPES(BOOL);
         PRINT_TYPES(FLOAT);
-        PRINT_OP_INT(OP_REF_LOAD);
+        PRINT_OP_INT(OP_LOAD);
         PRINT_OP(OP_NOTHING);
         PRINT_OP_INT(OP_PUSH_INT);
         PRINT_OP_BASE(OP_PUSH_FLOAT, Float);

vm/Operation.h

@@ -40,10 +40,8 @@ typedef enum Operation {
     TYPE_OPERATION(RETURN),
     OP_RESERVE,
     TYPE_OPERATION(LOAD),
-    TYPE_OPERATION(REF_LOAD),
-    OP_REF_LOAD,
+    OP_LOAD,
     TYPE_OPERATION(STORE),
-    TYPE_OPERATION(REF_STORE),
     OP_DEREFERENCE_VAR,
     OP_REFERENCE,
     OP_DUPLICATE_REFERENCE,

vm/Script.c

@@ -178,16 +178,6 @@ static bool sCheckAddress(Script* sc, int address, int length) {
     return true;
 }
 
-static void sLoad(Script* sc, int length) {
-    int address = -1;
-    if(sReadInt(sc, &address)) {
-        address += sc->stackVarIndex;
-        if(sCheckAddress(sc, address, length)) {
-            sPush(sc, sc->stack + address, length);
-        }
-    }
-}
-
 static void sStore(Script* sc, int length) {
     int address = -1;
     int index = sc->stackIndex - sizeof(int) - length;
@@ -202,13 +192,6 @@ static void sStore(Script* sc, int length) {
     }
 }
 
-static void sStoreRef(Script* sc, int length) {
-    int address = -1;
-    if(sPopInt(sc, &address) && sCheckAddress(sc, address, length)) {
-        sPop(sc, sc->stack + address, length);
-    }
-}
-
 static void sNot(Script* sc) {
     bool value = false;
     if(sPopBool(sc, &value)) {
@@ -325,14 +308,12 @@ static void sRefLoad(Script* sc) {
     }
 }
 
-#define LOAD_REF(type, Type)                                                   \
-    {                                                                          \
-        int address = 0;                                                       \
-        if(sPopInt(sc, &address) &&                                            \
-           sCheckAddress(sc, address, sizeof(type))) {                         \
-            sPush(sc, sc->stack + address, sizeof(type));                      \
-        }                                                                      \
+static void sLoad(Script* sc, int length) {
+    int address = 0;
+    if(sPopInt(sc, &address) && sCheckAddress(sc, address, length)) {
+        sPush(sc, sc->stack + address, length);
     }
+}
 
 #define CASE_NUMBER_OP(name, op)                                               \
     case OP_##name##_INT: NUMBER_OP(int, Int, op); break;                      \
@@ -345,13 +326,11 @@ static void sRefLoad(Script* sc) {
         BOOL_OP(float, Float, op);                                             \
         break;
 #define CASE_TYPE(TYPE, Type, type)                                            \
-    case OP_LOAD_##TYPE: sLoad(sc, sizeof(type)); break;                       \
     case OP_STORE_##TYPE: sStore(sc, sizeof(type)); break;                     \
     case OP_RETURN_##TYPE: RETURN(type, Type); break;                          \
     case OP_PRINT_##TYPE: PRINT(type, Type, type##Printer); break;             \
     case OP_EQUAL_##TYPE: BOOL_OP(type, Type, ==); break;                      \
-    case OP_REF_STORE_##TYPE: sStoreRef(sc, sizeof(type)); break;              \
-    case OP_REF_LOAD_##TYPE: LOAD_REF(type, Type); break;
+    case OP_LOAD_##TYPE: sLoad(sc, sizeof(type)); break;
 
 static void sConsumeInstruction(Script* sc) {
     switch(sReadOperation(sc)) {
@@ -393,7 +372,7 @@ static void sConsumeInstruction(Script* sc) {
         case OP_DEREFERENCE_VAR: sVarRef(sc); break;
         case OP_REFERENCE: sReference(sc); break;
         case OP_DUPLICATE_REFERENCE: sDuplicateReference(sc); break;
-        case OP_REF_LOAD: sRefLoad(sc); break;
+        case OP_LOAD: sRefLoad(sc); break;
         case OP_INT_ARRAY: sIntArray(sc); break;
         case OP_STORE_ARRAY: sStore(sc, sizeof(int)); break;
     }