src/tbl/tblUtil.c

Go to the documentation of this file.

#include "tblInt.h"

static char rcsid[] UNUSED = "$Id: tblUtil.c,v 1.19 2009/04/11 02:01:29 fabio Exp $";

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

/* Structure used to sort table inputs. */
typedef struct varOrdStruct {
  int id;                       /* input column number */
  int rank;                     /* low-ranked columns should go first */
} Var_Ord_t;


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

static int TableEntryComputeHashVal(Tbl_Table_t *table, Tbl_Entry_t *entry);
static array_t* TableCreatIntArray(int size);
static char* TableObtainSignature(Tbl_Table_t * table, int outputColumn);
static int varCompare(const void *x, const void *y);

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

Tbl_Table_t*
Tbl_TableAlloc(void)
{
  Tbl_Table_t * table;

  table = ALLOC(Tbl_Table_t,1);
  table->inputNames = array_alloc(Var_Variable_t*,0);
  table->outputNames = array_alloc(Var_Variable_t*,0);
  table->data = ALLOC(Tbl_Data_t,1);  
  TblTableReadDefaults(table) = array_alloc(Tbl_Entry_t*,0);
  TblTableReadRefCount(table) = 1;
  TblTableReadData(table) = array_alloc(Tbl_Row_t*,0);
  return table;
}


void
Tbl_TableFree(
  Tbl_Table_t *  table /* The table to be freed */)
{
  int i,j,k;
  Tbl_Row_t * row;
  Tbl_Entry_t *entry;
    
    
  if (table != NIL(Tbl_Table_t)) {
    if (TblTableReadRefCount(table) < 2) {
  Tbl_TableForEachEntry(table,j,i,k,entry) {
      if (entry != NIL(Tbl_Entry_t)) {
        Tbl_EntryFree(entry);
      }
    }                        
    TblTableForEachRow(table,row,i){
      array_free(row->inputs);
      array_free(row->outputs);
      FREE(row);
    }
    Tbl_TableForEachDefaultEntry(table,entry,i) {
      if (entry != NIL(Tbl_Entry_t)) {
        Tbl_EntryFree(entry);
      }
    }            
    array_free(TblTableReadDefaults(table));
    array_free(TblTableReadData(table));
    FREE(table->data);
  
    }
  else {
    TblTableReadRefCount(table)--;;
  }
    array_free(table->inputNames);
    array_free(table->outputNames);
    FREE(table);
  }
}   

Tbl_Table_t *
Tbl_TableSoftDup(
  Tbl_Table_t *  table /* The table to be duplicated */)
{
  Tbl_Table_t *tabledup;

  assert(TblTableReadRefCount(table) >0);
  tabledup = ALLOC(Tbl_Table_t,1);
  tabledup->data = table->data;

  tabledup->inputNames = array_dup(table->inputNames);
  tabledup->outputNames = array_dup(table->outputNames);
  
  TblTableReadRefCount(table) ++;
  return tabledup;
}

Tbl_Table_t *
Tbl_TableHardDup(
  Tbl_Table_t *  table /* The table to be duplicated */)
{
  Tbl_Table_t * tabledup;
  int i;
  Tbl_Entry_t *newEntry, *entry;
  Var_Variable_t *var;
  Tbl_Row_t *row;

  tabledup = Tbl_TableAlloc();

  Tbl_TableForEachInputVar(table,i,var){
    Tbl_TableAddColumn(tabledup,var,0);
  }

  Tbl_TableForEachOutputVar(table,i,var){
    Tbl_TableAddColumn(tabledup,var,1);
  }  

  Tbl_TableForEachDefaultEntry(table,entry,i) {
    if (entry != NIL(Tbl_Entry_t)) {
      newEntry = Tbl_EntryDup(entry);
    }
    else {
      newEntry = NIL(Tbl_Entry_t);
    }
    (void) Tbl_TableDefaultSetEntry(tabledup,newEntry,i);
  }

  TblTableForEachRow(table,row,i){
    TblTableSetRow(tabledup,TblRowDup(row),i);
  }
  
  return tabledup;
}


boolean
Tbl_TableDefaultSetEntry(
    Tbl_Table_t *table,
    Tbl_Entry_t *entry,
    int index)
{
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by re-setting this entry\n");
  }
  
  if (array_n(TblTableReadDefaults(table)) < index) {
    return FALSE; 
  }
  
  if (entry != NIL(Tbl_Entry_t)) {
    entry->ioType = 1;
    entry->varColNum = index;
    /* debug */
    if (entry->type == Tbl_EntryEqual_c)
    assert(Tbl_EntryReadVarIndex(entry) < Tbl_TableReadNumInputs(table));    
  }
  
  
  array_insert(Tbl_Entry_t*, TblTableReadDefaults(table),index,entry);
  return TRUE;
}

Tbl_Entry_t*
Tbl_TableDefaultReadEntry(
    Tbl_Table_t *table,
    int index)
{
  if (array_n(TblTableReadDefaults(table)) < index) {
    return NIL(Tbl_Entry_t); 
  }

  return (array_fetch(Tbl_Entry_t*, TblTableReadDefaults(table),index));
}

    
int 
Tbl_TableAddRow(
  Tbl_Table_t *  table)
{
  Tbl_Row_t * row;
  int i;

  if (table != NIL(Tbl_Table_t)) {
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by adding this row\n");
  }    
      row = ALLOC(Tbl_Row_t,1);
      row->inputs = array_alloc(Tbl_Entry_t*,0);
      for (i=0; i < array_n(table->inputNames); i++) {
        array_insert_last(Tbl_Entry_t*,row->inputs, NIL(Tbl_Entry_t)); 
      }
      

      row->outputs = array_alloc(Tbl_Entry_t*,0);
      for (i=0; i < array_n(table->outputNames); i++) {
        array_insert_last(Tbl_Entry_t*,row->outputs, NIL(Tbl_Entry_t)); 
      }
                        
      array_insert_last(Tbl_Row_t*, TblTableReadData(table),row);
      return ( array_n(TblTableReadData(table)) -1);
    }
  else return -1;
}  

int
Tbl_TableAddColumn(
  Tbl_Table_t *  table /* the table */,
  Var_Variable_t *  var /* the Var being added */,
  int  flag /* This flag is set to 0 if it is an input and 1 if it is and output
 */)
{
  int i, index;
  Tbl_Row_t *row;
  array_t *carray;
  
  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You may be modifying more than one table by adding this column\n");
  }  
  index = 0;
  for (i=0; i< array_n(TblTableReadData(table)); i++) {
    row = array_fetch(Tbl_Row_t*,TblTableReadData(table),i);
    if (flag==0) {
      carray = row->inputs; 
    }
    else {
      carray = row->outputs; 
    }
  
    array_insert_last(Tbl_Entry_t*,carray,NIL(Tbl_Entry_t));
  
  }
  if (flag==0) {
    array_insert_last(Var_Variable_t*, table->inputNames, var);
    index = array_n(table->inputNames);
  }
  else {
      array_insert_last(Var_Variable_t*, table->outputNames, var);
      index = array_n(table->outputNames);      
      array_insert_last(Tbl_Entry_t*,
                        TblTableReadDefaults(table),NIL(Tbl_Entry_t));
    }

  return index;
}

Tbl_Table_t *
Tbl_TableRowDelete(
   Tbl_Table_t *originalTable,
   int rowNumToDelete,
   array_t *freeArray            
   )
{
    Tbl_Table_t *newTable;
    int i, rownum, newRowNum, numInputs, numOutputs;
    Var_Variable_t *var, *newVar;
    Tbl_Row_t *row UNUSED;
    Tbl_Entry_t *newEntry, *origEntry, *entry, *dupEntry;

    newTable = Tbl_TableAlloc();
    Tbl_TableForEachInputVar(originalTable, i, var){
        newVar = Var_VariableDup(var, NIL(Hrc_Node_t));
        array_insert_last(Var_Variable_t *, freeArray, newVar);
        (void) Tbl_TableAddColumn(newTable, newVar, 0);
    }
    Tbl_TableForEachOutputVar(originalTable, i, var){
        newVar = Var_VariableDup(var, NIL(Hrc_Node_t));
        array_insert_last(Var_Variable_t *, freeArray, newVar);
        (void) Tbl_TableAddColumn(newTable, newVar, 1);
    }
    for(i = 0; i < Tbl_TableReadNumOutputs(originalTable); i++){
        entry = Tbl_TableDefaultReadEntry(originalTable, i);
        if(entry != NIL(Tbl_Entry_t)){
            dupEntry = Tbl_EntryDup(entry);
            Tbl_TableDefaultSetEntry(newTable, dupEntry, i);
        }
    }
    numInputs = Tbl_TableReadNumInputs(originalTable);
    numOutputs = Tbl_TableReadNumOutputs(originalTable);
    TblTableForEachRow(originalTable, row, rownum){
        if(rownum != rowNumToDelete){
            newRowNum = Tbl_TableAddRow(newTable);
            for(i = 0; i < numInputs; i++){
                origEntry = Tbl_TableReadEntry(originalTable, rownum, i, 0);
                newEntry = Tbl_EntryDup(origEntry);
                Tbl_TableSetEntry(newTable, newEntry, newRowNum, i, 0);
            }
            for(i = 0; i < numOutputs; i++){
                origEntry = Tbl_TableReadEntry(originalTable, rownum, i, 1);
                newEntry = Tbl_EntryDup(origEntry);
                Tbl_TableSetEntry(newTable, newEntry, newRowNum, i, 1);
            }
        }
    }
    Tbl_TableFree(originalTable);
    return newTable;
}

