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

#include "ConversionController.h"
#include <stdexcept>
#include "EvalContext.h"
#include "ElftosbErrors.h"
#include "GlobMatcher.h"
#include "ExcludesListMatcher.h"
#include "BootImageGenerator.h"
#include "EncoreBootImageGenerator.h"
#include "Logging.h"
#include "OptionDictionary.h"
#include "format_string.h"
#include "SearchPath.h"
#include "DataSourceImager.h"
#include "IVTDataSource.h"
#include <algorithm>

//! Set to 1 to cause the ConversionController to print information about
//! the values that it processes (options, constants, etc.).
#define PRINT_VALUES 1

using namespace elftosb;

// Define the parser function prototype;
extern int yyparse(ElftosbLexer * lexer, CommandFileASTNode ** resultAST);

bool elftosb::g_enableHABSupport = false;

ConversionController::ConversionController()
:	OptionDictionary(),
	m_commandFilePath(),
	m_ast(),
	m_defaultSource(0)
{
	m_context.setSourceFileManager(this);
}

ConversionController::~ConversionController()
{
	// clean up sources
	source_map_t::iterator it = m_sources.begin();
	for (; it != m_sources.end(); ++it)
	{
		if (it->second)
		{
			delete it->second;
		}
	}
}

void ConversionController::setCommandFilePath(const std::string & path)
{
	m_commandFilePath = new std::string(path);
}

//! The paths provided to this method are added to an array and accessed with the
//! "extern(N)" notation in the command file. So the path provided in the third
//! call to addExternalFilePath() will be found with N=2 in the source definition.
void ConversionController::addExternalFilePath(const std::string & path)
{
	m_externPaths.push_back(path);
}

bool ConversionController::hasSourceFile(const std::string & name)
{
	return m_sources.find(name) != m_sources.end();
}

SourceFile * ConversionController::getSourceFile(const std::string & name)
{
	if (!hasSourceFile(name))
	{
		return NULL;
	}
	
	return m_sources[name];
}

SourceFile * ConversionController::getDefaultSourceFile()
{
	return m_defaultSource;
}

//! These steps are executed while running this method:
//!		- The command file is parsed into an abstract syntax tree.
//!		- The list of options is extracted.
//!		- Constant expressions are evaluated.
//!		- The list of source files is extracted and source file objects created.
//!		- Section definitions are extracted.
//!
//! This method does not produce any output. It processes the input files and
//! builds a representation of the output in memory. Use the generateOutput() method
//! to produce a BootImage object after this method returns.
//!
//! \note This method is \e not reentrant. And in fact, the whole class is not designed
//!		to be reentrant.
//!
//! \exception std::runtime_error Any number of problems will cause this exception to
//!		be thrown.
//!
//! \see parseCommandFile()
//! \see processOptions()
//! \see processConstants()
//! \see processSources()
//! \see processSections()
void ConversionController::run()
{
#if PRINT_VALUES
	Log::SetOutputLevel debugLevel(Logger::DEBUG2);
#endif

	parseCommandFile();
	assert(m_ast);
	
	ListASTNode * blocks = m_ast->getBlocks();
	if (!blocks)
	{
		throw std::runtime_error("command file has no blocks");
	}
	
	ListASTNode::iterator it = blocks->begin();
	for (; it != blocks->end(); ++it)
	{
		ASTNode * node = *it;
		
		// Handle an options block.
		OptionsBlockASTNode * options = dynamic_cast<OptionsBlockASTNode *>(node);
		if (options)
		{
			processOptions(options->getOptions());
			continue;
		}
		
		// Handle a constants block.
		ConstantsBlockASTNode * constants = dynamic_cast<ConstantsBlockASTNode *>(node);
		if (constants)
		{
			processConstants(constants->getConstants());
			continue;
		}
		
		// Handle a sources block.
		SourcesBlockASTNode * sources = dynamic_cast<SourcesBlockASTNode *>(node);
		if (sources)
		{
			processSources(sources->getSources());
		}
	}
	
	processSections(m_ast->getSections());
}

//! Opens the command file and runs it through the lexer and parser. The resulting
//! abstract syntax tree is held in the m_ast member variable. After parsing, the
//! command file is closed.
//!
//! \exception std::runtime_error Several problems will cause this exception to be
//!		raised, including an unspecified command file path or an error opening the
//!		file.
void ConversionController::parseCommandFile()
{
	if (!m_commandFilePath)
	{
		throw std::runtime_error("no command file path was provided");
	}
	
	// Search for command file
	std::string actualPath;
	bool found = PathSearcher::getGlobalSearcher().search(*m_commandFilePath, PathSearcher::kFindFile, true, actualPath);
	if (!found)
	{
		throw runtime_error(format_string("unable to find command file %s\n", m_commandFilePath->c_str()));
	}

	// open command file
	std::ifstream commandFile(actualPath.c_str(), ios_base::in | ios_base::binary);
	if (!commandFile.is_open())
	{
		throw std::runtime_error("could not open command file");
	}
	
	try
	{
		// create lexer instance
		ElftosbLexer lexer(commandFile);
//		testLexer(lexer);
		
		CommandFileASTNode * ast = NULL;
		int result = yyparse(&lexer, &ast);
		m_ast = ast;
		
		// check results
		if (result || !m_ast)
		{
			throw std::runtime_error("failed to parse command file");
		}
		
		// dump AST
//		m_ast->printTree(0);
		
		// close command file
		commandFile.close();
	}
	catch (...)
	{
		// close command file
		commandFile.close();
		
		// rethrow exception
		throw;
	}
}

