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