src/hrc/hrcMemUtil.c

Go to the documentation of this file.

#include "hrcInt.h"

static char rcsid[] UNUSED = "$Id: hrcMemUtil.c,v 1.3 2005/04/16 04:23:47 fabio Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Type declarations                                                         */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Stucture declarations                                                     */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Variable declarations                                                     */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Macro declarations                                                        */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/

static void ModelFree(Hrc_Model_t *model);
static void SubcktFree(Hrc_Subckt_t *subckt);
static void LatchFree(Hrc_Latch_t *latch);

/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/
Hrc_Manager_t *
Hrc_ManagerAlloc(
  void)
{
  Hrc_Manager_t *manager = ALLOC(Hrc_Manager_t, 1);
  
  manager->rootNode = NIL(Hrc_Node_t);
  manager->currentNode = NIL(Hrc_Node_t);
  manager->modelTable = st_init_table(strcmp, st_strhash);
  return manager;
}

Hrc_Model_t *
Hrc_ModelAlloc(
  Hrc_Manager_t *manager,
  char *modelName)
{
  Hrc_Model_t *model;
  
  if(!st_is_member(manager->modelTable,modelName)){
    model = ALLOC(Hrc_Model_t, 1);
    model->modelName = util_strsav(modelName);
    st_insert(manager->modelTable, model->modelName, (char *) model);
    model->subcktTable = st_init_table(strcmp, st_strhash);
    model->masterNode = Hrc_NodeAlloc(manager, model->modelName,
                                      NIL(char), NIL(Hrc_Node_t));
    return model;
  }
  else {
    return NIL(Hrc_Model_t);
  }
}

Hrc_Node_t *
Hrc_NodeAlloc(
  Hrc_Manager_t *manager,
  char *modelName,
  char *instanceName,
  Hrc_Node_t *parentNode)
{
  Hrc_Node_t *node = ALLOC(Hrc_Node_t, 1);
  /* The manager field is needed only for allocating the parent node. For
     allocating any other node in the hierarchy, the manager can be obtained
     from the parent node. */
  node->manager = manager;
  node->modelName = util_strsav(modelName);
  node->instanceName = util_strsav(instanceName);
  node->parentNode = parentNode;
  node->formalInputs = array_alloc(Var_Variable_t *, 0);
  node->formalOutputs = array_alloc(Var_Variable_t *, 0);
  /* The arrays actualInputs and actualOutputs do not need to be allocated
     because 1) they are never needed for the master node of a model, and
     2) they are written over whenever a new node is added to the hierarchy
     by using Hrc_NodeAddChild() */
  node->actualInputs = NIL(array_t);
  node->actualOutputs = NIL(array_t);
  node->nameTables = array_alloc(Tbl_Table_t *, 0);
  node->childTable = st_init_table(strcmp, st_strhash);
  node->latchTable = st_init_table(strcmp, st_strhash);
  node->varTable = st_init_table(strcmp, st_strhash);
  node->applInfoTable = st_init_table(strcmp, st_strhash);
  node->undef = NIL(void);
  return node;
}

