xref: /netbsd/src/external/bsd/elftosb/dist/elftosb2/ElftosbAST.h

/*
 * 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_