OpenGrok

/*
 * File:	ElftosbAST.h
 *
 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
 * See included license file for license details.
 */
#if !defined(_ElftosbAST_h_)
#define _ElftosbAST_h_

#include "stdafx.h"
#include <string>
#include <list>
#include "smart_ptr.h"
#include "EvalContext.h"

namespace elftosb
{

// forward reference
class SymbolASTNode;

/*!
 * \brief Token location in the source file.
 */
struct token_loc_t
{
	int m_firstLine;	//!< Starting line of the token.
	int m_lastLine;		//!< Ending line of the token.
};

/*!
 * \brief The base class for all AST node classes.
 */
class ASTNode
{
public:
	//! \brief Default constructor.
	ASTNode() : m_parent(0) {}

	//! \brief Constructor taking a parent node.
	ASTNode(ASTNode * parent) : m_parent(parent) {}

	//! \brief Copy constructor.
	ASTNode(const ASTNode & other) : m_parent(other.m_parent) {}

	//! \brief Destructor.
	virtual ~ASTNode() {}

	//! \brief Returns an exact duplicate of this object.
	virtual ASTNode * clone() const = 0;

	//! \brief Returns the name of the object's class.
	virtual std::string nodeName() const { return "ASTNode"; }

	//! \name Parents
	//@{
	virtual ASTNode * getParent() const { return m_parent; }
	virtual void setParent(ASTNode * newParent) { m_parent = newParent; }
	//@}

	//! \name Tree printing
	//@{
	virtual void printTree() const { printTree(0); }
	virtual void printTree(int indent) const;
	//@}

	//! \name Location
	//@{
	virtual void setLocation(token_loc_t & loc) { m_location = loc; }
	virtual void setLocation(token_loc_t & first, token_loc_t & last);
	virtual void setLocation(ASTNode * loc) { setLocation(loc->getLocation()); }
	virtual void setLocation(ASTNode * first, ASTNode * last);

	virtual token_loc_t & getLocation() { return m_location; }
	virtual const token_loc_t & getLocation() const { return m_location; }

	virtual int getFirstLine() { return m_location.m_firstLine; }
	virtual int getLastLine() { return m_location.m_lastLine; }
	//@}

protected:
	ASTNode * m_parent;	//!< Pointer to parent node of this object. May be NULL.
	token_loc_t m_location;	//!< Location of this node in the source file.

	//! \brief Prints \a indent number of spaces.
	void printIndent(int indent) const;
};

/*!
 * \brief AST node that contains other AST nodes.
 *
 * Unlike other AST nodes, the location of a ListASTNode is computed dynamically
 * based on the nodes in its list. Or mostly dynamic at least. The updateLocation()
 * method is used to force the list object to recalculate its beginning and ending
 * line numbers.
 *
 * \todo Figure out why it crashes in the destructor when the
 *       ast_list_t type is a list of smart_ptr<ASTNode>.
 */
class ListASTNode : public ASTNode
{
public:
	typedef std::list< /*smart_ptr<ASTNode>*/ ASTNode * > ast_list_t;
	typedef ast_list_t::iterator iterator;
	typedef ast_list_t::const_iterator const_iterator;

public:
	ListASTNode() {}

	ListASTNode(const ListASTNode & other);

	virtual ~ListASTNode();

	virtual ASTNode * clone() const { return new ListASTNode(*this); }

	virtual std::string nodeName() const { return "ListASTNode"; }

	virtual void printTree(int indent) const;

	//! \name List operations
	//@{
	//! \brief Adds \a node to the end of the ordered list of child nodes.
	virtual void appendNode(ASTNode * node);

	//! \brief Returns the number of nodes in this list.
	virtual unsigned nodeCount() const { return static_cast<unsigned>(m_list.size()); }
	//@}

	//! \name Node iterators
	//@{
	inline iterator begin() { return m_list.begin(); }
	inline iterator end() { return m_list.end(); }

	inline const_iterator begin() const { return m_list.begin(); }
	inline const_iterator end() const { return m_list.end(); }
	//@}

	//! \name Location
	//@{
	virtual void updateLocation();
	//@}

protected:
	ast_list_t m_list;	//!< Ordered list of child nodes.
};

/*!
 *
 */
class OptionsBlockASTNode : public ASTNode
{
public:
	OptionsBlockASTNode(ListASTNode * options) : ASTNode(), m_options(options) {}

	inline ListASTNode * getOptions() { return m_options; }

