Merge branch 'master' into llvm

CppEmitter.cpp

@@ -294,102 +294,58 @@ void CppEmitter::emit(VarDeclaration const& decl) {
     }
 }
 
-void CppEmitter::emitExp(char const* symbol, ExpNode const& node) {
+std::ostream& operator<<(std::ostream &stream, Operator op) {
+    switch (op) {
+        case Operator::PLUS:
+            stream << '+';
+            break;
+        case Operator::MINUS:
+            stream << '-';
+            break;
+        case Operator::TIMES:
+            stream << '*';
+            break;
+        case Operator::DIV:
+            stream << '/';
+            break;
+        case Operator::SHL:
+            stream << "<<";
+            break;
+        case Operator::SHR:
+            stream << ">>";
+            break;
+        case Operator::LT:
+            stream << '<';
+            break;
+        case Operator::GT:
+            stream << '>';
+            break;
+        case Operator::GTE:
+            stream << ">=";
+            break;
+        case Operator::LTE:
+            stream << "<=";
+            break;
+        case Operator::EQ:
+            stream << "==";
+            break;
+    }
+
+    return stream;
+}
+
+void CppEmitter::emit(BinaryExpression const& node) {
     node.getLeft().emit(this);
-    stream << ' ' << symbol << ' ';
+    stream << ' ' << node.getOperator() << ' ';
     node.getRight().emit(this);
 }
 
-void CppEmitter::emitSemiExp(char const* symbol, SemiExpNode const& node) {
+void CppEmitter::emit(BinarySemiExpression const& node) {
     bool braces = (dynamic_cast<SimpleExpression const*>(&node.getLeft()) == nullptr);
 
-    stream << ' ' << symbol << ' ';
+    stream << ' ' << node.getOperator() << ' ';
     if (braces) stream << "(";    
     node.getLeft().emit(this);
     if (braces) stream << ")";
 }
 
-void CppEmitter::emit(ExpLt const& node) {
-    emitExp("<", node);
-}
-
-void CppEmitter::emit(ExpGt const& node) {
-    emitExp(">", node);
-}
-
-void CppEmitter::emit(ExpLte const& node) {
-    emitExp("<=", node);
-}
-
-void CppEmitter::emit(ExpGte const& node) {
-    emitExp(">=", node);
-}
-
-void CppEmitter::emit(ExpPlus const& node) {
-    emitExp("+", node);
-}
-
-void CppEmitter::emit(ExpMinus const& node) {
-    emitExp("-", node);
-}
-
-void CppEmitter::emit(ExpTimes const& node) {
-    emitExp("*", node);
-}
-
-void CppEmitter::emit(ExpDiv const& node) {
-    emitExp("/", node);
-}
-
-void CppEmitter::emit(ExpShl const& node) {
-    emitExp("<<", node);
-}
-
-void CppEmitter::emit(ExpShr const& node) {
-    emitExp(">>", node);
-}
-
-void CppEmitter::emit(SemiExpEq const& node) {
-    emitSemiExp("==", node);
-}
-
-void CppEmitter::emit(SemiExpLt const& node) {
-    emitSemiExp("<", node);
-}
-
-void CppEmitter::emit(SemiExpGt const& node) {
-    emitSemiExp(">", node);
-}
-
-void CppEmitter::emit(SemiExpLte const& node) {
-    emitSemiExp("<=", node);
-}
-
-void CppEmitter::emit(SemiExpGte const& node) {
-    emitSemiExp(">=", node);
-}
-
-void CppEmitter::emit(SemiExpPlus const& node) {
-    emitSemiExp("+", node);
-}
-
-void CppEmitter::emit(SemiExpMinus const& node) {
-    emitSemiExp("-", node);
-}
-
-void CppEmitter::emit(SemiExpTimes const& node) {
-    emitSemiExp("*", node);
-}
-
-void CppEmitter::emit(SemiExpDiv const& node) {
-    emitSemiExp("/", node);
-}
-
-void CppEmitter::emit(SemiExpShl const& node) {
-    emitSemiExp("<<", node);
-}
-
-void CppEmitter::emit(SemiExpShr const& node) {
-    emitSemiExp(">>", node);
-}
-

CppEmitter.hpp

@@ -31,9 +31,6 @@ class CppEmitter: public Emitter {
 public:
     CppEmitter(std::ostream *stream): stream(*stream), indent_chars(0) {}
 
-    virtual void emit(Id const&) override;
-    virtual void emit(Integer const&) override;
-    virtual void emit(Float const&) override;
     virtual void emit(Return const&) override;
     virtual void emit(Loop const&) override;
     virtual void emit(VarDeclaration const&) override;
@@ -49,32 +46,15 @@ public:
     virtual void emit(Function const&) override;
     virtual void emit(Module const&) override;
     virtual void emit(Program const&) override;
-    virtual void emit(ExpLt const&) override;
+
-    virtual void emit(ExpGt const&) override;
+    virtual void emit(Id const&) override;
-    virtual void emit(ExpLte const&) override;
+    virtual void emit(Integer const&) override;
-    virtual void emit(ExpGte const&) override;
+    virtual void emit(Float const&) override;
-    virtual void emit(ExpPlus const&) override;
+    virtual void emit(BinaryExpression const&) override;
-    virtual void emit(ExpMinus const&) override;
+    virtual void emit(BinarySemiExpression const&) override;
-    virtual void emit(ExpTimes const&) override;
-    virtual void emit(ExpDiv const&) override;
-    virtual void emit(ExpShl const&) override;
-    virtual void emit(ExpShr const&) override;
-    virtual void emit(SemiExpEq const&) override;
-    virtual void emit(SemiExpLt const&) override;
-    virtual void emit(SemiExpGt const&) override;
-    virtual void emit(SemiExpLte const&) override;
-    virtual void emit(SemiExpGte const&) override;
-    virtual void emit(SemiExpPlus const&) override;
-    virtual void emit(SemiExpMinus const&) override;
-    virtual void emit(SemiExpTimes const&) override;
-    virtual void emit(SemiExpDiv const&) override;
-    virtual void emit(SemiExpShl const&) override;
-    virtual void emit(SemiExpShr const&) override;
 
 private:
     void emitIndent();
-    void emitExp(char const* symbol, ExpNode const& node);
-    void emitSemiExp(char const* symbol, SemiExpNode const& node);
     void emitFunctionSignature(Function const& function);
     void emitFunctionParams(PointerList<FunArg> const& funargs);
     void emitFunctionArglist(PointerList<Expression> const& args);

Emitter.hpp

@@ -41,34 +41,12 @@ class Main;
 class Function;
 class Module;
 class Program;
-class ExpLt;
+class BinaryExpression;
-class ExpGt;
+class BinarySemiExpression;
-class ExpLte;
-class ExpGte;
-class ExpPlus;
-class ExpMinus;
-class ExpTimes;
-class ExpDiv;
-class ExpShl;
-class ExpShr;
-class SemiExpEq;
-class SemiExpLt;
-class SemiExpGt;
-class SemiExpLte;
-class SemiExpGte;
-class SemiExpPlus;
-class SemiExpMinus;
-class SemiExpTimes;
-class SemiExpDiv;
-class SemiExpShl;
-class SemiExpShr;
 
 
 class Emitter {
 public:
-    virtual void emit(Id const&) = 0;
-    virtual void emit(Integer const&) = 0;
-    virtual void emit(Float const&) = 0;
     virtual void emit(Return const&) = 0;
     virtual void emit(Loop const&) = 0;
     virtual void emit(VarDeclaration const&) = 0;
@@ -84,27 +62,12 @@ public:
     virtual void emit(Function const&) = 0;
     virtual void emit(Module const&) = 0;
     virtual void emit(Program const&) = 0;
-    virtual void emit(ExpLt const&) = 0;
+
-    virtual void emit(ExpGt const&) = 0;
+    virtual void emit(Id const&) = 0;
-    virtual void emit(ExpLte const&) = 0;
+    virtual void emit(Integer const&) = 0;
-    virtual void emit(ExpGte const&) = 0;
+    virtual void emit(Float const&) = 0;
-    virtual void emit(ExpPlus const&) = 0;
+    virtual void emit(BinaryExpression const&) = 0;
-    virtual void emit(ExpMinus const&) = 0;
+    virtual void emit(BinarySemiExpression const&) = 0;
-    virtual void emit(ExpTimes const&) = 0;
-    virtual void emit(ExpDiv const&) = 0;
-    virtual void emit(ExpShl const&) = 0;
-    virtual void emit(ExpShr const&) = 0;
-    virtual void emit(SemiExpEq const&) = 0;
-    virtual void emit(SemiExpLt const&) = 0;
-    virtual void emit(SemiExpGt const&) = 0;
-    virtual void emit(SemiExpLte const&) = 0;
-    virtual void emit(SemiExpGte const&) = 0;
-    virtual void emit(SemiExpPlus const&) = 0;
-    virtual void emit(SemiExpMinus const&) = 0;
-    virtual void emit(SemiExpTimes const&) = 0;
-    virtual void emit(SemiExpDiv const&) = 0;
-    virtual void emit(SemiExpShl const&) = 0;
-    virtual void emit(SemiExpShr const&) = 0;
 };
 
 }

Nodes.hpp

@@ -520,9 +520,21 @@ private:
 };
 
 
-class ExpNode: public Expression {
+enum class Operator {
+    PLUS, MINUS, TIMES, DIV,
+    SHL, SHR,
+    LT, GT, GTE, LTE, EQ
+};
+
+
+class BinaryExpression: public Expression {
 public:
-    ExpNode(Expression *l, Expression *r): left(l), right(r) {}
+    BinaryExpression(Expression *l, Operator op, Expression *r):
+        left(l), op(op), right(r) {}
+
+    virtual void emit(Emitter *emitter) const {
+        emitter->emit(*this);
+    }
 
     Expression const& getLeft() const {
         return *left;
@@ -532,233 +544,163 @@ public:
         return *right;
     }
 
+    Operator getOperator() const {
+        return op;
+    }
+
 private:
     Pointer<Expression> left;
+    Operator op;
     Pointer<Expression> right;
 };
 
 
-class ExpLt: public ExpNode {
+class ExpLt: public BinaryExpression {
 public:
-    ExpLt(Expression *l, Expression *r): ExpNode(l, r) {}
+    ExpLt(Expression *l, Expression *r): BinaryExpression(l, Operator::LT, r) {}
+};
+
+
+class ExpGt: public BinaryExpression {
+public:
+    ExpGt(Expression *l, Expression *r): BinaryExpression(l, Operator::GT, r) {}
+};
+
+
+class ExpLte: public BinaryExpression {
+public:
+    ExpLte(Expression *l, Expression *r): BinaryExpression(l, Operator::LTE, r) {}
+};
+
+
+class ExpGte: public BinaryExpression {
+public:
+    ExpGte(Expression *l, Expression *r): BinaryExpression(l, Operator::GTE, r) {}
+};
+
+
+class ExpPlus: public BinaryExpression {
+public:
+    ExpPlus(Expression *l, Expression *r): BinaryExpression(l, Operator::PLUS, r) {}
+
+};
+
+
+class ExpMinus: public BinaryExpression {
+public:
+    ExpMinus(Expression *l, Expression *r): BinaryExpression(l, Operator::MINUS, r) {}
+};
+
+
+class ExpTimes: public BinaryExpression {
+public:
+    ExpTimes(Expression *l, Expression *r): BinaryExpression(l, Operator::TIMES, r) {}
+};
+
+
+class ExpDiv: public BinaryExpression {
+public:
+    ExpDiv(Expression *l, Expression *r): BinaryExpression(l, Operator::DIV, r) {}
+};
+
+
+class ExpShl: public BinaryExpression {
+public:
+    ExpShl(Expression *l, Expression *r): BinaryExpression(l, Operator::SHL, r) {}
+};
+
+
+class ExpShr: public BinaryExpression {
+public:
+    ExpShr(Expression *l, Expression *r): BinaryExpression(l, Operator::SHR, r) {}
+};
+
+
+class BinarySemiExpression: public SemiExpression {
+public:
+    BinarySemiExpression(Operator op, Expression *l): op(op), left(l) {}
 
     virtual void emit(Emitter *emitter) const {
         emitter->emit(*this);
     }
-};
-
-
-class ExpGt: public ExpNode {
-public:
-    ExpGt(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpLte: public ExpNode {
-public:
-    ExpLte(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpGte: public ExpNode {
-public:
-    ExpGte(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpPlus: public ExpNode {
-public:
-    ExpPlus(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpMinus: public ExpNode {
-public:
-    ExpMinus(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpTimes: public ExpNode {
-public:
-    ExpTimes(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpDiv: public ExpNode {
-public:
-    ExpDiv(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpShl: public ExpNode {
-public:
-    ExpShl(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class ExpShr: public ExpNode {
-public:
-    ExpShr(Expression *l, Expression *r): ExpNode(l, r) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
-};
-
-
-class SemiExpNode: public SemiExpression {
-public:
-    SemiExpNode(Expression *l): left(l) {}
 
     Expression const& getLeft() const {
         return *left;
     }
 
+    Operator getOperator() const {
+        return op;
+    }
+
 private:
+    Operator op;
     Pointer<Expression> left;
 };
 
 
-
+class SemiExpEq: public BinarySemiExpression {
-class SemiExpEq: public SemiExpNode {
 public:
-    SemiExpEq(Expression *l): SemiExpNode(l) {}
+    SemiExpEq(Expression *l): BinarySemiExpression(Operator::EQ, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpLt: public SemiExpNode {
+class SemiExpLt: public BinarySemiExpression {
 public:
-    SemiExpLt(Expression *l): SemiExpNode(l) {}
+    SemiExpLt(Expression *l): BinarySemiExpression(Operator::LT, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpGt: public SemiExpNode {
+class SemiExpGt: public BinarySemiExpression {
 public:
-    SemiExpGt(Expression *l): SemiExpNode(l) {}
+    SemiExpGt(Expression *l): BinarySemiExpression(Operator::GT, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpLte: public SemiExpNode {
+class SemiExpLte: public BinarySemiExpression {
 public:
-    SemiExpLte(Expression *l): SemiExpNode(l) {}
+    SemiExpLte(Expression *l): BinarySemiExpression(Operator::LTE, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpGte: public SemiExpNode {
+class SemiExpGte: public BinarySemiExpression {
 public:
-    SemiExpGte(Expression *l): SemiExpNode(l) {}
+    SemiExpGte(Expression *l): BinarySemiExpression(Operator::GTE, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpPlus: public SemiExpNode {
+class SemiExpPlus: public BinarySemiExpression {
 public:
-    SemiExpPlus(Expression *l): SemiExpNode(l) {}
+    SemiExpPlus(Expression *l): BinarySemiExpression(Operator::PLUS, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpMinus: public SemiExpNode {
+class SemiExpMinus: public BinarySemiExpression {
 public:
-    SemiExpMinus(Expression *l): SemiExpNode(l) {}
+    SemiExpMinus(Expression *l): BinarySemiExpression(Operator::MINUS, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpTimes: public SemiExpNode {
+class SemiExpTimes: public BinarySemiExpression {
 public:
-    SemiExpTimes(Expression *l): SemiExpNode(l) {}
+    SemiExpTimes(Expression *l): BinarySemiExpression(Operator::TIMES, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpDiv: public SemiExpNode {
+class SemiExpDiv: public BinarySemiExpression {
 public:
-    SemiExpDiv(Expression *l): SemiExpNode(l) {}
+    SemiExpDiv(Expression *l): BinarySemiExpression(Operator::DIV, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpShl: public SemiExpNode {
+class SemiExpShl: public BinarySemiExpression {
 public:
-    SemiExpShl(Expression *l): SemiExpNode(l) {}
+    SemiExpShl(Expression *l): BinarySemiExpression(Operator::SHR, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 
-class SemiExpShr: public SemiExpNode {
+class SemiExpShr: public BinarySemiExpression {
 public:
-    SemiExpShr(Expression *l): SemiExpNode(l) {}
+    SemiExpShr(Expression *l): BinarySemiExpression(Operator::SHL, l) {}
-
-    virtual void emit(Emitter *emitter) const {
-        emitter->emit(*this);
-    }
 };
 
 } // namespace