src/DesignCompile/CompileClass.cpp

/*
 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:   CompileClass.cpp
 * Author: alain
 *
 * Created on June 7, 2018, 10:26 PM
 */
#include "../SourceCompile/VObjectTypes.h"
#include "../Design/VObject.h"
#include "../Library/Library.h"
#include "../Design/Signal.h"
#include "../Design/FileContent.h"
#include "../Design/ClockingBlock.h"
#include "../SourceCompile/SymbolTable.h"
#include "../ErrorReporting/Error.h"
#include "../ErrorReporting/Location.h"
#include "../ErrorReporting/Error.h"
#include "../CommandLine/CommandLineParser.hpp"
#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 "../DesignCompile/CompileDesign.h"
#include "../Testbench/ClassDefinition.h"
#include "CompileClass.h"

using namespace SURELOG;

CompileClass::~CompileClass() {}

int FunctorCompileClass::operator()() const {
  CompileClass* instance =
      new CompileClass(m_compileDesign, m_class, m_design, m_symbols, m_errors);
  instance->compile();
  delete instance;
  return true;
}

bool CompileClass::compile() {
  FileContent* fC = m_class->m_fileContents[0];
  NodeId nodeId = m_class->m_nodeIds[0];

  std::string fileName = fC->getFileName(nodeId);
  if (strstr(fileName.c_str(), "builtin.sv")) {
    fileName = "builtin.sv";
  }
  Location loc(m_symbols->registerSymbol(fileName),
               fC->Line(nodeId), 0,
               m_symbols->registerSymbol(m_class->getName()));

  Error err1(ErrorDefinition::COMP_COMPILE_CLASS, loc);
  ErrorContainer* errors = new ErrorContainer(m_symbols);
  errors->regiterCmdLine(
      m_compileDesign->getCompiler()->getCommandLineParser());
  errors->addError(err1);
  errors->printMessage(
      err1,
      m_compileDesign->getCompiler()->getCommandLineParser()->muteStdout());
  delete errors;
  if (fC->getSize() == 0) return true;

  // Package imports
  std::vector<FileCNodeId> pack_imports;
  // - Local file imports
  for (auto import : fC->getObjects(VObjectType::slPackage_import_item)) {
    pack_imports.push_back(import);
  }
  // - Parent container imports
  DesignComponent* container = m_class->getContainer();
  if (container) {
    // FileCNodeId itself(container->getFileContents ()[0],
    // container->getNodeIds ()[0]); pack_imports.push_back(itself);
    for (auto import :
         container->getObjects(VObjectType::slPackage_import_item)) {
      pack_imports.push_back(import);
    }
  }

  for (auto pack_import : pack_imports) {
    FileContent* pack_fC = pack_import.fC;
    NodeId pack_id = pack_import.nodeId;
    m_helper.importPackage(m_class, m_design, pack_fC, pack_id);
  }

  compile_class_parameters_(fC, nodeId);

  // This
  DataType* thisdt =
      new DataType(fC, nodeId, "this", VObjectType::slClass_declaration);
  thisdt->setDefinition(m_class);
  Property* prop = new Property(thisdt, fC, nodeId, 0, "this", false, false,
                                false, false, false);
  m_class->insertProperty(prop);

  VObject current = fC->Object(fC->getSize() - 2);
  NodeId id = nodeId;
  if (!id) return false;
  std::stack<NodeId> stack;
  stack.push(id);
  bool inFunction_body_declaration = false;
  bool inTask_body_declaration = false;
  while (stack.size()) {
    bool skipGuts = false;
    id = stack.top();
    stack.pop();
    current = fC->Object(id);
    VObjectType type = fC->Type(id);
    switch (type) {
      case VObjectType::slPackage_import_item: {
        m_helper.importPackage(m_class, m_design, fC, id);
        break;
      }
      case VObjectType::slClass_constructor_declaration: {
        inFunction_body_declaration = true;
        break;
      }
      case VObjectType::slFunction_body_declaration: {
        inFunction_body_declaration = true;
        break;
      }
      case VObjectType::slEndfunction: {
        inFunction_body_declaration = false;
        break;
      }
      case VObjectType::slTask_body_declaration: {
        inTask_body_declaration = true;
        break;
      }
      case VObjectType::slEndtask: {
        inTask_body_declaration = false;
        break;
      }
      case VObjectType::slClass_property:
        if (inFunction_body_declaration || inTask_body_declaration) break;
        compile_class_property_(fC, id);
        break;
      case VObjectType::slClass_constraint:
        compile_class_constraint_(fC, id);
        break;
      case VObjectType::slClass_declaration:
        if (id != nodeId) {
          compile_class_declaration_(fC, id);
          if (current.m_sibling) stack.push(current.m_sibling);
          continue;
        }
        break;
      case VObjectType::slCovergroup_declaration:
        compile_covergroup_declaration_(fC, id);
        break;
      case VObjectType::slLocal_parameter_declaration:
        compile_local_parameter_declaration_(fC, id);
        break;
      case VObjectType::slParameter_declaration:
        compile_parameter_declaration_(fC, id);
        break;
      case VObjectType::slClass_method:
        compile_class_method_(fC, id);
        skipGuts = true;
        break;
      case VObjectType::slClass_type:
        compile_class_type_(fC, id);
      default:
        break;
    }

    if (current.m_sibling) stack.push(current.m_sibling);
    if (!skipGuts)
      if (current.m_child) stack.push(current.m_child);
  }

  // Default constructor
  DataType* returnType = new DataType();
  FunctionMethod* method =
      new FunctionMethod(m_class, fC, nodeId, "new", returnType, false, false,
                         false, false, false, false);
  method->compile(m_helper);
  Function* prevDef = m_class->getFunction("new");
  if (!prevDef) {
    m_class->insertFunction(method);
  }

  return true;
}

