feat: add support for string

shejialuo · Apr 1, 2023 · 2d26f20 · 2d26f20
1 parent 1e5601c
commit 2d26f20
Show file tree

Hide file tree

Showing 6 changed files with 124 additions and 3 deletions.
diff --git a/compiler/compiler.cpp b/compiler/compiler.cpp
@@ -57,7 +57,7 @@ void Compiler::compile(Node *node) {
 
   IntegerLiteral *integerLiteral = dynamic_cast<IntegerLiteral *>(node);
   if (integerLiteral != nullptr) {
-    auto integer = std::make_unique<Integer>(integerLiteral->value);
+    std::unique_ptr<Object> integer = std::make_unique<Integer>(integerLiteral->value);
     // Here, we push the index for the constant, not the number itself.
     emit(Ops::OpConstant, {addConstant(integer)});
   }
@@ -159,9 +159,15 @@ void Compiler::compile(Node *node) {
 
     emit(Ops::OpGetGlobal, {symbol.value().get().index});
   }
+
+  StringLiteral *stringLiteral = dynamic_cast<StringLiteral *>(node);
+  if (stringLiteral != nullptr) {
+    std::unique_ptr<Object> string = std::make_unique<String>(stringLiteral->value);
+    emit(Ops::OpConstant, {addConstant(string)});
+  }
 }
 
