dist/elftosb2/ElftosbAST.cpp

/*
 * File:	ElftosbAST.cpp
 *
 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
 * See included license file for license details.
 */

#include "ElftosbAST.h"
#include <stdexcept>
#include <math.h>
#include <assert.h>
#include "ElftosbErrors.h"
#include "format_string.h"

using namespace elftosb;

#pragma mark = ASTNode =

void ASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s\n", nodeName().c_str());
}

void ASTNode::printIndent(int indent) const
{
	int i;
	for (i=0; i<indent; ++i)
	{
		printf("   ");
	}
}

void ASTNode::setLocation(token_loc_t & first, token_loc_t & last)
{
	m_location.m_firstLine = first.m_firstLine;
	m_location.m_lastLine = last.m_lastLine;
}

void ASTNode::setLocation(ASTNode * first, ASTNode * last)
{
	m_location.m_firstLine = first->getLocation().m_firstLine;
	m_location.m_lastLine = last->getLocation().m_lastLine;
}

#pragma mark = ListASTNode =

ListASTNode::ListASTNode(const ListASTNode & other)
:	ASTNode(other), m_list()
{
	// deep copy each item of the original's list
	const_iterator it = other.begin();
	for (; it != other.end(); ++it)
	{
		m_list.push_back((*it)->clone());
	}
}

//! Deletes child node in the list.
//!
ListASTNode::~ListASTNode()
{
	iterator it = begin();
	for (; it != end(); it++)
	{
		delete *it;
	}
}

//! If \a node is NULL then the list is left unmodified.
//!
//! The list node's location is automatically updated after the node is added by a call
//! to updateLocation().
void ListASTNode::appendNode(ASTNode * node)
{
	if (node)
	{
		m_list.push_back(node);
		updateLocation();
	}
}

void ListASTNode::printTree(int indent) const
{
	ASTNode::printTree(indent);

	int n = 0;
	const_iterator it = begin();
	for (; it != end(); it++, n++)
	{
		printIndent(indent + 1);
		printf("%d:\n", n);
		(*it)->printTree(indent + 2);
	}
}

void ListASTNode::updateLocation()
{
	token_loc_t current = { 0 };
	const_iterator it = begin();
	for (; it != end(); it++)
	{
		const ASTNode * node = *it;
		const token_loc_t & loc = node->getLocation();

		// handle first node
		if (current.m_firstLine == 0)
		{
			current = loc;
			continue;
		}

		if (loc.m_firstLine < current.m_firstLine)
		{
			current.m_firstLine = loc.m_firstLine;
		}

		if (loc.m_lastLine > current.m_lastLine)
		{
			current.m_lastLine = loc.m_lastLine;
		}
	}

	setLocation(current);
}

#pragma mark = CommandFileASTNode =

CommandFileASTNode::CommandFileASTNode()
:	ASTNode(), m_options(), m_constants(), m_sources(), m_sections()
{
}

CommandFileASTNode::CommandFileASTNode(const CommandFileASTNode & other)
:	ASTNode(other), m_options(), m_constants(), m_sources(), m_sections()
{
	m_options = dynamic_cast<ListASTNode*>(other.m_options->clone());
	m_constants = dynamic_cast<ListASTNode*>(other.m_constants->clone());
	m_sources = dynamic_cast<ListASTNode*>(other.m_sources->clone());
	m_sections = dynamic_cast<ListASTNode*>(other.m_sections->clone());
}

void CommandFileASTNode::printTree(int indent) const
{
	ASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("options:\n");
	if (m_options) m_options->printTree(indent + 2);

	printIndent(indent + 1);
	printf("constants:\n");
	if (m_constants) m_constants->printTree(indent + 2);

	printIndent(indent + 1);
	printf("sources:\n");
	if (m_sources) m_sources->printTree(indent + 2);

	printIndent(indent + 1);
	printf("sections:\n");
	if (m_sections) m_sections->printTree(indent + 2);
}

#pragma mark = ExprASTNode =

int_size_t ExprASTNode::resultIntSize(int_size_t a, int_size_t b)
{
	int_size_t result;
	switch (a)
	{
		case kWordSize:
			result = kWordSize;
			break;
		case kHalfWordSize:
			if (b == kWordSize)
			{
				result = kWordSize;
			}
			else
			{
				result = kHalfWordSize;
			}
			break;
		case kByteSize:
			if (b == kWordSize)
			{
				result = kWordSize;
			}
			else if (b == kHalfWordSize)
			{
				result = kHalfWordSize;
			}
			else
			{
				result = kByteSize;
			}
			break;
	}

	return result;
}

