/*
 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:   TestbenchElaboration.cpp
 * Author: alain
 * 
 * Created on February 6, 2019, 9:01 PM
 */

#include <queue>

#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 "../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 "TestbenchElaboration.h"

using namespace SURELOG;


TestbenchElaboration::~TestbenchElaboration () { }


bool TestbenchElaboration::bindTypedefs_() {
  Compiler* compiler = m_compileDesign->getCompiler ();
  ErrorContainer* errors = compiler->getErrorContainer ();
  SymbolTable* symbols = compiler->getSymbolTable ();
  Design* design = compiler->getDesign();

  std::vector<std::pair < TypeDef*, DesignComponent*>> defs;

  for (auto file : design->getAllFileContents ())
    {
      FileContent* fC = file.second;
      for (auto typed : fC ->getTypeDefMap ())
        {
          TypeDef* typd = typed.second;
          defs.push_back (std::make_pair (typd, fC));
        }
    }

  for (auto package : design->getPackageDefinitions ())
    {
      Package* pack = package.second;
      for (auto typed : pack->getTypeDefMap ())
        {
          TypeDef* typd = typed.second;
          defs.push_back (std::make_pair (typd, pack));
        }
    }

  for (auto program_def : design->getProgramDefinitions ())
    {
      Program* program = program_def.second;
      for (auto typed : program->getTypeDefMap ())
        {
          TypeDef* typd = typed.second;
          defs.push_back (std::make_pair (typd, program));
        }
    }

  for (auto class_def : design->getClassDefinitions ())
    {
      ClassDefinition* classp = class_def.second;
      for (auto typed : classp->getTypeDefMap ())
        {
          TypeDef* typd = typed.second;
          defs.push_back (std::make_pair (typd, classp));
        }
    }


  for (auto def : defs)
    {
      TypeDef* typd = def.first;
      DesignComponent* comp = def.second;
      if (typd->getDefinition () == NULL)
        {
          DataType* def = bindTypeDef_ (typd, comp, ErrorDefinition::NO_ERROR_MESSAGE);
          if (def && (typd != def))
            {
              typd->setDefinition (def);
            }
          else
            {
              FileContent* fC = typd->getFileContent ();
              NodeId id = typd->getNodeId ();
              std::string fileName = fC->getFileName (id);
              unsigned int line = fC->Line (id);
              std::string definition_string;
              NodeId defNode = typd->getDefinitionNode ();
              VObjectType defType = fC->Type (defNode);
              if (defType == VObjectType::slStringConst)
                {
                  definition_string = fC->SymName (defNode);
                }
              Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (definition_string));
              Error err1 (ErrorDefinition::COMP_UNDEFINED_TYPE, loc1);
              errors->addError (err1);
            }
        }
    }

  
  return true;
}

bool checkValidFunction(DataType* dtype, std::string function,
                        Statement* stmt, Design* design, std::string& datatypeName)
{
  bool validFunction = true;
  VObjectType type = dtype->getType ();
  DataType* def = dtype->getDefinition ();
  if (type == VObjectType::slClass_declaration)
    {
      ClassDefinition* the_class = dynamic_cast<ClassDefinition*> (dtype);
      if (the_class)
        {
          Function* func = the_class->getFunction (function);
          if (func)
            stmt->setFunction (func);
          else
            validFunction = false;
        }
      else
        {
          the_class = dynamic_cast<ClassDefinition*> (def);
          if (the_class)
            {
              Function* func = the_class->getFunction (function);
              if (func)
                stmt->setFunction (func);
              else
                validFunction = false;
            }

        }
    }
  else if (dtype->isString_type (type))
    {
      ClassDefinition* array = design->getClassDefinition ("builtin::string");
      Function* func = array->getFunction (function);
      if (func)
        stmt->setFunction (func);
      else
        {
          datatypeName = "string";
          validFunction = false;
        }
    }
  else
    validFunction = false;
  return validFunction;
}

bool checkValidBuiltinClass_(std::string classname, std::string function, 
                             Statement* stmt, Design* design, std::string& datatypeName)
{
  bool validFunction = true;
  ClassDefinition* array = design->getClassDefinition ("builtin::" + classname);
  Function* func = array->getFunction (function);
  if (func)
    stmt->setFunction (func);
  else
    {
      datatypeName = classname;
      validFunction = false;
    }
  return validFunction;
}

