/*
 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:   DesignElaboration.cpp
 * Author: alain
 * 
 * Created on July 12, 2017, 8:55 PM
 */
#include "../Utils/StringUtils.h"
#include "../SourceCompile/VObjectTypes.h"
#include "../Design/VObject.h"
#include "../Library/Library.h"
#include "../Design/FileContent.h"
#include "../SourceCompile/SymbolTable.h"
#include "../ErrorReporting/Error.h"
#include "../ErrorReporting/Location.h"
#include "../ErrorReporting/Error.h"
#include "../ErrorReporting/ErrorDefinition.h"
#include "../ErrorReporting/ErrorContainer.h"
#include "../Config/ConfigSet.h"
#include "../CommandLine/CommandLineParser.hpp"
#include "../SourceCompile/CompilationUnit.h"
#include "../SourceCompile/PreprocessFile.h"
#include "../SourceCompile/CompileSourceFile.h"
#include "../SourceCompile/ParseFile.h"
#include "../SourceCompile/Compiler.h"
#include "CompileDesign.h"
#include "../Testbench/Property.h"
#include "../Design/Function.h"
#include "../Testbench/ClassDefinition.h"
#include "DesignElaboration.h"
#include <queue>

using namespace SURELOG;

DesignElaboration::DesignElaboration (CompileDesign* compileDesign) : ElaborationStep (compileDesign)
{
  m_moduleDefFactory = NULL;
  m_moduleInstFactory = NULL;
  m_exprBuilder.seterrorReporting (m_compileDesign->getCompiler ()->getErrorContainer (),
                                   m_compileDesign->getCompiler ()->getSymbolTable ());
}

DesignElaboration::~DesignElaboration () { }

bool
DesignElaboration::elaborate ()
{
  createBuiltinPrimitives_();
  setupConfigurations_();
  identifyTopModules_ ();
  elaborateAllModules_ (true);
  elaborateAllModules_ (false);
  reduceUnnamedBlocks_();
  checkElaboration_ ();
  reportElaboration_ ();
  return true;
}

bool
DesignElaboration::setupConfigurations_ ()
{
  ConfigSet* configSet = m_compileDesign->getCompiler ()->getDesign ()->getConfigSet ();
  SymbolTable* st = m_compileDesign->getCompiler ()->getCommandLineParser ()->getSymbolTable ();
  std::vector<Config>& allConfigs = configSet->getAllConfigs ();
  std::vector<SymbolId> selectedConfigIds = m_compileDesign->getCompiler ()->getCommandLineParser ()->getUseConfigs ();
  std::set<std::string> selectedConfigs;
  for (auto confId : selectedConfigIds)
    {
      std::string name = st->getSymbol (confId);
      if (name.find (".") == std::string::npos)
        {
          name = "work@" + name;
        }
      else 
        {
          name = StringUtils::replaceAll (name, ".", "@");
        }
      selectedConfigs.insert (name);
      bool found = false;
      for (auto& config : allConfigs)
        {
          if (config.getName() == name)
            {
              found = true;
              break;
            }
        }
      if (!found)
        {
          Location loc (st->registerSymbol (name));
          Error err (ErrorDefinition::CMD_UNDEFINED_CONFIG, loc);
          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
        }
    }

  std::queue<std::string> configq;
  for (auto& config : allConfigs)
    {
      if (selectedConfigs.find (config.getName ()) != selectedConfigs.end ())
        {
          config.setIsUsed ();
          config.setTopLevel (true);
          configq.push (config.getName ());
        }
    }
  std::set<Config*> configS;
  while (configq.size ())
    {
      std::string configName = configq.front ();
      configq.pop ();
      Config* conf = configSet->getConfig (configName);
      if (conf)
        {
          if (configS.find(conf) != configS.end ())
            {
              continue;
            }
          configS.insert (conf);
          
          conf->setIsUsed ();
          for (auto& usec : conf->getInstanceUseClauses ())
            {
              if (usec.second.getType () == UseClause::UseConfig)
                {
                  std::string confName = usec.second.getName ();
                  configq.push (confName);
                  Config* conf = configSet->getConfig (confName);
                  if (!conf)
                    {
                      FileContent* fC = usec.second.getFileContent ();
                      Location loc (st->registerSymbol(fC->getFileName(usec.second.getNodeId ())), fC->Line(usec.second.getNodeId ()), 0,  st->registerSymbol (confName));
                      Error err (ErrorDefinition::ELAB_UNDEFINED_CONFIG, loc);
                      m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
                    }
                  
                }
            }
        }
    }

  std::vector<std::string> unused;
  for (auto& config : allConfigs)
    {
      std::string name = config.getName ();
      FileContent* fC = config.getFileContent ();
      SymbolId fid = st->registerSymbol(fC->getFileName(config.getNodeId ()));
      unsigned int line = fC->Line (config.getNodeId ());
      Location loc (fid, line, 0, st->getId (config.getName ()));
      if (!config.isUsed ())
        {
          Error err (ErrorDefinition::ELAB_CONFIGURATION_IGNORED, loc);
          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
          unused.push_back (name);
        }
      else
        {
          Error err (ErrorDefinition::ELAB_CONFIGURATION_USED, loc);
          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
        }
    }

  // Remove unused configs from set
  for (auto name : unused)
    {
      std::vector<Config>::iterator itr;
      for (itr = allConfigs.begin (); itr != allConfigs.end (); itr++)
        {
          if ((*itr).getName () == name)
            {
              allConfigs.erase (itr);
              break;
            }
        }
    }

  // Create top level module list and recurse configs
  for (auto& config : allConfigs)
    {
      if (config.isTopLevel ())
        {
          std::string lib = config.getDesignLib ();
          std::string top = config.getDesignTop ();
          std::string name = lib + "@" + top;
          m_toplevelConfigModules.insert (name);
          m_instConfig.insert(std::make_pair(name, config));
          m_cellConfig.insert(std::make_pair(name, config));
          
          for (auto& instClause : config.getInstanceUseClauses ())
            {
              m_instUseClause.insert(std::make_pair(lib + "@" + instClause.first, instClause.second));
              if (instClause.second.getType () == UseClause::UseConfig)
                {
                  Config* config = configSet->getConfig (instClause.second.getName ());
                  if (config)
                    {
                      std::set<Config*> configStack;
                      recurseBuildInstanceClause_(lib + "@" + instClause.first, config, configStack);
                    }
                }
            }
          for (auto& cellClause : config.getCellUseClauses ())
            {
              m_cellUseClause.insert(std::make_pair(cellClause.first, cellClause.second));
            }
        }
    }
  return true;
}

