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