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