void DesignElaboration::recurseBuildInstanceClause_(std::string parentPath, Config* config, std::set<Config*>& configStack)
{
  if (configStack.find(config) != configStack.end()) 
    {      
      return;
    }
  configStack.insert(config);
  
  ConfigSet* configSet = m_compileDesign->getCompiler ()->getDesign ()->getConfigSet ();
  for (auto& useClause : config->getInstanceUseClauses ())
    {
      std::string inst = useClause.first;
      std::string fullPath = parentPath + "." + inst;
      m_instUseClause.insert (std::make_pair (fullPath, useClause.second));
      if (useClause.second.getType () == UseClause::UseConfig)
        {
          Config* config = configSet->getConfig (useClause.second.getName ());
          if (config)
            {
              recurseBuildInstanceClause_ (parentPath + "." + useClause.first, config, configStack);
            }
        }
    }
  for (auto& useClause : config->getCellUseClauses ())
    {
      std::string inst = useClause.first;
      std::string fullPath =  inst;
      m_cellUseClause.insert(std::make_pair(fullPath, useClause.second));
    }
}

bool
DesignElaboration::identifyTopModules_ ()
{
  m_topLevelModules.clear ();
  bool modulePresent = false;
  bool toplevelModuleFound = false;
  SymbolTable* st = m_compileDesign->getCompiler ()->getSymbolTable ();
  auto all_files = m_compileDesign->getCompiler ()->getDesign ()->getAllFileContents ();
  typedef std::multimap<std::string, std::pair<DesignElement*, FileContent*>> ModuleMultiMap;
  ModuleMultiMap all_modules;
  for (auto file : all_files)
    {
      if (m_compileDesign->getCompiler ()->isLibraryFile (file.first))
        continue;
      for (DesignElement& element : file.second->getDesignElements ())
        {
          std::string elemName = st->getSymbol (element.m_name);
          if (element.m_type == DesignElement::Module)
            {
              if (element.m_parent)
                {
                  // This is a nested element
                  continue;
                }
              std::string topname = file.second->getLibrary ()->getName();
              topname += "@" + elemName;
              
              if (!file.second->getParent ())
                {
                  // Files that have parent are splited files (When a module is too large it is splited)
                  all_modules.insert(std::make_pair(topname, std::make_pair(&element, file.second)));          
                }
                           
              modulePresent = true;
              bool used = false;
              for (auto file1 : all_files)
                {
                  if (file1.second->getReferencedObjects ().find (elemName) != file1.second->getReferencedObjects ().end ())
                    {
                      used = true;
                      break;
                    }
                }
              
              if (!used)
                {
                  bool isTop = true;                
                  
                  if (m_toplevelConfigModules.size())
                    {
                      isTop = false;
                      if (m_toplevelConfigModules.find(topname) != m_toplevelConfigModules.end()) 
                        {
                          isTop = true;
                        }
                    }

                  if (isTop)
                    {
                      SymbolId topid = st->registerSymbol (topname);
                      auto itr = m_uniqueTopLevelModules.find (topname);
                      Location loc (st->registerSymbol (file.second->getFileName(element.m_node)),
                                    element.m_line,
                                    0,
                                    topid);
                      if (itr == m_uniqueTopLevelModules.end ())
                        {
                          m_uniqueTopLevelModules.insert (topname);
                          m_topLevelModules.push_back (std::make_pair (topname, file.second));
                          toplevelModuleFound = true;
                          Error err (ErrorDefinition::ELAB_TOP_LEVEL_MODULE, loc);
                          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
                        }                        
                    }
                }
            }
        }
    }
  
  // Check for multiple definition
  std::string prevModuleName = "";
  DesignElement* prevModuleDefinition = NULL;
  FileContent* prevFileContent = NULL;
  for (ModuleMultiMap::iterator itr = all_modules.begin(); itr != all_modules.end(); itr++)   
    {
      std::string    moduleName = (*itr).first;
      DesignElement* moduleDefinition = (*itr).second.first;
      FileContent*   fileContent = (*itr).second.second;
      bool done = false;
      if (moduleName == prevModuleName)
        {
          
          FileContent* fC1 = (*itr).second.second;
          NodeId nodeId1 = moduleDefinition->m_node;
          std::string fileName1 = fC1->getFileName (nodeId1);
          unsigned int line1 = fC1->Line (nodeId1);
          Location loc1 (st->registerSymbol (fileName1), line1, 0, st->registerSymbol (moduleName));

          std::vector<Location> locations;
          
          while (1)
            {

              FileContent* fC2 = prevFileContent;
              NodeId nodeId2 = prevModuleDefinition->m_node;
              std::string fileName2 = fC2->getFileName (nodeId2);
              unsigned int line2 = fC2->Line (nodeId2);
              Location loc2 (st->registerSymbol (fileName2), line2, 0, st->registerSymbol (moduleName));

              if ((fileName1 != fileName2) || (line1 != line2))
                {
                  locations.push_back(loc2);                   
                }
              
              itr++;
              if (itr == all_modules.end())
                {
                  done = true;
                  break;
                }
              else 
                {
                  std::string    nextModuleName = (*itr).first;
                  DesignElement* nextModuleDefinition = (*itr).second.first;
                  FileContent*   nextFileContent = (*itr).second.second;
                  prevModuleName       = nextModuleName;
                  prevModuleDefinition = nextModuleDefinition;
                  prevFileContent      = nextFileContent;
                  if (prevModuleName != moduleName)
                    {
                      moduleName       = prevModuleName;
                      moduleDefinition = prevModuleDefinition;
                      fileContent      = prevFileContent;
                      break;
                    }
                }             
            }
          
          if (locations.size())
            {
              Error err1 (ErrorDefinition::ELAB_MULTIPLY_DEFINED_MODULE, loc1, &locations);
              m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err1);
            }                
        }
      prevModuleName = moduleName;
      prevModuleDefinition = moduleDefinition;
      prevFileContent = fileContent;
      if (done)
        break;      
    }
  
  if (m_topLevelModules.size () > 1)
    {
      Location loc (0);
      Error err (ErrorDefinition::ELAB_MULTIPLE_TOP_LEVEL_MODULES, loc);
      m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
    }
  if (modulePresent && (!toplevelModuleFound))
    {
      Location loc (0);
      Error err (ErrorDefinition::ELAB_NO_TOP_LEVEL_MODULE, loc);
      m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
    }

  return true;
}