bool CompileClass::compile_class_property_(FileContent* fC, NodeId id) {
  NodeId data_declaration = fC->Child(id);
  NodeId var_decl = fC->Child(data_declaration);
  VObjectType type = fC->Type(data_declaration);
  bool is_local = false;
  bool is_static = false;
  bool is_protected = false;
  bool is_rand = false;
  bool is_randc = false;
  while ((type == VObjectType::slPropQualifier_ClassItem) ||
         (type == VObjectType::slPropQualifier_Rand) ||
         (type == VObjectType::slPropQualifier_Randc)) {
    NodeId qualifier = fC->Child(data_declaration);
    VObjectType qualType = fC->Type(qualifier);
    if (qualType == VObjectType::slClassItemQualifier_Protected)
      is_protected = true;
    if (qualType == VObjectType::slClassItemQualifier_Static) is_static = true;
    if (qualType == VObjectType::slClassItemQualifier_Local) is_local = true;
    if (type == VObjectType::slPropQualifier_Rand) is_rand = true;
    if (type == VObjectType::slPropQualifier_Randc) is_randc = true;
    data_declaration = fC->Sibling(data_declaration);
    type = fC->Type(data_declaration);
    var_decl = fC->Child(data_declaration);
  }

  if (type == VObjectType::slData_declaration) {
    /*
   n<A> u<3> t<StringConst> p<37> s<12> l<5>
   n<> u<4> t<IntegerAtomType_Int> p<5> l<6>
   n<> u<5> t<Data_type> p<9> c<4> s<8> l<6>
   n<size> u<6> t<StringConst> p<7> l<6>
   n<> u<7> t<Variable_decl_assignment> p<8> c<6> l<6>
   n<> u<8> t<List_of_variable_decl_assignments> p<9> c<7> l<6>
   n<> u<9> t<Variable_declaration> p<10> c<5> l<6>
   n<> u<10> t<Data_declaration> p<11> c<9> l<6>
   n<> u<11> t<Class_property> p<12> c<10> l<6>
   n<> u<12> t<Class_item> p<37> c<11> s<35> l<6>
     */
    VObjectType var_type = fC->Type(var_decl);
    if (var_type == VObjectType::slVariable_declaration) {
      NodeId data_type = fC->Child(var_decl);
      NodeId node_type = fC->Child(data_type);

      VObjectType the_type = fC->Type(node_type);
      std::string typeName;
      if (the_type == VObjectType::slStringConst) {
        typeName = fC->SymName(node_type);
      } else if (the_type == VObjectType::slClass_scope) {
        NodeId class_type = fC->Child(node_type);
        NodeId class_name = fC->Child(class_type);
        typeName = fC->SymName(class_name);
        typeName += "::";
        NodeId symb_id = fC->Sibling(node_type);
        typeName += fC->SymName(symb_id);
      } else {
        typeName = VObject::getTypeName(the_type);
      }
      DataType* datatype = m_class->getUsedDataType(typeName);
      if (!datatype) {
        DataType* type =
            new DataType(fC, node_type, typeName, fC->Type(node_type));
        m_class->insertUsedDataType(typeName, type);
        datatype = m_class->getUsedDataType(typeName);
      }

      NodeId list_of_variable_decl_assignments = fC->Sibling(data_type);
      NodeId variable_decl_assignment =
          fC->Child(list_of_variable_decl_assignments);
      while (variable_decl_assignment) {
        NodeId var = fC->Child(variable_decl_assignment);
        NodeId range = fC->Sibling(var);
        std::string varName = fC->SymName(var);

        Property* previous = m_class->getProperty(varName);
        if (previous) {
          Location loc1(m_symbols->registerSymbol(fC->getFileName(var)),
                        fC->Line(var), 0, m_symbols->registerSymbol(varName));
          FileContent* prevFile = previous->getFileContent();
          NodeId prevNode = previous->getNodeId();
          Location loc2(
              m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
              prevFile->Line(prevNode), 0, m_symbols->registerSymbol(varName));
          Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_PROPERTY, loc1,
                    loc2);
          m_errors->addError(err);
        }

        Property* prop =
            new Property(datatype, fC, var, range, varName, is_local, is_static,
                         is_protected, is_rand, is_randc);
        m_class->insertProperty(prop);

        variable_decl_assignment = fC->Sibling(variable_decl_assignment);
      }
    } else if (var_type == VObjectType::slType_declaration) {
      compile_type_declaration_(fC, data_declaration);
    }
  }

  return true;
}