void computeVarChain(FileContent* fC, NodeId nodeId, std::vector<std::string>& var_chain) {
  while (nodeId)
    {
      VObjectType type = fC->Type(nodeId);
      switch (type)
        {
        case VObjectType::slStringConst:
        {
          var_chain.push_back (fC->SymName(nodeId));
          break;
        }
        case VObjectType::slImplicit_class_handle:
        {
          NodeId child = fC->Child(nodeId);
          VObjectType childType = fC->Type(child);
          if (childType == VObjectType::slThis_keyword)
            var_chain.push_back("this");
          else if (childType == VObjectType::slSuper_keyword)
            var_chain.push_back("super");
          else 
            var_chain.push_back("UNKNOWN_TYPE");
          break;
        }
        default:
          var_chain.push_back("UNKNOWN_NAME");
          break;
        }
      nodeId = fC->Sibling(nodeId);
    }
} 

bool TestbenchElaboration::bindClasses_() {
  checkForMultipleDefinition_();
  bindBaseClasses_();
  bindDataTypes_();
  bindFunctions_();
  bindTasks_();
  return true;
}
  
bool TestbenchElaboration::checkForMultipleDefinition_() {
  Compiler* compiler = m_compileDesign->getCompiler ();
  ErrorContainer* errors = compiler->getErrorContainer ();
  SymbolTable* symbols = compiler->getSymbolTable ();
  Design* design = compiler->getDesign();
  ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions ();  

  // Check for multiple definition
  std::string prevClassName = "";
  ClassDefinition* prevClassDefinition = NULL;
  for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++)
    {
      std::string className = (*itr).first;
      ClassDefinition* classDefinition = (*itr).second;
      bool done = false;
      if (className == prevClassName)
        {
          
          FileContent* fC1 = classDefinition->getFileContents()[0];
          NodeId nodeId1 = classDefinition->getNodeIds()[0];
          std::string fileName1 = fC1->getFileName (nodeId1);
          unsigned int line1 = fC1->Line (nodeId1);
          Location loc1 (symbols->registerSymbol (fileName1), line1, 0, symbols->registerSymbol (className));

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

              FileContent* fC2 = prevClassDefinition->getFileContents ()[0];
              NodeId nodeId2 = prevClassDefinition->getNodeIds ()[0];
              std::string fileName2 = fC2->getFileName (nodeId2);
              unsigned int line2 = fC2->Line (nodeId2);
              Location loc2 (symbols->registerSymbol (fileName2), line2, 0, symbols->registerSymbol (className));

              if ((fileName1 != fileName2) || (line1 != line2))
                {
                  std::string diff;
                  if (fC1->diffTree (diff, nodeId1, fC2, nodeId2))
                    {
                      locations.push_back(loc2);
                    }
                }
              
              itr++;
              if (itr == classes.end())
                {
                  done = true;
                  break;
                }
              else 
                {
                  std::string nextClassName = (*itr).first;
                  ClassDefinition* nextClassDefinition = (*itr).second;
                  prevClassName = nextClassName;
                  prevClassDefinition = nextClassDefinition;
                  if (prevClassName != className)
                    {
                      className = prevClassName;
                      classDefinition = prevClassDefinition;
                      break;
                    }
                }             
            }
          
          if (locations.size())
            {
              Error err1 (ErrorDefinition::COMP_MULTIPLY_DEFINED_CLASS, loc1, &locations);
              errors->addError (err1);
            }                
        }
      prevClassName = className;
      prevClassDefinition = classDefinition;
      if (done)
        break;
    }
  return true;
}