bool
DesignElaboration::createBuiltinPrimitives_ ()
{
  m_moduleDefFactory = new ModuleDefinitionFactory ();
  Design* design = m_compileDesign->getCompiler ()->getDesign ();

  // Register built-in primitives
  for (auto type :{"cmos", "rcmos",
      "bufif0", "bufif1", "notif0", "notif1",
      "nmos", "pmos", "rnmos", "rpmos",
      "and", "or", "nand", "nor", "xor", "xnor",
      "buf", "not",
      "tranif0", "tranif1", "rtranif0", "rtranif1",
      "tran", "rtran", "UnsupportedPrimitive"})
    {
      std::string name = std::string("work@") + type;
      design->addModuleDefinition (name, m_moduleDefFactory->newModuleDefinition (NULL, 0, std::string("work@") + type));
    }
 
  return true;
}

bool
DesignElaboration::elaborateAllModules_ (bool onlyTopLevel)
{
  bool status = true;
  for (auto topmodule : m_topLevelModules)
    {
      if (!elaborateModule_ (topmodule.first, topmodule.second, onlyTopLevel))
        {
          status = false;
        }
    }
  return status;
}

Config* DesignElaboration::getInstConfig(std::string name) {
   Config* config = NULL;
   auto itr = m_instConfig.find(name);
   if (itr != m_instConfig.end())
    {
      config = &(*itr).second;
    }
   return config;
}

Config* DesignElaboration::getCellConfig(std::string name) {
   Config* config = NULL;
   auto itr = m_cellConfig.find(name);
   if (itr != m_cellConfig.end())
    {
      config = &(*itr).second;
    }
   return config;
}


bool
DesignElaboration::elaborateModule_ (std::string moduleName, FileContent* fC, bool onlyTopLevel)
{
  FileContent::NameIdMap& nameIds = fC->getObjectLookup ();
  std::vector<VObjectType> types = {VObjectType::slUdp_instantiation,
    VObjectType::slModule_instantiation,
    VObjectType::slInterface_instantiation,
    VObjectType::slProgram_instantiation};
  std::string libName = fC->getLibrary ()->getName();
  Config* config = getInstConfig(moduleName);
  if (config == NULL)
    config = getCellConfig(moduleName);
  Design* design = m_compileDesign->getCompiler ()->getDesign ();
  if (!m_moduleInstFactory)
    m_moduleInstFactory = new ModuleInstanceFactory ();
  for (auto nameId : nameIds)
    {
      if ((fC->Type (nameId.second) == VObjectType::slModule_declaration) &&
          (moduleName == (libName + "@" + nameId.first)))
        {
          DesignComponent* def = design->getComponentDefinition (moduleName);
          if (onlyTopLevel)
            {
              ModuleInstance* instance = m_moduleInstFactory->newModuleInstance (def, fC, nameId.second, NULL, moduleName, moduleName);
              design->addTopLevelModuleInstance (instance);
            }
          else
            {
              ModuleInstance* instance = design->findInstance (moduleName);
              for (unsigned int i = 0; i < def->getFileContents().size(); i++)
                elaborateInstance_ (def->getFileContents ()[i], def->getNodeIds ()[i], 0, m_moduleInstFactory, instance, config);
            }
          break;
        }
    }
  return true;
}

void
DesignElaboration::recurseInstanceLoop_ (std::vector<int>& from, std::vector<int>& to, std::vector<int>& indexes, unsigned int pos,
                                         DesignComponent* def, FileContent* fC, NodeId subInstanceId, NodeId paramOverride,
                                         ModuleInstanceFactory* factory, ModuleInstance* parent, Config* config,
                                         std::string instanceName, std::string modName, std::vector<ModuleInstance*>& allSubInstances)
{
  if (pos == indexes.size ())
    {
      // This is where the real logic goes.
      // indexes[i] contain the value of the i-th index.
      for (unsigned int i = 0; i < indexes.size (); i++)
        {
          instanceName += std::to_string (indexes[i]);
        }
      ModuleInstance* child = factory->newModuleInstance (def, fC, subInstanceId, parent, instanceName, modName);
      VObjectType type = fC->Type (subInstanceId);
      if (def && (type != VObjectType::slGate_instantiation))
        for (unsigned int i = 0; i < def->getFileContents().size(); i++)
          elaborateInstance_ (def->getFileContents()[i], def->getNodeIds()[i], paramOverride, factory, child, config);
      allSubInstances.push_back (child);

    }
  else
    {
      for (indexes[pos] = from[pos]; indexes[pos] <= to[pos]; indexes[pos]++)
        {
          // Recurse for the next level
          recurseInstanceLoop_ (from, to, indexes, pos + 1, def, fC, subInstanceId, paramOverride,
                                factory, parent, config, instanceName, modName, allSubInstances);
        }
    }
}