//! Iterates over the option definition AST nodes. elftosb::Value objects are created for
//! each option value and added to the option dictionary.
//!
//! \exception std::runtime_error Various errors will cause this exception to be thrown. These
//!		include AST nodes being an unexpected type or expression not evaluating to integers.
void ConversionController::processOptions(ListASTNode * options)
{
	if (!options)
	{
		return;
	}
	
	ListASTNode::iterator it = options->begin();
	for (; it != options->end(); ++it)
	{
		std::string ident;
		Value * value = convertAssignmentNodeToValue(*it, ident);
		
		// check if this option has already been set
		if (hasOption(ident))
		{
			throw semantic_error(format_string("line %d: option already set", (*it)->getFirstLine()));
		}
		
		// now save the option value in our map
		if (value)
		{
			setOption(ident, value);
		}
	}
}

//! Scans the constant definition AST nodes, evaluates expression nodes by calling their
//! elftosb::ExprASTNode::reduce() method, and updates the evaluation context member so
//! those constant values can be used in other expressions.
//!
//! \exception std::runtime_error Various errors will cause this exception to be thrown. These
//!		include AST nodes being an unexpected type or expression not evaluating to integers.
void ConversionController::processConstants(ListASTNode * constants)
{
	if (!constants)
	{
		return;
	}
	
	ListASTNode::iterator it = constants->begin();
	for (; it != constants->end(); ++it)
	{
		std::string ident;
		Value * value = convertAssignmentNodeToValue(*it, ident);
		
		SizedIntegerValue * intValue = dynamic_cast<SizedIntegerValue*>(value);
		if (!intValue)
		{
			throw semantic_error(format_string("line %d: constant value is an invalid type", (*it)->getFirstLine()));
		}
				
//#if PRINT_VALUES
//		Log::log("constant ");
//		printIntConstExpr(ident, intValue);
//#endif
		
		// record this constant's value in the evaluation context
		m_context.setVariable(ident, intValue->getValue(), intValue->getWordSize());
	}
}

//! \exception std::runtime_error Various errors will cause this exception to be thrown. These
//!		include AST nodes being an unexpected type or expression not evaluating to integers.
//!
//! \todo Handle freeing of dict if an exception occurs.
void ConversionController::processSources(ListASTNode * sources)
{
	if (!sources)
	{
		return;
	}
	
	ListASTNode::iterator it = sources->begin();
	for (; it != sources->end(); ++it)
	{
		SourceDefASTNode * node = dynamic_cast<SourceDefASTNode*>(*it);
		if (!node)
		{
			throw semantic_error(format_string("line %d: source definition node is an unexpected type", node->getFirstLine()));
		}
		
		// get source name and check if it has already been defined
		std::string * name = node->getName();
		if (m_sources.find(*name) != m_sources.end())
		{
			// can't define a source multiple times
			throw semantic_error(format_string("line %d: source already defined", node->getFirstLine()));
		}
		
		// convert attributes into an option dict
		OptionDictionary * dict = new OptionDictionary(this);
		ListASTNode * attrsNode = node->getAttributes();
		if (attrsNode)
		{
			ListASTNode::iterator attrIt = attrsNode->begin();
			for (; attrIt != attrsNode->end(); ++attrIt)
			{
				std::string ident;
				Value * value = convertAssignmentNodeToValue(*attrIt, ident);
				dict->setOption(ident, value);
			}
		}
		
		// figure out which type of source definition this is
		PathSourceDefASTNode * pathNode = dynamic_cast<PathSourceDefASTNode*>(node);
		ExternSourceDefASTNode * externNode = dynamic_cast<ExternSourceDefASTNode*>(node);
		SourceFile * file = NULL;
		
		if (pathNode)
		{
			// explicit path
			std::string * path = pathNode->getPath();
			
#if PRINT_VALUES
			Log::log("source %s => path(%s)\n", name->c_str(), path->c_str());
#endif
			
			try
			{
				file = SourceFile::openFile(*path);
			}
			catch (...)
			{
				// file doesn't exist
				Log::log(Logger::INFO2, "failed to open source file: %s (ignoring for now)\n", path->c_str());
				m_failedSources.push_back(*name);
			}
		}
		else if (externNode)
		{
			// externally provided path
			ExprASTNode * expr = externNode->getSourceNumberExpr()->reduce(m_context);
			IntConstExprASTNode * intConst = dynamic_cast<IntConstExprASTNode*>(expr);
			if (!intConst)
			{
				throw semantic_error(format_string("line %d: expression didn't evaluate to an integer", expr->getFirstLine()));
			}
			
			uint32_t externalFileNumber = static_cast<uint32_t>(intConst->getValue());
			
			// make sure the extern number is valid
			if (externalFileNumber >= 0 && externalFileNumber < m_externPaths.size())
			{
			
#if PRINT_VALUES
			Log::log("source %s => extern(%d=%s)\n", name->c_str(), externalFileNumber, m_externPaths[externalFileNumber].c_str());
#endif
			
				try
				{
					file = SourceFile::openFile(m_externPaths[externalFileNumber]);
				}
				catch (...)
				{
					Log::log(Logger::INFO2, "failed to open source file: %s (ignoring for now)\n", m_externPaths[externalFileNumber].c_str());
					m_failedSources.push_back(*name);
				}
			}
		}
		else
		{
			throw semantic_error(format_string("line %d: unexpected source definition node type", node->getFirstLine()));
		}
		
		if (file)
		{
			// set options
			file->setOptions(dict);
			
			// stick the file object in the source map
			m_sources[*name] = file;
		}
	}
}