#pragma mark = IntConstExprASTNode =

IntConstExprASTNode::IntConstExprASTNode(const IntConstExprASTNode & other)
:	ExprASTNode(other), m_value(other.m_value), m_size(other.m_size)
{
}

void IntConstExprASTNode::printTree(int indent) const
{
	printIndent(indent);
	char sizeChar='?';
	switch (m_size)
	{
		case kWordSize:
			sizeChar = 'w';
			break;
		case kHalfWordSize:
			sizeChar = 'h';
			break;
		case kByteSize:
			sizeChar = 'b';
			break;
	}
	printf("%s(%d:%c)\n", nodeName().c_str(), m_value, sizeChar);
}

#pragma mark = VariableExprASTNode =

VariableExprASTNode::VariableExprASTNode(const VariableExprASTNode & other)
:	ExprASTNode(other), m_variable()
{
	m_variable = new std::string(*other.m_variable);
}

void VariableExprASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s(%s)\n", nodeName().c_str(), m_variable->c_str());
}

ExprASTNode * VariableExprASTNode::reduce(EvalContext & context)
{
	if (!context.isVariableDefined(*m_variable))
	{
		throw std::runtime_error(format_string("line %d: undefined variable '%s'", getFirstLine(), m_variable->c_str()));
	}

	uint32_t value = context.getVariableValue(*m_variable);
	int_size_t size = context.getVariableSize(*m_variable);
	return new IntConstExprASTNode(value, size);
}

#pragma mark = SymbolRefExprASTNode =

SymbolRefExprASTNode::SymbolRefExprASTNode(const SymbolRefExprASTNode & other)
:	ExprASTNode(other), m_symbol(NULL)
{
	if (other.m_symbol)
	{
		m_symbol = dynamic_cast<SymbolASTNode*>(other.m_symbol->clone());
	}
}

void SymbolRefExprASTNode::printTree(int indent) const
{
}

ExprASTNode * SymbolRefExprASTNode::reduce(EvalContext & context)
{
	EvalContext::SourceFileManager * manager = context.getSourceFileManager();
	if (!manager)
	{
		throw std::runtime_error("no source manager available");
	}

	if (!m_symbol)
	{
		throw semantic_error("no symbol provided");
	}

	// Get the name of the symbol
	std::string * symbolName = m_symbol->getSymbolName();
//	if (!symbolName)
//	{
//		throw semantic_error(format_string("line %d: no symbol name provided", getFirstLine()));
//	}

	// Get the source file.
	std::string * sourceName = m_symbol->getSource();
	SourceFile * sourceFile;

	if (sourceName)
	{
		sourceFile = manager->getSourceFile(*sourceName);
		if (!sourceFile)
		{
			throw semantic_error(format_string("line %d: no source file named %s", getFirstLine(), sourceName->c_str()));
		}
	}
	else
	{
		sourceFile = manager->getDefaultSourceFile();
		if (!sourceFile)
		{
			throw semantic_error(format_string("line %d: no default source file is set", getFirstLine()));
		}
	}

	// open the file if it hasn't already been
	if (!sourceFile->isOpen())
	{
		sourceFile->open();
	}

	// Make sure the source file supports symbols before going any further
	if (symbolName && !sourceFile->supportsNamedSymbols())
	{
		throw semantic_error(format_string("line %d: source file %s does not support symbols", getFirstLine(), sourceFile->getPath().c_str()));
	}

    if (!symbolName && !sourceFile->hasEntryPoint())
    {
        throw semantic_error(format_string("line %d: source file %s does not have an entry point", getFirstLine(), sourceFile->getPath().c_str()));
    }

	// Returns a const expr node with the symbol's value.
	uint32_t value;
    if (symbolName)
    {
        value = sourceFile->getSymbolValue(*symbolName);
    }
    else
    {
        value = sourceFile->getEntryPointAddress();
    }
	return new IntConstExprASTNode(value);
}

#pragma mark = NegativeExprASTNode =

NegativeExprASTNode::NegativeExprASTNode(const NegativeExprASTNode & other)
:	ExprASTNode(other), m_expr()
{
	m_expr = dynamic_cast<ExprASTNode*>(other.m_expr->clone());
}

void NegativeExprASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);
	if (m_expr) m_expr->printTree(indent + 1);
}