void
DesignElaboration::elaborateInstance_ (FileContent* fC, NodeId nodeId, NodeId parentParamOverride, ModuleInstanceFactory* factory, ModuleInstance* parent, Config* config)
{
  if (!parent)
    return;
  std::vector<ModuleInstance*> allSubInstances;
  std::string genBlkBaseName = "genblk";
  unsigned int genBlkIndex = 1;
  bool reuseInstance = false;
  std::string mname;  
  std::vector<VObjectType> types;
  std::vector<std::string> params;

  // Scan for parameters, including DefParams
  collectParams_ (params, fC, nodeId, parent, parentParamOverride);

  //Apply DefParams
  Design* design = m_compileDesign->getCompiler ()->getDesign ();
  for (auto name : params)
    {

      DefParam* defparam = design->getDefParam (parent->getFullPathName () + "." + name);
      if (defparam)
        {
          Value* value = defparam->getValue ();
          if (value)
            {
              parent->setValue (name, value, m_exprBuilder);
              defparam->setUsed ();
            }
        }
    }


  // Scan for regular instances and generate blocks
  types = {VObjectType::slUdp_instantiation,
    VObjectType::slModule_instantiation,
    VObjectType::slInterface_instantiation,
    VObjectType::slProgram_instantiation,
    VObjectType::slGate_instantiation,
    VObjectType::slConditional_generate_construct, // Generate construct are a kind of instantiation
    VObjectType::slGenerate_module_conditional_statement,
    VObjectType::slLoop_generate_construct,
    VObjectType::slGenerate_module_loop_statement,
    VObjectType::slPar_block,
    VObjectType::slSeq_block};


  std::vector<VObjectType> stopPoints = {
    VObjectType::slConditional_generate_construct,
    VObjectType::slGenerate_module_conditional_statement,
    VObjectType::slLoop_generate_construct,
    VObjectType::slGenerate_module_loop_statement,
    VObjectType::slPar_block,
    VObjectType::slSeq_block,
    VObjectType::slModule_declaration
  };

  std::vector<NodeId> subInstances = fC->sl_collect_all (nodeId, types, stopPoints);

  for (auto subInstanceId : subInstances)
    {
      NodeId childId = 0;
      std::string instName;
      std::string modName;
      DesignComponent* def = NULL;
      NodeId paramOverride = 0;
      Config* subConfig = config;
      VObjectType type = fC->Type (subInstanceId);

      if (type == slSeq_block ||
          type == slPar_block)
        {
          NodeId identifierId = fC->Child (subInstanceId);
          if (fC->Name (identifierId))
            instName = fC->SymName (identifierId);
          else
            instName = "UNNAMED";
        }
      else if (type == slConditional_generate_construct)
        {
          NodeId constructId = fC->Child (subInstanceId);
          NodeId condId = fC->Child (constructId);
          NodeId blockId = fC->Sibling(condId);
          NodeId nameId = fC->Child (blockId);
          if (fC->Name (nameId))
            instName = fC->SymName (nameId);
          else
            instName = "UNNAMED";
        }
      else
        {
          NodeId instId = fC->sl_collect (subInstanceId, slName_of_instance);
          NodeId identifierId = 0;
          if (instId != InvalidNodeId)
            {
              identifierId = fC->Child (instId);
              instName = fC->SymName (identifierId);
            }
        }

      // Special module binding for built-in primitives
      if (type == VObjectType::slGate_instantiation)
        {
          VObjectType gatetype = fC->Type (fC->Child (subInstanceId));
          switch (gatetype)
            {
            case VObjectType::slNInpGate_And:
              modName = "work@and";
              break;
            case VObjectType::slNInpGate_Or:
              modName = "work@or";
              break;
            case VObjectType::slNInpGate_Nand:
              modName = "work@nand";
              break;
            case VObjectType::slNInpGate_Nor:
              modName = "work@nor";
              break;
            case VObjectType::slNInpGate_Xor:
              modName = "work@xor";
              break;
            case VObjectType::slNInpGate_Xnor:
              modName = "work@xnor";
              break;
            case VObjectType::slNOutGate_Buf:
              modName = "work@buf";
              break;
            case VObjectType::slNOutGate_Not:
              modName = "work@not";
              break;
              // TODO: Cater for the transistor level
            default:
              modName = "work@UnsupportedPrimitive";
              break;
            }
          
          def = design->getComponentDefinition (modName);
          childId = 0; // = def->getNodeId ();
          ModuleInstance* child = factory->newModuleInstance (def, fC, subInstanceId, parent, instName, modName);
          allSubInstances.push_back (child);
                   
        }
        // Special module binding for generate statements
      else if (type == VObjectType::slConditional_generate_construct ||
               type == VObjectType::slGenerate_module_conditional_statement ||
               type == VObjectType::slLoop_generate_construct ||
               type == VObjectType::slGenerate_module_loop_statement)
        {
          modName = genBlkBaseName + std::to_string (genBlkIndex);

          std::vector<VObjectType> btypes = {VObjectType::slGenerate_module_block,
            VObjectType::slGenerate_block,
            VObjectType::slGenerate_module_named_block};

          std::vector<NodeId> blockIds = fC->sl_collect_all (subInstanceId, btypes, true);
          bool namedBlock = false;
          if (blockIds.size ())
            {
              NodeId blockId = blockIds[0];
              NodeId blockNameId = fC->Child (blockId);
              if (fC->Type (blockNameId) == VObjectType::slStringConst)
                {
                  namedBlock = true;
                  modName = fC->SymName (blockNameId);
                }
            }
          if (!namedBlock)
            genBlkIndex++;
          instName = modName;
          std::string fullName;
          std::string libName = fC->getLibrary()->getName ();
          if (instName == parent->getInstanceName ())
            {
              fullName += parent->getFullPathName ();
              reuseInstance = true;
            }
          else
            {
              fullName += parent->getModuleName () + "." + instName;
            }
          def = design->getComponentDefinition (fullName);
          if (def == NULL)
            {
              def = m_moduleDefFactory->newModuleDefinition (fC, subInstanceId, fullName);
              design->addModuleDefinition (fullName, (ModuleDefinition*) def);
            }

          NodeId conditionId = fC->Child (subInstanceId);

          if (fC->Type (conditionId) == VObjectType::slGenvar_initialization ||
              fC->Type (conditionId) == VObjectType::slGenvar_decl_assignment)
            { // For loop stmt

              // Var init
              NodeId varId = fC->Child (conditionId);
              NodeId constExpr = fC->Sibling (varId);
              Value* initValue = m_exprBuilder.evalExpr (fC, constExpr, parent);
              std::string name = fC->SymName (varId);
              parent->setValue (name, initValue, m_exprBuilder);

              // End-loop test
              NodeId endLoopTest = fC->Sibling (conditionId);

              // Iteration
              NodeId iteration = fC->Sibling (endLoopTest);
              NodeId var = fC->Child (iteration);
              NodeId assignOp = fC->Sibling (var);
              NodeId expr = fC->Sibling (assignOp);
              if (expr == 0)
                { // Unary operator like i++
                  expr = var;
                }
              // Generate block
              NodeId genBlock = fC->Sibling (iteration);

              bool cont = true;
              Value* testCond = m_exprBuilder.evalExpr (fC, endLoopTest, parent);
              cont = testCond->getValueUL ();
              m_exprBuilder.deleteValue (testCond);

              while (cont)
                {
                  Value* currentIndexValue = parent->getValue (name);
                  long currVal = currentIndexValue->getValueUL ();
                  std::string indexedModName = modName + "[" + std::to_string (currVal) + "]";
                  instName = indexedModName;
                  ModuleInstance* child = factory->newModuleInstance (def, fC, genBlock, parent, instName, indexedModName);
                  child->setValue (name, currentIndexValue, m_exprBuilder);
                  elaborateInstance_ (def->getFileContents()[0], genBlock, 0, factory, child, config);
                  allSubInstances.push_back (child);

                  Value* newVal = m_exprBuilder.evalExpr (fC, expr, parent);
                  parent->setValue (name, newVal, m_exprBuilder);
                  Value* testCond = m_exprBuilder.evalExpr (fC, endLoopTest, parent);
                  cont = testCond->getValueUL ();
                  m_exprBuilder.deleteValue (testCond);
                }
              if (allSubInstances.size ())
                {
                  ModuleInstance** children = new ModuleInstance* [allSubInstances.size ()];
                  for (unsigned int index = 0; index < allSubInstances.size (); index++)
                    {
                      children[index] = allSubInstances[index];
                    }
                  parent->addSubInstances (children, allSubInstances.size ());
                }
              continue;

            }
          else
            { // If-Else or Case stmt
              if (fC->Type (conditionId) != VObjectType::slConstant_expression)
                {
                  conditionId = fC->Child (conditionId);
                }
              Value* condValue = m_exprBuilder.evalExpr (fC, conditionId, parent);
              long condVal = condValue->getValueUL ();
              m_exprBuilder.deleteValue (condValue);
              NodeId tmp = fC->Sibling (conditionId);
              if (fC->Type (tmp) == VObjectType::slCase_generate_item)
                { // Case stmt
                  NodeId caseItem = tmp;
                  bool nomatch = true;
                  while (nomatch)
                    {
                      NodeId exprItem = fC->Child (caseItem);
                      if (fC->Type (exprItem) == VObjectType::slGenerate_block) // Default block
                        nomatch = false;
                      while (nomatch)
                        {
                          // Find if one of the case expr matches the case expr
                          if (fC->Type (exprItem) == VObjectType::slConstant_expression)
                            {
                              Value* caseValue = m_exprBuilder.evalExpr (fC, exprItem, parent);
                              long caseVal = caseValue->getValueUL ();
                              m_exprBuilder.deleteValue (caseValue);
                              if (condVal == caseVal)
                                {
                                  nomatch = false;
                                  break;
                                }
                            }
                          else
                            break;
                          exprItem = fC->Sibling (exprItem);
                        }

                      if (nomatch)
                        {
                          // Next case stmt
                          caseItem = fC->Sibling (caseItem);
                          if (!caseItem)
                            break;
                          if (fC->Type (caseItem) != VObjectType::slCase_generate_item)
                            break;
                        }
                      else
                        {
                          // We found a match
                          while (fC->Type (exprItem) == VObjectType::slConstant_expression)
                            exprItem = fC->Sibling (exprItem);
                          childId = exprItem;
                        }
                    }
                }
              else
                { // If-Else stmt
                  if (condVal)
                    { // If branch            
                      if (tmp)
                        childId = tmp;
                      else // There is no If stmt 
                        continue;
                    }
                  else
                    { // Else branch
                      if (tmp)
                        tmp = fC->Sibling (tmp);
                      if (tmp)
                        childId = tmp;
                      else // There is no Else stmt
                        continue;
                    }
                }
            }
          
          
          libName = fC->getLibrary()->getName ();
          fullName = parent->getModuleName () + "." + instName;
          def = design->getComponentDefinition (fullName);
          if (def == NULL)
            {
              def = m_moduleDefFactory->newModuleDefinition (fC, subInstanceId, fullName);
              design->addModuleDefinition (fullName, (ModuleDefinition*) def);
            }

          ModuleInstance* child = factory->newModuleInstance (def, fC, subInstanceId, parent, instName, modName);
          elaborateInstance_ (def->getFileContents()[0], childId, paramOverride, factory, child, config);
          allSubInstances.push_back (child);
          
        }
        // Named blocks  
      else if (type == slSeq_block ||
               type == slPar_block)
        {
          std::string libName = fC->getLibrary()->getName ();
          std::string fullName = parent->getModuleName () + "." + instName;
          
          def = design->getComponentDefinition (fullName);
          if (def == NULL)
            {
              def = m_moduleDefFactory->newModuleDefinition (fC, subInstanceId, fullName);
              design->addModuleDefinition (fullName, (ModuleDefinition*) def);
            }

          ModuleInstance* child = factory->newModuleInstance (def, fC, subInstanceId, parent, instName, modName);
          elaborateInstance_ (def->getFileContents ()[0], subInstanceId, paramOverride, factory, child, config);
          allSubInstances.push_back (child);

        }
        // Regular module binding
      else
        {
          NodeId moduleName = fC->sl_collect (subInstanceId, VObjectType::slStringConst);
          std::string libName = fC->getLibrary ()->getName ();
          mname = fC->SymName (moduleName);

          std::vector<std::string> libs;
          if (config)
            {
              for (auto lib : config->getDefaultLibs ())
                {
                  libs.push_back (lib);
                }
              libs.push_back (libName);
            }
          else
            {
              libs.push_back (libName);
            }
          
          for (auto lib : libs)
            {
              modName = lib + "@" + mname;
              def = design->getComponentDefinition (modName);
              if (def)
                {
                  break;
                }
              else 
                {
                  modName = parent->getDefinition ()->getName () + "::" + mname;
                  def = design->getComponentDefinition (modName);
                  if (def)
                    {
                      break;
                    }
                }
            }

          auto itr = m_cellUseClause.find (mname);
          if (itr != m_cellUseClause.end ())
            {
              UseClause& use = (*itr).second;
              switch (use.getType ())
                {
                case UseClause::UseModule:
                  {
                    std::string name = use.getName ();
                    def = design->getComponentDefinition (name);
                    if (def)
                      use.setUsed ();
                    break;
                  }
                case UseClause::UseLib:
                  {
                    for (auto lib : use.getLibs ())
                      {
                        modName = lib + "@" + mname;
                        def = design->getComponentDefinition (modName);
                        if (def)
                          {
                            use.setUsed ();
                            break;
                          }
                      }
                    break;
                  }
                default:
                  break;
                }
            }
                                  
          if (def)
            childId = def->getNodeIds ()[0];
          
          NodeId tmpId = fC->Sibling (moduleName);
          if (fC->Type (tmpId) == VObjectType::slParameter_value_assignment)
            {
              paramOverride = tmpId;
            }
        

      bool loopDetected = false;
      ModuleInstance* tmp = parent;
      while (tmp)
        {
          if (tmp->getDefinition () == def)
            {
              loopDetected = true;
              break;
            }
          tmp = tmp->getParent ();
        }
      if (loopDetected)
        {
          SymbolTable* st = m_compileDesign->getCompiler ()->getErrorContainer ()->getSymbolTable ();
          Location loc (st->registerSymbol(fC->getFileName(subInstanceId)),
                        fC->Line (subInstanceId),
                        0,
                        st->registerSymbol (modName));
          Location loc2 (st->registerSymbol(tmp->getFileContent ()->getFileName (tmp->getNodeId ())),
                         tmp->getFileContent ()->Line (tmp->getNodeId ()),
                         0);
          Error err (ErrorDefinition::ELAB_INSTANTIATION_LOOP, loc, loc2);
          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
        }
      else
        {
          std::vector<int> from;
          std::vector<int> to;
          std::vector<int> index;

          std::vector<VObjectType> insttypes = {VObjectType::slHierarchical_instance,
            VObjectType::slN_input_gate_instance,
            VObjectType::slN_output_gate_instance,
            VObjectType::slUdp_instance};

          std::vector<NodeId> hierInstIds = fC->sl_collect_all (subInstanceId, insttypes, true);

          NodeId hierInstId = InvalidNodeId;
          if (hierInstIds.size ())
            hierInstId = hierInstIds[0];

          if (hierInstId == InvalidNodeId)
            continue;

          while (hierInstId)
            {
              NodeId instId = fC->sl_collect (hierInstId, slName_of_instance);
              NodeId identifierId = 0;
              if (instId != InvalidNodeId)
                {
                  identifierId = fC->Child (instId);
                  instName = fC->SymName (identifierId);
                }

              auto itr =  m_instUseClause.find(parent->getFullPathName () + "." + instName);
              if (itr != m_instUseClause.end())
                {
                  UseClause& use = (*itr).second;
                  switch (use.getType ())
                    {
                    case UseClause::UseModule:
                    {
                      std::string name = use.getName ();
                      def = design->getComponentDefinition (name);
                      if (def)
                        use.setUsed ();
                      break;
                    }
                    case UseClause::UseLib:
                    {
                      for (auto lib : use.getLibs ())
                        {
                           modName = lib + "@" + mname;
                           def = design->getComponentDefinition (modName);
                           if (def)
                             {
                               use.setUsed ();
                               break;
                             }
                        }
                      break;
                    }
                    case UseClause::UseConfig:
                    {
                      std::string useConfig = use.getName();
                      Config* config = design->getConfigSet ()->getConfig(useConfig);
                      if (config)
                        {
                          subConfig = config;
                          std::string lib = config->getDesignLib ();
                          std::string top = config->getDesignTop ();
                          modName = lib + "@" + top;
                          def = design->getComponentDefinition (modName); 
                          if (def)
                            use.setUsed ();
                          
                        }
                    }
                    default:
                      break;
                    }
                }

              if (def)
                childId = def->getNodeIds ()[0];
              else
                {
                  SymbolTable* st = m_compileDesign->getCompiler ()->getErrorContainer ()->getSymbolTable ();
                  Location loc (st->registerSymbol(fC->getFileName(subInstanceId)), fC->Line (subInstanceId), 0, st->registerSymbol (modName));
                  Error err (ErrorDefinition::ELAB_NO_MODULE_DEFINITION, loc);
                  m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err, false, false);
                }
              
              
              NodeId unpackedDimId = 0;

              if (identifierId)
                unpackedDimId = fC->Sibling (identifierId);

              if (unpackedDimId)
                {
                  // Vector instances
                  while (unpackedDimId)
                    {
                      if (fC->Type (unpackedDimId) == slUnpacked_dimension)
                        {
                          NodeId constantRangeId = fC->Child (unpackedDimId);
                          NodeId leftNode = fC->Child (constantRangeId);
                          NodeId rightNode = fC->Sibling (leftNode);
                          Value* leftVal = m_exprBuilder.evalExpr (fC, leftNode, parent);
                          Value* rightVal = m_exprBuilder.evalExpr (fC, rightNode, parent);
                          unsigned long left = leftVal->getValueUL ();
                          unsigned long right = rightVal->getValueUL ();
                          m_exprBuilder.deleteValue (leftVal);
                          m_exprBuilder.deleteValue (rightVal);
                          if (left < right)
                            {
                              from.push_back (left);
                              to.push_back (right);
                              index.push_back (left);
                            }
                          else
                            {
                              from.push_back (right);
                              to.push_back (left);
                              index.push_back (right);
                            }
                        }
                      unpackedDimId = fC->Sibling (unpackedDimId);
                    }
                  recurseInstanceLoop_ (from, to, index, 0, def, fC, subInstanceId, paramOverride, factory, parent, subConfig, instName, modName, allSubInstances);
                }
              else
                {
                  // Simple instance
                  ModuleInstance* child = NULL;
                  if (reuseInstance)
                    {
                      child = parent;
                      child->setNodeId (subInstanceId);
                    }
                  else
                    {
                      child = factory->newModuleInstance (def, fC, subInstanceId, parent, instName, modName);
                    }
                  if (def && (type != VObjectType::slGate_instantiation))
                    elaborateInstance_ (def->getFileContents ()[0], childId, paramOverride, factory, child, subConfig);

                  if (!reuseInstance)
                    allSubInstances.push_back (child);
                }

              hierInstId = fC->Sibling (hierInstId);
            }

          //std::cout << "INST: " << modName << " " << instName << " " << def << std::endl;
        }
    }
    }
  // Record sub-scopes and sub-instances
  if (allSubInstances.size ())
    {
      ModuleInstance** children = new ModuleInstance* [allSubInstances.size ()];
      for (unsigned int index = 0; index < allSubInstances.size (); index++)
        {
          children[index] = allSubInstances[index];
        }
      parent->addSubInstances (children, allSubInstances.size ());
    }

}