void ConversionController::processSections(ListASTNode * sections)
{
	if (!sections)
	{
		Log::log(Logger::WARNING, "warning: no sections were defined in command file");
		return;
	}
	
	ListASTNode::iterator it = sections->begin();
	for (; it != sections->end(); ++it)
	{
		SectionContentsASTNode * node = dynamic_cast<SectionContentsASTNode*>(*it);
		if (!node)
		{
			throw semantic_error(format_string("line %d: section definition is unexpected type", node->getFirstLine()));
		}
		
		// evaluate section number
		ExprASTNode * idExpr = node->getSectionNumberExpr()->reduce(m_context);
		IntConstExprASTNode * idConst = dynamic_cast<IntConstExprASTNode*>(idExpr);
		if (!idConst)
		{
			throw semantic_error(format_string("line %d: section number did not evaluate to an integer", idExpr->getFirstLine()));
		}
		uint32_t sectionID = idConst->getValue();
		
		// Create options context for this section. The options context has the
		// conversion controller as its parent context so it will inherit global options.
		// The context will be set in the section after the section is created below.
		OptionDictionary * optionsDict = new OptionDictionary(this);
		ListASTNode * attrsNode = node->getOptions();
		if (attrsNode)
		{
			ListASTNode::iterator attrIt = attrsNode->begin();
			for (; attrIt != attrsNode->end(); ++attrIt)
			{
				std::string ident;
				Value * value = convertAssignmentNodeToValue(*attrIt, ident);
				optionsDict->setOption(ident, value);
			}
		}
		
		// Now create the actual section object based on its type.
		OutputSection * outputSection = NULL;
		BootableSectionContentsASTNode * bootableSection;
		DataSectionContentsASTNode * dataSection;
		if (bootableSection = dynamic_cast<BootableSectionContentsASTNode*>(node))
		{		
			// process statements into a sequence of operations
			ListASTNode * statements = bootableSection->getStatements();
			OperationSequence * sequence = convertStatementList(statements);

#if 0
			Log::log("section ID = %d\n", sectionID);
			statements->printTree(0);
			
			Log::log("sequence has %d operations\n", sequence->getCount());
			OperationSequence::iterator_t it = sequence->begin();
			for (; it != sequence->end(); ++it)
			{
				Operation * op = *it;
				Log::log("op = %p\n", op);
			}
#endif
			
			// create the output section and add it to the list
			OperationSequenceSection * opSection = new OperationSequenceSection(sectionID);
			opSection->setOptions(optionsDict);
			opSection->getSequence() += sequence;
			outputSection = opSection;
		}
		else if (dataSection = dynamic_cast<DataSectionContentsASTNode*>(node))
		{
			outputSection = convertDataSection(dataSection, sectionID, optionsDict);
		}
		else
		{
			throw semantic_error(format_string("line %d: unexpected section contents type", node->getFirstLine()));
		}
		
		if (outputSection)
		{
			m_outputSections.push_back(outputSection);
		}
	}
}

//! Creates an instance of BinaryDataSection from the AST node passed in the
//! \a dataSection parameter. The section-specific options for this node will
//! have already been converted into an OptionDictionary, the one passed in
//! the \a optionsDict parameter.
//!
//! The \a dataSection node will have as its contents one of the AST node
//! classes that represents a source of data. The member function
//! createSourceFromNode() is used to convert this AST node into an
//! instance of a DataSource subclass. Then the method imageDataSource()
//! converts the segments of the DataSource into a raw binary buffer that
//! becomes the contents of the BinaryDataSection this is returned.
//!
//! \param dataSection The AST node for the data section.
//! \param sectionID Unique tag value the user has assigned to this section.
//! \param optionsDict Options that apply only to this section. This dictionary
//!		will be assigned as the options dictionary for the resulting section
//!		object. Its parent is the conversion controller itself.
//! \return An instance of BinaryDataSection. Its contents are a contiguous
//!		binary representation of the contents of \a dataSection.
OutputSection * ConversionController::convertDataSection(DataSectionContentsASTNode * dataSection, uint32_t sectionID, OptionDictionary * optionsDict)
{
	// Create a data source from the section contents AST node.
	ASTNode * contents = dataSection->getContents();
	DataSource * dataSource = createSourceFromNode(contents);
	
	// Convert the data source to a raw buffer.
	DataSourceImager imager;
	imager.addDataSource(dataSource);
	
	// Then make a data section from the buffer.
	BinaryDataSection * resultSection = new BinaryDataSection(sectionID);
	resultSection->setOptions(optionsDict);
	if (imager.getLength())
	{
		resultSection->setData(imager.getData(), imager.getLength());
	}
	
	return resultSection;
}

