#ifndef MSP_GL_PROGRAMSYNTAX_H_
#define MSP_GL_PROGRAMSYNTAX_H_
+#include <list>
#include <map>
#include <string>
#include <vector>
struct Node
{
+private:
+ Node &operator=(const Node &);
+public:
virtual ~Node() { }
+ virtual Node *clone() const = 0;
virtual void visit(NodeVisitor &) = 0;
};
+template<typename T>
+class NodePtr
+{
+private:
+ T *node;
+
+public:
+ NodePtr(T *n = 0): node(n) { }
+ NodePtr(const NodePtr &p): node(clone(p.node)) { }
+ NodePtr &operator=(const NodePtr &p) { delete node; node = clone(p.node); return *this; }
+ ~NodePtr() { delete node; }
+
+private:
+ static T *clone(T *n) { return n ? n->clone() : 0; }
+
+public:
+ T *operator->() { return node; }
+ const T *operator->() const { return node; }
+ operator void *() const { return node; }
+};
+
+struct VariableDeclaration;
+
struct Block: Node
{
- std::vector<Node *> body;
+ std::list<NodePtr<Node> > body;
bool use_braces;
Block();
- virtual ~Block();
+ virtual Block *clone() const { return new Block(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
+struct Expression: Node
+{
+ virtual Expression *clone() const = 0;
+};
+
+struct Literal: Expression
+{
+ std::string token;
+
+ virtual Literal *clone() const { return new Literal(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
+struct ParenthesizedExpression: Expression
+{
+ NodePtr<Expression> expression;
+
+ virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
+struct VariableReference: Expression
+{
+ std::string name;
+
+ virtual VariableReference *clone() const { return new VariableReference(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
+struct MemberAccess: Expression
+{
+ NodePtr<Expression> left;
+ std::string member;
+
+ virtual MemberAccess *clone() const { return new MemberAccess(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
+struct UnaryExpression: Expression
+{
+ std::string oper;
+ NodePtr<Expression> expression;
+ bool prefix;
+
+ UnaryExpression();
+
+ virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
virtual void visit(NodeVisitor &);
};
-struct Expression
+struct BinaryExpression: Expression
{
- std::vector<std::string> tokens;
+ NodePtr<Expression> left;
+ std::string oper;
+ NodePtr<Expression> right;
+ std::string after;
+ bool assignment;
+
+ BinaryExpression();
- bool empty() const { return tokens.empty(); }
+ virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
+struct FunctionCall: Expression
+{
+ std::string name;
+ bool constructor;
+ std::vector<NodePtr<Expression> > arguments;
+
+ FunctionCall();
+
+ virtual FunctionCall *clone() const { return new FunctionCall(*this); }
+ virtual void visit(NodeVisitor &);
};
struct ExpressionStatement: Node
{
- Expression expression;
+ NodePtr<Expression> expression;
+ virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
virtual void visit(NodeVisitor &);
};
std::vector<Qualifier> qualifiers;
std::string interface;
+ virtual Layout *clone() const { return new Layout(*this); }
virtual void visit(NodeVisitor &);
};
StructDeclaration();
+ virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
virtual void visit(NodeVisitor &);
};
std::string type;
std::string name;
bool array;
- Expression array_size;
- Expression init_expression;
+ NodePtr<Expression> array_size;
+ NodePtr<Expression> init_expression;
VariableDeclaration();
+ virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
virtual void visit(NodeVisitor &);
};
InterfaceBlock();
+ virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
virtual void visit(NodeVisitor &);
};
{
std::string return_type;
std::string name;
- std::vector<VariableDeclaration *> parameters;
+ std::vector<NodePtr<VariableDeclaration> > parameters;
bool definition;
Block body;
FunctionDeclaration();
- ~FunctionDeclaration();
+ virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
virtual void visit(NodeVisitor &);
};
struct Conditional: Node
{
- Expression condition;
+ Expression *condition;
Block body;
Block else_body;
+ virtual Conditional *clone() const { return new Conditional(*this); }
virtual void visit(NodeVisitor &);
};
struct Iteration: Node
{
- Node *init_statement;
- Expression condition;
- Expression loop_expression;
+ NodePtr<Node> init_statement;
+ NodePtr<Expression> condition;
+ NodePtr<Expression> loop_expression;
Block body;
- Iteration();
- virtual ~Iteration();
-
+ virtual Iteration *clone() const { return new Iteration(*this); }
virtual void visit(NodeVisitor &);
};
struct Return: Node
{
- Expression expression;
+ NodePtr<Expression> expression;
+ virtual Return *clone() const { return new Return(*this); }
virtual void visit(NodeVisitor &);
};
virtual ~NodeVisitor() { }
virtual void visit(Block &) { }
+ virtual void visit(Literal &) { }
+ virtual void visit(ParenthesizedExpression &) { }
+ virtual void visit(VariableReference &) { }
+ virtual void visit(MemberAccess &) { }
+ virtual void visit(UnaryExpression &) { }
+ virtual void visit(BinaryExpression &) { }
+ virtual void visit(FunctionCall &) { }
virtual void visit(ExpressionStatement &) { }
virtual void visit(Layout &) { }
virtual void visit(StructDeclaration &) { }