	virtual ASTNode * clone() const { return NULL; }

protected:
	smart_ptr<ListASTNode> m_options;
};

/*!
 *
 */
class ConstantsBlockASTNode : public ASTNode
{
public:
	ConstantsBlockASTNode(ListASTNode * constants) : ASTNode(), m_constants(constants) {}

	inline ListASTNode * getConstants() { return m_constants; }

	virtual ASTNode * clone() const { return NULL; }

protected:
	smart_ptr<ListASTNode> m_constants;
};

/*!
 *
 */
class SourcesBlockASTNode : public ASTNode
{
public:
	SourcesBlockASTNode(ListASTNode * sources) : ASTNode(), m_sources(sources) {}

	inline ListASTNode * getSources() { return m_sources; }

	virtual ASTNode * clone() const { return NULL; }

protected:
	smart_ptr<ListASTNode> m_sources;
};

/*!
 * \brief Root node for the entire file.
 */
class CommandFileASTNode : public ASTNode
{
public:
	CommandFileASTNode();
	CommandFileASTNode(const CommandFileASTNode & other);

	virtual std::string nodeName() const { return "CommandFileASTNode"; }

	virtual ASTNode * clone() const { return new CommandFileASTNode(*this); }

	virtual void printTree(int indent) const;

	inline void setBlocks(ListASTNode * blocks) { m_blocks = blocks; }
	inline void setOptions(ListASTNode * options) { m_options = options; }
	inline void setConstants(ListASTNode * constants) { m_constants = constants; }
	inline void setSources(ListASTNode * sources) { m_sources = sources; }
	inline void setSections(ListASTNode * sections) { m_sections = sections; }

	inline ListASTNode * getBlocks() { return m_blocks; }
	inline ListASTNode * getOptions() { return m_options; }
	inline ListASTNode * getConstants() { return m_constants; }
	inline ListASTNode * getSources() { return m_sources; }
	inline ListASTNode * getSections() { return m_sections; }

protected:
	smart_ptr<ListASTNode> m_blocks;
	smart_ptr<ListASTNode> m_options;
	smart_ptr<ListASTNode> m_constants;
	smart_ptr<ListASTNode> m_sources;
	smart_ptr<ListASTNode> m_sections;
};

/*!
 * \brief Abstract base class for all expression AST nodes.
 */
class ExprASTNode : public ASTNode
{
public:
	ExprASTNode() : ASTNode() {}
	ExprASTNode(const ExprASTNode & other) : ASTNode(other) {}

	virtual std::string nodeName() const { return "ExprASTNode"; }

	//! \brief Evaluate the expression and produce a result node to replace this one.
	//!
	//! The default implementation simply return this node unmodified. This
	//! method is responsible for deleting any nodes that are no longer needed.
	//! (?) how to delete this?
	virtual ExprASTNode * reduce(EvalContext & context) { return this; }

	int_size_t resultIntSize(int_size_t a, int_size_t b);
};

/*!
 *
 */
class IntConstExprASTNode : public ExprASTNode
{
public:
	IntConstExprASTNode(uint32_t value, int_size_t size=kWordSize)
	:	ExprASTNode(), m_value(value), m_size(size)
	{
	}

	IntConstExprASTNode(const IntConstExprASTNode & other);

	virtual std::string nodeName() const { return "IntConstExprASTNode"; }

	virtual ASTNode * clone() const { return new IntConstExprASTNode(*this); }

	virtual void printTree(int indent) const;

	uint32_t getValue() const { return m_value; }
	int_size_t getSize() const { return m_size; }

protected:
	uint32_t m_value;
	int_size_t m_size;
};

/*!
 *
 */
class VariableExprASTNode : public ExprASTNode
{
public:
	VariableExprASTNode(std::string * name) : ExprASTNode(), m_variable(name) {}
	VariableExprASTNode(const VariableExprASTNode & other);

	inline std::string * getVariableName() { return m_variable; }

	virtual ASTNode * clone() const { return new VariableExprASTNode(*this); }

	virtual std::string nodeName() const { return "VariableExprASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

protected:
	smart_ptr<std::string> m_variable;
};

/*!
 * \brief Expression node for a symbol reference.
 *
 * The symbol evaluates to its address.
 */
class SymbolRefExprASTNode : public ExprASTNode
{
public:
	SymbolRefExprASTNode(SymbolASTNode * sym) : ExprASTNode(), m_symbol(sym) {}
	SymbolRefExprASTNode(const SymbolRefExprASTNode & other);

