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 struct FunctionDeclaration;
  56
  57 struct Block: Node
  58 {
  59         std::list<NodePtr<Node> > body;
  60         bool use_braces;
  61         std::map<std::string, StructDeclaration *> types;
  62         std::map<std::string, VariableDeclaration *> variables;
  63
  64         Block();
  65
  66         virtual Block *clone() const { return new Block(*this); }
  67         virtual void visit(NodeVisitor &);
  68 };
  69
  70 struct Expression: Node
  71 {
  72         virtual Expression *clone() const = 0;
  73 };
  74
  75 struct Literal: Expression
  76 {
  77         std::string token;
  78
  79         virtual Literal *clone() const { return new Literal(*this); }
  80         virtual void visit(NodeVisitor &);
  81 };
  82
  83 struct ParenthesizedExpression: Expression
  84 {
  85         NodePtr<Expression> expression;
  86
  87         virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
  88         virtual void visit(NodeVisitor &);
  89 };
  90
  91 struct VariableReference: Expression
  92 {
  93         std::string name;
  94         VariableDeclaration *declaration;
  95
  96         VariableReference();
  97
  98         virtual VariableReference *clone() const { return new VariableReference(*this); }
  99         virtual void visit(NodeVisitor &);
 100 };
 101
 102 struct MemberAccess: Expression
 103 {
 104         NodePtr<Expression> left;
 105         std::string member;
 106         VariableDeclaration *declaration;
 107
 108         virtual MemberAccess *clone() const { return new MemberAccess(*this); }
 109         virtual void visit(NodeVisitor &);
 110 };
 111
 112 struct UnaryExpression: Expression
 113 {
 114         std::string oper;
 115         NodePtr<Expression> expression;
 116         bool prefix;
 117
 118         UnaryExpression();
 119
 120         virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
 121         virtual void visit(NodeVisitor &);
 122 };
 123
 124 struct BinaryExpression: Expression
 125 {
 126         NodePtr<Expression> left;
 127         std::string oper;
 128         NodePtr<Expression> right;
 129         std::string after;
 130
 131         virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
 132         virtual void visit(NodeVisitor &);
 133 };
 134
 135 struct Assignment: BinaryExpression
 136 {
 137         bool self_referencing;
 138         VariableDeclaration *target_declaration;
 139
 140         Assignment();
 141
 142         virtual Assignment *clone() const { return new Assignment(*this); }
 143         virtual void visit(NodeVisitor &);
 144 };
 145
 146 struct FunctionCall: Expression
 147 {
 148         std::string name;
 149         FunctionDeclaration *declaration;
 150         bool constructor;
 151         std::vector<NodePtr<Expression> > arguments;
 152
 153         FunctionCall();
 154
 155         virtual FunctionCall *clone() const { return new FunctionCall(*this); }
 156         virtual void visit(NodeVisitor &);
 157 };
 158
 159 struct ExpressionStatement: Node
 160 {
 161         NodePtr<Expression> expression;
 162
 163         virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
 164         virtual void visit(NodeVisitor &);
 165 };
 166
 167 struct Import: Node
 168 {
 169         std::string module;
 170
 171         virtual Import *clone() const { return new Import(*this); }
 172         virtual void visit(NodeVisitor &);
 173 };
 174
 175 struct Layout: Node
 176 {
 177         struct Qualifier
 178         {
 179                 std::string identifier;
 180                 std::string value;
 181         };
 182
 183         std::vector<Qualifier> qualifiers;
 184         std::string interface;
 185
 186         virtual Layout *clone() const { return new Layout(*this); }
 187         virtual void visit(NodeVisitor &);
 188 };
 189
 190 struct StructDeclaration: Node
 191 {
 192         std::string name;
 193         Block members;
 194
 195         StructDeclaration();
 196
 197         virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
 198         virtual void visit(NodeVisitor &);
 199 };
 200
 201 struct VariableDeclaration: Node
 202 {
 203         bool constant;
 204         std::string sampling;
 205         std::string interface;
 206         std::string type;
 207         StructDeclaration *type_declaration;
 208         std::string name;
 209         bool array;
 210         NodePtr<Expression> array_size;
 211         NodePtr<Expression> init_expression;
 212         VariableDeclaration *linked_declaration;
 213
 214         VariableDeclaration();
 215
 216         virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
 217         virtual void visit(NodeVisitor &);
 218 };
 219
 220 struct InterfaceBlock: Node
 221 {
 222         std::string interface;
 223         std::string name;
 224         Block members;
 225         std::string instance_name;
 226         bool array;
 227
 228         InterfaceBlock();
 229
 230         virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
 231         virtual void visit(NodeVisitor &);
 232 };
 233
 234 struct FunctionDeclaration: Node
 235 {
 236         std::string return_type;
 237         std::string name;
 238         std::vector<NodePtr<VariableDeclaration> > parameters;
 239         FunctionDeclaration *definition;
 240         Block body;
 241
 242         FunctionDeclaration();
 243         FunctionDeclaration(const FunctionDeclaration &);
 244
 245         virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
 246         virtual void visit(NodeVisitor &);
 247 };
 248
 249 struct Conditional: Node
 250 {
 251         NodePtr<Expression> condition;
 252         Block body;
 253         Block else_body;
 254
 255         virtual Conditional *clone() const { return new Conditional(*this); }
 256         virtual void visit(NodeVisitor &);
 257 };
 258
 259 struct Iteration: Node
 260 {
 261         NodePtr<Node> init_statement;
 262         NodePtr<Expression> condition;
 263         NodePtr<Expression> loop_expression;
 264         Block body;
 265
 266         virtual Iteration *clone() const { return new Iteration(*this); }
 267         virtual void visit(NodeVisitor &);
 268 };
 269
 270 struct Passthrough: Node
 271 {
 272         NodePtr<Expression> subscript;
 273
 274         virtual Passthrough *clone() const { return new Passthrough(*this); }
 275         virtual void visit(NodeVisitor &);
 276 };
 277
 278 struct Return: Node
 279 {
 280         NodePtr<Expression> expression;
 281
 282         virtual Return *clone() const { return new Return(*this); }
 283         virtual void visit(NodeVisitor &);
 284 };
 285
 286 struct NodeVisitor
 287 {
 288         virtual ~NodeVisitor() { }
 289
 290         virtual void visit(Block &) { }
 291         virtual void visit(Literal &) { }
 292         virtual void visit(ParenthesizedExpression &) { }
 293         virtual void visit(VariableReference &) { }
 294         virtual void visit(MemberAccess &) { }
 295         virtual void visit(UnaryExpression &) { }
 296         virtual void visit(BinaryExpression &) { }
 297         virtual void visit(Assignment &);
 298         virtual void visit(FunctionCall &) { }
 299         virtual void visit(ExpressionStatement &) { }
 300         virtual void visit(Import &) { }
 301         virtual void visit(Layout &) { }
 302         virtual void visit(StructDeclaration &) { }
 303         virtual void visit(VariableDeclaration &) { }
 304         virtual void visit(InterfaceBlock &) { }
 305         virtual void visit(FunctionDeclaration &) { }
 306         virtual void visit(Conditional &) { }
 307         virtual void visit(Iteration &) { }
 308         virtual void visit(Passthrough &) { }
 309         virtual void visit(Return &) { }
 310 };
 311
 312 struct TraversingVisitor: NodeVisitor
 313 {
 314         virtual void visit(Block &);
 315         virtual void visit(ParenthesizedExpression &);
 316         virtual void visit(MemberAccess &);
 317         virtual void visit(UnaryExpression &);
 318         virtual void visit(BinaryExpression &);
 319         virtual void visit(FunctionCall &);
 320         virtual void visit(ExpressionStatement &);
 321         virtual void visit(StructDeclaration &);
 322         virtual void visit(VariableDeclaration &);
 323         virtual void visit(InterfaceBlock &);
 324         virtual void visit(FunctionDeclaration &);
 325         virtual void visit(Conditional &);
 326         virtual void visit(Iteration &);
 327         virtual void visit(Passthrough &);
 328         virtual void visit(Return &);
 329 };
 330
 331 enum StageType
 332 {
 333         SHARED,
 334         VERTEX,
 335         GEOMETRY,
 336         FRAGMENT
 337 };
 338
 339 struct Stage
 340 {
 341         StageType type;
 342         Stage *previous;
 343         ProgramSyntax::Block content;
 344         std::map<std::string, VariableDeclaration *> in_variables;
 345         std::map<std::string, VariableDeclaration *> out_variables;
 346
 347         Stage(StageType);
 348 };
 349
 350 struct Module
 351 {
 352         Stage shared;
 353         std::list<Stage> stages;
 354
 355         Module();
 356 };
 357
 358 } // namespace ProgramSyntax
 359 } // namespace GL
 360 } // namespace Msp
 361
 362 #endif