src/tbl/tblEntryUtil.c

Go to the documentation of this file.

#include "tblInt.h"

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

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

static int RangeCompare(lsGeneric entry1, lsGeneric entry2);
static void EntryCanonicalize(Tbl_Entry_t * entry);
static void EntryComplement(Tbl_Entry_t * entry, int min, int max);

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

Tbl_Entry_t*
Tbl_EntryAlloc(
  Tbl_EntryType_t  type)
{
  Tbl_Entry_t *entry;

  entry = ALLOC(Tbl_Entry_t,1);
  entry->type = type;
  if (type == Tbl_EntryEqual_c) {
    entry->EntryData.var = -1;
  }
  else if (type == Tbl_EntryNormal_c) {
    entry->EntryData.listOfRanges = lsCreate();
  }
  return entry;
}

void
Tbl_EntryFree(
  Tbl_Entry_t * entry)
{
  if (entry->type == Tbl_EntryNormal_c) {
    lsDestroy(entry->EntryData.listOfRanges,(void (*)(lsGeneric))TblRangeFree);
  }

  FREE(entry);
  entry = NIL(Tbl_Entry_t);
}
Tbl_Entry_t *
Tbl_EntryDup(
  Tbl_Entry_t *entry)
{
  Tbl_Entry_t *newEntry;
  lsGen gen;
  Tbl_Range_t *range;

  assert(entry != NIL(Tbl_Entry_t));
  assert(entry->type != Tbl_EntryUnassigned_c);

  newEntry = Tbl_EntryAlloc(entry->type);
  newEntry->ioType = entry->ioType;
  newEntry->varColNum = entry->varColNum;
  
  if (entry->type == Tbl_EntryNormal_c) {
    lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
      Tbl_Range_t *newRange = ALLOC(Tbl_Range_t,1);
      newRange->begin = range->begin;
      newRange->end = range->end;
      lsNewEnd(newEntry->EntryData.listOfRanges,(lsGeneric)newRange,LS_NH);     
 
    }
  }
  else if (entry->type == Tbl_EntryEqual_c) {
    newEntry->EntryData.var = entry->EntryData.var;
  }
  return newEntry;
}
        

void
Tbl_EntrySetValue(
  Tbl_Entry_t *  entry,
  int  val1,
  int  val2)
{
  Tbl_Range_t *range;

  assert(val2 >= val1);
  assert(val1 >= 0);

  entry->type = Tbl_EntryNormal_c;
  range  = ALLOC(Tbl_Range_t,1);
  range->begin = val1;
  range->end = val2;
  lsNewEnd(entry->EntryData.listOfRanges,(lsGeneric)range,LS_NH);
  EntryCanonicalize(entry);
}

Tbl_Entry_t*
Tbl_EntryMerge(
    Tbl_Entry_t* entry1,
    Tbl_Entry_t* entry2)
{
  lsGen gen, gen2,newGen;
  Tbl_Range_t *range, *newRange;
  Tbl_Entry_t *newEntry;
    
  if ((entry1->type == Tbl_EntryEqual_c)||(entry2->type ==
                                            Tbl_EntryEqual_c)) {
    return NIL(Tbl_Entry_t);
  }

  if ((entry1->type == Tbl_EntryUnassigned_c)||(entry2->type ==
                                                 Tbl_EntryUnassigned_c)) {
    return NIL(Tbl_Entry_t);
  }

  newEntry = Tbl_EntryAlloc(Tbl_EntryNormal_c);
  newGen = lsStart(newEntry->EntryData.listOfRanges);
  lsForEachItem(entry1->EntryData.listOfRanges, gen, range) {
    newRange = ALLOC(Tbl_Range_t,1);
    newRange->begin = range->begin;
    newRange->end = range->end;
    lsInAfter(newGen,(lsGeneric)newRange,LS_NH);
  }
  lsForEachItem(entry2->EntryData.listOfRanges, gen2, range) {
    newRange = ALLOC(Tbl_Range_t,1);
    newRange->begin = range->begin;
    newRange->end = range->end;
    lsInAfter(newGen,(lsGeneric)newRange,LS_NH);
  }
  EntryCanonicalize(newEntry);
  lsFinish(newGen);
  return newEntry;
}


