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