add Base Class feature

CMakeLists.txt

@@ -4,13 +4,21 @@ project(cpp_lox LANGUAGES CXX)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
-set(CMAKE_AUTOUIC ON)
-set(CMAKE_AUTOMOC ON)
-set(CMAKE_AUTORCC ON)
-
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-add_executable(cpp_lox
-  main.cpp
-)
+set(SOURCE_FILES
+        LoxInstance.cpp LoxInstance.hpp
+        LoxClass.cpp LoxClass.hpp
+        Resolver.cpp Resolver.hpp
+        Token.cpp Token.hpp
+        LoxFunction.cpp LoxFunction.hpp
+        Environment.cpp Environment.hpp
+        Interpreter.cpp Interpreter.hpp
+        lox.cpp lox.hpp
+        Parser.cpp Parser.hpp
+        Scanner.cpp Scanner.hpp
+        Stmt.hpp Expr.hpp
+        main.cpp
+        )
+add_executable(cpp_lox ${SOURCE_FILES})

Interpreter.cpp

@@ -15,6 +15,7 @@
 #include "./LoxCallable.hpp"
 #include "./LoxFunction.hpp"
 #include "./ReturnError.hpp"
+#include "./LoxClass.hpp"
 #include "./lox.hpp"
 
 using std::stod;
@@ -184,18 +185,24 @@ Object Interpreter::visitCallExpr(shared_ptr<Call<Object>> expr) {
       arguments.push_back(evaluate(argument));
     }
 
