source/glsl/generate.h

   1 #ifndef MSP_GL_SL_GENERATE_H_
   2 #define MSP_GL_SL_GENERATE_H_
   3
   4 #include <map>
   5 #include <set>
   6 #include <string>
   7 #include <vector>
   8 #include "visitor.h"
   9
  10 namespace Msp {
  11 namespace GL {
  12 namespace SL {
  13
  14 /** Combines multiple declarations of the same identifier into one. */
  15 class DeclarationCombiner: private TraversingVisitor
  16 {
  17 private:
  18         std::map<std::string, std::vector<FunctionDeclaration *> > functions;
  19         std::map<std::string, VariableDeclaration *> variables;
  20         std::set<Node *> nodes_to_remove;
  21
  22 public:
  23         void apply(Stage &);
  24
  25 private:
  26         virtual void visit(Block &);
  27         virtual void visit(VariableDeclaration &);
  28         virtual void visit(FunctionDeclaration &) { }
  29 };
  30
  31 /** Manipulates specialization constants.  If values are specified, turns
  32 specialization constants into normal constants.  Without values assigns
  33 automatic constant_ids to specialization constants. */
  34 class ConstantSpecializer: private TraversingVisitor
  35 {
  36 private:
  37         const std::map<std::string, int> *values;
  38
  39 public:
  40         ConstantSpecializer();
  41
  42         void apply(Stage &, const std::map<std::string, int> *);
  43
  44 private:
  45         virtual void visit(VariableDeclaration &);
  46 };
  47
  48 /** Forms links between nested blocks in the syntax tree. */
  49 class BlockHierarchyResolver: private TraversingVisitor
  50 {
  51 public:
  52         void apply(Stage &s) { s.content.visit(*this); }
  53
  54 private:
  55         virtual void enter(Block &);
  56 };
  57
  58 /** Resolves types of variables and base types of other types. */
  59 class TypeResolver: private TraversingVisitor
  60 {
  61 private:
  62         Stage *stage;
  63         std::map<TypeDeclaration *, TypeDeclaration *> alias_map;
  64         std::map<TypeDeclaration *, TypeDeclaration *> array_types;
  65         NodeList<Statement>::iterator type_insert_point;
  66
  67 public:
  68         TypeResolver();
  69
  70         void apply(Stage &);
  71
  72 private:
  73         TypeDeclaration *resolve_type(const std::string &);
  74         virtual void visit(Block &);
  75         virtual void visit(BasicTypeDeclaration &);
  76         virtual void visit(ImageTypeDeclaration &);
  77         virtual void visit(StructDeclaration &);
  78         virtual void visit(VariableDeclaration &);
  79         virtual void visit(FunctionDeclaration &);
  80 };
  81
  82 /** Resolves variable references.  Variable references which match the name
  83 of an interface block are turned into interface block references. */
  84 class VariableResolver: private TraversingVisitor
  85 {
  86 private:
  87         Stage *stage;
  88         std::map<std::string, VariableDeclaration *> *r_members;
  89         RefPtr<InterfaceBlockReference> r_iface_ref;
  90         std::string block_interface;
  91         bool record_target;
  92         bool r_self_referencing;
  93         VariableDeclaration *r_assignment_target;
  94
  95 public:
  96         VariableResolver();
  97
  98         void apply(Stage &);
  99
 100 private:
 101         virtual void enter(Block &);
 102         virtual void visit(VariableReference &);
 103         virtual void visit(InterfaceBlockReference &);
 104         virtual void visit(MemberAccess &);
 105         virtual void visit(UnaryExpression &);
 106         virtual void visit(BinaryExpression &);
 107         virtual void visit(Assignment &);
 108         virtual void visit(FunctionCall &);
 109         virtual void visit(VariableDeclaration &);
 110         virtual void visit(InterfaceBlock &);
 111 };
 112
 113 /** Resolves function declarations and calls. */
 114 class FunctionResolver: private TraversingVisitor
 115 {
 116 private:
 117         Stage *stage;
 118         std::map<std::string, std::vector<FunctionDeclaration *> > declarations;
 119
 120 public:
 121         void apply(Stage &);
 122
 123 private:
 124         virtual void visit(FunctionCall &);
 125         virtual void visit(FunctionDeclaration &);
 126 };
 127
 128 /** Materializes implicitly declared interfaces.
 129
 130 Out variable declarations inside functions are moved to the global scope.
 131
 132 Passthrough statements are processed, generating out variables to match in
 133 variables and copying values.
 134
 135 Unresolved variables are looked up in the previous stage's out variables. */
 136 class InterfaceGenerator: private TraversingVisitor
 137 {
 138 private:
 139         Stage *stage;
 140         std::string in_prefix;
 141         std::string out_prefix;
 142         bool function_scope;
 143         InterfaceBlock *iface_block;
 144         bool copy_block;
 145         Block *iface_target_block;
 146         NodeList<Statement>::iterator iface_insert_point;
 147         NodeList<Statement>::iterator assignment_insert_point;
 148         std::set<Node *> nodes_to_remove;
 149
 150 public:
 151         InterfaceGenerator();
 152
 153         void apply(Stage &);
 154
 155 private:
 156         static std::string get_out_prefix(Stage::Type);
 157         std::string change_prefix(const std::string &, const std::string &) const;
 158         virtual void visit(Block &);
 159         VariableDeclaration *generate_interface(VariableDeclaration &, const std::string &, const std::string &);
 160         InterfaceBlock *generate_interface(InterfaceBlock &);
 161         ExpressionStatement &insert_assignment(const std::string &, Expression *);
 162         virtual void visit(VariableReference &);
 163         virtual void visit(VariableDeclaration &);
 164         virtual void visit(InterfaceBlock &);
 165         virtual void visit(FunctionDeclaration &);
 166         virtual void visit(Passthrough &);
 167 };
 168
 169 } // namespace SL
 170 } // namespace GL
 171 } // namespace Msp
 172
 173 #endif