ExprASTNode * NegativeExprASTNode::reduce(EvalContext & context)
{
	if (!m_expr)
	{
		return this;
	}

	m_expr = m_expr->reduce(context);
	IntConstExprASTNode * intConst = dynamic_cast<IntConstExprASTNode*>(m_expr.get());
	if (intConst)
	{
	    int32_t value = -(int32_t)intConst->getValue();
		return new IntConstExprASTNode((uint32_t)value, intConst->getSize());
	}
	else
	{
		return this;
	}
}

#pragma mark = BooleanNotExprASTNode =

BooleanNotExprASTNode::BooleanNotExprASTNode(const BooleanNotExprASTNode & other)
:	ExprASTNode(other), m_expr()
{
	m_expr = dynamic_cast<ExprASTNode*>(other.m_expr->clone());
}

void BooleanNotExprASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);
	if (m_expr) m_expr->printTree(indent + 1);
}

ExprASTNode * BooleanNotExprASTNode::reduce(EvalContext & context)
{
	if (!m_expr)
	{
		return this;
	}

	m_expr = m_expr->reduce(context);
	IntConstExprASTNode * intConst = dynamic_cast<IntConstExprASTNode*>(m_expr.get());
	if (intConst)
	{
	    int32_t value = !((int32_t)intConst->getValue());
		return new IntConstExprASTNode((uint32_t)value, intConst->getSize());
	}
	else
	{
		throw semantic_error(format_string("line %d: expression did not evaluate to an integer", m_expr->getFirstLine()));
	}
}

#pragma mark = SourceFileFunctionASTNode =

SourceFileFunctionASTNode::SourceFileFunctionASTNode(const SourceFileFunctionASTNode & other)
:	ExprASTNode(other), m_functionName(), m_sourceFile()
{
	m_functionName = new std::string(*other.m_functionName);
	m_sourceFile = new std::string(*other.m_sourceFile);
}

void SourceFileFunctionASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);
	printIndent(indent+1);

	// for some stupid reason the msft C++ compiler barfs on the following line if the ".get()" parts are remove,
	// even though the first line of reduce() below has the same expression, just in parentheses. stupid compiler.
	if (m_functionName.get() && m_sourceFile.get())
	{
		printf("%s ( %s )\n", m_functionName->c_str(), m_sourceFile->c_str());
	}
}

ExprASTNode * SourceFileFunctionASTNode::reduce(EvalContext & context)
{
	if (!(m_functionName && m_sourceFile))
	{
		throw std::runtime_error("unset function name or source file");
	}

	// Get source file manager from evaluation context. This will be the
	// conversion controller itself.
	EvalContext::SourceFileManager * mgr = context.getSourceFileManager();
	if (!mgr)
	{
		throw std::runtime_error("source file manager is not set");
	}

	// Perform function
	uint32_t functionResult = 0;
	if (*m_functionName == "exists")
	{
		functionResult = static_cast<uint32_t>(mgr->hasSourceFile(*m_sourceFile));
	}

	// Return function result as an expression node
	return new IntConstExprASTNode(functionResult);
}

#pragma mark = DefinedOperatorASTNode =

DefinedOperatorASTNode::DefinedOperatorASTNode(const DefinedOperatorASTNode & other)
:	ExprASTNode(other), m_constantName()
{
	m_constantName = new std::string(*other.m_constantName);
}

void DefinedOperatorASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);
	printIndent(indent+1);

	if (m_constantName)
	{
		printf("defined ( %s )\n", m_constantName->c_str());
	}
}

ExprASTNode * DefinedOperatorASTNode::reduce(EvalContext & context)
{
	assert(m_constantName);

	// Return function result as an expression node
	return new IntConstExprASTNode(context.isVariableDefined(m_constantName) ? 1 : 0);
}

#pragma mark = SizeofOperatorASTNode =

SizeofOperatorASTNode::SizeofOperatorASTNode(const SizeofOperatorASTNode & other)
:	ExprASTNode(other), m_constantName(), m_symbol()
{
	m_constantName = new std::string(*other.m_constantName);
	m_symbol = dynamic_cast<SymbolASTNode*>(other.m_symbol->clone());
}

void SizeofOperatorASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);

	printIndent(indent+1);

	if (m_constantName)
	{
		printf("sizeof: %s\n", m_constantName->c_str());
	}
	else if (m_symbol)
	{
		printf("sizeof:\n");
		m_symbol->printTree(indent + 2);
	}
}