Var_Variable_t*
Tbl_TableReadIndexVar(
  Tbl_Table_t *  table,
  int index,
  int  flag /* Set to 0 if it is an input Var and 1 if it an output Var */
)
{
  array_t *carray;

  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));
  
  if (flag==0) {
    carray = table->inputNames;
  }
  else {
    carray = table->outputNames;
  }
            
  return (array_fetch(Var_Variable_t*,carray,index));
}

Tbl_Entry_t *
Tbl_TableReadEntry(
  Tbl_Table_t *  table ,
  int  rowNum,
  int  colNum,
  int  flag )
{
  Tbl_Row_t *row;
  Tbl_Entry_t *entry;
    

  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));
  
  row = TblTableReadRow(table,rowNum);
  entry = TblRowReadEntry(row,colNum,flag);
    
  return entry;
}

boolean 
Tbl_TableSetEntry(
  Tbl_Table_t *  table /* The Table to be examined */,
  Tbl_Entry_t * newEntry,
  int  i /* Row Id */,
  int  j /* Column Id */,
  int  flag /* flag indicating whether it is an input or output */)
{
  Tbl_Row_t *row;
  Tbl_Entry_t *entry;

  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by  re-setting this entry\n");
  }

  entry = Tbl_TableReadEntry(table ,i,j,flag);
 if (entry != NIL(Tbl_Entry_t)) {
   Tbl_EntryFree(entry);
  }

  row = TblTableReadRow(table,i);

  newEntry->ioType = flag;
  newEntry->varColNum = j;
  TblRowSetEntry(row,newEntry,j,flag);
  
  return TRUE;
}

boolean
Tbl_TableSetEntryDc(
  Tbl_Table_t *  table,
  int  i,
  int  j,
  int  flag)
{
  array_t *ioarray;
  int range;
  Tbl_Entry_t *entry;

  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by re-setting this entry\n");
  }
  
  if (flag==0) {
    ioarray = table->inputNames;
  }
  else {
    ioarray = table->outputNames;
  }

  range = Var_VariableReadNumValues(array_fetch(Var_Variable_t*,ioarray,j));
  entry = Tbl_TableReadEntry(table,i,j,flag);
  Tbl_EntrySetValue(entry,0,range-1);
  return TRUE;
}
void
Tbl_TableAddEntryRange(
  Tbl_Table_t *  table,
  int  i,
  int  j,
  int  val1,
  int  val2,
  int  flag)
{
  Tbl_Entry_t *entry;

  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by changing the re-setting this entry\n");
  }
  
  entry = Tbl_TableReadEntry(table,i,j,flag);
  Tbl_EntrySetValue(entry,val1,val2);
    
}
  
void
Tbl_TableComplementEntry(
  Tbl_Table_t *  table,
  int  i,
  int  j,
  int  flag)
{
  Tbl_Entry_t *entry;
    
  entry = Tbl_TableReadEntry(table,i,j,flag);
  Tbl_EntryComplement(entry,0,(Var_VariableReadNumValues(Tbl_EntryReadActualVar(table, entry))) -1 );

}

void
Tbl_TableSetEquality(
  Tbl_Table_t *  table,
  int  i,
  int  j,
  int flag,
  Var_Variable_t *  var)
{
  Tbl_Entry_t *entry;
  int index,check;
  Var_Variable_t *tblVar;

  check =0;
  entry = Tbl_TableReadEntry(table,i,j,flag);
  Tbl_TableForEachInputVar(table, index,tblVar) {
    if (tblVar == var) {
      Tbl_EntrySetEqual(entry,index);
      check =1;
      break;
    }
  }
  
  if (check == 0) {
    printf(" WARNING: Output Equal Another Output not supported, no change made\n ");
  }
}


boolean
Tbl_TableEntryIsDc(
  Tbl_Table_t *  table,
  int  i,
  int  j,
  int flag)
{
  Tbl_Range_t *range;
  Tbl_Entry_t *entry;
  lsGen gen;
  Var_Variable_t *var;
  
  assert(table !=NIL(Tbl_Table_t));

  entry = Tbl_TableReadEntry(table,i,j,flag);

    if (lsLength(entry->EntryData.listOfRanges) == 1){
      var = Tbl_EntryReadActualVar(table,entry);
      lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
        if ((range->begin ==0)&&(range->end ==
                                 Var_VariableReadNumValues(var)-1)){
          lsFinish(gen);
          return TRUE;
        }
      }
    }
  return FALSE;
}


boolean
Tbl_TableTestIsConstant(
  Tbl_Table_t *  table,
  int            outputColumnId)
{
  int colNum, rowNum;
  boolean check;
  Tbl_Entry_t *entry;
  Var_Variable_t *var;
  Tbl_Range_t *range;
  lsGen gen;
  int value, constant,count;
  
  
  assert(table !=NIL(Tbl_Table_t));
  assert((outputColumnId >= 0) && (outputColumnId <
                                   Tbl_TableReadNumOutputs(table)));

  if (Tbl_TableReadNumRows(table) == 1) {  
    if (array_n(table->inputNames) == 0) {
      entry = Tbl_TableReadEntry(table, 0, outputColumnId, 1);
      if (entry->type == Tbl_EntryNormal_c) {
        if (Tbl_EntryReadNumValues(entry) == 1) {
          return TRUE;
        }
      }
    }
    else {
      check = TRUE;
      Tbl_TableForEachInputEntry(table,rowNum,colNum,entry) {
        if (entry->type != Tbl_EntryNormal_c) {
          return FALSE;
        }
        if (check == TRUE) {
          check = FALSE;
          if (lsLength(entry->EntryData.listOfRanges) == 1){
            var = Tbl_EntryReadActualVar(table,entry);
            lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
              if ((range->begin ==0)&&(range->end ==
                                       Var_VariableReadNumValues(var)-1)){
                check = TRUE;
              }
            }
          }
        }
      }
      
      if (check) {
        entry = Tbl_TableReadEntry(table,0,outputColumnId,1);
        if (entry->type != Tbl_EntryNormal_c) {
          return FALSE;
        }            
        if (Tbl_EntryReadNumValues(entry) == 1) {
          return TRUE;
        }
      }
    }
  }
  else if (Tbl_TableReadNumRows(table) == 0) {
    entry = Tbl_TableDefaultReadEntry(table,outputColumnId);
    if (entry->type != Tbl_EntryNormal_c) {
      return FALSE;
    }    
    if (Tbl_EntryReadNumValues(entry) == 1) {
      return TRUE;
    }
  }
  else {
    entry = Tbl_TableDefaultReadEntry(table,outputColumnId);    
    if (entry == NIL(Tbl_Entry_t)){
      constant = -1;      
      Tbl_TableForEachOutputEntry(table,rowNum,colNum,entry) {
        if (colNum == outputColumnId) {
          if (entry->type != Tbl_EntryNormal_c){
            return FALSE;
          }          
          count = 1;
          Tbl_EntryForEachValue(entry,value,gen,range) {
            lsStatus status;
            if (count > 1) {
              status = lsFinish(gen); 
              assert(status == LS_OK);  
              return FALSE;
            }
            else {
              if (constant != -1) {
                if (constant != value) {
                  status = lsFinish(gen);
                  assert(status == LS_OK); 
                  return FALSE;
                }
              }
              else {
                constant = value;
              }
            }
            count ++;        
          }
        }
      }
      return TRUE;
    }
  }
  return FALSE;
}


boolean
Tbl_TableTestIsNonDeterministicConstant(
  Tbl_Table_t *  table,
  int            outputColumnId)
{
  assert(table !=NIL(Tbl_Table_t));
  
  if (array_n(table->inputNames) == 0) {
    if (!Tbl_TableTestIsConstant(table, outputColumnId)) {
      return TRUE;
    }
  }
  
  return FALSE;
}


int
Tbl_TableTestIsDeterministic(
  Tbl_Table_t *  table)
{

/* intersect every pair of input rows and
   then compare outputs if they're not same --- */
/* Sunil Khatri is implementing this */
  return 0;
}