//! @param node The AST node instance for the assignment expression.
//! @param[out] ident Upon exit this string will be set the the left hand side of the
//!		assignment expression, the identifier name.
//!
//! @return An object that is a subclass of Value is returned. The specific subclass will
//!		depend on the type of the right hand side of the assignment expression whose AST
//!		node was provided in the @a node argument.
//!
//! @exception semantic_error Thrown for any error where an AST node is an unexpected type.
//!		This may be the @a node argument itself, if it is not an AssignmentASTNode. Or it
//!		may be an unexpected type for either the right or left hand side of the assignment.
//!		The message for the exception will contain a description of the error.
Value * ConversionController::convertAssignmentNodeToValue(ASTNode * node, std::string & ident)
{
	Value * resultValue = NULL;
	
	// each item of the options list should be an assignment node
	AssignmentASTNode * assignmentNode = dynamic_cast<AssignmentASTNode*>(node);
	if (!node)
	{
		throw semantic_error(format_string("line %d: node is wrong type", assignmentNode->getFirstLine()));
	}
	
	// save the left hand side (the identifier) into ident
	ident = *assignmentNode->getIdent();
	
	// get the right hand side and convert it to a Value instance
	ASTNode * valueNode = assignmentNode->getValue();
	StringConstASTNode * str;
	ExprASTNode * expr;
	if (str = dynamic_cast<StringConstASTNode*>(valueNode))
	{
		// the option value is a string constant
		resultValue = new StringValue(str->getString());

//#if PRINT_VALUES
//		Log::log("option %s => \'%s\'\n", ident->c_str(), str->getString()->c_str());
//#endif
	}
	else if (expr = dynamic_cast<ExprASTNode*>(valueNode))
	{
		ExprASTNode * reducedExpr = expr->reduce(m_context);
		IntConstExprASTNode * intConst = dynamic_cast<IntConstExprASTNode*>(reducedExpr);
		if (!intConst)
		{
			throw semantic_error(format_string("line %d: expression didn't evaluate to an integer", expr->getFirstLine()));
		}
		
//#if PRINT_VALUES
//		Log::log("option ");
//		printIntConstExpr(*ident, intConst);
//#endif
		
		resultValue = new SizedIntegerValue(intConst->getValue(), intConst->getSize());
	}
	else
	{
		throw semantic_error(format_string("line %d: right hand side node is an unexpected type", valueNode->getFirstLine()));
	}
	
	return resultValue;
}

//! Builds up a sequence of Operation objects that are equivalent to the
//! statements in the \a statements list. The statement list is simply iterated
//! over and the results of convertOneStatement() are used to build up
//! the final result sequence.
//!
//! \see convertOneStatement()
OperationSequence * ConversionController::convertStatementList(ListASTNode * statements)
{
	OperationSequence * resultSequence = new OperationSequence();
	ListASTNode::iterator it = statements->begin();
	for (; it != statements->end(); ++it)
	{
		StatementASTNode * statement = dynamic_cast<StatementASTNode*>(*it);
		if (!statement)
		{
			throw semantic_error(format_string("line %d: statement node is unexpected type", (*it)->getFirstLine()));
		}
		
		// convert this statement and append it to the result
		OperationSequence * sequence = convertOneStatement(statement);
		if (sequence)
		{
			*resultSequence += sequence;
		}
	}
	
	return resultSequence;
}

//! Uses C++ RTTI to identify the particular subclass of StatementASTNode that
//! the \a statement argument matches. Then the appropriate conversion method
//! is called.
//!
//! \see convertLoadStatement()
//! \see convertCallStatement()
//! \see convertFromStatement()
OperationSequence * ConversionController::convertOneStatement(StatementASTNode * statement)
{
	// see if it's a load statement
	LoadStatementASTNode * load = dynamic_cast<LoadStatementASTNode*>(statement);
	if (load)
	{
		return convertLoadStatement(load);
	}
	
	// see if it's a call statement
	CallStatementASTNode * call = dynamic_cast<CallStatementASTNode*>(statement);
	if (call)
	{
		return convertCallStatement(call);
	}
	
	// see if it's a from statement
	FromStatementASTNode * from = dynamic_cast<FromStatementASTNode*>(statement);
	if (from)
	{
		return convertFromStatement(from);
	}
	
	// see if it's a mode statement
	ModeStatementASTNode * mode = dynamic_cast<ModeStatementASTNode*>(statement);
	if (mode)
	{
		return convertModeStatement(mode);
	}
	
	// see if it's an if statement
	IfStatementASTNode * ifStmt = dynamic_cast<IfStatementASTNode*>(statement);
	if (ifStmt)
	{
		return convertIfStatement(ifStmt);
	}
	
	// see if it's a message statement
	MessageStatementASTNode * messageStmt = dynamic_cast<MessageStatementASTNode*>(statement);
	if (messageStmt)
	{
		// Message statements don't produce operation sequences.
		handleMessageStatement(messageStmt);
		return NULL;
	}
	
	// didn't match any of the expected statement types
	throw semantic_error(format_string("line %d: unexpected statement type", statement->getFirstLine()));
	return NULL;
}

//! Possible load data node types:
//! - StringConstASTNode
//! - ExprASTNode
//! - SourceASTNode
//! - SectionMatchListASTNode
//!
//! Possible load target node types:
//! - SymbolASTNode
//! - NaturalLocationASTNode
//! - AddressRangeASTNode
OperationSequence * ConversionController::convertLoadStatement(LoadStatementASTNode * statement)
{
	LoadOperation * op = NULL;
	
	try
	{
		// build load operation from source and target
		op = new LoadOperation();
		op->setSource(createSourceFromNode(statement->getData()));
		op->setTarget(createTargetFromNode(statement->getTarget()));
		op->setDCDLoad(statement->isDCDLoad());
		
		return new OperationSequence(op);
	}
	catch (...)
	{
		if (op)
		{
			delete op;
		}
		throw;
	}
}

