/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef DIRECTOR_LINGO_LINGO_AST_H
#define DIRECTOR_LINGO_LINGO_AST_H

namespace Director {

struct Node;
struct ScriptNode;
struct FactoryNode;
struct HandlerNode;
struct CmdNode;
struct PutIntoNode;
struct PutAfterNode;
struct PutBeforeNode;
struct SetNode;
struct GlobalNode;
struct PropertyNode;
struct InstanceNode;
struct IfStmtNode;
struct IfElseStmtNode;
struct RepeatWhileNode;
struct RepeatWithToNode;
struct RepeatWithInNode;
struct NextRepeatNode;
struct ExitRepeatNode;
struct ExitNode;
struct ReturnNode;
struct TellNode;
struct WhenNode;
struct DeleteNode;
struct HiliteNode;
struct AssertErrorNode;
struct IntNode;
struct FloatNode;
struct SymbolNode;
struct StringNode;
struct ListNode;
struct PropListNode;
struct PropPairNode;
struct FuncNode;
struct VarNode;
struct ParensNode;
struct UnaryOpNode;
struct BinaryOpNode;
struct FrameNode;
struct MovieNode;
struct IntersectsNode;
struct WithinNode;
struct TheNode;
struct TheOfNode;
struct TheNumberOfNode;
struct TheLastNode;
struct TheDateTimeNode;
struct MenuNode;
struct MenuItemNode;
struct SoundNode;
struct SpriteNode;
struct ChunkExprNode;

typedef Common::Array<Node *> NodeList;
typedef Common::Array<Common::String *> IDList;

typedef void (*inst)(void);

template <typename T>
void deleteList(Common::Array<T> *list) {
	for (uint i = 0; i < list->size(); i++) {
		delete (*list)[i];
	}
	delete list;
}

enum NodeType {
	kScriptNode,
	kFactoryNode,
	kHandlerNode,
	kCmdNode,
	kPutIntoNode,
	kPutAfterNode,
	kPutBeforeNode,
	kSetNode,
	kGlobalNode,
	kPropertyNode,
	kInstanceNode,
	kIfStmtNode,
	kIfElseStmtNode,
	kRepeatWhileNode,
	kRepeatWithToNode,
	kRepeatWithInNode,
	kNextRepeatNode,
	kExitRepeatNode,
	kExitNode,
	kReturnNode,
	kTellNode,
	kWhenNode,
	kDeleteNode,
	kHiliteNode,
	kAssertErrorNode,
	kIntNode,
	kFloatNode,
	kSymbolNode,
	kStringNode,
	kListNode,
	kPropListNode,
	kPropPairNode,
	kFuncNode,
	kVarNode,
	kParensNode,
	kUnaryOpNode,
	kBinaryOpNode,
	kFrameNode,
	kMovieNode,
	kIntersectsNode,
	kWithinNode,
	kTheNode,
	kTheOfNode,
	kTheNumberOfNode,
	kTheLastNode,
	kTheDateTimeNode,
	kMenuNode,
	kMenuItemNode,
	kSoundNode,
	kSpriteNode,
	kChunkExprNode
};

enum NumberOfType {
	kNumberOfChars,
	kNumberOfWords,
	kNumberOfItems,
	kNumberOfLines,
	kNumberOfMenuItems,
	kNumberOfMenus,
	kNumberOfXtras,
	kNumberOfCastlibs,
};

/* NodeVisitor */

class NodeVisitor {
public:
	NodeVisitor() {}
	virtual ~NodeVisitor() {}