ExprASTNode * SizeofOperatorASTNode::reduce(EvalContext & context)
{
	// One or the other must be defined.
	assert(m_constantName || m_symbol);

	EvalContext::SourceFileManager * manager = context.getSourceFileManager();
	assert(manager);

	unsigned sizeInBytes = 0;
	SourceFile * sourceFile;

	if (m_symbol)
	{
		// Get the symbol name.
		std::string * symbolName = m_symbol->getSymbolName();
		assert(symbolName);

		// Get the source file, using the default if one is not specified.
		std::string * sourceName = m_symbol->getSource();
		if (sourceName)
		{
			sourceFile = manager->getSourceFile(*sourceName);
			if (!sourceFile)
			{
				throw semantic_error(format_string("line %d: invalid source file: %s", getFirstLine(), sourceName->c_str()));
			}
		}
		else
		{
			sourceFile = manager->getDefaultSourceFile();
			if (!sourceFile)
			{
				throw semantic_error(format_string("line %d: no default source file is set", getFirstLine()));
			}
		}

		// Get the size of the symbol.
		if (sourceFile->hasSymbol(*symbolName))
		{
			sizeInBytes = sourceFile->getSymbolSize(*symbolName);
		}
	}
	else if (m_constantName)
	{
		// See if the "constant" is really a constant or if it's a source name.
		if (manager->hasSourceFile(m_constantName))
		{
			sourceFile = manager->getSourceFile(m_constantName);
			if (sourceFile)
			{
				sizeInBytes = sourceFile->getSize();
			}
		}
		else
		{
			// Regular constant.
			if (!context.isVariableDefined(*m_constantName))
			{
				throw semantic_error(format_string("line %d: cannot get size of undefined constant %s", getFirstLine(), m_constantName->c_str()));
			}

			int_size_t intSize = context.getVariableSize(*m_constantName);
			switch (intSize)
			{
				case kWordSize:
					sizeInBytes = sizeof(uint32_t);
					break;
				case kHalfWordSize:
					sizeInBytes = sizeof(uint16_t);
					break;
				case kByteSize:
					sizeInBytes = sizeof(uint8_t);
					break;
			}
		}
	}

	// Return function result as an expression node
	return new IntConstExprASTNode(sizeInBytes);
}

#pragma mark = BinaryOpExprASTNode =

BinaryOpExprASTNode::BinaryOpExprASTNode(const BinaryOpExprASTNode & other)
:	ExprASTNode(other), m_left(), m_op(other.m_op), m_right()
{
	m_left = dynamic_cast<ExprASTNode*>(other.m_left->clone());
	m_right = dynamic_cast<ExprASTNode*>(other.m_right->clone());
}

void BinaryOpExprASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("left:\n");
	if (m_left) m_left->printTree(indent + 2);

	printIndent(indent + 1);
	printf("op: %s\n", getOperatorName().c_str());

	printIndent(indent + 1);
	printf("right:\n");
	if (m_right) m_right->printTree(indent + 2);
}

std::string BinaryOpExprASTNode::getOperatorName() const
{
	switch (m_op)
	{
		case kAdd:
			return "+";
		case kSubtract:
			return "-";
		case kMultiply:
			return "*";
		case kDivide:
			return "/";
		case kModulus:
			return "%";
		case kPower:
			return "**";
		case kBitwiseAnd:
			return "&";
		case kBitwiseOr:
			return "|";
		case kBitwiseXor:
			return "^";
		case kShiftLeft:
			return "<<";
		case kShiftRight:
			return ">>";
		case kLessThan:
			return "<";
		case kGreaterThan:
			return ">";
		case kLessThanEqual:
			return "<=";
		case kGreaterThanEqual:
			return ">";
		case kEqual:
			return "==";
		case kNotEqual:
			return "!=";
		case kBooleanAnd:
			return "&&";
		case kBooleanOr:
			return "||";
	}

	return "???";
}