//! Possible call target node types:
//! - SymbolASTNode
//! - ExprASTNode
//!
//! Possible call argument node types:
//! - ExprASTNode
//! - NULL
OperationSequence * ConversionController::convertCallStatement(CallStatementASTNode * statement)
{
	ExecuteOperation * op = NULL;
	
	try
	{
		// create operation from AST nodes
		op = new ExecuteOperation();
		
		bool isHAB = statement->isHAB();
		
		op->setTarget(createTargetFromNode(statement->getTarget()));
		
		// set argument value, which defaults to 0 if no expression was provided
		uint32_t arg = 0;
		ASTNode * argNode = statement->getArgument();
		if (argNode)
		{
			ExprASTNode * argExprNode = dynamic_cast<ExprASTNode*>(argNode);
			if (!argExprNode)
			{
				throw semantic_error(format_string("line %d: call argument is unexpected type", argNode->getFirstLine()));
			}
			argExprNode = argExprNode->reduce(m_context);
			IntConstExprASTNode * intNode = dynamic_cast<IntConstExprASTNode*>(argExprNode);
			if (!intNode)
			{
				throw semantic_error(format_string("line %d: call argument did not evaluate to an integer", argExprNode->getFirstLine()));
			}
			
			arg = intNode->getValue();
		}
		op->setArgument(arg);
		
		// set call type
		switch (statement->getCallType())
		{
			case CallStatementASTNode::kCallType:
				op->setExecuteType(ExecuteOperation::kCall);
				break;
			case CallStatementASTNode::kJumpType:
				op->setExecuteType(ExecuteOperation::kJump);
				break;
		}
		
		// Set the HAB mode flag.
		op->setIsHAB(isHAB);
		
		return new OperationSequence(op);
	}
	catch (...)
	{
		// delete op and rethrow exception
		if (op)
		{
			delete op;
		}
		throw;
	}
}

//! First this method sets the default source to the source identified in
//! the from statement. Then the statements within the from block are
//! processed recursively by calling convertStatementList(). The resulting
//! operation sequence is returned.
OperationSequence * ConversionController::convertFromStatement(FromStatementASTNode * statement)
{
	if (m_defaultSource)
	{
		throw semantic_error(format_string("line %d: from statements cannot be nested", statement->getFirstLine()));
	}
	
	// look up source file instance
	std::string * fromSourceName = statement->getSourceName();
	assert(fromSourceName);
	
	// make sure it's a valid source name
	source_map_t::iterator sourceIt = m_sources.find(*fromSourceName);
	if (sourceIt == m_sources.end())
	{
		throw semantic_error(format_string("line %d: bad source name", statement->getFirstLine()));
	}
	
	// set default source
	m_defaultSource = sourceIt->second;
	assert(m_defaultSource);
	
	// get statements inside the from block
	ListASTNode * fromStatements = statement->getStatements();
	assert(fromStatements);
	
	// produce resulting operation sequence
	OperationSequence * result = convertStatementList(fromStatements);
	
	// restore default source to NULL
	m_defaultSource = NULL;
	
	return result;
}

//! Evaluates the expression to get the new boot mode value. Then creates a
//! BootModeOperation object and returns an OperationSequence containing it.
//!
//! \exception elftosb::semantic_error Thrown if a semantic problem is found with
//!		the boot mode expression.
OperationSequence * ConversionController::convertModeStatement(ModeStatementASTNode * statement)
{
	BootModeOperation * op = NULL;
	
	try
	{
		op = new BootModeOperation();
		
		// evaluate the boot mode expression
		ExprASTNode * modeExprNode = statement->getModeExpr();
		if (!modeExprNode)
		{
			throw semantic_error(format_string("line %d: mode statement has invalid boot mode expression", statement->getFirstLine()));
		}
		modeExprNode = modeExprNode->reduce(m_context);
		IntConstExprASTNode * intNode = dynamic_cast<IntConstExprASTNode*>(modeExprNode);
		if (!intNode)
		{
			throw semantic_error(format_string("line %d: boot mode did not evaluate to an integer", statement->getFirstLine()));
		}
		
		op->setBootMode(intNode->getValue());
		
		return new OperationSequence(op);
	}
	catch (...)
	{
		if (op)
		{
			delete op;
		}
		
		// rethrow exception
		throw;
	}
}

//! Else branches, including else-if, are handled recursively, so there is a limit
//! on the number of them based on the stack size.
//!
//! \return Returns the operation sequence for the branch of the if statement that
//!		evaluated to true. If the statement did not have an else branch and the
//!		condition expression evaluated to false, then NULL will be returned.
//!
//! \todo Handle else branches without recursion.
OperationSequence * ConversionController::convertIfStatement(IfStatementASTNode * statement)
{
	// Get the if's conditional expression.
	ExprASTNode * conditionalExpr = statement->getConditionExpr();
	if (!conditionalExpr)
	{
		throw semantic_error(format_string("line %d: missing or invalid conditional expression", statement->getFirstLine()));
	}
	
	// Reduce the conditional to a single integer.
	conditionalExpr = conditionalExpr->reduce(m_context);
	IntConstExprASTNode * intNode = dynamic_cast<IntConstExprASTNode*>(conditionalExpr);
	if (!intNode)
	{
		throw semantic_error(format_string("line %d: if statement conditional expression did not evaluate to an integer", statement->getFirstLine()));
	}
	
	// Decide which statements to further process by the conditional's boolean value.
	if (intNode->getValue() && statement->getIfStatements())
	{
		return convertStatementList(statement->getIfStatements());
	}
	else if (statement->getElseStatements())
	{
		return convertStatementList(statement->getElseStatements());
	}
	else
	{
		// No else branch and the conditional was false, so there are no operations to return.
		return NULL;
	}
}

