src/io/ioParse.c

Go to the documentation of this file.

#include "ioInt.h"

static char rcsid[] UNUSED = "$Id: ioParse.c,v 1.4 2002/08/16 17:35:01 fabio Exp $";

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


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


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


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


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


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

static void _IoParserAddSubckt(array_t **subcktArray, char *modelName, char *instanceName, array_t *formalNameArray, array_t *actualNameArray);
static int _IoIOProcess(Hrc_Node_t *hnode, char *name, int type);
static IoPTable_t * _IoPTableCreate(array_t *inputArray, array_t *outputArray, array_t *defaultArray, array_t *symCubeArray);
static void _IoPTableFree(IoPTable_t *pTable);

/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/

Var_Variable_t *
IoVariableFindOrAllocByName(
  Hrc_Node_t *hnode,
  char *name)
{
  Var_Variable_t *var;

  if ((var = Hrc_NodeFindVariableByName(hnode,name)) != NIL(Var_Variable_t)){
    return var;
  }
  var = Var_VariableAlloc(hnode,name);
  return var;
}

int
IoAtoi(char *string)
{
  char *s;
  for (s=string; *s!='\0'; s++) {
    if (isdigit((int) *s)==0){
      return -1;
    }
  } 
  return atoi(string);
}

void
IoStringArrayFree(array_t *array)
{
  int i;
  char *symbol;

  for (i=0; i < array_n(array); i++) {
    symbol = array_fetch(char *, array, i);
    FREE(symbol);
  }
  array_free(array);
}


void
IoNameInsertInArray(array_t **arrayPtrPtr, char *name)
{
  if (*arrayPtrPtr == NIL(array_t)){
    *arrayPtrPtr = array_alloc(char *, 0);
  }
  array_insert_last(char *, *arrayPtrPtr, name);
}

void
IoSymValueInsertInArray(array_t **arrayPtrPtr, IoSymValue_t *value)
{
  if (*arrayPtrPtr == NIL(array_t)){
    *arrayPtrPtr = array_alloc(IoSymValue_t *, 0);
  }
  array_insert_last(IoSymValue_t *, *arrayPtrPtr, value);
}

void
IoSymCubeInsertInArray(array_t **arrayPtrPtr, array_t *symCube)
{
  if (*arrayPtrPtr == NIL(array_t)){
    *arrayPtrPtr = array_alloc(array_t *, 0);
  }
  array_insert_last(array_t *, *arrayPtrPtr, symCube);
}

boolean
IoInputProcess(
  Hrc_Node_t *hnode, 
  char *name)
{
  return _IoIOProcess(hnode, name, 0);
}

boolean
IoOutputProcess(
  Hrc_Node_t *hnode, 
  char *name)
{
  return _IoIOProcess(hnode, name, 1);
}

boolean
IoMvProcess(
  Hrc_Model_t *model, 
  Hrc_Node_t *hnode, 
  array_t *varNames, 
  int range, 
  array_t *symValues)
{
  int i;
  char *varName;
  Var_Variable_t *var;

  if (range == -1) {
    error_append("Invalid .mv specification of ");
    error_append(array_fetch(char *,varNames,0));
    error_append(" in model ");
    error_append(Hrc_ModelReadName(model));
    error_append("\n- Range should be an integer.\n");
    return 0;
  }

  for (i=0; i < array_n(varNames); i++){
    varName = array_fetch(char *,varNames,i);
    if ((var = Hrc_NodeFindVariableByName(hnode,varName)) != NIL(Var_Variable_t)) {
      if (Var_VariableAddRangeInfo(var,range,symValues) == 0){
        error_append("Invalid .mv specification of ");
        error_append(varName);
        error_append(" in model ");
        error_append(Hrc_ModelReadName(model));
        error_append("\n- You are trying to redefine the above variable.\n");
        return 0;
      }
    }
    else {
      var = Var_VariableAlloc(hnode,varName);
      (void)Var_VariableAddRangeInfo(var,range,symValues);
    }
  }
  return 1;
}

boolean
IoLatchProcess(
  Hrc_Model_t *model,
  Hrc_Node_t *hnode, 
  char *latchInput,
  char *latchOutput)
{
  Var_Variable_t *varIn, *varOut;

  varIn = IoVariableFindOrAllocByName(hnode,latchInput);
  varOut = IoVariableFindOrAllocByName(hnode,latchOutput);
  if (varIn == NIL(Var_Variable_t) || varOut == NIL(Var_Variable_t)){
    return 0;
  }
  if ((Hrc_LatchCreate(model,varIn,varOut)) == NIL(Hrc_Latch_t)){
    return 0; 
  }
  (void)Var_VariableSetNS(varIn);
  /* a latch can have only one fanin */
  if (Var_VariableSetPS(varOut) == 0){
    error_append("Variable ");
    error_append(latchOutput);
    error_append(" are fed by more than one latch\n");
    return 0;
  }
  return 1;
}

