3 * File: deserializer.cc
6 * Created on September 7, 2017, 6:08 PM
9 #include "deserializer.h"
13 #include "predicate.h"
17 Deserializer::Deserializer(const char* file):
20 filedesc = open(file, O_RDONLY);
27 Deserializer::~Deserializer() {
31 ssize_t Deserializer::myread(void* __buf, size_t __nbytes){
32 return read (filedesc, __buf, __nbytes);
35 CSolver * Deserializer::deserialize(){
37 while(myread(&nodeType, sizeof(ASTNodeType) ) >0){
40 deserializeBooleanEdge();
43 deserializeBooleanVar();
46 deserializeBooleanOrder();
55 deserializeBooleanLogic();
58 deserializeBooleanPredicate();
61 deserializePredicateTable();
64 deserializePredicateOperator();
70 deserializeElementSet();
73 deserializeElementConst();
76 deserializeElementFunction();
79 deserializeFunctionOperator();
82 deserializeFunctionTable();
91 void Deserializer::deserializeBooleanEdge(){
93 myread(&b, sizeof(Boolean*));
95 bool isNegated = tmp.isNegated();
96 ASSERT(map.contains(tmp.getBoolean()));
97 b = (Boolean*) map.get(tmp.getBoolean());
99 solver->addConstraint(isNegated?res.negate():res);
102 void Deserializer::deserializeBooleanVar(){
104 myread(&b, sizeof(BooleanVar*));
106 myread(&vtype, sizeof(VarType));
107 map.put(b, solver->getBooleanVar(vtype).getBoolean());
110 void Deserializer::deserializeBooleanOrder(){
111 BooleanOrder* bo_ptr;
112 myread(&bo_ptr, sizeof(BooleanOrder*));
114 myread(&order, sizeof(Order*));
115 ASSERT(map.contains(order));
116 order = (Order*) map.get(order);
118 myread(&first, sizeof(uint64_t));
120 myread(&second, sizeof(uint64_t));
121 map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
124 void Deserializer::deserializeOrder(){
126 myread(&o_ptr, sizeof(Order*));
128 myread(&type, sizeof(OrderType));
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));
136 void Deserializer::deserializeSet(){
138 myread(&s_ptr, sizeof(Set*));
140 myread(&type, sizeof(VarType));
142 myread(&isRange, sizeof(bool));
144 myread(&low, sizeof(uint64_t));
146 myread(&high, sizeof(uint64_t));
148 myread(&size, sizeof(uint));
149 Vector<uint64_t> members;
150 for(uint i=0; i<size; i++){
152 myread(&mem, sizeof(uint64_t));
155 Set *set = isRange? solver->createRangeSet(type, low, high):
156 solver->createSet(type, members.expose(), size);
160 void Deserializer::deserializeBooleanLogic(){
161 BooleanLogic *bl_ptr;
162 myread(&bl_ptr, sizeof(BooleanLogic *));
164 myread(&op, sizeof(LogicOp));
166 myread(&size, sizeof(uint));
167 Vector<BooleanEdge> members;
168 for(uint i=0; i<size; i++){
171 map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
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);
182 myread(&size, sizeof(uint));
183 Vector<Element*> members;
184 for(uint i=0; i<size; i++){
186 myread(&input, sizeof(Element *));
187 ASSERT(map.contains(input));
188 input = (Element*) map.get(input);
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;
205 map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
208 void Deserializer::deserializePredicateTable(){
209 PredicateTable *pt_ptr;
210 myread(&pt_ptr, sizeof(PredicateTable *));
212 myread(&table, sizeof(Table*));
213 ASSERT(map.contains(table));
214 table = (Table*) map.get(table);
215 UndefinedBehavior undefinedbehavior;
216 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
218 map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
221 void Deserializer::deserializePredicateOperator(){
222 PredicateOperator *po_ptr;
223 myread(&po_ptr, sizeof(PredicateOperator *));
225 myread(&op, sizeof(CompOp));
227 myread(&size, sizeof(uint));
228 Vector<Set*> domains;
229 for(uint i=0; i<size; i++){
231 myread(&domain, sizeof(Set*));
232 ASSERT(map.contains(domain));
233 domain = (Set*) map.get(domain);
234 domains.push(domain);
237 map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
240 void Deserializer::deserializeTable(){
242 myread(&t_ptr, sizeof(Table *));
244 myread(&size, sizeof(uint));
245 Vector<Set*> domains;
246 for(uint i=0; i<size; i++){
248 myread(&domain, sizeof(Set*));
249 ASSERT(map.contains(domain));
250 domain = (Set*) map.get(domain);
251 domains.push(domain);
254 myread(&range, sizeof(Set*));
256 ASSERT(map.contains(range));
257 range = (Set*) map.get(range);
259 Table* table = solver->createTable(domains.expose(), size, range);
260 myread(&size, sizeof(uint));
261 for(uint i=0; i<size; i++){
263 myread(&output, sizeof(uint64_t));
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);
272 map.put(t_ptr, table);
276 void Deserializer::deserializeElementSet(){
278 myread(&es_ptr, sizeof(ElementSet*));
280 myread(&set, sizeof(Set *));
281 ASSERT(map.contains(set));
282 set = (Set*) map.get(set);
283 map.put(es_ptr, solver->getElementVar(set));
286 void Deserializer::deserializeElementConst(){
288 myread(&es_ptr, sizeof(ElementSet*));
290 myread(&type, sizeof(VarType));
292 myread(&value, sizeof(uint64_t));
293 map.put(es_ptr, solver->getElementConst(type, value));
296 void Deserializer::deserializeElementFunction(){
297 ElementFunction *ef_ptr;
298 myread(&ef_ptr, sizeof(ElementFunction *));
300 myread(&function, sizeof(Function*));
301 ASSERT(map.contains(function));
302 function = (Function*) map.get(function);
304 myread(&size, sizeof(uint));
305 Vector<Element*> members;
306 for(uint i=0; i<size; i++){
308 myread(&input, sizeof(Element *));
309 ASSERT(map.contains(input));
310 input = (Element*) map.get(input);
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;
323 map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
327 void Deserializer::deserializeFunctionOperator(){
328 FunctionOperator *fo_ptr;
329 myread(&fo_ptr, sizeof(FunctionOperator *));
331 myread(&op, sizeof(ArithOp));
333 myread(&size, sizeof(uint));
334 Vector<Set*> domains;
335 for(uint i=0; i<size; i++){
337 myread(&domain, sizeof(Set*));
338 ASSERT(map.contains(domain));
339 domain = (Set*) map.get(domain);
340 domains.push(domain);
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));
351 void Deserializer::deserializeFunctionTable(){
352 FunctionTable *ft_ptr;
353 myread(&ft_ptr, sizeof(FunctionTable *));
355 myread(&table, sizeof(Table*));
356 ASSERT(map.contains(table));
357 table = (Table*) map.get(table);
358 UndefinedBehavior undefinedbehavior;
359 myread(&undefinedbehavior, sizeof(UndefinedBehavior));
361 map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));