bool TestbenchElaboration::bindBaseClasses_() {
  Compiler* compiler = m_compileDesign->getCompiler ();
  Design* design = compiler->getDesign();
  ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions ();
 
  // Bind base classes
  for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++)
    {
      std::string className = (*itr).first;
      ClassDefinition* classDefinition = (*itr).second;
      for (auto& class_def : classDefinition->getBaseClassMap ())
        {         
          DataType* the_def = bindDataType_(class_def.first, class_def.second->getFileContent (),
                                            class_def.second->getNodeId (),
                                            classDefinition, ErrorDefinition::COMP_UNDEFINED_BASE_CLASS);
          class_def.second = dynamic_cast<ClassDefinition*> (the_def); 
          if(class_def.second)
            {
              // Super
              DataType* thisdt = new DataType (class_def.second->getFileContent (), class_def.second->getNodeId (), class_def.second->getName (), VObjectType::slClass_declaration);
              thisdt->setDefinition (class_def.second);
              Property* prop = new Property (thisdt, classDefinition->getFileContent (), classDefinition->getNodeId(), 0, "super", false, false,
                                             false, false, false);
              classDefinition->insertProperty (prop);
            }
          else 
            {
              class_def.second = dynamic_cast<Parameter*> (the_def);
              if (class_def.second)
                {
                  // Super
                  DataType* thisdt = new DataType (class_def.second->getFileContent (), class_def.second->getNodeId (), class_def.second->getName (), VObjectType::slClass_declaration);
                  thisdt->setDefinition (class_def.second);
                  Property* prop = new Property (thisdt, classDefinition->getFileContent (), classDefinition->getNodeId (), 0, "super", false, false,
                                                 false, false, false);
                  classDefinition->insertProperty (prop);
                }
            }
        }
    }
  return true;
}

bool TestbenchElaboration::bindDataTypes_() {
  Compiler* compiler = m_compileDesign->getCompiler ();
  Design* design = compiler->getDesign();
  ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions ();  

   // Bind data types
   for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++)
    {
      std::string className = (*itr).first;
      ClassDefinition* classDefinition = (*itr).second;

      for (auto& datatype : classDefinition->getUsedDataTypeMap ())
        {
          std::string dataTypeName = datatype.first;
          DataType* dtype = datatype.second;
          if (dtype->getDefinition ())
            continue;
          VObjectType type = dtype->getType ();
          if (type == VObjectType::slStringConst ||
              type == VObjectType::slNull_rule ||
              type == VObjectType::slClass_scope)
            {
              DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), dtype->getNodeId (),
                                                 classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE);
              if (the_def != dtype)
                dtype->setDefinition (the_def);
            }
        }
       for (auto& func : classDefinition->getFunctionMap ())
        {
          for (auto& datatype : func.second->getUsedDataTypeMap ())
            {
              std::string dataTypeName = datatype.first;
              DataType* dtype = datatype.second;
              if (dtype->getDefinition ())
                continue;
              VObjectType type = dtype->getType ();
              if (type == VObjectType::slStringConst ||
                  type == VObjectType::slNull_rule ||
                  type == VObjectType::slClass_scope)
                {
                  DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), dtype->getNodeId (),
                                                     classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE);
                  if (the_def != dtype)
                    dtype->setDefinition (the_def);
                }
            }
         }
     }
  return true;
}


bool TestbenchElaboration::bindFunctions_() {
  bindFunctionReturnTypesAndParamaters_();
  bindFunctionBodies_();
  return true;
}

