source/glsl/resolve.h

   1 #ifndef MSP_GL_SL_RESOLVE_H_
   2 #define MSP_GL_SL_RESOLVE_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 /** Forms links between nested blocks in the syntax tree. */
  15 class BlockHierarchyResolver: private TraversingVisitor
  16 {
  17 private:
  18         bool r_any_resolved;
  19
  20 public:
  21         BlockHierarchyResolver(): r_any_resolved(false) { }
  22
  23         bool apply(Stage &s) { r_any_resolved = false; s.content.visit(*this); return r_any_resolved; }
  24
  25 private:
  26         virtual void enter(Block &);
  27 };
  28
  29 /** Resolves types of variables and base types of other types. */
  30 class TypeResolver: private TraversingVisitor
  31 {
  32 private:
  33         Stage *stage;
  34         std::map<TypeDeclaration *, TypeDeclaration *> alias_map;
  35         std::map<TypeDeclaration *, TypeDeclaration *> array_types;
  36         NodeList<Statement>::iterator type_insert_point;
  37         InterfaceBlock *iface_block;
  38         bool r_any_resolved;
  39
  40 public:
  41         TypeResolver();
  42
  43         bool apply(Stage &);
  44
  45 private:
  46         TypeDeclaration *get_or_create_array_type(TypeDeclaration &);
  47         void resolve_type(TypeDeclaration *&, const std::string &, bool);
  48         virtual void visit(Block &);
  49         virtual void visit(BasicTypeDeclaration &);
  50         virtual void visit(ImageTypeDeclaration &);
  51         virtual void visit(StructDeclaration &);
  52         virtual void visit(VariableDeclaration &);
  53         virtual void visit(InterfaceBlock &);
  54         virtual void visit(FunctionDeclaration &);
  55 };
  56
  57 /** Resolves variable references.  Variable references which match the name
  58 of an interface block are turned into interface block references. */
  59 class VariableResolver: private TraversingVisitor
  60 {
  61 private:
  62         Stage *stage;
  63         RefPtr<Expression> r_replacement_expr;
  64         bool r_any_resolved;
  65         bool record_target;
  66         bool r_self_referencing;
  67         Assignment::Target r_assignment_target;
  68         std::vector<VariableDeclaration *> redeclared_builtins;
  69         std::set<Node *> nodes_to_remove;
  70
  71 public:
  72         VariableResolver();
  73
  74         bool apply(Stage &);
  75
  76 private:
  77         virtual void enter(Block &);
  78         virtual void visit(RefPtr<Expression> &);
  79         void check_assignment_target(Statement *);
  80         virtual void visit(VariableReference &);
  81         virtual void visit(InterfaceBlockReference &);
  82         void add_to_chain(Assignment::Target::ChainType, unsigned);
  83         virtual void visit(MemberAccess &);
  84         virtual void visit(Swizzle &);
  85         virtual void visit(BinaryExpression &);
  86         virtual void visit(Assignment &);
  87         void merge_layouts(Layout &, const Layout &);
  88         virtual void visit(VariableDeclaration &);
  89         virtual void visit(InterfaceBlock &);
  90 };
  91
  92 /** Resolves types and lvalueness of expressions. */
  93 class ExpressionResolver: private TraversingVisitor
  94 {
  95 private:
  96         enum Compatibility
  97         {
  98                 NOT_COMPATIBLE,
  99                 LEFT_CONVERTIBLE,
 100                 RIGHT_CONVERTIBLE,
 101                 SAME_TYPE
 102         };
 103
 104         struct ArgumentInfo
 105         {
 106                 BasicTypeDeclaration *type;
 107                 unsigned component_count;
 108         };
 109
 110         Stage *stage;
 111         std::vector<BasicTypeDeclaration *> basic_types;
 112         NodeList<Statement>::iterator insert_point;
 113         bool r_any_resolved;
 114
 115 public:
 116         ExpressionResolver();
 117
 118         bool apply(Stage &);
 119
 120 private:
 121         static bool is_scalar(BasicTypeDeclaration &);
 122         static bool is_vector_or_matrix(BasicTypeDeclaration &);
 123         static BasicTypeDeclaration *get_element_type(BasicTypeDeclaration &);
 124         static bool can_convert(BasicTypeDeclaration &, BasicTypeDeclaration &);
 125         static Compatibility get_compatibility(BasicTypeDeclaration &, BasicTypeDeclaration &);
 126         BasicTypeDeclaration *find_type(BasicTypeDeclaration::Kind, unsigned);
 127         BasicTypeDeclaration *find_type(BasicTypeDeclaration &, BasicTypeDeclaration::Kind, unsigned);
 128         void convert_to(RefPtr<Expression> &, BasicTypeDeclaration &);
 129         bool convert_to_element(RefPtr<Expression> &, BasicTypeDeclaration &);
 130         bool truncate_vector(RefPtr<Expression> &, unsigned);
 131         void resolve(Expression &, TypeDeclaration *, bool);
 132
 133         virtual void visit(Block &);
 134         virtual void visit(Literal &);
 135         virtual void visit(VariableReference &);
 136         virtual void visit(InterfaceBlockReference &);
 137         virtual void visit(MemberAccess &);
 138         virtual void visit(Swizzle &);
 139         virtual void visit(UnaryExpression &);
 140         void visit(BinaryExpression &, bool);
 141         virtual void visit(BinaryExpression &);
 142         virtual void visit(Assignment &);
 143         virtual void visit(TernaryExpression &);
 144         void visit_constructor(FunctionCall &);
 145         virtual void visit(FunctionCall &);
 146         virtual void visit(BasicTypeDeclaration &);
 147         virtual void visit(VariableDeclaration &);
 148 };
 149
 150 /** Resolves function declarations and calls. */
 151 class FunctionResolver: private TraversingVisitor
 152 {
 153 private:
 154         Stage *stage;
 155         std::map<std::string, std::vector<FunctionDeclaration *> > declarations;
 156         bool r_any_resolved;
 157
 158 public:
 159         bool apply(Stage &);
 160
 161 private:
 162         virtual void visit(FunctionCall &);
 163         virtual void visit(FunctionDeclaration &);
 164 };
 165
 166 } // namespace SL
 167 } // namespace GL
 168 } // namespace Msp
 169
 170 #endif