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
  65 public:
  66         TypeResolver();
  67
  68         void apply(Stage &);
  69
  70 private:
  71         TypeDeclaration *resolve_type(const std::string &);
  72         virtual void visit(BasicTypeDeclaration &);
  73         virtual void visit(ImageTypeDeclaration &);
  74         virtual void visit(StructDeclaration &);
  75         virtual void visit(VariableDeclaration &);
  76         virtual void visit(FunctionDeclaration &);
  77 };
  78
  79 /** Resolves variable references.  Variable references which match the name
  80 of an interface block are turned into interface block references. */
  81 class VariableResolver: private TraversingVisitor
  82 {
  83 private:
  84         Stage *stage;
  85         std::map<std::string, VariableDeclaration *> *r_members;
  86         RefPtr<InterfaceBlockReference> r_iface_ref;
  87         std::string block_interface;
  88         bool record_target;
  89         bool r_self_referencing;
  90         VariableDeclaration *r_assignment_target;
  91
  92 public:
  93         VariableResolver();
  94
  95         void apply(Stage &);
  96
  97 private:
  98         virtual void enter(Block &);
  99         virtual void visit(VariableReference &);
 100         virtual void visit(InterfaceBlockReference &);
 101         virtual void visit(MemberAccess &);
 102         virtual void visit(UnaryExpression &);
 103         virtual void visit(BinaryExpression &);
 104         virtual void visit(Assignment &);
 105         virtual void visit(FunctionCall &);
 106         virtual void visit(VariableDeclaration &);
 107         virtual void visit(InterfaceBlock &);
 108 };
 109
 110 /** Resolves function declarations and calls. */
 111 class FunctionResolver: private TraversingVisitor
 112 {
 113 private:
 114         Stage *stage;
 115         std::map<std::string, std::vector<FunctionDeclaration *> > declarations;
 116
 117 public:
 118         void apply(Stage &);
 119
 120 private:
 121         virtual void visit(FunctionCall &);
 122         virtual void visit(FunctionDeclaration &);
 123 };
 124
 125 /** Materializes implicitly declared interfaces.
 126
 127 Out variable declarations inside functions are moved to the global scope.
 128
 129 Passthrough statements are processed, generating out variables to match in
 130 variables and copying values.
 131
 132 Unresolved variables are looked up in the previous stage's out variables. */
 133 class InterfaceGenerator: private TraversingVisitor
 134 {
 135 private:
 136         Stage *stage;
 137         std::string in_prefix;
 138         std::string out_prefix;
 139         bool function_scope;
 140         InterfaceBlock *iface_block;
 141         bool copy_block;
 142         Block *iface_target_block;
 143         NodeList<Statement>::iterator iface_insert_point;
 144         NodeList<Statement>::iterator assignment_insert_point;
 145         std::set<Node *> nodes_to_remove;
 146
 147 public:
 148         InterfaceGenerator();
 149
 150         void apply(Stage &);
 151
 152 private:
 153         static std::string get_out_prefix(Stage::Type);
 154         std::string change_prefix(const std::string &, const std::string &) const;
 155         virtual void visit(Block &);
 156         VariableDeclaration *generate_interface(VariableDeclaration &, const std::string &, const std::string &);
 157         InterfaceBlock *generate_interface(InterfaceBlock &);
 158         ExpressionStatement &insert_assignment(const std::string &, Expression *);
 159         virtual void visit(VariableReference &);
 160         virtual void visit(VariableDeclaration &);
 161         virtual void visit(InterfaceBlock &);
 162         virtual void visit(FunctionDeclaration &);
 163         virtual void visit(Passthrough &);
 164 };
 165
 166 } // namespace SL
 167 } // namespace GL
 168 } // namespace Msp
 169
 170 #endif