//! \todo Fix power operator under windows!!!
//!
ExprASTNode * BinaryOpExprASTNode::reduce(EvalContext & context)
{
	if (!m_left || !m_right)
	{
		return this;
	}

	IntConstExprASTNode * leftIntConst = NULL;
	IntConstExprASTNode * rightIntConst = NULL;
	uint32_t leftValue;
	uint32_t rightValue;
	uint32_t result = 0;

	// Always reduce the left hand side.
	m_left = m_left->reduce(context);
	leftIntConst = dynamic_cast<IntConstExprASTNode*>(m_left.get());
	if (!leftIntConst)
	{
		throw semantic_error(format_string("left hand side of %s operator failed to evaluate to an integer", getOperatorName().c_str()));
	}
	leftValue = leftIntConst->getValue();

	// Boolean && and || operators are handled separately so that we can perform
	// short-circuit evaluation.
	if (m_op == kBooleanAnd || m_op == kBooleanOr)
	{
		// Reduce right hand side only if required to evaluate the boolean operator.
		if ((m_op == kBooleanAnd && leftValue != 0) || (m_op == kBooleanOr && leftValue == 0))
		{
			m_right = m_right->reduce(context);
			rightIntConst = dynamic_cast<IntConstExprASTNode*>(m_right.get());
			if (!rightIntConst)
			{
				throw semantic_error(format_string("right hand side of %s operator failed to evaluate to an integer", getOperatorName().c_str()));
			}
			rightValue = rightIntConst->getValue();

			// Perform the boolean operation.
			switch (m_op)
			{
				case kBooleanAnd:
					result = leftValue && rightValue;
					break;

				case kBooleanOr:
					result = leftValue && rightValue;
					break;
			}
		}
		else if (m_op == kBooleanAnd)
		{
			// The left hand side is false, so the && operator's result must be false
			// without regard to the right hand side.
			result = 0;
		}
		else if (m_op == kBooleanOr)
		{
			// The left hand value is true so the || result is automatically true.
			result = 1;
		}
	}
	else
	{
		// Reduce right hand side always for most operators.
		m_right = m_right->reduce(context);
		rightIntConst = dynamic_cast<IntConstExprASTNode*>(m_right.get());
		if (!rightIntConst)
		{
			throw semantic_error(format_string("right hand side of %s operator failed to evaluate to an integer", getOperatorName().c_str()));
		}
		rightValue = rightIntConst->getValue();

		switch (m_op)
		{
			case kAdd:
				result = leftValue + rightValue;
				break;
			case kSubtract:
				result = leftValue - rightValue;
				break;
			case kMultiply:
				result = leftValue * rightValue;
				break;
			case kDivide:
				result = leftValue / rightValue;
				break;
			case kModulus:
				result = leftValue % rightValue;
				break;
			case kPower:
			#ifdef WIN32
				result = 0;
			#else
				result = lroundf(powf(float(leftValue), float(rightValue)));
			#endif
				break;
			case kBitwiseAnd:
				result = leftValue & rightValue;
				break;
			case kBitwiseOr:
				result = leftValue | rightValue;
				break;
			case kBitwiseXor:
				result = leftValue ^ rightValue;
				break;
			case kShiftLeft:
				result = leftValue << rightValue;
				break;
			case kShiftRight:
				result = leftValue >> rightValue;
				break;
			case kLessThan:
				result = leftValue < rightValue;
				break;
			case kGreaterThan:
				result = leftValue > rightValue;
				break;
			case kLessThanEqual:
				result = leftValue <= rightValue;
				break;
			case kGreaterThanEqual:
				result = leftValue >= rightValue;
				break;
			case kEqual:
				result = leftValue == rightValue;
				break;
			case kNotEqual:
				result = leftValue != rightValue;
				break;
		}
	}

	// Create the result value.
	int_size_t resultSize;
	if (leftIntConst && rightIntConst)
	{
		resultSize = resultIntSize(leftIntConst->getSize(), rightIntConst->getSize());
	}
	else if (leftIntConst)
	{
		resultSize = leftIntConst->getSize();
	}
	else
	{
		// This shouldn't really be possible, but just in case.
		resultSize = kWordSize;
	}
	return new IntConstExprASTNode(result, resultSize);
}

#pragma mark = IntSizeExprASTNode =

IntSizeExprASTNode::IntSizeExprASTNode(const IntSizeExprASTNode & other)
:	ExprASTNode(other), m_expr(), m_size(other.m_size)
{
	m_expr = dynamic_cast<ExprASTNode*>(other.m_expr->clone());
}

void IntSizeExprASTNode::printTree(int indent) const
{
	ExprASTNode::printTree(indent);

	char sizeChar='?';
	switch (m_size)
	{
		case kWordSize:
			sizeChar = 'w';
			break;
		case kHalfWordSize:
			sizeChar = 'h';
			break;
		case kByteSize:
			sizeChar = 'b';
			break;
	}
	printIndent(indent + 1);
	printf("size: %c\n", sizeChar);

	printIndent(indent + 1);
	printf("expr:\n");
	if (m_expr) m_expr->printTree(indent + 2);
}

