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