	virtual ASTNode * clone() const { return new SymbolRefExprASTNode(*this); }

	virtual std::string nodeName() const { return "SymbolRefExprASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

protected:
	SymbolASTNode * m_symbol;
};

/*!
 * \brief Negates an expression.
 */
class NegativeExprASTNode : public ExprASTNode
{
public:
	NegativeExprASTNode(ExprASTNode * expr) : ExprASTNode(), m_expr(expr) {}
	NegativeExprASTNode(const NegativeExprASTNode & other);

	virtual ASTNode * clone() const { return new NegativeExprASTNode(*this); }

	virtual std::string nodeName() const { return "NegativeExprASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	ExprASTNode * getExpr() { return m_expr; }

protected:
	smart_ptr<ExprASTNode> m_expr;
};

/*!
 * \brief Performa a boolean inversion.
 */
class BooleanNotExprASTNode : public ExprASTNode
{
public:
	BooleanNotExprASTNode(ExprASTNode * expr) : ExprASTNode(), m_expr(expr) {}
	BooleanNotExprASTNode(const BooleanNotExprASTNode & other);

	virtual ASTNode * clone() const { return new BooleanNotExprASTNode(*this); }

	virtual std::string nodeName() const { return "BooleanNotExprASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	ExprASTNode * getExpr() { return m_expr; }

protected:
	smart_ptr<ExprASTNode> m_expr;
};

/*!
 * \brief Calls a built-in function with a source as the parameter.
 */
class SourceFileFunctionASTNode : public ExprASTNode
{
public:
	SourceFileFunctionASTNode(std::string * functionName, std::string * sourceFileName) : ExprASTNode(), m_functionName(functionName), m_sourceFile(sourceFileName) {}
	SourceFileFunctionASTNode(const SourceFileFunctionASTNode & other);

	virtual ASTNode * clone() const { return new SourceFileFunctionASTNode(*this); }

	virtual std::string nodeName() const { return "SourceFileFunctionASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	std::string * getFunctionName() { return m_functionName; }
	std::string * getSourceFile() { return m_sourceFile; }

protected:
	smart_ptr<std::string> m_functionName;
	smart_ptr<std::string> m_sourceFile;
};

/*!
 * \brief Returns true or false depending on whether a constant is defined.
 */
class DefinedOperatorASTNode : public ExprASTNode
{
public:
	DefinedOperatorASTNode(std::string * constantName) : ExprASTNode(), m_constantName(constantName) {}
	DefinedOperatorASTNode(const DefinedOperatorASTNode & other);

	virtual ASTNode * clone() const { return new DefinedOperatorASTNode(*this); }

	virtual std::string nodeName() const { return "DefinedOperatorASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	std::string * getConstantName() { return m_constantName; }

protected:
	smart_ptr<std::string> m_constantName;	//!< Name of the constant.
};

class SymbolASTNode;

/*!
 * \brief Returns an integer that is the size in bytes of the operand.
 */
class SizeofOperatorASTNode : public ExprASTNode
{
public:
	SizeofOperatorASTNode(std::string * constantName) : ExprASTNode(), m_constantName(constantName), m_symbol() {}
	SizeofOperatorASTNode(SymbolASTNode * symbol) : ExprASTNode(), m_constantName(), m_symbol(symbol) {}
	SizeofOperatorASTNode(const SizeofOperatorASTNode & other);

	virtual ASTNode * clone() const { return new SizeofOperatorASTNode(*this); }

	virtual std::string nodeName() const { return "SizeofOperatorASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	std::string * getConstantName() { return m_constantName; }
	SymbolASTNode * getSymbol() { return m_symbol; }

protected:
	smart_ptr<std::string> m_constantName;	//!< Name of the constant.
	smart_ptr<SymbolASTNode> m_symbol;	//!< Symbol reference. If this is non-NULL then the constant name is used instead.
};

/*!
 *
 */
class BinaryOpExprASTNode : public ExprASTNode
{
public:
	enum operator_t
	{
		kAdd,
		kSubtract,
		kMultiply,
		kDivide,
		kModulus,
		kPower,
		kBitwiseAnd,
		kBitwiseOr,
		kBitwiseXor,
		kShiftLeft,
		kShiftRight,
		kLessThan,
		kGreaterThan,
		kLessThanEqual,
		kGreaterThanEqual,
		kEqual,
		kNotEqual,
		kBooleanAnd,
		kBooleanOr
	};

