/*
 Copyright 2019 Alain Dargelas
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */

/* 
 * File:   Compiler.cpp
 * Author: alain
 * 
 * Created on March 4, 2017, 5:16 PM
 */
#include "../CommandLine/CommandLineParser.hpp"
#include "../ErrorReporting/ErrorContainer.h"
#include "SymbolTable.h"
#include "CompilationUnit.h"
#include "PreprocessFile.h"
#include "CompilationUnit.h"
#include "CompileSourceFile.h"
#include "Compiler.h"
#include "CheckCompile.h"
#include "antlr4-runtime.h"
#include "../DesignCompile/CompileDesign.h"
#include "AnalyzeFile.h"
#include "../Library/ParseLibraryDef.h"
#include "../Utils/FileUtils.h"
#include "../Package/Precompiled.h"
#include "../Utils/StringUtils.h"
#include "../Utils/Timer.h"
#include "math.h"
using namespace antlr4;

#include "../API/PythonAPI.h"
#include "CheckCompile.h"
#include <mutex>
#include <thread>
#include <vector>
using namespace SURELOG;

Compiler::Compiler (CommandLineParser* commandLineParser, ErrorContainer* errors, SymbolTable* symbolTable) :
m_commandLineParser (commandLineParser), m_errors (errors), m_symbolTable (symbolTable), m_commonCompilationUnit (NULL)
{
  m_design = NULL;
#ifdef USETBB    
  if (getCommandLineParser ()->useTbb () && (getCommandLineParser ()->getNbMaxTreads () > 0))
    tbb::task_scheduler_init init (getCommandLineParser ()->getNbMaxTreads ());
#endif    
}

Compiler::Compiler (const Compiler& orig) { }

Compiler::~Compiler ()
{
  std::map<SymbolId, PreprocessFile::AntlrParserHandler*>::iterator itr;
  for (itr = m_antlrPpMap.begin (); itr != m_antlrPpMap.end (); itr++)
    {
      delete (*itr).second;
    }
  if (m_commonCompilationUnit)
    {
      delete m_commonCompilationUnit;
    }
  cleanup_ ();
}

struct FunctorCompileOneFile
{

  FunctorCompileOneFile (CompileSourceFile* compileSource, CompileSourceFile::Action action) :
  m_compileSourceFile (compileSource), m_action (action) { }

  int operator() () const
  {
    if (m_compileSourceFile->getCommandLineParser ()->pythonListener ()
     || m_compileSourceFile->getCommandLineParser ()->pythonEvalScriptPerFile ())
      {
        PyThreadState* interpState = PythonAPI::initNewInterp ();
        m_compileSourceFile->setPythonInterp (interpState);
      }
    return m_compileSourceFile->compile (m_action);
  }

private:
  CompileSourceFile* m_compileSourceFile;
  CompileSourceFile::Action m_action;
};

bool
Compiler::compileOneFile_ (CompileSourceFile* compiler, CompileSourceFile::Action action)
{
  bool status = compiler->compile (action);
  return status;
}

bool Compiler::isLibraryFile (SymbolId id) {
  if (m_libraryFiles.find(id) == m_libraryFiles.end())
    {
      return false;
    }
  else
    {
      return true;
    }
}

