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