Hrc_Node_t *
Hrc_NodeDup(
  Hrc_Node_t *node,
  char *instanceName)
{
  Hrc_Node_t *dupNode = ALLOC(Hrc_Node_t, 1);
  st_generator *gen;
  int i, index;
  Var_Variable_t *var, *dupVar;
  Tbl_Table_t *table, *dupTable;
  Hrc_Latch_t *latch, *dupLatch;
  st_table *varToDupVar;
  char *name, *dupName;
  char *key, *dupKey;
  ApplInfo_t *applInfo;
  
  dupNode->manager = node->manager;
  dupNode->modelName = util_strsav(node->modelName);
  dupNode->instanceName = util_strsav(instanceName);
  dupNode->parentNode = node->parentNode;
  dupNode->formalInputs = array_alloc(Var_Variable_t *, 0);
  dupNode->formalOutputs = array_alloc(Var_Variable_t *, 0);
  dupNode->actualInputs = NIL(array_t);
  dupNode->actualOutputs = NIL(array_t);
  /*
  dupNode->actualInputs = array_alloc(Var_Variable_t *, 0);
  Hrc_NodeForEachActualInput(node, i, var) {
    dupVar = Var_VariableDup(var, dupNode);
    array_insert_last(Var_Variable_t *, dupNode->actualInputs, dupVar);
  }
  dupNode->actualOutputs = array_alloc(Var_Variable_t *, 0);
  Hrc_NodeForEachActualOutput(node, i, var) {
    dupVar = Var_VariableDup(var, dupNode);
    array_insert_last(Var_Variable_t *, dupNode->actualOutputs, dupVar);
  }
  */
  dupNode->varTable = st_init_table(strcmp, st_strhash);
  varToDupVar = st_init_table(st_ptrcmp, st_ptrhash);
  Hrc_NodeForEachVariable(node, gen, name, var) {
    dupVar = Var_VariableDup(var, dupNode);
    dupName = Var_VariableReadName(dupVar);
    st_insert(dupNode->varTable, dupName, dupVar);
    st_insert(varToDupVar, var, dupVar);
  }
  Hrc_NodeForEachFormalInput(node, i, var) {
    st_lookup(varToDupVar, var, &dupVar);
    array_insert_last(Var_Variable_t *, dupNode->formalInputs, dupVar);
  }
  Hrc_NodeForEachFormalOutput(node, i, var) {
    st_lookup(varToDupVar, var, &dupVar);
    array_insert_last(Var_Variable_t *, dupNode->formalOutputs, dupVar);
  }
  dupNode->nameTables = array_alloc(Tbl_Table_t *, 0);
  Hrc_NodeForEachNameTable(node, i, table) {
    dupTable = Tbl_TableSoftDup(table);
    /*dupTable = Tbl_TableHardDup(table);*/
    Tbl_TableForEachInputVar(dupTable, index, var) {
      st_lookup(varToDupVar, var, &dupVar);
      Tbl_TableSubstituteVar(dupTable, var, dupVar);
    }
    Tbl_TableForEachOutputVar(dupTable, index, var) {
      st_lookup(varToDupVar, var, &dupVar);
      Tbl_TableSubstituteVar(dupTable, var, dupVar);
    }
    array_insert_last(Tbl_Table_t *, dupNode->nameTables, dupTable);
  }
  dupNode->latchTable = st_init_table(strcmp, st_strhash);
  Hrc_NodeForEachLatch(node, gen, name, latch) {
    dupLatch = ALLOC(Hrc_Latch_t, 1);
    st_lookup(varToDupVar, latch->latchInput, &(dupLatch->latchInput));
    st_lookup(varToDupVar, latch->latchOutput, &(dupLatch->latchOutput));
    dupLatch->resetTable = Tbl_TableSoftDup(latch->resetTable);
    /*dupLatch->resetTable = Tbl_TableHardDup(latch->resetTable);*/
    Tbl_TableForEachInputVar(dupLatch->resetTable, index, var) {
      st_lookup(varToDupVar, var, &dupVar);
      Tbl_TableSubstituteVar(dupLatch->resetTable, var, dupVar);
    }
    Tbl_TableForEachOutputVar(dupLatch->resetTable, index, var) {
      st_lookup(varToDupVar, var, &dupVar);
      Tbl_TableSubstituteVar(dupLatch->resetTable, var, dupVar);
    }
    dupLatch->undef = latch->undef;
    st_insert(dupNode->latchTable, Var_VariableReadName(dupLatch->latchOutput), dupLatch);
  }
  dupNode->childTable = st_copy(node->childTable);
  dupNode->applInfoTable = st_init_table(strcmp, st_strhash);
  st_foreach_item(node->applInfoTable, gen, &key, &applInfo) {
    dupKey = util_strsav(key);
    st_insert(dupNode->applInfoTable, dupKey, applInfo);
  }
  dupNode->undef = node->undef;
  st_free_table(varToDupVar);
  return dupNode;
}

    
Hrc_Latch_t *
Hrc_LatchCreate(
  Hrc_Model_t *model,
  Var_Variable_t *latchInput,
  Var_Variable_t *latchOutput)
{
  Hrc_Latch_t *latch;
  char *outputName = Var_VariableReadName(latchOutput);
  
  if(!st_is_member(model->masterNode->latchTable, outputName)) {
    latch = ALLOC(Hrc_Latch_t, 1);
    latch->latchInput = latchInput;
    latch->latchOutput = latchOutput;
    latch->resetTable = NIL(Tbl_Table_t);
    latch->undef = NIL(void);
    st_insert(model->masterNode->latchTable, outputName, (char *) latch);
    return latch;
  }
  else {
    return NIL(Hrc_Latch_t);
  }
}

