2 ** Splint - annotation-assisted static program checker
3 ** Copyright (C) 1994-2002 University of Virginia,
4 ** Massachusetts Institute of Technology
6 ** This program is free software; you can redistribute it and/or modify it
7 ** under the terms of the GNU General Public License as published by the
8 ** Free Software Foundation; either version 2 of the License, or (at your
9 ** option) any later version.
11 ** This program is distributed in the hope that it will be useful, but
12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 ** General Public License for more details.
16 ** The GNU General Public License is available from http://www.gnu.org/ or
17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 ** MA 02111-1307, USA.
20 ** For information on splint: info@splint.org
21 ** To report a bug: splint-bug@splint.org
22 ** For more information: http://www.splint.org
29 /* #define DEBUGPRINT 1 */
31 # include "splintMacros.nf"
33 # include "cgrammar.h"
34 # include "cgrammar_tokens.h"
36 # include "exprChecks.h"
37 # include "exprNodeSList.h"
41 /*@access exprNode@*/ /* !!! NO! Don't do this recklessly! */
42 /*@-nullderef@*/ /* !!! DRL needs to fix this code! */
43 /*@-nullstate@*/ /* !!! DRL needs to fix this code! */
44 /*@-temptrans@*/ /* !!! DRL needs to fix this code! */
47 static ctype constraintExpr_getOrigType (constraintExpr p_e);
48 static bool constraintExpr_hasTypeChange(constraintExpr p_e) /*@*/;
50 static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/constraintExpr p_expr, int p_literal);
53 /*@only@*/ static constraintExpr
54 doSRefFixInvarConstraintTerm (/*@only@*/ constraintExpr p_e,
55 sRef p_s, ctype p_ct);
57 /*@only@*/ static constraintExpr
58 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr p_e, /*@temp@*/ /*@observer@*/ exprNodeList p_arglist) /*@modifies p_e@*/;
60 static /*@only@*/ constraintExpr
61 doFixResultTerm (/*@only@*/ constraintExpr p_e, /*@exposed@*/ exprNode p_fcnCall)
64 static bool constraintExpr_canGetCType (constraintExpr p_e) /*@*/;
66 static ctype constraintExpr_getCType (constraintExpr p_e);
68 static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast(/*@only@*/ constraintExpr p_e, ctype p_ct);
70 /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
71 /* @allocates result->data @ @sets result->kind @ */ ;
73 void constraintExpr_free (/*@only@*/ constraintExpr expr)
75 if (constraintExpr_isDefined(expr) )
80 constraintExprData_freeUnaryExpr(expr->data);
83 constraintExprData_freeBinaryExpr(expr->data);
86 constraintExprData_freeTerm(expr->data);
97 llcontbug(message("attempted to free null pointer in constraintExpr_free"));
101 bool constraintExpr_isLit (constraintExpr expr)
103 llassert (expr != NULL);
105 if (expr->kind == term)
107 constraintTerm term = constraintExprData_termGetTerm (expr->data);
108 if (constraintTerm_isIntLiteral (term) )
117 static bool isZeroBinaryOp (constraintExpr expr)
121 llassert (expr != NULL); /* evans 2001-07-18 */
123 if (!constraintExpr_isBinaryExpr (expr) )
129 e2 = constraintExprData_binaryExprGetExpr2(expr->data);
131 llassert (e2 != NULL); /* evans 2001-07-18 */
133 if (constraintExpr_isBinaryExpr (e2) )
136 constraintExprBinaryOpKind op;
138 op = constraintExprData_binaryExprGetOp (e2->data);
140 e1 = constraintExprData_binaryExprGetExpr1(e2->data);
142 if (constraintExpr_isLit(e1) )
144 if (constraintExpr_getValue(e1) == 0 )
153 /* change expr + (o - expr) to (expr -expr) */
155 /*@only@*/ static constraintExpr removeZero (/*@only@*/ /*@returned@*/ constraintExpr expr)
157 constraintExpr expr1, expr2;
161 constraintExprBinaryOpKind op;
163 constraintExprBinaryOpKind tempOp;
165 if (!isZeroBinaryOp(expr) )
168 llassert (expr != NULL); /* evans 2001-07-18 */
170 expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
171 expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
172 op = constraintExprData_binaryExprGetOp(expr->data);
174 llassert( constraintExpr_isBinaryExpr(expr2) );
176 temp = constraintExprData_binaryExprGetExpr2 (expr2->data);
177 temp = constraintExpr_copy (temp);
179 tempOp = constraintExprData_binaryExprGetOp (expr2->data);
181 if (op == BINARYOP_PLUS)
183 else if (op == BINARYOP_MINUS)
185 if (tempOp == BINARYOP_PLUS)
187 else if (tempOp == BINARYOP_MINUS)
195 expr->data = constraintExprData_binaryExprSetExpr2(expr->data, temp);
196 expr->data = constraintExprData_binaryExprSetOp(expr->data, op);
202 /*@only@*/ constraintExpr constraintExpr_propagateConstants (/*@only@*/ constraintExpr expr,
203 /*@out@*/ bool * propagate,
204 /*@out@*/ int *literal)
206 constraintExpr expr1;
207 constraintExpr expr2;
208 bool propagate1, propagate2;
209 int literal1, literal2;
210 constraintExprBinaryOpKind op;
222 llassert (expr != NULL);
224 /* we simplify unaryExpr elsewhere */
225 if (expr->kind != binaryexpr)
228 op = constraintExprData_binaryExprGetOp (expr->data);
230 DPRINTF((message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
232 expr = removeZero(expr);
234 expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
235 expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
237 expr1 = constraintExpr_copy(expr1);
238 expr2 = constraintExpr_copy(expr2);
240 expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
241 expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
243 expr1 = removeZero(expr1);
244 expr2 = removeZero(expr2);
247 *propagate = propagate1 || propagate2;
249 if (op == BINARYOP_PLUS)
250 *literal = literal1 + literal2;
251 else if (op == BINARYOP_MINUS)
252 *literal = literal1 - literal2;
256 if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
259 t1 = constraintExpr_getValue (expr1);
260 t2 = constraintExpr_getValue (expr2);
261 llassert(*propagate == FALSE);
264 constraintExpr_free (expr);
265 constraintExpr_free (expr1);
266 constraintExpr_free (expr2);
268 if (op == BINARYOP_PLUS )
269 return (constraintExpr_makeIntLiteral ((t1+t2) ));
270 else if (op == BINARYOP_MINUS)
271 return (constraintExpr_makeIntLiteral ((t1-t2) ));
277 if (constraintExpr_isLit (expr1) )
281 *literal += constraintExpr_getValue (expr1);
283 if (op == BINARYOP_PLUS)
285 constraintExpr_free(expr1);
286 constraintExpr_free(expr);
289 else if (op == BINARYOP_MINUS)
294 /* this is an ugly kludge to deal with not
295 having a unary minus operation...*/
297 temp = constraintExpr_makeIntLiteral (0);
298 temp = constraintExpr_makeSubtractExpr (temp, expr2);
300 constraintExpr_free(expr1);
301 constraintExpr_free(expr);
307 BADBRANCH; /* evans 2001-07-18 */
311 if (constraintExpr_isLit (expr2) )
315 if ( op == BINARYOP_PLUS )
316 *literal += constraintExpr_getValue (expr2);
317 else if (op == BINARYOP_MINUS)
318 *literal -= constraintExpr_getValue (expr2);
323 constraintExpr_free(expr2);
324 constraintExpr_free(expr);
328 DPRINTF((message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
330 expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
331 expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
333 expr = removeZero(expr);
337 /*@only@*/ static constraintExpr constraintExpr_combineConstants (/*@only@*/ constraintExpr expr ) /*@modifies expr@*/
342 DPRINTF ((message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
343 expr = constraintExpr_propagateConstants (expr, &propagate, &literal);
352 ret = constraintExpr_makeBinaryOpConstraintExprIntLiteral (expr, literal);
356 DPRINTF ((message ("After combine %s", constraintExpr_unparse(expr) ) ) );
361 static /*@notnull@*/ constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
364 ret = dmalloc (sizeof (*ret) );
368 ret->origType = ctype_undefined;
372 /*@only@*/ static constraintExprData copyExprData (/*@observer@*/ constraintExprData data, constraintExprKind kind)
374 constraintExprData ret;
375 llassert(constraintExprData_isDefined(data));
380 ret = constraintExprData_copyBinaryExpr(data);
383 ret = constraintExprData_copyUnaryExpr(data);
386 ret = constraintExprData_copyTerm(data);
394 constraintExpr constraintExpr_copy (constraintExpr expr)
397 ret = constraintExpr_alloc ();
398 ret->kind = expr->kind;
400 ret->data = copyExprData (expr->data, expr->kind);
402 ret->origType = expr->origType;
407 /*@only@*/ static constraintExpr oldconstraintExpr_makeTermExprNode ( /*@dependent@*/ exprNode e)
411 ret = constraintExpr_alloc();
413 ret->data = dmalloc (sizeof *(ret->data) );
414 t = constraintTerm_makeExprNode (e);
415 ret->data = constraintExprData_termSetTerm (ret->data, t);
417 ret->origType = ctype_undefined;
422 constraintExpr constraintExpr_makeExprNode (exprNode e)
425 constraintExpr ret, ce1, ce2;
430 llassert (e != NULL);
437 t = exprData_getSingle (data);
438 while (exprNode_isInParens (t) )
440 t = exprData_getUopNode (t->edata);
442 s = exprNode_getSref (t);
443 if (sRef_isFixedArray(s) )
447 size = (int) sRef_getArraySize(s);
448 ret = constraintExpr_makeIntLiteral (size);
450 else if (exprNode_isStringLiteral (t))
452 cstring str = multiVal_forceString (exprNode_getValue(t));
453 ret = constraintExpr_makeIntLiteral (size_toLong (cstring_length (str) + 1));
457 DPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
458 ret = oldconstraintExpr_makeTermExprNode (e);
463 DPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
464 t1 = exprData_getOpA (data);
465 t2 = exprData_getOpB (data);
466 tok = exprData_getOpTok (data);
468 if (lltok_isPlus_Op (tok) || lltok_isMinus_Op (tok) )
470 ce1 = constraintExpr_makeExprNode (t1);
471 ce2 = constraintExpr_makeExprNode (t2);
472 ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2);
477 /* uncomment this block to activate the cheesy heuristic
478 for handling sizeof expressions
483 We handle expressions containing sizeof with the rule
484 (sizeof type ) * Expr = Expr
486 This is the total wronge way to do this but...
487 it may be better than nothing
492 else if (lltok_isMult(tok) )
494 if ((t1->kind == XPR_SIZEOF) || (t1->kind == XPR_SIZEOFT) )
496 ret = constraintExpr_makeExprNode(t2);
498 else if ((t2->kind == XPR_SIZEOF) || (t2->kind == XPR_SIZEOFT) )
500 ret = constraintExpr_makeExprNode(t1);
504 ret = oldconstraintExpr_makeTermExprNode (e);
509 ret = oldconstraintExpr_makeTermExprNode (e);
513 t = exprData_getUopNode (data);
514 ret = constraintExpr_makeExprNode (t);
518 t = exprData_getUopNode (data);
519 tok = exprData_getUopTok (data);
520 if (lltok_isIncOp (tok))
523 temp = constraintExpr_makeExprNode(t);
524 ret = constraintExpr_makeIncConstraintExpr(temp);
526 else if (lltok_isDecOp (tok))
529 temp = constraintExpr_makeExprNode(t);
530 ret = constraintExpr_makeDecConstraintExpr(temp);
533 ret = oldconstraintExpr_makeTermExprNode (e);
537 t = exprData_getUopNode (data);
538 ret = constraintExpr_makeExprNode (t);
541 t = exprData_getCastNode (data);
542 ret = constraintExpr_makeExprNode (t);
545 t = exprData_getPairA(data);
546 ret = constraintExpr_makeExprNode(t);
547 /*@i3434*/ /* drl: I'm not sure if this is right. I'm adding a break to quiet Splint */
550 ret = oldconstraintExpr_makeTermExprNode (e);
556 /*@only@*/ constraintExpr constraintExpr_makeTermExprNode (/*@exposed@*/ exprNode e)
558 return oldconstraintExpr_makeTermExprNode(e);
561 static constraintExpr constraintExpr_makeTerm (/*@only@*/ constraintTerm t)
565 ret = constraintExpr_alloc();
567 ret->data = dmalloc (sizeof *(ret->data) );
568 ret->data->term = NULL;
569 ret->data = constraintExprData_termSetTerm (ret->data, t);
571 ret->origType = ctype_undefined;
576 constraintExpr constraintExpr_makeTermsRef (/*@temp@*/ sRef s)
580 ret = constraintExpr_alloc();
582 ret->data = dmalloc (sizeof *(ret->data) );
583 t = constraintTerm_makesRef (s);
584 ret->data = constraintExprData_termSetTerm (ret->data, t);
587 ret->origType = ctype_undefined;
592 /*@special@*/ static constraintExpr makeUnaryOpGeneric (void) /*@allocates result->data@*/ /*@defines result->kind@*/
595 ret = constraintExpr_alloc();
596 ret->kind = unaryExpr;
597 ret->data = dmalloc ( sizeof *(ret->data) );
598 ret->data->unaryOp.expr = constraintExpr_undefined;
602 /*@only@*/ static constraintExpr constraintExpr_makeUnaryOpConstraintExpr (/*@only@*/ constraintExpr cexpr)
605 ret = makeUnaryOpGeneric();
609 ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
610 ret->data = constraintExprData_unaryExprSetOp (ret->data, UNARYOP_UNDEFINED);
619 /*@only@*/ static constraintExpr constraintExpr_makeUnaryOp (/*@only@*/ constraintExpr cexpr, constraintExprUnaryOpKind Op )
622 ret = makeUnaryOpGeneric();
624 ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
625 ret->data = constraintExprData_unaryExprSetOp (ret->data, Op);
628 ret->origType = ctype_undefined;
634 static constraintExpr constraintExpr_makeMaxSetConstraintExpr (/*@only@*/ constraintExpr c)
637 ret = constraintExpr_makeUnaryOp (c, MAXSET);
642 static constraintExpr constraintExpr_makeUnaryOpExprNode (/*@exposed@*/ exprNode expr)
646 sub = constraintExpr_makeExprNode (expr);
647 ret = constraintExpr_makeUnaryOpConstraintExpr(sub);
655 static constraintExpr constraintExpr_makeSRefUnaryOp (/*@temp@*/ /*@observer@*/ sRef s, constraintExprUnaryOpKind op)
660 t = constraintExpr_makeTermsRef (s);
661 ret = constraintExpr_makeUnaryOpConstraintExpr (t);
662 ret->data = constraintExprData_unaryExprSetOp (ret->data, op);
668 constraintExpr constraintExpr_makeSRefMaxRead( sRef s)
670 return (constraintExpr_makeSRefUnaryOp (s, MAXREAD) );
674 constraintExpr constraintExpr_makeSRefMaxset ( sRef s)
676 return (constraintExpr_makeSRefUnaryOp (s, MAXSET) );
680 constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr)
683 ret = constraintExpr_makeUnaryOpConstraintExpr ( cexpr);
685 switch (lltok_getTok (op))
688 ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
691 ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
694 llfatalbug (message ("Unhandled operation in constraint: %s", lltok_unparse (op)));
700 constraintExpr constraintExpr_makeMaxSetExpr (/*@exposed@*/ exprNode expr)
703 ret = constraintExpr_makeExprNode (expr);
705 ret = constraintExpr_makeMaxSetConstraintExpr (ret);
707 llassert (ret != NULL);
712 constraintExpr constraintExpr_makeMaxReadExpr (exprNode expr)
715 ret = constraintExpr_makeUnaryOpExprNode(expr);
716 ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
722 /*@unused@*/ static constraintExpr constraintExpr_makeMinSetExpr (/*@exposed@*/ exprNode expr)
725 ret = constraintExpr_makeUnaryOpExprNode(expr);
726 ret->data = constraintExprData_unaryExprSetOp (ret->data, MINSET);
731 /*@unused@*/ static constraintExpr constraintExpr_makeMinReadExpr (/*@exposed@*/ exprNode expr)
734 ret = constraintExpr_makeUnaryOpExprNode(expr);
735 ret->data = constraintExprData_unaryExprSetOp (ret->data, MINREAD);
741 constraintExpr constraintExpr_makeValueExpr (/*@exposed@*/ exprNode expr)
744 ret = constraintExpr_makeExprNode (expr);
749 constraintExpr constraintExpr_makeIntLiteral (long i)
753 ret = constraintExpr_alloc();
755 ret->data = dmalloc (sizeof *(ret->data) );
756 t = constraintTerm_makeIntLiteral (i);
757 ret->data = constraintExprData_termSetTerm (ret->data, t);
760 ret->origType = ctype_undefined;
766 constraintExpr constraintExpr_makeValueInt (int i)
768 return constraintExpr_makeIntLiteral (i);
773 /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
774 /*@allocates result->data @*/ /*@sets result->kind @*/
777 ret = constraintExpr_alloc();
778 ret->kind = binaryexpr;
779 ret->data = dmalloc ( sizeof *(ret->data) );
781 ret->data->binaryOp.expr1 = constraintExpr_undefined;
782 ret->data->binaryOp.expr2 = constraintExpr_undefined;
788 static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExpr (/*@only@*/constraintExpr expr1, /*@only@*/ constraintExpr expr2)
793 ret = constraintExpr_makeBinaryOp();
794 ret->data = constraintExprData_binaryExprSetExpr1 (ret->data, expr1);
795 ret->data = constraintExprData_binaryExprSetExpr2 (ret->data, expr2);
796 ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
799 ret->origType = ctype_undefined;
805 constraintExpr constraintExpr_parseMakeBinaryOp (/*@only@*/ constraintExpr expr1, lltok op,/*@only@*/ constraintExpr expr2)
808 ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
810 if (lltok_getTok (op) == TPLUS)
812 ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
814 else if (lltok_getTok (op) == TMINUS)
816 ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
828 /*@unused@*/ static constraintExpr constraintExpr_makeBinaryOpExprNode (/*@exposed@*/ exprNode expr1, /*@exposed@*/ exprNode expr2)
831 constraintExpr sub1, sub2;
832 sub1 = constraintExpr_makeTermExprNode (expr1);
833 sub2 = constraintExpr_makeTermExprNode (expr2);
834 ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2);
840 constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/ constraintExpr expr, int literal)
843 constraintExpr constExpr;
845 constExpr = constraintExpr_makeIntLiteral (literal);
846 ret = constraintExpr_makeBinaryOpConstraintExpr (expr, constExpr);
847 ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
852 constraintExpr constraintExpr_makeDecConstraintExpr (/*@only@*/constraintExpr expr)
857 inc = constraintExpr_makeIntLiteral (1);
858 ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
859 ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
864 /*@only@*/ constraintExpr constraintExpr_makeSubtractExpr (/*@only@*/ constraintExpr expr, /*@only@*/ constraintExpr addent)
868 DPRINTF ((message ("Making subtract expression") ) );
870 ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
871 ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_MINUS);
876 constraintExpr constraintExpr_makeAddExpr (/*@only@*/
877 constraintExpr expr, /*@only@*/
878 constraintExpr addent)
882 DPRINTF ((message ("Doing addTerm simplification") ) );
884 ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
885 ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_PLUS);
891 constraintExpr constraintExpr_makeIncConstraintExpr (/*@only@*/ constraintExpr expr)
896 inc = constraintExpr_makeIntLiteral (1);
897 ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
898 ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
903 static cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
908 return message("maxSet");
910 return message("minSet");
912 return message("maxRead");
914 return message("minRead");
917 return message ("<(Unary OP OTHER>");
923 static cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
935 return message ("<binary OP Unknown>");
939 bool constraintExpr_similar (constraintExpr expr1, constraintExpr expr2)
941 constraintExprKind kind;
943 llassert (expr1 != NULL);
944 llassert (expr2 != NULL);
945 if (expr1->kind != expr2->kind)
953 return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
954 constraintExprData_termGetTerm(expr2->data) );
955 /*@notreached@*/ break;
958 if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
961 return (constraintExpr_similar (
962 constraintExprData_unaryExprGetExpr (expr1->data),
963 constraintExprData_unaryExprGetExpr (expr2->data)
967 if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
970 if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr1 (expr1->data),
971 constraintExprData_binaryExprGetExpr1 (expr2->data)) )
974 if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr2 (expr1->data),
975 constraintExprData_binaryExprGetExpr2 (expr2->data)) )
990 bool constraintExpr_same (constraintExpr expr1, constraintExpr expr2)
992 constraintExprKind kind;
994 llassert (expr1 != NULL);
995 llassert (expr2 != NULL);
996 if (expr1->kind != expr2->kind)
1004 return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
1005 constraintExprData_termGetTerm(expr2->data) );
1006 /*@notreached@*/ break;
1009 if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
1012 return (constraintExpr_same (
1013 constraintExprData_unaryExprGetExpr (expr1->data),
1014 constraintExprData_unaryExprGetExpr (expr2->data)
1019 if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
1022 if (! constraintExpr_same (constraintExprData_binaryExprGetExpr1 (expr1->data),
1023 constraintExprData_binaryExprGetExpr1 (expr2->data)) )
1026 if (! constraintExpr_same (constraintExprData_binaryExprGetExpr2 (expr1->data),
1027 constraintExprData_binaryExprGetExpr2 (expr2->data)) )
1031 /*@notreached@*/ break;
1042 bool constraintExpr_search (/*@observer@*/ constraintExpr c, /*@observer@*/ constraintExpr old)
1045 constraintExprKind kind;
1046 constraintExpr temp;
1048 if ( constraintExpr_similar (c, old) )
1050 DPRINTF((message ("Found %q",
1051 constraintExpr_unparse(old)
1063 temp = constraintExprData_unaryExprGetExpr (c->data);
1064 ret = ret || constraintExpr_search (temp, old);
1068 temp = constraintExprData_binaryExprGetExpr1 (c->data);
1069 ret = ret || constraintExpr_search(temp, old);
1071 temp = constraintExprData_binaryExprGetExpr2 (c->data);
1072 ret = ret || constraintExpr_search(temp, old);
1082 /*@only@*/ constraintExpr constraintExpr_searchandreplace (/*@only@*/ /*@unique@*/ constraintExpr c, /*@temp@*/ constraintExpr old, /*@temp@*/ constraintExpr newExpr )
1084 constraintExprKind kind;
1085 constraintExpr temp;
1088 if ( constraintExpr_similar (c, old) )
1091 ctype newType, cType;
1094 ret = constraintExpr_copy (newExpr);
1096 DPRINTF((message ("Replacing %s with %s",
1097 constraintExpr_unparse(old), constraintExpr_unparse(newExpr)
1100 if (constraintExpr_canGetCType(c) && constraintExpr_canGetCType(newExpr) )
1102 cType = constraintExpr_getCType(c);
1103 newType = constraintExpr_getCType(newExpr);
1105 if (ctype_match(cType,newType) )
1107 DPRINTF(( message("constraintExpr_searchandreplace: replacing "
1108 " %s with type %s with %s with type %s",
1109 constraintExpr_print(c), ctype_unparse(cType),
1110 constraintExpr_print(newExpr), ctype_unparse(newType)
1115 ret->origType = cType;
1119 if (constraintExpr_hasMaxSet(c) )
1121 if (constraintExpr_hasTypeChange(c))
1123 DPRINTF(( message("constraintExpr_searchandreplace: encountered "
1124 "MaxSet with changed type %s ",
1125 constraintExpr_print(c) )
1128 /*fix this with a conversation */
1129 ret = constraintExpr_adjustMaxSetForCast(ret, constraintExpr_getOrigType(c));
1132 constraintExpr_free(c);
1144 temp = constraintExprData_unaryExprGetExpr (c->data);
1145 temp = constraintExpr_copy(temp);
1146 temp = constraintExpr_searchandreplace (temp, old, newExpr);
1147 c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1151 temp = constraintExprData_binaryExprGetExpr1 (c->data);
1152 temp = constraintExpr_copy(temp);
1153 temp = constraintExpr_searchandreplace (temp, old, newExpr);
1154 c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1156 temp = constraintExprData_binaryExprGetExpr2 (c->data);
1157 temp = constraintExpr_copy(temp);
1158 temp = constraintExpr_searchandreplace (temp, old, newExpr);
1159 c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1167 static constraintExpr constraintExpr_simplifyChildren (/*@returned@*/ constraintExpr c)
1169 constraintExprKind kind;
1170 constraintExpr temp;
1179 temp = constraintExprData_unaryExprGetExpr (c->data);
1180 temp = constraintExpr_copy(temp);
1181 temp = constraintExpr_simplify (temp);
1182 c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1185 DPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) );
1186 temp = constraintExprData_binaryExprGetExpr1 (c->data);
1187 temp = constraintExpr_copy(temp);
1188 temp = constraintExpr_simplify (temp);
1190 c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1192 temp = constraintExprData_binaryExprGetExpr2 (c->data);
1193 temp = constraintExpr_copy(temp);
1194 temp = constraintExpr_simplify (temp);
1196 c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1206 constraintExpr constraintExpr_setFileloc (/*@returned@*/ constraintExpr c, fileloc loc) /*@modifies c @*/
1209 constraintExpr temp;
1211 llassert(c != NULL);
1216 t = constraintExprData_termGetTerm (c->data);
1217 t = constraintTerm_copy(t);
1218 t = constraintTerm_setFileloc (t, loc);
1219 c->data = constraintExprData_termSetTerm (c->data, t);
1223 temp = constraintExprData_binaryExprGetExpr1 (c->data);
1224 temp = constraintExpr_copy(temp);
1225 temp = constraintExpr_setFileloc (temp, loc);
1226 c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1228 temp = constraintExprData_binaryExprGetExpr2 (c->data);
1229 temp = constraintExpr_copy(temp);
1230 temp = constraintExpr_setFileloc (temp, loc);
1231 c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1234 temp = constraintExprData_unaryExprGetExpr (c->data);
1235 temp = constraintExpr_copy(temp);
1236 temp = constraintExpr_setFileloc (temp, loc);
1237 c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1243 static /*@only@*/ constraintExpr constraintExpr_simplifybinaryExpr (/*@only@*/constraintExpr c)
1245 constraintExpr e1, e2;
1246 constraintExprBinaryOpKind op;
1248 e1 = constraintExprData_binaryExprGetExpr1 (c->data);
1249 e2 = constraintExprData_binaryExprGetExpr2 (c->data);
1251 if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) )
1255 i = constraintExpr_getValue(e1) + constraintExpr_getValue (e2);
1256 constraintExpr_free(c);
1257 c = constraintExpr_makeIntLiteral (i);
1261 op = constraintExprData_binaryExprGetOp (c->data);
1262 if (op == BINARYOP_MINUS)
1263 if (constraintExpr_similar(e1, e2) )
1265 constraintExpr_free(c);
1266 c = constraintExpr_makeIntLiteral (0);
1274 this thing takes the lexpr and expr of a constraint and modifies lexpr
1275 and returns a (possiblly new) value for expr
1277 /* if lexpr is a binary express say x + y, we set lexpr to x and return a value for expr such as expr_old - y */
1279 /* the approach is a little Kludgy but seems to work. I should probably use something cleaner at some point ... */
1282 /*@only@*/ constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, /*@only@*/ constraintExpr expr)
1284 constraintExpr expr1, expr2;
1285 constraintExprBinaryOpKind op;
1287 if (lexpr->kind != binaryexpr)
1290 expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data);
1291 expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data);
1293 op = constraintExprData_binaryExprGetOp (lexpr->data);
1295 expr1 = constraintExpr_copy(expr1);
1296 expr2 = constraintExpr_copy(expr2);
1298 /* drl possible problem : warning make sure this works */
1300 lexpr->kind = expr1->kind;
1301 sfree (lexpr->data);
1303 lexpr->data = copyExprData (expr1->data, expr1->kind);
1304 constraintExpr_free(expr1);
1306 if (op == BINARYOP_PLUS)
1307 expr = constraintExpr_makeSubtractExpr (expr, expr2);
1308 else if (op == BINARYOP_MINUS)
1309 expr = constraintExpr_makeAddExpr (expr, expr2);
1317 #warning this needs to be checked
1318 expr = constraintExpr_solveBinaryExpr (expr1, expr);
1320 expr = constraintExpr_solveBinaryExpr (expr2, expr);
1325 static /*@only@*/ constraintExpr constraintExpr_simplifyunaryExpr (/*@only@*/ constraintExpr c)
1329 llassert (c->kind == unaryExpr);
1331 DPRINTF ((message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
1333 if ((constraintExprData_unaryExprGetOp (c->data) != MAXSET) &&
1334 (constraintExprData_unaryExprGetOp (c->data) != MAXREAD) )
1339 exp = constraintExprData_unaryExprGetExpr (c->data);
1340 exp = constraintExpr_copy(exp);
1342 if (exp->kind == term)
1344 constraintTerm cterm;
1346 cterm = constraintExprData_termGetTerm (exp->data);
1348 if (constraintTerm_isStringLiteral(cterm) )
1351 val = constraintTerm_getStringLiteral (cterm);
1352 if (constraintExprData_unaryExprGetOp (c->data) == MAXSET)
1354 constraintExpr temp;
1356 temp = constraintExpr_makeIntLiteral ((int)strlen (cstring_toCharsSafe(val) ) );
1358 constraintExpr_free(c);
1359 constraintExpr_free(exp);
1364 if (constraintExprData_unaryExprGetOp (c->data) == MAXREAD)
1366 constraintExpr temp;
1368 temp = constraintExpr_makeIntLiteral ((int)strlen (cstring_toCharsSafe(val) ) );
1370 constraintExpr_free(c);
1371 constraintExpr_free(exp);
1378 /* slight Kludge to hanlde var [] = { , , };
1379 ** type syntax I don't think this is sounds but it should be good
1380 ** enough. The C stanrad is very confusing about initialization
1384 if (constraintTerm_isInitBlock(cterm) )
1386 constraintExpr temp;
1389 len = constraintTerm_getInitBlockLength(cterm);
1391 temp = constraintExpr_makeIntLiteral (len );
1393 constraintExpr_free(c);
1394 DPRINTF(( message("Changed too %q", constraintExpr_print(temp)
1396 constraintExpr_free(exp);
1400 constraintExpr_free(exp);
1404 if (exp->kind != binaryexpr)
1406 constraintExpr_free(exp);
1410 if (constraintExprData_binaryExprGetOp (exp->data) == BINARYOP_PLUS )
1413 /* if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) ) */
1416 constraintExpr temp, temp2;
1418 DPRINTF ((message ("Doing fancy simplification") ) );
1420 temp = constraintExprData_binaryExprGetExpr2 (exp->data);
1422 temp2 = constraintExprData_binaryExprGetExpr1 (exp->data);
1424 temp2 = constraintExpr_copy(temp2);
1425 c->data = constraintExprData_unaryExprSetExpr (c->data, temp2);
1428 temp = constraintExpr_copy (temp);
1430 c = constraintExpr_makeSubtractExpr (c, temp);
1432 DPRINTF ((message ("Done fancy simplification:%s", constraintExpr_unparse (c) ) ) );
1436 DPRINTF ((message ("constraintExpr_simplifyUnaryExpr: Done simplification:%s", constraintExpr_unparse (c) ) ) );
1438 constraintExpr_free(exp);
1443 /*@only@*/ constraintExpr constraintExpr_simplify (/*@only@*/ constraintExpr c)
1445 constraintExprKind kind;
1449 DPRINTF ((message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) );
1454 /* drl: I think this is an Splint bug */
1456 ret = constraintExpr_copy(c);
1458 constraintExpr_free(c);
1460 ret = constraintExpr_simplifyChildren (ret);
1462 ret = constraintExpr_combineConstants (ret);
1464 ret = constraintExpr_simplifyChildren (ret);
1472 t = constraintExprData_termGetTerm (ret->data);
1473 t = constraintTerm_copy(t);
1474 t = constraintTerm_simplify (t);
1475 ret->data = constraintExprData_termSetTerm (ret->data, t);
1478 ret = constraintExpr_simplifyunaryExpr (ret);
1481 ret = constraintExpr_simplifybinaryExpr (ret);
1487 DPRINTF ((message ("constraintExpr_simplify returning :%s", constraintExpr_unparse (ret) ) ) );
1493 cstring constraintExpr_unparse (/*@temp@*/ /*@observer@*/ constraintExpr ex) /*@*/
1496 constraintExprKind kind;
1498 llassert (ex != NULL);
1506 if (context_getFlag (FLG_PARENCONSTRAINT) )
1508 st = message ("(%q) ", constraintTerm_print (constraintExprData_termGetTerm (ex->data)));
1512 st = message ("%q", constraintTerm_print (constraintExprData_termGetTerm (ex->data)));
1516 st = message ("%q(%q)",
1517 constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data) ),
1518 constraintExpr_unparse (constraintExprData_unaryExprGetExpr (ex->data) )
1522 if (context_getFlag (FLG_PARENCONSTRAINT) )
1524 st = message ("(%q) %q (%q)",
1525 constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ),
1526 constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)
1528 constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) )
1533 st = message ("%q %q %q",
1534 constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ),
1535 constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)
1537 constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) )
1544 st = message ("error");
1548 DPRINTF((message ("constraintExpr_unparse: '%s'",st) ) );
1552 constraintExpr constraintExpr_doSRefFixBaseParam (/*@returned@*/ constraintExpr expr, exprNodeList arglist)
1554 constraintTerm Term;
1555 constraintExprKind kind;
1556 constraintExpr expr1, expr2;
1557 constraintExprData data;
1558 llassert (expr != NULL);
1567 Term = constraintExprData_termGetTerm(data);
1568 Term = constraintTerm_copy(Term);
1570 Term = constraintTerm_doSRefFixBaseParam (Term, arglist);
1571 data = constraintExprData_termSetTerm(data, Term);
1574 expr1 = constraintExprData_unaryExprGetExpr (data);
1575 expr1 = constraintExpr_copy(expr1);
1577 expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
1578 data = constraintExprData_unaryExprSetExpr (data, expr1);
1581 expr1 = constraintExprData_binaryExprGetExpr1 (data);
1582 expr2 = constraintExprData_binaryExprGetExpr2 (data);
1584 expr1 = constraintExpr_copy(expr1);
1585 expr2 = constraintExpr_copy(expr2);
1587 expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
1588 data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1589 expr2 = constraintExpr_doSRefFixBaseParam (expr2, arglist);
1590 data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1601 / *@only@* / constraintExpr constraintExpr_doSRefFixInvarConstraint (/ *@only@* / constraintExpr expr, sRef s, ctype ct)
1603 constraintExprKind kind;
1604 constraintExpr expr1, expr2;
1605 constraintExprData data;
1606 llassert (expr != NULL);
1615 expr = doSRefFixInvarConstraintTerm (expr, s, ct);
1618 expr1 = constraintExprData_unaryExprGetExpr (data);
1619 expr1 = constraintExpr_copy(expr1);
1620 expr1 = constraintExpr_doSRefFixInvarConstraint (expr1, s, ct);
1621 data = constraintExprData_unaryExprSetExpr (data, expr1);
1624 expr1 = constraintExprData_binaryExprGetExpr1 (data);
1625 expr2 = constraintExprData_binaryExprGetExpr2 (data);
1627 expr1 = constraintExpr_copy(expr1);
1628 expr2 = constraintExpr_copy(expr2);
1630 expr1 = constraintExpr_doSRefFixInvarConstraint (expr1, s, ct);
1631 data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1632 expr2 = constraintExpr_doSRefFixInvarConstraint (expr2, s, ct);
1633 data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1644 /*@only@*/ constraintExpr constraintExpr_doSRefFixConstraintParam (/*@only@*/ constraintExpr expr, exprNodeList arglist) /*@modifies expr@*/
1646 constraintExprKind kind;
1647 constraintExpr expr1, expr2;
1648 constraintExprData data;
1649 llassert (expr != NULL);
1658 expr = doSRefFixConstraintParamTerm (expr, arglist);
1661 expr1 = constraintExprData_unaryExprGetExpr (data);
1662 expr1 = constraintExpr_copy(expr1);
1663 expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
1664 data = constraintExprData_unaryExprSetExpr (data, expr1);
1667 expr1 = constraintExprData_binaryExprGetExpr1 (data);
1668 expr2 = constraintExprData_binaryExprGetExpr2 (data);
1670 expr1 = constraintExpr_copy(expr1);
1671 expr2 = constraintExpr_copy(expr2);
1673 expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
1674 data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1675 expr2 = constraintExpr_doSRefFixConstraintParam (expr2, arglist);
1676 data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1686 /*@only@*/ constraintExpr constraintExpr_doFixResult (/*@only@*/ constraintExpr expr, /*@observer@*/ exprNode fcnCall)
1688 constraintExprKind kind;
1689 constraintExpr expr1, expr2;
1690 constraintExprData data;
1691 llassert (expr != NULL);
1700 expr = doFixResultTerm (expr, fcnCall);
1703 expr1 = constraintExprData_unaryExprGetExpr (data);
1704 expr1 = constraintExpr_copy(expr1);
1706 expr1 = constraintExpr_doFixResult (expr1, fcnCall);
1707 data = constraintExprData_unaryExprSetExpr (data, expr1);
1710 expr1 = constraintExprData_binaryExprGetExpr1 (data);
1711 expr2 = constraintExprData_binaryExprGetExpr2 (data);
1713 expr1 = constraintExpr_copy(expr1);
1714 expr2 = constraintExpr_copy(expr2);
1716 expr1 = constraintExpr_doFixResult (expr1, fcnCall);
1717 data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1718 expr2 = constraintExpr_doFixResult (expr2, fcnCall);
1719 data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1729 cstring constraintExpr_print (constraintExpr expr) /*@*/
1731 return constraintExpr_unparse (expr);
1734 bool constraintExpr_hasMaxSet (constraintExpr expr) /*@*/
1738 t = constraintExpr_unparse(expr);
1740 if (cstring_containsLit(t, "maxSet") != NULL )
1754 /*returns 1 0 -1 like strcmp
1760 int constraintExpr_compare (constraintExpr expr1, constraintExpr expr2)
1762 long value1, value2;
1764 if (constraintExpr_similar (expr1, expr2) )
1769 value1 = constraintExpr_getValue(expr1);
1770 value2 = constraintExpr_getValue(expr2);
1772 if (value1 > value2)
1775 if (value1 == value2)
1782 long constraintExpr_getValue (constraintExpr expr)
1784 llassert (expr->kind == term);
1785 return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data)));
1788 bool constraintExpr_canGetValue (constraintExpr expr)
1793 return constraintTerm_canGetValue (constraintExprData_termGetTerm (expr->data) );
1802 fileloc constraintExpr_getFileloc (constraintExpr expr)
1806 constraintExprKind kind;
1813 t = constraintExprData_termGetTerm (expr->data);
1814 return (constraintTerm_getFileloc (t) );
1818 e = constraintExprData_unaryExprGetExpr (expr->data);
1819 return (constraintExpr_getFileloc (e) );
1823 e = constraintExprData_binaryExprGetExpr1 (expr->data);
1824 return (constraintExpr_getFileloc (e) );
1829 return (fileloc_undefined);
1832 /*drl moved from constriantTerm.c 5/20/001*/
1833 static /*@only@*/ constraintExpr
1834 doFixResultTerm (/*@only@*/ constraintExpr e, /*@exposed@*/ exprNode fcnCall)
1838 /*maybe this should move to cosntraintExpr.c -drl7x 5/18/01*/
1841 constraintExprData data = e->data;
1842 constraintExprKind kind = e->kind;
1846 llassert(kind == term);
1848 t = constraintExprData_termGetTerm (data);
1849 llassert (constraintTerm_isDefined(t) );
1852 switch (constraintTerm_getKind(t) )
1860 s = constraintTerm_getSRef(t);
1861 if (sRef_isResult (s))
1863 ret = constraintExpr_makeExprNode(fcnCall);
1864 constraintExpr_free(e);
1880 / *@only@* / static constraintExpr
1881 doSRefFixInvarConstraintTerm (/ *@only@* / constraintExpr e,
1886 constraintExprData data = e->data;
1888 constraintExprKind kind = e->kind;
1892 llassert(kind == term);
1894 t = constraintExprData_termGetTerm (data);
1895 llassert (constraintTerm_isDefined(t) );
1899 DPRINTF (("Fixing: %s", constraintExpr_print (e)));
1901 switch (constraintTerm_getKind(t))
1904 DPRINTF((message ("%q @ %q ", constraintTerm_print(t),
1905 fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
1908 DPRINTF((message (" %q ", constraintTerm_print (t)) ));
1912 / * evans 2001-07-24: constants should use the original term * /
1913 if (!constraintTerm_canGetValue (t))
1916 DPRINTF ((message("Doing sRef_fixInvarConstraint for %q ",
1917 constraintTerm_print (t) ) ));
1919 snew = fixSref (ct, s, constraintTerm_getSRef(t));
1921 ret = constraintExpr_makeTermsRef(snew);
1923 constraintExpr_free (e);
1925 DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
1926 constraintExpr_print (ret) ) ));
1927 / *@-branchstate@* /
1928 } / *@=branchstate@* /
1940 /*drl moved from constriantTerm.c 5/20/001*/
1941 /*@only@*/ static constraintExpr
1942 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, /*@observer@*/ /*@temp@*/ exprNodeList arglist)
1946 constraintExprData data = e->data;
1948 constraintExprKind kind = e->kind;
1952 llassert(kind == term);
1954 t = constraintExprData_termGetTerm (data);
1955 llassert (constraintTerm_isDefined(t) );
1959 DPRINTF (("Fixing: %s", constraintExpr_print (e)));
1961 switch (constraintTerm_getKind(t))
1964 DPRINTF((message ("%q @ %q ", constraintTerm_print(t),
1965 fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
1968 DPRINTF((message (" %q ", constraintTerm_print (t)) ));
1972 /* evans 2001-07-24: constants should use the original term */
1973 if (!constraintTerm_canGetValue (t))
1975 DPRINTF ((message("Doing sRef_fixConstraintParam for %q ",
1976 constraintTerm_print (t) ) ));
1977 ret = sRef_fixConstraintParam (constraintTerm_getSRef(t), arglist);
1979 constraintExpr_free (e);
1981 DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
1982 constraintExpr_print (ret) ) ));
1984 } /*@=branchstate@*/
1996 /* bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term) */
1998 /* if (constraintTerm_hasTerm (expr->term, term) ) */
2001 /* if ((expr->expr) != NULL) */
2003 /* return ( constraintExpr_includesTerm (expr->expr, term) ); */
2009 /*drl added 6/11/01 */
2010 bool constraintExpr_isBinaryExpr (/*@observer@*/ constraintExpr c)
2012 if (c->kind == binaryexpr)
2019 /*drl added 8/08/001 */
2020 bool constraintExpr_isTerm (/*@observer@*/ constraintExpr c) /*@*/
2022 if (c->kind == term)
2029 /*@observer@*/ /*@temp@*/ constraintTerm constraintExpr_getTerm ( /*@temp@*/ /*@observer@*/ constraintExpr c) /*@*/
2031 constraintTerm term;
2033 llassert(constraintExpr_isTerm(c) );
2035 term = constraintExprData_termGetTerm(c->data);
2040 static void binaryExpr_dump (/*@observer@*/ constraintExprData data, FILE *f)
2042 constraintExpr expr1;
2043 constraintExprBinaryOpKind binaryOp;
2044 constraintExpr expr2;
2047 binaryOp = constraintExprData_binaryExprGetOp (data);
2049 fprintf(f, "%d\n", (int) binaryOp);
2051 expr1 = constraintExprData_binaryExprGetExpr1 (data);
2052 expr2 = constraintExprData_binaryExprGetExpr2 (data);
2056 constraintExpr_dump(expr1, f);
2059 constraintExpr_dump(expr2, f);
2063 static constraintExpr binaryExpr_undump (FILE *f)
2065 constraintExpr expr1;
2066 constraintExprBinaryOpKind binaryOp;
2067 constraintExpr expr2;
2076 os = mstring_create (MAX_DUMP_LINE_LENGTH);
2078 str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2081 binaryOp = (constraintExprBinaryOpKind) reader_getInt(&str);
2083 str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2085 reader_checkChar (&str, 'e');
2086 reader_checkChar (&str, '1');
2088 expr1 = constraintExpr_undump (f);
2090 str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2092 reader_checkChar (&str, 'e');
2093 reader_checkChar (&str, '2');
2095 expr2 = constraintExpr_undump (f);
2097 ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
2098 ret->data = constraintExprData_binaryExprSetOp(ret->data, binaryOp);
2106 static void unaryExpr_dump (/*@observer@*/ constraintExprData data, FILE *f)
2109 constraintExpr expr;
2110 constraintExprUnaryOpKind unaryOp;
2112 unaryOp = constraintExprData_unaryExprGetOp (data);
2114 fprintf(f, "%d\n", (int) unaryOp);
2116 expr = constraintExprData_unaryExprGetExpr (data);
2118 constraintExpr_dump(expr, f);
2121 static constraintExpr unaryExpr_undump ( FILE *f)
2124 constraintExpr expr;
2125 constraintExprUnaryOpKind unaryOp;
2131 str = mstring_create (MAX_DUMP_LINE_LENGTH);
2133 str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2135 unaryOp = (constraintExprUnaryOpKind) reader_getInt(&str);
2137 expr = constraintExpr_undump (f);
2139 ret = constraintExpr_makeUnaryOp (expr, unaryOp);
2146 void constraintExpr_dump (/*@observer@*/ constraintExpr expr, FILE *f)
2148 constraintExprKind kind;
2152 DPRINTF((message("constraintExpr_dump:: dumping constraintExpr %s",
2153 constraintExpr_unparse(expr)
2158 fprintf(f,"%d\n", (int) kind);
2163 t = constraintExprData_termGetTerm (expr->data);
2164 constraintTerm_dump (t, f);
2167 unaryExpr_dump (expr->data, f);
2170 binaryExpr_dump (expr->data, f);
2175 /*@only@*/ constraintExpr constraintExpr_undump (FILE *f)
2177 constraintExprKind kind;
2184 s = mstring_create (MAX_DUMP_LINE_LENGTH);
2188 s = fgets(os, MAX_DUMP_LINE_LENGTH, f);
2190 kind = (constraintExprKind) reader_getInt(&s);
2197 t = constraintTerm_undump (f);
2198 ret = constraintExpr_makeTerm(t);
2201 ret = unaryExpr_undump (f);
2204 ret = binaryExpr_undump (f);
2212 int constraintExpr_getDepth (constraintExpr ex)
2216 constraintExprKind kind;
2218 llassert (ex != NULL);
2228 ret = constraintExpr_getDepth (constraintExprData_unaryExprGetExpr (ex->data) );
2234 ret = constraintExpr_getDepth (constraintExprData_binaryExprGetExpr1 (ex->data) );
2238 ret += constraintExpr_getDepth (constraintExprData_binaryExprGetExpr2 (ex->data) );
2249 bool constraintExpr_canGetCType (constraintExpr e) /*@*/
2251 if (e->kind == term)
2257 DPRINTF(( message("constraintExpr_canGetCType: can't get type for %s ",
2258 constraintExpr_print(e) ) ));
2263 ctype constraintExpr_getCType (constraintExpr e) /*@*/
2267 llassert(constraintExpr_canGetCType(e) );
2272 t = constraintExprData_termGetTerm (e->data);
2273 return (constraintTerm_getCType(t) );
2274 /* assume that a unary expression will be an int ... */
2276 return ctype_signedintegral;
2278 /* drl for just return type of first operand */
2281 constraintExpr_getCType
2282 (constraintExprData_binaryExprGetExpr1 (e->data) )
2290 /* drl add 10-5-001 */
2292 static bool constraintExpr_hasTypeChange(constraintExpr e)
2294 if (constraintExpr_isDefined((e)) && (e->ct == TRUE) )
2299 if (e->kind == unaryExpr)
2301 if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
2305 ce = constraintExprData_unaryExprGetExpr(e->data);
2307 return (constraintExpr_hasTypeChange(ce) );
2314 /* drl add 10-5-001 */
2316 static ctype constraintExpr_getOrigType (constraintExpr e)
2319 llassert(constraintExpr_hasTypeChange(e) );
2327 if (e->kind == unaryExpr)
2329 if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
2333 ce = constraintExprData_unaryExprGetExpr(e->data);
2335 return (constraintExpr_getOrigType(ce) );
2343 /*drl added these around 10/18/001*/
2345 static /*@only@*/ constraintExpr constraintExpr_div (/*@only@*/ constraintExpr e, /*@unused@*/ ctype ct)
2350 static /*@only@*/ constraintExpr constraintTerm_simpleDivTypeExprNode(/*@only@*/ constraintExpr e, ctype ct)
2353 exprNode t1, t2, expr;
2358 message("constraintTerm_simpleDivTypeExprNode e=%s, ct=%s",
2359 constraintExpr_print(e), ctype_unparse(ct)
2363 t = constraintExprData_termGetTerm(e->data);
2365 expr = constraintTerm_getExprNode(t);
2367 if (expr->kind == XPR_OP)
2371 t1 = exprData_getOpA (data);
2372 t2 = exprData_getOpB (data);
2373 tok = exprData_getOpTok (data);
2374 if (lltok_isMult(tok) )
2377 if ((t1->kind == XPR_SIZEOF) || (t1->kind == XPR_SIZEOFT) )
2381 if (t1->kind == XPR_SIZEOFT)
2383 ct2 = qtype_getType (exprData_getType (t1->edata));
2389 tempE = exprData_getSingle (t1->edata);
2391 ct2 = exprNode_getType (tempE);
2393 if (ctype_match (ctype_makePointer(ct2), ct) )
2395 /* this is a bit sloopy but ... */
2396 constraintExpr_free(e);
2397 return constraintExpr_makeExprNode(t2);
2402 else if ((t2->kind == XPR_SIZEOF) || (t2->kind == XPR_SIZEOFT) )
2406 if (t2->kind == XPR_SIZEOFT)
2408 ct2 = qtype_getType (exprData_getType (t2->edata));
2412 ct2 = qtype_getType (exprData_getType(exprData_getSingle (t2->edata)->edata ) );
2414 if (ctype_match (ctype_makePointer(ct2),ct) )
2416 /* sloopy way to do this... */ /*@i22*/
2417 constraintExpr_free(e);
2418 return constraintExpr_makeExprNode(t1);
2428 return (constraintExpr_div (e, ct) );
2431 static /*@only@*/ constraintExpr simpleDivType (/*@only@*/ constraintExpr e, ctype ct)
2434 DPRINTF(( (message("simpleDiv got %s ", constraintExpr_unparse(e) ) )
2444 t = constraintExprData_termGetTerm(e->data);
2447 if (constraintTerm_isExprNode (t) )
2449 return constraintTerm_simpleDivTypeExprNode(e, ct);
2451 /* search for * size of ct and remove */
2453 return constraintExpr_div (e, ct);
2458 constraintExpr temp;
2460 temp = constraintExprData_binaryExprGetExpr1 (e->data);
2461 temp = constraintExpr_copy(temp);
2462 temp = simpleDivType (temp, ct);
2464 e->data = constraintExprData_binaryExprSetExpr1 (e->data, temp);
2466 temp = constraintExprData_binaryExprGetExpr2 (e->data);
2467 temp = constraintExpr_copy(temp);
2468 temp = simpleDivType (temp, ct);
2469 e->data = constraintExprData_binaryExprSetExpr2 (e->data, temp);
2471 DPRINTF(( (message("simpleDiv binaryexpr returning %s ", constraintExpr_unparse(e) ) )
2477 return constraintExpr_div (e, ct);
2484 static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast(/*@only@*/ constraintExpr e, ctype ct)
2487 DPRINTF(( (message("constraintExpr_adjustMaxSetForCast got %s ", constraintExpr_unparse(e) ) )
2490 e = constraintExpr_makeIncConstraintExpr(e);
2492 e = constraintExpr_simplify(e);
2495 e = simpleDivType (e, ct);
2497 e = constraintExpr_makeDecConstraintExpr(e);
2499 e = constraintExpr_simplify(e);
2501 DPRINTF(( (message("constraintExpr_adjustMaxSetForCast returning %s ", constraintExpr_unparse(e) ) )
2508 bool constraintExpr_isConstantOnly ( constraintExpr e )
2510 DPRINTF(( (message("constraintExpr_isConstantOnly %s ",
2511 constraintExpr_unparse(e) ) )
2520 t = constraintExprData_termGetTerm(e->data);
2523 if (constraintTerm_isConstantOnly (t) )
2535 constraintExpr temp1, temp2;
2537 temp1 = constraintExprData_binaryExprGetExpr1 (e->data);
2539 temp2 = constraintExprData_binaryExprGetExpr2 (e->data);
2541 if (constraintExpr_isConstantOnly(temp1) &&
2542 constraintExpr_isConstantOnly(temp2) )
2554 constraintExpr temp;
2556 temp = constraintExprData_unaryExprGetExpr (e->data );
2558 if (constraintExpr_isConstantOnly(temp) )