src/tbl/tblSweep.c

Go to the documentation of this file.

#include "tblInt.h"

static char rcsid[] UNUSED = "$Id: tblSweep.c,v 1.12 2009/04/11 18:26:45 fabio Exp $";

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

static void SetAdjustedEntry(Tbl_Table_t *table, Tbl_Entry_t *entry, int index, int rownum, int colnum, boolean flag);
static void SetEntry(Tbl_Table_t *newTable, Tbl_Entry_t *entry1, Tbl_Entry_t *entry2, int rownum, int colnum, int index, boolean flag);

/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/
Tbl_Table_t*
Tbl_TableCollapse(Tbl_Table_t* table1, Tbl_Table_t* table2,int index)
{
  int rownum, realRowNum, colnum,eqcolnum,count,check;
  Var_Variable_t *var;
  Tbl_Table_t *newTable;
  Tbl_Entry_t *entry1, *entry2;
  Tbl_Entry_t *testEntry;

  if (Tbl_TableReadNumOutputs(table2)==1){
    newTable = Tbl_TableAlloc();

    if (Tbl_TableReadNumRows(table2) !=0) {
      entry2 = Tbl_TableReadEntry(table2,0,0,1);
    }
    else {
      entry2 = Tbl_TableDefaultReadEntry(table2,0);
    }
    /* add every input column except collapsing input */
    for(colnum=0;colnum < Tbl_TableReadNumInputs(table1); colnum++) {
      if (colnum != index) {
        var = Tbl_TableReadIndexVar(table1,colnum,0);
        Tbl_TableAddColumn(newTable,var,0);
      }
    }
    for(colnum=0;colnum < Tbl_TableReadNumOutputs(table1); colnum++) {
      var = Tbl_TableReadIndexVar(table1,colnum,1);
      Tbl_TableAddColumn(newTable,var,1);
    }
    /*     (void) Tbl_TableAddRow(newTable); */


    realRowNum =0;
    eqcolnum = index;

    /* row by row, check if var has given constant value */
    for(rownum=0; rownum< Tbl_TableReadNumRows(table1); rownum++) {
      testEntry = Tbl_TableReadEntry(table1,rownum,index,0);
      assert(entry2->type == Tbl_EntryNormal_c);

      /* input column by column */
      if (testEntry->type == Tbl_EntryNormal_c){
        if (Tbl_EntryTestIntersectEntry(testEntry,entry2)){
          (void) Tbl_TableAddRow(newTable);

          for(colnum=0;colnum < Tbl_TableReadNumInputs(table1); colnum++) {
            entry1= Tbl_TableReadEntry(table1,rownum,colnum,0);
            SetEntry(newTable,entry1,entry2,realRowNum,colnum,index,0);
          }

          /* do outputs */
          for(colnum=0;colnum < Tbl_TableReadNumOutputs(table1); colnum++) {
            entry1= Tbl_TableReadEntry(table1,rownum,colnum,1);
            SetEntry(newTable,entry1,entry2,realRowNum,colnum,index,1);
          }
          realRowNum++;
        }
      }
      else if (testEntry->type == Tbl_EntryEqual_c){
        count = 0;
        check = 0;
        while(count<= Tbl_TableReadNumInputs(table1)){

          /* Find out the column the entry equal to
           * and set that column entry to constant value if
           * its is of type Equal. This gets propagated by the while count
           * loop until you find a non-equal entry, and then it checks
           * for an intersection. If no intersection, then it
           * nullifies the row. Alas, there was no easier way */
          if (testEntry->type == Tbl_EntryNormal_c){
            if (Tbl_EntryTestIntersectEntry(testEntry,entry2)){
              check = 1;
            }
            count = Tbl_TableReadNumInputs(table1)+1;
          }
          else {
            eqcolnum = Tbl_EntryReadVarIndex(testEntry);
            testEntry = Tbl_TableReadEntry(table1,rownum,eqcolnum,0);
          }
          if (count == Tbl_TableReadNumInputs(table1)){
            check = 1;
          }
          count ++;
        }

        if (check == 1) {
          (void) Tbl_TableAddRow(newTable);
          count = 0;
          eqcolnum = index;
          testEntry = Tbl_TableReadEntry(table1,rownum,index,0);
          while(count<= Tbl_TableReadNumInputs(table1)){
            if (testEntry->type == Tbl_EntryNormal_c){
              SetEntry(newTable,entry2,entry2,realRowNum,eqcolnum,index,0);
              count = Tbl_TableReadNumInputs(table1)+1 ;
            }
            else {
            eqcolnum = Tbl_EntryReadVarIndex(testEntry);
            testEntry = Tbl_TableReadEntry(table1,rownum,eqcolnum,0);
            count ++;
          }
          }
          /* end of while */
          /* fill in zero entries */
          for(colnum=0;colnum < Tbl_TableReadNumInputs(table1); colnum++) {
            entry1= Tbl_TableReadEntry(table1,rownum,colnum,0);
            SetAdjustedEntry(newTable,Tbl_EntryDup(entry1),index,rownum,colnum,0);
          }
          /* do outputs */
          for(colnum=0;colnum < Tbl_TableReadNumOutputs(table1); colnum++) {
            entry1= Tbl_TableReadEntry(table1,rownum,colnum,1);
            SetEntry(newTable,entry1,entry2,realRowNum,colnum,index,1);

          }
        }
          realRowNum++;
      }
    }
    Tbl_TableForEachDefaultEntry(table1,entry1,colnum) {
      entry2 = NIL(Tbl_Entry_t);

      if (entry1 != NIL(Tbl_Entry_t)) {
        if (entry1->type != Tbl_EntryEqual_c) {
          entry2 = Tbl_EntryDup(entry1);
        }
        else{
          eqcolnum = Tbl_EntryReadVarIndex(entry1);
          if ( eqcolnum < index) {
            entry2 = Tbl_EntryDup(entry1);
          }
          else {
            if ( eqcolnum > index) {
              entry2 = Tbl_EntryDup(entry1);
              Tbl_EntrySetEqual(entry2, eqcolnum -1);
            }
            else {
              entry2 = Tbl_EntryDup(Tbl_TableReadEntry(table2,0,0,1));
            }
          }
        }
      }
      (void) Tbl_TableDefaultSetEntry(newTable,entry2,colnum);
    }
    return newTable;
  }
  else {
    fail("The table is not constant\n");
    return NIL(Tbl_Table_t);  /* not reached */
  }
}