	virtual bool visitScriptNode(ScriptNode *node) = 0;
	virtual bool visitFactoryNode(FactoryNode *node) = 0;
	virtual bool visitHandlerNode(HandlerNode *node) = 0;
	virtual bool visitCmdNode(CmdNode *node) = 0;
	virtual bool visitPutIntoNode(PutIntoNode *node) = 0;
	virtual bool visitPutAfterNode(PutAfterNode *node) = 0;
	virtual bool visitPutBeforeNode(PutBeforeNode *node) = 0;
	virtual bool visitSetNode(SetNode *node) = 0;
	virtual bool visitGlobalNode(GlobalNode *node) = 0;
	virtual bool visitPropertyNode(PropertyNode *node) = 0;
	virtual bool visitInstanceNode(InstanceNode *node) = 0;
	virtual bool visitIfStmtNode(IfStmtNode *node) = 0;
	virtual bool visitIfElseStmtNode(IfElseStmtNode *node) = 0;
	virtual bool visitRepeatWhileNode(RepeatWhileNode *node) = 0;
	virtual bool visitRepeatWithToNode(RepeatWithToNode *node) = 0;
	virtual bool visitRepeatWithInNode(RepeatWithInNode *node) = 0;
	virtual bool visitNextRepeatNode(NextRepeatNode *node) = 0;
	virtual bool visitExitRepeatNode(ExitRepeatNode *node) = 0;
	virtual bool visitExitNode(ExitNode *node) = 0;
	virtual bool visitReturnNode(ReturnNode *node) = 0;
	virtual bool visitTellNode(TellNode *node) = 0;
	virtual bool visitWhenNode(WhenNode *node) = 0;
	virtual bool visitDeleteNode(DeleteNode *node) = 0;
	virtual bool visitHiliteNode(HiliteNode *node) = 0;
	virtual bool visitAssertErrorNode(AssertErrorNode *node) = 0;
	virtual bool visitIntNode(IntNode *node) = 0;
	virtual bool visitFloatNode(FloatNode *node) = 0;
	virtual bool visitSymbolNode(SymbolNode *node) = 0;
	virtual bool visitStringNode(StringNode *node) = 0;
	virtual bool visitListNode(ListNode *node) = 0;
	virtual bool visitPropListNode(PropListNode *node) = 0;
	virtual bool visitPropPairNode(PropPairNode *node) = 0;
	virtual bool visitFuncNode(FuncNode *node) = 0;
	virtual bool visitVarNode(VarNode *node) = 0;
	virtual bool visitParensNode(ParensNode *node) = 0;
	virtual bool visitUnaryOpNode(UnaryOpNode *node) = 0;
	virtual bool visitBinaryOpNode(BinaryOpNode *node) = 0;
	virtual bool visitFrameNode(FrameNode *node) = 0;
	virtual bool visitMovieNode(MovieNode *node) = 0;
	virtual bool visitIntersectsNode(IntersectsNode *node) = 0;
	virtual bool visitWithinNode(WithinNode *node) = 0;
	virtual bool visitTheNode(TheNode *node) = 0;
	virtual bool visitTheOfNode(TheOfNode *node) = 0;
	virtual bool visitTheNumberOfNode(TheNumberOfNode *node) = 0;
	virtual bool visitTheLastNode(TheLastNode *node) = 0;
	virtual bool visitTheDateTimeNode(TheDateTimeNode *node) = 0;
	virtual bool visitMenuNode(MenuNode *node) = 0;
	virtual bool visitMenuItemNode(MenuItemNode *node) = 0;
	virtual bool visitSoundNode(SoundNode *node) = 0;
	virtual bool visitSpriteNode(SpriteNode *node) = 0;
	virtual bool visitChunkExprNode(ChunkExprNode *node) = 0;
};

/* Node */

struct Node {
	NodeType type;
	bool isExpression;
	bool isStatement;
	bool isLoop;
	uint32 startOffset;
	uint32 endOffset;

	Node(NodeType t) : type(t), isExpression(false), isStatement(false), isLoop(false), startOffset(0), endOffset(0) {}
	virtual ~Node() {}
	virtual bool accept(NodeVisitor *visitor) = 0;
};

/* ExprNode */

struct ExprNode : Node {
	ExprNode(NodeType t) : Node(t) {
		isExpression = true;
	}
	virtual ~ExprNode() {}
};

/* StmtNode */

struct StmtNode : Node {
	StmtNode(NodeType t) : Node(t) {
		isStatement = true;
	}
	virtual ~StmtNode() {}
};

/* LoopNode */

struct LoopNode : StmtNode {
	Common::Array<uint> nextRepeats;
	Common::Array<uint> exitRepeats;

	LoopNode(NodeType t) : StmtNode(t) {
		isLoop = true;
	}
	virtual ~LoopNode() {}
};

/* ScriptNode */

struct ScriptNode : Node {
	NodeList *children;

	ScriptNode(NodeList *childrenIn): Node(kScriptNode), children(childrenIn) {}
	virtual ~ScriptNode() {
		deleteList(children);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitScriptNode(this);
	}
};

/* FactoryNode */

struct FactoryNode : Node {
	Common::String *name;
	NodeList *methods;

