yee

src/Optimizer.cpp

@@ -1,26 +1,27 @@
 #include "Optimizer.h"
+#include "Parser.h"
 
 using namespace zp;
 
-void AstVisitor::visit(Block& block)
+std::unique_ptr<BlockInstruction> AstVisitor::visit(Block& block)
 {
         block.accept(*this);
 }
 
 
-std::unique_ptr<Instruction> Optimizer::visitInstructionBlock(InstructionBlock& ib)
+std::unique_ptr<BlockInstruction> Optimizer::visitInstructionBlock(InstructionBlock& ib)
 {
 
 }
 
 
-std::unique_ptr<Instruction> void Optimizer::visitUnionBlock(UnionBlock& ub)
+std::unique_ptr<BlockInstruction> Optimizer::visitUnionBlock(UnionBlock& ub)
 {
 
 }
 
 
-std::unique_ptr<Instruction> Optimizer::visitLoop(Loop& loop)
+std::unique_ptr<BlockInstruction> Optimizer::visitLoop(Loop& loop)
 {
 
 }

src/Optimizer.h

@@ -1,43 +1,53 @@
 #ifndef ZP_OPTIMIZER_H
-#define ZP_OPTIMIZER_H 
+#define ZP_OPTIMIZER_H
 
 #include "Parser.h"
 
 namespace zp
 {
-    template <typename T>
+    // forward declarations
+    enum class Instruction : char;
+
+    struct Block;
+    struct InstructionBlock;
+    struct UnionBlock;
+    struct Loop;
+
     class AstVisitor;
 
-    struct Instruction;
+    struct BlockInstruction;
+
     class Optimizer;
 }
 
 
-template <typename T>
 class zp::AstVisitor
 {
 public:
-    T visit(Block& block);
-
-    virtual T visitLoop(Loop& loop) = 0;
-    virtual T visitInstructionBlock(InstructionBlock& ib) = 0;
-    virtual T visitUnionBlock(UnionBlock& ub) = 0;
+    std::unique_ptr<BlockInstruction> visit(Block& block);
+
+    virtual std::unique_ptr<BlockInstruction>
+        visitLoop(Loop& loop) = 0;
+    virtual std::unique_ptr<BlockInstruction>
+        visitInstructionBlock(InstructionBlock& ib) = 0;
+    virtual std::unique_ptr<BlockInstruction>
+        visitUnionBlock(UnionBlock& ub) = 0;
 };
 
 
-struct zp::Instruction
+struct zp::BlockInstruction
 {
 
 };
 
 
 class zp::Optimizer :
-    public AstVisitor<std::unique_ptr<Instruction>>
+    public AstVisitor
 {
 public:
-    std::unique_ptr<Instruction> visitLoop(Loop& loop) override;
-    std::unique_ptr<Instruction> visitInstructionBlock(InstructionBlock& ib) override;
-    std::unique_ptr<Instruction> visitUnionBlock(UnionBlock& ub) override;
+    std::unique_ptr<BlockInstruction> visitLoop(Loop& loop) override;
+    std::unique_ptr<BlockInstruction> visitInstructionBlock(InstructionBlock& ib) override;
+    std::unique_ptr<BlockInstruction> visitUnionBlock(UnionBlock& ub) override;
 
 };
 

src/Parser.cpp

@@ -6,21 +6,21 @@ using namespace zp;
 using namespace std;
 
 
-void InstructionBlock::accept(AstVisitor& v)
+std::unique_ptr<BlockInstruction> InstructionBlock::accept(AstVisitor& v)
 {
-    v.visitInstructionBlock(*this);
+    return v.visitInstructionBlock(*this);
 }
 
 
-void UnionBlock::accept(AstVisitor& v)
+std::unique_ptr<BlockInstruction> UnionBlock::accept(AstVisitor& v)
 {
-    v.visitUnionBlock(*this);
+    return v.visitUnionBlock(*this);
 }
 
 
-void Loop::accept(AstVisitor& v)
+std::unique_ptr<BlockInstruction> Loop::accept(AstVisitor& v)
 {
-    v.visitLoop(*this);
+    return v.visitLoop(*this);
 }
 
 

src/Parser.h

@@ -15,11 +15,12 @@ namespace zp
     struct UnionBlock;
     struct Loop;
 
-    // forward declaration
-    class AstVisitor;
-
     class Parser;
     class ParserException;
+
+    // forward declarations
+    class AstVisitor;
+    struct BlockInstruction;
 }
 
 
@@ -38,7 +39,7 @@ struct zp::Block
 {
     virtual ~Block(void) = default;
 
-    virtual void accept(AstVisitor& v) = 0;
+    virtual std::unique_ptr<BlockInstruction> accept(AstVisitor& v) = 0;
 };
 
 
@@ -50,7 +51,7 @@ struct zp::InstructionBlock :
     inline void addInstruction(Instruction i)               { instructions.push_back(i); }
     inline bool isEmpty(void) const                         { return instructions.empty(); }
 
-    void accept(AstVisitor& v);
+    std::unique_ptr<BlockInstruction> accept(AstVisitor& v);
 };
 
 
@@ -59,15 +60,15 @@ struct zp::UnionBlock :
 {
     std::vector<std::unique_ptr<Block>> instructions;
     inline void addBlock(std::unique_ptr<Block>&& block)    { instructions.push_back(std::move(block)); }
-    
-    void accept(AstVisitor& v);
+
+    std::unique_ptr<BlockInstruction> accept(AstVisitor& v);
 };
 
 
 struct zp::Loop :
     public UnionBlock
 {
-    void accept(AstVisitor& v);
+    std::unique_ptr<BlockInstruction> accept(AstVisitor& v);
 };