REPL: add support for printing arrays

include/vm.h

@@ -70,7 +70,8 @@ struct FunctionType : public VariableType {
 struct Object {
     enum class Type {
         Invalid = 0,
-        String
+        String,
+        Array,
     } objType;
     Object() : objType(Type::Invalid){};
     explicit Object(Type type) : objType(type){};
@@ -81,7 +82,6 @@ struct StringObject : public Object {
     char *chars;
     StringObject(size_t length, char *chars) : Object(Type::String), length(length), chars(chars){};
     inline bool operator==(StringObject &other) const {
-        if (objType != other.objType) return false;
         if (length != other.length) return false;
         return std::memcmp(chars, other.chars, length) == 0;
     }
@@ -93,7 +93,7 @@ struct StringObject : public Object {
 struct ArrayObject : public Object {
     uint64_t *data;
     size_t size;
-    ArrayObject(size_t size, uint64_t *data) : size(size), data(data) {}
+    ArrayObject(size_t size, uint64_t *data) : Object(Object::Type::Array), size(size), data(data) {}
     inline bool operator==(ArrayObject &other) const {
         if (size != other.size) return false;
         for (size_t i = 0; i < size; i++) {

main.cpp

@@ -20,6 +20,14 @@ void printTopStack(const VM &vm, const Program &program) {
             auto obj = std::bit_cast<Object *>(vm.topStack());
             if (obj->objType == Object::Type::String) {
                 std::cout << static_cast<StringObject *>(obj)->chars << std::endl;
+            } else if (obj->objType == Object::Type::Array) {
+                auto array = static_cast<ArrayObject *>(obj);
+                std::cout << "[";
+                for (size_t i = 0; i < array->size; i++) {
+                    std::cout << array->data[i];
+                    if (i != array->size - 1) std::cout << ", ";
+                }
+                std::cout << "]" << std::endl;
             }
         }
         default:

src/utils.cpp

@@ -168,6 +168,9 @@ VariableType::Type getInstructionType(const Program &program, const Instruction
         case Instruction::InstructionType::LoadGlobalObject:
         case Instruction::InstructionType::MakeArray:
             return VariableType::Object;
+        case Instruction::InstructionType::LoadArrayElement:
+            // TODO: Handle other types
+            return VariableType::I64;
         case Instruction::InstructionType::Call: {
             auto func_index = instruction.params.index;
             auto function = program.segments[func_index];