	BinaryOpExprASTNode(ExprASTNode * left, operator_t op, ExprASTNode * right)
	:	ExprASTNode(), m_left(left), m_op(op), m_right(right)
	{
	}

	BinaryOpExprASTNode(const BinaryOpExprASTNode & other);

	virtual ASTNode * clone() const { return new BinaryOpExprASTNode(*this); }

	virtual std::string nodeName() const { return "BinaryOpExprASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	ExprASTNode * getLeftExpr() { return m_left; }
	ExprASTNode * getRightExpr() { return m_right; }
	operator_t getOp() const { return m_op; }

protected:
	smart_ptr<ExprASTNode> m_left;
	smart_ptr<ExprASTNode> m_right;
	operator_t m_op;

	std::string getOperatorName() const;
};

/*!
 * \brief Negates an expression.
 */
class IntSizeExprASTNode : public ExprASTNode
{
public:
	IntSizeExprASTNode(ExprASTNode * expr, int_size_t intSize) : ExprASTNode(), m_expr(expr), m_size(intSize) {}
	IntSizeExprASTNode(const IntSizeExprASTNode & other);

	virtual ASTNode * clone() const { return new IntSizeExprASTNode(*this); }

	virtual std::string nodeName() const { return "IntSizeExprASTNode"; }

	virtual void printTree(int indent) const;

	virtual ExprASTNode * reduce(EvalContext & context);

	ExprASTNode * getExpr() { return m_expr; }
	int_size_t getIntSize() { return m_size; }

protected:
	smart_ptr<ExprASTNode> m_expr;
	int_size_t m_size;
};

/*!
 * Base class for const AST nodes.
 */
class ConstASTNode : public ASTNode
{
public:
	ConstASTNode() : ASTNode() {}
	ConstASTNode(const ConstASTNode & other) : ASTNode(other) {}

protected:
};

/*!
 *
 */
class ExprConstASTNode : public ConstASTNode
{
public:
	ExprConstASTNode(ExprASTNode * expr) : ConstASTNode(), m_expr(expr) {}
	ExprConstASTNode(const ExprConstASTNode & other);

	virtual ASTNode * clone() const { return new ExprConstASTNode(*this); }

	virtual std::string nodeName() const { return "ExprConstASTNode"; }

	virtual void printTree(int indent) const;

	ExprASTNode * getExpr() { return m_expr; }

protected:
	smart_ptr<ExprASTNode> m_expr;
};

/*!
 *
 */
class StringConstASTNode : public ConstASTNode
{
public:
	StringConstASTNode(std::string * value) : ConstASTNode(), m_value(value) {}
	StringConstASTNode(const StringConstASTNode & other);

	virtual ASTNode * clone() const { return new StringConstASTNode(*this); }

	virtual std::string nodeName() const { return "StringConstASTNode"; }

	virtual void printTree(int indent) const;

	std::string * getString() { return m_value; }

protected:
	smart_ptr<std::string> m_value;
};

/*!
 *
 */
class BlobConstASTNode : public ConstASTNode
{
public:
	BlobConstASTNode(Blob * value) : ConstASTNode(), m_blob(value) {}
	BlobConstASTNode(const BlobConstASTNode & other);

	virtual ASTNode * clone() const { return new BlobConstASTNode(*this); }

	virtual std::string nodeName() const { return "BlobConstASTNode"; }

	virtual void printTree(int indent) const;

	Blob * getBlob() { return m_blob; }

protected:
	smart_ptr<Blob> m_blob;
};

// Forward declaration.
struct hab_ivt;

/*!
 * \brief Node for a constant IVT structure as used by HAB4.
 */
class IVTConstASTNode : public ConstASTNode
{
public:
    IVTConstASTNode() : ConstASTNode(), m_fields() {}
    IVTConstASTNode(const IVTConstASTNode & other);

	virtual ASTNode * clone() const { return new IVTConstASTNode(*this); }

	virtual std::string nodeName() const { return "IVTConstASTNode"; }

	virtual void printTree(int indent) const;

    void setFieldAssignments(ListASTNode * fields) { m_fields = fields; }
    ListASTNode * getFieldAssignments() { return m_fields; }

protected:
    //! Fields of the IVT are set through assignment statements.
    smart_ptr<ListASTNode> m_fields;
};

/*!
 *
 */
class AssignmentASTNode : public ASTNode
{
public:
	AssignmentASTNode(std::string * ident, ASTNode * value)
	:	ASTNode(), m_ident(ident), m_value(value)
	{
	}

