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 class DeclarationCombiner: public BlockModifier
  15 {
  16 private:
  17         bool toplevel;
  18         std::map<std::string, std::vector<FunctionDeclaration *> > functions;
  19         std::map<std::string, VariableDeclaration *> variables;
  20
  21 public:
  22         DeclarationCombiner();
  23
  24         using StageVisitor::visit;
  25         virtual void visit(Block &);
  26         virtual void visit(FunctionDeclaration &);
  27         virtual void visit(VariableDeclaration &);
  28 };
  29
  30 class VariableResolver: public StageVisitor
  31 {
  32 private:
  33         std::vector<Block *> blocks;
  34         StructDeclaration *type;
  35         bool anonymous;
  36         std::string block_interface;
  37         bool record_target;
  38         VariableDeclaration *assignment_target;
  39         bool self_referencing;
  40
  41 public:
  42         VariableResolver();
  43
  44         virtual void apply(Stage &);
  45         using StageVisitor::visit;
  46         virtual void visit(Block &);
  47         virtual void visit(VariableReference &);
  48         virtual void visit(MemberAccess &);
  49         virtual void visit(BinaryExpression &);
  50         virtual void visit(Assignment &);
  51         virtual void visit(StructDeclaration &);
  52         virtual void visit(VariableDeclaration &);
  53         virtual void visit(InterfaceBlock &);
  54 };
  55
  56 class FunctionResolver: public StageVisitor
  57 {
  58 private:
  59         std::map<std::string, std::vector<FunctionDeclaration *> > functions;
  60
  61 public:
  62         using StageVisitor::visit;
  63         virtual void visit(FunctionCall &);
  64         virtual void visit(FunctionDeclaration &);
  65 };
  66
  67 class InterfaceGenerator: public BlockModifier
  68 {
  69 private:
  70         std::string in_prefix;
  71         std::string out_prefix;
  72         unsigned scope_level;
  73         std::map<std::string, RefPtr<VariableDeclaration> > iface_declarations;
  74
  75 public:
  76         InterfaceGenerator();
  77
  78         static std::string get_out_prefix(Stage::Type);
  79         virtual void apply(Stage &);
  80         using StageVisitor::visit;
  81         virtual void visit(Block &);
  82         std::string change_prefix(const std::string &, const std::string &) const;
  83         bool generate_interface(VariableDeclaration &, const std::string &, const std::string &);
  84         ExpressionStatement &insert_assignment(const std::string &, Expression *);
  85         virtual void visit(VariableReference &);
  86         virtual void visit(VariableDeclaration &);
  87         virtual void visit(Passthrough &);
  88 };
  89
  90 class DeclarationReorderer: public StageVisitor
  91 {
  92 private:
  93         enum DeclarationKind
  94         {
  95                 NO_DECLARATION,
  96                 LAYOUT,
  97                 STRUCT,
  98                 VARIABLE,
  99                 FUNCTION
 100         };
 101
 102         unsigned scope_level;
 103         DeclarationKind kind;
 104         std::set<Node *> ordered_funcs;
 105         std::set<Node *> needed_funcs;
 106
 107 public:
 108         DeclarationReorderer();
 109
 110         using StageVisitor::visit;
 111         virtual void visit(Block &);
 112         virtual void visit(FunctionCall &);
 113         virtual void visit(InterfaceLayout &) { kind = LAYOUT; }
 114         virtual void visit(StructDeclaration &) { kind = STRUCT; }
 115         virtual void visit(VariableDeclaration &);
 116         virtual void visit(InterfaceBlock &) { kind = VARIABLE; }
 117         virtual void visit(FunctionDeclaration &);
 118 };
 119
 120 } // namespace SL
 121 } // namespace GL
 122 } // namespace Msp
 123
 124 #endif