ExprASTNode * IntSizeExprASTNode::reduce(EvalContext & context)
{
	if (!m_expr)
	{
		return this;
	}

	m_expr = m_expr->reduce(context);
	IntConstExprASTNode * intConst = dynamic_cast<IntConstExprASTNode*>(m_expr.get());
	if (!intConst)
	{
		return this;
	}

	return new IntConstExprASTNode(intConst->getValue(), m_size);
}

#pragma mark = ExprConstASTNode =

ExprConstASTNode::ExprConstASTNode(const ExprConstASTNode & other)
:	ConstASTNode(other), m_expr()
{
	m_expr = dynamic_cast<ExprASTNode*>(other.m_expr->clone());
}

void ExprConstASTNode::printTree(int indent) const
{
	ConstASTNode::printTree(indent);
	if (m_expr) m_expr->printTree(indent + 1);
}

#pragma mark = StringConstASTNode =

StringConstASTNode::StringConstASTNode(const StringConstASTNode & other)
:	ConstASTNode(other), m_value()
{
	m_value = new std::string(other.m_value);
}

void StringConstASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s(%s)\n", nodeName().c_str(), m_value->c_str());
}

#pragma mark = BlobConstASTNode =

BlobConstASTNode::BlobConstASTNode(const BlobConstASTNode & other)
:	ConstASTNode(other), m_blob()
{
	m_blob = new Blob(*other.m_blob);
}

void BlobConstASTNode::printTree(int indent) const
{
	printIndent(indent);

	const uint8_t * dataPtr = m_blob->getData();
	unsigned dataLen = m_blob->getLength();
	printf("%s(%p:%d)\n", nodeName().c_str(), dataPtr, dataLen);
}

#pragma mark = IVTConstASTNode =

IVTConstASTNode::IVTConstASTNode(const IVTConstASTNode & other)
:	ConstASTNode(other), m_fields()
{
	m_fields = dynamic_cast<ListASTNode*>(other.m_fields->clone());
}

void IVTConstASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s:\n", nodeName().c_str());
    if (m_fields)
    {
        m_fields->printTree(indent + 1);
    }
}

#pragma mark = AssignmentASTNode =

AssignmentASTNode::AssignmentASTNode(const AssignmentASTNode & other)
:	ASTNode(other), m_ident(), m_value()
{
	m_ident = new std::string(*other.m_ident);
	m_value = dynamic_cast<ConstASTNode*>(other.m_value->clone());
}

void AssignmentASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s(%s)\n", nodeName().c_str(), m_ident->c_str());

	if (m_value) m_value->printTree(indent + 1);
}

#pragma mark = SourceDefASTNode =

SourceDefASTNode::SourceDefASTNode(const SourceDefASTNode & other)
:	ASTNode(other), m_name()
{
	m_name = new std::string(*other.m_name);
}

#pragma mark = PathSourceDefASTNode =

PathSourceDefASTNode::PathSourceDefASTNode(const PathSourceDefASTNode & other)
:	SourceDefASTNode(other), m_path()
{
	m_path = new std::string(*other.m_path);
}

void PathSourceDefASTNode::printTree(int indent) const
{
	SourceDefASTNode::printTree(indent);

	printIndent(indent+1);
	printf("path: %s\n", m_path->c_str());

	printIndent(indent+1);
	printf("attributes:\n");
	if (m_attributes)
	{
		m_attributes->printTree(indent+2);
	}
}

#pragma mark = ExternSourceDefASTNode =

ExternSourceDefASTNode::ExternSourceDefASTNode(const ExternSourceDefASTNode & other)
:	SourceDefASTNode(other), m_expr()
{
	m_expr = dynamic_cast<ExprASTNode*>(other.m_expr->clone());
}

void ExternSourceDefASTNode::printTree(int indent) const
{
	SourceDefASTNode::printTree(indent);

	printIndent(indent+1);
	printf("expr:\n");
	if (m_expr) m_expr->printTree(indent + 2);

	printIndent(indent+1);
	printf("attributes:\n");
	if (m_attributes)
	{
		m_attributes->printTree(indent+2);
	}
}

#pragma mark = SectionContentsASTNode =

SectionContentsASTNode::SectionContentsASTNode(const SectionContentsASTNode & other)
:	ASTNode(other), m_sectionExpr()
{
	m_sectionExpr = dynamic_cast<ExprASTNode*>(other.m_sectionExpr->clone());
}