void
Tbl_EntryComplement(
  Tbl_Entry_t *  entry,
  int min,
  int max)
{
  EntryComplement(entry, min, max);
  EntryCanonicalize(entry);
}


void
Tbl_EntrySetEqual(
  Tbl_Entry_t *  entry,
/*  Var_Variable_t *  var*/
  int varCol)
{
  entry->type=Tbl_EntryEqual_c;
  entry->EntryData.var = varCol;   
}

boolean
Tbl_EntryCheckRange(
  Tbl_Entry_t *  entry,
  int  val1,
  int  val2)
{
  lsGen gen;
  lsGeneric data;
  Tbl_Range_t *range;
  
  gen = lsStart(entry->EntryData.listOfRanges);
  while (lsNext(gen, &data, LS_NH) == LS_OK) {
    range = (Tbl_Range_t*)data;
    if (range->begin < val1) {
      lsFinish(gen);
      return FALSE;
    }
    if (range->end > val2) {
      lsFinish(gen);      
      return FALSE;
    }
  }
  lsFinish(gen);  
  return TRUE;
}

boolean Tbl_EntryIsEqual(
  Tbl_Entry_t *entry)
{
  return (entry->type==Tbl_EntryEqual_c);
}



Var_Variable_t*
Tbl_EntryReadActualVar(
    Tbl_Table_t *table,
    Tbl_Entry_t *entry)
{
  array_t *carray;

  if (entry->ioType==0) {
    carray = table->inputNames;
  }
  else if (entry->ioType==1) {
    carray = table->outputNames;
  }
  else return NIL(Var_Variable_t);         
    
  return (array_fetch(Var_Variable_t*,carray,entry->varColNum));
}


Var_Variable_t*
Tbl_EntryReadVar(
    Tbl_Table_t *table,
    Tbl_Entry_t *entry)
{
  array_t *carray;
  
  carray = table->inputNames;
  if (array_n(carray) < Tbl_EntryReadVarIndex(entry)) {
    fail(" FAIL: equal to output not supported\n");
  }
  return (array_fetch(Var_Variable_t*,carray,Tbl_EntryReadVarIndex(entry)));
}

int
Tbl_EntryReadVarIndex(
  Tbl_Entry_t * entry)
{
  assert(entry->type == Tbl_EntryEqual_c);
  return (entry->EntryData.var);
}

int
Tbl_EntryReadNumValues(
  Tbl_Entry_t * entry)
{
  lsGen gen;
  int numOfValues;
  Tbl_Range_t *range;

  numOfValues = 0;
  assert(entry->type == Tbl_EntryNormal_c);    
  lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
    numOfValues = numOfValues + (range->end - range->begin + 1);
  }
  return (numOfValues);
}

boolean
Tbl_EntryTestEqualEntry(
  Tbl_Entry_t * entrya,
  Tbl_Entry_t * entryb)
{
  lsGen gena;
  lsGen genb;  
  Tbl_Range_t *rangea;
  Tbl_Range_t *rangeb;
  lsGeneric data;

  assert(entrya->type == Tbl_EntryNormal_c);
  assert(entryb->type == Tbl_EntryNormal_c);

  if (lsLength(entrya->EntryData.listOfRanges) != \
      lsLength(entryb->EntryData.listOfRanges))   {
    return FALSE;
  }

  genb = lsStart(entryb->EntryData.listOfRanges);  
  lsForEachItem(entrya->EntryData.listOfRanges, gena, rangea) {
    if (lsNext(genb, &data,LS_NH) == LS_OK) {
      rangeb = (Tbl_Range_t*)data;                        
      if (rangea->begin != rangeb->begin) {
        lsFinish(gena);
        lsFinish(genb);
        return FALSE;
      }
      if (rangea->end != rangeb->end){
        lsFinish(gena);
        lsFinish(genb);
        return FALSE;
      }
    }
    else {
      return FALSE;
    }
  }
  return TRUE;
}