boolean
Tbl_TableTestIsOutputSpaceComplete(
  Tbl_Table_t *table,
  mdd_manager *mddMgr)
{
  int i, offset,rowNum,colNum,oldRowNum;
  boolean check;
  Mvf_Function_t *mvf;
  mdd_t *temp, *result, *function, *x;
  Var_Variable_t *var;
  Tbl_Entry_t *entry;
  array_t        *faninMvfArray ;
  array_t        *mvarValues ;
  int             numOutputs;
  
  if (Tbl_TableReadNumInputs(table) != 0) {
    return FALSE;
  }

  x = NIL(mdd_t);
  faninMvfArray     = array_alloc(Mvf_Function_t *, 0);
  mvarValues        = array_alloc(int, 0);
  numOutputs         = Tbl_TableReadNumOutputs(table );

  
  /* Add mdd's for new table input variables. */
  Tbl_TableForEachOutputVar(table, colNum, var) {
    array_insert_last(int, mvarValues, Var_VariableReadNumValues(var));
  }
  offset = array_n(mdd_ret_mvar_list(mddMgr));    
  mdd_create_variables(mddMgr,mvarValues, NIL(array_t), NIL(array_t));
  array_free(mvarValues);

  /*
   * Construct an MVF for each table input. The MVF for column i is the MVF
   * for MDD variable i.
   */
  for (i = 0; i < numOutputs; i++) {
    Mvf_Function_t *faninMvf = Mvf_FunctionCreateFromVariable(mddMgr, (i+offset));
    array_insert_last(Mvf_Function_t *, faninMvfArray, faninMvf);
  }
  /* Compute the MVF of the outputs */

/* iterate over output part and compute all mvf's of rows */
/* add to total */
  function = mdd_zero(mddMgr);
  oldRowNum = -1;
  result = mdd_zero(mddMgr);  
  Tbl_TableForEachOutputEntry(table,rowNum,colNum,entry) {    
    if (rowNum != oldRowNum) {
      temp =function;
      function = mdd_or(temp,result, 1,1);
      mdd_free(temp);
      mdd_free(result);        
      result = mdd_one(mddMgr);
    }
    if (entry->type == Tbl_EntryNormal_c) {
      mvf = array_fetch(Mvf_Function_t*,faninMvfArray,colNum);
      x = TblEntryNormalConstructMdd(mddMgr,entry,mvf);          
    }
    else  if (entry->type == Tbl_EntryEqual_c) {
      printf("Failure: output equal to another output construct not supported\n");
      assert(FALSE);
    }
    temp = result;
    result = mdd_and(x,temp,1,1);
    mdd_free(x);
    mdd_free(temp);
    oldRowNum = rowNum;
  }
  temp =function;
  function = mdd_or(temp,result, 1,1);
  mdd_free(temp);
  mdd_free(result);        

  check = mdd_is_tautology(function,1);
  mdd_free(function);
  
  for (i=0;i < array_n(faninMvfArray); i++){
    Mvf_FunctionFree(array_fetch(Mvf_Function_t *,faninMvfArray,i));
  }
  array_free(faninMvfArray);
  return check;
}


array_t *
Tbl_TableComputeMvfAndInputDependenciesOfOutput(
  Tbl_Table_t *table,
  mdd_manager  *mddMgr,  
  int          outIndex,
  int *value)
{
  int             i, offset;
  Mvf_Function_t *outMvf;
  Var_Variable_t *var;
  int             colNum;
  array_t        *faninMvfArray     = array_alloc(Mvf_Function_t *, 0);
  array_t        *mvarValues        = array_alloc(int, 0);
  array_t        *totalSupportArray = array_alloc(int, 0);
  int             numInputs         = Tbl_TableReadNumInputs(table );
  
  /* Add mdd's for new table input variables. */
  Tbl_TableForEachInputVar(table, colNum, var) {
    array_insert_last(int, mvarValues, Var_VariableReadNumValues(var));
  }
  offset = array_n(mdd_ret_mvar_list(mddMgr));    
  mdd_create_variables(mddMgr,mvarValues, NIL(array_t), NIL(array_t));
  array_free(mvarValues);

  /*
   * Construct an MVF for each table input. The MVF for column i is the MVF
   * for MDD variable i.
   */
  for (i = 0; i < numInputs; i++) {
    Mvf_Function_t *faninMvf = Mvf_FunctionCreateFromVariable(mddMgr, (i+offset));
    array_insert_last(Mvf_Function_t *, faninMvfArray, faninMvf);
  }
  /* Compute the MVF of the output indexed by outIndex. */
  outMvf = Tbl_TableBuildMvfFromFanins(table, outIndex, faninMvfArray, mddMgr);
  Mvf_FunctionArrayFree(faninMvfArray);


  totalSupportArray 
      = Mvf_FunctionComputeSupport(outMvf,mddMgr,value);
  
  Mvf_FunctionFree(outMvf);  
  return totalSupportArray;
}


Tbl_Table_t*
Tbl_TableCreateTrueSupportTableForOutput(
  Tbl_Table_t *table,
  Mvf_Function_t *outMvf,
  mdd_manager *mddMgr,
  int offset,  
  int outIndex,
  array_t *varMap /* maps input column to mdd id */
  )
{
  array_t *support;
  Tbl_Table_t * newTable;
  int i, inputId, rowNum, colNum, newColNum, newEqColNum, value, eqColNum;
  Tbl_Entry_t *newEntry, *entry;
  Var_Variable_t *var;
  Tbl_Row_t *row UNUSED;
  st_table *supLookup;

  newTable = Tbl_TableAlloc();  
  /* compute dependancies and put in a hash table */

  if (outMvf != NIL(Mvf_Function_t)) {
    support =
        Mvf_FunctionComputeSupport(outMvf,mddMgr,&value);
  }
  else {
    offset = array_n(mdd_ret_mvar_list(mddMgr));
    support =
        Tbl_TableComputeMvfAndInputDependenciesOfOutput(table,mddMgr,outIndex,&value);
  }
  
  if(support == NIL(array_t)) {
    /* create a constant table */
    var = Tbl_TableReadIndexVar(table,outIndex,1);
    Tbl_TableAddColumn(newTable,var,1);
    i  = Tbl_TableAddRow(newTable);
    newEntry = Tbl_EntryAlloc(Tbl_EntryNormal_c);
    Tbl_TableSetEntry(newTable, newEntry, 0, 0, 1);
    Tbl_TableAddEntryRange(newTable,0,0,value,value,1);
    newEntry = NIL(Tbl_Entry_t);    
    (void) Tbl_TableDefaultSetEntry(newTable,newEntry,0);
    return newTable;
  }

  supLookup = st_init_table(st_numcmp, st_numhash);

  arrayForEachItem(int, support, i, inputId) {
    st_insert(supLookup,(char*)((long)(inputId - offset)),(char*)((long)i));
  }
  array_free(support);

  /* Account for multiple columns mapping to the same MDD variable.
   * There are two reasons why there may be fewer variables in the MVF
   * than there are input columns in a table:
   * 1. Multiple columns are tied to the same Var_Variable_t and hence
   *    get the same MDD variable.
   * 2. Variables that are in the apparent support of the table are not
   *    in the true support of the MVF.
   * The first reason is captured by varMap, the second by supLookup.
   * Now we merge the two and replace supLookup with the resulting table.
   */
  if (varMap != NIL(array_t)) {
    int mapped;
    int nCol = 0;
    Var_Ord_t *varArray = ALLOC(Var_Ord_t, array_n(varMap));
    arrayForEachItem(int, varMap, i, mapped) {
      int position;
      if (st_lookup_int(supLookup, (char*)(long) mapped, &position) == 1) {
        varArray[nCol].id = i;
        varArray[nCol].rank = position;
        nCol++;
      }
    }
    qsort((void *)varArray, nCol, sizeof(Var_Ord_t), varCompare);
    st_free_table(supLookup);
    supLookup = st_init_table(st_numcmp, st_numhash);
    for (i=0; i < nCol; i++) {
      st_insert(supLookup, (char*)((long)varArray[i].id), (char*)((long)i));
    }
    FREE(varArray);
  }

  /* foreach input var check if in true support and then insert */
  Tbl_TableForEachInputVar(table,i,var){
    if (st_lookup_int(supLookup, (char*)(long) i, &newColNum) == 1) {
      Tbl_TableAddColumn(newTable,var,0);
    }
  }

  /* insert only specified output */
  Tbl_TableForEachOutputVar(table,i,var){
    if (i == outIndex) {    
      Tbl_TableAddColumn(newTable,var,1);
    }  
  }

  /* add rows to this table */

  TblTableForEachRow(table, row, rowNum){
    i = Tbl_TableAddRow(newTable);
  }

  for (rowNum =0; rowNum < Tbl_TableReadNumRows(table); rowNum++ ) {
    for (colNum =0; colNum < Tbl_TableReadNumInputs(table); colNum++) {
      if (st_lookup_int(supLookup, (char*)(long) colNum, &newColNum) == 1) {
        entry = Tbl_TableReadEntry(table,rowNum, colNum, 0);
        newEntry = Tbl_EntryDup(entry);              
        if (Tbl_EntryIsEqual(entry)) {
          eqColNum = Tbl_EntryReadVarIndex(entry);
          if (st_lookup_int(supLookup,(char*)(long)eqColNum,&newEqColNum) == 0) {
            fail("Entry Equal Var not in True Support\n");
          }
          else {
            Tbl_EntrySetEqual(newEntry,newEqColNum);
          }
        }
        Tbl_TableSetEntry(newTable, newEntry, rowNum, newColNum, 0);      
      }
    }
  }


  for (rowNum =0; rowNum < Tbl_TableReadNumRows(table); rowNum++ ) {
    entry = Tbl_TableReadEntry(table,rowNum, outIndex, 1);
    newEntry = Tbl_EntryDup(entry);
    if (entry->type == Tbl_EntryEqual_c) {
      eqColNum = Tbl_EntryReadVarIndex(entry);
      if (st_lookup_int(supLookup,(char*)(long)eqColNum,&newEqColNum) == 0) {
        fail("Entry Equal Var not in True Support\n");
      }
      else {
        Tbl_EntrySetEqual(newEntry,newEqColNum);
      }
    }
    Tbl_TableSetEntry(newTable, newEntry, rowNum, 0, 1);
  }
  st_free_table(supLookup);


  Tbl_TableForEachDefaultEntry(table,entry,i) {
    if (i==outIndex) {        
      if (entry != NIL(Tbl_Entry_t)) {
        if (entry->type != Tbl_EntryEqual_c) {
          newEntry = Tbl_EntryDup(entry);
        }
        else{
          eqColNum =
            Tbl_TableReadVarIndex(newTable,Tbl_EntryReadVar(table,entry),0);
          if (eqColNum != -1) {
            newEntry = Tbl_EntryDup(entry);
            Tbl_EntrySetEqual(newEntry,eqColNum);
          }
          else {
            newEntry = NIL(Tbl_Entry_t);
          }
        }
      }
      else {
        newEntry = NIL(Tbl_Entry_t);
      }
      (void) Tbl_TableDefaultSetEntry(newTable,newEntry,0);
    }
  }

  return newTable;
}