bool CompileClass::compile_class_method_(FileContent* fC, NodeId id) {
  /*
    n<> u<8> t<MethodQualifier_Virtual> p<21> s<20> l<12>
    n<> u<9> t<Function_data_type> p<10> l<12>
    n<> u<10> t<Function_data_type_or_implicit> p<19> c<9> s<11> l<12>
    n<print_tree1> u<11> t<StringConst> p<19> s<17> l<12>
    n<> u<12> t<IntegerAtomType_Int> p<13> l<12>
    n<> u<13> t<Data_type> p<14> c<12> l<12>
    n<> u<14> t<Data_type_or_implicit> p<16> c<13> s<15> l<12>
    n<a> u<15> t<StringConst> p<16> l<12>
    n<> u<16> t<Tf_port_item> p<17> c<14> l<12>
    n<> u<17> t<Tf_port_list> p<19> c<16> s<18> l<12>
    n<> u<18> t<Endfunction> p<19> l<14>
    n<> u<19> t<Function_body_declaration> p<20> c<10> l<12>
    n<> u<20> t<Function_declaration> p<21> c<19> l<12>
    n<> u<21> t<Class_method> p<22> c<8> l<12>
   */
  NodeId func_decl = fC->Child(id);
  VObjectType func_type = fC->Type(func_decl);
  std::string funcName;
  std::string taskName;
  bool is_virtual = false;
  bool is_extern = false;
  bool is_static = false;
  bool is_local = false;
  bool is_protected = false;
  bool is_pure = false;
  DataType* returnType = new DataType();
  while ((func_type == VObjectType::slMethodQualifier_Virtual) ||
         (func_type == VObjectType::slMethodQualifier_ClassItem) ||
         (func_type == VObjectType::slPure_virtual_qualifier) ||
         (func_type == VObjectType::slExtern_qualifier) ||
         (func_type == VObjectType::slClassItemQualifier_Protected)) {
    if (func_type == VObjectType::slMethodQualifier_Virtual) {
      is_virtual = true;
      func_decl = fC->Sibling(func_decl);
      func_type = fC->Type(func_decl);
    }
    if (func_type == VObjectType::slClassItemQualifier_Protected) {
      is_protected = true;
      func_decl = fC->Sibling(func_decl);
      func_type = fC->Type(func_decl);
    }
    if (func_type == VObjectType::slPure_virtual_qualifier) {
      is_virtual = true;
      is_pure = true;
      func_decl = fC->Sibling(func_decl);
      func_type = fC->Type(func_decl);
    }
    if (func_type == VObjectType::slExtern_qualifier) {
      is_extern = true;
      func_decl = fC->Sibling(func_decl);
      func_type = fC->Type(func_decl);
    }
    if (func_type == VObjectType::slMethodQualifier_ClassItem) {
      NodeId qualifier = fC->Child(func_decl);
      VObjectType type = fC->Type(qualifier);
      if (type == VObjectType::slClassItemQualifier_Static) is_static = true;
      if (type == VObjectType::slClassItemQualifier_Local) is_local = true;
      if (type == VObjectType::slClassItemQualifier_Protected)
        is_protected = true;
      func_decl = fC->Sibling(func_decl);
      func_type = fC->Type(func_decl);
    }
  }
  if (func_type == VObjectType::slFunction_declaration) {
    NodeId func_body_decl = fC->Child(func_decl);
    NodeId function_data_type_or_implicit = fC->Child(func_body_decl);
    NodeId function_data_type = fC->Child(function_data_type_or_implicit);
    NodeId data_type = fC->Child(function_data_type);
    NodeId type = fC->Child(data_type);
    VObjectType the_type = fC->Type(type);
    std::string typeName;
    if (the_type == VObjectType::slStringConst) {
      typeName = fC->SymName(type);
    } else {
      typeName = VObject::getTypeName(the_type);
    }
    returnType->init(fC, type, typeName, fC->Type(type));
    NodeId function_name = fC->Sibling(function_data_type_or_implicit);
    funcName = fC->SymName(function_name);

  } else if (func_type == VObjectType::slTask_declaration) {
    /*
     n<cfg_dut> u<143> t<StringConst> p<146> s<144> l<37>
     n<> u<144> t<Endtask> p<146> s<145> l<39>
     n<cfg_dut> u<145> t<StringConst> p<146> l<39>
     n<> u<146> t<Task_body_declaration> p<147> c<143> l<37>
     n<> u<147> t<Task_declaration> p<148> c<146> l<37>
     n<> u<148> t<Class_method> p<149> c<147> l<37>
     */
    NodeId task_body_decl = fC->Child(func_decl);
    NodeId task_name = fC->Child(task_body_decl);
    taskName = fC->SymName(task_name);
  } else if (func_type == VObjectType::slMethod_prototype) {
    /*
     n<> u<65> t<IntVec_TypeBit> p<66> l<37>
     n<> u<66> t<Data_type> p<67> c<65> l<37>
     n<> u<67> t<Function_data_type> p<69> c<66> s<68> l<37>
     n<is_active> u<68> t<StringConst> p<69> l<37>
     n<> u<69> t<Function_prototype> p<70> c<67> l<37>
     n<> u<70> t<Method_prototype> p<71> c<69> l<37>
     n<> u<71> t<Class_method> p<72> c<70> l<37>
     */
    NodeId func_prototype = fC->Child(func_decl);
    if (fC->Type(func_prototype) == VObjectType::slTask_prototype) {
      NodeId task_name = fC->Child(func_prototype);
      taskName = fC->SymName(task_name);
    } else {
      NodeId function_data_type = fC->Child(func_prototype);
      NodeId data_type = fC->Child(function_data_type);
      NodeId type = fC->Child(data_type);
      VObjectType the_type = fC->Type(type);
      std::string typeName;
      if (the_type == VObjectType::slStringConst) {
        typeName = fC->SymName(type);
      } else {
        typeName = VObject::getTypeName(the_type);
      }
      returnType->init(fC, type, typeName, fC->Type(type));
      NodeId function_name = fC->Sibling(function_data_type);
      funcName = fC->SymName(function_name);
    }
    is_extern = true;
  } else if (func_type == VObjectType::slClass_constructor_declaration) {
    funcName = "new";
    returnType->init(fC, 0, "void", VObjectType::slNoType);
  } else if (func_type == VObjectType::slClass_constructor_prototype) {
    funcName = "new";
  } else {
    funcName = "UNRECOGNIZED_METHOD_TYPE";
  }
  if (taskName != "") {
    TaskMethod* method = new TaskMethod(m_class, fC, id, taskName, is_extern);
    method->compile(m_helper);
    TaskMethod* prevDef = m_class->getTask(taskName);
    if (prevDef) {
      Location loc1(m_symbols->registerSymbol(fC->getFileName(id)),
                    fC->Line(id), 0, m_symbols->registerSymbol(taskName));
      FileContent* prevFile = prevDef->getFileContent();
      NodeId prevNode = prevDef->getNodeId();
      Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                    prevFile->Line(prevNode), 0,
                    m_symbols->registerSymbol(taskName));
      Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_TASK, loc1, loc2);
      m_errors->addError(err);
    }
    m_class->insertTask(method);
  } else {
    FunctionMethod* method = new FunctionMethod(
        m_class, fC, id, funcName, returnType, is_virtual, is_extern, is_static,
        is_local, is_protected, is_pure);
    Variable* variable = new Variable(returnType, fC, id, 0, funcName);
    method->addVariable(variable);
    method->compile(m_helper);
    Function* prevDef = m_class->getFunction(funcName);
    if (prevDef) {
      Location loc1(m_symbols->registerSymbol(fC->getFileName(id)),
                    fC->Line(id), 0, m_symbols->registerSymbol(funcName));
      FileContent* prevFile = prevDef->getFileContent();
      NodeId prevNode = prevDef->getNodeId();
      Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                    prevFile->Line(prevNode), 0,
                    m_symbols->registerSymbol(funcName));
      Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_FUNCTION, loc1, loc2);
      m_errors->addError(err);
    }
    m_class->insertFunction(method);
  }
  return true;
}