	AssignmentASTNode(const AssignmentASTNode & other);

	virtual ASTNode * clone() const { return new AssignmentASTNode(*this); }

	virtual std::string nodeName() const { return "AssignmentASTNode"; }

	virtual void printTree(int indent) const;

	inline std::string * getIdent() { return m_ident; }
	inline ASTNode * getValue() { return m_value; }

protected:
	smart_ptr<std::string> m_ident;
	smart_ptr<ASTNode> m_value;
};

/*!
 * Base class for PathSourceDefASTNode and ExternSourceDefASTNode.
 */
class SourceDefASTNode : public ASTNode
{
public:
	SourceDefASTNode(std::string * name) : m_name(name) {}
	SourceDefASTNode(const SourceDefASTNode & other);

	inline std::string * getName() { return m_name; }

	inline void setAttributes(ListASTNode * attributes) { m_attributes = attributes; }
	inline ListASTNode * getAttributes() { return m_attributes; }

protected:
	smart_ptr<std::string> m_name;
	smart_ptr<ListASTNode> m_attributes;
};

/*!
 *
 */
class PathSourceDefASTNode : public SourceDefASTNode
{
public:
	PathSourceDefASTNode(std::string * name, std::string * path)
	:	SourceDefASTNode(name), m_path(path)
	{
	}

	PathSourceDefASTNode(const PathSourceDefASTNode & other);

	virtual PathSourceDefASTNode * clone() const { return new PathSourceDefASTNode(*this); }

	virtual std::string nodeName() const { return "PathSourceDefASTNode"; }

	virtual void printTree(int indent) const;

	std::string * getPath() { return m_path; }

protected:
	smart_ptr<std::string> m_path;
};

/*!
 *
 */
class ExternSourceDefASTNode : public SourceDefASTNode
{
public:
	ExternSourceDefASTNode(std::string * name, ExprASTNode * expr)
	:	SourceDefASTNode(name), m_expr(expr)
	{
	}

	ExternSourceDefASTNode(const ExternSourceDefASTNode & other);

	virtual ASTNode * clone() const { return new ExternSourceDefASTNode(*this); }

	virtual std::string nodeName() const { return "ExternSourceDefASTNode"; }

	virtual void printTree(int indent) const;

	ExprASTNode * getSourceNumberExpr() { return m_expr; }

protected:
	smart_ptr<ExprASTNode> m_expr;
};

/*!
 *
 */
class SectionContentsASTNode : public ASTNode
{
public:
	SectionContentsASTNode() : m_sectionExpr() {}
	SectionContentsASTNode(ExprASTNode * section) : m_sectionExpr(section) {}
	SectionContentsASTNode(const SectionContentsASTNode & other);

	virtual ASTNode * clone() const { return new SectionContentsASTNode(*this); }

	virtual std::string nodeName() const { return "SectionContentsASTNode"; }

	virtual void printTree(int indent) const;

	inline void setSectionNumberExpr(ExprASTNode * section)
	{
		m_sectionExpr = section;
	}

	inline ExprASTNode * getSectionNumberExpr()
	{
		return m_sectionExpr;
	}

	inline void setOptions(ListASTNode * options)
	{
		m_options = options;
	}

	inline ListASTNode * getOptions()
	{
		return m_options;
	}

protected:
	smart_ptr<ExprASTNode> m_sectionExpr;
	smart_ptr<ListASTNode> m_options;
};

/*!
 * @brief Node representing a raw binary section definition.
 */
class DataSectionContentsASTNode : public SectionContentsASTNode
{
public:
	DataSectionContentsASTNode(ASTNode * contents)
	:	SectionContentsASTNode(), m_contents(contents)
	{
	}

	DataSectionContentsASTNode(const DataSectionContentsASTNode & other);

	virtual ASTNode * clone() const { return new DataSectionContentsASTNode(*this); }

	virtual std::string nodeName() const { return "DataSectionContentsASTNode"; }

	virtual void printTree(int indent) const;

	ASTNode * getContents() { return m_contents; }

protected:
	smart_ptr<ASTNode> m_contents;
};

/*!
 *
 */
class BootableSectionContentsASTNode : public SectionContentsASTNode
{
public:
	BootableSectionContentsASTNode(ListASTNode * statements)
	:	SectionContentsASTNode(), m_statements(statements)
	{
	}