boolean
Tbl_EntryTestIntersectEntry(
  Tbl_Entry_t * entrya,
  Tbl_Entry_t * entryb)
{
  lsGen gena;
  lsGen genb;  
  lsGeneric dataa;
  lsGeneric datab;  
  boolean checka, checkb;
  Tbl_Range_t *rangea = NIL(Tbl_Range_t);
  Tbl_Range_t *rangeb = NIL(Tbl_Range_t);

  assert(entrya->type == Tbl_EntryNormal_c);
  assert(entryb->type == Tbl_EntryNormal_c);

  gena = lsStart(entrya->EntryData.listOfRanges);
  genb = lsStart(entryb->EntryData.listOfRanges);

  checka = TRUE;
  checkb = TRUE;  
  while((checka)||(checkb)) {
    if (checka) {
      if (lsNext(gena, &dataa,LS_NH) == LS_OK) {
        rangea = (Tbl_Range_t*)dataa;
      }
      else {
        lsFinish(gena);
        lsFinish(genb);        
        return FALSE;
      }
    }

    if (checkb) {
      if (lsNext(genb, &datab,LS_NH) == LS_OK) {
        rangeb = (Tbl_Range_t*)datab;
      }
      else {
        lsFinish(gena);
        lsFinish(genb);        
        return FALSE;
      }  
    }

    if ((rangea->begin <= rangeb->end) &&(rangeb->begin <= rangea->end)) {      
      lsFinish(gena);
      lsFinish(genb);
      return TRUE;
    }
    else if (rangea->end < rangeb->begin){
      checka = TRUE;
      checkb = FALSE;
    }
    else {
      checka = FALSE;
      checkb = TRUE;
    }    
  }
  lsFinish(gena);
  lsFinish(genb);  
  return FALSE;    
}

lsList
Tbl_EntryReadList(
  Tbl_Entry_t * entry)
{
  return (entry->EntryData.listOfRanges);
}


Tbl_EntryType_t
Tbl_EntryReadType(
  Tbl_Entry_t *entry)
{
  return (entry->type);
}


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

mdd_t *
TblEntryNormalConstructMdd(
    mdd_manager *manager,
    Tbl_Entry_t * entry,
    array_t * mddArray)
{
  lsGen gen;
  Tbl_Range_t *range;
  int i;
  mdd_t *result, *temp, *x;
    
  result = mdd_zero(manager);
  lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
    for (i=range->begin; i< (range->end +1); i++) {
      temp = result;
      x = Mvf_FunctionObtainComponent(mddArray,i);
      result = mdd_or(temp, x,1,1);
      mdd_free(temp);
      mdd_free(x);
    }
  }
  return result;
}


mdd_t *
TblEntryEqualConstructMdd(
    mdd_manager *manager,
    Tbl_Entry_t * entry,
    Mvf_Function_t * mddArray,
    Mvf_Function_t * mddEArray)
{
  lsGen gen;
  Tbl_Range_t *range;
  int i;
  mdd_t *result, *temp, *x;

  assert(entry->type == Tbl_EntryNormal_c);
  result = mdd_zero(manager);
  lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
    for (i=range->begin; i< (range->end +1); i++) {
      temp = result;
      x = Mvf_FunctionObtainComponent(mddArray,i);
      result = mdd_or(temp, x,1,1);
      mdd_free(temp);
      temp = result;
      x = Mvf_FunctionObtainComponent(mddEArray,i);
      result = mdd_or(temp, x,1,1);
      mdd_free(temp);
    }
  }
  return result;
}