boolean
Tbl_TableSwapRows(
  Tbl_Table_t *  table,
  int  i,
  int  j)
{
  Tbl_Row_t *rowi, *rowj;
    
  assert(table !=NIL(Tbl_Table_t));
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by swapping these rows\n");
  }
  
  rowi = TblTableReadRow(table,i);
  rowj = TblTableReadRow(table,j);
  TblTableSetRow(table,rowi,j);
  TblTableSetRow(table,rowj,i);

  return TRUE;
}
  

boolean
Tbl_TableSwapColumns(
  Tbl_Table_t *  table,
  int  i,
  int  j,
  int  flag)
{
  int k, rowNum,colNum,flag2;
  Tbl_Row_t *row UNUSED;
  Tbl_Entry_t *coli, *colj, *entry;
  array_t *rowArray;
  Var_Variable_t *vari, *varj;
    
  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));
  if (TblTableReadRefCount(table) > 1) {
    printf(" WARNING: You are modifying more than one table by swapping rows\n");
  }
  
  TblTableForEachRow(table,row,k) {
    coli = Tbl_EntryDup(Tbl_TableReadEntry(table,k,i,flag));
    colj = Tbl_EntryDup(Tbl_TableReadEntry(table,k,j,flag));    

    Tbl_TableSetEntry(table,coli,k,j,flag);
    Tbl_TableSetEntry(table,colj,k,i,flag);
  }

  if (flag == 0) {
    rowArray = table->inputNames;
  }
  else {
    rowArray = table->outputNames;
  }

  vari = array_fetch(Var_Variable_t*,rowArray,i);
  varj = array_fetch(Var_Variable_t*,rowArray,j);
  array_insert(Var_Variable_t*,rowArray,i,varj);
  array_insert(Var_Variable_t*,rowArray,j,vari);

  /* Correct Equal entries */
  Tbl_TableForEachEntry(table,rowNum,colNum,flag2,entry) {
    if (entry->type == Tbl_EntryEqual_c) {
      if (Tbl_EntryReadVarIndex(entry)==i){
        Tbl_EntrySetEqual(entry,j);
      }
      else if (Tbl_EntryReadVarIndex(entry)==j){
        Tbl_EntrySetEqual(entry,i);
      }      
    }
  }

  
  Tbl_TableForEachDefaultEntry(table,entry,colNum) {
    if (entry != NIL(Tbl_Entry_t)) {
    if (entry->type == Tbl_EntryEqual_c) {
      if (Tbl_EntryReadVarIndex(entry)==i){
        Tbl_EntrySetEqual(entry,j);
      }
      else if (Tbl_EntryReadVarIndex(entry)==j){
        Tbl_EntrySetEqual(entry,i);
      }      
    }
    }    
    }
  
  return TRUE;
}
      
void
Tbl_TableCanonicalize(
    Tbl_Table_t * table)
{
  int numRows, numInputs, numOutputs, rowNum, colNum;
  array_t *rowValArray;
  Tbl_Row_t *colVal;
  int i, val1,val2;
  

  numRows = Tbl_TableReadNumRows(table);
  numInputs = Tbl_TableReadNumInputs(table);
  numOutputs = Tbl_TableReadNumOutputs(table);
  
  rowValArray = TableCreatIntArray(numRows);
  colVal = ALLOC(Tbl_Row_t,1);
  colVal->inputs= TableCreatIntArray(numInputs);
  colVal->outputs= TableCreatIntArray(numOutputs);

  for(i=0; i< numRows; i++) {
    for(rowNum=0; rowNum< numRows-1; rowNum++) {
      if (Tbl_TableRowDominatesRow(table,rowNum,rowNum+1,rowValArray)) {
        Tbl_TableSwapRows(table,rowNum,rowNum+1);
        val1 = array_fetch(int,rowValArray,rowNum);
        val2 =array_fetch(int,rowValArray,rowNum+1);
        array_insert(int,rowValArray,rowNum,val2);
        array_insert(int,rowValArray,rowNum+1,val1);
      }
    }
  }

  for(i=0; i< numInputs; i++) {  
    for(colNum=0; colNum< numInputs-1; colNum++) {
      if (Tbl_TableColDominatesCol(table,colNum,colNum+1,0,colVal)) {
        Tbl_TableSwapColumns(table,colNum,colNum+1,0);
        val1 = array_fetch(int,TblRowReadInputs(colVal),colNum);
        val2 = array_fetch(int,TblRowReadInputs(colVal),colNum+1);
        array_insert(int,TblRowReadInputs(colVal),colNum,val2);
        array_insert(int,TblRowReadInputs(colVal),colNum+1,val1);
      }
    }
  }

  for(i=0; i< numOutputs; i++) {  
    for(colNum=0; colNum< numOutputs-1; colNum++) {
      if (Tbl_TableColDominatesCol(table,colNum,colNum+1,1,colVal)) {
        Tbl_TableSwapColumns(table,colNum,colNum+1,1);
        val1 = array_fetch(int,TblRowReadOutputs(colVal),colNum);
        val2 = array_fetch(int,TblRowReadOutputs(colVal),colNum+1);
        array_insert(int,TblRowReadOutputs(colVal),colNum,val2);
        array_insert(int,TblRowReadOutputs(colVal),colNum+1,val1);        
      }
    }
  }
  TblRowFree(colVal); 
  array_free(rowValArray);
}
boolean
Tbl_TableRowDominatesRow(
  Tbl_Table_t *table,
  int rowa,
  int rowb,
  array_t *rowValArray)  
{
  int valuea, valueb, totala, totalb;
  Tbl_Entry_t *entrya, *entryb;
  int colNum;

  

  valuea = array_fetch(int,rowValArray,rowa);
  totala = valuea;
  
  if (valuea == -1) {
    totala =0;    
    Tbl_RowForEachInputEntry(table,rowa,entrya,colNum) {
      valuea = TableEntryComputeHashVal(table,entrya);
      totala = valuea + totala;      
    }
    Tbl_RowForEachOutputEntry(table,rowa,entrya,colNum) {
      valuea = TableEntryComputeHashVal(table,entrya);
      totala = valuea + totala;      
    }        
    array_insert(int, rowValArray,rowa,totala);
  }

  valueb = array_fetch(int,rowValArray,rowb);
  totalb = valueb;
  
  if (valueb == -1) {
    totalb =0;    
    Tbl_RowForEachInputEntry(table,rowb,entryb,colNum) {
      valueb = TableEntryComputeHashVal(table,entryb);
      totalb = valueb + totalb;      
    }
    Tbl_RowForEachOutputEntry(table,rowb,entryb,colNum) {
      valueb = TableEntryComputeHashVal(table,entryb);
      totalb = valueb + totalb;      
    }        
    array_insert(int, rowValArray,rowb,totalb);
  }  
  
  if (totala < totalb ) {
    return FALSE;
  }
  else {
    return TRUE;
  }
}  

boolean
Tbl_TableColDominatesCol(
  Tbl_Table_t *table,
  int cola,
  int colb,
  int flag,
  Tbl_Row_t *colValArray)  
{

  int valuea, valueb, totala, totalb;
  Tbl_Entry_t *entrya, *entryb;
  int colNum, rowNum;
  
  if (flag == 0) {
    valuea = array_fetch(int,TblRowReadInputs(colValArray),cola);
  }
  else {
    valuea = array_fetch(int,TblRowReadOutputs(colValArray),cola);
  }

  totala = valuea;
  if (valuea == -1) {
  totala =0;
    if (flag ==0) {
      Tbl_TableForEachInputEntry(table,rowNum,colNum,entrya){
        if (colNum == cola) {
          valuea = TableEntryComputeHashVal(table,entrya);
          totala = valuea + totala;      
        }
      }
    array_insert(int, TblRowReadInputs(colValArray),cola,totala);      
    }
    else if (flag ==1) {
      Tbl_TableForEachOutputEntry(table,rowNum,colNum,entrya){
        if (colNum == cola) {    
          valuea = TableEntryComputeHashVal(table,entrya);
          totala = valuea + totala;      
        }
      }
    array_insert(int, TblRowReadOutputs(colValArray),cola,totala);      
    }
  }

  if (flag ==0) {
    valueb = array_fetch(int,TblRowReadInputs(colValArray),colb);
  }
  else {
    valueb = array_fetch(int,TblRowReadOutputs(colValArray),colb);
  }
  
  totalb = valueb;  
  if (valueb == -1) {
  totalb =0;  
    if (flag ==0) {
      Tbl_TableForEachInputEntry(table,rowNum,colNum,entryb){
        if (colNum == colb) {
          valueb = TableEntryComputeHashVal(table,entryb);
          totalb = valueb + totalb;      
        }
      }
    array_insert(int, TblRowReadInputs(colValArray),colb,totalb);      
    }
    else if (flag ==1) {
      Tbl_TableForEachOutputEntry(table,rowNum,colNum,entryb){
        if (colNum == colb) {    
          valuea = TableEntryComputeHashVal(table,entryb);
          totalb = valueb + totalb;      
        }
      }
    array_insert(int, TblRowReadOutputs(colValArray),colb,totalb);      
    }
  }
  
  if (totala < totalb ) {
    return FALSE;
  }
  else {
    return TRUE;
  }
}

