#include <map>
#include <string>
#include <vector>
+#include <msp/core/refptr.h>
#include "extension.h"
namespace Msp {
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; }
-#if __cplusplus>=201103L
- NodePtr(NodePtr &&p): node(p.node) { p.node = 0; }
- NodePtr &operator=(NodePtr &&p) { delete node; node = p.node; p.node = 0; return *this; }
-#endif
- ~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; }
- T &operator*() { return *node; }
- const T &operator*() const { return *node; }
- operator void *() const { return node; }
-};
-
struct StructDeclaration;
struct VariableDeclaration;
struct FunctionDeclaration;
struct Block: Node
{
- std::list<NodePtr<Node> > body;
+ std::list<RefPtr<Node> > body;
bool use_braces;
std::map<std::string, StructDeclaration *> types;
std::map<std::string, VariableDeclaration *> variables;
struct ParenthesizedExpression: Expression
{
- NodePtr<Expression> expression;
+ RefPtr<Expression> expression;
virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
virtual void visit(NodeVisitor &);
struct MemberAccess: Expression
{
- NodePtr<Expression> left;
+ RefPtr<Expression> left;
std::string member;
VariableDeclaration *declaration;
struct UnaryExpression: Expression
{
std::string oper;
- NodePtr<Expression> expression;
+ RefPtr<Expression> expression;
bool prefix;
UnaryExpression();
struct BinaryExpression: Expression
{
- NodePtr<Expression> left;
+ RefPtr<Expression> left;
std::string oper;
- NodePtr<Expression> right;
+ RefPtr<Expression> right;
std::string after;
virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
std::string name;
FunctionDeclaration *declaration;
bool constructor;
- std::vector<NodePtr<Expression> > arguments;
+ std::vector<RefPtr<Expression> > arguments;
FunctionCall();
struct ExpressionStatement: Node
{
- NodePtr<Expression> expression;
+ RefPtr<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 &);
};
+struct InterfaceLayout: Node
+{
+ std::string interface;
+ Layout layout;
+
+ virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
+ virtual void visit(NodeVisitor &);
+};
+
struct StructDeclaration: Node
{
std::string name;
StructDeclaration *type_declaration;
std::string name;
bool array;
- NodePtr<Expression> array_size;
- NodePtr<Expression> init_expression;
+ RefPtr<Expression> array_size;
+ RefPtr<Expression> init_expression;
VariableDeclaration *linked_declaration;
+ RefPtr<Layout> layout;
VariableDeclaration();
{
std::string return_type;
std::string name;
- std::vector<NodePtr<VariableDeclaration> > parameters;
+ std::vector<RefPtr<VariableDeclaration> > parameters;
FunctionDeclaration *definition;
Block body;
struct Conditional: Node
{
- NodePtr<Expression> condition;
+ RefPtr<Expression> condition;
Block body;
Block else_body;
struct Iteration: Node
{
- NodePtr<Node> init_statement;
- NodePtr<Expression> condition;
- NodePtr<Expression> loop_expression;
+ RefPtr<Node> init_statement;
+ RefPtr<Expression> condition;
+ RefPtr<Expression> loop_expression;
Block body;
virtual Iteration *clone() const { return new Iteration(*this); }
struct Passthrough: Node
{
- NodePtr<Expression> subscript;
+ RefPtr<Expression> subscript;
virtual Passthrough *clone() const { return new Passthrough(*this); }
virtual void visit(NodeVisitor &);
struct Return: Node
{
- NodePtr<Expression> expression;
+ RefPtr<Expression> expression;
virtual Return *clone() const { return new Return(*this); }
virtual void visit(NodeVisitor &);
virtual void visit(ExpressionStatement &) { }
virtual void visit(Import &) { }
virtual void visit(Layout &) { }
+ virtual void visit(InterfaceLayout &) { }
virtual void visit(StructDeclaration &) { }
virtual void visit(VariableDeclaration &) { }
virtual void visit(InterfaceBlock &) { }
virtual void visit(BinaryExpression &);
virtual void visit(FunctionCall &);
virtual void visit(ExpressionStatement &);
+ virtual void visit(InterfaceLayout &);
virtual void visit(StructDeclaration &);
virtual void visit(VariableDeclaration &);
virtual void visit(InterfaceBlock &);
ProgramSyntax::Block content;
std::map<std::string, VariableDeclaration *> in_variables;
std::map<std::string, VariableDeclaration *> out_variables;
+ std::map<std::string, unsigned> locations;
Version required_version;
Stage(StageType);