void
TblEntryWriteBlifMv(
    Tbl_Table_t *table,
    Tbl_Entry_t *entry,
    FILE *fp)
{
  lsGen gen;
  Tbl_Range_t *range;
  Var_Variable_t *var;
  boolean test, testParen;
  int i, itemNum, length;
    
  var = Tbl_EntryReadActualVar(table,entry);
  test = Var_VariableTestIsSymbolic(var);
  testParen = TRUE;
  
  if (entry != NIL(Tbl_Entry_t)) {
    if (entry->type == Tbl_EntryNormal_c) {
      length = lsLength(entry->EntryData.listOfRanges);
      
      if (length == 1){
        var = Tbl_EntryReadActualVar(table,entry);
        lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
          if ((range->begin ==0)&&(range->end == Var_VariableReadNumValues(var)-1)){
            fprintf(fp,"-");
          lsFinish(gen);            
            return;
          }
        }
      }
      
      itemNum = 1;
      if (length ==1) {
        testParen = FALSE;
      }
      
      lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
        if (itemNum ==1) {
          if (testParen) {
              fprintf(fp,"(");
          }
        }
          
        if (itemNum < length) {
          if (test == FALSE) {
            if (range->end != range->begin) {
              fprintf(fp,"{%d-%d},", range->begin, range->end);
            }
            else {
              fprintf(fp,"%d,", range->end);
            }
          }
          else {
            if (range->end != range->begin) {
                fprintf(fp,"(%s,",Var_VariableReadSymbolicValueFromIndex(var,range->begin));
                for (i= range->begin+1; i < range->end ; i++) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,i));
              }
                        
              fprintf(fp,"%s),",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
            else {
              fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
          }
        }
        else {
          if (test == FALSE) {
            if (range->end != range->begin)
              fprintf(fp,"{%d-%d}", range->begin, range->end);
            else fprintf(fp,"%d", range->end);
          }
          else {
            if (range->end != range->begin) {
                fprintf(fp,"(%s,",Var_VariableReadSymbolicValueFromIndex(var,range->begin));
                for (i= range->begin+1; i < range->end ; i++) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,i));
              }
                        
              fprintf(fp,"%s)",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
            else {
              fprintf(fp,"%s",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
          }   
        }
      itemNum++;        
      }
      if (testParen) {      
        fprintf(fp,")");
      }
    }
    else if (entry->type == Tbl_EntryEqual_c) {
      fprintf(fp,"=%s", Var_VariableReadName(Tbl_EntryReadVar(table,entry)));
    }
  }
  else printf("NIL Entry ");
}

void
TblEntryWriteSmv(
    Tbl_Table_t *table,
    Tbl_Entry_t *entry,
    boolean varnameflag,
    FILE *fp)
{
  lsGen gen;
  Tbl_Range_t *range;
  Var_Variable_t *var;
  boolean symbolic, testParen;
  int i, itemNum, length;
    
  var = Tbl_EntryReadActualVar(table,entry);
  symbolic = Var_VariableTestIsSymbolic(var);
  testParen = TRUE;
  
  if (entry != NIL(Tbl_Entry_t)) {
    if (entry->type == Tbl_EntryNormal_c) {
      length = lsLength(entry->EntryData.listOfRanges);
      
      if (length == 1){
        var = Tbl_EntryReadActualVar(table,entry);
        lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
          if ((range->begin ==0)&&(range->end == Var_VariableReadNumValues(var)-1)){
            fprintf(fp,"1"); /* A don't-care is always true */
          lsFinish(gen);            
            return;
          }
        }
      }
      
      if (!varnameflag) {
        fprintf(fp,"(");
        Io_SmvPrintVar(fp,var);
      }
      itemNum = 1;
      if (length ==1) {
        testParen = FALSE;
      }
      
      lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
        if (!varnameflag) {
          if (itemNum ==1) {
            if (testParen) {
              fprintf(fp," IN {");
            } else {
              fprintf(fp, "=");
            }
          }
        }
        
        if (itemNum < length) {
          if (symbolic == FALSE) {
            if (range->end != range->begin) {
              for (i= range->begin; i < range->end ; i++)
                fprintf(fp,"%d,",i);
            }
            fprintf(fp,"%d,", range->end);
          }
          else {
            if (range->end != range->begin) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,range->begin));
                for (i= range->begin+1; i < range->end ; i++) {
                  fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,i));
                }
                        
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
            else {
              fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
          }
        }
        else {
          if (symbolic == FALSE) {
            if (range->end != range->begin) {
              for (i= range->begin; i < range->end ; i++)
                fprintf(fp,"%d,",i);
            }
            fprintf(fp,"%d", range->end);
          }
          else {
            if (range->end != range->begin) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,range->begin));
                for (i= range->begin+1; i < range->end ; i++) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,i));
              }
                        
              fprintf(fp,"%s",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
            else {
              fprintf(fp,"%s",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
          }   
        }
      itemNum++;        
      }
      if (testParen) {      
        fprintf(fp,"} ");
      }
      if (!varnameflag) {
        fprintf(fp, ") ");
      }
    }
    else if (entry->type == Tbl_EntryEqual_c) {
      if (!varnameflag) {
        Io_SmvPrintVar(fp, var);
        fprintf(fp,"=");
      }
      Io_SmvPrintVar(fp, Tbl_EntryReadVar(table,entry));
    }
  }
  else printf("NIL Entry ");
}