boolean
Tbl_TablesAreIdentical(
    Tbl_Table_t *tablea,
    Tbl_Table_t *tableb,
    int a,
    int b)
{
  char *signaturea;
  char *signatureb;

  signaturea = TableObtainSignature(tablea, a);
  signatureb = TableObtainSignature(tableb, b);  
  if (strcmp(signaturea, signatureb) == 0) {
    FREE(signaturea);
    FREE(signatureb);    
    return TRUE;
  }
  FREE(signaturea);
  FREE(signatureb);    
  return FALSE;
}



mdd_t *
Tbl_TableRowToMdd(
  Tbl_Table_t *  table,
  mdd_manager *  manager,
  int  i,
  array_t *  svArray /* array of array of mdd_t to be used */)
{
  mdd_t *result, *finalResult, *temp;
  int j,k;
  Tbl_Entry_t *entry;
  Mvf_Function_t *mvf1, *mvf2;
    

  result = NIL(mdd_t);
  finalResult = mdd_one(manager);
    
  Tbl_RowForEachInputEntry(table,i,entry,j) {
    if ((entry->type) == Tbl_EntryNormal_c) {
      mvf1 = array_fetch(Mvf_Function_t*,svArray,j);
      result = TblEntryNormalConstructMdd(manager,entry,mvf1);
    }
    else if ((entry->type == Tbl_EntryEqual_c)) {
      k = Tbl_EntryReadVarIndex(entry);
      mvf1 = array_fetch(Mvf_Function_t*,svArray,j);
      mvf2 = array_fetch(Mvf_Function_t*,svArray,k);
      result = Mvf_FunctionsComputeEquivalentSet(mvf1,mvf2);
    }
    else if (entry->type == Tbl_EntryUnassigned_c) {
      return NIL(mdd_t);
    }
        
    temp = finalResult;
    finalResult = mdd_and(temp,result,1,1);
    mdd_free(temp);
    mdd_free(result);
  }
    
  Tbl_RowForEachOutputEntry(table,i,entry,j) {
    if ((entry->type) == Tbl_EntryNormal_c) {
      mvf1 = array_fetch(Mvf_Function_t*,svArray,j);
      result = TblEntryNormalConstructMdd(manager,entry,mvf1);
    }
    else if ((entry->type == Tbl_EntryEqual_c)) {
      k = Tbl_EntryReadVarIndex(entry);
      mvf1 = array_fetch(Mvf_Function_t*,svArray,j);
      mvf2 = array_fetch(Mvf_Function_t*,svArray,k);
      result = Mvf_FunctionsComputeEquivalentSet(mvf1,mvf2);
    }
    else if (entry->type == Tbl_EntryUnassigned_c) {
      return NIL(mdd_t);
    }
    
    temp = finalResult;
    finalResult = mdd_and(temp,result,1,1);
    mdd_free(temp);
    mdd_free(result);
  }
  return finalResult;
}


Mvf_Function_t *
Tbl_TableBuildNonDetConstantMvf(
  Tbl_Table_t * table,
  int outIndex,
  int mddId,
  mdd_manager *  mddMgr)
{

  lsGen gen;
  Tbl_Entry_t *entry;
  Tbl_Range_t *range;
  int value, rowNum, colNum;
  mdd_t *x;
  Mvf_Function_t *function;
  
  assert(Tbl_TableReadNumInputs(table) ==0);

  value = Var_VariableReadNumValues(Tbl_TableReadIndexVar(table,outIndex,1));
  function = Mvf_FunctionAlloc(mddMgr,value);
  
  Tbl_TableForEachOutputEntry(table,rowNum,colNum,entry) {
    if (colNum == outIndex) {
      assert(entry->type == Tbl_EntryNormal_c);
      Tbl_EntryForEachValue(entry,value,gen,range) {
        x = mdd_eq_c(mddMgr,mddId,value);
        Mvf_FunctionAddMintermsToComponent(function, value,x);
        mdd_free(x);
      }
    }
  }
  return function;
}


Mvf_Function_t *
Tbl_TableBuildMvfFromFanins(
  Tbl_Table_t * table,
  int outIndex,
  array_t * faninArray,
  mdd_manager *  mddMgr)
{

  lsGen gen;
  Tbl_Entry_t *entry, *entry2,*inputEntry;
  Tbl_Range_t *range;
  int value, rowNum, colNum, rowColNum, i;
  mdd_t *x, *result, *temp;
  Mvf_Function_t *function, *mvf1, *mvf2;
  

  x = NIL(mdd_t);
  value = Var_VariableReadNumValues(Tbl_TableReadIndexVar(table,outIndex,1));
  function = Mvf_FunctionAlloc(mddMgr,value);
  
  Tbl_TableForEachOutputEntry(table,rowNum,colNum,entry) {
    if (colNum == outIndex) {
      if (entry->type == Tbl_EntryNormal_c) {
        result = mdd_one(mddMgr);
        Tbl_RowForEachInputEntry(table,rowNum,inputEntry,rowColNum) {
          if (inputEntry->type == Tbl_EntryNormal_c) {
            mvf1 = array_fetch(Mvf_Function_t*,faninArray,rowColNum);
            x = TblEntryNormalConstructMdd(mddMgr,inputEntry,mvf1);
          }
          else if (inputEntry->type == Tbl_EntryEqual_c) {
            value =Tbl_EntryReadVarIndex(inputEntry);
            mvf1 = array_fetch(Mvf_Function_t*,faninArray,rowColNum);
            mvf2 = array_fetch(Mvf_Function_t*,faninArray,value);
            x = Mvf_FunctionsComputeEquivalentSet(mvf1,mvf2);
          }
          temp = result;
          result = mdd_and(x,temp,1,1);
          mdd_free(temp);
          mdd_free(x);
        }
        Tbl_EntryForEachValue(entry,value,gen,range) {  
          Mvf_FunctionAddMintermsToComponent(function, value,result);
        }
        mdd_free(result);
      }
      else  if (entry->type == Tbl_EntryEqual_c) {
        value = Tbl_EntryReadVarIndex(entry);
        if (value == -1) {
        fail("Failure: Not equal to any input var in this table\n");
        }
        
          
        /* must be equal to an input */
        
        entry2 = Tbl_TableReadEntry(table,rowNum,value,0);
        result = mdd_one(mddMgr);
        Tbl_RowForEachInputEntry(table,rowNum,inputEntry,rowColNum) {
          if (inputEntry->type == Tbl_EntryNormal_c) {
            mvf1 = array_fetch(Mvf_Function_t*,faninArray,rowColNum);
            x = TblEntryNormalConstructMdd(mddMgr,inputEntry,mvf1);
          }
          else if (inputEntry->type == Tbl_EntryEqual_c) {
            value =Tbl_EntryReadVarIndex(inputEntry);
            mvf1 = array_fetch(Mvf_Function_t*,faninArray,rowColNum);
            mvf2 = array_fetch(Mvf_Function_t*,faninArray,value);
            x = Mvf_FunctionsComputeEquivalentSet(mvf1,mvf2);
          }
          temp = result;
          result = mdd_and(x,temp,1,1);
          mdd_free(temp);
          mdd_free(x);
        }

        rowColNum = Tbl_EntryReadVarIndex(entry);
        mvf1 = array_fetch(Mvf_Function_t*,faninArray,rowColNum);        
        value = Var_VariableReadNumValues(Tbl_EntryReadActualVar(table,entry2));
        temp = result;

        for(i=0; i< value; i++) {
          x = Mvf_FunctionReadComponent(mvf1,i);
          result = mdd_and(temp,x,1,1);
          Mvf_FunctionAddMintermsToComponent(function, i,result);
          mdd_free(result);
        }
        mdd_free(temp);
      }  
    }
  }

  /* accounting for the defaults */
  entry = Tbl_TableDefaultReadEntry(table,outIndex);
  if (entry != NIL(Tbl_Entry_t)) {  
    temp = Mvf_FunctionComputeDomain(function);
    result = mdd_not(temp);
    mdd_free(temp);

    if (entry->type == Tbl_EntryNormal_c) {    
      Tbl_EntryForEachValue(entry,value,gen,range) {
        Mvf_FunctionAddMintermsToComponent(function, value,result);
      }
    }
    else {
      value = Tbl_EntryReadVarIndex(entry);
      if (value == -1) {
        fail("Failure: Not equal to any input var in this table\n");
      }
      mvf1 = array_fetch(Mvf_Function_t*,faninArray,value);
      
      Mvf_FunctionForEachComponent(mvf1,i,x) {
        temp = mdd_and(x,result,1,1);
        Mvf_FunctionAddMintermsToComponent(function, i ,temp);
        mdd_free(temp);
      }
    }
    
    mdd_free(result);    
  }
        
  return function;  
}

  
        
