Merge pull request #6 from sriharivishnu/refactor-parser

Refactor parser
sriharivishnu · Sep 30, 2020 · 0d058a3 · 0d058a3
2 parents 34c00f6 + 5a94e09
commit 0d058a3
Show file tree

Hide file tree

Showing 8 changed files with 238 additions and 386 deletions.
diff --git a/include/Expression.h b/include/Expression.h
@@ -126,23 +126,27 @@ class ConditionalExpression : public Expression {
 class CallFunctionExpression : public Expression {
     public:
         CallFunctionExpression(
+            shared_ptr<Expression> left,
             Token tok_, 
             vector<shared_ptr<Expression>> params
         );
         shared_obj accept(Context& context, Visitor& v) override;
         std::string toString() override;
-        vector<shared_ptr<Expression>> params;
+        shared_ptr<Expression> left;
+    vector<shared_ptr<Expression>> params;
 };
 
 class IndexExpression : public Expression {
     public:
         IndexExpression(
+            shared_ptr<Expression> left,
             Token tok_, 
             shared_ptr<Expression> index
         );
         shared_obj accept(Context& context, Visitor& v) override;
         std::string toString() override;
         shared_ptr<Expression> index;
+        shared_ptr<Expression> left;
 };
 
 class ListExpression : public Expression {

diff --git a/include/ParseHelper.h b/include/ParseHelper.h
@@ -1,7 +1,5 @@
 #ifndef PARSER_HELPER
 #define PARSER_HELPER
-#include "Expression.h"
-#include "Parser.h"
 #include "Token.h"
 #include <memory>
 #include <vector>
@@ -16,109 +14,10 @@ enum Precedence {
     EXPONENT = 5, 
     PREFIX = 6,
     POSTFIX = 7,
-    CALL = 8
-};
-class Parser;
-class PrefixParser {
-    public:
-        virtual shared_ptr<Expression> parse(Parser& parser, const Token& token);
-        virtual ~PrefixParser() = default;
-};
-class InfixParser {
-    public:
-        virtual shared_ptr<Expression> parse(Parser& parser, shared_ptr<Expression> left, const Token& token);
-        virtual int getPrecedence();
-        virtual ~InfixParser() = default;
-};
-
-class NameParser : public PrefixParser {
-    public:
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class NumberParser : public PrefixParser {
-    public:
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-class StringParser : public PrefixParser {
-    public:
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class ListParser : public PrefixParser {
-    public:
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class PrefixOperatorParser : public PrefixParser {
-    public:
-        PrefixOperatorParser(int precedence);
-        shared_ptr<Expression> parse(Parser& parser, const Token& token);
-        int getPrecedence() const;
-    private:
-        int precedence;
-};
-
-class PostfixOperatorParser : public InfixParser {
-    public:
-        PostfixOperatorParser(int precedence);
-        shared_ptr<Expression> parse(Parser& parser, shared_ptr<Expression> left, const Token& token) override;
-        int getPrecedence() override;
-    private:
-        int precedence = 0;
-};
-
-class BinaryOperatorParser : public InfixParser {
-    public:
-        BinaryOperatorParser(int precedence, bool isRight);
-        shared_ptr<Expression> parse(Parser& parser, shared_ptr<Expression> left, const Token& token) override;
-        int getPrecedence() override;
-    private:
-        int precedence = 0;
-        bool isRight = false;
-};
-
-class ComparisonParser : public InfixParser {
-    public:
-        ComparisonParser();
-        shared_ptr<Expression> parse(Parser& parser, shared_ptr<Expression> left, const Token& token) override;
-        int getPrecedence() override;
-};
-
-class AssignmentParser : public PrefixParser {
-    public:
-        AssignmentParser();
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class UpdateOrAssignParser : public InfixParser {
-    public:
-        UpdateOrAssignParser();
-        shared_ptr<Expression> parse(Parser& parser, shared_ptr<Expression> left, const Token& token) override;
-        int getPrecedence() override;
-};
-
-class ConditionalParser : public PrefixParser {
-    public:
-        ConditionalParser();
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class GroupParser : public PrefixParser {
-    public:
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class FuncDefParser : public PrefixParser {
-    public:
-        shared_ptr<Expression> parse(Parser& parser, const Token& token) override;
-};
-
-class MemberAccessParser : public InfixParser {
-    public:
-        MemberAccessParser();
-        shared_ptr<Expression> parse(Parser& parser, shared_ptr<Expression> left, const Token& token) override;
-        int getPrecedence() override;
+    INDEX = 8,
+    CALL = 9
 };
+//Infix
+int getTokenPrecedence(const Token& tok);
 
 #endif
diff --git a/include/Parser.h b/include/Parser.h
@@ -18,11 +18,11 @@ class InfixParser;
 class Parser {
     public:
         Parser(std::vector<Token> tokens);
-        void addType(Token::Type type, shared_ptr<PrefixParser> prefix);
-        void addType(Token::Type type, shared_ptr<InfixParser> prefix);
         Token consume();
-        Token consume(Token::Type expected, std::string expectedStr = std::string(""));
+        Token consume(Token::Type expected, const std::string& expectedStr = std::string(""));
 
+        shared_ptr<Expression> getPrefixExpression(const Token& tok);
+        shared_ptr<Expression> getInfixExpression(const shared_ptr<Expression>& left, const Token& tok);
         shared_ptr<Expression> parseExpression(int precedence);
         shared_ptr<Expression> parseExpression();
 
@@ -36,8 +36,6 @@ class Parser {
         int cur = 0;
         vector<Token> tokens;
         vector<Token> mRead;
-        unordered_map<Token::Type, std::shared_ptr<PrefixParser>> mPrefixParsables;
-        unordered_map<Token::Type, std::shared_ptr<InfixParser>> mInfixParsables;
 };
 
 #endif
diff --git a/nova-0.0.2-alpha.tar.gz b/nova-0.0.2-alpha.tar.gz
diff --git a/src/Expression.cpp b/src/Expression.cpp
@@ -175,9 +175,10 @@ std::string ConditionalExpression::toString() {
 }
 
 CallFunctionExpression::CallFunctionExpression(
+            shared_ptr<Expression> left_,
             Token tok_, 
             vector<shared_ptr<Expression>> params
-        ) : params(std::move(params)) { tok = std::move(tok_);}
+        ) : left(std::move(left_)),params(std::move(params)) { tok = std::move(tok_);}
 shared_obj CallFunctionExpression::accept(Context& context, Visitor& v) {
     return v.visit(context, this);
 };
@@ -192,9 +193,10 @@ std::string CallFunctionExpression::toString() {
 };
 
 IndexExpression::IndexExpression(
+            shared_ptr<Expression> left_,
             Token tok_, 
             shared_ptr<Expression> index
-        ) : index(std::move(index)) { tok = std::move(tok_); }
+        ) : index(std::move(index)), left(std::move(left_)) { tok = std::move(tok_); }
 shared_obj IndexExpression::accept(Context& context, Visitor& v) {
     return v.visit(context, this);
 }

diff --git a/src/Interpreter.cpp b/src/Interpreter.cpp
@@ -147,24 +147,18 @@ shared_obj Visitor::visit(Context& context, ConditionalExpression* e) {
     return e->elseBranch->accept(context, *this);
 }
 
-shared_obj Visitor::visit(Context& parent, CallFunctionExpression* e) {
-
-    Visitor v;
-    std::optional<shared_obj> decl = parent.symbols->get(e->getToken().getValue());
-    if (!decl) throw UndefinedVariable(make_shared<Context>(parent), e->getToken().getValue(), e->getToken().startPos);
+shared_obj Visitor::visit(Context& context, CallFunctionExpression* e) {
+    shared_obj decl = e->left->accept(context, *this);
     vector<shared_obj> args;
     for (auto & param : e->params) {
-        args.push_back(param->accept(parent, v));
+        args.push_back(param->accept(context, *this));
     }
-    return decl->get()->call(parent, args);
+    return decl->call(context, args);
 }
 
 shared_obj Visitor::visit(Context& context, IndexExpression* e) {
-    std::optional<shared_obj> value = context.symbols->get(e->getToken().getValue());
-    if (!value) {
-        throw UndefinedVariable(make_shared<Context>(context), e->getToken().getValue(), e->getToken().startPos);
-    }
-    return value->get()->index(e->index->accept(context, *this));
+    shared_obj index_obj = e->index->accept(context, *this);
+    return e->left->accept(context, *this)->index(index_obj);
 }
 shared_obj Visitor::visit(Context& context, FuncDefExpression* e) {
     shared_ptr<func_type> fun = make_shared<func_type>(e->name, e->params, e->body);