bool
Compiler::ppinit_ ()
{
  if (!m_commandLineParser->fileunit ())
    {
      m_commonCompilationUnit = new CompilationUnit (false);
    }
  
  CompilationUnit* comp_unit = m_commonCompilationUnit;

  // Source files (.v, .sv on the command line)
  std::set<SymbolId> sourceFiles;
  unsigned int size = m_commandLineParser->getSourceFiles ().size ();
  for (unsigned int i = 0; i < size; i++)
    {
      SymbolTable* symbols = m_symbolTable;
      if (m_commandLineParser->fileunit ())
        {
          comp_unit = new CompilationUnit (true);
          m_compilationUnits.push_back (comp_unit);
          symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ());
          m_symbolTables.push_back (symbols);
        }
      ErrorContainer* errors = new ErrorContainer (symbols);
      m_errorContainers.push_back (errors);
      errors->regiterCmdLine (m_commandLineParser);
      
      SymbolId id = m_commandLineParser->getSourceFiles ()[i];
      
      std::string fileName = m_commandLineParser->getSymbolTable ()->getSymbol (id);
      std::string fullPath = FileUtils::getFullPath (fileName);
      SymbolId fullPathId = m_commandLineParser->getSymbolTable ()->registerSymbol(fullPath);
      Library* library  = m_librarySet->getLibrary (fullPathId);
      sourceFiles.insert(fullPathId);
      
      CompileSourceFile* compiler = new CompileSourceFile (m_commandLineParser->getSourceFiles ()[i],
                                                           m_commandLineParser, errors, this, symbols, comp_unit, library);
      m_compilers.push_back (compiler);
    }
  
  // Library files
  std::set<SymbolId> libFiles; 
  // (-v <file>)
  size = m_commandLineParser->getLibraryFiles ().size ();
  for (unsigned int i = 0; i < size; i++)
    {
      SymbolId id = m_commandLineParser->getLibraryFiles ()[i];
       libFiles.insert(id);
    }  
  // (-y <path> +libext+<ext>)
  for (auto path : m_commandLineParser->getLibraryPaths ())
    {
      for (auto ext : m_commandLineParser->getLibraryExtensions ())
        {
          auto files = FileUtils::collectFiles (path, ext, m_commandLineParser->getSymbolTable ());
          for (auto file : files)
            {
              libFiles.insert(file);
            }
        }
    }  
  for (auto id : libFiles)
    {
      SymbolTable* symbols = m_symbolTable;
      if (m_commandLineParser->fileunit ())
        {
          comp_unit = new CompilationUnit (true);
          m_compilationUnits.push_back (comp_unit);
          symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ());
          m_symbolTables.push_back (symbols);
        }
      ErrorContainer* errors = new ErrorContainer (symbols);
      m_errorContainers.push_back (errors);
      errors->regiterCmdLine (m_commandLineParser);
      
      std::string fullPath = FileUtils::getFullPath (m_commandLineParser->getSymbolTable ()->getSymbol (id));
      
      // This line registers the file in the "work" library:
      SymbolId fullPathId = m_commandLineParser->getSymbolTable ()->registerSymbol(fullPath);
      /*Library* library  = */ m_librarySet->getLibrary (fullPathId);
      m_libraryFiles.insert(id);
      m_libraryFiles.insert(fullPathId);
      // No need to register a compiler
      //CompileSourceFile* compiler = new CompileSourceFile (m_commandLineParser->getLibraryFiles ()[i],
      //                                                     m_commandLineParser, errors, this, symbols, comp_unit, library);
      //m_compilers.push_back (compiler);
    }
  
  
  // Libraries (.map)
  for (auto& lib : m_librarySet->getLibraries ())
    {
      for (auto id: lib.getFiles ())
        {
          std::string fileName = lib.getSymbols()->getSymbol (id);  
          if (sourceFiles.find(id) != sourceFiles.end())
            {
              // These files are already included in the command line
              continue;
            }
          
          if (strstr(fileName.c_str(), ".map"))
            {
              // .map files are not parsed with the regular parser
              continue;
            }
          SymbolTable* symbols = m_symbolTable;
          if (m_commandLineParser->fileunit ())
            {
              comp_unit = new CompilationUnit (true);
              m_compilationUnits.push_back (comp_unit);
              symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ());
              m_symbolTables.push_back (symbols);
            }
          ErrorContainer* errors = new ErrorContainer (symbols);
          m_errorContainers.push_back (errors);
          errors->regiterCmdLine (m_commandLineParser);

          CompileSourceFile* compiler = new CompileSourceFile (id,
                                                               m_commandLineParser, errors, this, symbols, comp_unit, &lib);
          m_compilers.push_back (compiler);
        }
    }
  
  
  return true;
}