	BootableSectionContentsASTNode(const BootableSectionContentsASTNode & other);

	virtual ASTNode * clone() const { return new BootableSectionContentsASTNode(*this); }

	virtual std::string nodeName() const { return "BootableSectionContentsASTNode"; }

	virtual void printTree(int indent) const;

	ListASTNode * getStatements() { return m_statements; }

protected:
	smart_ptr<ListASTNode> m_statements;
};

/*!
 *
 */
class StatementASTNode : public ASTNode
{
public:
	StatementASTNode() : ASTNode() {}
	StatementASTNode(const StatementASTNode & other) : ASTNode(other) {}

protected:
};

/*!
 *
 */
class IfStatementASTNode : public StatementASTNode
{
public:
	IfStatementASTNode() : StatementASTNode(), m_ifStatements(), m_nextIf(), m_elseStatements() {}
	IfStatementASTNode(const IfStatementASTNode & other);

	virtual ASTNode * clone() const { return new IfStatementASTNode(*this); }

	void setConditionExpr(ExprASTNode * expr) { m_conditionExpr = expr; }
	ExprASTNode * getConditionExpr() { return m_conditionExpr; }

	void setIfStatements(ListASTNode * statements) { m_ifStatements = statements; }
	ListASTNode * getIfStatements() { return m_ifStatements; }

	void setNextIf(IfStatementASTNode * nextIf) { m_nextIf = nextIf; }
	IfStatementASTNode * getNextIf() { return m_nextIf; }

	void setElseStatements(ListASTNode * statements) { m_elseStatements = statements; }
	ListASTNode * getElseStatements() { return m_elseStatements; }

protected:
	smart_ptr<ExprASTNode> m_conditionExpr;	//!< Boolean expression.
	smart_ptr<ListASTNode> m_ifStatements;	//!< List of "if" section statements.
	smart_ptr<IfStatementASTNode> m_nextIf;	//!< Link to next "else if". If this is non-NULL then #m_elseStatements must be NULL and vice-versa.
	smart_ptr<ListASTNode> m_elseStatements;	//!< Statements for the "else" part of the statements.
};

/*!
 * \brief Statement to insert a ROM_MODE_CMD command.
 */
class ModeStatementASTNode : public StatementASTNode
{
public:
	ModeStatementASTNode() : StatementASTNode(), m_modeExpr() {}
	ModeStatementASTNode(ExprASTNode * modeExpr) : StatementASTNode(), m_modeExpr(modeExpr) {}
	ModeStatementASTNode(const ModeStatementASTNode & other);

	virtual ASTNode * clone() const { return new ModeStatementASTNode(*this); }

	virtual std::string nodeName() const { return "ModeStatementASTNode"; }

	virtual void printTree(int indent) const;

	inline void setModeExpr(ExprASTNode * modeExpr) { m_modeExpr = modeExpr; }
	inline ExprASTNode * getModeExpr() { return m_modeExpr; }

protected:
	smart_ptr<ExprASTNode> m_modeExpr;	//!< Expression that evaluates to the new boot mode.
};

/*!
 * \brief Statement to print a message to the elftosb user.
 */
class MessageStatementASTNode : public StatementASTNode
{
public:
	enum _message_type
	{
		kInfo,	//!< Prints an informational messag to the user.
		kWarning,	//!< Prints a warning to the user.
		kError	//!< Throws an error exception.
	};

	typedef enum _message_type message_type_t;

public:
	MessageStatementASTNode(message_type_t messageType, std::string * message) : StatementASTNode(), m_type(messageType), m_message(message) {}
	MessageStatementASTNode(const MessageStatementASTNode & other);

	virtual ASTNode * clone() const { return new MessageStatementASTNode(*this); }

	virtual std::string nodeName() const { return "MessageStatementASTNode"; }

	virtual void printTree(int indent) const;

	inline message_type_t getType() { return m_type; }
	inline std::string * getMessage() { return m_message; }

	const char * getTypeName() const;

protected:
	message_type_t m_type;
	smart_ptr<std::string> m_message;	//!< Message to report.
};

/*!
 * \brief AST node for a load statement.
 */
class LoadStatementASTNode : public StatementASTNode
{
public:
	LoadStatementASTNode()
	:	StatementASTNode(), m_data(), m_target(), m_isDCDLoad(false)
	{
	}