bool TestbenchElaboration::bindFunctionReturnTypesAndParamaters_() {  
  Compiler* compiler = m_compileDesign->getCompiler ();
  ErrorContainer* errors = compiler->getErrorContainer ();
  SymbolTable* symbols = compiler->getSymbolTable ();
  Design* design = compiler->getDesign();
  ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions ();  
  
   // Bind Function return values, parameters and body
   for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++)
    {
      std::string className = (*itr).first;
      ClassDefinition* classDefinition = (*itr).second;
      for (auto& func : classDefinition->getFunctionMap ())
        {
          DataType* dtype = func.second->getReturnType ();
          std::string dataTypeName = dtype->getName ();
          if (dtype->getDefinition ())
            continue;
          if (dtype->getFileContent () == NULL)
            continue;
          if (dtype->getType () == VObjectType::slStringConst) 
            {
              DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), func.second->getNodeId (),
                                                 classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE);
              if (the_def != dtype)
                dtype->setDefinition (the_def);
            }
          for (auto& param : func.second->getParams ())
            {
              DataType* dtype = param->getDataType ();
              std::string dataTypeName = dtype->getName ();
              if (dtype->getDefinition ())
                continue;
              if (dtype->getFileContent () == NULL)
                continue;
              if (dtype->getType () == VObjectType::slStringConst)
                {
                  DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), param->getNodeId (),
                                                     classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE);
                  if (the_def != dtype)
                    dtype->setDefinition (the_def);
                  if (the_def && the_def->isParameter ())
                    continue;
                  Value* value = param->getDefault ();
                  if (value)
                    {
                      if (!dtype->isCompatible (value))
                        {
                          std::string name = param->getName ();
                          std::string typeName = dtype->getName ();
                          NodeId p = param->getNodeId ();
                          FileContent* fC = dtype->getFileContent ();
                          std::string fileName = fC->getFileName (p);
                          unsigned int line = fC->Line (p);
                          Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (name + " of type " + typeName));
                          std::string exp;
                          if (value->getType () == Value::String)
                            exp = value->getValueS ();
                          else if (value->getType () == Value::Double)
                            exp = std::to_string (value->getValueD (0));
                          else
                            exp = std::to_string (value->getValueL (0));
                          Location loc2 (0, 0, 0, symbols->registerSymbol (exp));
                          Error err1 (ErrorDefinition::COMP_INCOMPATIBLE_TYPES, loc1, loc2);
                          errors->addError (err1);
                        }
                    }
                }
            }
        }
     }
  return true;
}

bool TestbenchElaboration::bindSubRoutineCall_(ClassDefinition* classDefinition, Statement* stmt, Design* design, SymbolTable* symbols, ErrorContainer* errors)
{
  std::string datatypeName;
  SubRoutineCallStmt* st = dynamic_cast<SubRoutineCallStmt*> (stmt);
  std::vector<std::string> var_chain = st->getVarChainNames ();
  std::string function = st->getFunc ();
  bool validFunction = true;
  DataType* dtype = NULL;
  Variable* the_obj = NULL;
  if (st->isStatic ())
    the_obj = locateStaticVariable_ (var_chain, st->getFileContent (), st->getNodeId (), stmt->getScope (), classDefinition, ErrorDefinition::ELAB_UNDEF_VARIABLE);
  else
    the_obj = locateVariable_ (var_chain, st->getFileContent (), st->getNodeId (), stmt->getScope (), classDefinition, ErrorDefinition::ELAB_UNDEF_VARIABLE);

  if (the_obj)
    {
      dtype = the_obj->getDataType ();
      if (dtype == NULL)
        return true;
      VObjectType type = dtype->getType ();
      DataType* def = dtype->getDefinition ();

      if (type == VObjectType::slClass_declaration)
        {
          validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName);
        }
      else if (dtype->isNumber (type) || dtype->isInteger_type (type) ||
               dtype->isNon_integer_type (type) || dtype->isString_type (type))
        {
          if (def)
            {
              type = def->getType ();
              dtype = def;
            }

          NodeId range = the_obj->getRange ();
          if (range)
            {
              VObjectType rangeType = the_obj->getFileContent ()->Type (range);

              if (rangeType == VObjectType::slUnsized_dimension)
                {
                  // Vector
                  validFunction = checkValidBuiltinClass_("array", function, stmt, design, datatypeName);
                }
              else if (rangeType == VObjectType::slVariable_dimension)
                {
                  FileContent* sfC = the_obj->getFileContent ();
                  NodeId subRange = sfC->Child (range);
                  VObjectType the_type = sfC->Type (subRange);
                  if (the_type == VObjectType::slQueue_dimension)
                    {
                      // Queue   

                      // foreach (darray[id]) darray[id].func() 
                      NodeId tmp = stmt->getNodeId ();
                      tmp = sfC->Child (tmp);
                      tmp = sfC->Sibling (tmp);
                      VObjectType t = sfC->Type (tmp);
                      if ((t == VObjectType::slConstant_bit_select) && sfC->Child (tmp))
                        {
                          // there is an actual array index 
                          if (type == VObjectType::slClass_declaration)
                            {
                              validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName);
                            }
                        }
                      else
                        {
                          validFunction = checkValidBuiltinClass_("queue", function, stmt, design, datatypeName);
                        }
                    }
                  else if (the_type == VObjectType::slUnpacked_dimension)
                    {
                      // foreach (darray[id]) darray[id].func() 
                      NodeId subroutine_call = stmt->getNodeId ();
                      NodeId var_id = sfC->Child (subroutine_call);
                      NodeId constant_bit_select = sfC->Sibling (var_id);
                      VObjectType t = sfC->Type (constant_bit_select);
                      NodeId select_id = sfC->Child (constant_bit_select);
                      if ((t == VObjectType::slConstant_bit_select) && select_id)
                        {
                          validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName);
                        }
                      else
                        {
                          validFunction = checkValidBuiltinClass_("queue", function, stmt, design, datatypeName);
                        }
                    }
                }
            }
          else
            {
              validFunction = checkValidFunction (dtype, function, stmt, design, datatypeName);
            }
        }
    }
  if (var_chain.size () == 0)
    {
      if (st->isSystemCall ())
        {
          validFunction = checkValidBuiltinClass_("system", function, stmt, design, datatypeName);
          if (!validFunction)
            { 
              FileContent* fC = st->getFileContent ();
              NodeId p = st->getNodeId ();
              std::string fileName = fC->getFileName (p);
              unsigned int line = fC->Line (p);
              Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol (function));
              Error err1 (ErrorDefinition::COMP_UNDEFINED_SYSTEM_FUNCTION, loc1);
              errors->addError (err1);
              return true;
            }
        }
      else
        {
          Function* func = classDefinition->getFunction (function);
          if (func)
            stmt->setFunction (func);
          else
            {
              validFunction = false;
              dtype = classDefinition;
            }
        }
    }

  if (validFunction == false)
    {
      if (dtype->isParameter ())
        {
          return true;
        }
      std::string name;
      for (auto v : var_chain) name += v + ".";
      if (name.size ())
        name = name.substr (0, name.size () - 1);
      while (dtype && dtype->getDefinition ())
        {
          dtype = dtype->getDefinition ();
        }
      if (name == "")
        {
          name = "this";
        }
      std::string typeName = dtype->getName ();
      if (datatypeName != "")
        typeName = datatypeName;
      NodeId p = st->getNodeId ();
      FileContent* fC = st->getFileContent ();
      std::string fileName = fC->getFileName (p);
      unsigned int line = fC->Line (p);
      Location loc1 (symbols->registerSymbol (fileName), line, 0, symbols->registerSymbol ("\"" + name + "\"" + " of type " + typeName));
      FileContent* fC2 = dtype->getFileContent ();
      std::string fileName2 = fC2->getFileName (dtype->getNodeId ());
      unsigned int line2 = fC2->Line (dtype->getNodeId ());
      Location loc2 (symbols->registerSymbol (fileName2), line2, 0, symbols->registerSymbol (function));
      Error err1 (ErrorDefinition::COMP_NO_METHOD_FOR_TYPE, loc1, loc2);
      errors->addError (err1);
    }
  return true;
}


