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 #include <msp/core/refptr.h>
   9 #include "extension.h"
  10 #include "uniform.h"
  11
  12 #pragma push_macro("interface")
  13 #undef interface
  14
  15 namespace Msp {
  16 namespace GL {
  17 namespace ProgramSyntax {
  18
  19 struct NodeVisitor;
  20
  21 struct Node
  22 {
  23 private:
  24         Node &operator=(const Node &);
  25 public:
  26         virtual ~Node() { }
  27
  28         virtual Node *clone() const = 0;
  29         virtual void visit(NodeVisitor &) = 0;
  30 };
  31
  32 template<typename T>
  33 class NodePtr: public RefPtr<T>
  34 {
  35 public:
  36         NodePtr() { }
  37         NodePtr(T *p): RefPtr<T>(p) { }
  38         NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
  39
  40         template<typename U>
  41         NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
  42
  43         template<typename U>
  44         NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
  45 };
  46
  47 template<typename C>
  48 class NodeContainer: public C
  49 {
  50 public:
  51         NodeContainer() { }
  52         NodeContainer(const NodeContainer &);
  53 };
  54
  55 template<typename T>
  56 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
  57 { };
  58
  59 template<typename T>
  60 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
  61 { };
  62
  63 struct StructDeclaration;
  64 struct VariableDeclaration;
  65 struct FunctionDeclaration;
  66
  67 struct Statement: Node
  68 {
  69         virtual Statement *clone() const = 0;
  70 };
  71
  72 struct Block: Node
  73 {
  74         NodeList<Statement> body;
  75         bool use_braces;
  76         std::map<std::string, StructDeclaration *> types;
  77         std::map<std::string, VariableDeclaration *> variables;
  78
  79         Block();
  80
  81         virtual Block *clone() const { return new Block(*this); }
  82         virtual void visit(NodeVisitor &);
  83 };
  84
  85 struct Expression: Node
  86 {
  87         virtual Expression *clone() const = 0;
  88 };
  89
  90 struct Literal: Expression
  91 {
  92         std::string token;
  93
  94         virtual Literal *clone() const { return new Literal(*this); }
  95         virtual void visit(NodeVisitor &);
  96 };
  97
  98 struct ParenthesizedExpression: Expression
  99 {
 100         NodePtr<Expression> expression;
 101
 102         virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
 103         virtual void visit(NodeVisitor &);
 104 };
 105
 106 struct VariableReference: Expression
 107 {
 108         std::string name;
 109         VariableDeclaration *declaration;
 110
 111         VariableReference();
 112
 113         virtual VariableReference *clone() const { return new VariableReference(*this); }
 114         virtual void visit(NodeVisitor &);
 115 };
 116
 117 struct MemberAccess: Expression
 118 {
 119         NodePtr<Expression> left;
 120         std::string member;
 121         VariableDeclaration *declaration;
 122
 123         virtual MemberAccess *clone() const { return new MemberAccess(*this); }
 124         virtual void visit(NodeVisitor &);
 125 };
 126
 127 struct UnaryExpression: Expression
 128 {
 129         std::string oper;
 130         NodePtr<Expression> expression;
 131         bool prefix;
 132
 133         UnaryExpression();
 134
 135         virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
 136         virtual void visit(NodeVisitor &);
 137 };
 138
 139 struct BinaryExpression: Expression
 140 {
 141         NodePtr<Expression> left;
 142         std::string oper;
 143         NodePtr<Expression> right;
 144         std::string after;
 145
 146         virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
 147         virtual void visit(NodeVisitor &);
 148 };
 149
 150 struct Assignment: BinaryExpression
 151 {
 152         bool self_referencing;
 153         VariableDeclaration *target_declaration;
 154
 155         Assignment();
 156
 157         virtual Assignment *clone() const { return new Assignment(*this); }
 158         virtual void visit(NodeVisitor &);
 159 };
 160
 161 struct FunctionCall: Expression
 162 {
 163         std::string name;
 164         FunctionDeclaration *declaration;
 165         bool constructor;
 166         NodeArray<Expression> arguments;
 167
 168         FunctionCall();
 169
 170         virtual FunctionCall *clone() const { return new FunctionCall(*this); }
 171         virtual void visit(NodeVisitor &);
 172 };
 173
 174 struct ExpressionStatement: Statement
 175 {
 176         NodePtr<Expression> expression;
 177
 178         virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
 179         virtual void visit(NodeVisitor &);
 180 };
 181
 182 struct Import: Statement
 183 {
 184         std::string module;
 185
 186         virtual Import *clone() const { return new Import(*this); }
 187         virtual void visit(NodeVisitor &);
 188 };
 189
 190 struct Precision: Statement
 191 {
 192         std::string precision;
 193         std::string type;
 194
 195         virtual Precision *clone() const { return new Precision(*this); }
 196         virtual void visit(NodeVisitor &);
 197 };
 198
 199 struct Layout: Node
 200 {
 201         struct Qualifier
 202         {
 203                 // TODO the standard calls this name, not identifier
 204                 std::string identifier;
 205                 std::string value;
 206         };
 207
 208         std::vector<Qualifier> qualifiers;
 209
 210         virtual Layout *clone() const { return new Layout(*this); }
 211         virtual void visit(NodeVisitor &);
 212 };
 213
 214 struct InterfaceLayout: Statement
 215 {
 216         std::string interface;
 217         Layout layout;
 218
 219         virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
 220         virtual void visit(NodeVisitor &);
 221 };
 222
 223 struct StructDeclaration: Statement
 224 {
 225         std::string name;
 226         Block members;
 227
 228         StructDeclaration();
 229
 230         virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
 231         virtual void visit(NodeVisitor &);
 232 };
 233
 234 struct VariableDeclaration: Statement
 235 {
 236         bool constant;
 237         std::string sampling;
 238         std::string interpolation;
 239         std::string interface;
 240         std::string precision;
 241         std::string type;
 242         StructDeclaration *type_declaration;
 243         std::string name;
 244         bool array;
 245         NodePtr<Expression> array_size;
 246         NodePtr<Expression> init_expression;
 247         VariableDeclaration *linked_declaration;
 248         NodePtr<Layout> layout;
 249
 250         VariableDeclaration();
 251
 252         virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
 253         virtual void visit(NodeVisitor &);
 254 };
 255
 256 struct InterfaceBlock: Statement
 257 {
 258         std::string interface;
 259         std::string name;
 260         Block members;
 261         std::string instance_name;
 262         bool array;
 263
 264         InterfaceBlock();
 265
 266         virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
 267         virtual void visit(NodeVisitor &);
 268 };
 269
 270 struct FunctionDeclaration: Statement
 271 {
 272         std::string return_type;
 273         std::string name;
 274         NodeArray<VariableDeclaration> parameters;
 275         FunctionDeclaration *definition;
 276         Block body;
 277
 278         FunctionDeclaration();
 279         FunctionDeclaration(const FunctionDeclaration &);
 280
 281         virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
 282         virtual void visit(NodeVisitor &);
 283 };
 284
 285 struct Conditional: Statement
 286 {
 287         NodePtr<Expression> condition;
 288         Block body;
 289         Block else_body;
 290
 291         virtual Conditional *clone() const { return new Conditional(*this); }
 292         virtual void visit(NodeVisitor &);
 293 };
 294
 295 struct Iteration: Statement
 296 {
 297         NodePtr<Node> init_statement;
 298         NodePtr<Expression> condition;
 299         NodePtr<Expression> loop_expression;
 300         Block body;
 301
 302         virtual Iteration *clone() const { return new Iteration(*this); }
 303         virtual void visit(NodeVisitor &);
 304 };
 305
 306 struct Passthrough: Statement
 307 {
 308         NodePtr<Expression> subscript;
 309
 310         virtual Passthrough *clone() const { return new Passthrough(*this); }
 311         virtual void visit(NodeVisitor &);
 312 };
 313
 314 struct Return: Statement
 315 {
 316         NodePtr<Expression> expression;
 317
 318         virtual Return *clone() const { return new Return(*this); }
 319         virtual void visit(NodeVisitor &);
 320 };
 321
 322 struct Jump: Statement
 323 {
 324         std::string keyword;
 325
 326         virtual Jump *clone() const { return new Jump(*this); }
 327         virtual void visit(NodeVisitor &);
 328 };
 329
 330 struct NodeVisitor
 331 {
 332         virtual ~NodeVisitor() { }
 333
 334         virtual void visit(Block &) { }
 335         virtual void visit(Literal &) { }
 336         virtual void visit(ParenthesizedExpression &) { }
 337         virtual void visit(VariableReference &) { }
 338         virtual void visit(MemberAccess &) { }
 339         virtual void visit(UnaryExpression &) { }
 340         virtual void visit(BinaryExpression &) { }
 341         virtual void visit(Assignment &);
 342         virtual void visit(FunctionCall &) { }
 343         virtual void visit(ExpressionStatement &) { }
 344         virtual void visit(Import &) { }
 345         virtual void visit(Precision &) { }
 346         virtual void visit(Layout &) { }
 347         virtual void visit(InterfaceLayout &) { }
 348         virtual void visit(StructDeclaration &) { }
 349         virtual void visit(VariableDeclaration &) { }
 350         virtual void visit(InterfaceBlock &) { }
 351         virtual void visit(FunctionDeclaration &) { }
 352         virtual void visit(Conditional &) { }
 353         virtual void visit(Iteration &) { }
 354         virtual void visit(Passthrough &) { }
 355         virtual void visit(Return &) { }
 356         virtual void visit(Jump &) { }
 357 };
 358
 359 struct TraversingVisitor: NodeVisitor
 360 {
 361         using NodeVisitor::visit;
 362         virtual void visit(Block &);
 363         virtual void visit(ParenthesizedExpression &);
 364         virtual void visit(MemberAccess &);
 365         virtual void visit(UnaryExpression &);
 366         virtual void visit(BinaryExpression &);
 367         virtual void visit(FunctionCall &);
 368         virtual void visit(ExpressionStatement &);
 369         virtual void visit(InterfaceLayout &);
 370         virtual void visit(StructDeclaration &);
 371         virtual void visit(VariableDeclaration &);
 372         virtual void visit(InterfaceBlock &);
 373         virtual void visit(FunctionDeclaration &);
 374         virtual void visit(Conditional &);
 375         virtual void visit(Iteration &);
 376         virtual void visit(Passthrough &);
 377         virtual void visit(Return &);
 378 };
 379
 380 enum StageType
 381 {
 382         SHARED,
 383         VERTEX,
 384         GEOMETRY,
 385         FRAGMENT
 386 };
 387
 388 struct Stage
 389 {
 390         StageType type;
 391         Stage *previous;
 392         ProgramSyntax::Block content;
 393         std::map<std::string, VariableDeclaration *> in_variables;
 394         std::map<std::string, VariableDeclaration *> out_variables;
 395         std::map<std::string, unsigned> locations;
 396         Version required_version;
 397         std::vector<const Extension *> required_extensions;
 398
 399         Stage(StageType);
 400 };
 401
 402 struct Module
 403 {
 404         Stage shared;
 405         std::list<Stage> stages;
 406
 407         Module();
 408 };
 409
 410 } // namespace ProgramSyntax
 411 } // namespace GL
 412 } // namespace Msp
 413
 414 #pragma pop_macro("interface")
 415
 416 #endif