bool
Compiler::parseinit_ ()
{
  Precompiled* prec = Precompiled::getSingleton ();
  // Single out the large files.
  // Small files are going to be scheduled in multiple threads based on size.
  // Large files are going to be compiled in a different batch in multithread

  if (!m_commandLineParser->fileunit ())
    {
      unsigned int size = m_symbolTables.size ();
      for (unsigned int i = 0; i < size; i++)
        {
          delete m_symbolTables[i];
        }
      size = m_errorContainers.size ();
      for (unsigned int i = 0; i < size; i++)
        {
          delete m_errorContainers[i];
        }
      m_symbolTables.clear ();
      m_errorContainers.clear ();
    }
  
  std::vector<CompileSourceFile*> tmp_compilers;
  unsigned int size = m_compilers.size ();
  for (unsigned int i = 0; i < size; i++)
    {
      std::string fileName = m_compilers[i]->getSymbolTable ()->getSymbol(m_compilers[i]->getPpOutputFileId ());
      std::string origFile = m_compilers[i]->getSymbolTable ()->getSymbol(m_compilers[i]->getFileId ());
      unsigned int nbThreads = m_commandLineParser->getNbMaxTreads ();
      std::string root = fileName;
      root = StringUtils::getRootFileName (root);
      if (prec->isFilePrecompiled (root))
        {
          nbThreads = 0;
        }
      int effectiveNbThreads = 0;
      if (nbThreads > 4)
        effectiveNbThreads = (int) (log (((float) nbThreads + 1.0) / 4.0) * 10.0);
      else
        effectiveNbThreads = nbThreads;
      
      AnalyzeFile* fileAnalyzer = new AnalyzeFile(m_commandLineParser, m_design, fileName, origFile, effectiveNbThreads);
      fileAnalyzer->analyze();
      m_compilers[i]->setFileAnalyzer (fileAnalyzer);
      if (fileAnalyzer->getSplitFiles ().size() > 1) 
        {
          // Schedule parent 
          m_compilersParentFiles.push_back (m_compilers[i]);
          m_compilers[i]->initParser ();
                
          if (!m_commandLineParser->fileunit ())
            {
              SymbolTable* symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ());
              m_symbolTables.push_back (symbols);
              m_compilers[i]->setSymbolTable (symbols);
             // fileContent->setSymbolTable(symbols);
              ErrorContainer* errors = new ErrorContainer (symbols);
              m_errorContainers.push_back (errors);
              errors->regiterCmdLine (m_commandLineParser);
              m_compilers[i]->setErrorContainer (errors);
            }
          
          FileContent* fileContent = new FileContent(m_compilers[i]->getParser()->getFileId(0), 
                                                     m_compilers[i]->getParser()->getLibrary (), 
                                                     m_compilers[i]->getSymbolTable(), 
                                                     m_compilers[i]->getErrorContainer (),
                                                     NULL, 0);
          m_compilers[i]->getParser()->setFileContent(fileContent);
              
          int j = 0;
          for (auto chunk : fileAnalyzer->getSplitFiles ())
            {            
              SymbolTable* symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ());
              m_symbolTables.push_back (symbols);
              SymbolId ppId = symbols->registerSymbol(chunk);
              symbols->registerSymbol(m_compilers[i]->getParser()->getFileName (LINE1));
              CompileSourceFile* chunkCompiler = new CompileSourceFile(m_compilers[i], ppId,
                                                                      fileAnalyzer->getLineOffsets ()[j]);
              // Schedule chunk
              tmp_compilers.push_back(chunkCompiler);            
              
              
              chunkCompiler->setSymbolTable (symbols);
              ErrorContainer* errors = new ErrorContainer (symbols);
              m_errorContainers.push_back (errors);
              errors->regiterCmdLine (m_commandLineParser);
              chunkCompiler->setErrorContainer (errors);
              //chunkCompiler->getParser ()->setFileContent (fileContent);  
              
              FileContent* fileContent = new FileContent(m_compilers[i]->getParser()->getFileId(0), 
                                                         m_compilers[i]->getParser()->getLibrary(),
                                                         symbols, errors, NULL, ppId);
              chunkCompiler->getParser()->setFileContent(fileContent);
              getDesign()->addFileContent(m_compilers[i]->getParser()->getFileId(0), fileContent);
              
              j++;
            }
        }
      else
        {

          if (!m_commandLineParser->fileunit ())
            {
              SymbolTable* symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ());
              m_symbolTables.push_back (symbols);
              m_compilers[i]->setSymbolTable (symbols);
              ErrorContainer* errors = new ErrorContainer (symbols);
              m_errorContainers.push_back (errors);
              errors->regiterCmdLine (m_commandLineParser);
              m_compilers[i]->setErrorContainer (errors);
            }
          
          tmp_compilers.push_back (m_compilers[i]);
        }
    }
  m_compilers = tmp_compilers;
  
  return true;
}

bool
Compiler::pythoninit_ ()
{
  return parseinit_();
}

ErrorContainer::Stats
Compiler::getErrorStats ()
{
  ErrorContainer::Stats stats;
  unsigned int size = m_errorContainers.size ();
  for (unsigned int i = 0; i < size; i++)
    {
      ErrorContainer::Stats tmp;
      tmp = m_errorContainers[i]->getErrorStats ();
      stats += tmp;
    }

  return stats;
}