bool TestbenchElaboration::bindForLoop_(ClassDefinition* classDefinition, Statement* stmt, ForLoopStmt* st) {
  FileContent* sfC = st->getFileContent ();
  NodeId fid = st->getNodeId ();
  VObjectType itr_type = st->getIteratorType (); 
  DataType* itrDataType = new DataType (sfC, fid, "integer", itr_type);
  for (auto itrId : st->getIteratorIds ())
    {
      Variable* var = new Variable (itrDataType, sfC, itrId.first, 0, sfC->SymName (itrId.first));
      st->getParentScope ()->addVariable (var);
    }
  return true;
}

bool TestbenchElaboration::bindForeachLoop_(ClassDefinition* classDefinition, Statement* stmt, ForeachLoopStmt* st) {

  NodeId arrayId = st->getArrayId ();
  FileContent* sfC = st->getFileContent ();
  std::vector<std::string> var_chain;
  computeVarChain (sfC, arrayId, var_chain);
  Variable* arrayVar = locateVariable_ (var_chain, sfC, arrayId, stmt->getScope (), classDefinition, ErrorDefinition::ELAB_UNDEF_VARIABLE);
  if (arrayVar)
    {
      NodeId range = arrayVar->getRange ();
      NodeId rangeTypeId = range;
      DataType* itrDataType = NULL;
      while (range)
        {
          rangeTypeId = range;
          range = sfC->Child (rangeTypeId);
        }
      VObjectType rangeType = sfC->Type (rangeTypeId);
      if (rangeType == VObjectType::slStringConst)
        {
          std::string dataTypeName = sfC->SymName (rangeTypeId);
          itrDataType = bindDataType_ (dataTypeName, sfC, rangeTypeId,
                                       classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE);
        }
      else if (rangeType == VObjectType::slAssociative_dimension ||
               rangeType == VObjectType::slQueue_dimension)
        {
          // Integer Type
          itrDataType = new DataType (sfC, arrayId, "integer", VObjectType::slIntegerAtomType_Int);
        }

      for (auto itrId : st->getIteratorIds ())
        {
          Variable* var = new Variable (itrDataType, sfC, itrId, 0, sfC->SymName (itrId));
          st->getParentScope ()->addVariable (var);
        }
    }
  return true;
}