-    if (callee.type != Object::Object_fun) {
+    if (callee.type != Object::Object_fun && callee.type != Object::Object_class) {
         throw RuntimeError(expr->paren,
           "Can only call functions and classes.");
     }
 
-    shared_ptr<LoxCallable> function = callee.function;
-    if (arguments.size() != function->arity()) {
+    shared_ptr<LoxCallable> callable;
+    if (callee.type == Object::Object_fun) {
+        callable = callee.function;
+    }
+    if (callee.type == Object::Object_class) {
+        callable = callee.lox_class;
+    }
+    if (arguments.size() != callable->arity()) {
       throw RuntimeError(expr->paren, "Expected " +
-          to_string(function->arity()) + " arguments but got " +
+          to_string(callable->arity()) + " arguments but got " +
           to_string(arguments.size()) + ".");
     }
-    return function->call(shared_from_this(), arguments);
+    return callable->call(shared_from_this(), arguments);
 }
 
 void Interpreter::visitExpressionStmt(const Expression& stmt) {
@@ -226,6 +233,12 @@ void Interpreter::visitBlockStmt(const Block& stmt) {
     executeBlock(stmt.statements, env);
 }
 
+void Interpreter::visitClassStmt(const Class& stmt) {
+    environment->define(stmt.name.lexeme, Object::make_nil_obj());
+    auto klass = shared_ptr<LoxClass>(new LoxClass(stmt.name.lexeme));
+    environment->assign(stmt.name, Object::make_class_obj(klass));
+}
+
 void Interpreter::visitWhileStmt(const While& stmt) {
     while (isTruthy(evaluate(stmt.condition))) {
       Object obj =  evaluate(stmt.condition);

Interpreter.hpp

@@ -38,6 +38,7 @@ class Interpreter:
     void visitPrintStmt(const Print& stmt);
     void visitVarStmt(const Var& stmt);
     void visitBlockStmt(const Block& stmt);
+    void visitClassStmt(const Class& stmt);
     void visitIfStmt(const If& stmt);
     void visitWhileStmt(const While& stmt);
     void visitFunctionStmt(const Function& stmt);

LoxClass.cpp

@@ -0,0 +1,31 @@
+// Copyright 2020.2.23 <Copyright hulin>
+
+#include <string>
+#include <memory>
+#include <vector>
+
+#include "./LoxClass.hpp"
+#include "./LoxInstance.hpp"
+#include "./Interpreter.hpp"
+#include "./Token.hpp"
+
+using std::string;
+using std::shared_ptr;
+using std::vector;
+
+
+LoxClass::LoxClass(string name_): name(name_) {}
+
+Object LoxClass::call(
+        shared_ptr<Interpreter> interpreter,
+        vector<Object> arguments) {
+    auto instance = shared_ptr<LoxInstance>(new LoxInstance(*this));
+    return Object::make_instance_obj(instance);
+}
+
+int LoxClass::arity() {
+    return 0;
+}
+string LoxClass::toString() {
+    return name;
+}

LoxClass.hpp

@@ -0,0 +1,28 @@
+// Copyright 2020.2.23 <Copyright hulin>
+
+#ifndef LOXCLASS_HPP_
+#define LOXCLASS_HPP_
+
+#include <string>
+#include <memory>
+#include <vector>
+#include "./LoxCallable.hpp"
+#include "./Interpreter.hpp"
+#include "./Token.hpp"
+
+using std::string;
+using std::shared_ptr;
+using std::vector;
+
+class LoxClass: public LoxCallable {
+ public:
+    string name;
+    explicit LoxClass(string name_);
+    Object call(
+        shared_ptr<Interpreter> interpreter,
+        vector<Object> arguments);
+    int arity();
+    string toString();
+};
+
+#endif  // LOXCLASS_HPP_

LoxInstance.cpp

@@ -0,0 +1,14 @@
+// Copyright 2020.2.23 <Copyright hulin>
+
+#include <string>
+
+#include "./LoxInstance.hpp"
+#include "./LoxClass.hpp"
+
+using std::string;
+
+LoxInstance::LoxInstance(LoxClass klass_): klass(klass_) {}
+
+string LoxInstance::toString() {
+    return klass.name + " instance";
+}

LoxInstance.hpp

@@ -0,0 +1,18 @@
+// Copyright 2020.2.23 <Copyright hulin>
+
+#ifndef LOXINSTANCE_HPP_
+#define LOXINSTANCE_HPP_
+
+#include <string>
+#include "./LoxClass.hpp"
+
+using std::string;
+
+class LoxInstance {
+ public:
+    LoxClass klass;
+    explicit LoxInstance(LoxClass klass_);
+    string toString();
+};
+
+#endif  // LOXINSTANCE_HPP_

Makefile

@@ -1,21 +1,20 @@
 CXXFLAGS=-g -std=c++11 -Wall -pedantic
 CXX = g++
 
-all: main test demo
+all: main
 
+LoxInstance.o:	LoxInstance.cpp LoxInstance.hpp
+LoxClass.o:	LoxClass.cpp LoxClass.hpp
 Resolver.o:	Resolver.cpp Resolver.hpp
 Token.o:	Token.cpp Token.hpp
 LoxFunction.o: LoxFunction.cpp LoxFunction.hpp
 Environment.o: Environment.cpp Environment.hpp
-Interpreter.o:	Interpreter.cpp Interpreter.hpp Environment.o LoxFunction.o
-lox.o:	lox.cpp lox.hpp Interpreter.o Resolver.o
+Interpreter.o:	Interpreter.cpp Interpreter.hpp
+lox.o:	lox.cpp lox.hpp
 Parser.o:	Parser.cpp Parser.hpp
 Scanner.o:	Scanner.cpp Scanner.hpp
-AstPrinter.o: AstPrinter.hpp AstPrinter.cpp
 
-main: main.cpp lox.o LoxFunction.o Token.o Scanner.o Parser.o Interpreter.o Environment.o Resolver.o
-test: test.cpp AstPrinter.o Token.o
-demo: demo.cpp
+main: main.cpp lox.o LoxFunction.o Token.o Scanner.o Parser.o Interpreter.o Environment.o Resolver.o LoxClass.o LoxInstance.o
 
 clean:
 	rm -f *.o main

Parser.cpp

@@ -423,6 +423,7 @@ shared_ptr<Stmt> Parser::varDeclaration() {
 
 shared_ptr<Stmt> Parser::declaration() {
   try {
+    if (match({ CLASS })) return classDeclaration();
     if (match({ FUN })) return function("function");
     if (match({ VAR })) return varDeclaration();
     return statement();
@@ -432,6 +433,19 @@ shared_ptr<Stmt> Parser::declaration() {
   }
 }
 
+shared_ptr<Stmt> Parser::classDeclaration() {
+    Token name = consume(IDENTIFIER, "Expect class name.");
+    consume(LEFT_BRACE, "Expect '{' before class body.");
+
+    vector<shared_ptr<Stmt>> methods;
+    while (!check(RIGHT_BRACE) && !isAtEnd()) {
+      methods.push_back(function("method"));
+    }
+    consume(RIGHT_BRACE, "Expect '}' after class body.");
+
+    return shared_ptr<Stmt>(new Class(name, methods));
+}
+
 vector<shared_ptr<Stmt>> Parser::parse() {
   vector<shared_ptr<Stmt>> statements;
   while (!isAtEnd()) {

Parser.hpp

@@ -56,6 +56,7 @@ class Parser {
     shared_ptr<Stmt> expressionStatement();
     shared_ptr<Stmt> function(string kind);
     shared_ptr<Stmt> declaration();
+    shared_ptr<Stmt> classDeclaration();
     shared_ptr<Stmt> varDeclaration();
     vector<shared_ptr<Stmt>> block();
 };

Resolver.cpp

@@ -95,6 +95,11 @@ void Resolver::visitBlockStmt(const Block& stmt) {
     endScope();
 }
 
+void Resolver::visitClassStmt(const Class& stmt) {
+    declare(stmt.name);
+    define(stmt.name);
+}
+
 void Resolver::visitIfStmt(const If& stmt) {
     resolve(stmt.condition);
     resolve(stmt.thenBranch);

Resolver.hpp

@@ -37,6 +37,7 @@ class Resolver:
     void visitPrintStmt(const Print& stmt);
     void visitVarStmt(const Var& stmt);
     void visitBlockStmt(const Block& stmt);
+    void visitClassStmt(const Class& stmt);
     void visitIfStmt(const If& stmt);
     void visitWhileStmt(const While& stmt);
     void visitFunctionStmt(const Function& stmt);

Stmt.hpp

@@ -3,10 +3,13 @@
 /*
 program     → declaration* EOF ;
 
-declaration → funDecl
+declaration → classDecl 
+            |funDecl
             | varDecl
             | statement ;
 
+classDecl   → "class" IDENTIFIER "{" function* "}" ;
+
 funDecl  → "fun" function ;
 function → IDENTIFIER "(" parameters? ")" block ;
 parameters → IDENTIFIER ( "," IDENTIFIER )* ;
@@ -59,6 +62,7 @@ class If;
 class While;
 class Function;
 class Return;
+class Class;
 
 class Visitor_Stmt {
  public:
@@ -71,6 +75,7 @@ class Visitor_Stmt {
     virtual void visitWhileStmt(const While& stmt) = 0;
     virtual void visitFunctionStmt(const Function& stmt) = 0;
     virtual void visitReturnStmt(const Return& stmt) = 0;
+    virtual void visitClassStmt(const Class& stmt) = 0;
 };
 
 class Stmt {
@@ -181,4 +186,15 @@ class Return: public Stmt {
     shared_ptr<Expr<Object>> value;
 };
 
+class Class: public Stmt {
+ public:
+    Class(Token name_, vector<shared_ptr<Stmt>> function_):
+    name(name_), function(function_) { }
+    void accept(shared_ptr<Visitor_Stmt> visitor) override {
+        visitor->visitClassStmt(*this);
+    }
+    Token name;
+    vector<shared_ptr<Stmt>> function;
+};
+
 #endif  // STMT_HPP_

Token.hpp

@@ -10,6 +10,8 @@ using std::string;
 using std::shared_ptr;
 
 class LoxCallable;
+class LoxInstance;
+class LoxClass;
 
 typedef enum {
   LEFT_PAREN, RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE,
@@ -39,6 +41,8 @@ class Object {
       Object_bool,
       Object_nil,
       Object_fun,
+      Object_instance,
+      Object_class,
     } Object_type;
     string str;
     double num;
@@ -47,11 +51,15 @@ class Object {
     Object_type type;
     string toString();
     shared_ptr<LoxCallable> function;
+    shared_ptr<LoxInstance> instance;
+    shared_ptr<LoxClass> lox_class;
     static Object make_num_obj(double num);
     static Object make_str_obj(string str);
     static Object make_bool_obj(bool boolean);
     static Object make_nil_obj();
     static Object make_fun_obj(shared_ptr<LoxCallable> function_);
+    static Object make_instance_obj(shared_ptr<LoxInstance> instance_);
+    static Object make_class_obj(shared_ptr<LoxClass> lox_class_);
 };
 
 class Token {