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         uint64_t low;
 149         myread(&low, sizeof(uint64_t));
 150         uint64_t high;
 151         myread(&high, sizeof(uint64_t));
 152         bool isMutable;
 153         myread(&isMutable, sizeof(bool));
 154         Set *set;
 155         if (isMutable) {
 156                 set = new MutableSet(type);
 157         }
 158         uint size;
 159         myread(&size, sizeof(uint));
 160         Vector<uint64_t> members;
 161         for (uint i = 0; i < size; i++) {
 162                 uint64_t mem;
 163                 myread(&mem, sizeof(uint64_t));
 164                 if (isMutable) {
 165                         ((MutableSet *) set)->addElementMSet(mem);
 166                 } else {
 167                         members.push(mem);
 168                 }
 169         }
 170         if (!isMutable) {
 171                 set = isRange ? solver->createRangeSet(type, low, high) :
 172                                         solver->createSet(type, members.expose(), size);
 173         }
 174         map.put(s_ptr, set);
 175 }
 176
 177 void Deserializer::deserializeBooleanLogic() {
 178         BooleanLogic *bl_ptr;
 179         myread(&bl_ptr, sizeof(BooleanLogic *));
 180         LogicOp op;
 181         myread(&op, sizeof(LogicOp));
 182         uint size;
 183         myread(&size, sizeof(uint));
 184         Vector<BooleanEdge> members;
 185         for (uint i = 0; i < size; i++) {
 186                 Boolean *member;
 187                 myread(&member, sizeof(Boolean *));
 188                 BooleanEdge tmp(member);
 189                 bool isNegated = tmp.isNegated();
 190                 ASSERT(map.contains(tmp.getBoolean()));
 191                 member = (Boolean *) map.get(tmp.getBoolean());
 192                 BooleanEdge res(member);
 193                 members.push( isNegated ? res.negate() : res );
 194         }
 195         map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
 196 }
 197
 198 void Deserializer::deserializeBooleanPredicate() {
 199         BooleanPredicate *bp_ptr;
 200         myread(&bp_ptr, sizeof(BooleanPredicate *));
 201         Predicate *predicate;
 202         myread(&predicate, sizeof(Predicate *));
 203         ASSERT(map.contains(predicate));
 204         predicate = (Predicate *) map.get(predicate);
 205         uint size;
 206         myread(&size, sizeof(uint));
 207         Vector<Element *> members;
 208         for (uint i = 0; i < size; i++) {
 209                 Element *input;
 210                 myread(&input, sizeof(Element *));
 211                 ASSERT(map.contains(input));
 212                 input = (Element *) map.get(input);
 213                 members.push(input);
 214         }
 215
 216         Boolean *stat_ptr;
 217         myread(&stat_ptr, sizeof(Boolean *));
 218         BooleanEdge undefStatus;
 219         if (stat_ptr != NULL) {
 220                 BooleanEdge tmp(stat_ptr);
 221                 bool isNegated = tmp.isNegated();
 222                 ASSERT(map.contains(tmp.getBoolean()));
 223                 stat_ptr = (Boolean *) map.get(tmp.getBoolean());
 224                 BooleanEdge res(stat_ptr);
 225                 undefStatus = isNegated ? res.negate() : res;
 226         } else {
 227                 undefStatus = NULL;
 228         }
 229         map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
 230 }
 231
 232 void Deserializer::deserializePredicateTable() {
 233         PredicateTable *pt_ptr;
 234         myread(&pt_ptr, sizeof(PredicateTable *));
 235         Table *table;
 236         myread(&table, sizeof(Table *));
 237         ASSERT(map.contains(table));
 238         table = (Table *) map.get(table);
 239         UndefinedBehavior undefinedbehavior;
 240         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 241
 242         map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
 243 }
 244
 245 void Deserializer::deserializePredicateOperator() {
 246         PredicateOperator *po_ptr;
 247         myread(&po_ptr, sizeof(PredicateOperator *));
 248         CompOp op;
 249         myread(&op, sizeof(CompOp));
 250         uint size;
 251         myread(&size, sizeof(uint));
 252         Vector<Set *> domains;
 253         for (uint i = 0; i < size; i++) {
 254                 Set *domain;
 255                 myread(&domain, sizeof(Set *));
 256                 ASSERT(map.contains(domain));
 257                 domain = (Set *) map.get(domain);
 258                 domains.push(domain);
 259         }
 260
 261         map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
 262 }
 263
 264 void Deserializer::deserializeTable() {
 265         Table *t_ptr;
 266         myread(&t_ptr, sizeof(Table *));
 267         uint size;
 268         myread(&size, sizeof(uint));
 269         Vector<Set *> domains;
 270         for (uint i = 0; i < size; i++) {
 271                 Set *domain;
 272                 myread(&domain, sizeof(Set *));
 273                 ASSERT(map.contains(domain));
 274                 domain = (Set *) map.get(domain);
 275                 domains.push(domain);
 276         }
 277         Set *range;
 278         myread(&range, sizeof(Set *));
 279         if (range != NULL) {
 280                 ASSERT(map.contains(range));
 281                 range = (Set *) map.get(range);
 282         }
 283         Table *table = solver->createTable(domains.expose(), size, range);
 284         myread(&size, sizeof(uint));
 285         for (uint i = 0; i < size; i++) {
 286                 uint64_t output;
 287                 myread(&output, sizeof(uint64_t));
 288                 uint inputSize;
 289                 myread(&inputSize, sizeof(uint));
 290                 Vector<uint64_t> inputs;
 291                 inputs.setSize(inputSize);
 292                 myread(inputs.expose(), sizeof(uint64_t) * inputSize);
 293                 table->addNewTableEntry(inputs.expose(), inputSize, output);
 294         }
 295
 296         map.put(t_ptr, table);
 297 }
 298
 299
 300 void Deserializer::deserializeElementSet() {
 301         ElementSet *es_ptr;
 302         myread(&es_ptr, sizeof(ElementSet *));
 303         Set *set;
 304         myread(&set, sizeof(Set *));
 305         ASSERT(map.contains(set));
 306         set  = (Set *) map.get(set);
 307         map.put(es_ptr, solver->getElementVar(set));
 308 }
 309
 310 void Deserializer::deserializeElementConst() {
 311         ElementSet *es_ptr;
 312         myread(&es_ptr, sizeof(ElementSet *));
 313         VarType type;
 314         myread(&type, sizeof(VarType));
 315         uint64_t value;
 316         myread(&value, sizeof(uint64_t));
 317         map.put(es_ptr, solver->getElementConst(type, value));
 318 }
 319
 320 void Deserializer::deserializeElementFunction() {
 321         ElementFunction *ef_ptr;
 322         myread(&ef_ptr, sizeof(ElementFunction *));
 323         Function *function;
 324         myread(&function, sizeof(Function *));
 325         ASSERT(map.contains(function));
 326         function = (Function *) map.get(function);
 327         uint size;
 328         myread(&size, sizeof(uint));
 329         Vector<Element *> members;
 330         for (uint i = 0; i < size; i++) {
 331                 Element *input;
 332                 myread(&input, sizeof(Element *));
 333                 ASSERT(map.contains(input));
 334                 input = (Element *) map.get(input);
 335                 members.push(input);
 336         }
 337
 338         Boolean *overflowstatus;
 339         myread(&overflowstatus, sizeof(Boolean *));
 340         BooleanEdge tmp(overflowstatus);
 341         bool isNegated = tmp.isNegated();
 342         ASSERT(map.contains(tmp.getBoolean()));
 343         overflowstatus = (Boolean *) map.get(tmp.getBoolean());
 344         BooleanEdge res(overflowstatus);
 345         BooleanEdge undefStatus = isNegated ? res.negate() : res;
 346
 347         map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
 348 }
 349
 350
 351 void Deserializer::deserializeFunctionOperator() {
 352         FunctionOperator *fo_ptr;
 353         myread(&fo_ptr, sizeof(FunctionOperator *));
 354         ArithOp op;
 355         myread(&op, sizeof(ArithOp));
 356         uint size;
 357         myread(&size, sizeof(uint));
 358         Vector<Set *> domains;
 359         for (uint i = 0; i < size; i++) {
 360                 Set *domain;
 361                 myread(&domain, sizeof(Set *));
 362                 ASSERT(map.contains(domain));
 363                 domain = (Set *) map.get(domain);
 364                 domains.push(domain);
 365         }
 366         Set *range;
 367         myread(&range, sizeof(Set *));
 368         ASSERT(map.contains(range));
 369         range = (Set *) map.get(range);
 370         OverFlowBehavior overflowbehavior;
 371         myread(&overflowbehavior, sizeof(OverFlowBehavior));
 372         map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
 373 }
 374
 375 void Deserializer::deserializeFunctionTable() {
 376         FunctionTable *ft_ptr;
 377         myread(&ft_ptr, sizeof(FunctionTable *));
 378         Table *table;
 379         myread(&table, sizeof(Table *));
 380         ASSERT(map.contains(table));
 381         table = (Table *) map.get(table);
 382         UndefinedBehavior undefinedbehavior;
 383         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 384
 385         map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));
 386 }