bool CompileClass::compile_class_constraint_(FileContent* fC,
                                             NodeId class_constraint) {
  NodeId constraint_prototype = fC->Child(class_constraint);
  NodeId constraint_name = fC->Child(constraint_prototype);
  std::string constName = fC->SymName(constraint_name);
  Constraint* prevDef = m_class->getConstraint(constName);
  if (prevDef) {
    Location loc1(m_symbols->registerSymbol(fC->getFileName(class_constraint)),
                  fC->Line(class_constraint), 0,
                  m_symbols->registerSymbol(constName));
    FileContent* prevFile = prevDef->getFileContent();
    NodeId prevNode = prevDef->getNodeId();
    Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                  prevFile->Line(prevNode), 0,
                  m_symbols->registerSymbol(constName));
    Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_CONSTRAINT, loc1, loc2);
    m_errors->addError(err);
  }
  Constraint* constraint = new Constraint(fC, class_constraint, constName);
  m_class->insertConstraint(constraint);

  return true;
}

bool CompileClass::compile_type_declaration_(FileContent* fC, NodeId id) {
  /*
    n<> u<8> t<IntegerAtomType_Int> p<9> l<3>
    n<> u<9> t<Data_type> p<11> c<8> s<10> l<3>
    n<my_int> u<10> t<StringConst> p<11> l<3>
    n<> u<11> t<Type_declaration> p<12> c<9> l<3>
    n<> u<12> t<Data_declaration> p<13> c<11> l<3>
    n<> u<13> t<Class_property> p<14> c<12> l<3>
  */
  m_helper.compileTypeDef(m_class, fC, id);

  return true;
}