	LoadStatementASTNode(ASTNode * data, ASTNode * target)
	:	StatementASTNode(), m_data(data), m_target(), m_isDCDLoad(false)
	{
	}

	LoadStatementASTNode(const LoadStatementASTNode & other);

	virtual ASTNode * clone() const { return new LoadStatementASTNode(*this); }

	virtual std::string nodeName() const { return "LoadStatementASTNode"; }

	virtual void printTree(int indent) const;

	inline void setData(ASTNode * data) { m_data = data; }
	inline ASTNode * getData() { return m_data; }

	inline void setTarget(ASTNode * target) { m_target = target; }
	inline ASTNode * getTarget() { return m_target; }

	inline void setDCDLoad(bool isDCD) { m_isDCDLoad = isDCD; }
	inline bool isDCDLoad() const { return m_isDCDLoad; }

protected:
	smart_ptr<ASTNode> m_data;
	smart_ptr<ASTNode> m_target;
	bool m_isDCDLoad;
};

/*!
 * \brief AST node for a call statement.
 */
class CallStatementASTNode : public StatementASTNode
{
public:
	//! Possible sub-types of call statements.
	typedef enum {
		kCallType,
		kJumpType
	} call_type_t;

public:
	CallStatementASTNode(call_type_t callType=kCallType)
	:	StatementASTNode(), m_type(callType), m_target(), m_arg(), m_isHAB(false)
	{
	}

	CallStatementASTNode(call_type_t callType, ASTNode * target, ASTNode * arg)
	:	StatementASTNode(), m_type(callType), m_target(target), m_arg(arg), m_isHAB(false)
	{
	}

	CallStatementASTNode(const CallStatementASTNode & other);

	virtual ASTNode * clone() const { return new CallStatementASTNode(*this); }

	virtual std::string nodeName() const { return "CallStatementASTNode"; }

	virtual void printTree(int indent) const;

	inline void setCallType(call_type_t callType) { m_type = callType; }
	inline call_type_t getCallType() { return m_type; }

	inline void setTarget(ASTNode * target) { m_target = target; }
	inline ASTNode * getTarget() { return m_target; }

	inline void setArgument(ASTNode * arg) { m_arg = arg; }
	inline ASTNode * getArgument() { return m_arg; }

	inline void setIsHAB(bool isHAB) { m_isHAB = isHAB; }
	inline bool isHAB() const { return m_isHAB; }

protected:
	call_type_t m_type;
	smart_ptr<ASTNode> m_target;	//!< This becomes the IVT address in HAB mode.
	smart_ptr<ASTNode> m_arg;
	bool m_isHAB;
};

/*!
 *
 */
class SourceASTNode : public ASTNode
{
public:
	SourceASTNode(std::string * name) : ASTNode(), m_name(name) {}
	SourceASTNode(const SourceASTNode & other);

	virtual ASTNode * clone() const { return new SourceASTNode(*this); }

	virtual std::string nodeName() const { return "SourceASTNode"; }

	virtual void printTree(int indent) const;

	inline std::string * getSourceName() { return m_name; }

protected:
	smart_ptr<std::string> m_name;
};

/*!
 * \brief List of section matches for a particular source name.
 */
class SectionMatchListASTNode : public ASTNode
{
public:
	SectionMatchListASTNode(ListASTNode * sections)
	:	ASTNode(), m_sections(sections), m_source()
	{
	}

	SectionMatchListASTNode(ListASTNode * sections, std::string * source)
	:	ASTNode(), m_sections(sections), m_source(source)
	{
	}

	SectionMatchListASTNode(const SectionMatchListASTNode & other);

	virtual ASTNode * clone() const { return new SectionMatchListASTNode(*this); }

	virtual std::string nodeName() const { return "SectionMatchListASTNode"; }

	virtual void printTree(int indent) const;

	inline ListASTNode * getSections() { return m_sections; }
	inline std::string * getSourceName() { return m_source; }

protected:
	smart_ptr<ListASTNode> m_sections;
	smart_ptr<std::string> m_source;
};

/*!
 * \brief AST node for a section glob.
 *
 * Can be assigned an include or exclude action for when this node is part of a
 * SectionMatchListASTNode.
 */
class SectionASTNode : public ASTNode
{
public:
	//! Possible actions for a section match list.
	typedef enum
	{
		kInclude,	//!< Include sections matched by this node.
		kExclude	//!< Exclude sections matched by this node.
	} match_action_t;

public:
	SectionASTNode(std::string * name)
	:	ASTNode(), m_action(kInclude), m_name(name), m_source()
	{
	}

