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
 130         virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
 131         virtual void visit(NodeVisitor &);
 132 };
 133
 134 struct Assignment: BinaryExpression
 135 {
 136         bool self_referencing;
 137         VariableDeclaration *target_declaration;
 138
 139         Assignment();
 140
 141         virtual Assignment *clone() const { return new Assignment(*this); }
 142         virtual void visit(NodeVisitor &);
 143 };
 144
 145 struct FunctionCall: Expression
 146 {
 147         std::string name;
 148         bool constructor;
 149         std::vector<NodePtr<Expression> > arguments;
 150
 151         FunctionCall();
 152
 153         virtual FunctionCall *clone() const { return new FunctionCall(*this); }
 154         virtual void visit(NodeVisitor &);
 155 };
 156
 157 struct ExpressionStatement: Node
 158 {
 159         NodePtr<Expression> expression;
 160
 161         virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
 162         virtual void visit(NodeVisitor &);
 163 };
 164
 165 struct Import: Node
 166 {
 167         std::string module;
 168
 169         virtual Import *clone() const { return new Import(*this); }
 170         virtual void visit(NodeVisitor &);
 171 };
 172
 173 struct Layout: Node
 174 {
 175         struct Qualifier
 176         {
 177                 std::string identifier;
 178                 std::string value;
 179         };
 180
 181         std::vector<Qualifier> qualifiers;
 182         std::string interface;
 183
 184         virtual Layout *clone() const { return new Layout(*this); }
 185         virtual void visit(NodeVisitor &);
 186 };
 187
 188 struct StructDeclaration: Node
 189 {
 190         std::string name;
 191         Block members;
 192
 193         StructDeclaration();
 194
 195         virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
 196         virtual void visit(NodeVisitor &);
 197 };
 198
 199 struct VariableDeclaration: Node
 200 {
 201         bool constant;
 202         std::string sampling;
 203         std::string interface;
 204         std::string type;
 205         StructDeclaration *type_declaration;
 206         std::string name;
 207         bool array;
 208         NodePtr<Expression> array_size;
 209         NodePtr<Expression> init_expression;
 210         VariableDeclaration *linked_declaration;
 211
 212         VariableDeclaration();
 213
 214         virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
 215         virtual void visit(NodeVisitor &);
 216 };
 217
 218 struct InterfaceBlock: Node
 219 {
 220         std::string interface;
 221         std::string name;
 222         Block members;
 223         std::string instance_name;
 224         bool array;
 225
 226         InterfaceBlock();
 227
 228         virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
 229         virtual void visit(NodeVisitor &);
 230 };
 231
 232 struct FunctionDeclaration: Node
 233 {
 234         std::string return_type;
 235         std::string name;
 236         std::vector<NodePtr<VariableDeclaration> > parameters;
 237         FunctionDeclaration *definition;
 238         Block body;
 239
 240         FunctionDeclaration();
 241         FunctionDeclaration(const FunctionDeclaration &);
 242
 243         virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
 244         virtual void visit(NodeVisitor &);
 245 };
 246
 247 struct Conditional: Node
 248 {
 249         NodePtr<Expression> condition;
 250         Block body;
 251         Block else_body;
 252
 253         virtual Conditional *clone() const { return new Conditional(*this); }
 254         virtual void visit(NodeVisitor &);
 255 };
 256
 257 struct Iteration: Node
 258 {
 259         NodePtr<Node> init_statement;
 260         NodePtr<Expression> condition;
 261         NodePtr<Expression> loop_expression;
 262         Block body;
 263
 264         virtual Iteration *clone() const { return new Iteration(*this); }
 265         virtual void visit(NodeVisitor &);
 266 };
 267
 268 struct Passthrough: Node
 269 {
 270         NodePtr<Expression> subscript;
 271
 272         virtual Passthrough *clone() const { return new Passthrough(*this); }
 273         virtual void visit(NodeVisitor &);
 274 };
 275
 276 struct Return: Node
 277 {
 278         NodePtr<Expression> expression;
 279
 280         virtual Return *clone() const { return new Return(*this); }
 281         virtual void visit(NodeVisitor &);
 282 };
 283
 284 struct NodeVisitor
 285 {
 286         virtual ~NodeVisitor() { }
 287
 288         virtual void visit(Block &) { }
 289         virtual void visit(Literal &) { }
 290         virtual void visit(ParenthesizedExpression &) { }
 291         virtual void visit(VariableReference &) { }
 292         virtual void visit(MemberAccess &) { }
 293         virtual void visit(UnaryExpression &) { }
 294         virtual void visit(BinaryExpression &) { }
 295         virtual void visit(Assignment &);
 296         virtual void visit(FunctionCall &) { }
 297         virtual void visit(ExpressionStatement &) { }
 298         virtual void visit(Import &) { }
 299         virtual void visit(Layout &) { }
 300         virtual void visit(StructDeclaration &) { }
 301         virtual void visit(VariableDeclaration &) { }
 302         virtual void visit(InterfaceBlock &) { }
 303         virtual void visit(FunctionDeclaration &) { }
 304         virtual void visit(Conditional &) { }
 305         virtual void visit(Iteration &) { }
 306         virtual void visit(Passthrough &) { }
 307         virtual void visit(Return &) { }
 308 };
 309
 310 struct TraversingVisitor: NodeVisitor
 311 {
 312         virtual void visit(Block &);
 313         virtual void visit(ParenthesizedExpression &);
 314         virtual void visit(MemberAccess &);
 315         virtual void visit(UnaryExpression &);
 316         virtual void visit(BinaryExpression &);
 317         virtual void visit(FunctionCall &);
 318         virtual void visit(ExpressionStatement &);
 319         virtual void visit(StructDeclaration &);
 320         virtual void visit(VariableDeclaration &);
 321         virtual void visit(InterfaceBlock &);
 322         virtual void visit(FunctionDeclaration &);
 323         virtual void visit(Conditional &);
 324         virtual void visit(Iteration &);
 325         virtual void visit(Passthrough &);
 326         virtual void visit(Return &);
 327 };
 328
 329 enum StageType
 330 {
 331         SHARED,
 332         VERTEX,
 333         GEOMETRY,
 334         FRAGMENT
 335 };
 336
 337 struct Stage
 338 {
 339         StageType type;
 340         Stage *previous;
 341         ProgramSyntax::Block content;
 342         std::map<std::string, VariableDeclaration *> in_variables;
 343         std::map<std::string, VariableDeclaration *> out_variables;
 344
 345         Stage(StageType);
 346 };
 347
 348 struct Module
 349 {
 350         Stage shared;
 351         std::list<Stage> stages;
 352
 353         Module();
 354 };
 355
 356 } // namespace ProgramSyntax
 357 } // namespace GL
 358 } // namespace Msp
 359
 360 #endif