bool CompileClass::compile_class_declaration_(FileContent* fC, NodeId id) {
  NodeId class_name_id = fC->Child(id);
  std::string class_name =
      m_class->getName() + "::" + fC->SymName(class_name_id);
  ClassDefinition* prevDef = m_class->getClass(class_name);
  if (prevDef) {
    Location loc1(m_symbols->registerSymbol(fC->getFileName(class_name_id)),
                  fC->Line(class_name_id), 0,
                  m_symbols->registerSymbol(class_name));
    FileContent* prevFile = prevDef->getFileContent();
    NodeId prevNode = prevDef->getNodeId();
    Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                  prevFile->Line(prevNode), 0,
                  m_symbols->registerSymbol(class_name));
    Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_INNER_CLASS, loc1, loc2);
    m_errors->addError(err);
  }

  ClassDefinition* the_class =
      new ClassDefinition(class_name, m_class->getLibrary(),
                          m_class->getContainer(), fC, class_name_id, m_class);
  m_class->insertClass(the_class);

  CompileClass* instance = new CompileClass(m_compileDesign, the_class,
                                            m_design, m_symbols, m_errors);
  instance->compile();
  delete instance;

  return true;
}

bool CompileClass::compile_covergroup_declaration_(FileContent* fC, NodeId id) {
  NodeId covergroup_name = fC->Child(id);
  std::string covergroupName = fC->SymName(covergroup_name);
  CoverGroupDefinition* prevDef = m_class->getCoverGroup(covergroupName);
  if (prevDef) {
    Location loc1(m_symbols->registerSymbol(fC->getFileName(covergroup_name)),
                  fC->Line(covergroup_name), 0,
                  m_symbols->registerSymbol(covergroupName));
    FileContent* prevFile = prevDef->getFileContent();
    NodeId prevNode = prevDef->getNodeId();
    Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                  prevFile->Line(prevNode), 0,
                  m_symbols->registerSymbol(covergroupName));
    Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_COVERGROUP, loc1, loc2);
    m_errors->addError(err);
  }
  CoverGroupDefinition* covergroup =
      new CoverGroupDefinition(fC, id, covergroupName);
  m_class->insertCoverGroup(covergroup);

  return true;
}

