]>
Commit | Line | Data |
---|---|---|
3aaedf88 | 1 | /* |
2 | ** constraintExpr.c | |
3 | */ | |
4 | ||
5 | //#define DEBUGPRINT 1 | |
6 | ||
7 | # include "lclintMacros.nf" | |
8 | # include "basic.h" | |
9 | # include "cgrammar.h" | |
10 | # include "cgrammar_tokens.h" | |
11 | ||
12 | # include "exprChecks.h" | |
13 | # include "aliasChecks.h" | |
14 | # include "exprNodeSList.h" | |
15 | ||
16 | ||
17 | # include "exprData.i" | |
18 | # include "exprDataQuite.i" | |
19 | ||
20 | ||
21 | /*@-czechfcns@*/ | |
22 | ||
23 | #include "constraintExpr.h" | |
24 | ||
25 | ||
26 | ||
3aaedf88 | 27 | constraintExpr constraintExpr_makeMaxSetConstraintExpr (constraintExpr c); |
28 | ||
29 | bool constraintExpr_isLit (constraintExpr expr) | |
30 | { | |
dc92450f | 31 | llassert (expr != NULL); |
3aaedf88 | 32 | |
33 | if (expr->kind == term) | |
34 | { | |
35 | constraintTerm term = constraintExprData_termGetTerm (expr->data); | |
36 | if (constraintTerm_isIntLiteral (term) ) | |
37 | { | |
38 | return TRUE; | |
39 | } | |
40 | ||
41 | } | |
42 | return FALSE; | |
43 | } | |
44 | ||
45 | ||
46 | constraintExpr constraintExpr_propagateConstants (constraintExpr expr, | |
47 | /*@out@*/ bool * propagate, | |
48 | /*@out@*/ int *literal) | |
49 | { | |
50 | constraintExpr expr1; | |
51 | constraintExpr expr2; | |
52 | bool propagate1, propagate2; | |
53 | int literal1, literal2; | |
54 | ||
55 | propagate1 = FALSE; | |
56 | propagate2 = FALSE; | |
57 | ||
58 | literal1 = 0; | |
59 | literal2 = 0; | |
60 | ||
61 | *propagate = FALSE; | |
62 | *literal = 0; | |
63 | ||
dc92450f | 64 | llassert (expr != NULL); |
3aaedf88 | 65 | |
66 | // we simplify unaryExpr else where | |
67 | if (expr->kind == unaryExpr) | |
68 | return expr; | |
69 | ||
70 | if (expr->kind == term) | |
71 | return expr; | |
72 | ||
73 | if (constraintExpr_isLit (expr) ) | |
74 | return expr; | |
75 | ||
76 | BPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) ); | |
77 | ||
78 | expr1 = constraintExprData_binaryExprGetExpr1(expr->data); | |
79 | expr2 = constraintExprData_binaryExprGetExpr2(expr->data); | |
80 | ||
81 | expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1); | |
82 | expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2); | |
83 | ||
84 | expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1); | |
85 | expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2); | |
86 | ||
87 | *propagate = propagate1 || propagate2; | |
88 | *literal = literal1 + literal2; | |
89 | ||
90 | if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) ) | |
91 | { | |
92 | int t1, t2; | |
93 | t1 = constraintExpr_getValue (expr1); | |
94 | t2 = constraintExpr_getValue (expr2); | |
95 | *propagate = FALSE; | |
96 | if (constraintExprData_binaryExprGetOp (expr->data) == PLUS ) | |
97 | return (constraintExpr_makeIntLiteral ( (t1+t2) )); | |
98 | else if (constraintExprData_binaryExprGetOp (expr->data) == MINUS) | |
99 | return (constraintExpr_makeIntLiteral ( (t1-t2) )); | |
100 | else | |
101 | llassert(FALSE); | |
102 | } | |
103 | ||
104 | if (constraintExpr_isLit (expr1) ) | |
105 | { | |
106 | /*@i334*/ | |
107 | /*handle MINUS case right */ | |
108 | *propagate = TRUE; | |
109 | *literal += constraintExpr_getValue (expr1); | |
110 | return expr2; | |
111 | } | |
112 | ||
113 | ||
114 | if (constraintExpr_isLit (expr2) ) | |
115 | { | |
116 | *propagate = TRUE; | |
117 | ||
118 | if (constraintExprData_binaryExprGetOp (expr->data) == PLUS ) | |
119 | *literal += constraintExpr_getValue (expr2); | |
120 | else | |
121 | *literal -= constraintExpr_getValue (expr2); | |
122 | return expr1; | |
123 | } | |
124 | ||
125 | ||
126 | ||
127 | BPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) ); | |
128 | ||
129 | return expr; | |
130 | } | |
131 | ||
132 | constraintExpr constraintExpr_combineConstants (constraintExpr expr ) | |
133 | { | |
134 | bool propagate; | |
135 | int literal; | |
136 | ||
137 | BPRINTF ( (message ("Before combine %s", constraintExpr_unparse(expr) ) ) ); | |
138 | expr = constraintExpr_propagateConstants (expr, &propagate, &literal); | |
139 | ||
140 | ||
141 | if (propagate) | |
142 | { | |
143 | constraintExpr ret; | |
144 | ||
145 | if (literal != 0) | |
146 | { | |
147 | ret = constraintExpr_makeBinaryOpConstraintExprIntLiteral (expr, literal); | |
148 | expr = ret; | |
149 | } | |
150 | } | |
151 | BPRINTF ( (message ("After combine %s", constraintExpr_unparse(expr) ) ) ); | |
152 | return expr; | |
153 | } | |
dc92450f | 154 | /*@special@*/ |
155 | constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/ | |
3aaedf88 | 156 | { |
157 | constraintExpr ret; | |
158 | ret = dmalloc (sizeof (*ret) ); | |
159 | ret->kind = term; | |
160 | ret->data = NULL; | |
161 | return ret; | |
162 | } | |
163 | ||
164 | ||
165 | constraintExpr constraintExpr_copy (constraintExpr expr) | |
166 | { | |
167 | constraintExpr ret; | |
168 | ret = constraintExpr_alloc(); | |
169 | ret->kind = expr->kind; | |
170 | ret->data = constraintExprData_copy (expr->data, expr->kind); | |
171 | return ret; | |
172 | } | |
173 | ||
174 | ||
175 | constraintExpr oldconstraintExpr_makeTermExprNode (exprNode e) | |
176 | { | |
177 | constraintExpr ret; | |
178 | constraintTerm t; | |
179 | ret = constraintExpr_alloc(); | |
180 | ret->kind = term; | |
181 | ret->data = dmalloc (sizeof *(ret->data) ); | |
182 | t = constraintTerm_makeExprNode (e); | |
183 | ret->data = constraintExprData_termSetTerm (ret->data, t); | |
184 | return ret; | |
185 | } | |
186 | ||
187 | constraintExpr constraintExpr_makeExprNode (exprNode e) | |
188 | { | |
189 | sRef s; | |
190 | constraintExpr ret, ce1, ce2; | |
191 | exprData data; | |
192 | exprNode t, t1, t2; | |
193 | lltok tok; | |
194 | ||
195 | ||
dc92450f | 196 | llassert (e != NULL); |
3aaedf88 | 197 | |
198 | data = e->edata; | |
199 | ||
200 | switch (e->kind) | |
201 | { | |
202 | case XPR_SIZEOF: | |
203 | t = exprData_getSingle (data); | |
204 | s = exprNode_getSref (t); | |
205 | if (sRef_isFixedArray(s) ) | |
206 | { | |
207 | int size; | |
208 | ||
dc92450f | 209 | size = (int) sRef_getArraySize(s); |
3aaedf88 | 210 | ret = constraintExpr_makeIntLiteral (size); |
211 | } | |
212 | else | |
213 | { | |
214 | BPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) ); | |
215 | ret = oldconstraintExpr_makeTermExprNode (e); | |
216 | } | |
217 | break; | |
218 | ||
219 | case XPR_OP: | |
220 | BPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) ); | |
221 | t1 = exprData_getOpA (data); | |
222 | t2 = exprData_getOpB (data); | |
223 | tok = exprData_getOpTok (data); | |
224 | ||
225 | if (lltok_isPlus_Op (tok) || lltok_isMinus_Op (tok) ) | |
226 | { | |
227 | ce1 = constraintExpr_makeExprNode (t1); | |
228 | ce2 = constraintExpr_makeExprNode (t2); | |
229 | ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2); | |
230 | } | |
231 | else | |
232 | { | |
233 | ret = oldconstraintExpr_makeTermExprNode (e); | |
234 | } | |
235 | break; | |
236 | case XPR_PARENS: | |
237 | t = exprData_getUopNode (data); | |
238 | ret = constraintExpr_makeExprNode (t); | |
239 | break; | |
240 | ||
241 | case XPR_PREOP: | |
242 | t = exprData_getUopNode (data); | |
243 | tok = exprData_getUopTok (data); | |
244 | if (lltok_isInc_Op (tok) ) | |
245 | { | |
246 | constraintExpr temp; | |
247 | temp = constraintExpr_makeExprNode(t); | |
248 | ret = constraintExpr_makeIncConstraintExpr(temp); | |
249 | } | |
250 | else if (lltok_isDec_Op (tok) ) | |
251 | { | |
252 | constraintExpr temp; | |
253 | temp = constraintExpr_makeExprNode(t); | |
254 | ret = constraintExpr_makeDecConstraintExpr(temp); | |
255 | } | |
256 | else | |
257 | ret = oldconstraintExpr_makeTermExprNode (e); | |
258 | break; | |
259 | ||
260 | case XPR_POSTOP: | |
261 | t = exprData_getUopNode (data); | |
262 | ret = constraintExpr_makeExprNode (t); | |
263 | break; | |
264 | default: | |
265 | ret = oldconstraintExpr_makeTermExprNode (e); | |
266 | ||
267 | } | |
268 | return ret; | |
269 | } | |
270 | ||
271 | ||
272 | constraintExpr constraintExpr_makeTermExprNode (exprNode e) | |
273 | { | |
274 | return oldconstraintExpr_makeTermExprNode(e); //constraintExpr_makeExprNode (e); | |
275 | } | |
276 | ||
277 | ||
278 | constraintExpr constraintExpr_makeTermsRef (sRef s) | |
279 | { | |
280 | constraintExpr ret; | |
281 | constraintTerm t; | |
282 | ret = constraintExpr_alloc(); | |
283 | ret->kind = term; | |
284 | ret->data = dmalloc (sizeof *(ret->data) ); | |
285 | t = constraintTerm_makesRef (s); | |
286 | ret->data = constraintExprData_termSetTerm (ret->data, t); | |
287 | return ret; | |
288 | } | |
289 | ||
dc92450f | 290 | constraintExpr constraintExpr_makeUnaryOp (void) /*@allocates result->data@*/ |
3aaedf88 | 291 | { |
292 | constraintExpr ret; | |
293 | ret = constraintExpr_alloc(); | |
294 | ret->kind = unaryExpr; | |
295 | ret->data = dmalloc ( sizeof *(ret->data) ); | |
296 | return ret; | |
297 | } | |
298 | ||
299 | constraintExpr constraintExpr_makeUnaryOpConstraintExpr (constraintExpr cexpr) | |
300 | { | |
301 | constraintExpr ret; | |
302 | ret = constraintExpr_makeUnaryOp(); | |
303 | ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr); | |
304 | return ret; | |
305 | } | |
306 | ||
307 | constraintExpr constraintExpr_makeMaxSetConstraintExpr (constraintExpr c) | |
308 | { | |
309 | constraintExpr ret; | |
310 | ret = constraintExpr_makeUnaryOpConstraintExpr (c); | |
311 | ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET); | |
312 | return ret; | |
313 | } | |
314 | ||
315 | constraintExpr constraintExpr_makeUnaryOpExprNode (exprNode expr) | |
316 | { | |
317 | constraintExpr ret; | |
318 | constraintExpr sub; | |
319 | sub = constraintExpr_makeExprNode (expr); | |
320 | ret = constraintExpr_makeUnaryOpConstraintExpr(sub); | |
321 | return ret; | |
322 | } | |
323 | ||
324 | ||
325 | ||
326 | constraintExpr constraintExpr_makeSRefUnaryOp (sRef s, constraintExprUnaryOpKind op) | |
327 | { | |
328 | constraintExpr ret; | |
329 | constraintExpr t; | |
330 | ||
331 | t = constraintExpr_makeTermsRef (s); | |
332 | ret = constraintExpr_makeUnaryOpConstraintExpr (t); | |
333 | ret->data = constraintExprData_unaryExprSetOp (ret->data, op); | |
334 | return ret; | |
335 | } | |
336 | ||
337 | constraintExpr constraintExpr_makeSRefMaxset (sRef s) | |
338 | { | |
339 | return (constraintExpr_makeSRefUnaryOp (s, MAXSET) ); | |
340 | } | |
341 | ||
342 | constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr) | |
343 | { | |
344 | constraintExpr ret; | |
345 | ret = constraintExpr_makeUnaryOpConstraintExpr ( cexpr); | |
346 | ||
347 | switch (op.tok) | |
348 | { | |
349 | case QMAXSET: | |
350 | ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET); | |
351 | break; | |
352 | case QMAXREAD: | |
353 | ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD); | |
354 | break; | |
355 | default: | |
dc92450f | 356 | llfatalbug(message("Unhandled Operation in Constraint") ); |
3aaedf88 | 357 | } |
358 | return ret; | |
359 | } | |
360 | ||
361 | constraintExpr constraintExpr_makeMaxSetExpr (exprNode expr) | |
362 | { | |
363 | constraintExpr ret; | |
364 | ret = constraintExpr_makeExprNode (expr); | |
365 | ||
366 | ret = constraintExpr_makeMaxSetConstraintExpr (ret); | |
367 | ||
dc92450f | 368 | llassert (ret != NULL); |
3aaedf88 | 369 | return ret; |
370 | } | |
371 | ||
372 | constraintExpr constraintExpr_makeMaxReadExpr (exprNode expr) | |
373 | { | |
374 | constraintExpr ret; | |
375 | ret = constraintExpr_makeUnaryOpExprNode(expr); | |
376 | ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD); | |
377 | return ret; | |
378 | } | |
379 | ||
380 | constraintExpr constraintExpr_makeMinSetExpr (exprNode expr) | |
381 | { | |
382 | constraintExpr ret; | |
383 | ret = constraintExpr_makeUnaryOpExprNode(expr); | |
384 | ret->data = constraintExprData_unaryExprSetOp (ret->data, MINSET); | |
385 | return ret; | |
386 | } | |
387 | ||
388 | constraintExpr constraintExpr_makeMinReadExpr (exprNode expr) | |
389 | { | |
390 | constraintExpr ret; | |
391 | ret = constraintExpr_makeUnaryOpExprNode(expr); | |
392 | ret->data = constraintExprData_unaryExprSetOp (ret->data, MINREAD); | |
393 | return ret; | |
394 | } | |
395 | ||
396 | ||
397 | constraintExpr constraintExpr_makeValueExpr (exprNode expr) | |
398 | { | |
399 | constraintExpr ret; | |
400 | ret = constraintExpr_makeExprNode (expr); | |
401 | return ret; | |
402 | } | |
403 | ||
404 | constraintExpr constraintExpr_makeIntLiteral (int i) | |
405 | { | |
406 | constraintExpr ret; | |
407 | constraintTerm t; | |
408 | ret = constraintExpr_alloc(); | |
409 | ret->kind = term; | |
410 | ret->data = dmalloc (sizeof *(ret->data) ); | |
411 | t = constraintTerm_makeIntLiteral (i); | |
412 | ret->data = constraintExprData_termSetTerm (ret->data, t); | |
413 | return ret; | |
414 | } | |
415 | ||
416 | ||
417 | constraintExpr constraintExpr_makeValueInt (int i) | |
418 | { | |
419 | return constraintExpr_makeIntLiteral (i); | |
420 | } | |
421 | ||
422 | static constraintExpr constraintExpr_makeBinaryOp (void) | |
423 | { | |
424 | constraintExpr ret; | |
425 | ret = constraintExpr_alloc(); | |
426 | ret->kind = binaryexpr; | |
427 | ret->data = dmalloc ( sizeof *(ret->data) ); | |
428 | ret->data = constraintExprData_binaryExprSetOp (ret->data, PLUS); | |
429 | return ret; | |
430 | } | |
431 | ||
432 | ||
433 | constraintExpr constraintExpr_makeBinaryOpConstraintExpr (constraintExpr expr1,constraintExpr expr2) | |
434 | ||
435 | { | |
436 | constraintExpr ret; | |
437 | ret = constraintExpr_makeBinaryOp(); | |
438 | ret->data = constraintExprData_binaryExprSetExpr1 (ret->data, expr1); | |
439 | ret->data = constraintExprData_binaryExprSetExpr2 (ret->data, expr2); | |
440 | return ret; | |
441 | } | |
442 | ||
443 | constraintExpr constraintExpr_parseMakeBinaryOp (constraintExpr expr1, lltok op, constraintExpr expr2) | |
444 | { | |
445 | constraintExpr ret; | |
446 | ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2); | |
447 | if (op.tok == TPLUS) | |
448 | ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS); | |
449 | else if (op.tok == TMINUS) | |
450 | ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS); | |
451 | else | |
452 | { | |
453 | llassert(FALSE); | |
454 | } | |
455 | return ret; | |
456 | } | |
457 | ||
458 | constraintExpr constraintExpr_makeBinaryOpExprNode (exprNode expr1, exprNode expr2) | |
459 | { | |
460 | constraintExpr ret; | |
461 | constraintExpr sub1, sub2; | |
462 | sub1 = constraintExpr_makeTermExprNode (expr1); | |
463 | sub2 = constraintExpr_makeTermExprNode (expr2); | |
464 | ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2); | |
465 | return ret; | |
466 | } | |
467 | ||
468 | constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (constraintExpr expr, int literal) | |
469 | { | |
470 | constraintExpr ret; | |
471 | constraintExpr constExpr; | |
472 | ||
473 | constExpr = constraintExpr_makeIntLiteral (literal); | |
474 | ret = constraintExpr_makeBinaryOpConstraintExpr (expr, constExpr); | |
475 | ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS); | |
476 | return ret; | |
477 | } | |
478 | ||
479 | constraintExpr constraintExpr_makeDecConstraintExpr (constraintExpr expr) | |
480 | { | |
481 | constraintExpr ret; | |
482 | constraintExpr inc; | |
483 | ||
484 | inc = constraintExpr_makeIntLiteral (1); | |
485 | ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc); | |
486 | ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS); | |
487 | return ret; | |
488 | } | |
489 | ||
490 | constraintExpr constraintExpr_makeAddConstraintExpr (constraintExpr expr, constraintExpr add) | |
491 | { | |
492 | constraintExpr ret; | |
493 | ||
494 | ret = constraintExpr_makeBinaryOpConstraintExpr (expr, add); | |
495 | ||
496 | ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS); | |
497 | ||
498 | return ret; | |
499 | } | |
500 | ||
501 | constraintExpr constraintExpr_makeIncConstraintExpr (constraintExpr expr) | |
502 | { | |
503 | constraintExpr ret; | |
504 | constraintExpr inc; | |
505 | ||
506 | inc = constraintExpr_makeIntLiteral (1); | |
507 | ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc); | |
508 | ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS); | |
509 | return ret; | |
510 | } | |
511 | ||
512 | cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op) | |
513 | { | |
514 | switch (op) | |
515 | { | |
516 | case MAXSET: | |
517 | return message("MAXSET"); | |
518 | case MINSET: | |
519 | return message("MINSET"); | |
520 | case MAXREAD: | |
521 | return message("MAXREAD"); | |
522 | case MINREAD: | |
523 | return message("MINREAD"); | |
524 | default: | |
525 | llassert(FALSE); | |
526 | return message ("<(Unary OP OTHER>"); | |
527 | } | |
528 | } | |
529 | ||
530 | ||
531 | cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op) | |
532 | { | |
533 | ||
534 | switch (op) | |
535 | { | |
536 | case PLUS: | |
537 | return message("+"); | |
538 | case MINUS: | |
539 | return message("-"); | |
dc92450f | 540 | |
541 | default: | |
542 | llassert(FALSE); | |
543 | return message ("<binary OP Unknown>"); | |
3aaedf88 | 544 | } |
3aaedf88 | 545 | } |
546 | ||
547 | bool constraintExpr_similar (constraintExpr expr1, constraintExpr expr2) | |
548 | { | |
549 | constraintExprKind kind; | |
550 | ||
551 | llassert (expr1 != NULL); | |
552 | llassert (expr2 != NULL); | |
553 | if (expr1->kind != expr2->kind) | |
554 | return FALSE; | |
555 | ||
556 | kind = expr1->kind; | |
557 | ||
558 | switch (kind) | |
559 | { | |
560 | case term: | |
561 | return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data), | |
562 | constraintExprData_termGetTerm(expr2->data) ); | |
dc92450f | 563 | /*@noreached@*/ break; |
3aaedf88 | 564 | |
565 | case unaryExpr: | |
566 | if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) ) | |
567 | return FALSE; | |
568 | ||
569 | return (constraintExpr_similar ( | |
570 | constraintExprData_unaryExprGetExpr (expr1->data), | |
571 | constraintExprData_unaryExprGetExpr (expr2->data) | |
572 | )); | |
573 | ||
574 | case binaryexpr: | |
575 | if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) ) | |
576 | return FALSE; | |
577 | ||
578 | if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr1 (expr1->data), | |
579 | constraintExprData_binaryExprGetExpr1 (expr2->data)) ) | |
580 | return FALSE; | |
581 | ||
582 | if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr2 (expr1->data), | |
583 | constraintExprData_binaryExprGetExpr2 (expr2->data)) ) | |
584 | return FALSE; | |
585 | else | |
586 | return TRUE; | |
587 | /*@notreached@*/ | |
588 | break; | |
589 | ||
590 | default: | |
591 | llassert(FALSE); | |
592 | return FALSE; | |
593 | } | |
594 | /*@notreached@*/ | |
595 | return FALSE; | |
596 | } | |
597 | ||
598 | bool constraintExpr_same (constraintExpr expr1, constraintExpr expr2) | |
599 | { | |
600 | constraintExprKind kind; | |
601 | ||
602 | llassert (expr1 != NULL); | |
603 | llassert (expr2 != NULL); | |
604 | if (expr1->kind != expr2->kind) | |
605 | return FALSE; | |
606 | ||
607 | kind = expr1->kind; | |
608 | ||
609 | switch (kind) | |
610 | { | |
611 | case term: | |
612 | return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data), | |
613 | constraintExprData_termGetTerm(expr2->data) ); | |
dc92450f | 614 | /*@notreached@*/ break; |
3aaedf88 | 615 | |
616 | case unaryExpr: | |
617 | if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) ) | |
618 | return FALSE; | |
619 | ||
620 | return (constraintExpr_same ( | |
621 | constraintExprData_unaryExprGetExpr (expr1->data), | |
622 | constraintExprData_unaryExprGetExpr (expr2->data) | |
623 | )); | |
624 | ||
625 | ||
626 | case binaryexpr: | |
627 | if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) ) | |
628 | return FALSE; | |
629 | ||
630 | if (! constraintExpr_same (constraintExprData_binaryExprGetExpr1 (expr1->data), | |
631 | constraintExprData_binaryExprGetExpr1 (expr2->data)) ) | |
632 | return FALSE; | |
633 | ||
634 | if (! constraintExpr_same (constraintExprData_binaryExprGetExpr2 (expr1->data), | |
635 | constraintExprData_binaryExprGetExpr2 (expr2->data)) ) | |
636 | return FALSE; | |
637 | else | |
638 | return TRUE; | |
dc92450f | 639 | /*@notreached@*/ break; |
3aaedf88 | 640 | |
641 | default: | |
642 | llassert(FALSE); | |
643 | return FALSE; | |
644 | } | |
645 | ||
646 | /*@notreached@*/ | |
647 | BADEXIT; | |
648 | } | |
649 | ||
650 | bool constraintExpr_search (constraintExpr c, constraintExpr old) | |
651 | { | |
652 | bool ret = FALSE; | |
653 | constraintExprKind kind; | |
654 | constraintExpr temp; | |
655 | ||
656 | if ( constraintExpr_similar (c, old) ) | |
657 | { | |
658 | #warning mem leak | |
659 | DPRINTF((message ("Found %s", | |
660 | constraintExpr_unparse(old) | |
661 | ))); | |
662 | return TRUE; | |
663 | } | |
664 | ||
665 | kind = c->kind; | |
666 | ||
667 | switch (kind) | |
668 | { | |
669 | case term: | |
670 | break; | |
671 | case unaryExpr: | |
672 | temp = constraintExprData_unaryExprGetExpr (c->data); | |
673 | ret = ret || constraintExpr_search (temp, old); | |
674 | break; | |
675 | case binaryexpr: | |
676 | ||
677 | temp = constraintExprData_binaryExprGetExpr1 (c->data); | |
678 | ret = ret || constraintExpr_search(temp, old); | |
679 | ||
680 | temp = constraintExprData_binaryExprGetExpr2 (c->data); | |
681 | ret = ret || constraintExpr_search(temp, old); | |
682 | break; | |
683 | default: | |
684 | llassert(FALSE); | |
685 | } | |
686 | return ret; | |
687 | ||
688 | } | |
689 | ||
690 | ||
691 | constraintExpr constraintExpr_searchandreplace (constraintExpr c, constraintExpr old, constraintExpr new ) | |
692 | { | |
693 | constraintExprKind kind; | |
694 | constraintExpr temp; | |
695 | ||
696 | if ( constraintExpr_similar (c, old) ) | |
697 | { | |
698 | #warning mem leak | |
699 | BPRINTF((message ("Replacing %s with %s", | |
700 | constraintExpr_unparse(old), constraintExpr_unparse(new) | |
701 | ))); | |
702 | return constraintExpr_copy (new); | |
703 | } | |
704 | ||
705 | kind = c->kind; | |
706 | ||
707 | switch (kind) | |
708 | { | |
709 | case term: | |
710 | break; | |
711 | case unaryExpr: | |
712 | temp = constraintExprData_unaryExprGetExpr (c->data); | |
713 | temp = constraintExpr_searchandreplace (temp, old, new); | |
714 | c->data = constraintExprData_unaryExprSetExpr (c->data, temp); | |
715 | break; | |
716 | case binaryexpr: | |
717 | ||
718 | temp = constraintExprData_binaryExprGetExpr1 (c->data); | |
719 | temp = constraintExpr_searchandreplace (temp, old, new); | |
720 | c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp); | |
721 | ||
722 | temp = constraintExprData_binaryExprGetExpr2 (c->data); | |
723 | temp = constraintExpr_searchandreplace (temp, old, new); | |
724 | c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp); | |
725 | break; | |
726 | default: | |
727 | llassert(FALSE); | |
728 | } | |
729 | return c; | |
730 | ||
731 | } | |
732 | ||
733 | constraintExpr constraintExpr_simplifyChildren (constraintExpr c) | |
734 | { | |
735 | constraintExprKind kind; | |
736 | constraintExpr temp; | |
737 | ||
738 | kind = c->kind; | |
739 | ||
740 | switch (kind) | |
741 | { | |
742 | case term: | |
743 | break; | |
744 | case unaryExpr: | |
745 | temp = constraintExprData_unaryExprGetExpr (c->data); | |
746 | temp = constraintExpr_simplify (temp); | |
747 | c->data = constraintExprData_unaryExprSetExpr (c->data, temp); | |
748 | break; | |
749 | case binaryexpr: | |
750 | BPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) ); | |
751 | temp = constraintExprData_binaryExprGetExpr1 (c->data); | |
752 | temp = constraintExpr_simplify (temp); | |
753 | ||
754 | c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp); | |
755 | ||
756 | temp = constraintExprData_binaryExprGetExpr2 (c->data); | |
757 | temp = constraintExpr_simplify (temp); | |
758 | ||
759 | c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp); | |
760 | break; | |
761 | default: | |
762 | llassert(FALSE); | |
763 | } | |
764 | return c; | |
765 | ||
766 | } | |
767 | ||
768 | ||
769 | constraintExpr constraintExpr_setFileloc (constraintExpr c, fileloc loc) | |
770 | { | |
771 | constraintTerm t; | |
772 | constraintExpr temp; | |
773 | ||
dc92450f | 774 | llassert(c != NULL); |
3aaedf88 | 775 | |
776 | switch (c->kind) | |
777 | { | |
778 | case term: | |
779 | t = constraintExprData_termGetTerm (c->data); | |
780 | t = constraintTerm_setFileloc (t, loc); | |
781 | c->data = constraintExprData_termSetTerm (c->data, t); | |
782 | break; | |
783 | case binaryexpr: | |
784 | ||
785 | temp = constraintExprData_binaryExprGetExpr1 (c->data); | |
786 | temp = constraintExpr_setFileloc (temp, loc); | |
787 | c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp); | |
788 | ||
789 | temp = constraintExprData_binaryExprGetExpr2 (c->data); | |
790 | temp = constraintExpr_setFileloc (temp, loc); | |
791 | c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp); | |
792 | break; | |
793 | case unaryExpr: | |
794 | temp = constraintExprData_unaryExprGetExpr (c->data); | |
795 | temp = constraintExpr_setFileloc (temp, loc); | |
796 | c->data = constraintExprData_unaryExprSetExpr (c->data, temp); | |
797 | break; | |
798 | } | |
799 | return c; | |
800 | } | |
801 | ||
802 | constraintExpr constraintExpr_simplifybinaryExpr (constraintExpr c) | |
803 | { | |
804 | constraintExpr e1, e2; | |
805 | ||
806 | e1 = constraintExprData_binaryExprGetExpr1 (c->data); | |
807 | e2 = constraintExprData_binaryExprGetExpr2 (c->data); | |
808 | ||
809 | if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) ) | |
810 | { | |
811 | int i; | |
812 | ||
813 | i = constraintExpr_getValue(e1) + constraintExpr_getValue (e2); | |
814 | ||
815 | c = constraintExpr_makeIntLiteral (i); | |
816 | ||
817 | } | |
818 | return c; | |
819 | } | |
820 | ||
821 | ||
822 | constraintExpr constraintExpr_subtractExpr (constraintExpr expr, constraintExpr addent) | |
823 | { | |
824 | constraintExpr new; | |
825 | ||
826 | BPRINTF ( (message ("Doing subtraceTerm simplification") ) ); | |
827 | ||
828 | new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent); | |
829 | new->data = constraintExprData_binaryExprSetOp (new->data, MINUS); | |
830 | return new; | |
831 | } | |
832 | ||
833 | constraintExpr constraintExpr_addExpr (constraintExpr expr, constraintExpr addent) | |
834 | { | |
835 | constraintExpr new; | |
836 | ||
837 | BPRINTF ( (message ("Doing addTerm simplification") ) ); | |
838 | ||
839 | new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent); | |
840 | new->data = constraintExprData_binaryExprSetOp (new->data, PLUS); | |
841 | return new; | |
842 | } | |
843 | ||
844 | constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, constraintExpr expr) | |
845 | { | |
846 | constraintExpr expr1, expr2; | |
847 | constraintExprBinaryOpKind op; | |
848 | ||
849 | if (lexpr->kind != binaryexpr) | |
850 | return expr; | |
851 | ||
852 | expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data); | |
853 | expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data); | |
854 | op = constraintExprData_binaryExprGetOp (lexpr->data); | |
855 | ||
856 | ||
857 | // if (constraintExpr_canGetValue (expr2) ) | |
858 | { | |
859 | #warning make sure this works | |
860 | ||
861 | lexpr->kind = expr1->kind; | |
862 | lexpr->data = constraintExprData_copy (expr1->data, expr1->kind); | |
863 | ||
864 | ||
865 | if (op == PLUS) | |
866 | expr = constraintExpr_subtractExpr (expr, expr2); | |
867 | else | |
868 | expr = constraintExpr_addExpr (expr, expr2); | |
869 | ||
870 | return expr; | |
871 | } | |
872 | expr = constraintExpr_solveBinaryExpr (expr1, expr); | |
873 | ||
874 | expr = constraintExpr_solveBinaryExpr (expr2, expr); | |
875 | return expr; | |
876 | } | |
877 | ||
878 | constraintExpr constraintExpr_simplifyunaryExpr (constraintExpr c) | |
879 | { | |
880 | constraintExpr exp; | |
881 | ||
882 | llassert (c->kind == unaryExpr); | |
883 | ||
884 | BPRINTF ( (message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) ); | |
885 | ||
886 | if ( (constraintExprData_unaryExprGetOp (c->data) != MAXSET) && | |
887 | (constraintExprData_unaryExprGetOp (c->data) != MAXREAD) ) | |
888 | { | |
889 | return c; | |
890 | } | |
891 | // pattern mxr ( var + const) = mxr(var) - const | |
892 | ||
893 | exp = constraintExprData_unaryExprGetExpr (c->data); | |
894 | ||
895 | if (exp->kind == term) | |
896 | { | |
897 | constraintTerm cterm; | |
898 | ||
899 | cterm = constraintExprData_termGetTerm (exp->data); | |
900 | ||
901 | if (constraintTerm_isStringLiteral(cterm) ) | |
902 | { | |
903 | cstring val; | |
904 | val = constraintTerm_getStringLiteral (cterm); | |
905 | if (constraintExprData_unaryExprGetOp (c->data) == MAXSET) | |
906 | { | |
907 | return constraintExpr_makeIntLiteral (strlen (val) ); | |
908 | } | |
909 | if (constraintExprData_unaryExprGetOp (c->data) == MAXREAD) | |
910 | { | |
911 | return constraintExpr_makeIntLiteral (strlen (val) ); | |
912 | } | |
913 | BADEXIT; | |
914 | } | |
915 | return c; | |
916 | } | |
917 | ||
918 | if (exp->kind != binaryexpr) | |
919 | return c; | |
920 | ||
921 | if (constraintExprData_binaryExprGetOp (exp->data) == PLUS ) | |
922 | { | |
923 | ||
924 | // if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) ) | |
925 | { | |
926 | ||
927 | constraintExpr temp, temp2, new; | |
928 | ||
929 | DPRINTF ( (message ("Doing fancy simplification") ) ); | |
930 | ||
931 | temp = constraintExprData_binaryExprGetExpr2 (exp->data); | |
932 | ||
933 | temp2 = constraintExprData_binaryExprGetExpr1 (exp->data); | |
934 | c->data = constraintExprData_unaryExprSetExpr (c->data, temp2); | |
935 | ||
936 | ||
937 | ||
938 | new = constraintExpr_subtractExpr (c, temp); | |
939 | ||
940 | DPRINTF ( (message ("Done fancy simplification:%s", constraintExpr_unparse (new) ) ) ); | |
941 | ||
942 | c = new; | |
943 | } | |
944 | } | |
945 | ||
946 | DPRINTF ( (message ("Done simplification:%s", constraintExpr_unparse (c) ) ) ); | |
947 | return c; | |
948 | } | |
949 | ||
950 | ||
951 | constraintExpr constraintExpr_simplify (constraintExpr c) | |
952 | { | |
953 | constraintExprKind kind; | |
954 | constraintTerm t; | |
955 | ||
956 | ||
957 | BPRINTF ( (message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) ); | |
958 | ||
959 | c = constraintExpr_simplifyChildren (c); | |
960 | c = constraintExpr_combineConstants (c); | |
961 | c = constraintExpr_simplifyChildren (c); | |
962 | ||
963 | kind = c->kind; | |
964 | ||
965 | switch (kind) | |
966 | { | |
967 | case term: | |
968 | t = constraintExprData_termGetTerm (c->data); | |
969 | t = constraintTerm_simplify (t); | |
970 | c->data = constraintExprData_termSetTerm (c->data, t); | |
971 | break; | |
972 | case unaryExpr: | |
973 | c = constraintExpr_simplifyunaryExpr (c); | |
974 | break; | |
975 | case binaryexpr: | |
976 | c = constraintExpr_simplifybinaryExpr (c); | |
977 | break; | |
978 | default: | |
979 | llassert(FALSE); | |
980 | } | |
981 | return c; | |
982 | ||
983 | } | |
984 | ||
985 | cstring constraintExpr_unparse (constraintExpr ex) | |
986 | { | |
987 | cstring st; | |
988 | constraintExprKind kind; | |
989 | ||
990 | llassert (ex != NULL); | |
991 | ||
992 | kind = ex->kind; | |
993 | ||
994 | switch (kind) | |
995 | { | |
996 | case term: | |
997 | st = message ("(%s) ", constraintTerm_print (constraintExprData_termGetTerm(ex->data) ) ); | |
998 | break; | |
999 | case unaryExpr: | |
1000 | st = message ("%s (%s)", | |
1001 | constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data) | |
1002 | ), | |
1003 | constraintExpr_unparse (constraintExprData_unaryExprGetExpr (ex->data) ) | |
1004 | ); | |
1005 | break; | |
1006 | case binaryexpr: | |
1007 | st = message ("(%s) %s (%s)", | |
1008 | constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ), | |
1009 | constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data) | |
1010 | ), | |
1011 | constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) ) | |
1012 | ); | |
1013 | break; | |
1014 | default: | |
1015 | llassert(FALSE); | |
1016 | st = message ("error"); | |
1017 | ||
1018 | } | |
1019 | ||
1020 | DPRINTF((message ("constraintExpr_unparse: '%s'",st) ) ); | |
1021 | return st; | |
1022 | } | |
1023 | ||
1024 | constraintExpr constraintExpr_doSRefFixBaseParam (/*@returned@*/ constraintExpr expr, exprNodeList arglist) | |
1025 | { | |
1026 | constraintTerm Term; | |
1027 | constraintExprKind kind; | |
1028 | constraintExpr expr1, expr2; | |
1029 | constraintExprData data; | |
1030 | llassert (expr != NULL); | |
1031 | ||
1032 | data = expr->data; | |
1033 | ||
1034 | kind = expr->kind; | |
1035 | ||
1036 | switch (kind) | |
1037 | { | |
1038 | case term: | |
1039 | Term = constraintExprData_termGetTerm(data); | |
1040 | Term = constraintTerm_doSRefFixBaseParam (Term, arglist); | |
1041 | data = constraintExprData_termSetTerm(data, Term); | |
1042 | break; | |
1043 | case unaryExpr: | |
1044 | expr1 = constraintExprData_unaryExprGetExpr (data); | |
1045 | expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist); | |
1046 | data = constraintExprData_unaryExprSetExpr (data, expr1); | |
1047 | break; | |
1048 | case binaryexpr: | |
1049 | expr1 = constraintExprData_binaryExprGetExpr1 (data); | |
1050 | expr2 = constraintExprData_binaryExprGetExpr2 (data); | |
1051 | ||
1052 | expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist); | |
1053 | data = constraintExprData_binaryExprSetExpr1 (data, expr1); | |
1054 | expr2 = constraintExpr_doSRefFixBaseParam (expr2, arglist); | |
1055 | data = constraintExprData_binaryExprSetExpr2 (data, expr2); | |
1056 | ||
1057 | break; | |
1058 | default: | |
1059 | llassert(FALSE); | |
1060 | data = NULL; | |
1061 | } | |
1062 | return expr; | |
1063 | } | |
1064 | ||
1065 | constraintExpr constraintExpr_doSRefFixConstraintParam (/*@returned@*/ constraintExpr expr, exprNodeList arglist) | |
1066 | { | |
1067 | constraintExprKind kind; | |
1068 | constraintExpr expr1, expr2; | |
1069 | constraintExprData data; | |
1070 | llassert (expr != NULL); | |
1071 | ||
1072 | data = expr->data; | |
1073 | ||
1074 | kind = expr->kind; | |
1075 | ||
1076 | switch (kind) | |
1077 | { | |
1078 | case term: | |
1079 | expr = constraintTerm_doSRefFixConstraintParam (expr, arglist); | |
1080 | break; | |
1081 | case unaryExpr: | |
1082 | expr1 = constraintExprData_unaryExprGetExpr (data); | |
1083 | expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist); | |
1084 | data = constraintExprData_unaryExprSetExpr (data, expr1); | |
1085 | break; | |
1086 | case binaryexpr: | |
1087 | expr1 = constraintExprData_binaryExprGetExpr1 (data); | |
1088 | expr2 = constraintExprData_binaryExprGetExpr2 (data); | |
1089 | ||
1090 | expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist); | |
1091 | data = constraintExprData_binaryExprSetExpr1 (data, expr1); | |
1092 | expr2 = constraintExpr_doSRefFixConstraintParam (expr2, arglist); | |
1093 | data = constraintExprData_binaryExprSetExpr2 (data, expr2); | |
1094 | ||
1095 | break; | |
1096 | default: | |
1097 | llassert(FALSE); | |
1098 | data = NULL; | |
1099 | } | |
1100 | return expr; | |
1101 | } | |
1102 | ||
1103 | constraintExpr constraintExpr_doFixResult (/*@returned@*/ constraintExpr expr, exprNode fcnCall) | |
1104 | { | |
1105 | constraintExprKind kind; | |
1106 | constraintExpr expr1, expr2; | |
1107 | constraintExprData data; | |
1108 | llassert (expr != NULL); | |
1109 | ||
1110 | data = expr->data; | |
1111 | ||
1112 | kind = expr->kind; | |
1113 | ||
1114 | switch (kind) | |
1115 | { | |
1116 | case term: | |
1117 | expr = constraintTerm_doFixResult (expr, fcnCall); | |
1118 | break; | |
1119 | case unaryExpr: | |
1120 | expr1 = constraintExprData_unaryExprGetExpr (data); | |
1121 | expr1 = constraintExpr_doFixResult (expr1, fcnCall); | |
1122 | data = constraintExprData_unaryExprSetExpr (data, expr1); | |
1123 | break; | |
1124 | case binaryexpr: | |
1125 | expr1 = constraintExprData_binaryExprGetExpr1 (data); | |
1126 | expr2 = constraintExprData_binaryExprGetExpr2 (data); | |
1127 | ||
1128 | expr1 = constraintExpr_doFixResult (expr1, fcnCall); | |
1129 | data = constraintExprData_binaryExprSetExpr1 (data, expr1); | |
1130 | expr2 = constraintExpr_doFixResult (expr2, fcnCall); | |
1131 | data = constraintExprData_binaryExprSetExpr2 (data, expr2); | |
1132 | ||
1133 | break; | |
1134 | default: | |
1135 | llassert(FALSE); | |
1136 | data = NULL; | |
1137 | } | |
1138 | return expr; | |
1139 | } | |
1140 | ||
dc92450f | 1141 | cstring constraintExpr_print (constraintExpr expr) /*@*/ |
3aaedf88 | 1142 | { |
1143 | return constraintExpr_unparse(expr); | |
1144 | } | |
1145 | ||
dc92450f | 1146 | bool constraintExpr_hasMaxSet (constraintExpr expr) /*@*/ |
3aaedf88 | 1147 | { |
1148 | cstring t; | |
1149 | ||
1150 | t = constraintExpr_unparse(expr); | |
1151 | ||
1152 | return (strstr (t, "MAXSET") ); | |
1153 | } | |
1154 | ||
1155 | ||
1156 | ||
1157 | /*returns 1 0 -1 like strcmp | |
1158 | 1 => expr1 > expr2 | |
1159 | 0 => expr1 == expr2 | |
1160 | -1 => expr1 < expr2 | |
1161 | */ | |
1162 | int constraintExpr_compare (constraintExpr expr1, constraintExpr expr2) | |
1163 | { | |
1164 | int value1, value2; | |
1165 | ||
1166 | if (constraintExpr_similar (expr1, expr2) ) | |
1167 | { | |
1168 | return 0; | |
1169 | } | |
1170 | value1 = constraintExpr_getValue(expr1); | |
1171 | value2 = constraintExpr_getValue(expr2); | |
1172 | ||
1173 | if (value1 > value2) | |
1174 | return 1; | |
1175 | ||
1176 | if (value1 == value2) | |
1177 | return 0; | |
1178 | ||
1179 | else | |
1180 | return -1; | |
1181 | } | |
1182 | ||
1183 | int constraintExpr_getValue (constraintExpr expr) | |
1184 | { | |
1185 | llassert (expr->kind == term); | |
1186 | return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data) ) ); | |
1187 | } | |
1188 | ||
1189 | bool constraintExpr_canGetValue (constraintExpr expr) | |
1190 | { | |
1191 | switch (expr->kind) | |
1192 | { | |
1193 | case term: | |
1194 | return constraintTerm_canGetValue (constraintExprData_termGetTerm (expr->data) ); | |
1195 | default: | |
1196 | return FALSE; | |
1197 | ||
1198 | } | |
1199 | llassert(FALSE); | |
1200 | } | |
1201 | ||
1202 | bool constraintExpr_canCompare (constraintExpr expr1, constraintExpr expr2) | |
1203 | { | |
1204 | ||
1205 | llassert(expr1 && expr2); | |
1206 | return ( constraintExpr_canGetValue(expr1) && | |
1207 | constraintExpr_canGetValue(expr2) | |
1208 | ); | |
1209 | } | |
1210 | ||
1211 | ||
1212 | fileloc constraintExpr_getFileloc (constraintExpr expr) | |
1213 | { | |
1214 | constraintExpr e; | |
1215 | constraintTerm t; | |
1216 | constraintExprKind kind; | |
1217 | ||
1218 | kind = expr->kind; | |
1219 | ||
1220 | switch (kind) | |
1221 | { | |
1222 | case term: | |
1223 | t = constraintExprData_termGetTerm (expr->data); | |
1224 | return (constraintTerm_getFileloc (t) ); | |
1225 | break; | |
1226 | case unaryExpr: | |
1227 | e = constraintExprData_unaryExprGetExpr (expr->data); | |
1228 | return (constraintExpr_getFileloc (e) ); | |
1229 | break; | |
1230 | case binaryexpr: | |
1231 | e = constraintExprData_binaryExprGetExpr1 (expr->data); | |
1232 | return (constraintExpr_getFileloc (e) ); | |
1233 | } | |
1234 | llassert (FALSE); | |
1235 | // llfatalbug("Code should be reached"); | |
1236 | return (fileloc_undefined); | |
1237 | } | |
1238 | ||
1239 | ||
1240 | ||
1241 | /* bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term) */ | |
1242 | /* { */ | |
1243 | /* if (constraintTerm_hasTerm (expr->term, term) ) */ | |
1244 | /* return TRUE; */ | |
1245 | ||
1246 | /* if ( (expr->expr) != NULL) */ | |
1247 | /* { */ | |
1248 | /* return ( constraintExpr_includesTerm (expr->expr, term) ); */ | |
1249 | /* } */ | |
1250 | /* return FALSE; */ | |
1251 | ||
1252 | /* } */ | |
1253 | ||
1254 | ||
1255 | ||
1256 |