source/glsl/visitor.h

   1 #ifndef MSP_GL_SL_VISITOR_H_
   2 #define MSP_GL_SL_VISITOR_H_
   3
   4 #include <set>
   5 #include <vector>
   6 #include "syntax.h"
   7
   8 namespace Msp {
   9 namespace GL {
  10 namespace SL {
  11
  12 /** Base class for all node visitors. */
  13 class NodeVisitor
  14 {
  15 protected:
  16         NodeVisitor() { }
  17 public:
  18         virtual ~NodeVisitor() { }
  19
  20         virtual void visit(Block &) { }
  21         virtual void visit(Literal &) { }
  22         virtual void visit(ParenthesizedExpression &) { }
  23         virtual void visit(VariableReference &) { }
  24         virtual void visit(InterfaceBlockReference &) { }
  25         virtual void visit(MemberAccess &) { }
  26         virtual void visit(Swizzle &) { }
  27         virtual void visit(UnaryExpression &) { }
  28         virtual void visit(BinaryExpression &) { }
  29         virtual void visit(Assignment &) { }
  30         virtual void visit(TernaryExpression &) { }
  31         virtual void visit(FunctionCall &) { }
  32         virtual void visit(ExpressionStatement &) { }
  33         virtual void visit(Import &) { }
  34         virtual void visit(Precision &) { }
  35         virtual void visit(Layout &) { }
  36         virtual void visit(InterfaceLayout &) { }
  37         virtual void visit(BasicTypeDeclaration &) { }
  38         virtual void visit(ImageTypeDeclaration &) { }
  39         virtual void visit(StructDeclaration &) { }
  40         virtual void visit(VariableDeclaration &) { }
  41         virtual void visit(InterfaceBlock &) { }
  42         virtual void visit(FunctionDeclaration &) { }
  43         virtual void visit(Conditional &) { }
  44         virtual void visit(Iteration &) { }
  45         virtual void visit(Passthrough &) { }
  46         virtual void visit(Return &) { }
  47         virtual void visit(Jump &) { }
  48 };
  49
  50 /** An intermediate base visitor class which traverses the syntax tree. */
  51 class TraversingVisitor: public NodeVisitor
  52 {
  53 protected:
  54         Block *current_block;
  55
  56         TraversingVisitor(): current_block(0) { }
  57
  58 public:
  59         virtual void enter(Block &) { }
  60         virtual void visit(Block &);
  61         virtual void visit(RefPtr<Expression> &);
  62         virtual void visit(ParenthesizedExpression &);
  63         virtual void visit(MemberAccess &);
  64         virtual void visit(Swizzle &);
  65         virtual void visit(UnaryExpression &);
  66         virtual void visit(BinaryExpression &);
  67         virtual void visit(Assignment &);
  68         virtual void visit(TernaryExpression &);
  69         virtual void visit(FunctionCall &);
  70         virtual void visit(ExpressionStatement &);
  71         virtual void visit(InterfaceLayout &);
  72         virtual void visit(StructDeclaration &);
  73         virtual void visit(VariableDeclaration &);
  74         virtual void visit(InterfaceBlock &);
  75         virtual void visit(FunctionDeclaration &);
  76         virtual void visit(Conditional &);
  77         virtual void visit(Iteration &);
  78         virtual void visit(Passthrough &);
  79         virtual void visit(Return &);
  80 };
  81
  82 /** Removes a set of nodes from the syntax tree. */
  83 class NodeRemover: private TraversingVisitor
  84 {
  85 private:
  86         Stage *stage;
  87         const std::set<Node *> *to_remove;
  88         bool recursive_remove;
  89
  90 public:
  91         NodeRemover();
  92
  93         void apply(Stage &, const std::set<Node *> &);
  94
  95 private:
  96         template<typename T>
  97         void remove_from_map(std::map<std::string, T *> &, const std::string &, T &);
  98
  99         virtual void visit(Block &);
 100         void visit(TypeDeclaration &);
 101         virtual void visit(BasicTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
 102         virtual void visit(ImageTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
 103         virtual void visit(StructDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
 104         virtual void visit(VariableDeclaration &);
 105         virtual void visit(InterfaceBlock &);
 106         virtual void visit(FunctionDeclaration &);
 107         virtual void visit(Iteration &);
 108 };
 109
 110 /** Reorders a set of nodes so they appear before another node.  Only nodes
 111 on the same hierarchly level as the target node are reordered. */
 112 class NodeReorderer: private TraversingVisitor
 113 {
 114 private:
 115         Node *reorder_before;
 116         const std::set<Node *> *to_reorder;
 117
 118 public:
 119         NodeReorderer();
 120
 121         void apply(Stage &, Node &, const std::set<Node *> &);
 122
 123 private:
 124         virtual void visit(Block &);
 125 };
 126
 127 } // namespace SL
 128 } // namespace GL
 129 } // namespace Msp
 130
 131 #endif