//! Message statements are executed immediately, by this method. They are
//! not converted into an abstract operation. All messages are passed through
//! substituteVariables() before being output.
//!
//! \param statement The message statement AST node object.
void ConversionController::handleMessageStatement(MessageStatementASTNode * statement)
{
	string * message = statement->getMessage();
	if (!message)
	{
		throw runtime_error("message statement had no message");
	}
	
	smart_ptr<string> finalMessage = substituteVariables(message);
	
	switch (statement->getType())
	{
		case MessageStatementASTNode::kInfo:
			Log::log(Logger::INFO, "%s\n", finalMessage->c_str());
			break;
		
		case MessageStatementASTNode::kWarning:
			Log::log(Logger::WARNING, "warning: %s\n", finalMessage->c_str());
			break;
		
		case MessageStatementASTNode::kError:
			throw runtime_error(*finalMessage);
			break;
	}
}

//! Performs shell-like variable substitution on the string passed into it.
//! Both sources and constants can be substituted. Sources will be replaced
//! with their path and constants with their integer value. The syntax allows
//! for some simple formatting for constants.
//!
//! The syntax is mostly standard. A substitution begins with a dollar-sign
//! and is followed by the source or constant name in parentheses. For instance,
//! "$(mysource)" or "$(myconst)". The parentheses are always required.
//!
//! Constant names can be prefixed by a single formatting character followed
//! by a colon. The only formatting characters currently supported are 'd' for
//! decimal and 'x' for hex. For example, "$(x:myconst)" will be replaced with
//! the value of the constant named "myconst" formatted as hexadecimal. The
//! default is decimal, so the 'd' formatting character isn't really ever
//! needed.
//!
//! \param message The string to perform substitution on.
//! \return Returns a newly allocated std::string object that has all
//!		substitutions replaced with the associated value. The caller is
//!		responsible for freeing the string object using the delete operator.
std::string * ConversionController::substituteVariables(const std::string * message)
{
	string * result = new string();
	int i;
	int state = 0;
	string name;
	
	for (i=0; i < message->size(); ++i)
	{
		char c = (*message)[i];
		switch (state)
		{
			case 0:
				if (c == '$')
				{
					state = 1;
				}
				else
				{
					(*result) += c;
				}
				break;
			
			case 1:
				if (c == '(')
				{
					state = 2;
				}
				else
				{
					// Wasn't a variable substitution, so revert to initial state after
					// inserting the original characters.
					(*result) += '$';
					(*result) += c;
					state = 0;
				}
				break;
			
			case 2:
				if (c == ')')
				{
					// Try the name as a source name first.
					if (m_sources.find(name) != m_sources.end())
					{
						(*result) += m_sources[name]->getPath();
					}
					// Otherwise try it as a variable.
					else
					{
						// Select format.
						const char * fmt = "%d";
						if (name[1] == ':' && (name[0] == 'd' || name[0] == 'x'))
						{
							if (name[0] == 'x')
							{
								fmt = "0x%x";
							}
							
							// Delete the format characters.
							name.erase(0, 2);
						}
						
						// Now insert the formatted variable if it exists.
						if (m_context.isVariableDefined(name))
						{
							(*result) += format_string(fmt, m_context.getVariableValue(name));
						}
					}
					
					// Switch back to initial state and clear name.
					state = 0;
					name.clear();
				}
				else
				{
					// Just keep building up the variable name.
					name += c;
				}
				break;
		}
	}
	
	return result;
}

//!
//! \param generator The generator to use.
BootImage * ConversionController::generateOutput(BootImageGenerator * generator)
{
	// set the generator's option context
	generator->setOptionContext(this);
	
	// add output sections to the generator in sequence
	section_vector_t::iterator it = m_outputSections.begin();
	for (; it != m_outputSections.end(); ++it)
	{
		generator->addOutputSection(*it);
	}
	
	// and produce the output
	BootImage * image = generator->generate();
//	Log::log("boot image = %p\n", image);
	return image;
}