bool CompileClass::compile_local_parameter_declaration_(FileContent* fC,
                                                        NodeId id) {
  /*
   n<> u<8> t<IntegerAtomType_Int> p<9> l<3>
   n<> u<9> t<Data_type> p<10> c<8> l<3>
   n<> u<10> t<Data_type_or_implicit> p<20> c<9> s<19> l<3>
   n<FOO> u<11> t<StringConst> p<18> s<17> l<3>
   n<3> u<12> t<IntConst> p<13> l<3>
   n<> u<13> t<Primary_literal> p<14> c<12> l<3>
   n<> u<14> t<Constant_primary> p<15> c<13> l<3>
   n<> u<15> t<Constant_expression> p<16> c<14> l<3>
   n<> u<16> t<Constant_mintypmax_expression> p<17> c<15> l<3>
   n<> u<17> t<Constant_param_expression> p<18> c<16> l<3>
   n<> u<18> t<Param_assignment> p<19> c<11> l<3>
   n<> u<19> t<List_of_param_assignments> p<20> c<18> l<3>
   n<> u<20> t<Local_parameter_declaration> p<21> c<10> l<3>
  */

  NodeId data_type_or_implicit = fC->Child(id);
  NodeId list_of_param_assignments = fC->Sibling(data_type_or_implicit);
  NodeId param_assignment = fC->Child(list_of_param_assignments);
  while (param_assignment) {
    NodeId var = fC->Child(param_assignment);
    std::string name = fC->SymName(var);
    std::pair<FileCNodeId, DesignComponent*>* prevDef =
        m_class->getNamedObject(name);
    if (prevDef) {
      Location loc1(m_symbols->registerSymbol(fC->getFileName(var)),
                    fC->Line(var), 0, m_symbols->registerSymbol(name));
      FileContent* prevFile = prevDef->first.fC;
      NodeId prevNode = prevDef->first.nodeId;
      Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                    prevFile->Line(prevNode), 0,
                    m_symbols->registerSymbol(name));
      Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_PARAMETER, loc1, loc2);
      m_errors->addError(err);
    }

    FileCNodeId fnid(fC, id);
    m_class->addObject(VObjectType::slLocal_parameter_declaration, fnid);
    m_class->addNamedObject(name, fnid, NULL);

    param_assignment = fC->Sibling(param_assignment);
  }
  return true;
}

bool CompileClass::compile_parameter_declaration_(FileContent* fC, NodeId id) {
  NodeId data_type_or_implicit = fC->Child(id);
  NodeId list_of_param_assignments = fC->Sibling(data_type_or_implicit);
  NodeId param_assignment = fC->Child(list_of_param_assignments);
  while (param_assignment) {
    NodeId var = fC->Child(param_assignment);
    std::string name = fC->SymName(var);
    std::pair<FileCNodeId, DesignComponent*>* prevDef =
        m_class->getNamedObject(name);
    if (prevDef) {
      Location loc1(m_symbols->registerSymbol(fC->getFileName(var)),
                    fC->Line(var), 0, m_symbols->registerSymbol(name));
      FileContent* prevFile = prevDef->first.fC;
      NodeId prevNode = prevDef->first.nodeId;
      Location loc2(m_symbols->registerSymbol(prevFile->getFileName(prevNode)),
                    prevFile->Line(prevNode), 0,
                    m_symbols->registerSymbol(name));
      Error err(ErrorDefinition::COMP_MULTIPLY_DEFINED_PARAMETER, loc1, loc2);
      m_errors->addError(err);
    }

    FileCNodeId fnid(fC, id);
    m_class->addObject(VObjectType::slLocal_parameter_declaration, fnid);
    m_class->addNamedObject(name, fnid, NULL);

    param_assignment = fC->Sibling(param_assignment);
  }
  return true;
}

