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 deserializeBooleanConst();
83 deserializeBooleanOrder();
92 deserializeBooleanLogic();
95 deserializeBooleanPredicate();
98 deserializePredicateTable();
101 deserializePredicateOperator();
107 deserializeElementSet();
110 deserializeElementConst();
113 deserializeElementFunction();
116 deserializeFunctionOperator();
119 deserializeFunctionTable();
128 void Deserializer::deserializeBooleanEdge() {
130 myread(&b_ptr, sizeof(Boolean *));
131 BooleanEdge tmp(b_ptr);
132 bool isNegated = tmp.isNegated();
133 ASSERT(map.contains(tmp.getBoolean()));
134 b_ptr = (Boolean *) map.get(tmp.getBoolean());
135 BooleanEdge res(b_ptr);
137 myread(&isTopLevel, sizeof(bool));
139 solver->addConstraint(isNegated ? res.negate() : res);
143 void Deserializer::deserializeBooleanVar() {
145 myread(&b, sizeof(BooleanVar *));
147 myread(&vtype, sizeof(VarType));
148 map.put(b, solver->getBooleanVar(vtype).getBoolean());
151 void Deserializer::deserializeBooleanConst() {
153 myread(&b, sizeof(BooleanVar *));
155 myread(&istrue, sizeof(bool));
156 map.put(b, istrue ? solver->getBooleanTrue().getBoolean() :
157 solver->getBooleanFalse().getBoolean());
160 void Deserializer::deserializeBooleanOrder() {
161 BooleanOrder *bo_ptr;
162 myread(&bo_ptr, sizeof(BooleanOrder *));
164 myread(&order, sizeof(Order *));
165 ASSERT(map.contains(order));
166 order = (Order *) map.get(order);
168 myread(&first, sizeof(uint64_t));
170 myread(&second, sizeof(uint64_t));
171 map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
174 void Deserializer::deserializeOrder() {
176 myread(&o_ptr, sizeof(Order *));
178 myread(&type, sizeof(OrderType));
180 myread(&set_ptr, sizeof(Set *));
181 ASSERT(map.contains(set_ptr));
182 Set *set = (Set *) map.get(set_ptr);
183 map.put(o_ptr, solver->createOrder(type, set));
186 void Deserializer::deserializeSet() {
188 myread(&s_ptr, sizeof(Set *));
190 myread(&type, sizeof(VarType));
192 myread(&isRange, sizeof(bool));
194 myread(&isMutable, sizeof(bool));
197 myread(&low, sizeof(uint64_t));
199 myread(&high, sizeof(uint64_t));
200 map.put(s_ptr, new Set(type, low, high));
204 set = new MutableSet(type);
207 myread(&size, sizeof(uint));
208 Vector<uint64_t> members;
209 for (uint i = 0; i < size; i++) {
211 myread(&mem, sizeof(uint64_t));
213 ((MutableSet *) set)->addElementMSet(mem);
219 set = solver->createSet(type, members.expose(), size);
225 void Deserializer::deserializeBooleanLogic() {
226 BooleanLogic *bl_ptr;
227 myread(&bl_ptr, sizeof(BooleanLogic *));
229 myread(&op, sizeof(LogicOp));
231 myread(&size, sizeof(uint));
232 Vector<BooleanEdge> members;
233 for (uint i = 0; i < size; i++) {
235 myread(&member, sizeof(Boolean *));
236 BooleanEdge tmp(member);
237 bool isNegated = tmp.isNegated();
238 ASSERT(map.contains(tmp.getBoolean()));
239 member = (Boolean *) map.get(tmp.getBoolean());
240 BooleanEdge res(member);
241 members.push( isNegated ? res.negate() : res );
243 map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
246 void Deserializer::deserializeBooleanPredicate() {
247 BooleanPredicate *bp_ptr;
248 myread(&bp_ptr, sizeof(BooleanPredicate *));
249 Predicate *predicate;
250 myread(&predicate, sizeof(Predicate *));
251 ASSERT(map.contains(predicate));
252 predicate = (Predicate *) map.get(predicate);
254 myread(&size, sizeof(uint));
255 Vector<Element *> members;
256 for (uint i = 0; i < size; i++) {
258 myread(&input, sizeof(Element *));
259 ASSERT(map.contains(input));
260 input = (Element *) map.get(input);
265 myread(&stat_ptr, sizeof(Boolean *));
266 BooleanEdge undefStatus;
267 if (stat_ptr != NULL) {
268 BooleanEdge tmp(stat_ptr);
269 bool isNegated = tmp.isNegated();
270 ASSERT(map.contains(tmp.getBoolean()));
271 stat_ptr = (Boolean *) map.get(tmp.getBoolean());
272 BooleanEdge res(stat_ptr);
273 undefStatus = isNegated ? res.negate() : res;
277 map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
280 void Deserializer::deserializePredicateTable() {
281 PredicateTable *pt_ptr;
282 myread(&pt_ptr, sizeof(PredicateTable *));
284 myread(&table, sizeof(Table *));
285 ASSERT(map.contains(table));
286 table = (Table *) map.get(table);
287 UndefinedBehavior undefinedbehavior;
288 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
290 map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
293 void Deserializer::deserializePredicateOperator() {
294 PredicateOperator *po_ptr;
295 myread(&po_ptr, sizeof(PredicateOperator *));
297 myread(&op, sizeof(CompOp));
299 map.put(po_ptr, solver->createPredicateOperator(op));
302 void Deserializer::deserializeTable() {
304 myread(&t_ptr, sizeof(Table *));
306 myread(&range, sizeof(Set *));
308 ASSERT(map.contains(range));
309 range = (Set *) map.get(range);
311 Table *table = solver->createTable(range);
313 myread(&size, sizeof(uint));
314 for (uint i = 0; i < size; i++) {
316 myread(&output, sizeof(uint64_t));
318 myread(&inputSize, sizeof(uint));
319 Vector<uint64_t> inputs;
320 inputs.setSize(inputSize);
321 myread(inputs.expose(), sizeof(uint64_t) * inputSize);
322 table->addNewTableEntry(inputs.expose(), inputSize, output);
325 map.put(t_ptr, table);
329 void Deserializer::deserializeElementSet() {
330 bool anyValue = false;
331 myread(&anyValue, sizeof(bool));
333 myread(&es_ptr, sizeof(ElementSet *));
335 myread(&set, sizeof(Set *));
336 ASSERT(map.contains(set));
337 set = (Set *) map.get(set);
338 Element *newEl = solver->getElementVar(set);
339 newEl->anyValue = anyValue;
340 map.put(es_ptr, newEl);
343 void Deserializer::deserializeElementConst() {
344 bool anyValue = false;
345 myread(&anyValue, sizeof(bool));
347 myread(&es_ptr, sizeof(ElementSet *));
349 myread(&type, sizeof(VarType));
351 myread(&value, sizeof(uint64_t));
352 Element *newEl = solver->getElementConst(type, value);
353 newEl->anyValue = anyValue;
354 map.put(es_ptr, newEl);
357 void Deserializer::deserializeElementFunction() {
358 bool anyValue = false;
359 myread(&anyValue, sizeof(bool));
360 ElementFunction *ef_ptr;
361 myread(&ef_ptr, sizeof(ElementFunction *));
363 myread(&function, sizeof(Function *));
364 ASSERT(map.contains(function));
365 function = (Function *) map.get(function);
367 myread(&size, sizeof(uint));
368 Vector<Element *> members;
369 for (uint i = 0; i < size; i++) {
371 myread(&input, sizeof(Element *));
372 ASSERT(map.contains(input));
373 input = (Element *) map.get(input);
377 Boolean *overflowstatus;
378 myread(&overflowstatus, sizeof(Boolean *));
379 BooleanEdge tmp(overflowstatus);
380 bool isNegated = tmp.isNegated();
381 ASSERT(map.contains(tmp.getBoolean()));
382 overflowstatus = (Boolean *) map.get(tmp.getBoolean());
383 BooleanEdge res(overflowstatus);
384 BooleanEdge undefStatus = isNegated ? res.negate() : res;
385 Element *newEl = solver->applyFunction(function, members.expose(), size, undefStatus);
386 newEl->anyValue = anyValue;
387 map.put(ef_ptr, newEl);
391 void Deserializer::deserializeFunctionOperator() {
392 FunctionOperator *fo_ptr;
393 myread(&fo_ptr, sizeof(FunctionOperator *));
395 myread(&op, sizeof(ArithOp));
397 myread(&range, sizeof(Set *));
398 ASSERT(map.contains(range));
399 range = (Set *) map.get(range);
400 OverFlowBehavior overflowbehavior;
401 myread(&overflowbehavior, sizeof(OverFlowBehavior));
402 map.put(fo_ptr, solver->createFunctionOperator(op, range, overflowbehavior));
405 void Deserializer::deserializeFunctionTable() {
406 FunctionTable *ft_ptr;
407 myread(&ft_ptr, sizeof(FunctionTable *));
409 myread(&table, sizeof(Table *));
410 ASSERT(map.contains(table));
411 table = (Table *) map.get(table);
412 UndefinedBehavior undefinedbehavior;
413 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
415 map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));