bool TestbenchElaboration::bindFunctionBodies_() {
  Compiler* compiler = m_compileDesign->getCompiler ();
  ErrorContainer* errors = compiler->getErrorContainer ();
  SymbolTable* symbols = compiler->getSymbolTable ();
  Design* design = compiler->getDesign();
  ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions ();  
  
   // Bind Function return values, parameters and body
   for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++)
    {
      std::string className = (*itr).first;
      ClassDefinition* classDefinition = (*itr).second;
      for (auto& func : classDefinition->getFunctionMap ())
        {
          // Skip binding of parameterized classes
          if (!classDefinition->hasCompleteBaseSpecification ())
            continue;

          std::queue<Statement*> stmts;
          for (Statement* stmt : func.second->getStmts ())
            stmts.push (stmt);
          
          while (stmts.size())
            {
              Statement* stmt = stmts.front ();
              stmts.pop();
              for (Statement* stmt1 : stmt->getStatements())
                stmts.push (stmt1);
              VObjectType stmt_type = stmt->getType();
              switch (stmt_type)
                {
                case VObjectType::slPs_or_hierarchical_array_identifier:
                  {
                    // Foreach loop
                    ForeachLoopStmt* st = dynamic_cast<ForeachLoopStmt*> (stmt);
                    if (st)
                      {
                        bindForeachLoop_(classDefinition, stmt, st);
                      }
                    break;
                  }
                case VObjectType::slFor_initialization:
                {
                    // For loop
                    ForLoopStmt* st = dynamic_cast<ForLoopStmt*> (stmt);
                    if (st)
                      {
                        bindForLoop_(classDefinition, stmt, st);
                      }
                    break;
                }
                case VObjectType::slSubroutine_call_statement:
                    bindSubRoutineCall_(classDefinition, stmt, design, symbols, errors);
                    break;                 
                default:
                  break;
                }
            }
        }
     }
  return true;
}

bool TestbenchElaboration::bindTasks_() {
  Compiler* compiler = m_compileDesign->getCompiler ();
  //ErrorContainer* errors = compiler->getErrorContainer ();
  //SymbolTable* symbols = compiler->getSymbolTable ();
  Design* design = compiler->getDesign();
  ClassNameClassDefinitionMultiMap classes = design->getClassDefinitions ();  
   
   // Bind Tasks parameters and body
   for (ClassNameClassDefinitionMultiMap::iterator itr = classes.begin(); itr != classes.end(); itr++)
     {
      std::string className = (*itr).first;
      ClassDefinition* classDefinition = (*itr).second;
  
      // Bind Tasks parameters
      for (auto& func : classDefinition->getTaskMap ())
        {
          for (auto param : func.second->getParams ())
            {
              DataType* dtype = param->getDataType ();
              std::string dataTypeName = dtype->getName ();
              if (dtype->getDefinition ())
                continue;
              if (dtype->getFileContent () == NULL)
                continue;
              if (dtype->getType () == VObjectType::slStringConst)
                {
                  DataType* the_def = bindDataType_ (dataTypeName, dtype->getFileContent (), param->getNodeId (),
                                                     classDefinition, ErrorDefinition::COMP_UNDEFINED_TYPE);
                  if (the_def != dtype)
                    dtype->setDefinition (the_def);
                }
            }
        }
     }
  return true;
}