boolean
IoTableProcess(
  Hrc_Model_t *model,
  Hrc_Node_t *hnode,
  array_t *inputArray,
  array_t *outputArray,
  array_t *defaultArray,
  array_t *symCubeArray)
{
  IoPTable_t *pTable;
  Tbl_Table_t *table;

  pTable = _IoPTableCreate(inputArray,outputArray,defaultArray,symCubeArray);

  if ((table = IoPTableTransformToTable(model, hnode, pTable)) == NIL(Tbl_Table_t)){
    _IoPTableFree(pTable);
    return 0;
  }
  _IoPTableFree(pTable);
  Hrc_ModelAddNameTable(model,table);
  return 1;
}

boolean
IoResetProcess(
  array_t **resetArray,
  Hrc_Model_t *model, 
  Hrc_Node_t *hnode, 
  array_t *inputArray, 
  array_t *outputArray, 
  array_t *defaultArray, 
  array_t *symCubeArray)
{
  IoPTable_t *pTable;
  Tbl_Table_t *table;

  pTable = _IoPTableCreate(inputArray,outputArray,defaultArray,symCubeArray);
  if ((table = IoPTableTransformToTable(model,hnode,pTable)) == NIL(Tbl_Table_t)){
    _IoPTableFree(pTable);
    return 0;
  }
  _IoPTableFree(pTable);

  if (*resetArray == NIL(array_t)){
    *resetArray = array_alloc(Tbl_Table_t *,0);
  }
  array_insert_last(Tbl_Table_t *,*resetArray,table);
  return 1;
}


boolean
IoSubcktProcess(
  array_t **subcktArray,
  Hrc_Model_t *model, 
  Hrc_Node_t *hnode, 
  char *modelName, 
  char *instanceName, 
  array_t *formalNameArray, 
  array_t *actualNameArray)
{
  int i;
  char *actual;
  Var_Variable_t *var;

  for (i=0; i < array_n(actualNameArray); i++){
    actual = array_fetch(char *,actualNameArray,i);
    var = IoVariableFindOrAllocByName(hnode,actual);
    if (var == NIL(Var_Variable_t)){
      error_append("Problem in defining variable ");
      error_append(actual);
      error_append(" found in subckt ");
      error_append(instanceName);
      error_append(" in model ");
      error_append(Hrc_ModelReadName(model));
      error_append("\n");
      return 0;
    }
  }

  _IoParserAddSubckt(subcktArray,modelName,instanceName,formalNameArray,actualNameArray);
  return 1;
}


/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/

static void
_IoParserAddSubckt(
  array_t **subcktArray,
  char *modelName,
  char *instanceName,
  array_t *formalNameArray,
  array_t *actualNameArray)
{
  IoSubckt_t *subckt;

  subckt = ALLOC(IoSubckt_t,1);
  subckt->modelName = modelName;
  subckt->instanceName = instanceName;
  subckt->formalNameArray = formalNameArray;
  subckt->actualNameArray = actualNameArray;

  if (*subcktArray == NIL(array_t)){
    *subcktArray = array_alloc(IoSubckt_t *,0);
  }
  array_insert_last(IoSubckt_t *, *subcktArray, subckt);
}

static int
_IoIOProcess(
  Hrc_Node_t *hnode,
  char *name,
  int type)
{
  Var_Variable_t *var;

  if (Hrc_NodeFindVariableByName(hnode, name) != NIL(Var_Variable_t)) {
    error_append("Variable ");
    error_append(name);
    error_append(" is tried to be set to PI and PO in model ");
    error_append(Hrc_NodeReadModelName(hnode));
    error_append("\n");
    return 0;
  }
  var = Var_VariableAlloc(hnode,name);
  switch(type){
    case 0:  /* PI */
      Hrc_NodeAddFormalInput(hnode,var);
      /* the following is now a part of Hrc_NodeAddFormalInput */
      /*(void)Var_VariableSetPI(var);*/
      break;
    case 1:  /* PO */
      Hrc_NodeAddFormalOutput(hnode,var);
      /* the following is now a part of Hrc_NodeAddFormalOutput */
      /*(void)Var_VariableSetPO(var);*/
      break;
    default:
      fail("Strange argument is given to variable type in IOProcess\n");
  }
  return 1;
}


static IoPTable_t *
_IoPTableCreate(
  array_t *inputArray,
  array_t *outputArray,
  array_t *defaultArray,
  array_t *symCubeArray)
{
  IoPTable_t *pTable;

  pTable = ALLOC(IoPTable_t,1);
  if (inputArray == NIL(array_t)){
    pTable->inputs = array_alloc(char *,0);
  }
  else {
    pTable->inputs = inputArray;
  }
  assert(outputArray != NIL(array_t));
  pTable->outputs = outputArray;
  pTable->defaultOutput = defaultArray;
  pTable->cubes = symCubeArray;

  return pTable;
}

static void
_IoPTableFree(IoPTable_t *pTable)
{
  int i;
  array_t *symValueArray;

  IoStringArrayFree(pTable->inputs);
  IoStringArrayFree(pTable->outputs);
  if (pTable->defaultOutput != NIL(array_t)){
    IoSymValueArrayFree(pTable->defaultOutput);
  }
  if (pTable->cubes != NIL(array_t)){
    for (i=0; i < array_n(pTable->cubes); i++){
      symValueArray = array_fetch(array_t *,pTable->cubes,i);
      IoSymValueArrayFree(symValueArray);
    }
    array_free(pTable->cubes);
  }
  FREE(pTable);
}