/*
* 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"

namespace elftosb
{

/*!
* \brief Manages the entire elftosb file conversion process.
*
* Instances of this class are intended to be used only once. There is no
* way to reset an instance once it has started or completed a conversion.
* Thus the run() method is not reentrant. State information is stored in
* the object during the conversion process.
*
* Two things need to be done before the conversion can be started. The
* command file path has to be set with the setCommandFilePath() method,
* and the paths of any externally provided (i.e., from the command line)
* files need to be added with addExternalFilePath(). Once these tasks
* are completed, the run() method can be called to parse and execute the
* command file. After run() returns, pass an instance of
* BootImageGenerator to the generateOutput() method in order to get
* an instance of BootImage that can be written to the output file.
*/
class ConversionController : public OptionDictionary, public EvalContext::SourceFileManager
{
public:
       //! \brief Default constructor.
       ConversionController();

       //! \brief Destructor.
       virtual ~ConversionController();

       //! \name Paths
       //@{
       //! \brief Specify the command file that controls the conversion process.
       void setCommandFilePath(const std::string & path);

       //! \brief Specify the path of a file provided by the user from outside the command file.
       void addExternalFilePath(const std::string & path);
       //@}

       //! \name Conversion
       //@{
       //! \brief Process input files.
       void run();

       //! \brief Uses a BootImageGenerator object to create the final output boot image.
       BootImage * generateOutput(BootImageGenerator * generator);
       //@}

       //! \name SourceFileManager interface
       //@{
       //! \brief Returns true if a source file with the name \a name exists.
       virtual bool hasSourceFile(const std::string & name);

       //! \brief Gets the requested source file.
       virtual SourceFile * getSourceFile(const std::string & name);

       //! \brief Returns the default source file, or NULL if none is set.
       virtual SourceFile * getDefaultSourceFile();
       //@}

       //! \brief Returns a reference to the context used for expression evaluation.
       inline EvalContext & getEvalContext() { return m_context; }

protected:
       //! \name AST processing
       //@{
       void parseCommandFile();
       void processOptions(ListASTNode * options);
       void processConstants(ListASTNode * constants);
       void processSources(ListASTNode * sources);
       void processSections(ListASTNode * sections);
       OutputSection * convertDataSection(DataSectionContentsASTNode * dataSection, uint32_t sectionID, OptionDictionary * optionsDict);
       //@}

       //! \name Statement conversion
       //@{
       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 * convertIfStatement(IfStatementASTNode * statement);
       void handleMessageStatement(MessageStatementASTNode * statement);
       //@}

       //! \name Utilities
       //@{
       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);
       //@}

       //! \name Debugging
       //@{
       void testLexer(ElftosbLexer & lexer);
       void printIntConstExpr(const std::string & ident, IntConstExprASTNode * expr);
       //@}

protected:
       typedef std::map<std::string, SourceFile*> source_map_t;        //!< Map from source name to object.
       typedef std::vector<std::string> path_vector_t; //!< List of file paths.
       typedef std::vector<OutputSection*> section_vector_t;   //!< List of output sections.
       typedef std::vector<std::string> source_name_vector_t;  //!< List of source names.

       smart_ptr<std::string> m_commandFilePath;       //!< Path to command file.
       smart_ptr<CommandFileASTNode> m_ast;    //!< Root of the abstract syntax tree.
       EvalContext m_context;  //!< Evaluation context for expressions.
       source_map_t m_sources; //!< Map of source names to file objects.
       path_vector_t m_externPaths;    //!< Paths provided on the command line by the user.
       SourceFile * m_defaultSource;   //!< Source to use when one isn't provided.
       section_vector_t m_outputSections;      //!< List of output sections the user wants.
       source_name_vector_t m_failedSources;   //!< List of sources that failed to open successfully.
};

//! \brief Whether to support HAB keywords during parsing.
//!
//! This is a standalone global solely so that the bison-generated parser code can get to it
//! as simply as possible.
extern bool g_enableHABSupport;

}; // namespace elftosb

#endif // _ConversionController_h_