bool CompileClass::compile_class_type_(FileContent* fC, NodeId id) {
  NodeId parent = fC->Parent(id);
  VObjectType ptype = fC->Type(parent);
  if (ptype != VObjectType::slClass_declaration) return true;
  NodeId base_class_id = fC->Child(id);
  std::string base_class_name = fC->SymName(base_class_id);
  while (fC->Sibling(base_class_id) &&
         (fC->Type(fC->Sibling(base_class_id)) == VObjectType::slStringConst)) {
    base_class_id = fC->Sibling(base_class_id);
    base_class_name += "::" + fC->SymName(base_class_id);
  }
  // Insert base class placeholder
  // Will be bound in UVMElaboration step
  ClassDefinition* base_class =
      new ClassDefinition(base_class_name, m_class->getLibrary(),
                          m_class->getContainer(), fC, base_class_id, NULL);
  m_class->insertBaseClass(base_class);

  return true;
}

bool CompileClass::compile_class_parameters_(FileContent* fC, NodeId id) {
  /*
  n<all_c> u<1> t<StringConst> p<16> s<14> l<3>
  n<uvm_port_base> u<2> t<StringConst> p<12> s<8> l<7>
  n<IF> u<3> t<StringConst> p<6> s<5> l<7>
  n<uvm_void> u<4> t<StringConst> p<5> l<7>
  n<> u<5> t<Data_type> p<6> c<4> l<7>
  n<> u<6> t<List_of_type_assignments> p<7> c<3> l<7>
  n<> u<7> t<Parameter_port_declaration> p<8> c<6> l<7>
  n<> u<8> t<Parameter_port_list> p<12> c<7> s<10> l<7>
  n<IF> u<9> t<StringConst> p<10> l<7>
  n<> u<10> t<Class_type> p<12> c<9> s<11> l<7>
  n<> u<11> t<Endclass> p<12> l<8>
  n<> u<12> t<Class_declaration> p<13> c<2> l<7>

  or

  n<T1> u<3> t<StringConst> p<9> s<5> l<18>
  n<> u<4> t<IntegerAtomType_Int> p<5> l<18>
  n<> u<5> t<Data_type> p<9> c<4> s<6> l<18>
  n<T2> u<6> t<StringConst> p<9> s<8> l<18>
  n<T1> u<7> t<StringConst> p<8> l<18>
  n<> u<8> t<Data_type> p<9> c<7> l<18>
  n<> u<9> t<List_of_type_assignments> p<10> c<3> l<18>
  n<> u<10> t<Parameter_port_declaration> p<11> c<9> l<18>
  n<> u<11> t<Parameter_port_list> p<31> c<10> s<20> l<18>

  */

  NodeId className = fC->Child(id);
  NodeId paramList = fC->Sibling(className);
  if (fC->Type(paramList) == VObjectType::slParameter_port_list) {
    NodeId parameter_port_declaration = fC->Child(paramList);
    while (parameter_port_declaration) {
      NodeId list_of_type_assignments = fC->Child(parameter_port_declaration);
      NodeId typeNameId = fC->Child(list_of_type_assignments);
      while (typeNameId) {
        NodeId ntype = fC->Sibling(typeNameId);
        bool skip = false;
        if (ntype && fC->Type(ntype) == VObjectType::slData_type) {
          ntype = fC->Child(ntype);
          skip = true;
        } else {
          ntype = 0;
        }
        Parameter* param =
            new Parameter(fC, typeNameId, fC->SymName(typeNameId), ntype);
        m_class->insertParameter(param);
        typeNameId = fC->Sibling(typeNameId);
        if (skip) typeNameId = fC->Sibling(typeNameId);
      }
      parameter_port_declaration = fC->Sibling(parameter_port_declaration);
    }
  }
  return true;
}