void
DesignElaboration::reportElaboration_ ()
{
  unsigned int nbTopLevelModules = 0;
  unsigned int maxDepth = 0;
  unsigned int numberOfInstances = 0;
  unsigned int numberOfLeafInstances = 0;
  unsigned int nbUndefinedModules = 0;
  unsigned int nbUndefinedInstances = 0;

  m_compileDesign->getCompiler ()->getDesign ()->reportInstanceTreeStats (
                                                                          nbTopLevelModules, maxDepth, numberOfInstances,
                                                                          numberOfLeafInstances, nbUndefinedModules, nbUndefinedInstances);

  SymbolTable* symtable = m_compileDesign->getCompiler ()->getSymbolTable ();

  Location loc1 (symtable->registerSymbol (std::to_string (nbTopLevelModules)));
  Error err1 (ErrorDefinition::ELAB_NB_TOP_LEVEL_MODULES, loc1);
  m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err1);

  Location loc2 (symtable->registerSymbol (std::to_string (maxDepth)));
  Error err2 (ErrorDefinition::ELAB_MAX_INSTANCE_DEPTH, loc2);
  m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err2);

  Location loc3 (symtable->registerSymbol (std::to_string (numberOfInstances)));
  Error err3 (ErrorDefinition::ELAB_NB_INSTANCES, loc3);
  m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err3);

  Location loc4 (symtable->registerSymbol (std::to_string (numberOfLeafInstances)));
  Error err4 (ErrorDefinition::ELAB_NB_LEAF_INSTANCES, loc4);
  m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err4);

  if (nbUndefinedModules)
    {
      Location loc5 (symtable->registerSymbol (std::to_string (nbUndefinedModules)));
      Error err5 (ErrorDefinition::ELAB_NB_UNDEF_MODULES, loc5);
      m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err5);
    }

  if (nbUndefinedInstances)
    {
      Location loc6 (symtable->registerSymbol (std::to_string (nbUndefinedInstances)));
      Error err6 (ErrorDefinition::ELAB_NB_UNDEF_INSTANCES, loc6);
      m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err6);
    }
  CommandLineParser* cl = m_compileDesign->getCompiler ()->getCommandLineParser ();
  if (cl->getDebugInstanceTree () && (!cl->muteStdout ()))
    {
      std::cout << "Instance tree:" << std::endl;
      std::cout << m_compileDesign->getCompiler ()->getDesign ()->reportInstanceTree ();
      std::cout << std::endl;
    }
}