int
Tbl_TableReadConstValue(
  Tbl_Table_t * table,
  int outputColumnId)
{
  int colNum, rowNum;
  boolean check;
  Tbl_Entry_t *entry;
  Var_Variable_t *var;
  Tbl_Range_t *range;
  lsGen gen;
  int value, constant,count;
  

  constant = -1;
  assert(table !=NIL(Tbl_Table_t));
  assert((outputColumnId >= 0) && (outputColumnId <
                                   Tbl_TableReadNumOutputs(table)));

  if (Tbl_TableReadNumRows(table) == 1) {  
    if (array_n(table->inputNames) == 0) {
      entry = Tbl_TableReadEntry(table, 0, outputColumnId, 1);
      if (entry->type == Tbl_EntryNormal_c) {
        if (Tbl_EntryReadNumValues(entry) == 1) {
          Tbl_EntryForEachValue(entry,value,gen,range) {
            constant = value;
          }
          return constant;
        }
      }
    }
    else {
      check = TRUE;
      Tbl_TableForEachInputEntry(table,rowNum,colNum,entry) {
        if (entry->type != Tbl_EntryNormal_c) {
          return -1;
        }
        if (check == TRUE) {
          check = -1;
          if (lsLength(entry->EntryData.listOfRanges) == 1){
            var = Tbl_EntryReadActualVar(table,entry);
            lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
              if ((range->begin ==0)&&(range->end ==
                                       Var_VariableReadNumValues(var)-1)){
                check = TRUE;
              }
            }
          }
        }
      }
      
      if (check) {
        entry = Tbl_TableReadEntry(table,0,outputColumnId,1);
        if (entry->type != Tbl_EntryNormal_c) {
          return -1;
        }            
        if (Tbl_EntryReadNumValues(entry) == 1) {
          Tbl_EntryForEachValue(entry,value,gen,range) {
            constant = value;
          }
          return constant;
        }
      }
    }
  }
  else if (Tbl_TableReadNumRows(table) == 0) {
    entry = Tbl_TableDefaultReadEntry(table,outputColumnId);
    if (entry->type != Tbl_EntryNormal_c) {
      return -1;
    }    
    if (Tbl_EntryReadNumValues(entry) == 1) {
      Tbl_EntryForEachValue(entry,value,gen,range) {
        constant = value;
      }
      return constant;      
    }
  }
  else {
    entry = Tbl_TableDefaultReadEntry(table,outputColumnId);    
    if (entry == NIL(Tbl_Entry_t)){
      constant = -1;
      Tbl_TableForEachOutputEntry(table,rowNum,colNum,entry) {
        if (colNum == outputColumnId) {
          count = 1;
        if (entry->type != Tbl_EntryNormal_c){
          return -1;
        }          
          Tbl_EntryForEachValue(entry,value,gen,range) {
            lsStatus status;
            if (count > 1) {
              status = lsFinish(gen); 
              assert(status == LS_OK);
              return -1;
            }
            else {
              if (constant != -1) {
                if (constant != value) {
                  status = lsFinish(gen); 
                  assert(status == LS_OK); 
                  return -1;
                }
              }
              else {
                constant = value;
              }
            }
            count ++;        
          }
        }
      }
      return constant;
    }
  }
  
  return -1;
}

Tbl_Table_t *
Tbl_MddToTable(
  mdd_t *  mdd,
  mdd_manager *  manager,
  st_table *  idtoVar,
  array_t * inputids)
{
  /* use foreach cube */
  printf("Not implemented as yet, contact gms@ic\n");
  return NIL(Tbl_Table_t);
}


boolean
Tbl_TableSubstituteVar(
  Tbl_Table_t *  table,
  Var_Variable_t *  oldVar,
  Var_Variable_t *  newVar)
{
  int i,k;
  int flag;
  Var_Variable_t *var;


  k = -1;
  flag =0;
  var = NIL(Var_Variable_t);

  if (!Var_VariablesTestHaveSameDomain(oldVar,newVar)) return FALSE;

  if (table != NIL(Tbl_Table_t)) {
    Tbl_TableForEachInputVar(table,i,var) {
      if (var == oldVar) {
        k = i;
        i = Tbl_TableReadNumInputs(table);
        flag = 0;
      }
    }
    if (k == -1) {
      Tbl_TableForEachOutputVar(table,i,var) {
        if (var == oldVar) {
          k = i;
          i = Tbl_TableReadNumOutputs(table);
          flag = 1;
        }
      }
    }
    if (k != -1) {
      Tbl_TableSetVar(table,k,newVar,flag);
      /* traverse all the entries of the table and change all the references
      to the old variable in the equal-to construct to the new variable */
      /* The above no longer has to be done as the entry refers to an
         index rather than the var */
      return TRUE;
    }
    else {
      return FALSE;
    }
  }
  return FALSE;
}

void
Tbl_TableSetVar(
  Tbl_Table_t * table,
  int i,
  Var_Variable_t * sv,
  int flag)
{
  array_t *svarray;
  
  if (flag==0){
    svarray = Tbl_TableReadInputVars(table);
  }
  else {
    svarray = Tbl_TableReadOutputVars(table);
  }
  
  array_insert(Var_Variable_t*,svarray,i,sv);
}

array_t *
Tbl_TableSplit(
  Tbl_Table_t *  table)
{
  int i,j, rowNum, colNum;
  array_t *resArray;
  Tbl_Table_t *newtable;
  Var_Variable_t *output, *input;
  Tbl_Entry_t *entry, *newEntry;
    

  resArray = array_alloc(Tbl_Table_t*,0);
    
  Tbl_TableForEachOutputVar(table,i,output) {
    newtable = Tbl_TableAlloc();
    Tbl_TableAddColumn(newtable,output,1);
    Tbl_TableForEachInputVar(table,colNum,input) {
      Tbl_TableAddColumn(newtable,input,0);
    }
    for (rowNum =0; rowNum < Tbl_TableReadNumRows(table); rowNum++) {
      (void) Tbl_TableAddRow(newtable);
    }
    
    Tbl_TableForEachEntry(table,rowNum,colNum,j,entry) {
      if (j==0) {
        newEntry = Tbl_EntryDup(entry);
        Tbl_TableSetEntry(newtable,newEntry,rowNum,colNum,0);
      }
      else {
        if (colNum ==i) {
          newEntry = Tbl_EntryDup(entry);
          Tbl_TableSetEntry(newtable,newEntry,rowNum,0,1);
        }
      }
    }
    entry = Tbl_TableDefaultReadEntry(table,i);
    if (entry != NIL(Tbl_Entry_t)) {
      newEntry = Tbl_EntryDup(entry);
      Tbl_TableDefaultSetEntry(newtable,newEntry,0);
    }
    
    array_insert_last(Tbl_Table_t*,resArray,newtable);
  }
  return resArray;
}
  

int 
Tbl_TableReadNumInputs(
    Tbl_Table_t * table)
{
  return(array_n(table->inputNames));
    
}
  

int
Tbl_TableReadNumOutputs(
  Tbl_Table_t *  table)
{
  return(array_n(table->outputNames));
}
  
int
Tbl_TableReadNumVars(
  Tbl_Table_t *table,
  int flag)
{
  if (flag==0) {
    return Tbl_TableReadNumInputs(table);
  }
  else {
    return Tbl_TableReadNumOutputs(table);
  }
}

int
Tbl_TableReadNumRows(
  Tbl_Table_t *  table)
{
  return(array_n(TblTableReadData(table)));
}
  
int
Tbl_TableReadVarIndex(
  Tbl_Table_t *  table,
  Var_Variable_t *  var,
  int  flag /* Set to 0 if it is an input Var and 1 if it an output Var */
)
{
  int i;
  array_t *carray;
  Var_Variable_t *aVar;

  assert(table !=NIL(Tbl_Table_t));
  assert((flag==0)||(flag ==1));  
  
  if (flag==0) {
    carray = table->inputNames; 
  }
  else {
    carray = table->outputNames; 
  }
            
  for (i=0; i< array_n(carray);i++) {
    aVar = array_fetch(Var_Variable_t*,carray,i);
    if (var==aVar) {
      return i;
    }
  }
  return -1;
}

