source/programsyntax.h

   1 #ifndef MSP_GL_PROGRAMSYNTAX_H_
   2 #define MSP_GL_PROGRAMSYNTAX_H_
   3
   4 #include <list>
   5 #include <map>
   6 #include <string>
   7 #include <vector>
   8
   9 namespace Msp {
  10 namespace GL {
  11 namespace ProgramSyntax {
  12
  13 struct NodeVisitor;
  14
  15 struct Node
  16 {
  17 private:
  18         Node &operator=(const Node &);
  19 public:
  20         virtual ~Node() { }
  21
  22         virtual Node *clone() const = 0;
  23         virtual void visit(NodeVisitor &) = 0;
  24 };
  25
  26 template<typename T>
  27 class NodePtr
  28 {
  29 private:
  30         T *node;
  31
  32 public:
  33         NodePtr(T *n = 0): node(n) { }
  34         NodePtr(const NodePtr &p): node(clone(p.node)) { }
  35         NodePtr &operator=(const NodePtr &p) { delete node; node = clone(p.node); return *this; }
  36 #if __cplusplus>=201103L
  37         NodePtr(NodePtr &&p): node(p.node) { p.node = 0; }
  38         NodePtr &operator=(NodePtr &&p) { delete node; node = p.node; p.node = 0; return *this; }
  39 #endif
  40         ~NodePtr() { delete node; }
  41
  42 private:
  43         static T *clone(T *n) { return n ? n->clone() : 0; }
  44
  45 public:
  46         T *operator->() { return node; }
  47         const T *operator->() const { return node; }
  48         T &operator*() { return *node; }
  49         const T &operator*() const { return *node; }
  50         operator void *() const { return node; }
  51 };
  52
  53 struct StructDeclaration;
  54 struct VariableDeclaration;
  55
  56 struct Block: Node
  57 {
  58         std::list<NodePtr<Node> > body;
  59         bool use_braces;
  60         std::map<std::string, StructDeclaration *> types;
  61         std::map<std::string, VariableDeclaration *> variables;
  62
  63         Block();
  64
  65         virtual Block *clone() const { return new Block(*this); }
  66         virtual void visit(NodeVisitor &);
  67 };
  68
  69 struct Expression: Node
  70 {
  71         virtual Expression *clone() const = 0;
  72 };
  73
  74 struct Literal: Expression
  75 {
  76         std::string token;
  77
  78         virtual Literal *clone() const { return new Literal(*this); }
  79         virtual void visit(NodeVisitor &);
  80 };
  81
  82 struct ParenthesizedExpression: Expression
  83 {
  84         NodePtr<Expression> expression;
  85
  86         virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
  87         virtual void visit(NodeVisitor &);
  88 };
  89
  90 struct VariableReference: Expression
  91 {
  92         std::string name;
  93         VariableDeclaration *declaration;
  94
  95         VariableReference();
  96
  97         virtual VariableReference *clone() const { return new VariableReference(*this); }
  98         virtual void visit(NodeVisitor &);
  99 };
 100
 101 struct MemberAccess: Expression
 102 {
 103         NodePtr<Expression> left;
 104         std::string member;
 105         VariableDeclaration *declaration;
 106
 107         virtual MemberAccess *clone() const { return new MemberAccess(*this); }
 108         virtual void visit(NodeVisitor &);
 109 };
 110
 111 struct UnaryExpression: Expression
 112 {
 113         std::string oper;
 114         NodePtr<Expression> expression;
 115         bool prefix;
 116
 117         UnaryExpression();
 118
 119         virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
 120         virtual void visit(NodeVisitor &);
 121 };
 122
 123 struct BinaryExpression: Expression
 124 {
 125         NodePtr<Expression> left;
 126         std::string oper;
 127         NodePtr<Expression> right;
 128         std::string after;
 129         bool assignment;
 130
 131         BinaryExpression();
 132
 133         virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
 134         virtual void visit(NodeVisitor &);
 135 };
 136
 137 struct FunctionCall: Expression
 138 {
 139         std::string name;
 140         bool constructor;
 141         std::vector<NodePtr<Expression> > arguments;
 142
 143         FunctionCall();
 144
 145         virtual FunctionCall *clone() const { return new FunctionCall(*this); }
 146         virtual void visit(NodeVisitor &);
 147 };
 148
 149 struct ExpressionStatement: Node
 150 {
 151         NodePtr<Expression> expression;
 152
 153         virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
 154         virtual void visit(NodeVisitor &);
 155 };
 156
 157 struct Layout: Node
 158 {
 159         struct Qualifier
 160         {
 161                 std::string identifier;
 162                 std::string value;
 163         };
 164
 165         std::vector<Qualifier> qualifiers;
 166         std::string interface;
 167
 168         virtual Layout *clone() const { return new Layout(*this); }
 169         virtual void visit(NodeVisitor &);
 170 };
 171
 172 struct StructDeclaration: Node
 173 {
 174         std::string name;
 175         Block members;
 176
 177         StructDeclaration();
 178
 179         virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
 180         virtual void visit(NodeVisitor &);
 181 };
 182
 183 struct VariableDeclaration: Node
 184 {
 185         bool constant;
 186         std::string sampling;
 187         std::string interface;
 188         std::string type;
 189         StructDeclaration *type_declaration;
 190         std::string name;
 191         bool array;
 192         NodePtr<Expression> array_size;
 193         NodePtr<Expression> init_expression;
 194         VariableDeclaration *linked_declaration;
 195
 196         VariableDeclaration();
 197
 198         virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
 199         virtual void visit(NodeVisitor &);
 200 };
 201
 202 struct InterfaceBlock: Node
 203 {
 204         std::string interface;
 205         std::string name;
 206         Block members;
 207
 208         InterfaceBlock();
 209
 210         virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
 211         virtual void visit(NodeVisitor &);
 212 };
 213
 214 struct FunctionDeclaration: Node
 215 {
 216         std::string return_type;
 217         std::string name;
 218         std::vector<NodePtr<VariableDeclaration> > parameters;
 219         bool definition;
 220         Block body;
 221
 222         FunctionDeclaration();
 223
 224         virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
 225         virtual void visit(NodeVisitor &);
 226 };
 227
 228 struct Conditional: Node
 229 {
 230         NodePtr<Expression> condition;
 231         Block body;
 232         Block else_body;
 233
 234         virtual Conditional *clone() const { return new Conditional(*this); }
 235         virtual void visit(NodeVisitor &);
 236 };
 237
 238 struct Iteration: Node
 239 {
 240         NodePtr<Node> init_statement;
 241         NodePtr<Expression> condition;
 242         NodePtr<Expression> loop_expression;
 243         Block body;
 244
 245         virtual Iteration *clone() const { return new Iteration(*this); }
 246         virtual void visit(NodeVisitor &);
 247 };
 248
 249 struct Passthrough: Node
 250 {
 251         NodePtr<Expression> subscript;
 252
 253         virtual Passthrough *clone() const { return new Passthrough(*this); }
 254         virtual void visit(NodeVisitor &);
 255 };
 256
 257 struct Return: Node
 258 {
 259         NodePtr<Expression> expression;
 260
 261         virtual Return *clone() const { return new Return(*this); }
 262         virtual void visit(NodeVisitor &);
 263 };
 264
 265 struct NodeVisitor
 266 {
 267         virtual ~NodeVisitor() { }
 268
 269         virtual void visit(Block &) { }
 270         virtual void visit(Literal &) { }
 271         virtual void visit(ParenthesizedExpression &) { }
 272         virtual void visit(VariableReference &) { }
 273         virtual void visit(MemberAccess &) { }
 274         virtual void visit(UnaryExpression &) { }
 275         virtual void visit(BinaryExpression &) { }
 276         virtual void visit(FunctionCall &) { }
 277         virtual void visit(ExpressionStatement &) { }
 278         virtual void visit(Layout &) { }
 279         virtual void visit(StructDeclaration &) { }
 280         virtual void visit(VariableDeclaration &) { }
 281         virtual void visit(InterfaceBlock &) { }
 282         virtual void visit(FunctionDeclaration &) { }
 283         virtual void visit(Conditional &) { }
 284         virtual void visit(Iteration &) { }
 285         virtual void visit(Passthrough &) { }
 286         virtual void visit(Return &) { }
 287 };
 288
 289 struct TraversingVisitor: NodeVisitor
 290 {
 291         virtual void visit(Block &);
 292         virtual void visit(ParenthesizedExpression &);
 293         virtual void visit(MemberAccess &);
 294         virtual void visit(UnaryExpression &);
 295         virtual void visit(BinaryExpression &);
 296         virtual void visit(FunctionCall &);
 297         virtual void visit(ExpressionStatement &);
 298         virtual void visit(StructDeclaration &);
 299         virtual void visit(VariableDeclaration &);
 300         virtual void visit(InterfaceBlock &);
 301         virtual void visit(FunctionDeclaration &);
 302         virtual void visit(Conditional &);
 303         virtual void visit(Iteration &);
 304         virtual void visit(Passthrough &);
 305         virtual void visit(Return &);
 306 };
 307
 308 enum StageType
 309 {
 310         SHARED,
 311         VERTEX,
 312         GEOMETRY,
 313         FRAGMENT
 314 };
 315
 316 struct Stage
 317 {
 318         StageType type;
 319         Stage *previous;
 320         ProgramSyntax::Block content;
 321         std::map<std::string, VariableDeclaration *> in_variables;
 322         std::map<std::string, VariableDeclaration *> out_variables;
 323
 324         Stage(StageType);
 325 };
 326
 327 struct Module
 328 {
 329         Stage shared;
 330         std::list<Stage> stages;
 331
 332         Module();
 333 };
 334
 335 } // namespace ProgramSyntax
 336 } // namespace GL
 337 } // namespace Msp
 338
 339 #endif