void
DesignElaboration::collectParams_ (std::vector<std::string>& params, FileContent* fC, NodeId nodeId, ModuleInstance* instance, NodeId parentParamOverride)
{
  if (!nodeId)
    return;
  if (!instance)
    return;
  Design* design = m_compileDesign->getCompiler ()->getDesign ();
  SymbolTable* st = m_compileDesign->getCompiler ()->getSymbolTable ();
  ErrorContainer* errors = m_compileDesign->getCompiler ()->getErrorContainer ();
  DesignComponent* module = instance->getDefinition();

  // Parameters imported by package imports 
  std::vector<FileCNodeId> pack_imports;
  for (auto import : fC->getObjects (VObjectType::slPackage_import_item))
    {
      pack_imports.push_back(import);
    }
  for (auto import : module->getObjects (VObjectType::slPackage_import_item))
    {
      pack_imports.push_back(import);
    }
 
  for (auto pack_import : pack_imports)
    {
      NodeId pack_id = pack_import.fC->Child(pack_import.nodeId);
      std::string pack_name = pack_import.fC->SymName (pack_id);      
      Package* def = design->getPackage (pack_name);
      if (def)
        {
          auto& paramSet = def->getObjects (VObjectType::slParam_assignment);
          for (unsigned int i = 0; i < paramSet.size(); i++)
            {
              FileContent* packageFile = paramSet[i].fC;
              NodeId param = paramSet[i].nodeId;
              
              NodeId ident = packageFile->Child (param);
              std::string name = packageFile->SymName (ident);
              Value* value = m_exprBuilder.clone (def->getValues ()[i]);
              instance->setValue (name, value, m_exprBuilder);
              params.push_back(name);             
            }
        }
      else 
        {
          Location loc (st->registerSymbol(pack_import.fC->getFileName (pack_id)), pack_import.fC->Line(pack_id), 0, st->registerSymbol (pack_name));
          Error err (ErrorDefinition::ELAB_UNDEFINED_PACKAGE, loc);
          errors->addError(err);
        }
    }
   
  for (FileCNodeId param : module->getObjects (VObjectType::slParam_assignment))
    {
      NodeId ident = param.fC->Child (param.nodeId);
      std::string name = param.fC->SymName (ident);
      Value* value = m_exprBuilder.evalExpr (param.fC, param.fC->Sibling (ident), instance);
      instance->setValue (name, value, m_exprBuilder);
      params.push_back (name);
    }
  
  std::vector<VObjectType> types;
  // Param overrides
  if (parentParamOverride)
    {
      FileContent* parentFile = instance->getParent()->getDefinition ()->getFileContents()[0];
      types = {VObjectType::slOrdered_parameter_assignment,
        VObjectType::slNamed_parameter_assignment};
      std::vector<NodeId> overrideParams = parentFile->sl_collect_all (parentParamOverride, types);

      unsigned int index = 0;
      for (auto paramAssign : overrideParams)
        {
          NodeId child = parentFile->Child (paramAssign);
          if (parentFile->Type (child) == VObjectType::slStringConst)
            {
              // Named param
              std::string name = parentFile->SymName (child);
              NodeId expr = parentFile->Sibling (child);
              Value* value = m_exprBuilder.evalExpr (parentFile, expr, instance->getParent ());
              instance->setValue (name, value, m_exprBuilder);
            }
          else
            {
              // Index param
              NodeId expr = child;
              Value* value = m_exprBuilder.evalExpr (parentFile, expr, instance->getParent ());
              std::string name = "OUT_OF_RANGE_PARAM_INDEX";
              if (index < params.size()) 
                {
                  name = params[index];
                } 
              else 
                {
                  Location loc (st->registerSymbol(parentFile->getFileName(paramAssign)), parentFile->Line(paramAssign), 0, st->registerSymbol (std::to_string(index)));
                  Error err (ErrorDefinition::ELAB_OUT_OF_RANGE_PARAM_INDEX, loc);
                  errors->addError(err);
                }
              instance->setValue (name, value, m_exprBuilder);
              index++;
            }
        }
    }

  // Defparams
  types = {VObjectType::slDefparam_assignment};
  std::vector<VObjectType> stopPoints = {
    VObjectType::slConditional_generate_construct,
    VObjectType::slGenerate_module_conditional_statement,
    VObjectType::slLoop_generate_construct,
    VObjectType::slGenerate_module_loop_statement,
    VObjectType::slPar_block,
    VObjectType::slSeq_block,
    VObjectType::slModule_declaration
  };

  std::vector<NodeId> defParams = fC->sl_collect_all (nodeId, types, stopPoints);
  for (auto defParam : defParams)
    {

      NodeId hIdent = fC->Child (defParam);
      NodeId var = fC->Child (hIdent);
      NodeId value = fC->Sibling (hIdent);
      std::string fullPath = fC->SymName (var);
      std::string path;
      for (unsigned int i = 0; i < fullPath.size(); i++)
        {
          if (fullPath[i] == '.')
            break;
          path += fullPath[i];
        }
      std::string pathRoot;
      pathRoot = fC->getLibrary ()->getName() + "@";
      pathRoot += path;
      path = fullPath;

      // path refers to a sub instance
      std::string prefix;
      if (design->findInstance (pathRoot))
        {
          std::string p = design->findInstance (pathRoot)->getFullPathName ();
          if (strstr (p.c_str (), "."))
            {
              prefix = instance->getFullPathName () + ".";
            }
          else 
            {
              prefix =  fC->getLibrary ()->getName() + "@";
            }
        }
      else
        {
          prefix = instance->getFullPathName () + ".";
        }
      path = prefix + path;
      Value* val = m_exprBuilder.evalExpr (fC, value, instance);
      design->addDefParam (path, fC, hIdent, val);

    }
}

