src/AST/table.cc

   1 #include "table.h"
   2 #include "common.h"
   3 #include "structs.h"
   4 #include "tableentry.h"
   5 #include "set.h"
   6 #include "mutableset.h"
   7 #include "csolver.h"
   8 #include "serializer.h"
   9
  10 Table::Table(Set **_domains, uint numDomain, Set *_range) :
  11         domains(_domains, numDomain),
  12         range(_range) {
  13         entries = new HashsetTableEntry();
  14 }
  15
  16 void Table::addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result) {
  17 #ifdef CONFIG_ASSERT
  18         if (range == NULL)
  19                 ASSERT(result == true || result == false);
  20 #endif
  21         TableEntry *tb = allocTableEntry(inputs, inputSize, result);
  22         bool status = entries->add(tb);
  23         ASSERT(status);
  24 }
  25
  26 TableEntry *Table::getTableEntry(uint64_t *inputs, uint inputSize) {
  27         TableEntry *temp = allocTableEntry(inputs, inputSize, -1);
  28         TableEntry *result = entries->get(temp);
  29         deleteTableEntry(temp);
  30         return result;
  31 }
  32
  33 Table *Table::clone(CSolver *solver, CloneMap *map) {
  34         Table *t = (Table *) map->get(this);
  35         if (t != NULL)
  36                 return t;
  37         Set *array[domains.getSize()];
  38         for (uint i = 0; i < domains.getSize(); i++) {
  39                 array[i] = domains.get(i)->clone(solver, map);
  40         }
  41         Set *rcopy = range != NULL ? range->clone(solver, map) : NULL;
  42         t = solver->createTable(array, domains.getSize(), rcopy);
  43         SetIteratorTableEntry *entryit = entries->iterator();
  44         while (entryit->hasNext()) {
  45                 TableEntry *te = entryit->next();
  46                 solver->addTableEntry(t, &te->inputs[0], te->inputSize, te->output);
  47         }
  48         delete entryit;
  49         map->put(this, t);
  50         return t;
  51 }
  52
  53 Table::~Table() {
  54         SetIteratorTableEntry *iterator = entries->iterator();
  55         while (iterator->hasNext()) {
  56                 deleteTableEntry(iterator->next());
  57         }
  58         delete iterator;
  59         delete entries;
  60 }
  61
  62
  63
  64 void Table::serialize(Serializer* serializer){
  65         if(serializer->isSerialized(this))
  66                 return;
  67         serializer->addObject(this);
  68
  69         uint size = domains.getSize();
  70         for(uint i=0; i<size; i++){
  71                 Set* domain = domains.get(i);
  72                 domain->serialize(serializer);
  73         }
  74         range->serialize(serializer);
  75
  76         ASTNodeType type = TABLETYPE;
  77         serializer->mywrite(&type, sizeof(ASTNodeType));
  78         Table* This = this;
  79         serializer->mywrite(&This, sizeof(Table*));
  80         serializer->mywrite(&size, sizeof(uint));
  81         for(uint i=0; i<size; i++){
  82                 Set* domain = domains.get(i);
  83                 serializer->mywrite(&domain, sizeof(Set*));
  84         }
  85         serializer->mywrite(&range, sizeof(Set*));
  86         size = entries->getSize();
  87         serializer->mywrite(&size, sizeof(uint));
  88         SetIteratorTableEntry* iterator = getEntries();
  89         while(iterator->hasNext()){
  90                 TableEntry* entry = iterator->next();
  91                 serializer->mywrite(&entry->output, sizeof(uint64_t));
  92                 serializer->mywrite(&entry->inputSize, sizeof(uint));
  93                 serializer->mywrite(entry->inputs, sizeof(uint64_t) * entry->inputSize);
  94                 ASSERT(0);
  95         }
  96 }
  97
  98