Unified codebase for TX28, TX48, TX51, TX53

[karo-tx-uboot.git] / tools / elftosb / elftosb2 / ConversionController.cpp

/*
 * 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);
}