void
DesignElaboration::checkElaboration_ ()
{
  Design* design = m_compileDesign->getCompiler ()->getDesign ();
  design->checkDefParamUsage ();
  checkConfigurations_();
}

void DesignElaboration::checkConfigurations_() {
  SymbolTable* st = m_compileDesign->getCompiler ()->getSymbolTable ();
  for (auto& pathUseC : m_cellUseClause)
    {
      UseClause& useC = pathUseC.second;
      if (!useC.isUsed ())
        {
          FileContent* fC = useC.getFileContent ();
          Location loc (st->registerSymbol(fC->getFileName(useC.getNodeId ())), fC->Line (useC.getNodeId ()), 0, st->registerSymbol (pathUseC.first));
          Error err (ErrorDefinition::ELAB_USE_CLAUSE_IGNORED, loc);
          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
        }
    }
  for (auto& pathUseC : m_instUseClause)
    {
      UseClause& useC = pathUseC.second;
      if (!useC.isUsed ())
        {
          FileContent* fC = useC.getFileContent ();
          Location loc (st->registerSymbol(fC->getFileName(useC.getNodeId ())), fC->Line (useC.getNodeId ()), 0, st->registerSymbol (pathUseC.first));
          Error err (ErrorDefinition::ELAB_USE_CLAUSE_IGNORED, loc);
          m_compileDesign->getCompiler ()->getErrorContainer ()->addError (err);
        }
    }
}