//! Takes an AST node that is one of the following subclasses and creates the corresponding
//! type of DataSource object from it.
//! - StringConstASTNode
//! - ExprASTNode
//! - SourceASTNode
//! - SectionASTNode
//! - SectionMatchListASTNode
//! - BlobConstASTNode
//! - IVTConstASTNode
//!
//! \exception elftosb::semantic_error Thrown if a semantic problem is found with
//!		the data node.
//! \exception std::runtime_error Thrown if an error occurs that shouldn't be possible
//!		based on the grammar.
DataSource * ConversionController::createSourceFromNode(ASTNode * dataNode)
{
	assert(dataNode);
	
	DataSource * source = NULL;
	StringConstASTNode * stringNode;
	BlobConstASTNode * blobNode;
	ExprASTNode * exprNode;
	SourceASTNode * sourceNode;
	SectionASTNode * sectionNode;
	SectionMatchListASTNode * matchListNode;
    IVTConstASTNode * ivtNode;
	
	if (stringNode = dynamic_cast<StringConstASTNode*>(dataNode))
	{
		// create a data source with the string contents
		std::string * stringData = stringNode->getString();
		const uint8_t * stringContents = reinterpret_cast<const uint8_t *>(stringData->c_str());
		source = new UnmappedDataSource(stringContents, static_cast<unsigned>(stringData->size()));
	}
	else if (blobNode = dynamic_cast<BlobConstASTNode*>(dataNode))
	{
		// create a data source with the raw binary data
		Blob * blob = blobNode->getBlob();
		source = new UnmappedDataSource(blob->getData(), blob->getLength());
	}
	else if (exprNode = dynamic_cast<ExprASTNode*>(dataNode))
	{
		// reduce the expression first
		exprNode = exprNode->reduce(m_context);
		IntConstExprASTNode * intNode = dynamic_cast<IntConstExprASTNode*>(exprNode);
		if (!intNode)
		{
			throw semantic_error("load pattern expression did not evaluate to an integer");
		}
		
		SizedIntegerValue intValue(intNode->getValue(), intNode->getSize());
		source = new PatternSource(intValue);
	}
	else if (sourceNode = dynamic_cast<SourceASTNode*>(dataNode))
	{
		// load the entire source contents
		SourceFile * sourceFile = getSourceFromName(sourceNode->getSourceName(), sourceNode->getFirstLine());
		source = sourceFile->createDataSource();
	}
	else if (sectionNode = dynamic_cast<SectionASTNode*>(dataNode))
	{
		// load some subset of the source
		SourceFile * sourceFile = getSourceFromName(sectionNode->getSourceName(), sectionNode->getFirstLine());
		if (!sourceFile->supportsNamedSections())
		{
			throw semantic_error(format_string("line %d: source does not support sections", sectionNode->getFirstLine()));
		}
		
		// create data source from the section name
		std::string * sectionName = sectionNode->getSectionName();
		GlobMatcher globber(*sectionName);
		source = sourceFile->createDataSource(globber);
		if (!source)
		{
			throw semantic_error(format_string("line %d: no sections match the pattern", sectionNode->getFirstLine()));
		}
	}
	else if (matchListNode = dynamic_cast<SectionMatchListASTNode*>(dataNode))
	{
		SourceFile * sourceFile = getSourceFromName(matchListNode->getSourceName(), matchListNode->getFirstLine());
		if (!sourceFile->supportsNamedSections())
		{
			throw semantic_error(format_string("line %d: source type does not support sections", matchListNode->getFirstLine()));
		}
		
		// create string matcher
		ExcludesListMatcher matcher;
		
		// add each pattern to the matcher
		ListASTNode * matchList = matchListNode->getSections();
		ListASTNode::iterator it = matchList->begin();
		for (; it != matchList->end(); ++it)
		{
			ASTNode * node = *it;
			sectionNode = dynamic_cast<SectionASTNode*>(node);
			if (!sectionNode)
			{
				throw std::runtime_error(format_string("line %d: unexpected node type in section pattern list", (*it)->getFirstLine()));
			}
			bool isInclude = sectionNode->getAction() == SectionASTNode::kInclude;
			matcher.addPattern(isInclude, *(sectionNode->getSectionName()));
		}
		
		// create data source from the section match list
		source = sourceFile->createDataSource(matcher);
		if (!source)
		{
			throw semantic_error(format_string("line %d: no sections match the section pattern list", matchListNode->getFirstLine()));
		}
	}
    else if (ivtNode = dynamic_cast<IVTConstASTNode*>(dataNode))
    {
        source = createIVTDataSource(ivtNode);
    }
	else
	{
		throw semantic_error(format_string("line %d: unexpected load data node type", dataNode->getFirstLine()));
	}
	
	return source;
}

DataSource * ConversionController::createIVTDataSource(IVTConstASTNode * ivtNode)
{
    IVTDataSource * source = new IVTDataSource;
    
    // Iterate over the assignment statements in the IVT definition.
    ListASTNode * fieldList = ivtNode->getFieldAssignments();
    
    if (fieldList)
    {
        ListASTNode::iterator it = fieldList->begin();
        for (; it != fieldList->end(); ++it)
        {
            AssignmentASTNode * assignmentNode = dynamic_cast<AssignmentASTNode*>(*it);
            if (!assignmentNode)
            {
                throw std::runtime_error(format_string("line %d: unexpected node type in IVT definition", (*it)->getFirstLine()));
            }
            
            // Get the IVT field name.
            std::string * fieldName = assignmentNode->getIdent();
            
            // Reduce the field expression and get the integer result.
            ASTNode * valueNode = assignmentNode->getValue();
            ExprASTNode * valueExpr = dynamic_cast<ExprASTNode*>(valueNode);
            if (!valueExpr)
            {
                throw semantic_error("IVT field must have a valid expression");
            }
            IntConstExprASTNode * valueIntExpr = dynamic_cast<IntConstExprASTNode*>(valueExpr->reduce(m_context));
            if (!valueIntExpr)
            {
                throw semantic_error(format_string("line %d: IVT field '%s' does not evaluate to an integer", valueNode->getFirstLine(), fieldName->c_str()));
            }
            uint32_t value = static_cast<uint32_t>(valueIntExpr->getValue());
            
            // Set the field in the IVT data source.
            if (!source->setFieldByName(*fieldName, value))
            {
                throw semantic_error(format_string("line %d: unknown IVT field '%s'", assignmentNode->getFirstLine(), fieldName->c_str()));
            }
        }
    }
    
    return source;
}