	FactoryNode(Common::String *nameIn, NodeList *methodsIn)
		: Node(kFactoryNode), name(nameIn), methods(methodsIn) {}
	virtual ~FactoryNode() {
		delete name;
		deleteList(methods);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitFactoryNode(this);
	}
};

/* HandlerNode */

struct HandlerNode : Node {
	Common::String *name;
	IDList *args;
	NodeList *stmts;

	HandlerNode(Common::String *nameIn, IDList *argsIn, NodeList *stmtsIn)
		: Node(kHandlerNode), name(nameIn), args(argsIn), stmts(stmtsIn) {}
	virtual ~HandlerNode() {
		delete name;
		deleteList(args);
		deleteList(stmts);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitHandlerNode(this);
	}
};

/* CmdNode */

struct CmdNode : StmtNode {
	Common::String *name;
	NodeList *args;
	uint lineNumber;

	CmdNode(Common::String *nameIn, NodeList *argsIn, uint lineNumberIn)
		: StmtNode(kCmdNode), name(nameIn), args(argsIn), lineNumber(lineNumberIn) {}
	virtual ~CmdNode() {
		delete name;
		deleteList(args);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitCmdNode(this);
	}
};

/* PutIntoNode */

struct PutIntoNode : StmtNode {
	Node *val;
	Node *var;

	PutIntoNode(Node *valIn, Node *varIn)
		: StmtNode(kPutIntoNode), val(valIn), var(varIn) {}
	virtual ~PutIntoNode() {
		delete val;
		delete var;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitPutIntoNode(this);
	}
};

/* PutAfterNode */

struct PutAfterNode : StmtNode {
	Node *val;
	Node *var;

	PutAfterNode(Node *valIn, Node *varIn)
		: StmtNode(kPutAfterNode), val(valIn), var(varIn) {}
	virtual ~PutAfterNode() {
		delete val;
		delete var;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitPutAfterNode(this);
	}
};

/* PutBeforeNode */

struct PutBeforeNode : StmtNode {
	Node *val;
	Node *var;

	PutBeforeNode(Node *valIn, Node *varIn)
		: StmtNode(kPutBeforeNode), val(valIn), var(varIn) {}
	virtual ~PutBeforeNode() {
		delete val;
		delete var;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitPutBeforeNode(this);
	}
};

/* SetNode */

struct SetNode : StmtNode {
	Node *var;
	Node *val;

	SetNode(Node *varIn, Node *valIn)
		: StmtNode(kSetNode), var(varIn), val(valIn) {}
	virtual ~SetNode() {
		delete var;
		delete val;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitSetNode(this);
	}
};

/* GlobalNode */

struct GlobalNode : StmtNode {
	IDList *names;

	GlobalNode(IDList *namesIn) : StmtNode(kGlobalNode), names(namesIn) {}
	virtual ~GlobalNode() {
		deleteList(names);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitGlobalNode(this);
	}
};

/* PropertyNode */

struct PropertyNode : StmtNode {
	IDList *names;

	PropertyNode(IDList *namesIn) : StmtNode(kPropertyNode), names(namesIn) {}
	virtual ~PropertyNode() {
		deleteList(names);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitPropertyNode(this);
	}
};

/* InstanceNode */

struct InstanceNode : StmtNode {
	IDList *names;

	InstanceNode(IDList *namesIn) : StmtNode(kInstanceNode), names(namesIn) {}
	virtual ~InstanceNode() {
		deleteList(names);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitInstanceNode(this);
	}
};

/* IfStmtNode */

struct IfStmtNode : StmtNode {
	Node *cond;
	NodeList *stmts;

	IfStmtNode(Node *condIn, NodeList *stmtsIn)
		: StmtNode(kIfStmtNode), cond(condIn), stmts(stmtsIn) {}
	virtual ~IfStmtNode() {
		delete cond;
		deleteList(stmts);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitIfStmtNode(this);
	}
};

/* IfElseStmtNode */

struct IfElseStmtNode : StmtNode {
	Node *cond;
	NodeList *stmts1;
	NodeList *stmts2;