void
TblEntryWriteBlif(
    Tbl_Table_t *table,
    Tbl_Entry_t *entry,
    FILE *fp)
{
  lsGen gen;
  Tbl_Range_t *range;
  Var_Variable_t *var;
  boolean test;
  int i, itemNum, length;
    
  var = Tbl_EntryReadActualVar(table,entry);
  test = Var_VariableTestIsSymbolic(var);
  if (entry != NIL(Tbl_Entry_t)) {
    if (entry->type == Tbl_EntryNormal_c) {
      length = lsLength(entry->EntryData.listOfRanges);      
      if (length == 1){
        var = Tbl_EntryReadActualVar(table,entry);
        lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
          if ((range->begin ==0)&&(range->end == Var_VariableReadNumValues(var)-1)){
            fprintf(fp,"-");
          lsFinish(gen);            
            return;
          }
        }
      }

      length = lsLength(entry->EntryData.listOfRanges);
      itemNum = 1;
      lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
        if (itemNum < length) {
          if (test == FALSE) {
            if (range->end != range->begin) {
              fprintf(fp,"{%d-%d},", range->begin, range->end);
            }
            else {
              fprintf(fp,"%d,", range->end);
            }
          }
          else {
            if (range->end != range->begin) {
              for (i= range->begin; i < range->end ; i++) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,i));
              }
                        
              fprintf(fp,"%s",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
            else {
              fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
          }
        }
        else {
          if (test == FALSE) {
            if (range->end != range->begin)
              fprintf(fp,"{%d-%d}", range->begin, range->end);
            else fprintf(fp,"%d", range->end);
          }
          else {
            if (range->end != range->begin) {
              for (i= range->begin; i < range->end ; i++) {
                fprintf(fp,"%s,",Var_VariableReadSymbolicValueFromIndex(var,i));
              }
                        
              fprintf(fp,"%s",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }
            else {
              fprintf(fp,"%s",Var_VariableReadSymbolicValueFromIndex(var,range->end));
            }   
          }
        }
        itemNum++;        
      }
    }
    else if (entry->type == Tbl_EntryEqual_c) {
      fprintf(fp," =%s ",Var_VariableReadName(Tbl_EntryReadVar(table,entry)));
    }
  }
  else printf("NIL Entry ");
}

void
TblRangeFree(
  Tbl_Range_t * range)
{
  FREE(range);
}

int
Tbl_RangeBegin(
  Tbl_Range_t *range)
{
  return(range->begin);
}

int
Tbl_RangeEnd(
  Tbl_Range_t *range)
{
  return(range->end);
}

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

