1 #ifndef MSP_GL_SL_GENERATE_H_
2 #define MSP_GL_SL_GENERATE_H_
14 /** Combines multiple declarations of the same identifier into one. */
15 class DeclarationCombiner: private TraversingVisitor
18 std::map<std::string, std::vector<FunctionDeclaration *> > functions;
19 std::map<std::string, VariableDeclaration *> variables;
20 std::set<Node *> nodes_to_remove;
26 virtual void visit(Block &);
27 virtual void visit(VariableDeclaration &);
28 virtual void visit(FunctionDeclaration &) { }
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
37 const std::map<std::string, int> *values;
40 ConstantSpecializer();
42 void apply(Stage &, const std::map<std::string, int> *);
45 virtual void visit(VariableDeclaration &);
48 /** Forms links between nested blocks in the syntax tree. */
49 class BlockHierarchyResolver: private TraversingVisitor
52 void apply(Stage &s) { s.content.visit(*this); }
55 virtual void enter(Block &);
58 /** Resolves types of variables and base types of other types. */
59 class TypeResolver: private TraversingVisitor
63 std::map<TypeDeclaration *, TypeDeclaration *> alias_map;
64 std::map<TypeDeclaration *, TypeDeclaration *> array_types;
65 NodeList<Statement>::iterator type_insert_point;
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 &);
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
88 RefPtr<Expression> r_replacement_expr;
89 std::string block_interface;
92 bool r_self_referencing;
93 VariableDeclaration *r_assignment_target;
101 virtual void enter(Block &);
102 void visit_and_replace(RefPtr<Expression> &);
103 virtual void visit(VariableReference &);
104 virtual void visit(InterfaceBlockReference &);
105 virtual void visit(MemberAccess &);
106 virtual void visit(UnaryExpression &);
107 virtual void visit(BinaryExpression &);
108 virtual void visit(Assignment &);
109 virtual void visit(FunctionCall &);
110 virtual void visit(VariableDeclaration &);
111 virtual void visit(InterfaceBlock &);
114 /** Resolves types and lvalueness of expressions. */
115 class ExpressionResolver: private TraversingVisitor
127 std::vector<BasicTypeDeclaration *> basic_types;
131 ExpressionResolver();
136 static bool is_scalar(BasicTypeDeclaration &);
137 static bool is_vector_or_matrix(BasicTypeDeclaration &);
138 static BasicTypeDeclaration *get_element_type(BasicTypeDeclaration &);
139 static bool can_convert(BasicTypeDeclaration &, BasicTypeDeclaration &);
140 static Compatibility get_compatibility(BasicTypeDeclaration &, BasicTypeDeclaration &);
141 BasicTypeDeclaration *find_type(BasicTypeDeclaration::Kind, unsigned);
142 BasicTypeDeclaration *find_type(BasicTypeDeclaration &, BasicTypeDeclaration::Kind, unsigned);
143 void convert_to(RefPtr<Expression> &, BasicTypeDeclaration &);
144 bool convert_to_element(RefPtr<Expression> &, BasicTypeDeclaration &);
145 void resolve(Expression &, TypeDeclaration *, bool);
147 virtual void visit(Literal &);
148 virtual void visit(ParenthesizedExpression &);
149 virtual void visit(VariableReference &);
150 virtual void visit(InterfaceBlockReference &);
151 virtual void visit(MemberAccess &);
152 virtual void visit(UnaryExpression &);
153 void visit(BinaryExpression &, bool);
154 virtual void visit(BinaryExpression &);
155 virtual void visit(Assignment &);
156 virtual void visit(FunctionCall &);
157 virtual void visit(BasicTypeDeclaration &);
158 virtual void visit(VariableDeclaration &);
161 /** Resolves function declarations and calls. */
162 class FunctionResolver: private TraversingVisitor
166 std::map<std::string, std::vector<FunctionDeclaration *> > declarations;
172 virtual void visit(FunctionCall &);
173 virtual void visit(FunctionDeclaration &);
176 /** Materializes implicitly declared interfaces.
178 Out variable declarations inside functions are moved to the global scope.
180 Passthrough statements are processed, generating out variables to match in
181 variables and copying values.
183 Unresolved variables are looked up in the previous stage's out variables. */
184 class InterfaceGenerator: private TraversingVisitor
188 std::string in_prefix;
189 std::string out_prefix;
191 InterfaceBlock *iface_block;
193 Block *iface_target_block;
194 NodeList<Statement>::iterator iface_insert_point;
195 NodeList<Statement>::iterator assignment_insert_point;
196 std::set<Node *> nodes_to_remove;
199 InterfaceGenerator();
204 static std::string get_out_prefix(Stage::Type);
205 std::string change_prefix(const std::string &, const std::string &) const;
206 virtual void visit(Block &);
207 VariableDeclaration *generate_interface(VariableDeclaration &, const std::string &, const std::string &);
208 InterfaceBlock *generate_interface(InterfaceBlock &);
209 ExpressionStatement &insert_assignment(const std::string &, Expression *);
210 virtual void visit(VariableReference &);
211 virtual void visit(VariableDeclaration &);
212 virtual void visit(InterfaceBlock &);
213 virtual void visit(FunctionDeclaration &);
214 virtual void visit(Passthrough &);