refactoring

meson.build

@@ -14,7 +14,6 @@ src = [
     'Test.c', 
     'vm/ByteCode.c',
     'vm/Script.c', 
-    'vm/Object.c',
     'vm/Allocator.c'
 ]
 

utils/ByteCodePrinter.c

@@ -99,18 +99,6 @@ static void btPrintFloat(const char* op) {
     puts(buffer);
 }
 
-static void btPrintString(const char* msg) {
-    btFillBase();
-    int length = 0;
-    btRead(&length, sizeof(int));
-    char* s = (char*)(code->code + readIndex);
-    readIndex += length;
-    btAddOperation(msg);
-    btAdd(" %10s |", s);
-    btAddFiller();
-    puts(buffer);
-}
-
 #define PRINT_OP_BASE(op, name)                                                \
     case op:                                                                   \
         btPrint##name(#op);                                                    \
@@ -118,6 +106,7 @@ static void btPrintString(const char* msg) {
 #define PRINT_OP(op) PRINT_OP_BASE(op, Op)
 #define PRINT_OP_INT(op) PRINT_OP_BASE(op, Int)
 #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)
 
 static void btConsumeOperation() {
     Operation op = code->code[readIndex++];
@@ -125,26 +114,17 @@ static void btConsumeOperation() {
         PRINT_OP(OP_NOTHING);
         PRINT_OP_INT(OP_PUSH_INT);
         PRINT_OP_BASE(OP_PUSH_FLOAT, Float);
-        PRINT_OP_BASE(OP_PUSH_CONST_STRING, String);
         PRINT_OP(OP_PUSH_TRUE);
         PRINT_OP(OP_PUSH_FALSE);
-        PRINT_OP(OP_ADD_INT);
-        PRINT_OP(OP_ADD_FLOAT);
-        PRINT_OP(OP_SUB_INT);
-        PRINT_OP(OP_SUB_FLOAT);
-        PRINT_OP(OP_MUL_INT);
-        PRINT_OP(OP_MUL_FLOAT);
-        PRINT_OP(OP_DIV_INT);
-        PRINT_OP(OP_DIV_FLOAT);
+        PRINT_NUMBER_OP(ADD);
+        PRINT_NUMBER_OP(SUB);
+        PRINT_NUMBER_OP(MUL);
+        PRINT_NUMBER_OP(DIV);
         PRINT_OP(OP_MOD_INT);
-        PRINT_OP(OP_INVERT_SIGN_INT);
-        PRINT_OP(OP_INVERT_SIGN_FLOAT);
-        PRINT_OP(OP_LESS_INT);
-        PRINT_OP(OP_LESS_FLOAT);
-        PRINT_OP(OP_GREATER_INT);
-        PRINT_OP(OP_GREATER_FLOAT);
-        PRINT_OP(OP_EQUAL_INT);
-        PRINT_OP(OP_EQUAL_FLOAT);
+        PRINT_NUMBER_OP(INVERT_SIGN);
+        PRINT_NUMBER_OP(LESS);
+        PRINT_NUMBER_OP(GREATER);
+        PRINT_NUMBER_OP(EQUAL);
         PRINT_OP(OP_EQUAL_BOOL);
         PRINT_OP(OP_NOT);
         PRINT_OP(OP_AND);
@@ -155,8 +135,7 @@ static void btConsumeOperation() {
         PRINT_OP(OP_BIT_XOR);
         PRINT_OP(OP_LEFT_SHIFT);
         PRINT_OP(OP_RIGHT_SHIFT);
-        PRINT_OP(OP_PRINT_INT);
-        PRINT_OP(OP_PRINT_FLOAT);
+        PRINT_NUMBER_OP(PRINT);
         PRINT_OP(OP_PRINT_BOOL);
         PRINT_OP_INT(OP_GOTO);
         PRINT_OP_INT(OP_IF_GOTO);
@@ -166,15 +145,10 @@ static void btConsumeOperation() {
         PRINT_OP_INT(OP_RETURN);
         PRINT_OP_INT(OP_RETURN_INT);
         PRINT_OP_INT(OP_RETURN_BOOL);
-        // PRINT_OP(OP_ALLOCATE_ARRAY);
-        // PRINT_OP(OP_ARRAY_LENGTH);
         PRINT_OP_INT2(OP_RESERVE);
         PRINT_OP_INT(OP_LOAD_INT);
         PRINT_OP_INT(OP_STORE_INT);
-        case OP_LINE:
-            sPrintLine();
-            break;
-            // default: printf("Unknown: %d\n", op);
+        case OP_LINE: sPrintLine(); break;
     }
 }
 

vm/Allocator.c

@@ -3,7 +3,7 @@
 
 #include "vm/Allocator.h"
 
-void aInit(Allocator* a) {
+/*void aInit(Allocator* a) {
     a->capacity = 0;
     a->usedStart = -1;
     a->freeStart = -1;
@@ -89,4 +89,4 @@ void aRemoveUnmarked(Allocator* a) {
         }
         i = next;
     }
-}
+}*/

vm/Allocator.h

@@ -3,13 +3,11 @@
 
 #include <stdbool.h>
 
-#include "Object.h"
-
 typedef struct {
     int length;
     int next;
     bool marked;
-    Object* data;
+    // Object* data;
 } Array;
 
 typedef struct {

vm/Object.c

@@ -1,15 +0,0 @@
-#include "vm/Object.h"
-
-const char* oGetName(ObjectType ot) {
-    switch(ot) {
-        case OT_INT: return "int";
-        case OT_FLOAT: return "float";
-        case OT_CONST_STRING: return "const string";
-        case OT_NULL: return "null";
-        case OT_BOOL: return "bool";
-        case OT_VOID: return "void";
-        case OT_ARRAY: return "array";
-        case OT_REFERENCE: return "reference";
-        default: return "unknown";
-    }
-}

vm/Object.h

@@ -1,32 +0,0 @@
-#ifndef OBJECT_H
-#define OBJECT_H
-
-typedef enum {
-    OT_INT,
-    OT_FLOAT,
-    OT_CONST_STRING,
-    OT_NULL,
-    OT_BOOL,
-    OT_VOID,
-    OT_ARRAY,
-    OT_REFERENCE
-} ObjectType;
-
-typedef struct {
-    int pointer;
-    int index;
-} Reference;
-
-typedef struct {
-    ObjectType type;
-    union {
-        int intValue;
-        float floatValue;
-        const char* stringValue;
-        Reference reference;
-    } as;
-} Object;
-
-const char* oGetName(ObjectType ot);
-
-#endif

vm/Operation.h

@@ -6,7 +6,6 @@
 typedef enum Operation {
     OP_NOTHING,
     NUMBER_OPERATION(PUSH),
-    OP_PUSH_CONST_STRING,
     OP_PUSH_TRUE,
     OP_PUSH_FALSE,
     NUMBER_OPERATION(ADD),
@@ -39,12 +38,9 @@ typedef enum Operation {
     OP_RETURN,
     OP_RETURN_INT,
     OP_RETURN_BOOL,
-    /*OP_ALLOCATE_ARRAY,
-    OP_ARRAY_LENGTH,*/
     OP_RESERVE,
     OP_LOAD_INT,
     OP_STORE_INT,
-    /*OP_REFERENCE_FROM_ARRAY,*/
 } Operation;
 
 #endif

vm/Script.c

@@ -147,6 +147,14 @@ POP_PUSH(bool, Bool)
         }                                                                      \
     }
 
+#define INVERT_SIGN(type, Type)                                                \
+    {                                                                          \
+        type value = 0;                                                        \
+        if(sPop##Type(sc, &value)) {                                           \
+            sPush##Type(sc, -value);                                           \
+        }                                                                      \
+    }
+
 static void sReserveBytes(Script* sc) {
     int bytes = 0;
     int offset = 0;
@@ -186,55 +194,6 @@ static void sStore(Script* sc, int length) {
     }
 }
 
-/*static void sAllocateArray(Script* sc) {
-    Object length;
-    if(!sPop(sc, &length) && sCheckType(sc, &length, OT_INT)) {
-        if(length.as.intValue < 0) {
-            sError(sc, "negative array length");
-            return;
-        }
-        Object o = {.type = OT_ARRAY,
-                    .as.intValue =
-                        aAllocate(&sc->allocator, length.as.intValue)};
-        sPush(sc, &o);
-    }
-}
-
-static void sArrayLength(Script* sc) {
-    Object* o = sPopAndDereference(sc);
-    if(o != NULL && sCheckType(sc, o, OT_ARRAY)) {
-        int arrayPointer = o->as.intValue;
-        if(arrayPointer < 0 || arrayPointer >= sc->allocator.capacity) {
-            sError(sc, "array pointer is out of range");
-            return;
-        }
-        sPushInt(sc, sc->allocator.data[arrayPointer].length);
-    }
-}*/
-
-static void sPushCodeString(Script* sc) {
-    int value = 0;
-    if(sReadInt(sc, &value)) {
-        char* s = (char*)(sc->code->code + sc->readIndex);
-        sc->readIndex += value;
-        sPush(sc, s, sizeof(char*));
-    }
-}
-
-static void sInvertSignInt(Script* sc) {
-    int i = 0;
-    if(sPopInt(sc, &i)) {
-        sPushInt(sc, -i);
-    }
-}
-
-static void sInvertSignFloat(Script* sc) {
-    float f = 0;
-    if(sPopFloat(sc, &f)) {
-        sPushFloat(sc, -f);
-    }
-}
-
 static void sNot(Script* sc) {
     bool value = false;
     if(sPopBool(sc, &value)) {
@@ -278,7 +237,6 @@ static void sReturn(Script* sc) {
     if(sReadInt(sc, &bytes) && sPopInt(sc, &varIndex)) {
         sc->stackVarIndex = varIndex;
         sFree(sc, bytes);
-
         int returnIndex;
         if(sPopInt(sc, &returnIndex)) {
             sc->readIndex = returnIndex;
@@ -286,21 +244,14 @@ static void sReturn(Script* sc) {
     }
 }
 
-static void sReturnInt(Script* sc) {
-    int value = 0;
-    if(sPopInt(sc, &value)) {
-        sReturn(sc);
-        sPushInt(sc, value);
-    }
-}
-
-static void sReturnBool(Script* sc) {
-    bool value = 0;
-    if(sPopBool(sc, &value)) {
-        sReturn(sc);
-        sPushBool(sc, value);
+#define RETURN(type, Type)                                                     \
+    {                                                                          \
+        type value;                                                            \
+        if(sPop##Type(sc, &value)) {                                           \
+            sReturn(sc);                                                       \
+            sPush##Type(sc, value);                                            \
+        }                                                                      \
     }
-}
 
 static void sIfGoTo(Script* sc) {
     int gotoIndex = 0;
@@ -331,7 +282,6 @@ static void sConsumeInstruction(Script* sc) {
         case OP_NOTHING: break;
         case OP_PUSH_INT: PUSH_CONSTANT(int, Int, 0); break;
         case OP_PUSH_FLOAT: PUSH_CONSTANT(float, Float, 0.0f); break;
-        case OP_PUSH_CONST_STRING: sPushCodeString(sc); break;
         case OP_PUSH_TRUE: sPushBool(sc, true); break;
         case OP_PUSH_FALSE: sPushBool(sc, false); break;
         case OP_ADD_INT: NUMBER_OP(int, Int, +); break;
@@ -349,8 +299,8 @@ static void sConsumeInstruction(Script* sc) {
         case OP_MOD_INT:
             CHECKED_NUMBER_OP(int, Int, %, ZERO_CHECK("module"));
             break;
-        case OP_INVERT_SIGN_INT: sInvertSignInt(sc); break;
-        case OP_INVERT_SIGN_FLOAT: sInvertSignFloat(sc); break;
+        case OP_INVERT_SIGN_INT: INVERT_SIGN(int, Int); break;
+        case OP_INVERT_SIGN_FLOAT: INVERT_SIGN(float, Float); break;
         case OP_LESS_INT: BOOL_OP(int, Int, <); break;
         case OP_LESS_FLOAT: BOOL_OP(float, Float, <); break;
         case OP_GREATER_INT: BOOL_OP(int, Int, >); break;
@@ -377,14 +327,8 @@ static void sConsumeInstruction(Script* sc) {
         case OP_PEEK_TRUE_GOTO: sPeekTrueGoTo(sc); break;
         case OP_GOSUB: sGoSub(sc); break;
         case OP_RETURN: sReturn(sc); break;
-        case OP_RETURN_INT: sReturnInt(sc); break;
-        case OP_RETURN_BOOL:
-            sReturnBool(sc);
-            break;
-            // case OP_SET_RETURN: sSetReturn(sc); break;
-            // case OP_DUPLICATE: sDuplicate(sc); break;
-            // case OP_ALLOCATE_ARRAY: sAllocateArray(sc); break;
-            // case OP_ARRAY_LENGTH: sArrayLength(sc); break;
+        case OP_RETURN_INT: RETURN(int, Int); break;
+        case OP_RETURN_BOOL: RETURN(bool, Bool); break;
         case OP_RESERVE: sReserveBytes(sc); break;
         case OP_LOAD_INT: sLoad(sc, sizeof(int)); break;
         case OP_STORE_INT: sStore(sc, sizeof(int)); break;

vm/Script.h

@@ -5,7 +5,6 @@
 
 #include "vm/Allocator.h"
 #include "vm/ByteCode.h"
-#include "vm/Object.h"
 
 #define SCRIPT_STACK_SIZE 1000
 #define SCRIPT_ERROR_SIZE 256