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