//! Takes an AST node subclass and returns an appropriate DataTarget object that contains
//! the same information. Supported AST node types are:
//! - SymbolASTNode
//! - NaturalLocationASTNode
//! - AddressRangeASTNode
//!
//! \exception elftosb::semantic_error Thrown if a semantic problem is found with
//!		the target node.
DataTarget * ConversionController::createTargetFromNode(ASTNode * targetNode)
{
	assert(targetNode);
	
	DataTarget * target = NULL;
	SymbolASTNode * symbolNode;
	NaturalLocationASTNode * naturalNode;
	AddressRangeASTNode * addressNode;
	
	if (symbolNode = dynamic_cast<SymbolASTNode*>(targetNode))
	{
		SourceFile * sourceFile = getSourceFromName(symbolNode->getSource(), symbolNode->getFirstLine());
		std::string * symbolName = symbolNode->getSymbolName();
		
		// symbol name is optional
		if (symbolName)
		{
			if (!sourceFile->supportsNamedSymbols())
			{
				throw std::runtime_error(format_string("line %d: source does not support symbols", symbolNode->getFirstLine()));
			}
			
			target = sourceFile->createDataTargetForSymbol(*symbolName);
			if (!target)
			{
				throw std::runtime_error(format_string("line %d: source does not have a symbol with that name", symbolNode->getFirstLine()));
			}
		}
		else
		{
			// no symbol name was specified so use entry point
			target = sourceFile->createDataTargetForEntryPoint();
			if (!target)
			{
				throw std::runtime_error(format_string("line %d: source does not have an entry point", symbolNode->getFirstLine()));
			}
		}
	}
	else if (naturalNode = dynamic_cast<NaturalLocationASTNode*>(targetNode))
	{
		// the target is the source's natural location
		target = new NaturalDataTarget();
	}
	else if (addressNode = dynamic_cast<AddressRangeASTNode*>(targetNode))
	{
		// evaluate begin address
		ExprASTNode * beginExpr = dynamic_cast<ExprASTNode*>(addressNode->getBegin());
		if (!beginExpr)
		{
			throw semantic_error("address range must always have a beginning expression");
		}
		IntConstExprASTNode * beginIntExpr = dynamic_cast<IntConstExprASTNode*>(beginExpr->reduce(m_context));
		if (!beginIntExpr)
		{
			throw semantic_error("address range begin did not evaluate to an integer");
		}
		uint32_t beginAddress = static_cast<uint32_t>(beginIntExpr->getValue());
		
		// evaluate end address
		ExprASTNode * endExpr = dynamic_cast<ExprASTNode*>(addressNode->getEnd());
		uint32_t endAddress = 0;
		bool hasEndAddress = false;
		if (endExpr)
		{
			IntConstExprASTNode * endIntExpr = dynamic_cast<IntConstExprASTNode*>(endExpr->reduce(m_context));
			if (!endIntExpr)
			{
				throw semantic_error("address range end did not evaluate to an integer");
			}
			endAddress = static_cast<uint32_t>(endIntExpr->getValue());
			hasEndAddress = true;
		}
		
		// create target
		if (hasEndAddress)
		{
			target = new ConstantDataTarget(beginAddress, endAddress);
		}
		else
		{
			target = new ConstantDataTarget(beginAddress);
		}
	}
	else
	{
		throw semantic_error("unexpected load target node type");
	}
	
	return target;
}

//! \param sourceName Pointer to string containing the name of the source to look up.
//!		May be NULL, in which case the default source is used.
//! \param line The line number on which the source name was located.
//!
//! \result A source file object that was previously created in the processSources()
//!		stage.
//!
//! \exception std::runtime_error Thrown if the source name is invalid, or if it
//!		was NULL and there is no default source (i.e., we're not inside a from
//!		statement).
SourceFile * ConversionController::getSourceFromName(std::string * sourceName, int line)
{
	SourceFile * sourceFile = NULL;
	if (sourceName)
	{
		// look up source in map
		source_map_t::iterator it = m_sources.find(*sourceName);
		if (it == m_sources.end())
		{
			source_name_vector_t::const_iterator findIt = std::find<source_name_vector_t::const_iterator, std::string>(m_failedSources.begin(), m_failedSources.end(), *sourceName);
			if (findIt != m_failedSources.end())
			{
				throw semantic_error(format_string("line %d: error opening source '%s'", line, sourceName->c_str()));
			}
			else
			{
				throw semantic_error(format_string("line %d: invalid source name '%s'", line, sourceName->c_str()));
			}
		}
		sourceFile = it->second;
	}
	else
	{
		// no name provided - use default source
		sourceFile = m_defaultSource;
		if (!sourceFile)
		{
			throw semantic_error(format_string("line %d: source required but no default source is available", line));
		}
	}
	
	// open the file if it hasn't already been
	if (!sourceFile->isOpen())
	{
		sourceFile->open();
	}
	return sourceFile;
}

//! Exercises the lexer by printing out the value of every token produced by the
//! lexer. It is assumed that the lexer object has already be configured to read
//! from some input file. The method will return when the lexer has exhausted all
//! tokens, or an error occurs.
void ConversionController::testLexer(ElftosbLexer & lexer)
{
	// test lexer
	while (1)
	{
		YYSTYPE value;
		int lexresult = lexer.yylex();
		if (lexresult == 0)
			break;
		lexer.getSymbolValue(&value);
		Log::log("%d -> int:%d, ast:%p", lexresult, value.m_int, value.m_str, value.m_ast);
		if (lexresult == TOK_IDENT || lexresult == TOK_SOURCE_NAME || lexresult == TOK_STRING_LITERAL)
		{
			if (value.m_str)
			{
				Log::log(", str:%s\n", value.m_str->c_str());
			}
			else
			{
				Log::log("str:NULL\n");
			}
		}
		else
		{
			Log::log("\n");
		}
	}
}

//! Prints out the value of an integer constant expression AST node. Also prints
//! the name of the identifier associated with that node, as well as the integer
//! size.
void ConversionController::printIntConstExpr(const std::string & ident, IntConstExprASTNode * expr)
{
	// print constant value
	char sizeChar;
	switch (expr->getSize())
	{
		case kWordSize:
			sizeChar = 'w';
			break;
		case kHalfWordSize:
			sizeChar = 'h';
			break;
		case kByteSize:
			sizeChar = 'b';
			break;
	}
	Log::log("%s => %d:%c\n", ident.c_str(), expr->getValue(), sizeChar);
}