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