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