	IfElseStmtNode(Node *condIn, NodeList *stmts1In, NodeList *stmts2In)
		: StmtNode(kIfElseStmtNode), cond(condIn), stmts1(stmts1In), stmts2(stmts2In) {}
	virtual ~IfElseStmtNode() {
		delete cond;
		deleteList(stmts1);
		deleteList(stmts2);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitIfElseStmtNode(this);
	}
};

/* RepeatWhileNode */

struct RepeatWhileNode : LoopNode {
	Node *cond;
	NodeList *stmts;

	RepeatWhileNode(Node *condIn, NodeList *stmtsIn)
		: LoopNode(kRepeatWhileNode), cond(condIn), stmts(stmtsIn) {}
	virtual ~RepeatWhileNode() {
		delete cond;
		deleteList(stmts);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitRepeatWhileNode(this);
	}
};

/* RepeatWithToNode */

struct RepeatWithToNode : LoopNode {
	Common::String *var;
	Node *start;
	bool down;
	Node *end;
	NodeList *stmts;

	RepeatWithToNode(Common::String *varIn, Node *startIn, bool downIn, Node *endIn, NodeList *stmtsIn)
		: LoopNode(kRepeatWithToNode), var(varIn), start(startIn), down(downIn), end(endIn), stmts(stmtsIn) {}
	virtual ~RepeatWithToNode() {
		delete var;
		delete start;
		delete end;
		deleteList(stmts);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitRepeatWithToNode(this);
	}
};

/* RepeatWithInNode */

struct RepeatWithInNode : LoopNode {
	Common::String *var;
	Node *list;
	NodeList *stmts;

	RepeatWithInNode(Common::String *varIn, Node *listIn, NodeList *stmtsIn)
		: LoopNode(kRepeatWithInNode), var(varIn), list(listIn), stmts(stmtsIn) {}
	virtual ~RepeatWithInNode() {
		delete var;
		delete list;
		deleteList(stmts);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitRepeatWithInNode(this);
	}
};

/* NextRepeatNode */

struct NextRepeatNode : StmtNode {
	NextRepeatNode() : StmtNode(kNextRepeatNode) {}
	virtual ~NextRepeatNode() {}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitNextRepeatNode(this);
	}
};

/* ExitRepeatNode */

struct ExitRepeatNode : StmtNode {
	ExitRepeatNode() : StmtNode(kExitRepeatNode) {}
	virtual ~ExitRepeatNode() {}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitExitRepeatNode(this);
	}
};

/* ExitNode */

struct ExitNode : StmtNode {
	ExitNode() : StmtNode(kExitNode) {}
	virtual ~ExitNode() {}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitExitNode(this);
	}
};

/* ReturnNode */

struct ReturnNode : StmtNode {
	Node *expr;
	ReturnNode(Node *exprIn) : StmtNode(kReturnNode), expr(exprIn) {}
	virtual ~ReturnNode() {
		if (expr)
			delete expr;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitReturnNode(this);
	}
};


/* TellNode */

struct TellNode : StmtNode {
	Node *target;
	NodeList *stmts;

	TellNode(Node *targetIn, NodeList *stmtsIn)
		: StmtNode(kTellNode), target(targetIn), stmts(stmtsIn) {}
	virtual ~TellNode() {
		delete target;
		deleteList(stmts);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitTellNode(this);
	}
};

/* WhenNode */

struct WhenNode : StmtNode {
	Common::String *event;
	Common::String *code;

	WhenNode(Common::String *eventIn, Common::String *codeIn)
		: StmtNode(kWhenNode), event(eventIn), code(codeIn) {}
	virtual ~WhenNode() {
		delete event;
		delete code;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitWhenNode(this);
	}
};

/* DeleteNode */

struct DeleteNode : StmtNode {
	Node *chunk;

	DeleteNode(Node *chunkIn) : StmtNode(kDeleteNode), chunk(chunkIn) {}
	virtual ~DeleteNode() {
		delete chunk;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitDeleteNode(this);
	}
};

/* HiliteNode */

struct HiliteNode : StmtNode {
	Node *chunk;

	HiliteNode(Node *chunkIn) : StmtNode(kHiliteNode), chunk(chunkIn) {}
	virtual ~HiliteNode() {
		delete chunk;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitHiliteNode(this);
	}
};

/* AssertErrorNode */

struct AssertErrorNode : StmtNode {
	Node *stmt;