	SectionASTNode(std::string * name, match_action_t action)
	:	ASTNode(), m_action(action), m_name(name), m_source()
	{
	}

	SectionASTNode(std::string * name, std::string * source)
	:	ASTNode(), m_action(kInclude), m_name(name), m_source(source)
	{
	}

	SectionASTNode(const SectionASTNode & other);

	virtual ASTNode * clone() const { return new SectionASTNode(*this); }

	virtual std::string nodeName() const { return "SectionASTNode"; }

	virtual void printTree(int indent) const;

	inline match_action_t getAction() { return m_action; }
	inline std::string * getSectionName() { return m_name; }
	inline std::string * getSourceName() { return m_source; }

protected:
	match_action_t m_action;
	smart_ptr<std::string> m_name;
	smart_ptr<std::string> m_source;
};

/*!
 *
 */
class SymbolASTNode : public ASTNode
{
public:
	SymbolASTNode()
	:	ASTNode(), m_symbol(), m_source()
	{
	}

	SymbolASTNode(std::string * symbol, std::string * source=0)
	:	ASTNode(), m_symbol(symbol), m_source(source)
	{
	}

	SymbolASTNode(const SymbolASTNode & other);

	virtual ASTNode * clone() const { return new SymbolASTNode(*this); }

	virtual std::string nodeName() const { return "SymbolASTNode"; }

	virtual void printTree(int indent) const;

	inline void setSymbolName(std::string * symbol) { m_symbol = symbol; }
	inline std::string * getSymbolName() { return m_symbol; }

	inline void setSource(std::string * source) { m_source = source; }
	inline std::string * getSource() { return m_source; }

protected:
	smart_ptr<std::string> m_symbol;	//!< Required.
	smart_ptr<std::string> m_source;	//!< Optional, may be NULL;
};

/*!
 * If the end of the range is NULL, then only a single address was specified.
 */
class AddressRangeASTNode : public ASTNode
{
public:
	AddressRangeASTNode()
	:	ASTNode(), m_begin(), m_end()
	{
	}

	AddressRangeASTNode(ASTNode * begin, ASTNode * end)
	:	ASTNode(), m_begin(begin), m_end(end)
	{
	}

	AddressRangeASTNode(const AddressRangeASTNode & other);

	virtual ASTNode * clone() const { return new AddressRangeASTNode(*this); }

	virtual std::string nodeName() const { return "AddressRangeASTNode"; }

	virtual void printTree(int indent) const;

	inline void setBegin(ASTNode * begin) { m_begin = begin; }
	inline ASTNode * getBegin() { return m_begin; }

	inline void setEnd(ASTNode * end) { m_end = end; }
	inline ASTNode * getEnd() { return m_end; }

protected:
	smart_ptr<ASTNode> m_begin;
	smart_ptr<ASTNode> m_end;
};

/*!
 *
 */
class NaturalLocationASTNode : public ASTNode
{
public:
	NaturalLocationASTNode()
	:	ASTNode()
	{
	}

	NaturalLocationASTNode(const NaturalLocationASTNode & other)
	:	ASTNode(other)
	{
	}

	virtual ASTNode * clone() const { return new NaturalLocationASTNode(*this); }

	virtual std::string nodeName() const { return "NaturalLocationASTNode"; }
};

/*!
 *
 */
class FromStatementASTNode : public StatementASTNode
{
public:
	FromStatementASTNode() : StatementASTNode() {}
	FromStatementASTNode(std::string * source, ListASTNode * statements);
	FromStatementASTNode(const FromStatementASTNode & other);

	virtual ASTNode * clone() const { return new FromStatementASTNode(*this); }

	virtual std::string nodeName() const { return "FromStatementASTNode"; }

	virtual void printTree(int indent) const;

	inline void setSourceName(std::string * source) { m_source = source; }
	inline std::string * getSourceName() { return m_source; }

	inline void setStatements(ListASTNode * statements) { m_statements = statements; }
	inline ListASTNode * getStatements() { return m_statements; }

protected:
	smart_ptr<std::string> m_source;
	smart_ptr<ListASTNode> m_statements;
};

}; // namespace elftosb

#endif // _ElftosbAST_h_