void
Hrc_ManagerFree(
  Hrc_Manager_t *manager)
{
  st_generator *gen;
  char *name;
  Hrc_Model_t *model;
  
  if(manager->rootNode != NIL(Hrc_Node_t)) {
    HrcNodeFreeRecursively(manager->rootNode);
  }
  Hrc_ManagerForEachModel(manager, gen, name, model){
    ModelFree(model);
  }
  st_free_table(manager->modelTable);
  FREE(manager);
}

boolean
Hrc_ModelDelete(
  Hrc_Manager_t *manager,
  char *modelName)
{
  Hrc_Model_t *model;
  
  if(st_delete(manager->modelTable, &(modelName), &model)) {
    ModelFree(model);
    return TRUE;
  }
  else {
    return FALSE;
  }
}

/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/
void
HrcNodeFreeRecursively(
  Hrc_Node_t *node)
{
  st_generator *gen;
  char *name;
  Hrc_Node_t *childNode;
  
  if(node == node->manager->rootNode) {
    node->manager->rootNode = NIL(Hrc_Node_t);
  }
  if(node == node->manager->currentNode) {
    node->manager->currentNode = NIL(Hrc_Node_t);
  }
  HrcNodeFreeInternalMemory(node);
  Hrc_NodeForEachChild(node, gen, name, childNode) {
    HrcNodeFreeRecursively(childNode);
  }
  st_free_table(node->childTable);
  FREE(node);
}

void
HrcNodeFreeInternalMemory(
  Hrc_Node_t *node)
{
  char *name;
  st_generator *gen;
  int i;
  Tbl_Table_t *table;
  Hrc_Latch_t *latch;
  Var_Variable_t *var;
  ApplInfo_t *applInfo;
  char *key;
  
  FREE(node->modelName);
  FREE(node->instanceName);
  array_free(node->formalInputs);
  array_free(node->formalOutputs);
  /* In a master node of a model, actualInputs and actualOutputs are NULL.
     That is why the following two checks are needed. */
  if(node->actualInputs != NIL(array_t)) {
    array_free(node->actualInputs);
  }
  if(node->actualOutputs != NIL(array_t)) {
    array_free(node->actualOutputs);
  }
  Hrc_NodeForEachNameTable(node, i, table) {
    Tbl_TableFree(table);
  }
  array_free(node->nameTables);
  Hrc_NodeForEachLatch(node, gen, name, latch) {
    LatchFree(latch);
  }
  st_free_table(node->latchTable);
  Hrc_NodeForEachVariable(node, gen, name, var) {
    Var_VariableFree(var);
  }
  st_free_table(node->varTable);
  if(node->applInfoTable) {
    st_foreach_item(node->applInfoTable, gen, &key, &applInfo) {
      FREE(key);
      (*applInfo->freeFn)(applInfo->data);
      FREE(applInfo);
    }
    st_free_table(node->applInfoTable);
  }
}


/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/
static void
ModelFree(
  Hrc_Model_t *model)
{
  st_generator *gen;
  char *name;
  Hrc_Subckt_t *subckt;
  
  FREE(model->modelName);
  HrcNodeFreeInternalMemory(model->masterNode);
  st_free_table(model->masterNode->childTable);
  FREE(model->masterNode);
  st_foreach_item(model->subcktTable, gen, &name, &subckt) {
    SubcktFree(subckt);
  }
  st_free_table(model->subcktTable);
  FREE(model);
}

static void
SubcktFree(
  Hrc_Subckt_t *subckt)
{
  FREE(subckt->instanceName);
  array_free(subckt->actualInputVars);
  array_free(subckt->actualOutputVars);
  FREE(subckt);
}

static void
LatchFree(
  Hrc_Latch_t *latch)
{
  if(latch->resetTable != NIL(Tbl_Table_t)){    
    Tbl_TableFree(latch->resetTable);
  }
  FREE(latch);
}