src/Serialize/deserializer.cc

   1
   2 /*
   3  * File:   deserializer.cc
   4  * Author: hamed
   5  *
   6  * Created on September 7, 2017, 6:08 PM
   7  */
   8
   9 #include "deserializer.h"
  10 #include "csolver.h"
  11 #include "unistd.h"
  12 #include "fcntl.h"
  13 #include "predicate.h"
  14 #include "table.h"
  15 #include "element.h"
  16 #include "mutableset.h"
  17
  18 Deserializer::Deserializer(const char *file) :
  19         solver(new CSolver())
  20 {
  21         filedesc = open(file, O_RDONLY);
  22
  23         if (filedesc < 0) {
  24                 exit(-1);
  25         }
  26 }
  27
  28 Deserializer::~Deserializer() {
  29         delete solver;
  30
  31         if (-1 == close(filedesc)) {
  32                 exit(-1);
  33         }
  34 }
  35
  36 ssize_t Deserializer::myread(void *__buf, size_t __nbytes) {
  37         return read (filedesc, __buf, __nbytes);
  38 }
  39
  40 CSolver *Deserializer::deserialize() {
  41         ASTNodeType nodeType;
  42         while (myread(&nodeType, sizeof(ASTNodeType) ) > 0) {
  43                 switch (nodeType) {
  44                 case BOOLEANEDGE:
  45                         deserializeBooleanEdge();
  46                         break;
  47                 case BOOLEANVAR:
  48                         deserializeBooleanVar();
  49                         break;
  50                 case ORDERCONST:
  51                         deserializeBooleanOrder();
  52                         break;
  53                 case ORDERTYPE:
  54                         deserializeOrder();
  55                         break;
  56                 case SETTYPE:
  57                         deserializeSet();
  58                         break;
  59                 case LOGICOP:
  60                         deserializeBooleanLogic();
  61                         break;
  62                 case PREDICATEOP:
  63                         deserializeBooleanPredicate();
  64                         break;
  65                 case PREDTABLETYPE:
  66                         deserializePredicateTable();
  67                         break;
  68                 case PREDOPERTYPE:
  69                         deserializePredicateOperator();
  70                         break;
  71                 case TABLETYPE:
  72                         deserializeTable();
  73                         break;
  74                 case ELEMSET:
  75                         deserializeElementSet();
  76                         break;
  77                 case ELEMCONST:
  78                         deserializeElementConst();
  79                         break;
  80                 case ELEMFUNCRETURN:
  81                         deserializeElementFunction();
  82                         break;
  83                 case FUNCOPTYPE:
  84                         deserializeFunctionOperator();
  85                         break;
  86                 case FUNCTABLETYPE:
  87                         deserializeFunctionTable();
  88                         break;
  89                 default:
  90                         ASSERT(0);
  91                 }
  92         }
  93         return solver;
  94 }
  95
  96 void Deserializer::deserializeBooleanEdge() {
  97         Boolean *b;
  98         myread(&b, sizeof(Boolean *));
  99         BooleanEdge tmp(b);
 100         bool isNegated = tmp.isNegated();
 101         ASSERT(map.contains(tmp.getBoolean()));
 102         b = (Boolean *) map.get(tmp.getBoolean());
 103         BooleanEdge res(b);
 104         solver->addConstraint(isNegated ? res.negate() : res);
 105 }
 106
 107 void Deserializer::deserializeBooleanVar() {
 108         BooleanVar *b;
 109         myread(&b, sizeof(BooleanVar *));
 110         VarType vtype;
 111         myread(&vtype, sizeof(VarType));
 112         map.put(b, solver->getBooleanVar(vtype).getBoolean());
 113 }
 114
 115 void Deserializer::deserializeBooleanOrder() {
 116         BooleanOrder *bo_ptr;
 117         myread(&bo_ptr, sizeof(BooleanOrder *));
 118         Order *order;
 119         myread(&order, sizeof(Order *));
 120         ASSERT(map.contains(order));
 121         order  = (Order *) map.get(order);
 122         uint64_t first;
 123         myread(&first, sizeof(uint64_t));
 124         uint64_t second;
 125         myread(&second, sizeof(uint64_t));
 126         map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
 127 }
 128
 129 void Deserializer::deserializeOrder() {
 130         Order *o_ptr;
 131         myread(&o_ptr, sizeof(Order *));
 132         OrderType type;
 133         myread(&type, sizeof(OrderType));
 134         Set *set_ptr;
 135         myread(&set_ptr, sizeof(Set *));
 136         ASSERT(map.contains(set_ptr));
 137         Set *set  = (Set *) map.get(set_ptr);
 138         map.put(o_ptr, solver->createOrder(type, set));
 139 }
 140
 141 void Deserializer::deserializeSet() {
 142         Set *s_ptr;
 143         myread(&s_ptr, sizeof(Set *));
 144         VarType type;
 145         myread(&type, sizeof(VarType));
 146         bool isRange;
 147         myread(&isRange, sizeof(bool));
 148         bool isMutable;
 149         myread(&isMutable, sizeof(bool));
 150         if(isRange){
 151                 uint64_t low;
 152                 myread(&low, sizeof(uint64_t));
 153                 uint64_t high;
 154                 myread(&high, sizeof(uint64_t));
 155                 map.put(s_ptr, new Set(type, low, high));
 156         } else{
 157                 Set *set;
 158                 if(isMutable){
 159                         set = new MutableSet(type);
 160                 }
 161                 uint size;
 162                 myread(&size, sizeof(uint));
 163                 Vector<uint64_t> members;
 164                 for(uint i=0; i<size; i++){
 165                         uint64_t mem;
 166                         myread(&mem, sizeof(uint64_t));
 167                         if(isMutable) {
 168                                 ((MutableSet*) set)->addElementMSet(mem);
 169                         }else {
 170                                 members.push(mem);
 171                         }
 172                 }
 173                 if(!isMutable){
 174                         set = solver->createSet(type, members.expose(), size);
 175                 }
 176                 map.put(s_ptr, set);
 177         }
 178 }
 179
 180 void Deserializer::deserializeBooleanLogic() {
 181         BooleanLogic *bl_ptr;
 182         myread(&bl_ptr, sizeof(BooleanLogic *));
 183         LogicOp op;
 184         myread(&op, sizeof(LogicOp));
 185         uint size;
 186         myread(&size, sizeof(uint));
 187         Vector<BooleanEdge> members;
 188         for (uint i = 0; i < size; i++) {
 189                 Boolean *member;
 190                 myread(&member, sizeof(Boolean *));
 191                 BooleanEdge tmp(member);
 192                 bool isNegated = tmp.isNegated();
 193                 ASSERT(map.contains(tmp.getBoolean()));
 194                 member = (Boolean *) map.get(tmp.getBoolean());
 195                 BooleanEdge res(member);
 196                 members.push( isNegated ? res.negate() : res );
 197         }
 198         map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
 199 }
 200
 201 void Deserializer::deserializeBooleanPredicate() {
 202         BooleanPredicate *bp_ptr;
 203         myread(&bp_ptr, sizeof(BooleanPredicate *));
 204         Predicate *predicate;
 205         myread(&predicate, sizeof(Predicate *));
 206         ASSERT(map.contains(predicate));
 207         predicate = (Predicate *) map.get(predicate);
 208         uint size;
 209         myread(&size, sizeof(uint));
 210         Vector<Element *> members;
 211         for (uint i = 0; i < size; i++) {
 212                 Element *input;
 213                 myread(&input, sizeof(Element *));
 214                 ASSERT(map.contains(input));
 215                 input = (Element *) map.get(input);
 216                 members.push(input);
 217         }
 218
 219         Boolean *stat_ptr;
 220         myread(&stat_ptr, sizeof(Boolean *));
 221         BooleanEdge undefStatus;
 222         if (stat_ptr != NULL) {
 223                 BooleanEdge tmp(stat_ptr);
 224                 bool isNegated = tmp.isNegated();
 225                 ASSERT(map.contains(tmp.getBoolean()));
 226                 stat_ptr = (Boolean *) map.get(tmp.getBoolean());
 227                 BooleanEdge res(stat_ptr);
 228                 undefStatus = isNegated ? res.negate() : res;
 229         } else {
 230                 undefStatus = NULL;
 231         }
 232         map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
 233 }
 234
 235 void Deserializer::deserializePredicateTable() {
 236         PredicateTable *pt_ptr;
 237         myread(&pt_ptr, sizeof(PredicateTable *));
 238         Table *table;
 239         myread(&table, sizeof(Table *));
 240         ASSERT(map.contains(table));
 241         table = (Table *) map.get(table);
 242         UndefinedBehavior undefinedbehavior;
 243         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 244
 245         map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
 246 }
 247
 248 void Deserializer::deserializePredicateOperator() {
 249         PredicateOperator *po_ptr;
 250         myread(&po_ptr, sizeof(PredicateOperator *));
 251         CompOp op;
 252         myread(&op, sizeof(CompOp));
 253         uint size;
 254         myread(&size, sizeof(uint));
 255         Vector<Set *> domains;
 256         for (uint i = 0; i < size; i++) {
 257                 Set *domain;
 258                 myread(&domain, sizeof(Set *));
 259                 ASSERT(map.contains(domain));
 260                 domain = (Set *) map.get(domain);
 261                 domains.push(domain);
 262         }
 263
 264         map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
 265 }
 266
 267 void Deserializer::deserializeTable() {
 268         Table *t_ptr;
 269         myread(&t_ptr, sizeof(Table *));
 270         uint size;
 271         myread(&size, sizeof(uint));
 272         Vector<Set *> domains;
 273         for (uint i = 0; i < size; i++) {
 274                 Set *domain;
 275                 myread(&domain, sizeof(Set *));
 276                 ASSERT(map.contains(domain));
 277                 domain = (Set *) map.get(domain);
 278                 domains.push(domain);
 279         }
 280         Set *range;
 281         myread(&range, sizeof(Set *));
 282         if (range != NULL) {
 283                 ASSERT(map.contains(range));
 284                 range = (Set *) map.get(range);
 285         }
 286         Table *table = solver->createTable(domains.expose(), size, range);
 287         myread(&size, sizeof(uint));
 288         for (uint i = 0; i < size; i++) {
 289                 uint64_t output;
 290                 myread(&output, sizeof(uint64_t));
 291                 uint inputSize;
 292                 myread(&inputSize, sizeof(uint));
 293                 Vector<uint64_t> inputs;
 294                 inputs.setSize(inputSize);
 295                 myread(inputs.expose(), sizeof(uint64_t) * inputSize);
 296                 table->addNewTableEntry(inputs.expose(), inputSize, output);
 297         }
 298
 299         map.put(t_ptr, table);
 300 }
 301
 302
 303 void Deserializer::deserializeElementSet() {
 304         ElementSet *es_ptr;
 305         myread(&es_ptr, sizeof(ElementSet *));
 306         Set *set;
 307         myread(&set, sizeof(Set *));
 308         ASSERT(map.contains(set));
 309         set  = (Set *) map.get(set);
 310         map.put(es_ptr, solver->getElementVar(set));
 311 }
 312
 313 void Deserializer::deserializeElementConst() {
 314         ElementSet *es_ptr;
 315         myread(&es_ptr, sizeof(ElementSet *));
 316         VarType type;
 317         myread(&type, sizeof(VarType));
 318         uint64_t value;
 319         myread(&value, sizeof(uint64_t));
 320         map.put(es_ptr, solver->getElementConst(type, value));
 321 }
 322
 323 void Deserializer::deserializeElementFunction() {
 324         ElementFunction *ef_ptr;
 325         myread(&ef_ptr, sizeof(ElementFunction *));
 326         Function *function;
 327         myread(&function, sizeof(Function *));
 328         ASSERT(map.contains(function));
 329         function = (Function *) map.get(function);
 330         uint size;
 331         myread(&size, sizeof(uint));
 332         Vector<Element *> members;
 333         for (uint i = 0; i < size; i++) {
 334                 Element *input;
 335                 myread(&input, sizeof(Element *));
 336                 ASSERT(map.contains(input));
 337                 input = (Element *) map.get(input);
 338                 members.push(input);
 339         }
 340
 341         Boolean *overflowstatus;
 342         myread(&overflowstatus, sizeof(Boolean *));
 343         BooleanEdge tmp(overflowstatus);
 344         bool isNegated = tmp.isNegated();
 345         ASSERT(map.contains(tmp.getBoolean()));
 346         overflowstatus = (Boolean *) map.get(tmp.getBoolean());
 347         BooleanEdge res(overflowstatus);
 348         BooleanEdge undefStatus = isNegated ? res.negate() : res;
 349
 350         map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
 351 }
 352
 353
 354 void Deserializer::deserializeFunctionOperator() {
 355         FunctionOperator *fo_ptr;
 356         myread(&fo_ptr, sizeof(FunctionOperator *));
 357         ArithOp op;
 358         myread(&op, sizeof(ArithOp));
 359         uint size;
 360         myread(&size, sizeof(uint));
 361         Vector<Set *> domains;
 362         for (uint i = 0; i < size; i++) {
 363                 Set *domain;
 364                 myread(&domain, sizeof(Set *));
 365                 ASSERT(map.contains(domain));
 366                 domain = (Set *) map.get(domain);
 367                 domains.push(domain);
 368         }
 369         Set *range;
 370         myread(&range, sizeof(Set *));
 371         ASSERT(map.contains(range));
 372         range = (Set *) map.get(range);
 373         OverFlowBehavior overflowbehavior;
 374         myread(&overflowbehavior, sizeof(OverFlowBehavior));
 375         map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
 376 }
 377
 378 void Deserializer::deserializeFunctionTable() {
 379         FunctionTable *ft_ptr;
 380         myread(&ft_ptr, sizeof(FunctionTable *));
 381         Table *table;
 382         myread(&table, sizeof(Table *));
 383         ASSERT(map.contains(table));
 384         table = (Table *) map.get(table);
 385         UndefinedBehavior undefinedbehavior;
 386         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 387
 388         map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));
 389 }