-int Compiler::addConstant(std::unique_ptr<Integer> &object) {
+int Compiler::addConstant(std::unique_ptr<Object> &object) {
   bytecode.constants.emplace_back(std::move(object));
   return bytecode.constants.size() - 1;
 }

diff --git a/compiler/compiler.hpp b/compiler/compiler.hpp
@@ -56,7 +56,7 @@ class Compiler {
    * @param object
    * @return int
    */
-  int addConstant(std::unique_ptr<Integer> &object);
+  int addConstant(std::unique_ptr<Object> &object);
 
   /**
    * @brief emit the instruction, return the instruction length

diff --git a/compiler/tests/compilerTest.cpp b/compiler/tests/compilerTest.cpp
@@ -28,6 +28,7 @@ std::unique_ptr<Program> parse(const std::string &input);
 Instructions concatInstructions(std::vector<Instructions> &instructions);
 bool testInstructions(const Instructions &expected, const Instructions &actual);
 bool testIntegerObject(int expected, Object *actual);
+bool testStringObject(const std::string &expected, Object *actual);
 
 template <typename T>
 bool testConstants(std::vector<T> &expected, std::vector<std::shared_ptr<Object>> &actual);
@@ -44,6 +45,10 @@ bool testConstants(std::vector<T> &expected, std::vector<std::shared_ptr<Object>
       if (!testIntegerObject(expected[i], actual[i].get())) {
         return false;
       }
+    } else if constexpr (std::is_same_v<std::string, T>) {
+      if (!testStringObject(expected[i], actual[i].get())) {
+        return false;
+      }
     }
   }
 
@@ -97,6 +102,21 @@ bool testIntegerObject(int expected, Object *actual) {
   return true;
 }
 
+bool testStringObject(const std::string &expected, Object *actual) {
+  auto str = dynamic_cast<const String *>(actual);
+  if (str == nullptr) {
+    spdlog::error("object is not String. got={}", actual->type());
+    return false;
+  }
+
+  if (str->value != expected) {
+    spdlog::error("object has wrong value. want={}, got={}", expected, str->value);
+    return false;
+  }
+
+  return true;
+}
+
 TEST(Compiler, TestIntegerArithmetic) {
   std::vector<CompilerTestCase<int>> tests{
       {
@@ -367,3 +387,35 @@ TEST(Compiler, TestGlobalLetStatements) {
     EXPECT_TRUE(testConstants(test.expectedConstants, compiler.getBytecode().constants));
   }
 }
+
+TEST(Compiler, TestStringExpressions) {
+  std::vector<CompilerTestCase<std::string>> tests{
+      {
+          R"("monkey")",
+          {"monkey"},
+          {
+              Code::make(Ops::OpConstant, {0}),
+              Code::make(Ops::OpPop, {}),
+          },
+      },
+      {
+          R"("mon" + "key")",
+          {"mon", "key"},
+          {
+              Code::make(Ops::OpConstant, {0}),
+              Code::make(Ops::OpConstant, {1}),
+              Code::make(Ops::OpAdd, {}),
+              Code::make(Ops::OpPop, {}),
+          },
+      },
+  };
+
+  for (auto &&test : tests) {
+    auto program = parse(test.input);
+    Compiler compiler;
+    compiler.compile(program.get());
+    auto instructions = compiler.getBytecode().instructions;
+    EXPECT_TRUE(testInstructions(test.expectedInstructions, instructions));
+    EXPECT_TRUE(testConstants(test.expectedConstants, compiler.getBytecode().constants));
+  }
+}
diff --git a/vm/tests/vmTest.cpp b/vm/tests/vmTest.cpp
@@ -38,6 +38,8 @@ bool testExpectedObject(const T &expected, Object *actual) {
     return testIntegerObject(expected, actual);
   } else if constexpr (std::is_same_v<bool, T>) {
     return testBooleanObject(expected, actual);
+  } else if constexpr (std::is_same_v<std::string, T>) {
+    return testStringObject(expected, actual);
   }
   return false;
 }
@@ -72,6 +74,21 @@ bool testBooleanObject(bool expected, Object *actual) {
   return true;
 }
 
+bool testStringObject(const std::string &expected, Object *actual) {
+  auto string = dynamic_cast<const String *>(actual);
+  if (string == nullptr) {
+    spdlog::error("object is not String. got={}", actual->type());
+    return false;
+  }
+
+  if (string->value != expected) {
+    spdlog::error("object has wrong value. want={}, got={}", expected, string->value);
+    return false;
+  }
+
+  return true;
+}
+
 TEST(VM, TestIntegerArithmetic) {
   std::vector<vmTestCase<int>> tests{
       {"1", 1},
@@ -203,3 +220,25 @@ TEST(VM, TestGlobalLetStatements) {
     EXPECT_TRUE(testExpectedObject(test.expected, stackElem.get()));
   }
 }
+
+TEST(VM, TestStringExpressions) {
+  std::vector<vmTestCase<std::string>> tests{
+      {"\"monkey\"", "monkey"},
+      {"\"mon\" + \"key\"", "monkey"},
+      {"\"mon\" + \"key\" + \"banana\"", "monkeybanana"},
+  };
+
+  for (auto &&test : tests) {
+    auto program = parse(test.input);
+
+    Compiler compiler;
+    compiler.compile(program.get());
+
+    VM vm{std::move(compiler.getBytecode().constants), std::move(compiler.getBytecode().instructions)};
+    vm.run();
+
+    auto stackElem = vm.lastPoppedStackElem();
+
+    EXPECT_TRUE(testExpectedObject(test.expected, stackElem.get()));
+  }
+}
diff --git a/vm/vm.cpp b/vm/vm.cpp
@@ -104,6 +104,8 @@ void VM::executeBinaryOperation(const Opcode &op) {
 
   if (leftType == INTEGER_OBJ && rightType == INTEGER_OBJ) {
     executeBinaryIntegerOperation(op, left, right);
+  } else if (leftType == STRING_OBJ && rightType == STRING_OBJ) {
+    executeBinaryStringOperation(op, left, right);
   } else {
     spdlog::error("unsupported types for binary operation: {} {}", leftType, rightType);
   }
@@ -133,6 +135,19 @@ void VM::executeBinaryIntegerOperation(const Opcode &op,
   push(resultObject);
 }
 
+void VM::executeBinaryStringOperation(const Opcode &op, std::shared_ptr<Object> &left, std::shared_ptr<Object> &right) {
+  String *rightString = dynamic_cast<String *>(right.get());
+  String *leftString = dynamic_cast<String *>(left.get());
+
+  if (op == Ops::OpAdd) {
+    std::string result = leftString->value + rightString->value;
+    std::shared_ptr<Object> resultObject = std::make_shared<String>(result);
+    push(resultObject);
+  } else {
+    spdlog::error("unknown operator for strings: {}", op);
+  }
+}
+
 void VM::executeComparision(const Opcode &op) {
   auto right = pop();
   auto left = pop();

diff --git a/vm/vm.hpp b/vm/vm.hpp
@@ -87,6 +87,15 @@ class VM {
    */
   void executeBinaryIntegerOperation(const Opcode &op, std::shared_ptr<Object> &left, std::shared_ptr<Object> &right);
 
+  /**
+   * @brief execute the string operator such as add
+   *
+   * @param op the operator
+   * @param left the left object
+   * @param right the right object
+   */
+  void executeBinaryStringOperation(const Opcode &op, std::shared_ptr<Object> &left, std::shared_ptr<Object> &right);
+
   /**
    * @brief execute the comparison such as equal, not equal, greater than, less than
    *