Tbl_Table_t *
Tbl_TableInvertBinaryInputColumn(
  Tbl_Table_t *table,
  int index
  )
{
  int rowNum, colNum;
  Tbl_Entry_t *entry;
  Tbl_Table_t *newTable;
  Var_Variable_t *var;

  var = Tbl_TableReadIndexVar(table, index, 0);
  if (Var_VariableReadNumValues(var) != 2 ||
      Var_VariableTestIsSymbolic(var)) return NIL(Tbl_Table_t);

  /* Check default entries.  We give up if any variable points to the column
   * to be complemented, because it's a rare case and it does not seem worth
   * the effort.
   */
  Tbl_TableForEachDefaultEntry(table, entry, colNum) {
    if (entry != NIL(Tbl_Entry_t) && Tbl_EntryIsEqual(entry)) {
      int eqColNum = Tbl_EntryReadVarIndex(entry);
      if (eqColNum == index) {
        return NIL(Tbl_Table_t);
      }
    }
  }

  newTable = Tbl_TableHardDup(table);

  Tbl_TableForEachInputVar(table, colNum, var) {
    Tbl_TableSetVar(newTable, colNum, var, 0);
  }

  Tbl_TableForEachOutputVar(table, colNum, var) {
    Tbl_TableSetVar(newTable, colNum, var, 1);
  }

  /* Get rid of equal entries in the output part that point to the
   * column to be negated.  We do not currently deal with equal
   * entries in the input part.  If we find one, we give up.
   */
  Tbl_TableForEachOutputEntry(newTable, rowNum, colNum, entry) {
    if (Tbl_EntryIsEqual(entry)) {
      int eqColNum = Tbl_EntryReadVarIndex(entry);
      if (eqColNum == index) {
        Tbl_Entry_t *eqEntry = Tbl_TableReadEntry(newTable, rowNum, index, 0);
        if (Tbl_EntryIsEqual(eqEntry) ||
            Tbl_EntryReadNumValues(eqEntry) == 0) {
          /* Tricky case: we give up. */
          Tbl_TableFree(newTable);
          return NIL(Tbl_Table_t);
        } else if (Tbl_EntryReadNumValues(eqEntry) == 1) {
          /* Downgrade the equality to a constant value. */
          Tbl_Entry_t *entry2 = Tbl_EntryDup(eqEntry);
          Tbl_TableSetEntry(newTable, entry2, rowNum, colNum, 1);
        } else {
          int i, j;
          Tbl_Entry_t *entry2;
          i = Tbl_TableAddRow(newTable);
          Tbl_RowForEachInputEntry(newTable, rowNum, entry2, j) {
            if (j == index) {
              Tbl_Entry_t *entry3 = Tbl_EntryAlloc(Tbl_EntryNormal_c);
              Tbl_Entry_t *entry4 = Tbl_EntryAlloc(Tbl_EntryNormal_c);
              Tbl_EntrySetValue(entry3, 0, 0);
              Tbl_EntrySetValue(entry4, 1, 1);
              Tbl_TableSetEntry(newTable, entry3, rowNum, j, 0);
              Tbl_TableSetEntry(newTable, entry4, i, j, 0);
            } else {
              Tbl_TableSetEntry(newTable, Tbl_EntryDup(entry2), i, j, 0);
            }
          }
          Tbl_RowForEachOutputEntry(newTable, rowNum, entry2, j) {
            if (Tbl_EntryIsEqual(entry2) &&
                Tbl_EntryReadVarIndex(entry) == index) {
              Tbl_Entry_t *entry3 = Tbl_EntryAlloc(Tbl_EntryNormal_c);
              Tbl_Entry_t *entry4 = Tbl_EntryAlloc(Tbl_EntryNormal_c);
              Tbl_EntrySetValue(entry3, 0, 0);
              Tbl_EntrySetValue(entry4, 1, 1);
              Tbl_TableSetEntry(newTable, entry3, rowNum, j, 1);
              Tbl_TableSetEntry(newTable, entry4, i, j, 1);
            } else {
              Tbl_TableSetEntry(newTable, Tbl_EntryDup(entry2), i, j, 1);
            }
          }
          continue;
        }
      }
    }
  }

  Tbl_TableForEachInputEntry(newTable, rowNum, colNum, entry) {
    if (Tbl_EntryIsEqual(entry)) {
      if (colNum == index) {
        Tbl_TableFree(newTable);
        return NIL(Tbl_Table_t);
      } else {
        int eqColNum = Tbl_EntryReadVarIndex(entry);
        if (eqColNum == index) {
          Tbl_TableFree(newTable);
          return NIL(Tbl_Table_t);
        }
      }
    } else if (colNum == index) {
      if (Tbl_EntryReadNumValues(entry) == 1) {
        Tbl_EntryComplement(entry, 0, 1);
      }
    }
  }

  return newTable;

} /* Tbl_TableInvertBinaryInputColumn */


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