void SectionContentsASTNode::printTree(int indent) const
{
	ASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("section#:\n");
	if (m_sectionExpr) m_sectionExpr->printTree(indent + 2);
}

#pragma mark = DataSectionContentsASTNode =

DataSectionContentsASTNode::DataSectionContentsASTNode(const DataSectionContentsASTNode & other)
:	SectionContentsASTNode(other), m_contents()
{
	m_contents = dynamic_cast<ASTNode*>(other.m_contents->clone());
}

void DataSectionContentsASTNode::printTree(int indent) const
{
	SectionContentsASTNode::printTree(indent);

	if (m_contents)
	{
		m_contents->printTree(indent + 1);
	}
}

#pragma mark = BootableSectionContentsASTNode =

BootableSectionContentsASTNode::BootableSectionContentsASTNode(const BootableSectionContentsASTNode & other)
:	SectionContentsASTNode(other), m_statements()
{
	m_statements = dynamic_cast<ListASTNode*>(other.m_statements->clone());
}

void BootableSectionContentsASTNode::printTree(int indent) const
{
	SectionContentsASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("statements:\n");
	if (m_statements) m_statements->printTree(indent + 2);
}

#pragma mark = IfStatementASTNode =

//! \warning Be careful; this method could enter an infinite loop if m_nextIf feeds
//!		back onto itself. m_nextIf must be NULL at some point down the next if list.
IfStatementASTNode::IfStatementASTNode(const IfStatementASTNode & other)
:	StatementASTNode(),
	m_conditionExpr(),
	m_ifStatements(),
	m_nextIf(),
	m_elseStatements()
{
	m_conditionExpr = dynamic_cast<ExprASTNode*>(other.m_conditionExpr->clone());
	m_ifStatements = dynamic_cast<ListASTNode*>(other.m_ifStatements->clone());
	m_nextIf = dynamic_cast<IfStatementASTNode*>(other.m_nextIf->clone());
	m_elseStatements = dynamic_cast<ListASTNode*>(other.m_elseStatements->clone());
}

#pragma mark = ModeStatementASTNode =

ModeStatementASTNode::ModeStatementASTNode(const ModeStatementASTNode & other)
:	StatementASTNode(other), m_modeExpr()
{
	m_modeExpr = dynamic_cast<ExprASTNode*>(other.m_modeExpr->clone());
}

void ModeStatementASTNode::printTree(int indent) const
{
	StatementASTNode::printTree(indent);
	printIndent(indent + 1);
	printf("mode:\n");
	if (m_modeExpr) m_modeExpr->printTree(indent + 2);
}

#pragma mark = MessageStatementASTNode =

MessageStatementASTNode::MessageStatementASTNode(const MessageStatementASTNode & other)
:	StatementASTNode(other), m_type(other.m_type), m_message()
{
	m_message = new std::string(*other.m_message);
}

void MessageStatementASTNode::printTree(int indent) const
{
	StatementASTNode::printTree(indent);
	printIndent(indent + 1);
	printf("%s: %s\n", getTypeName(), m_message->c_str());
}

const char * MessageStatementASTNode::getTypeName() const
{
	switch (m_type)
	{
		case kInfo:
			return "info";

		case kWarning:
			return "warning";

		case kError:
			return "error";
	}

	return "unknown";
}

#pragma mark = LoadStatementASTNode =

LoadStatementASTNode::LoadStatementASTNode(const LoadStatementASTNode & other)
:	StatementASTNode(other), m_data(), m_target(), m_isDCDLoad(other.m_isDCDLoad)
{
	m_data = other.m_data->clone();
	m_target = other.m_target->clone();
}

void LoadStatementASTNode::printTree(int indent) const
{
	StatementASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("data:\n");
	if (m_data) m_data->printTree(indent + 2);

	printIndent(indent + 1);
	printf("target:\n");
	if (m_target) m_target->printTree(indent + 2);
}

#pragma mark = CallStatementASTNode =

CallStatementASTNode::CallStatementASTNode(const CallStatementASTNode & other)
:	StatementASTNode(other), m_type(other.m_type), m_target(), m_arg()
{
	m_target = other.m_target->clone();
	m_arg = other.m_arg->clone();
}

void CallStatementASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s(%s)%s\n", nodeName().c_str(), (m_type == kCallType ? "call" : "jump"), (m_isHAB ? "/HAB" : ""));

	printIndent(indent + 1);
	printf("target:\n");
	if (m_target) m_target->printTree(indent + 2);

	printIndent(indent + 1);
	printf("arg:\n");
	if (m_arg) m_arg->printTree(indent + 2);
}

