3 * File: deserializer.cc
6 * Created on September 7, 2017, 6:08 PM
9 #include "deserializer.h"
13 #include "predicate.h"
16 #include "mutableset.h"
18 #define READBUFFERSIZE 16384
20 Deserializer::Deserializer(const char *file) :
21 buffer((char *) ourmalloc(READBUFFERSIZE)),
24 buffercap(READBUFFERSIZE),
27 filedesc = open(file, O_RDONLY);
34 Deserializer::~Deserializer() {
35 if (-1 == close(filedesc)) {
41 ssize_t Deserializer::myread(void *__buf, size_t bytestoread) {
42 char *out = (char * ) __buf;
43 size_t totalbytesread = 0;
45 if (bufferbytes != 0) {
46 uint bytestocopy = (bufferbytes > bytestoread) ? bytestoread : bufferbytes;
47 memcpy(out, &buffer[bufferindex], bytestocopy);
49 bufferbytes -= bytestocopy;
50 bufferindex += bytestocopy;
51 totalbytesread += bytestocopy;
52 //update request pointers
54 bytestoread -= bytestocopy;
56 ssize_t bytesread = read (filedesc, buffer, buffercap);
58 bufferbytes = bytesread;
61 } else if (bytesread < 0) {
66 return totalbytesread;
69 CSolver *Deserializer::deserialize() {
71 while (myread(&nodeType, sizeof(ASTNodeType) ) > 0) {
74 deserializeBooleanEdge();
77 deserializeBooleanVar();
80 deserializeBooleanOrder();
89 deserializeBooleanLogic();
92 deserializeBooleanPredicate();
95 deserializePredicateTable();
98 deserializePredicateOperator();
104 deserializeElementSet();
107 deserializeElementConst();
110 deserializeElementFunction();
113 deserializeFunctionOperator();
116 deserializeFunctionTable();
125 void Deserializer::deserializeBooleanEdge() {
127 myread(&b_ptr, sizeof(Boolean *));
128 BooleanEdge tmp(b_ptr);
129 bool isNegated = tmp.isNegated();
130 ASSERT(map.contains(tmp.getBoolean()));
131 b_ptr = (Boolean *) map.get(tmp.getBoolean());
132 BooleanEdge res(b_ptr);
134 myread(&isTopLevel, sizeof(bool));
136 solver->addConstraint(isNegated ? res.negate() : res);
140 void Deserializer::deserializeBooleanVar() {
142 myread(&b, sizeof(BooleanVar *));
144 myread(&vtype, sizeof(VarType));
145 map.put(b, solver->getBooleanVar(vtype).getBoolean());
148 void Deserializer::deserializeBooleanOrder() {
149 BooleanOrder *bo_ptr;
150 myread(&bo_ptr, sizeof(BooleanOrder *));
152 myread(&order, sizeof(Order *));
153 ASSERT(map.contains(order));
154 order = (Order *) map.get(order);
156 myread(&first, sizeof(uint64_t));
158 myread(&second, sizeof(uint64_t));
159 map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
162 void Deserializer::deserializeOrder() {
164 myread(&o_ptr, sizeof(Order *));
166 myread(&type, sizeof(OrderType));
168 myread(&set_ptr, sizeof(Set *));
169 ASSERT(map.contains(set_ptr));
170 Set *set = (Set *) map.get(set_ptr);
171 map.put(o_ptr, solver->createOrder(type, set));
174 void Deserializer::deserializeSet() {
176 myread(&s_ptr, sizeof(Set *));
178 myread(&type, sizeof(VarType));
180 myread(&isRange, sizeof(bool));
182 myread(&isMutable, sizeof(bool));
185 myread(&low, sizeof(uint64_t));
187 myread(&high, sizeof(uint64_t));
188 map.put(s_ptr, new Set(type, low, high));
192 set = new MutableSet(type);
195 myread(&size, sizeof(uint));
196 Vector<uint64_t> members;
197 for (uint i = 0; i < size; i++) {
199 myread(&mem, sizeof(uint64_t));
201 ((MutableSet *) set)->addElementMSet(mem);
207 set = solver->createSet(type, members.expose(), size);
213 void Deserializer::deserializeBooleanLogic() {
214 BooleanLogic *bl_ptr;
215 myread(&bl_ptr, sizeof(BooleanLogic *));
217 myread(&op, sizeof(LogicOp));
219 myread(&size, sizeof(uint));
220 Vector<BooleanEdge> members;
221 for (uint i = 0; i < size; i++) {
223 myread(&member, sizeof(Boolean *));
224 BooleanEdge tmp(member);
225 bool isNegated = tmp.isNegated();
226 ASSERT(map.contains(tmp.getBoolean()));
227 member = (Boolean *) map.get(tmp.getBoolean());
228 BooleanEdge res(member);
229 members.push( isNegated ? res.negate() : res );
231 map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
234 void Deserializer::deserializeBooleanPredicate() {
235 BooleanPredicate *bp_ptr;
236 myread(&bp_ptr, sizeof(BooleanPredicate *));
237 Predicate *predicate;
238 myread(&predicate, sizeof(Predicate *));
239 ASSERT(map.contains(predicate));
240 predicate = (Predicate *) map.get(predicate);
242 myread(&size, sizeof(uint));
243 Vector<Element *> members;
244 for (uint i = 0; i < size; i++) {
246 myread(&input, sizeof(Element *));
247 ASSERT(map.contains(input));
248 input = (Element *) map.get(input);
253 myread(&stat_ptr, sizeof(Boolean *));
254 BooleanEdge undefStatus;
255 if (stat_ptr != NULL) {
256 BooleanEdge tmp(stat_ptr);
257 bool isNegated = tmp.isNegated();
258 ASSERT(map.contains(tmp.getBoolean()));
259 stat_ptr = (Boolean *) map.get(tmp.getBoolean());
260 BooleanEdge res(stat_ptr);
261 undefStatus = isNegated ? res.negate() : res;
265 map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
268 void Deserializer::deserializePredicateTable() {
269 PredicateTable *pt_ptr;
270 myread(&pt_ptr, sizeof(PredicateTable *));
272 myread(&table, sizeof(Table *));
273 ASSERT(map.contains(table));
274 table = (Table *) map.get(table);
275 UndefinedBehavior undefinedbehavior;
276 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
278 map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
281 void Deserializer::deserializePredicateOperator() {
282 PredicateOperator *po_ptr;
283 myread(&po_ptr, sizeof(PredicateOperator *));
285 myread(&op, sizeof(CompOp));
287 myread(&size, sizeof(uint));
288 Vector<Set *> domains;
289 for (uint i = 0; i < size; i++) {
291 myread(&domain, sizeof(Set *));
292 ASSERT(map.contains(domain));
293 domain = (Set *) map.get(domain);
294 domains.push(domain);
297 map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
300 void Deserializer::deserializeTable() {
302 myread(&t_ptr, sizeof(Table *));
304 myread(&size, sizeof(uint));
305 Vector<Set *> domains;
306 for (uint i = 0; i < size; i++) {
308 myread(&domain, sizeof(Set *));
309 ASSERT(map.contains(domain));
310 domain = (Set *) map.get(domain);
311 domains.push(domain);
314 myread(&range, sizeof(Set *));
316 ASSERT(map.contains(range));
317 range = (Set *) map.get(range);
319 Table *table = solver->createTable(domains.expose(), size, range);
320 myread(&size, sizeof(uint));
321 for (uint i = 0; i < size; i++) {
323 myread(&output, sizeof(uint64_t));
325 myread(&inputSize, sizeof(uint));
326 Vector<uint64_t> inputs;
327 inputs.setSize(inputSize);
328 myread(inputs.expose(), sizeof(uint64_t) * inputSize);
329 table->addNewTableEntry(inputs.expose(), inputSize, output);
332 map.put(t_ptr, table);
336 void Deserializer::deserializeElementSet() {
338 myread(&es_ptr, sizeof(ElementSet *));
340 myread(&set, sizeof(Set *));
341 ASSERT(map.contains(set));
342 set = (Set *) map.get(set);
343 map.put(es_ptr, solver->getElementVar(set));
346 void Deserializer::deserializeElementConst() {
348 myread(&es_ptr, sizeof(ElementSet *));
350 myread(&type, sizeof(VarType));
352 myread(&value, sizeof(uint64_t));
353 map.put(es_ptr, solver->getElementConst(type, value));
356 void Deserializer::deserializeElementFunction() {
357 ElementFunction *ef_ptr;
358 myread(&ef_ptr, sizeof(ElementFunction *));
360 myread(&function, sizeof(Function *));
361 ASSERT(map.contains(function));
362 function = (Function *) map.get(function);
364 myread(&size, sizeof(uint));
365 Vector<Element *> members;
366 for (uint i = 0; i < size; i++) {
368 myread(&input, sizeof(Element *));
369 ASSERT(map.contains(input));
370 input = (Element *) map.get(input);
374 Boolean *overflowstatus;
375 myread(&overflowstatus, sizeof(Boolean *));
376 BooleanEdge tmp(overflowstatus);
377 bool isNegated = tmp.isNegated();
378 ASSERT(map.contains(tmp.getBoolean()));
379 overflowstatus = (Boolean *) map.get(tmp.getBoolean());
380 BooleanEdge res(overflowstatus);
381 BooleanEdge undefStatus = isNegated ? res.negate() : res;
382 map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
386 void Deserializer::deserializeFunctionOperator() {
387 FunctionOperator *fo_ptr;
388 myread(&fo_ptr, sizeof(FunctionOperator *));
390 myread(&op, sizeof(ArithOp));
392 myread(&size, sizeof(uint));
393 Vector<Set *> domains;
394 for (uint i = 0; i < size; i++) {
396 myread(&domain, sizeof(Set *));
397 ASSERT(map.contains(domain));
398 domain = (Set *) map.get(domain);
399 domains.push(domain);
402 myread(&range, sizeof(Set *));
403 ASSERT(map.contains(range));
404 range = (Set *) map.get(range);
405 OverFlowBehavior overflowbehavior;
406 myread(&overflowbehavior, sizeof(OverFlowBehavior));
407 map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
410 void Deserializer::deserializeFunctionTable() {
411 FunctionTable *ft_ptr;
412 myread(&ft_ptr, sizeof(FunctionTable *));
414 myread(&table, sizeof(Table *));
415 ASSERT(map.contains(table));
416 table = (Table *) map.get(table);
417 UndefinedBehavior undefinedbehavior;
418 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
420 map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));