bool
Compiler::cleanup_ ()
{
  unsigned int size = m_compilers.size ();
  for (unsigned int i = 0; i < size; i++)
    {
      delete m_compilers[i];
    }
  size = m_compilationUnits.size ();
  for (unsigned int i = 0; i < size; i++)
    {
      delete m_compilationUnits[i];
    }
  size = m_symbolTables.size ();
  for (unsigned int i = 0; i < size; i++)
    {
      delete m_symbolTables[i];
    }
  size = m_errorContainers.size ();
  for (unsigned int i = 0; i < size; i++)
    {
      delete m_errorContainers[i];
    }
  return true;
}

bool
Compiler::compileFileSet_ (CompileSourceFile::Action action, bool allowMultithread, std::vector<CompileSourceFile*>& container)
{
  unsigned short maxThreadCount = m_commandLineParser->getNbMaxTreads ();
  if (allowMultithread == false)
    {
      maxThreadCount = 0;
    }

  if (maxThreadCount == 0)
    {
      // Single thread
      unsigned int size = container.size ();
      for (unsigned int i = 0; i < size; i++)
        {
          container[i]->setPythonInterp (PythonAPI::getMainInterp ());
          bool status = compileOneFile_ (container[i], action);
          m_errors->appendErrors (*container[i]->getErrorContainer ());
          m_errors->printMessages (m_commandLineParser->muteStdout ());
          if ((!status) || container[i]->getErrorContainer ()->hasFatalErrors ())
            return false;
        }
    }
  else if (getCommandLineParser ()->useTbb () && (action != CompileSourceFile::Action::Parse))
    {
#ifdef USETBB
      // TBB Thread management
      int maxThreadCount = m_commandLineParser->getNbMaxTreads ();
      if (allowMultithread == false)
        {
          maxThreadCount = 0;
        }
      unsigned int size = container.size ();
      if (maxThreadCount)
        {
          for (unsigned int i = 0; i < size; i++)
            {
              m_taskGroup.run (FunctorCompileOneFile (container[i], action));
            }
          m_taskGroup.wait ();
          bool fatalErrors = false;
          for (unsigned int i = 0; i < size; i++)
            {
              // Promote report to master error container
              m_errors->appendErrors (*container[i]->getErrorContainer ());
              if (container[i]->getErrorContainer ()->hasFatalErrors ())
                {
                  fatalErrors = true;
                }
              if (getCommandLineParser ()->pythonListener ())
                {
                  container[i]->shutdownPythonInterp ();
                }
              m_errors->printMessages (m_commandLineParser->muteStdout ());
            }
          if (fatalErrors)
            return false;
        }
      else
        {
          for (unsigned int i = 0; i < size; i++)
            {
              container[i]->setPythonInterp (PythonAPI::getMainInterp ());
              bool status = compileOneFile_ (container[i], action);
              m_errors->appendErrors (*container[i]->getErrorContainer ());
              m_errors->printMessages (m_commandLineParser->muteStdout ());
              if ((!status) || container[i]->getErrorContainer ()->hasFatalErrors ())
                return false;

            }
        }
#endif
    }
  else
    {
      // Custom Thread management
      
      // Optimize the load balance, try to even out the work in each thread by the size of the files 
      std::vector<std::vector < CompileSourceFile*>> jobArray (maxThreadCount);      

      std::vector<unsigned long> jobSize(maxThreadCount);

      for (unsigned short i = 0; i < maxThreadCount; i++) 
        jobSize[i] = 0;
      
      for (unsigned int i = 0; i < container.size (); i++)
        {
          unsigned int size = container[i]->getJobSize(action);
          unsigned int newJobIndex = 0;
          unsigned long minJobQueue = ULLONG_MAX;
          for (unsigned short ii = 0; ii < maxThreadCount; ii++) 
            {
              if (jobSize[ii] < minJobQueue) 
                {
                  newJobIndex = ii;
                  minJobQueue = jobSize[ii];
                }
            }
          
          jobSize[newJobIndex] += size;
          jobArray[newJobIndex].push_back (container[i]);
 
        }

      if (getCommandLineParser ()->profile()) 
        {
          if(action == CompileSourceFile::Preprocess)
            std::cout << "Preprocessing task\n";
          else if(action == CompileSourceFile::Parse)
            std::cout << "Parsing task\n";          
          else 
            std::cout << "Misc Task\n";    
          for (unsigned short i = 0; i < maxThreadCount; i++)
            {

              std::cout << "Thread " << i << " : \n";
              int sum = 0;
              for (unsigned int j = 0; j < jobArray[i].size (); j++)
                {
                  std::string fileName;
                  if (jobArray[i][j]->getPreprocessor ())
                    fileName = jobArray[i][j]->getPreprocessor ()->getFileName (0);
                  if (jobArray[i][j]->getParser ())
                    fileName = jobArray[i][j]->getParser ()->getFileName (0);
                  sum += jobArray[i][j]->getJobSize (action);
                  std::cout << jobArray[i][j]->getJobSize (action) << " " << fileName << "\n";
                }
              std::cout << ", Total: " << sum << std::endl << std::flush;
            }
        }
      
      // Create the threads with their respective workloads
      std::vector<std::thread*> threads;
      for (unsigned short i = 0; i < maxThreadCount; i++)
        {
          std::thread* th = new std::thread ([ = ]{
                    
           for (unsigned int j = 0; j < jobArray[i].size(); j++)
             { 
               if (getCommandLineParser ()->pythonListener ()
                || getCommandLineParser ()->pythonEvalScriptPerFile ())
                  {
                    PyThreadState* interpState = PythonAPI::initNewInterp ();
                    jobArray[i][j]->setPythonInterp (interpState);
                  }
                  
               jobArray[i][j]->compile(action);

               if (getCommandLineParser ()->pythonListener ()
                || getCommandLineParser ()->pythonEvalScriptPerFile ())
                  {
                    jobArray[i][j]->shutdownPythonInterp ();
                  }
             } 
          });
          threads.push_back(th);
        }

      // Sync the threads
      for (unsigned int th = 0; th < threads.size (); th++)
        {
          threads[th]->join ();
        }
      
      // Delete the threads
      for (unsigned int th = 0; th < threads.size (); th++)
        {
          delete threads[th];
        }

      // Promote report to master error container
      bool fatalErrors = false;
      for (unsigned int j = 0; j < container.size (); j++)
        {
          m_errors->appendErrors (*container[j]->getErrorContainer ());
          if (container[j]->getErrorContainer ()->hasFatalErrors ())
            fatalErrors = true;
        }
      m_errors->printMessages (m_commandLineParser->muteStdout ());
      
      if (fatalErrors)
       return false;
    }
  return true;
}