void
DesignElaboration::reduceUnnamedBlocks_ ()
{
  Design* design = m_compileDesign->getCompiler ()->getDesign ();
  std::queue<ModuleInstance*> queue;
  for (auto instance : design->getTopLevelModuleInstances ())
    {
      queue.push (instance);
    }

  while (queue.size ())
    {
      ModuleInstance* current = queue.front ();
      queue.pop ();
      for (unsigned int i = 0; i < current->getNbChildren (); i++)
        {
          queue.push (current->getChildren (i));
        }
      FileContent* fC = current->getFileContent ();
      NodeId id = current->getNodeId ();
      VObjectType type = fC->Type (id);

      ModuleInstance* parent = current->getParent ();
      if (parent)
        {
          FileContent* fCP = parent->getFileContent ();
          NodeId idP = parent->getNodeId ();
          VObjectType typeP = fCP->Type (idP);

          if ((type == VObjectType::slConditional_generate_construct ||
               type == VObjectType::slGenerate_module_conditional_statement ||
               type == VObjectType::slLoop_generate_construct ||
               type == VObjectType::slGenerate_module_loop_statement)
              &&
              (typeP == VObjectType::slConditional_generate_construct ||
               typeP == VObjectType::slGenerate_module_conditional_statement ||
               typeP == VObjectType::slLoop_generate_construct ||
               typeP == VObjectType::slGenerate_module_loop_statement))
            {
              std::string fullModName = current->getModuleName ();
              fullModName = StringUtils::leaf (fullModName);
              std::string fullModNameP = parent->getModuleName ();
              fullModNameP = StringUtils::leaf (fullModNameP);
              if (strstr (fullModName.c_str (), "genblk"))
                {
                  if (fullModName == fullModNameP)
                    parent->getParent ()->overrideParentChild (parent->getParent (), parent, current);
                }
              else
                {
                  if (strstr (fullModNameP.c_str (), "genblk"))
                    parent->getParent ()->overrideParentChild (parent->getParent (), parent, current);
                }
            }
        }
    }
}