support for empty classes

Author: penelopeysm

src/chunk.cpp

@@ -234,6 +234,12 @@ size_t lox::Chunk::disassemble(std::ostream& os, size_t offset,
     os << "POP\n";
     return offset + 1;
   }
+  case OpCode::CLASS: {
+    uint8_t constant_index = code[offset + 1];
+    Value constant = constants[constant_index];
+    os << "CLASS " << constant << "\n";
+    return offset + 2;
+  }
   case OpCode::GET_GLOBAL: {
     uint8_t constant_index = code[offset + 1];
     Value constant = constants[constant_index];

src/chunk.hpp

@@ -38,6 +38,7 @@ enum class OpCode {
   GET_UPVALUE,
   SET_UPVALUE,
   CLOSE_UPVALUE,
+  CLASS,
   // more to come
 };
 

src/compiler.cpp

@@ -386,11 +386,33 @@ void Parser::declaration() {
     var_declaration();
   } else if (consume_if(TokenType::FUN)) {
     function();
+  } else if (consume_if(TokenType::CLASS)) {
+    class_declaration();
   } else {
     statement();
   }
 }
 
+void Parser::class_declaration() {
+  // class token already consumed
+  consume_or_error(TokenType::IDENTIFIER, "expected class name");
+  std::string_view class_name = previous.lexeme;
+
+  // Store the class name in the constant table. The CLASS instruction will
+  // construct the ObjClass at runtime and put it on the stack.
+  uint8_t name_constant_index = make_constant(gc.get_string_ptr(class_name));
+  emit(lox::OpCode::CLASS);
+  emit(name_constant_index);
+
+  // This call will emit code to read from the top of the stack and create
+  // either a local or global variable with the class.
+  define_variable(class_name);
+
+  consume_or_error(TokenType::LEFT_BRACE, "expected '{' before class body");
+  // TODO class body
+  consume_or_error(TokenType::RIGHT_BRACE, "expected '}' after class body");
+}
+
 void Parser::var_declaration() {
   // Parse identifier
   consume_or_error(TokenType::IDENTIFIER, "expected variable name");

src/compiler.hpp

@@ -131,6 +131,7 @@ class Parser {
   void function();
   void declaration();
   void var_declaration();
+  void class_declaration();
   void statement();
   void print_statement();
   void if_statement();

src/gc.cpp

@@ -88,6 +88,8 @@ void GC::gc() {
       break;
     case ObjType::NATIVE_FUNCTION:
       break;
+    case ObjType::CLASS:
+      break;
     case ObjType::FUNCTION: {
       ObjFunction* p = static_cast<ObjFunction*>(objptr);
       for (const auto& constant : p->chunk.get_constants()) {
@@ -111,6 +113,11 @@ void GC::gc() {
       }
       break;
     }
+    case ObjType::INSTANCE: {
+      // TODO
+      throw std::runtime_error(
+          "GC: mark_as_grey: unimplemented for ObjType::INSTANCE");
+    }
     }
 
 #ifdef LOX_GC_DEBUG

src/value.hpp

@@ -5,7 +5,6 @@
 #include <functional>
 #include <iostream>
 #include <stddef.h>
-#include <stdexcept>
 #include <stdint.h>
 #include <string>
 #include <string_view>
@@ -16,7 +15,15 @@ namespace lox {
 
 enum class InterpretResult { OK, COMPILE_ERROR, RUNTIME_ERROR };
 
-enum class ObjType { STRING, FUNCTION, UPVALUE, CLOSURE, NATIVE_FUNCTION };
+enum class ObjType {
+  STRING,
+  FUNCTION,
+  UPVALUE,
+  CLOSURE,
+  NATIVE_FUNCTION,
+  CLASS,
+  INSTANCE
+};
 
 // Forward declarations
 class GC;
@@ -126,6 +133,29 @@ class ObjNativeFunction : public Obj {
   std::function<Value(size_t arg_count, const Value* args)> function;
 };
 
+class ObjClass : public Obj {
+public:
+  ObjClass(std::string_view name)
+      : Obj(ObjType::CLASS), name(std::string(name)) {}
+
+  std::string to_repr() const override { return "<class " + name + ">"; }
+
+private:
+  std::string name;
+};
+
+class ObjInstance : public Obj {
+public:
+  ObjInstance(ObjClass* klass) : Obj(ObjType::INSTANCE), klass(klass) {}
+
+  std::string to_repr() const override {
+    return "<instance of " + klass->to_repr() + ">";
+  }
+
+private:
+  ObjClass* klass;
+};
+
 bool is_truthy(const Value& value);
 bool is_equal(const Value& a, const Value& b);
 Value add(const Value& a, const Value& b, GC& gc);

src/vm.cpp

@@ -142,7 +142,7 @@ lox::Value VM::stack_peek() {
   return stack.back();
 }
 
-std::string VM::read_global_name() {
+std::string VM::read_constant_string() {
   lox::Value var_name_value = read_constant();
   // This is technically unsafe since the constant could be any Value, but
   // by construction of the parser it should always be a string.
@@ -399,7 +399,7 @@ InterpretResult VM::run() {
         // have a DEFINE_GLOBAL instruction followed by the constant index.
         // When we get here we have already seen the DEFINE_GLOBAL
         // instruction, so we need to read the variable name.
-        std::string var_name = read_global_name();
+        std::string var_name = read_constant_string();
         // After this, the parser will have emitted bytecode that pushes the
         // value of the variable onto the stack. So we need to pop that value.
         // (Or, following the book, just peek it now and pop it later, after
@@ -414,8 +414,14 @@ InterpretResult VM::run() {
         stack_pop(); // now pop the value
         break;
       }
+      case OpCode::CLASS: {
+        std::string class_name = read_constant_string();
+        auto new_class = _gc.alloc<ObjClass>(class_name);
+        stack_push(new_class);
+        break;
+      }
       case OpCode::GET_GLOBAL: {
-        std::string var_name = read_global_name();
+        std::string var_name = read_constant_string();
         // Now that we have the name of the variable, we can look it up in our
         // map
         auto it = globals.find(var_name);
@@ -426,7 +432,7 @@ InterpretResult VM::run() {
         break;
       }
       case OpCode::SET_GLOBAL: {
-        std::string var_name = read_global_name();
+        std::string var_name = read_constant_string();
         auto it = globals.find(var_name);
         if (it == globals.end()) {
           error("undefined variable '" + var_name + "'");

src/vm.hpp

@@ -110,7 +110,7 @@ class VM {
   // pointer.
   lox::Value read_constant();
   // Read the name of a global variable from the chunk's constant table.
-  std::string read_global_name();
+  std::string read_constant_string();
 
   void error(const std::string& message);
 

test.lox

@@ -1,9 +1,3 @@
-fun bench() {
-    fun add(a, b) { return a + b; }
-    var result = 0;
-    for (var i = 0; i < 10000000; i = i + 1) {
-      result = add(result, 1);
-    }
-    return result;
-}
-print bench();
+class Cat {}
+
+print Cat;