static int
RangeCompare(
  lsGeneric entry1,
  lsGeneric entry2)
{
  Tbl_Range_t * range1 = (Tbl_Range_t *) entry1;
  Tbl_Range_t * range2 = (Tbl_Range_t *) entry2;
  int value = 0;

  if (range1->begin > range2->begin) {
    value = 1;
  }
  else if (range1->begin < range2->begin) {
    value = -1;
  }
  else if (range1->begin == range2->begin) {
    if (range1->end > range2->end) {
      value = 1;
    }
    else if (range1->end <  range2->end) {
      value = -1;
    }
  }
  return value;
}

static void
EntryCanonicalize(
  Tbl_Entry_t *  entry)
{
  lsGen gen;
  Tbl_Range_t *range, *newRange, *nextRange;
  lsGeneric data;

  if (entry->type == Tbl_EntryEqual_c) {
    return;
  }

  if (entry->type == Tbl_EntryUnassigned_c) {
    return;
  }

  if (lsLength(entry->EntryData.listOfRanges)  > 1) {
    lsSort(entry->EntryData.listOfRanges,RangeCompare);
    lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
      if (lsNext(gen, &data,LS_NH) == LS_OK) {
        nextRange = (Tbl_Range_t*)data;
        if (nextRange->begin < (range->end + 2)) {
          if (nextRange->end > range->end) {
            newRange = ALLOC(Tbl_Range_t,1);
            newRange->begin = range->begin;
            newRange->end = nextRange->end;
            lsInAfter(gen,(lsGeneric)newRange,LS_NH);
            lsDelBefore(gen,(lsGeneric*)nextRange);
            TblRangeFree(nextRange);
            lsDelBefore(gen,(lsGeneric*)range);
            TblRangeFree(range);
          }
          else {
            lsDelBefore(gen,(lsGeneric*)nextRange);
            TblRangeFree(nextRange);
            if (lsPrev(gen,&data,LS_NH)!= LS_OK) {
              (void) lsFinish(gen);
            }
          }
        }
        else {
          lsPrev(gen,&data,LS_NH);
        }
      }
    }
  }
}


static void
EntryComplement(
  Tbl_Entry_t *  entry,
  int min,
  int max)
{
  lsGen gen, newGen;
  Tbl_Range_t *range, *newRange, *nextRange;
  lsList newRangeList;
  int listMin, listMax;
  lsGeneric data;
    
  if (entry->type == Tbl_EntryEqual_c) {
    return;
  }

  if (entry->type == Tbl_EntryUnassigned_c) {
    return;
  }

  listMin = max;
  listMax = min;
  newRangeList = lsCreate();
  newGen = lsStart(newRangeList);
  lsForEachItem(entry->EntryData.listOfRanges, gen, range) {
    if (lsNext(gen, &data, LS_NH) == LS_OK) {
      nextRange = (Tbl_Range_t*)data;
      newRange = ALLOC(Tbl_Range_t,1);
      newRange->begin = range->end +1;
      newRange->end = nextRange->begin -1;
      lsInAfter(newGen,(lsGeneric)newRange,LS_NH);
      lsPrev(gen, &data, LS_NH);
    }      
    if (listMin > range->begin) listMin = range->begin;
    if (listMax < range->end) listMax = range->end;
  }
  lsFinish(newGen);
  if (min < listMin) {
    newRange = ALLOC(Tbl_Range_t,1);
    newRange->begin = min;
    newRange->end = listMin -1;
    lsNewBegin(newRangeList,(lsGeneric)newRange,LS_NH);
  }
  if (listMax < max) {
    newRange = ALLOC(Tbl_Range_t,1);
    newRange->begin = listMax +1;
    newRange->end = max;
    lsNewEnd(newRangeList,(lsGeneric)newRange,LS_NH);
  }
  lsDestroy(entry->EntryData.listOfRanges,(void (*)(lsGeneric))TblRangeFree);
  entry->EntryData.listOfRanges = newRangeList;
}