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 Deserializer::Deserializer(const char *file) :
21 filedesc = open(file, O_RDONLY);
28 Deserializer::~Deserializer() {
29 if (-1 == close(filedesc)) {
34 ssize_t Deserializer::myread(void *__buf, size_t __nbytes) {
35 return read (filedesc, __buf, __nbytes);
38 CSolver *Deserializer::deserialize() {
40 while (myread(&nodeType, sizeof(ASTNodeType) ) > 0) {
43 deserializeBooleanEdge();
46 deserializeBooleanVar();
49 deserializeBooleanOrder();
58 deserializeBooleanLogic();
61 deserializeBooleanPredicate();
64 deserializePredicateTable();
67 deserializePredicateOperator();
73 deserializeElementSet();
76 deserializeElementConst();
79 deserializeElementFunction();
82 deserializeFunctionOperator();
85 deserializeFunctionTable();
94 void Deserializer::deserializeBooleanEdge() {
96 myread(&b_ptr, sizeof(Boolean *));
97 BooleanEdge tmp(b_ptr);
98 bool isNegated = tmp.isNegated();
99 ASSERT(map.contains(tmp.getBoolean()));
100 b_ptr = (Boolean *) map.get(tmp.getBoolean());
101 BooleanEdge res(b_ptr);
103 myread(&isTopLevel, sizeof(bool));
105 solver->addConstraint(isNegated ? res.negate() : res);
109 void Deserializer::deserializeBooleanVar() {
111 myread(&b, sizeof(BooleanVar *));
113 myread(&vtype, sizeof(VarType));
114 map.put(b, solver->getBooleanVar(vtype).getBoolean());
117 void Deserializer::deserializeBooleanOrder() {
118 BooleanOrder *bo_ptr;
119 myread(&bo_ptr, sizeof(BooleanOrder *));
121 myread(&order, sizeof(Order *));
122 ASSERT(map.contains(order));
123 order = (Order *) map.get(order);
125 myread(&first, sizeof(uint64_t));
127 myread(&second, sizeof(uint64_t));
128 map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
131 void Deserializer::deserializeOrder() {
133 myread(&o_ptr, sizeof(Order *));
135 myread(&type, sizeof(OrderType));
137 myread(&set_ptr, sizeof(Set *));
138 ASSERT(map.contains(set_ptr));
139 Set *set = (Set *) map.get(set_ptr);
140 map.put(o_ptr, solver->createOrder(type, set));
143 void Deserializer::deserializeSet() {
145 myread(&s_ptr, sizeof(Set *));
147 myread(&type, sizeof(VarType));
149 myread(&isRange, sizeof(bool));
151 myread(&isMutable, sizeof(bool));
154 myread(&low, sizeof(uint64_t));
156 myread(&high, sizeof(uint64_t));
157 map.put(s_ptr, new Set(type, low, high));
161 set = new MutableSet(type);
164 myread(&size, sizeof(uint));
165 Vector<uint64_t> members;
166 for(uint i=0; i<size; i++){
168 myread(&mem, sizeof(uint64_t));
170 ((MutableSet*) set)->addElementMSet(mem);
176 set = solver->createSet(type, members.expose(), size);
182 void Deserializer::deserializeBooleanLogic() {
183 BooleanLogic *bl_ptr;
184 myread(&bl_ptr, sizeof(BooleanLogic *));
186 myread(&op, sizeof(LogicOp));
188 myread(&size, sizeof(uint));
189 Vector<BooleanEdge> members;
190 for (uint i = 0; i < size; i++) {
192 myread(&member, sizeof(Boolean *));
193 BooleanEdge tmp(member);
194 bool isNegated = tmp.isNegated();
195 ASSERT(map.contains(tmp.getBoolean()));
196 member = (Boolean *) map.get(tmp.getBoolean());
197 BooleanEdge res(member);
198 members.push( isNegated ? res.negate() : res );
200 map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
203 void Deserializer::deserializeBooleanPredicate() {
204 BooleanPredicate *bp_ptr;
205 myread(&bp_ptr, sizeof(BooleanPredicate *));
206 Predicate *predicate;
207 myread(&predicate, sizeof(Predicate *));
208 ASSERT(map.contains(predicate));
209 predicate = (Predicate *) map.get(predicate);
211 myread(&size, sizeof(uint));
212 Vector<Element *> members;
213 for (uint i = 0; i < size; i++) {
215 myread(&input, sizeof(Element *));
216 ASSERT(map.contains(input));
217 input = (Element *) map.get(input);
222 myread(&stat_ptr, sizeof(Boolean *));
223 BooleanEdge undefStatus;
224 if (stat_ptr != NULL) {
225 BooleanEdge tmp(stat_ptr);
226 bool isNegated = tmp.isNegated();
227 ASSERT(map.contains(tmp.getBoolean()));
228 stat_ptr = (Boolean *) map.get(tmp.getBoolean());
229 BooleanEdge res(stat_ptr);
230 undefStatus = isNegated ? res.negate() : res;
234 map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
237 void Deserializer::deserializePredicateTable() {
238 PredicateTable *pt_ptr;
239 myread(&pt_ptr, sizeof(PredicateTable *));
241 myread(&table, sizeof(Table *));
242 ASSERT(map.contains(table));
243 table = (Table *) map.get(table);
244 UndefinedBehavior undefinedbehavior;
245 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
247 map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
250 void Deserializer::deserializePredicateOperator() {
251 PredicateOperator *po_ptr;
252 myread(&po_ptr, sizeof(PredicateOperator *));
254 myread(&op, sizeof(CompOp));
256 myread(&size, sizeof(uint));
257 Vector<Set *> domains;
258 for (uint i = 0; i < size; i++) {
260 myread(&domain, sizeof(Set *));
261 ASSERT(map.contains(domain));
262 domain = (Set *) map.get(domain);
263 domains.push(domain);
266 map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
269 void Deserializer::deserializeTable() {
271 myread(&t_ptr, sizeof(Table *));
273 myread(&size, sizeof(uint));
274 Vector<Set *> domains;
275 for (uint i = 0; i < size; i++) {
277 myread(&domain, sizeof(Set *));
278 ASSERT(map.contains(domain));
279 domain = (Set *) map.get(domain);
280 domains.push(domain);
283 myread(&range, sizeof(Set *));
285 ASSERT(map.contains(range));
286 range = (Set *) map.get(range);
288 Table *table = solver->createTable(domains.expose(), size, range);
289 myread(&size, sizeof(uint));
290 for (uint i = 0; i < size; i++) {
292 myread(&output, sizeof(uint64_t));
294 myread(&inputSize, sizeof(uint));
295 Vector<uint64_t> inputs;
296 inputs.setSize(inputSize);
297 myread(inputs.expose(), sizeof(uint64_t) * inputSize);
298 table->addNewTableEntry(inputs.expose(), inputSize, output);
301 map.put(t_ptr, table);
305 void Deserializer::deserializeElementSet() {
307 myread(&es_ptr, sizeof(ElementSet *));
309 myread(&set, sizeof(Set *));
310 ASSERT(map.contains(set));
311 set = (Set *) map.get(set);
312 map.put(es_ptr, solver->getElementVar(set));
315 void Deserializer::deserializeElementConst() {
317 myread(&es_ptr, sizeof(ElementSet *));
319 myread(&type, sizeof(VarType));
321 myread(&value, sizeof(uint64_t));
322 map.put(es_ptr, solver->getElementConst(type, value));
325 void Deserializer::deserializeElementFunction() {
326 ElementFunction *ef_ptr;
327 myread(&ef_ptr, sizeof(ElementFunction *));
329 myread(&function, sizeof(Function *));
330 ASSERT(map.contains(function));
331 function = (Function *) map.get(function);
333 myread(&size, sizeof(uint));
334 Vector<Element *> members;
335 for (uint i = 0; i < size; i++) {
337 myread(&input, sizeof(Element *));
338 ASSERT(map.contains(input));
339 input = (Element *) map.get(input);
343 Boolean *overflowstatus;
344 myread(&overflowstatus, sizeof(Boolean *));
345 BooleanEdge tmp(overflowstatus);
346 bool isNegated = tmp.isNegated();
347 ASSERT(map.contains(tmp.getBoolean()));
348 overflowstatus = (Boolean *) map.get(tmp.getBoolean());
349 BooleanEdge res(overflowstatus);
350 BooleanEdge undefStatus = isNegated ? res.negate() : res;
351 map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
355 void Deserializer::deserializeFunctionOperator() {
356 FunctionOperator *fo_ptr;
357 myread(&fo_ptr, sizeof(FunctionOperator *));
359 myread(&op, sizeof(ArithOp));
361 myread(&size, sizeof(uint));
362 Vector<Set *> domains;
363 for (uint i = 0; i < size; i++) {
365 myread(&domain, sizeof(Set *));
366 ASSERT(map.contains(domain));
367 domain = (Set *) map.get(domain);
368 domains.push(domain);
371 myread(&range, sizeof(Set *));
372 ASSERT(map.contains(range));
373 range = (Set *) map.get(range);
374 OverFlowBehavior overflowbehavior;
375 myread(&overflowbehavior, sizeof(OverFlowBehavior));
376 map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
379 void Deserializer::deserializeFunctionTable() {
380 FunctionTable *ft_ptr;
381 myread(&ft_ptr, sizeof(FunctionTable *));
383 myread(&table, sizeof(Table *));
384 ASSERT(map.contains(table));
385 table = (Table *) map.get(table);
386 UndefinedBehavior undefinedbehavior;
387 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
389 map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));