#pragma mark = SourceASTNode =

SourceASTNode::SourceASTNode(const SourceASTNode & other)
:	ASTNode(other), m_name()
{
	m_name = new std::string(*other.m_name);
}

void SourceASTNode::printTree(int indent) const
{
	printIndent(indent);
	printf("%s(%s)\n", nodeName().c_str(), m_name->c_str());
}

#pragma mark = SectionMatchListASTNode =

SectionMatchListASTNode::SectionMatchListASTNode(const SectionMatchListASTNode & other)
:	ASTNode(other), m_sections(), m_source()
{
	if (other.m_sections)
	{
		m_sections = dynamic_cast<ListASTNode *>(other.m_sections->clone());
	}

	if (other.m_source)
	{
		m_source = new std::string(*other.m_source);
	}
}

void SectionMatchListASTNode::printTree(int indent) const
{
	ASTNode::printTree(indent);

	printIndent(indent+1);
	printf("sections:\n");
	if (m_sections)
	{
		m_sections->printTree(indent+2);
	}

	printIndent(indent+1);
	printf("source: ");
	if (m_source)
	{
		printf("%s\n", m_source->c_str());
	}
	else
	{
		printf("\n");
	}
}

#pragma mark = SectionASTNode =

SectionASTNode::SectionASTNode(const SectionASTNode & other)
:	ASTNode(other), m_name(), m_source()
{
	m_action = other.m_action;

	if (other.m_name)
	{
		m_name = new std::string(*other.m_name);
	}

	if (other.m_source)
	{
		m_source = new std::string(*other.m_source);
	}
}

void SectionASTNode::printTree(int indent) const
{
	printIndent(indent);

	const char * actionName;
	switch (m_action)
	{
		case kInclude:
			actionName = "include";
			break;
		case kExclude:
			actionName = "exclude";
			break;
	}

	if (m_source)
	{
		printf("%s(%s:%s:%s)\n", nodeName().c_str(), actionName, m_name->c_str(), m_source->c_str());
	}
	else
	{
		printf("%s(%s:%s)\n", nodeName().c_str(), actionName, m_name->c_str());
	}
}

#pragma mark = SymbolASTNode =

SymbolASTNode::SymbolASTNode(const SymbolASTNode & other)
:	ASTNode(other), m_symbol(), m_source()
{
	m_symbol = new std::string(*other.m_symbol);
	m_source = new std::string(*other.m_source);
}

void SymbolASTNode::printTree(int indent) const
{
	printIndent(indent);

	const char * symbol = NULL;
	if (m_symbol)
	{
		symbol = m_symbol->c_str();
	}

	const char * source = NULL;
	if (m_source)
	{
		source = m_source->c_str();
	}

	printf("%s(", nodeName().c_str());
	if (source)
	{
		printf("%s", source);
	}
	else
	{
		printf(".");
	}
	printf(":");
	if (symbol)
	{
		printf("%s", symbol);
	}
	else
	{
		printf(".");
	}
	printf(")\n");
}

#pragma mark = AddressRangeASTNode =

AddressRangeASTNode::AddressRangeASTNode(const AddressRangeASTNode & other)
:	ASTNode(other), m_begin(), m_end()
{
	m_begin = other.m_begin->clone();
	m_end = other.m_end->clone();
}

void AddressRangeASTNode::printTree(int indent) const
{
	ASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("begin:\n");
	if (m_begin) m_begin->printTree(indent + 2);

	printIndent(indent + 1);
	printf("end:\n");
	if (m_end) m_end->printTree(indent + 2);
}

#pragma mark = FromStatementASTNode =

FromStatementASTNode::FromStatementASTNode(std::string * source, ListASTNode * statements)
:	StatementASTNode(), m_source(source), m_statements(statements)
{
}

FromStatementASTNode::FromStatementASTNode(const FromStatementASTNode & other)
:	StatementASTNode(), m_source(), m_statements()
{
	m_source = new std::string(*other.m_source);
	m_statements = dynamic_cast<ListASTNode*>(other.m_statements->clone());
}

void FromStatementASTNode::printTree(int indent) const
{
	ASTNode::printTree(indent);

	printIndent(indent + 1);
	printf("source: ");
	if (m_source) printf("%s\n", m_source->c_str());

	printIndent(indent + 1);
	printf("statements:\n");
	if (m_statements) m_statements->printTree(indent + 2);
}