	AssertErrorNode(Node *stmtIn) : StmtNode(kAssertErrorNode), stmt(stmtIn) {}
	virtual ~AssertErrorNode() {
		delete stmt;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitAssertErrorNode(this);
	}
};

/* IntNode */

struct IntNode : ExprNode {
	int val;

	IntNode(int valIn) : ExprNode(kIntNode), val(valIn) {}
	virtual ~IntNode() {}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitIntNode(this);
	}
};

/* FloatNode */

struct FloatNode : ExprNode {
	double val;

	FloatNode(double valIn) : ExprNode(kFloatNode), val(valIn) {}
	virtual ~FloatNode() {}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitFloatNode(this);
	}
};

/* SymbolNode */

struct SymbolNode : ExprNode {
	Common::String *val;

	SymbolNode(Common::String *valIn) : ExprNode(kSymbolNode), val(valIn) {}
	virtual ~SymbolNode() {
		delete val;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitSymbolNode(this);
	}
};

/* StringNode */

struct StringNode : ExprNode {
	Common::String *val;

	StringNode(Common::String *valIn) : ExprNode(kStringNode), val(valIn) {}
	virtual ~StringNode() {
		delete val;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitStringNode(this);
	}
};

/* ListNode */

struct ListNode : ExprNode {
	NodeList *items;

	ListNode(NodeList *itemsIn) : ExprNode(kListNode), items(itemsIn) {}
	virtual ~ListNode() {
		deleteList(items);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitListNode(this);
	}
};

/* PropListNode */

struct PropListNode : ExprNode {
	NodeList *items;

	PropListNode(NodeList *itemsIn) : ExprNode(kListNode), items(itemsIn) {}
	virtual ~PropListNode() {
		deleteList(items);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitPropListNode(this);
	}
};

/* PropPairNode */

struct PropPairNode : ExprNode {
	Node *key;
	Node *val;

	PropPairNode(Node *keyIn, Node *valIn)
		: ExprNode(kPropPairNode), key(keyIn), val(valIn) {}
	virtual ~PropPairNode() {
		delete key;
		delete val;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitPropPairNode(this);
	}
};

/* FuncNode */

struct FuncNode : ExprNode {
	Common::String *name;
	NodeList *args;

	FuncNode(Common::String *nameIn, NodeList *argsIn)
		: ExprNode(kFuncNode), name(nameIn), args(argsIn) {}
	virtual ~FuncNode() {
		delete name;
		deleteList(args);
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitFuncNode(this);
	}
};

/* VarNode */

struct VarNode : ExprNode {
	Common::String *name;

	VarNode(Common::String *nameIn) : ExprNode(kVarNode), name(nameIn) {}
	virtual ~VarNode() {
		delete name;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitVarNode(this);
	}
};

/* ParensNode */

struct ParensNode : ExprNode {
	Node *expr;

	ParensNode(Node *exprIn) : ExprNode(kParensNode), expr(exprIn) {}
	virtual ~ParensNode() {
		delete expr;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitParensNode(this);
	}
};

/* UnaryOpNode */

struct UnaryOpNode : ExprNode {
	inst op;
	Node *arg;

	UnaryOpNode(inst opIn, Node *argIn) : ExprNode(kUnaryOpNode), op(opIn), arg(argIn) {}
	virtual ~UnaryOpNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitUnaryOpNode(this);
	}
};

/* BinaryOpNode */

struct BinaryOpNode : ExprNode {
	inst op;
	Node *a;
	Node *b;

	BinaryOpNode(inst opIn, Node *aIn, Node *bIn) : ExprNode(kBinaryOpNode), op(opIn), a(aIn), b(bIn) {}
	virtual ~BinaryOpNode() {
		delete a;
		delete b;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitBinaryOpNode(this);
	}
};

/* FrameNode */

struct FrameNode : ExprNode {
	Node *arg;

	FrameNode(Node *argIn) : ExprNode(kFrameNode), arg(argIn) {}
	virtual ~FrameNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitFrameNode(this);
	}
};

/* MovieNode */

struct MovieNode : ExprNode {
	Node *arg;

	MovieNode(Node *argIn) : ExprNode(kMovieNode), arg(argIn) {}
	virtual ~MovieNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitMovieNode(this);
	}
};

/* IntersectsNode */