void
Tbl_TablePrintStats(
  Tbl_Table_t *table,
    FILE *fp)
{
  int rowNum, colNum,i,dc, total;
  Tbl_Entry_t *entry;
  Var_Variable_t *var;
  lsGen gen;
  Tbl_Range_t *range;

  fprintf(fp,"Table Stats\n");   
  fprintf(fp,"Number of  Inputs           = %d\n",Tbl_TableReadNumInputs(table));
  
  fprintf(fp,"Inputs                      :"); 
  Tbl_TableForEachInputVar(table,colNum,var){
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  fprintf(fp,"\n");
  fprintf(fp,"Values                      :");
  
  Tbl_TableForEachInputVar(table,colNum,var){
    fprintf(fp,"%d ",Var_VariableReadNumValues(var));
  }
  fprintf(fp,"\n");  
  
  fprintf(fp,"Number of  Outputs          = %d\n",Tbl_TableReadNumOutputs(table));
  
  fprintf(fp,"Outputs                     :");
  
  Tbl_TableForEachOutputVar(table,colNum,var){
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  fprintf(fp,"\n");
  fprintf(fp,"Values                      :");
  Tbl_TableForEachOutputVar(table,colNum,var){
    fprintf(fp,"%d ",Var_VariableReadNumValues(var));
  }
  fprintf(fp,"\n");    
  fprintf(fp,"Number of  Rows             = %d\n",Tbl_TableReadNumRows(table));

  dc = 0;
  total =0;
  Tbl_TableForEachEntry(table,rowNum,colNum,i,entry) {
    total++;
    if(entry->type == Tbl_EntryNormal_c) {    
      if (lsLength(entry->EntryData.listOfRanges) == 1){
        var = Tbl_EntryReadActualVar(table,entry);
        lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
          if ((range->begin ==0)&&(range->end == Var_VariableReadNumValues(var)-1)){
            dc++;
          }
        }
      }
    }
  }
  if (total > 0) {
    i = 100 *dc/total;
  }
  else {
    i = 0;
  }
  
  fprintf(fp,"# Don't Care entries        = %d\n",dc);
  fprintf(fp,"Percent Don't Care entries  = %d\n",i);    
}


void
Tbl_TableWriteBlifMvToFileSpecial(
    Tbl_Table_t *table,
    int flag,
    FILE *fp)
{
  int rowNum, colNum,i;
  Tbl_Entry_t *entry;
  Var_Variable_t *var;
    

  if (flag ==0) {
    fprintf(fp,".table "); 
  }
  else {
    fprintf(fp,".reset ");
  }
    
  Tbl_TableForEachInputVar(table,colNum,var){
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  fprintf(fp,"->"); 
  Tbl_TableForEachOutputVar(table,colNum,var){
    fprintf(fp,"%s_bufin ",Var_VariableReadName(var));
  }
  fprintf(fp,"\n");

  if ((array_fetch(Tbl_Entry_t*, TblTableReadDefaults(table),0)) != NIL(Tbl_Entry_t)) {
    fprintf(fp,".default ");
    Tbl_TableForEachDefaultEntry(table,entry,colNum) {
      TblEntryWriteBlifMv(table,entry,fp);
      fprintf(fp," ");
    }
    fprintf(fp,"\n");
  }

   Tbl_TableForEachEntry(table, rowNum,colNum,i,entry) { 
    TblEntryWriteBlifMv(table,entry,fp);
    fprintf(fp," ");    
    if ((colNum == (Tbl_TableReadNumOutputs(table) -1))&&(i==1)) {
      fprintf(fp,"\n");
    }
  }
}

void
Tbl_TableWriteBlifMvToFile(
    Tbl_Table_t *table,
    int flag,
    FILE *fp)
{
  int rowNum, colNum,i;
  Tbl_Entry_t *entry;
  Var_Variable_t *var;
    

  if (flag == 0) {
    fprintf(fp,".table "); 
  }
  else if (flag == 1) {
    fprintf(fp,".reset ");
  }

  if (flag < 2) {
    Tbl_TableForEachInputVar(table,colNum,var){
      fprintf(fp,"%s ",Var_VariableReadName(var));
    }
    fprintf(fp,"->"); 
    Tbl_TableForEachOutputVar(table,colNum,var){
      fprintf(fp," %s",Var_VariableReadName(var));
    }
    fprintf(fp,"\n");
  }

  if ((array_fetch(Tbl_Entry_t*, TblTableReadDefaults(table),0)) != NIL(Tbl_Entry_t)) {
    fprintf(fp,".default");
    Tbl_TableForEachDefaultEntry(table,entry,colNum) {
      fprintf(fp," ");
      TblEntryWriteBlifMv(table,entry,fp);
    }
    fprintf(fp,"\n");
  }

   Tbl_TableForEachEntry(table,rowNum,colNum,i,entry) { 
    TblEntryWriteBlifMv(table,entry,fp);
    if ((colNum == (Tbl_TableReadNumOutputs(table) -1))&&(i==1)) {
      fprintf(fp,"\n");
    } else {
      fprintf(fp," ");    
    }
  }
}

void
Tbl_TableWriteSmvToFile(
    Tbl_Table_t *table,
    int flag,
    FILE *fp)
{
  int rowNum, colNum,i;
  Tbl_Entry_t *entry;
  Var_Variable_t *var;

  if (flag ==0) { 
    fprintf(fp,"\n-- Table for ");
  }
  else {
    fprintf(fp,"\n-- Reset table for ");
  }
  Tbl_TableForEachInputVar(table,colNum,var){
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  fprintf(fp,"->"); 
  Tbl_TableForEachOutputVar(table,colNum,var){
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  fprintf(fp,"\n");

  if (flag ==0) { 

    fprintf(fp, "INVAR\n( ");

    Tbl_TableForEachEntry(table, rowNum,colNum,i,entry) { 
      TblEntryWriteSmv(table,entry,0,fp);
      if ((colNum == (Tbl_TableReadNumOutputs(table) -1))&&(i==1)) {
        if(rowNum < Tbl_TableReadNumRows(table) -1) {
            fprintf(fp,") |\n( ");
        }
      } else {
        fprintf(fp,"& ");    
      }
    }
    
    if ((array_fetch(Tbl_Entry_t*, TblTableReadDefaults(table),0)) != NIL(Tbl_Entry_t)) {
      fprintf(fp,") |\n( ");
   
      if (Tbl_TableReadNumInputs(table) > 0) {
        fprintf(fp,"!( (");
      }
      Tbl_TableForEachInputEntry(table, rowNum,colNum,entry) { 
        TblEntryWriteSmv(table,entry,0,fp);
        if (colNum == (Tbl_TableReadNumInputs(table) -1)) {
          if(rowNum < Tbl_TableReadNumRows(table) -1) {
            fprintf(fp,") | ( ");
          }
        } else {
          fprintf(fp,"& ");    
        }
      }
      if (Tbl_TableReadNumInputs(table) > 0) {
        fprintf(fp,") ) & ");
      }
      
      Tbl_TableForEachDefaultEntry(table,entry,colNum) {
        TblEntryWriteSmv(table,entry,0,fp);
        if (colNum < (Tbl_TableReadNumOutputs(table) -1)) {
          fprintf(fp,"& ");    
        }
      }
    }
    fprintf(fp,")\n");

  } else {

    fprintf(fp,"case\n");

    Tbl_TableForEachEntry(table, rowNum,colNum,i,entry) { 
      TblEntryWriteSmv(table,entry,i,fp);
      if ((colNum == (Tbl_TableReadNumInputs(table) -1))&&(i==0)) {
        fprintf(fp,": ");
      } else if ((colNum == (Tbl_TableReadNumOutputs(table) -1))&&(i==1)) {
        fprintf(fp,";\n");    
      } else {
        fprintf(fp,"& ");    
      }
    }
    
    if ((array_fetch(Tbl_Entry_t*, TblTableReadDefaults(table),0)) != NIL(Tbl_Entry_t)) {
      fprintf(fp,"1 : ");
      
      Tbl_TableForEachDefaultEntry(table,entry,colNum) {
        TblEntryWriteSmv(table,entry,1,fp);
      }
      fprintf(fp,";\n");
    }

    fprintf(fp,"esac;\n");
  }
    
}

 

void
Tbl_TableWriteBlifToFile(
  Tbl_Table_t *table,
  FILE *fp    
    )
{                     
  int numInputs, numOutputs, numRows, colnum, i, j;
  Var_Variable_t *var;
  Tbl_Entry_t *entry;
  lsGen gen;
  Tbl_Range_t *range;
  int value, flag;


  fprintf(fp,".names ");     
  for (colnum=0; colnum < Tbl_TableReadNumInputs(table); colnum++) {
    var = Tbl_TableReadIndexVar(table, colnum, 0);
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  for (colnum=0; colnum < Tbl_TableReadNumOutputs(table); colnum++) {
    var = Tbl_TableReadIndexVar(table, colnum, 1);
    fprintf(fp,"%s ",Var_VariableReadName(var));
  }
  fprintf(fp,"\n");


  numInputs = Tbl_TableReadNumInputs(table);
  numOutputs = Tbl_TableReadNumOutputs(table);
  numRows = Tbl_TableReadNumRows(table);


  for (i=0; i < numRows; i++) {
    flag =1;
  
    if (numOutputs == 1) {
      entry =  Tbl_TableReadEntry(table, i, 0, 1);
      if (Tbl_EntryReadNumValues(entry) ==1 ){
        Tbl_EntryForEachValue(entry,value,gen,range){
          if (value ==0) {
            flag = 0;
          }
        }
      }
    }
    if (flag ==1) {      
      for(j = 0; j < numInputs; j++){
        entry = Tbl_TableReadEntry(table, i, j, 0);
        TblEntryWriteBlif(table,entry,fp);
      }
      fprintf(fp," ");
    
      for(j = 0; j < numOutputs; j++){
        entry = Tbl_TableReadEntry(table, i, j, 1);
        TblEntryWriteBlif(table,entry,fp);
      }
      fprintf(fp,"\n");      
    }
  }
}


array_t*
Tbl_TableReadDefaults(
    Tbl_Table_t * table)
{
  return (table->data->defaults);
}

array_t*
Tbl_TableReadInputVars(
    Tbl_Table_t * table)
{
  return (table->inputNames);
}

array_t*
Tbl_TableReadOutputVars(
    Tbl_Table_t * table)
{
  return (table->outputNames);
}


boolean
Tbl_RowInputIntersect(
  Tbl_Table_t * table,
  int a,
  int b)
{
  int colNum, check;
  Tbl_Entry_t *entrya, *entryb;
  Tbl_Row_t *rowb;
  
  check = FALSE;
  rowb = TblTableReadRow(table,b);
  
  Tbl_RowForEachInputEntry(table,a, entrya, colNum){
    entryb = TblRowReadEntry(rowb,colNum,0);
    check = Tbl_EntryTestIntersectEntry(entrya,entryb);

    if (check == FALSE) {
      return FALSE;
    }    
  }
  return TRUE;    
}


boolean
Tbl_RowOutputIntersect(
  Tbl_Table_t * table,
  int a,
  int b)
{
  int colNum, check;
  Tbl_Entry_t *entrya, *entryb;
  Tbl_Row_t *rowb;
  
  check = FALSE;
  rowb = TblTableReadRow(table,b);
  
  Tbl_RowForEachOutputEntry(table,a, entrya, colNum){
    entryb = TblRowReadEntry(rowb,colNum,1);
    check = Tbl_EntryTestIntersectEntry(entrya,entryb);

    if (check == FALSE) {
      return FALSE;
    }    
  }
  return TRUE;    

}

/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/
void
TblTableSetRow(
  Tbl_Table_t *table,
  Tbl_Row_t *row,
  int i)
{
  array_insert(Tbl_Row_t*, TblTableReadData(table),i,row);
}

array_t*
TblRowReadOutputs(
    Tbl_Row_t * row)
{
  return (row->outputs);
}

array_t*
TblRowReadInputs(
    Tbl_Row_t * row)
{
  return (row->inputs);
}

Tbl_Row_t*
TblTableReadRow(
  Tbl_Table_t *table,
  int rowNum)
{
  return(array_fetch(Tbl_Row_t*,TblTableReadData(table),rowNum));
}


Tbl_Row_t*
TblRowAlloc(void)
{
  Tbl_Row_t *row;

  row = ALLOC(Tbl_Row_t,1);
  row->inputs = array_alloc(Tbl_Entry_t*,0);
  row->outputs = array_alloc(Tbl_Entry_t*,0);

  return row;
}


Tbl_Row_t*
TblRowDup(
  Tbl_Row_t * row)
{
  Tbl_Row_t *newrow;
  Tbl_Entry_t *newEntry, *entry;
  int i;

  newrow = TblRowAlloc();

  for (i=0; i < array_n(row->inputs); i++){
    entry = array_fetch(Tbl_Entry_t*,row->inputs,i);
    if (entry != NIL(Tbl_Entry_t)) {
      newEntry= Tbl_EntryDup(entry);
    }
    else {
      newEntry = NIL(Tbl_Entry_t);
    }
    TblRowSetEntry(newrow,newEntry,i,0);
  }

  for (i=0; i < array_n(row->outputs); i++){
    entry = array_fetch(Tbl_Entry_t*,row->outputs,i);    
    if (entry != NIL(Tbl_Entry_t)) {
      newEntry = Tbl_EntryDup(entry);
    }
    else {
      newEntry = NIL(Tbl_Entry_t);
    }      
    TblRowSetEntry(newrow,newEntry,i,1);
  }
  return newrow;
}

void
TblRowSetEntry(
  Tbl_Row_t *row,
  Tbl_Entry_t * entry,
  int i,
  int flag)
{
  array_t *carray;
  
  if (flag ==0) {
    carray = TblRowReadInputs(row);
  }
  else {
    carray = TblRowReadOutputs(row);
  }
    
  if (i < array_n(carray)){
    array_insert(Tbl_Entry_t*,carray,i,entry);
  }
  else {
    array_insert_last(Tbl_Entry_t*,carray,entry);
  }
}

void
TblRowFree(
  Tbl_Row_t *row)
{
  assert(row != NIL(Tbl_Row_t));
  array_free(row->inputs);
  array_free(row->outputs);
  FREE(row);
}


Tbl_Entry_t*
TblRowReadEntry(
    Tbl_Row_t *row,
    int i,
    int flag)
{
  
  if (flag==0) {
    return(array_fetch(Tbl_Entry_t*,TblRowReadInputs(row),i));
  }
  else {
    return(array_fetch(Tbl_Entry_t*, TblRowReadOutputs(row),i));
  }
}


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

static int
TableEntryComputeHashVal(
  Tbl_Table_t *table,
  Tbl_Entry_t *entry)
{
  int numRows, numCols;
  lsGen gen;
  int value;
  Tbl_Range_t *range;
  int total;

  numRows = Tbl_TableReadNumRows(table);
  numCols = Tbl_TableReadNumInputs(table) + Tbl_TableReadNumOutputs(table) + numRows+1;
  total = 0;

  if(entry->type == Tbl_EntryNormal_c) {
    Tbl_EntryForEachValue(entry,value,gen,range) {
      total = total + (int) pow(numCols,value);
    }
  }
  else if(entry->type == Tbl_EntryEqual_c) {
    value = Var_VariableReadNumValues(Tbl_EntryReadActualVar(table,entry));
    total = total + (int) pow(numCols,value);
  }
  
  return total;
}

static array_t*
TableCreatIntArray(
  int size)
{
  array_t *result;
  int i;
  
  result = array_alloc(int,0);
  for (i=0; i < size; i++) {
    array_insert_last(int,result,-1);
  }
  return result;
}


static char*
TableObtainSignature(Tbl_Table_t * table,
                     int outputColumn)
{
  char *                signature;
  char *                sig;            /* Signature under construction */

  int                   row;            /* locations in the table */
  int                   column;

  Tbl_Entry_t *         entry;          /* Entry at row, column */

  int                   value;          /* Value of an entry */
  lsGen                 gen;            /* For Tbl_EntryForEachValue */
  Tbl_Range_t *         range;

  int                   varIndex;       /* Index of the column of this variable */

  /*
   * TODO: This is unsafe!
   */

  signature = ALLOC( char, 10000 );
  sig = signature;

  for ( row = Tbl_TableReadNumRows( table ) ; --row >=0 ; ) {

    /*
     * Print each of the inputs in this row
     */

    Tbl_RowForEachInputEntry( table, row, entry, column ) {

      switch ( Tbl_EntryReadType( entry ) ) {

        /*
         * An equality entry ("this column is equal to that column")
         */

      case Tbl_EntryEqual_c:

        /*
         * Find the column index, first assuming it's an input
         */

        varIndex = Tbl_EntryReadVarIndex(entry);

        sprintf( sig, "=%d", varIndex );
        sig += strlen( sig );
        break;

        /*
         * A normal range entry - print a comma-separated list of values
         */

      case Tbl_EntryNormal_c:
        Tbl_EntryForEachValue( entry, value, gen, range ) {
          sprintf(sig, "%d,", value );
          sig += strlen( sig );
        }
        break;

        /*
         * Unassigned -- append a "?"
         */

      case Tbl_EntryUnassigned_c:
        sig[0] = '?';
        sig++;
        break;
        /*
         * None of the Above -- we're in trouble
         */

      default:
        assert(0);
        break;

      }
      
      /*
       * Separate entries with spaces
       */
      
      sig[0] = ' ';
      sig++;

    }

    /*
     * Print the output column's entry
     */

    entry = Tbl_TableReadEntry( table, row, outputColumn, 1 );

    switch ( Tbl_EntryReadType( entry ) ) {

      /*
       * An equality entry ("this column is equal to that column")
       */

    case Tbl_EntryEqual_c:

      /*
       * Find the column index, first assuming it's an input
       */

      varIndex = Tbl_EntryReadVarIndex(entry);

      sprintf( sig, "=%d", varIndex );
      sig += strlen( sig );
      break;
      
      /*
       * A normal range entry - print a comma-separated list of values
       */
      
    case Tbl_EntryNormal_c:
      Tbl_EntryForEachValue( entry, value, gen, range ) {
        sprintf(sig, "%d,", value );
        sig += strlen( sig );
      }
      break;
      
      /*
       * Unassigned -- append a "?"
       */
      
    case Tbl_EntryUnassigned_c:
      sig[0] = '?';
      sig++;
      break;
      
      /*
       * None of the Above -- we're in trouble
       */
      
    default:
      assert(0);
      break;
      
    }

    /*
     * Separate rows with newlines
     */

    sig[0] = '\n';
    sig++;

  }

  /*
   * Terminate the signature string
   */

  sig[0] = '\0';

  return signature;
}     


static int
varCompare(const void *x, const void *y)
{
  Var_Ord_t *a = (Var_Ord_t *) x;
  Var_Ord_t *b = (Var_Ord_t *) y;
  return(a->rank - b->rank);
}