bool
Compiler::compile ()
{
  
  std::string profile;
  Timer tmr;
  Timer tmrTotal;
  // Scan the libraries definition
  if (!parseLibrariesDef_()) return false;
 
  if (m_commandLineParser->profile())
    {
      std::string msg = "Scan libraries took " + StringUtils::to_string(tmr.elapsed_rounded ()) + "s\n";
      std::cout << msg << std::endl;
      profile += msg;
      tmr.reset();
    }
 
  // Preprocess
  ppinit_ ();
  if (!compileFileSet_ (CompileSourceFile::Preprocess, m_commandLineParser->fileunit (), m_compilers)) return false;

  // Single thread post Preprocess
  if (!compileFileSet_ (CompileSourceFile::PostPreprocess, false, m_compilers)) return false;
   
  if (m_commandLineParser->profile())
    {
      std::string msg = "Preprocessing took " + StringUtils::to_string(tmr.elapsed_rounded ()) + "s\n";
      std::cout << msg << std::endl;
      profile += msg;
      tmr.reset();
    }
  
  // Parse
  bool parserInitialized = false;
  if (m_commandLineParser->parse () 
   || m_commandLineParser->pythonListener ()
   || m_commandLineParser->pythonEvalScriptPerFile ()
   || m_commandLineParser->pythonEvalScript())
    {
      parseinit_ ();
      parserInitialized = true;
      if (!compileFileSet_ (CompileSourceFile::Parse, true, m_compilers)) return false;  // Small files and large file chunks
      if (!compileFileSet_ (CompileSourceFile::Parse, true, m_compilersParentFiles)) return false; // Recombine chunks
    }

  if (m_commandLineParser->profile())
    {
      std::string msg = "Parsing took " + StringUtils::to_string(tmr.elapsed_rounded()) + "s\n";
      for (unsigned int i = 0; i < m_compilersParentFiles.size(); i++)
        {
          msg += m_compilersParentFiles[i]->getParser ()->getProfileInfo ();
        }
      for (unsigned int i = 0; i < m_compilers.size(); i++)
        {
          msg += m_compilers[i]->getParser ()->getProfileInfo ();
        }
      
      std::cout << msg << std::endl;
      profile += msg;
      tmr.reset();
    }
  
  // Check Parsing 
  CheckCompile* checkComp = new CheckCompile (this);
  checkComp->check ();
  delete checkComp;
  m_errors->printMessages (m_commandLineParser->muteStdout ());
  
  // Python Listener
  if (m_commandLineParser->pythonListener ()
   || m_commandLineParser->pythonEvalScriptPerFile ())
    {
 
      if (!parserInitialized)
        pythoninit_ ();
      if (!compileFileSet_ (CompileSourceFile::PythonAPI, true, m_compilers)) return false;
      if (!compileFileSet_ (CompileSourceFile::PythonAPI, true, m_compilersParentFiles)) return false;

      if (m_commandLineParser->profile ())
        {
          std::string msg = "Python file processing took " + StringUtils::to_string(tmr.elapsed_rounded ()) + "s\n";
          std::cout << msg << std::endl;
          profile += msg;
          tmr.reset();
        }
      
    }

  if (m_commandLineParser->compile())
    {
      // Compile Design, has its own thread management
      CompileDesign* compileDesign = new CompileDesign (this);
      compileDesign->compile ();
      m_errors->printMessages (m_commandLineParser->muteStdout ());

      if (m_commandLineParser->profile ())
        {
          std::string msg = "Compilation took " + StringUtils::to_string (tmr.elapsed_rounded ()) + "s\n";
          std::cout << msg << std::endl;
          profile += msg;
          tmr.reset ();
        }

      if (m_commandLineParser->elaborate ())
        {
          compileDesign->elaborate ();
          m_errors->printMessages (m_commandLineParser->muteStdout ());

          if (m_commandLineParser->profile ())
            {
              std::string msg = "Elaboration took " + StringUtils::to_string (tmr.elapsed_rounded ()) + "s\n";
              std::cout << msg << std::endl;
              profile += msg;
              tmr.reset ();
            }

          if (m_commandLineParser->pythonEvalScript ())
            {
              PythonAPI::evalScript (m_commandLineParser->getSymbolTable ()->getSymbol (m_commandLineParser->pythonEvalScriptId ()),
                                     m_design);
              if (m_commandLineParser->profile ())
                {
                  std::string msg = "Python design processing took " + StringUtils::to_string (tmr.elapsed_rounded ()) + "s\n";
                  profile += msg;
                  std::cout << msg << std::endl;
                  tmr.reset ();
                }
            }
          m_errors->printMessages (m_commandLineParser->muteStdout ());
        }
      
 
      delete compileDesign;
    }
  if (m_commandLineParser->profile ())
    {
      std::string msg = "Total time " + StringUtils::to_string (tmrTotal.elapsed_rounded ()) + "s\n";
      profile += msg;
      profile = std::string ("==============\n") + "PROFILE\n" + std::string ("==============\n") + profile + "==============\n";
      std::cout << profile << std::endl;
      m_errors->printToLogFile (profile);
    }
  return true;
}