struct IntersectsNode : ExprNode {
	Node *sprite1;
	Node *sprite2;

	IntersectsNode(Node *sprite1In, Node *sprite2In)
		: ExprNode(kIntersectsNode), sprite1(sprite1In), sprite2(sprite2In) {}
	virtual ~IntersectsNode() {
		delete sprite1;
		delete sprite2;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitIntersectsNode(this);
	}
};

/* WithinNode */

struct WithinNode : ExprNode {
	Node *sprite1;
	Node *sprite2;

	WithinNode(Node *sprite1In, Node *sprite2In)
		: ExprNode(kWithinNode), sprite1(sprite1In), sprite2(sprite2In) {}
	virtual ~WithinNode() {
		delete sprite1;
		delete sprite2;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitWithinNode(this);
	}
};

/* TheNode */

struct TheNode : ExprNode {
	Common::String *prop;

	TheNode(Common::String *propIn) : ExprNode(kTheNode), prop(propIn) {}
	virtual ~TheNode() {
		delete prop;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitTheNode(this);
	}
};

/* TheOfNode */

struct TheOfNode : ExprNode {
	Common::String *prop;
	Node *obj;

	TheOfNode(Common::String *propIn, Node *objIn)
		: ExprNode(kTheOfNode), prop(propIn), obj(objIn) {}
	virtual ~TheOfNode() {
		delete prop;
		delete obj;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitTheOfNode(this);
	}
};

/* TheNumberOfNode */

struct TheNumberOfNode : ExprNode {
	NumberOfType type;
	Node *arg;

	TheNumberOfNode(NumberOfType typeIn, Node *argIn)
		: ExprNode(kTheNumberOfNode), type(typeIn), arg(argIn) {}
	virtual ~TheNumberOfNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitTheNumberOfNode(this);
	}
};

/* TheLastNode */

struct TheLastNode : ExprNode {
	ChunkType type;
	Node *arg;

	TheLastNode(ChunkType typeIn, Node *argIn)
		: ExprNode(kTheLastNode), type(typeIn), arg(argIn) {}
	virtual ~TheLastNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitTheLastNode(this);
	}
};

/* TheDateTimeNode */

struct TheDateTimeNode : ExprNode {
	int field;
	int entity;

	TheDateTimeNode(int fieldIn, int entityIn)
		: ExprNode(kTheDateTimeNode), field(fieldIn), entity(entityIn) {}
	virtual ~TheDateTimeNode() {}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitTheDateTimeNode(this);
	}
};

/* MenuNode */

struct MenuNode : ExprNode {
	Node *arg;

	MenuNode(Node *argIn) : ExprNode(kMenuNode), arg(argIn) {}
	virtual ~MenuNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitMenuNode(this);
	}
};

/* MenuItemNode */

struct MenuItemNode : ExprNode {
	Node *arg1;
	Node *arg2;

	MenuItemNode(Node *arg1In, Node *arg2In)
		: ExprNode(kMenuItemNode), arg1(arg1In), arg2(arg2In) {}
	virtual ~MenuItemNode() {
		delete arg1;
		delete arg2;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitMenuItemNode(this);
	}
};

/* SoundNode */

struct SoundNode : ExprNode {
	Node *arg;

	SoundNode(Node *argIn) : ExprNode(kSoundNode), arg(argIn) {}
	virtual ~SoundNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitSoundNode(this);
	}
};

/* SpriteNode */

struct SpriteNode : ExprNode {
	Node *arg;

	SpriteNode(Node *argIn) : ExprNode(kSpriteNode), arg(argIn) {}
	virtual ~SpriteNode() {
		delete arg;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitSpriteNode(this);
	}
};

/* ChunkExprNode */

struct ChunkExprNode : ExprNode {
	ChunkType type;
	Node *start;
	Node *end;
	Node *src;

	ChunkExprNode(ChunkType typeIn, Node *startIn, Node *endIn, Node *srcIn)
		: ExprNode(kChunkExprNode), type(typeIn), start(startIn), end(endIn), src(srcIn) {}
	virtual ~ChunkExprNode() {
		delete start;
		delete end;
		delete src;
	}
	virtual bool accept(NodeVisitor *visitor) {
		return visitor->visitChunkExprNode(this);
	}
};

} // End of namespace Director

#endif