ConversionController.h

/*
 * File:    ConversionController.h
 *
 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
 * See included license file for license details.
 */
#if !defined(_ConversionController_h_)
#define _ConversionController_h_

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include "smart_ptr.h"
#include "ElftosbLexer.h"
#include "ElftosbAST.h"
#include "EvalContext.h"
#include "Value.h"
#include "SourceFile.h"
#include "Operation.h"
#include "DataSource.h"
#include "DataTarget.h"
#include "OutputSection.h"
#include "BootImage.h"
#include "OptionDictionary.h"
#include "BootImageGenerator.h"
#include "Keyblob.h"

namespace elftosb
{
class ConversionController : public OptionDictionary, public EvalContext::SourceFileManager
{
public:
    ConversionController();

    virtual ~ConversionController();


    void setCommandFilePath(const std::string &path);

    void addExternalFilePath(const std::string &path);


    void run();

    BootImage *generateOutput(BootImageGenerator *generator);


    virtual bool hasSourceFile(const std::string &name);

    virtual SourceFile *getSourceFile(const std::string &name);

    virtual SourceFile *getDefaultSourceFile();

    inline EvalContext &getEvalContext() { return m_context; }
protected:

    void parseCommandFile();
    void processOptions(ListASTNode *options);
    void processConstants(ListASTNode *constants);
    void processSources(ListASTNode *sources);
    void processKeyblob(ExprASTNode *idExpr, ListASTNode *entires);
    void processSections(ListASTNode *sections);
    OutputSection *convertDataSection(DataSectionContentsASTNode *dataSection,
                                      uint32_t sectionID,
                                      OptionDictionary *optionsDict);


    OperationSequence *convertStatementList(ListASTNode *statements);
    OperationSequence *convertOneStatement(StatementASTNode *statement);
    OperationSequence *convertLoadStatement(LoadStatementASTNode *statement);
    OperationSequence *convertCallStatement(CallStatementASTNode *statement);
    OperationSequence *convertFromStatement(FromStatementASTNode *statement);
    OperationSequence *convertModeStatement(ModeStatementASTNode *statement);
    OperationSequence *convertResetStatement(ResetStatementASTNode *statement);
    OperationSequence *convertIfStatement(IfStatementASTNode *statement);
    OperationSequence *convertEraseStatement(EraseStatementASTNode *statement);
    OperationSequence *convertMemEnableStatement(MemEnableStatementASTNode *statement);
    OperationSequence *convertKeywrapStatement(KeywrapStatementASTNode *statement);
    OperationSequence *convertEncryptStatement(EncryptStatementASTNode *statement);
    void handleMessageStatement(MessageStatementASTNode *statement);


    Value *convertAssignmentNodeToValue(ASTNode *node, std::string &ident);
    SourceFile *getSourceFromName(std::string *sourceName, int line);
    DataSource *createSourceFromNode(ASTNode *dataNode);
    DataTarget *createTargetFromNode(ASTNode *targetNode);
    std::string *substituteVariables(const std::string *message);
    DataSource *createIVTDataSource(IVTConstASTNode *ivtNode);


    void testLexer(ElftosbLexer &lexer);
    void printIntConstExpr(const std::string &ident, IntConstExprASTNode *expr);

protected:
    typedef std::map<std::string, SourceFile *> source_map_t; 
    typedef std::vector<std::string> path_vector_t;           
    typedef std::vector<OutputSection *> section_vector_t;    
    typedef std::vector<std::string> source_name_vector_t;    
    typedef std::vector<Keyblob *> keyblob_vector_t;          

    smart_ptr<std::string> m_commandFilePath; 
    smart_ptr<CommandFileASTNode> m_ast;      
    EvalContext m_context;                    
    source_map_t m_sources;                   
    path_vector_t m_externPaths;              
    SourceFile *m_defaultSource;              
    section_vector_t m_outputSections;        
    source_name_vector_t m_failedSources;     
    keyblob_vector_t m_keyblobs;              
    Keyblob *m_keywrapKeyblob;                
    Keyblob *m_encryptKeyblob;                
};

extern bool g_enableHABSupport;

}; // namespace elftosb

#endif // _ConversionController_h_