boolean
TblTableDeleteLastRow(
  Tbl_Table_t* table)
{
  array_t *dataArray;
  Tbl_Row_t *row;
  int rowNum;

  dataArray = array_dup(TblTableReadData(table));
  array_free(TblTableReadData(table));
  TblTableReadData(table)= array_alloc(Tbl_Row_t*,0);
  for(rowNum=0; rowNum < (array_n(dataArray)-1); rowNum++) {
    row = array_fetch(Tbl_Row_t*,dataArray,rowNum);
    array_insert_last(Tbl_Row_t*,TblTableReadData(table),row);
  }
  return TRUE;
}

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


static void SetAdjustedEntry(
  Tbl_Table_t *table,
  Tbl_Entry_t *entry,
  int index,
  int rownum,
  int colnum,
  boolean flag)
{
  Tbl_Entry_t *newEntry;

  if (flag ==0) {
    if (colnum < index) {
      /* should free if necessary */
      newEntry = Tbl_TableReadEntry(table,rownum,colnum,0);
      if (newEntry==NIL(Tbl_Entry_t)) {
        Tbl_TableSetEntry(table,entry,rownum,colnum,0);
      }
      else {
        Tbl_EntryFree(entry);
      }
    }
    else if (colnum > index) {
      /* should free if necessary */
      newEntry = Tbl_TableReadEntry(table,rownum,colnum-1,0);
      if (newEntry==NIL(Tbl_Entry_t)) {
        Tbl_TableSetEntry(table,entry,rownum,colnum-1,0);
      }
      else {
        Tbl_EntryFree(entry);
      }
    }
    else {
      Tbl_EntryFree(entry);
    }
  }
  else {
    newEntry = Tbl_TableReadEntry(table,rownum,colnum,1);
    if (newEntry== NIL(Tbl_Entry_t)) {
      Tbl_TableSetEntry(table,entry,rownum,colnum,1);
    }
    else {
      Tbl_EntryFree(newEntry);
      Tbl_TableSetEntry(table,entry,rownum,colnum,1);

      }
    }
}

static void SetEntry(
Tbl_Table_t *newTable,
Tbl_Entry_t *entry1,
Tbl_Entry_t *entry2,
int rownum,
int colnum,
int index,
boolean flag)
{
  int varcolnum;
  Tbl_Entry_t *newEntry;


  if (entry1->type == Tbl_EntryNormal_c) {
    SetAdjustedEntry(newTable,Tbl_EntryDup(entry1),index,rownum,colnum, flag);
  }
  else {
    /* its of type equal */
    varcolnum = Tbl_EntryReadVarIndex(entry1);
    if (varcolnum < index) {
      SetAdjustedEntry(newTable,Tbl_EntryDup(entry1),index,rownum,colnum, flag);
    }
    else {
      if (varcolnum > index) {
        newEntry = Tbl_EntryDup(entry1);
        Tbl_EntrySetEqual(newEntry,varcolnum-1);
        SetAdjustedEntry(newTable,newEntry,index,rownum,colnum,flag);

      }
      else {
        SetAdjustedEntry(newTable,Tbl_EntryDup(entry2),index,rownum,colnum, flag);
      }
    }
  }
}