void
Compiler::registerAntlrPpHandlerForId (SymbolId id, PreprocessFile::AntlrParserHandler* pp)
{
  std::map<SymbolId, PreprocessFile::AntlrParserHandler*>::iterator itr = m_antlrPpMap.find (id);
  if (itr != m_antlrPpMap.end ())
    {
      delete (*itr).second;
      m_antlrPpMap.erase (itr);
      m_antlrPpMap.insert (std::make_pair (id, pp));
      return;
    }
  m_antlrPpMap.insert (std::make_pair (id, pp));
}

PreprocessFile::AntlrParserHandler*
Compiler::getAntlrPpHandlerForId (SymbolId id)
{
  std::map<SymbolId, PreprocessFile::AntlrParserHandler*>::iterator itr = m_antlrPpMap.find (id);
  if (itr != m_antlrPpMap.end ())
    {
      PreprocessFile::AntlrParserHandler* ptr = (*itr).second;
      return ptr;
    }
  return NULL;
}

bool Compiler::parseLibrariesDef_() {
  m_librarySet = new LibrarySet();
  m_configSet = new ConfigSet();
  m_design = new Design (this, m_librarySet, m_configSet);
  ParseLibraryDef* libParser = new ParseLibraryDef(m_commandLineParser,m_errors,m_symbolTable,m_librarySet, m_configSet);
  return libParser->parseLibrariesDefinition ();
}