** constraintExpr.c
*/
-//#define DEBUGPRINT 1
+/* #define DEBUGPRINT 1 */
# include "lclintMacros.nf"
# include "basic.h"
# include "cgrammar_tokens.h"
# include "exprChecks.h"
-# include "aliasChecks.h"
# include "exprNodeSList.h"
+/*@-czechfcns@*/
-# include "exprData.i"
-# include "exprDataQuite.i"
-/*@-czechfcns@*/
+/*@access exprNode constraintExpr@*/
+
+
+static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/constraintExpr p_expr, int p_literal);
-#include "constraintExpr.h"
+/*@only@*/ static constraintExpr
+doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr p_e, /*@temp@*/ /*@observer@*/ exprNodeList p_arglist) /*@modifies p_e@*/;
+static /*@only@*/ constraintExpr
+doFixResultTerm (/*@only@*/ constraintExpr p_e, /*@exposed@*/ exprNode p_fcnCall)
+ /*@modifies p_e@*/;
+
+
+/*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
+ /* @allocates result->data @ @sets result->kind @ */ ;
-constraintExpr constraintExpr_makeMaxSetConstraintExpr (constraintExpr c);
+void constraintExpr_free (/*@only@*/ constraintExpr expr)
+{
+ if (constraintExpr_isDefined(expr) )
+ {
+ switch (expr->kind)
+ {
+ case unaryExpr:
+ constraintExprData_freeUnaryExpr(expr->data);
+ break;
+ case binaryexpr:
+ constraintExprData_freeBinaryExpr(expr->data);
+ break;
+ case term:
+ constraintExprData_freeTerm(expr->data);
+ break;
+ default:
+ BADEXIT;
+ }
+
+ expr->data = NULL;
+ free (expr);
+ }
+ else
+ {
+ llcontbug(message("attempted to free null pointer in constraintExpr_free"));
+ }
+}
bool constraintExpr_isLit (constraintExpr expr)
{
return FALSE;
}
+static bool isZeroBinaryOp (constraintExpr expr)
+{
+ constraintExpr e2;
+
+ llassert (expr != NULL); /* evans 2001-07-18 */
+
+ if (!constraintExpr_isBinaryExpr (expr) )
+ {
+ return FALSE;
+ }
+
+
+ e2 = constraintExprData_binaryExprGetExpr2(expr->data);
+
+ llassert (e2 != NULL); /* evans 2001-07-18 */
+
+ if (constraintExpr_isBinaryExpr (e2) )
+ {
+ constraintExpr e1;
+ constraintExprBinaryOpKind op;
+
+ op = constraintExprData_binaryExprGetOp (e2->data);
+
+ e1 = constraintExprData_binaryExprGetExpr1(e2->data);
+
+ if (constraintExpr_isLit(e1) )
+ {
+ if (constraintExpr_getValue(e1) == 0 )
+ {
+ return TRUE;
+ }
+ }
+ }
+ return FALSE;
+}
+
+/* change expr + (o - expr) to (expr -expr) */
+
+/*@only@*/ static constraintExpr removeZero (/*@only@*/ /*@returned@*/ constraintExpr expr)
+{
+ constraintExpr expr1, expr2;
+
+ constraintExpr temp;
+
+ constraintExprBinaryOpKind op;
+
+ constraintExprBinaryOpKind tempOp;
+
+ if (!isZeroBinaryOp(expr) )
+ return expr;
+
+ llassert (expr != NULL); /* evans 2001-07-18 */
+
+ expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
+ expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
+ op = constraintExprData_binaryExprGetOp(expr->data);
+
+ llassert( constraintExpr_isBinaryExpr(expr2) );
+
+ temp = constraintExprData_binaryExprGetExpr2 (expr2->data);
+ temp = constraintExpr_copy (temp);
+
+ tempOp = constraintExprData_binaryExprGetOp (expr2->data);
+
+ if (op == BINARYOP_PLUS)
+ op = tempOp;
+ else if (op == BINARYOP_MINUS)
+ {
+ if (tempOp == BINARYOP_PLUS)
+ op = BINARYOP_MINUS;
+ else if (tempOp == BINARYOP_MINUS)
+ op = BINARYOP_PLUS;
+ else
+ BADEXIT;
+ }
+ else
+ BADEXIT;
+
+ expr->data = constraintExprData_binaryExprSetExpr2(expr->data, temp);
+ expr->data = constraintExprData_binaryExprSetOp(expr->data, op);
+
+ return expr;
+}
+
-constraintExpr constraintExpr_propagateConstants (constraintExpr expr,
+/*@only@*/ constraintExpr constraintExpr_propagateConstants (/*@only@*/ constraintExpr expr,
/*@out@*/ bool * propagate,
/*@out@*/ int *literal)
{
constraintExpr expr2;
bool propagate1, propagate2;
int literal1, literal2;
+ constraintExprBinaryOpKind op;
propagate1 = FALSE;
propagate2 = FALSE;
*propagate = FALSE;
*literal = 0;
+
llassert (expr != NULL);
- // we simplify unaryExpr else where
- if (expr->kind == unaryExpr)
+ /* we simplify unaryExpr elsewhere */
+ if (expr->kind != binaryexpr)
return expr;
- if (expr->kind == term)
- return expr;
-
- if (constraintExpr_isLit (expr) )
- return expr;
+ op = constraintExprData_binaryExprGetOp (expr->data);
+
+ DPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
- BPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
+ expr = removeZero(expr);
expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
+ expr1 = constraintExpr_copy(expr1);
+ expr2 = constraintExpr_copy(expr2);
+
expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
- expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
- expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
+ expr1 = removeZero(expr1);
+ expr2 = removeZero(expr2);
+
*propagate = propagate1 || propagate2;
- *literal = literal1 + literal2;
-
+
+ if (op == BINARYOP_PLUS)
+ *literal = literal1 + literal2;
+ else if (op == BINARYOP_MINUS)
+ *literal = literal1 - literal2;
+ else
+ BADEXIT;
+
if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
{
- int t1, t2;
+ long t1, t2;
t1 = constraintExpr_getValue (expr1);
t2 = constraintExpr_getValue (expr2);
+ llassert(*propagate == FALSE);
*propagate = FALSE;
- if (constraintExprData_binaryExprGetOp (expr->data) == PLUS )
+
+ constraintExpr_free (expr);
+ constraintExpr_free (expr1);
+ constraintExpr_free (expr2);
+
+ if (op == BINARYOP_PLUS )
return (constraintExpr_makeIntLiteral ( (t1+t2) ));
- else if (constraintExprData_binaryExprGetOp (expr->data) == MINUS)
+ else if (op == BINARYOP_MINUS)
return (constraintExpr_makeIntLiteral ( (t1-t2) ));
else
- llassert(FALSE);
+ BADEXIT;
}
+
if (constraintExpr_isLit (expr1) )
{
- /*@i334*/
- /*handle MINUS case right */
*propagate = TRUE;
+
*literal += constraintExpr_getValue (expr1);
- return expr2;
+
+ if (op == BINARYOP_PLUS)
+ {
+ constraintExpr_free(expr1);
+ constraintExpr_free(expr);
+ return expr2;
+ }
+ else if (op == BINARYOP_MINUS)
+ {
+
+ constraintExpr temp;
+
+ /* this is an ugly kludge to deal with not
+ having a unary minus operation...*/
+
+ temp = constraintExpr_makeIntLiteral (0);
+ temp = constraintExpr_makeSubtractExpr (temp, expr2);
+
+ constraintExpr_free(expr1);
+ constraintExpr_free(expr);
+
+ return temp;
+ }
+ else
+ {
+ BADBRANCH; /* evans 2001-07-18 */
+ }
}
-
if (constraintExpr_isLit (expr2) )
{
*propagate = TRUE;
-
- if (constraintExprData_binaryExprGetOp (expr->data) == PLUS )
+
+ if ( op == BINARYOP_PLUS )
*literal += constraintExpr_getValue (expr2);
- else
+ else if (op == BINARYOP_MINUS)
*literal -= constraintExpr_getValue (expr2);
+ else
+ BADEXIT;
+
+
+ constraintExpr_free(expr2);
+ constraintExpr_free(expr);
return expr1;
}
-
-
- BPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
+ DPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
+
+ expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
+ expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
+ expr = removeZero(expr);
return expr;
}
-constraintExpr constraintExpr_combineConstants (constraintExpr expr )
+/*@only@*/ static constraintExpr constraintExpr_combineConstants (/*@only@*/ constraintExpr expr ) /*@modifies expr@*/
{
bool propagate;
int literal;
- BPRINTF ( (message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
+ DPRINTF ( (message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
expr = constraintExpr_propagateConstants (expr, &propagate, &literal);
expr = ret;
}
}
- BPRINTF ( (message ("After combine %s", constraintExpr_unparse(expr) ) ) );
+ DPRINTF ( (message ("After combine %s", constraintExpr_unparse(expr) ) ) );
return expr;
}
+
/*@special@*/
-constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
+static constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
{
constraintExpr ret;
ret = dmalloc (sizeof (*ret) );
return ret;
}
+/*@only@*/ static constraintExprData copyExprData (/*@observer@*/ constraintExprData data, constraintExprKind kind)
+{
+ constraintExprData ret;
+ llassert(constraintExprData_isDefined(data));
+
+ switch (kind)
+ {
+ case binaryexpr:
+ ret = constraintExprData_copyBinaryExpr(data);
+ break;
+ case unaryExpr:
+ ret = constraintExprData_copyUnaryExpr(data);
+ break;
+ case term:
+ ret = constraintExprData_copyTerm(data);
+ break;
+ default:
+ BADEXIT;
+ }
+ return ret;
+}
constraintExpr constraintExpr_copy (constraintExpr expr)
{
constraintExpr ret;
ret = constraintExpr_alloc();
ret->kind = expr->kind;
- ret->data = constraintExprData_copy (expr->data, expr->kind);
+
+ ret->data = copyExprData (expr->data, expr->kind);
return ret;
}
-constraintExpr oldconstraintExpr_makeTermExprNode (exprNode e)
+/*@only@*/ static constraintExpr oldconstraintExpr_makeTermExprNode ( /*@dependent@*/ exprNode e)
{
constraintExpr ret;
constraintTerm t;
}
else
{
- BPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
+ DPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
ret = oldconstraintExpr_makeTermExprNode (e);
}
break;
case XPR_OP:
- BPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
+ DPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
t1 = exprData_getOpA (data);
t2 = exprData_getOpB (data);
tok = exprData_getOpTok (data);
ce2 = constraintExpr_makeExprNode (t2);
ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2);
}
- else
+ /*
+ drl 8-11-001
+
+ We handle expressions containing sizeof with the rule
+ (sizeof type ) * Expr = Expr
+
+ This is the total wronge way to do this but...
+ it may be better than nothing
+ */
+ else if (lltok_isMult(tok) )
{
- ret = oldconstraintExpr_makeTermExprNode (e);
+ if ((t1->kind == XPR_SIZEOF) || (t1->kind == XPR_SIZEOFT) )
+ {
+ ret = constraintExpr_makeExprNode(t2);
+ }
+ else if ((t2->kind == XPR_SIZEOF) || (t2->kind == XPR_SIZEOFT) )
+ {
+ ret = constraintExpr_makeExprNode(t1);
+ }
+ else
+ {
+ ret = oldconstraintExpr_makeTermExprNode (e);
+ }
}
+ else
+ ret = oldconstraintExpr_makeTermExprNode (e);
+
break;
case XPR_PARENS:
t = exprData_getUopNode (data);
break;
case XPR_COMMA:
t = exprData_getPairA(data);
- ret = constraintExpr_makeExprNode(t);
+ ret = constraintExpr_makeExprNode(t);
+ /*@i3434*/ /*I'm not sure if this is right. I'm adding a break to quite LCLint*/
+ break;
default:
ret = oldconstraintExpr_makeTermExprNode (e);
return ret;
}
-
-constraintExpr constraintExpr_makeTermExprNode (exprNode e)
+/*@only@*/ constraintExpr constraintExpr_makeTermExprNode (/*@exposed@*/ exprNode e)
{
- return oldconstraintExpr_makeTermExprNode(e); //constraintExpr_makeExprNode (e);
+ return oldconstraintExpr_makeTermExprNode(e);
}
+static constraintExpr constraintExpr_makeTerm (/*@only@*/ constraintTerm t)
+{
+ constraintExpr ret;
+
+ ret = constraintExpr_alloc();
+ ret->kind = term;
+ ret->data = dmalloc (sizeof *(ret->data) );
+ ret->data->term = NULL;
+ ret->data = constraintExprData_termSetTerm (ret->data, t);
+
+ return ret;
+}
-constraintExpr constraintExpr_makeTermsRef (sRef s)
+constraintExpr constraintExpr_makeTermsRef (/*@temp@*/ sRef s)
{
constraintExpr ret;
constraintTerm t;
return ret;
}
-constraintExpr constraintExpr_makeUnaryOp (void) /*@allocates result->data@*/
+/*@special@*/ static constraintExpr makeUnaryOpGeneric (void) /*@allocates result->data@*/ /*@defines result->kind@*/
{
constraintExpr ret;
ret = constraintExpr_alloc();
ret->kind = unaryExpr;
ret->data = dmalloc ( sizeof *(ret->data) );
+ ret->data->unaryOp.expr = constraintExpr_undefined;
return ret;
}
-constraintExpr constraintExpr_makeUnaryOpConstraintExpr (constraintExpr cexpr)
+/*@only@*/ static constraintExpr constraintExpr_makeUnaryOpConstraintExpr (/*@only@*/ constraintExpr cexpr)
{
constraintExpr ret;
- ret = constraintExpr_makeUnaryOp();
+ ret = makeUnaryOpGeneric();
+
+ /*@-uniondef@*/
+ /*@-compdef@*/
ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
+ ret->data = constraintExprData_unaryExprSetOp (ret->data, UNARYOP_UNDEFINED);
+
return ret;
+
+ /*@=compdef@*/
+ /*@=uniondef@*/
}
-constraintExpr constraintExpr_makeMaxSetConstraintExpr (constraintExpr c)
+
+/*@only@*/ static constraintExpr constraintExpr_makeUnaryOp (/*@only@*/ constraintExpr cexpr, constraintExprUnaryOpKind Op )
{
constraintExpr ret;
- ret = constraintExpr_makeUnaryOpConstraintExpr (c);
- ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
+ ret = makeUnaryOpGeneric();
+
+ ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
+ ret->data = constraintExprData_unaryExprSetOp (ret->data, Op);
+
return ret;
}
-constraintExpr constraintExpr_makeUnaryOpExprNode (exprNode expr)
+/*@only@*/
+static constraintExpr constraintExpr_makeMaxSetConstraintExpr (/*@only@*/ constraintExpr c)
+{
+ constraintExpr ret;
+ ret = constraintExpr_makeUnaryOp (c, MAXSET);
+ return ret;
+}
+
+/*@only@*/
+static constraintExpr constraintExpr_makeUnaryOpExprNode (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
constraintExpr sub;
sub = constraintExpr_makeExprNode (expr);
ret = constraintExpr_makeUnaryOpConstraintExpr(sub);
+
return ret;
}
-constraintExpr constraintExpr_makeSRefUnaryOp (sRef s, constraintExprUnaryOpKind op)
+/*@only@*/
+static constraintExpr constraintExpr_makeSRefUnaryOp (/*@temp@*/ /*@observer@*/ sRef s, constraintExprUnaryOpKind op)
{
constraintExpr ret;
constraintExpr t;
t = constraintExpr_makeTermsRef (s);
ret = constraintExpr_makeUnaryOpConstraintExpr (t);
ret->data = constraintExprData_unaryExprSetOp (ret->data, op);
+
return ret;
}
-constraintExpr constraintExpr_makeSRefMaxRead(sRef s)
+/*@only@*/
+constraintExpr constraintExpr_makeSRefMaxRead( sRef s)
{
return (constraintExpr_makeSRefUnaryOp (s, MAXREAD) );
}
-constraintExpr constraintExpr_makeSRefMaxset (sRef s)
+/*@only@*/
+constraintExpr constraintExpr_makeSRefMaxset ( sRef s)
{
return (constraintExpr_makeSRefUnaryOp (s, MAXSET) );
}
+/*@only@*/
constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr)
{
constraintExpr ret;
return ret;
}
-constraintExpr constraintExpr_makeMaxSetExpr (exprNode expr)
+/*@only@*/
+constraintExpr constraintExpr_makeMaxSetExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeExprNode (expr);
return ret;
}
+/*@only@*/
constraintExpr constraintExpr_makeMaxReadExpr (exprNode expr)
{
constraintExpr ret;
return ret;
}
-constraintExpr constraintExpr_makeMinSetExpr (exprNode expr)
+# if 0
+/*@only@*/
+/*@unused@*/ static constraintExpr constraintExpr_makeMinSetExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeUnaryOpExprNode(expr);
return ret;
}
-constraintExpr constraintExpr_makeMinReadExpr (exprNode expr)
+/*@only@*/
+/*@unused@*/ static constraintExpr constraintExpr_makeMinReadExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeUnaryOpExprNode(expr);
ret->data = constraintExprData_unaryExprSetOp (ret->data, MINREAD);
return ret;
}
+# endif
-
-constraintExpr constraintExpr_makeValueExpr (exprNode expr)
+/*@only@*/
+constraintExpr constraintExpr_makeValueExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeExprNode (expr);
return ret;
}
-constraintExpr constraintExpr_makeIntLiteral (int i)
+/*@only@*/
+constraintExpr constraintExpr_makeIntLiteral (long i)
{
constraintExpr ret;
constraintTerm t;
return ret;
}
-
+/*
constraintExpr constraintExpr_makeValueInt (int i)
{
return constraintExpr_makeIntLiteral (i);
}
+*/
-static constraintExpr constraintExpr_makeBinaryOp (void)
+/*@only@*/
+ /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
+ /*@allocates result->data @*/ /*@sets result->kind @*/
{
constraintExpr ret;
ret = constraintExpr_alloc();
ret->kind = binaryexpr;
ret->data = dmalloc ( sizeof *(ret->data) );
- ret->data = constraintExprData_binaryExprSetOp (ret->data, PLUS);
+
+ ret->data->binaryOp.expr1 = constraintExpr_undefined;
+ ret->data->binaryOp.expr2 = constraintExpr_undefined;
+
return ret;
}
-constraintExpr constraintExpr_makeBinaryOpConstraintExpr (constraintExpr expr1,constraintExpr expr2)
+static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExpr (/*@only@*/constraintExpr expr1, /*@only@*/ constraintExpr expr2)
{
constraintExpr ret;
+
ret = constraintExpr_makeBinaryOp();
ret->data = constraintExprData_binaryExprSetExpr1 (ret->data, expr1);
ret->data = constraintExprData_binaryExprSetExpr2 (ret->data, expr2);
+ ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
return ret;
}
-constraintExpr constraintExpr_parseMakeBinaryOp (constraintExpr expr1, lltok op, constraintExpr expr2)
+/*@only@*/
+constraintExpr constraintExpr_parseMakeBinaryOp (/*@only@*/ constraintExpr expr1, lltok op,/*@only@*/ constraintExpr expr2)
{
constraintExpr ret;
ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
if (op.tok == TPLUS)
- ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
+ ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
else if (op.tok == TMINUS)
- ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS);
+ ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
else
{
llassert(FALSE);
return ret;
}
-constraintExpr constraintExpr_makeBinaryOpExprNode (exprNode expr1, exprNode expr2)
+# if 0
+/*@only@*/
+/*@unused@*/ static constraintExpr constraintExpr_makeBinaryOpExprNode (/*@exposed@*/ exprNode expr1, /*@exposed@*/ exprNode expr2)
{
constraintExpr ret;
constraintExpr sub1, sub2;
ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2);
return ret;
}
+# endif
-constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (constraintExpr expr, int literal)
+static /*@only@*/
+constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/ constraintExpr expr, int literal)
{
constraintExpr ret;
constraintExpr constExpr;
constExpr = constraintExpr_makeIntLiteral (literal);
ret = constraintExpr_makeBinaryOpConstraintExpr (expr, constExpr);
- ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
+ ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
return ret;
}
-constraintExpr constraintExpr_makeDecConstraintExpr (constraintExpr expr)
+/*@only@*/
+constraintExpr constraintExpr_makeDecConstraintExpr (/*@only@*/constraintExpr expr)
{
constraintExpr ret;
constraintExpr inc;
inc = constraintExpr_makeIntLiteral (1);
ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
- ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS);
+ ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
return ret;
}
-constraintExpr constraintExpr_makeAddConstraintExpr (constraintExpr expr, constraintExpr add)
+
+/*@only@*/ constraintExpr constraintExpr_makeSubtractExpr (/*@only@*/ constraintExpr expr, /*@only@*/ constraintExpr addent)
{
- constraintExpr ret;
+ constraintExpr ret;
+
+ DPRINTF ( (message ("Making subtract expression") ) );
- ret = constraintExpr_makeBinaryOpConstraintExpr (expr, add);
+ ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
+ ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_MINUS);
+ return ret;
+}
+
+/*@only@*/
+constraintExpr constraintExpr_makeAddExpr (/*@only@*/
+constraintExpr expr, /*@only@*/
+constraintExpr addent)
+{
+ constraintExpr ret;
- ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
+ DPRINTF ( (message ("Doing addTerm simplification") ) );
+ ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
+ ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_PLUS);
return ret;
}
-constraintExpr constraintExpr_makeIncConstraintExpr (constraintExpr expr)
+
+/*@only@*/
+constraintExpr constraintExpr_makeIncConstraintExpr (/*@only@*/ constraintExpr expr)
{
constraintExpr ret;
constraintExpr inc;
inc = constraintExpr_makeIntLiteral (1);
ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
- ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
+ ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
return ret;
}
-cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
+/*@only@*/
+static cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
{
switch (op)
{
case MAXSET:
- return message("MAXSET");
+ return message("maxSet");
case MINSET:
- return message("MINSET");
+ return message("minSet");
case MAXREAD:
- return message("MAXREAD");
+ return message("maxRead");
case MINREAD:
- return message("MINREAD");
+ return message("minRead");
default:
llassert(FALSE);
return message ("<(Unary OP OTHER>");
}
-cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
+/*@only@*/
+static cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
{
switch (op)
{
- case PLUS:
+ case BINARYOP_PLUS:
return message("+");
- case MINUS:
+ case BINARYOP_MINUS:
return message("-");
default:
case term:
return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
constraintExprData_termGetTerm(expr2->data) );
- /*@noreached@*/ break;
+ /*@notreached@*/ break;
case unaryExpr:
if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
BADEXIT;
}
-bool constraintExpr_search (constraintExpr c, constraintExpr old)
+bool constraintExpr_search (/*@observer@*/ constraintExpr c, /*@observer@*/ constraintExpr old)
{
bool ret = FALSE;
constraintExprKind kind;
if ( constraintExpr_similar (c, old) )
{
- #warning mem leak
- DPRINTF((message ("Found %s",
+ DPRINTF((message ("Found %q",
constraintExpr_unparse(old)
)));
return TRUE;
}
-constraintExpr constraintExpr_searchandreplace (constraintExpr c, constraintExpr old, constraintExpr new )
+/*@only@*/ constraintExpr constraintExpr_searchandreplace (/*@only@*/ /*@unique@*/ constraintExpr c, /*@temp@*/ constraintExpr old, /*@temp@*/ constraintExpr newExpr )
{
constraintExprKind kind;
constraintExpr temp;
if ( constraintExpr_similar (c, old) )
{
- #warning mem leak
+
DPRINTF((message ("Replacing %s with %s",
- constraintExpr_unparse(old), constraintExpr_unparse(new)
+ constraintExpr_unparse(old), constraintExpr_unparse(newExpr)
)));
- return constraintExpr_copy (new);
+ constraintExpr_free(c);
+ return constraintExpr_copy (newExpr);
}
kind = c->kind;
break;
case unaryExpr:
temp = constraintExprData_unaryExprGetExpr (c->data);
- temp = constraintExpr_searchandreplace (temp, old, new);
+ temp = constraintExpr_copy(temp);
+ temp = constraintExpr_searchandreplace (temp, old, newExpr);
c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
break;
case binaryexpr:
temp = constraintExprData_binaryExprGetExpr1 (c->data);
- temp = constraintExpr_searchandreplace (temp, old, new);
+ temp = constraintExpr_copy(temp);
+ temp = constraintExpr_searchandreplace (temp, old, newExpr);
c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
temp = constraintExprData_binaryExprGetExpr2 (c->data);
- temp = constraintExpr_searchandreplace (temp, old, new);
+ temp = constraintExpr_copy(temp);
+ temp = constraintExpr_searchandreplace (temp, old, newExpr);
c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
break;
default:
}
-constraintExpr constraintExpr_simplifyChildren (constraintExpr c)
+static constraintExpr constraintExpr_simplifyChildren (/*@returned@*/ constraintExpr c)
{
constraintExprKind kind;
constraintExpr temp;
break;
case unaryExpr:
temp = constraintExprData_unaryExprGetExpr (c->data);
+ temp = constraintExpr_copy(temp);
temp = constraintExpr_simplify (temp);
c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
break;
case binaryexpr:
- BPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) );
+ DPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) );
temp = constraintExprData_binaryExprGetExpr1 (c->data);
+ temp = constraintExpr_copy(temp);
temp = constraintExpr_simplify (temp);
c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
temp = constraintExprData_binaryExprGetExpr2 (c->data);
+ temp = constraintExpr_copy(temp);
temp = constraintExpr_simplify (temp);
c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
}
-constraintExpr constraintExpr_setFileloc (constraintExpr c, fileloc loc)
+constraintExpr constraintExpr_setFileloc (/*@returned@*/ constraintExpr c, fileloc loc) /*@modifies c @*/
{
constraintTerm t;
constraintExpr temp;
{
case term:
t = constraintExprData_termGetTerm (c->data);
+ t = constraintTerm_copy(t);
t = constraintTerm_setFileloc (t, loc);
c->data = constraintExprData_termSetTerm (c->data, t);
break;
case binaryexpr:
temp = constraintExprData_binaryExprGetExpr1 (c->data);
+ temp = constraintExpr_copy(temp);
temp = constraintExpr_setFileloc (temp, loc);
c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
temp = constraintExprData_binaryExprGetExpr2 (c->data);
+ temp = constraintExpr_copy(temp);
temp = constraintExpr_setFileloc (temp, loc);
c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
break;
case unaryExpr:
temp = constraintExprData_unaryExprGetExpr (c->data);
+ temp = constraintExpr_copy(temp);
temp = constraintExpr_setFileloc (temp, loc);
c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
break;
return c;
}
-constraintExpr constraintExpr_simplifybinaryExpr (constraintExpr c)
+static /*@only@*/ constraintExpr constraintExpr_simplifybinaryExpr (/*@only@*/constraintExpr c)
{
constraintExpr e1, e2;
-
+ constraintExprBinaryOpKind op;
+
e1 = constraintExprData_binaryExprGetExpr1 (c->data);
e2 = constraintExprData_binaryExprGetExpr2 (c->data);
if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) )
{
- int i;
+ long i;
i = constraintExpr_getValue(e1) + constraintExpr_getValue (e2);
-
+ constraintExpr_free(c);
c = constraintExpr_makeIntLiteral (i);
-
}
+ else
+ {
+ op = constraintExprData_binaryExprGetOp (c->data);
+ if (op == BINARYOP_MINUS)
+ if (constraintExpr_similar(e1, e2) )
+ {
+ constraintExpr_free(c);
+ c = constraintExpr_makeIntLiteral (0);
+ }
+ }
+
return c;
}
+/*
+ this thing takes the lexpr and expr of a constraint and modifies lexpr
+ and returns a (possiblly new) value for expr
+*/
+/* 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 */
-constraintExpr constraintExpr_subtractExpr (constraintExpr expr, constraintExpr addent)
-{
- constraintExpr new;
-
- BPRINTF ( (message ("Doing subtraceTerm simplification") ) );
+/* the approach is a little Kludgy but seems to work. I should probably use something cleaner at some point ... */
- new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
- new->data = constraintExprData_binaryExprSetOp (new->data, MINUS);
- return new;
-}
-constraintExpr constraintExpr_addExpr (constraintExpr expr, constraintExpr addent)
-{
- constraintExpr new;
-
- BPRINTF ( (message ("Doing addTerm simplification") ) );
-
- new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
- new->data = constraintExprData_binaryExprSetOp (new->data, PLUS);
- return new;
-}
-
-constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, constraintExpr expr)
+/*@only@*/ constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, /*@only@*/ constraintExpr expr)
{
constraintExpr expr1, expr2;
constraintExprBinaryOpKind op;
expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data);
expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data);
- op = constraintExprData_binaryExprGetOp (lexpr->data);
-
- // if (constraintExpr_canGetValue (expr2) )
- {
- #warning make sure this works
-
- lexpr->kind = expr1->kind;
- lexpr->data = constraintExprData_copy (expr1->data, expr1->kind);
+ op = constraintExprData_binaryExprGetOp (lexpr->data);
-
- if (op == PLUS)
- expr = constraintExpr_subtractExpr (expr, expr2);
- else
- expr = constraintExpr_addExpr (expr, expr2);
-
- return expr;
- }
- expr = constraintExpr_solveBinaryExpr (expr1, expr);
+ expr1 = constraintExpr_copy(expr1);
+ expr2 = constraintExpr_copy(expr2);
- expr = constraintExpr_solveBinaryExpr (expr2, expr);
+ /* drl possible problem : warning make sure this works */
+
+ lexpr->kind = expr1->kind;
+ sfree (lexpr->data);
+
+ lexpr->data = copyExprData (expr1->data, expr1->kind);
+ constraintExpr_free(expr1);
+
+ if (op == BINARYOP_PLUS)
+ expr = constraintExpr_makeSubtractExpr (expr, expr2);
+ else if (op == BINARYOP_MINUS)
+ expr = constraintExpr_makeAddExpr (expr, expr2);
+ else
+ BADEXIT;
+
+
return expr;
+
+ /*
+ #warning this needs to be checked
+ expr = constraintExpr_solveBinaryExpr (expr1, expr);
+
+ expr = constraintExpr_solveBinaryExpr (expr2, expr);
+ return expr;
+ */
}
-constraintExpr constraintExpr_simplifyunaryExpr (constraintExpr c)
+static /*@only@*/ constraintExpr constraintExpr_simplifyunaryExpr (/*@only@*/ constraintExpr c)
{
constraintExpr exp;
llassert (c->kind == unaryExpr);
- BPRINTF ( (message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
+ DPRINTF ((message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
if ( (constraintExprData_unaryExprGetOp (c->data) != MAXSET) &&
(constraintExprData_unaryExprGetOp (c->data) != MAXREAD) )
{
return c;
}
- // pattern mxr ( var + const) = mxr(var) - const
exp = constraintExprData_unaryExprGetExpr (c->data);
-
+ exp = constraintExpr_copy(exp);
+
if (exp->kind == term)
{
constraintTerm cterm;
val = constraintTerm_getStringLiteral (cterm);
if (constraintExprData_unaryExprGetOp (c->data) == MAXSET)
{
- return constraintExpr_makeIntLiteral (strlen (val) );
+ constraintExpr temp;
+
+ temp = constraintExpr_makeIntLiteral ((int)strlen (cstring_toCharsSafe(val) ) );
+ cstring_free(val);
+ constraintExpr_free(c);
+ constraintExpr_free(exp);
+
+ return temp;
+
}
if (constraintExprData_unaryExprGetOp (c->data) == MAXREAD)
{
- return constraintExpr_makeIntLiteral (strlen (val) );
+ constraintExpr temp;
+
+ temp = constraintExpr_makeIntLiteral ((int)strlen (cstring_toCharsSafe(val) ) );
+ cstring_free(val);
+ constraintExpr_free(c);
+ constraintExpr_free(exp);
+
+ return temp;
}
BADEXIT;
}
+
+ /* slight Kludge to hanlde var [] = { , , };
+ ** type syntax I don't think this is sounds but it should be good
+ ** enough. The C stanrad is very confusing about initialization
+ ** -- DRL 7/25/01
+ */
+
+ if (constraintTerm_isInitBlock(cterm) )
+ {
+ constraintExpr temp;
+ int len;
+
+ len = constraintTerm_getInitBlockLength(cterm);
+
+ temp = constraintExpr_makeIntLiteral (len );
+
+ constraintExpr_free(c);
+ DPRINTF(( message("Changed too %q", constraintExpr_print(temp)
+ ) ));
+ constraintExpr_free(exp);
+ return temp;
+ }
+
+ constraintExpr_free(exp);
return c;
}
if (exp->kind != binaryexpr)
- return c;
-
- if (constraintExprData_binaryExprGetOp (exp->data) == PLUS )
+ {
+ constraintExpr_free(exp);
+ return c;
+ }
+
+ if (constraintExprData_binaryExprGetOp (exp->data) == BINARYOP_PLUS )
{
- // if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) )
+ /* if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) ) */
{
- constraintExpr temp, temp2, new;
+ constraintExpr temp, temp2;
DPRINTF ( (message ("Doing fancy simplification") ) );
temp = constraintExprData_binaryExprGetExpr2 (exp->data);
temp2 = constraintExprData_binaryExprGetExpr1 (exp->data);
+
+ temp2 = constraintExpr_copy(temp2);
c->data = constraintExprData_unaryExprSetExpr (c->data, temp2);
-
- new = constraintExpr_subtractExpr (c, temp);
+ temp = constraintExpr_copy (temp);
- DPRINTF ( (message ("Done fancy simplification:%s", constraintExpr_unparse (new) ) ) );
+ c = constraintExpr_makeSubtractExpr (c, temp);
- c = new;
+ DPRINTF ( (message ("Done fancy simplification:%s", constraintExpr_unparse (c) ) ) );
}
}
- DPRINTF ( (message ("Done simplification:%s", constraintExpr_unparse (c) ) ) );
+ DPRINTF ( (message ("constraintExpr_simplifyUnaryExpr: Done simplification:%s", constraintExpr_unparse (c) ) ) );
+
+ constraintExpr_free(exp);
return c;
}
-constraintExpr constraintExpr_simplify (constraintExpr c)
+/*@only@*/ constraintExpr constraintExpr_simplify (/*@only@*/ constraintExpr c)
{
constraintExprKind kind;
+ constraintExpr ret;
constraintTerm t;
+
+ DPRINTF ( (message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) );
+
+ /*@i22*/
- BPRINTF ( (message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) );
+ /*I think this is an LCLint bug */
+
+ ret = constraintExpr_copy(c);
+
+ constraintExpr_free(c);
+
+ ret = constraintExpr_simplifyChildren (ret);
- c = constraintExpr_simplifyChildren (c);
- c = constraintExpr_combineConstants (c);
- c = constraintExpr_simplifyChildren (c);
+ ret = constraintExpr_combineConstants (ret);
- kind = c->kind;
+ ret = constraintExpr_simplifyChildren (ret);
+
+
+ kind = ret->kind;
switch (kind)
{
case term:
- t = constraintExprData_termGetTerm (c->data);
+ t = constraintExprData_termGetTerm (ret->data);
+ t = constraintTerm_copy(t);
t = constraintTerm_simplify (t);
- c->data = constraintExprData_termSetTerm (c->data, t);
+ ret->data = constraintExprData_termSetTerm (ret->data, t);
break;
case unaryExpr:
- c = constraintExpr_simplifyunaryExpr (c);
+ ret = constraintExpr_simplifyunaryExpr (ret);
break;
case binaryexpr:
- c = constraintExpr_simplifybinaryExpr (c);
+ ret = constraintExpr_simplifybinaryExpr (ret);
break;
default:
llassert(FALSE);
- }
- return c;
+ }
+
+ DPRINTF ( (message ("constraintExpr_simplify returning :%s", constraintExpr_unparse (ret) ) ) );
+ return ret;
}
-cstring constraintExpr_unparse (constraintExpr ex)
+/*@only@*/
+cstring constraintExpr_unparse (/*@temp@*/ /*@observer@*/ constraintExpr ex) /*@*/
{
cstring st;
constraintExprKind kind;
switch (kind)
{
case term:
- st = message ("(%s) ", constraintTerm_print (constraintExprData_termGetTerm(ex->data) ) );
+
+ if (context_getFlag (FLG_PARENCONSTRAINT) )
+ {
+ st = message ("(%q) ", constraintTerm_print (constraintExprData_termGetTerm (ex->data)));
+ }
+ else
+ {
+ st = message ("%q", constraintTerm_print (constraintExprData_termGetTerm (ex->data)));
+ }
break;
case unaryExpr:
- st = message ("%s (%s)",
- constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data)
- ),
+ st = message ("%q(%q)",
+ constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data) ),
constraintExpr_unparse (constraintExprData_unaryExprGetExpr (ex->data) )
);
break;
case binaryexpr:
- st = message ("(%s) %s (%s)",
+ if (context_getFlag (FLG_PARENCONSTRAINT) )
+ {
+ st = message ("(%q) %q (%q)",
constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ),
constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)
),
constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) )
);
+ }
+ else
+ {
+ st = message ("%q %q %q",
+ constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ),
+ constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)
+ ),
+ constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) )
+ );
+ }
+
break;
default:
llassert(FALSE);
{
case term:
Term = constraintExprData_termGetTerm(data);
+ Term = constraintTerm_copy(Term);
+
Term = constraintTerm_doSRefFixBaseParam (Term, arglist);
data = constraintExprData_termSetTerm(data, Term);
break;
case unaryExpr:
expr1 = constraintExprData_unaryExprGetExpr (data);
+ expr1 = constraintExpr_copy(expr1);
+
expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
data = constraintExprData_unaryExprSetExpr (data, expr1);
break;
expr1 = constraintExprData_binaryExprGetExpr1 (data);
expr2 = constraintExprData_binaryExprGetExpr2 (data);
+ expr1 = constraintExpr_copy(expr1);
+ expr2 = constraintExpr_copy(expr2);
+
expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
data = constraintExprData_binaryExprSetExpr1 (data, expr1);
expr2 = constraintExpr_doSRefFixBaseParam (expr2, arglist);
return expr;
}
-constraintExpr constraintExpr_doSRefFixConstraintParam (/*@returned@*/ constraintExpr expr, exprNodeList arglist)
+/*@only@*/ constraintExpr constraintExpr_doSRefFixConstraintParam (/*@only@*/ constraintExpr expr, exprNodeList arglist) /*@modifies expr@*/
{
constraintExprKind kind;
constraintExpr expr1, expr2;
switch (kind)
{
case term:
- expr = constraintTerm_doSRefFixConstraintParam (expr, arglist);
+ expr = doSRefFixConstraintParamTerm (expr, arglist);
break;
case unaryExpr:
expr1 = constraintExprData_unaryExprGetExpr (data);
+ expr1 = constraintExpr_copy(expr1);
expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
data = constraintExprData_unaryExprSetExpr (data, expr1);
break;
expr1 = constraintExprData_binaryExprGetExpr1 (data);
expr2 = constraintExprData_binaryExprGetExpr2 (data);
+ expr1 = constraintExpr_copy(expr1);
+ expr2 = constraintExpr_copy(expr2);
+
expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
data = constraintExprData_binaryExprSetExpr1 (data, expr1);
expr2 = constraintExpr_doSRefFixConstraintParam (expr2, arglist);
return expr;
}
-constraintExpr constraintExpr_doFixResult (/*@returned@*/ constraintExpr expr, exprNode fcnCall)
+/*@only@*/ constraintExpr constraintExpr_doFixResult (/*@only@*/ constraintExpr expr, /*@observer@*/ exprNode fcnCall)
{
constraintExprKind kind;
constraintExpr expr1, expr2;
switch (kind)
{
case term:
- expr = constraintTerm_doFixResult (expr, fcnCall);
+ expr = doFixResultTerm (expr, fcnCall);
break;
case unaryExpr:
expr1 = constraintExprData_unaryExprGetExpr (data);
+ expr1 = constraintExpr_copy(expr1);
+
expr1 = constraintExpr_doFixResult (expr1, fcnCall);
data = constraintExprData_unaryExprSetExpr (data, expr1);
break;
expr1 = constraintExprData_binaryExprGetExpr1 (data);
expr2 = constraintExprData_binaryExprGetExpr2 (data);
+ expr1 = constraintExpr_copy(expr1);
+ expr2 = constraintExpr_copy(expr2);
+
expr1 = constraintExpr_doFixResult (expr1, fcnCall);
data = constraintExprData_binaryExprSetExpr1 (data, expr1);
expr2 = constraintExpr_doFixResult (expr2, fcnCall);
cstring constraintExpr_print (constraintExpr expr) /*@*/
{
- return constraintExpr_unparse(expr);
+ return constraintExpr_unparse (expr);
}
bool constraintExpr_hasMaxSet (constraintExpr expr) /*@*/
t = constraintExpr_unparse(expr);
- return ((bool)strstr (t, "MAXSET") );
+ if (cstring_containsLit(t, "maxSet") != NULL )
+ {
+ cstring_free(t);
+ return (TRUE);
+ }
+ else
+ {
+ cstring_free(t);
+ return FALSE;
+ }
}
0 => expr1 == expr2
-1 => expr1 < expr2
*/
+
int constraintExpr_compare (constraintExpr expr1, constraintExpr expr2)
{
- int value1, value2;
+ long value1, value2;
if (constraintExpr_similar (expr1, expr2) )
{
return 0;
}
+
value1 = constraintExpr_getValue(expr1);
value2 = constraintExpr_getValue(expr2);
return -1;
}
-int constraintExpr_getValue (constraintExpr expr)
+long constraintExpr_getValue (constraintExpr expr)
{
llassert (expr->kind == term);
- return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data) ) );
+ return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data)));
}
bool constraintExpr_canGetValue (constraintExpr expr)
return FALSE;
}
- llassert(FALSE);
-}
-bool constraintExpr_canCompare (constraintExpr expr1, constraintExpr expr2)
-{
-
- llassert(expr1 && expr2);
- return ( constraintExpr_canGetValue(expr1) &&
- constraintExpr_canGetValue(expr2)
- );
+ BADEXIT;
}
-
fileloc constraintExpr_getFileloc (constraintExpr expr)
{
constraintExpr e;
case term:
t = constraintExprData_termGetTerm (expr->data);
return (constraintTerm_getFileloc (t) );
+ /*@notreached@*/
break;
case unaryExpr:
e = constraintExprData_unaryExprGetExpr (expr->data);
return (constraintExpr_getFileloc (e) );
+ /*@notreached@*/
break;
case binaryexpr:
e = constraintExprData_binaryExprGetExpr1 (expr->data);
return (constraintExpr_getFileloc (e) );
+ /*@notreached@*/
+ break;
}
llassert (FALSE);
- // llfatalbug("Code should be reached");
return (fileloc_undefined);
}
+/*drl moved from constriantTerm.c 5/20/001*/
+static /*@only@*/ constraintExpr
+doFixResultTerm (/*@only@*/ constraintExpr e, /*@exposed@*/ exprNode fcnCall)
+{
+ constraintTerm t;
+ sRef s;
+ /*maybe this should move to cosntraintExpr.c -drl7x 5/18/01*/
+ /*@i22*/
+
+ constraintExprData data = e->data;
+ constraintExprKind kind = e->kind;
+
+ constraintExpr ret;
+
+ llassert(kind == term);
+
+ t = constraintExprData_termGetTerm (data);
+ llassert (constraintTerm_isDefined(t) );
+
+ ret = e;
+ switch (constraintTerm_getKind(t) )
+ {
+ case EXPRNODE:
+ break;
+ case INTLITERAL:
+ break;
+
+ case SREF:
+ s = constraintTerm_getSRef(t);
+ if (sRef_isResult (s))
+ {
+ ret = constraintExpr_makeExprNode(fcnCall);
+ constraintExpr_free(e);
+ e = NULL;
+ }
+ else
+ {
+ e = NULL;
+ }
+ break;
+ default:
+ BADEXIT;
+ }
+
+ return ret;
+
+}
+
+/*drl moved from constriantTerm.c 5/20/001*/
+/*@only@*/ static constraintExpr
+doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, /*@observer@*/ /*@temp@*/ exprNodeList arglist)
+{
+ constraintTerm t;
+
+ constraintExprData data = e->data;
+
+ constraintExprKind kind = e->kind;
+
+ constraintExpr ret;
+
+ llassert(kind == term);
+
+ t = constraintExprData_termGetTerm (data);
+ llassert (constraintTerm_isDefined(t) );
+
+ ret = e;
+
+ DPRINTF (("Fixing: %s", constraintExpr_print (e)));
+
+ switch (constraintTerm_getKind(t))
+ {
+ case EXPRNODE:
+ DPRINTF((message ("%q @ %q ", constraintTerm_print(t),
+ fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
+ break;
+ case INTLITERAL:
+ DPRINTF((message (" %q ", constraintTerm_print (t)) ));
+ break;
+
+ case SREF:
+ /* evans 2001-07-24: constants should use the original term */
+ if (!constraintTerm_canGetValue (t))
+ {
+ DPRINTF ((message("Doing sRef_fixConstraintParam for %q ",
+ constraintTerm_print (t) ) ));
+ ret = sRef_fixConstraintParam (constraintTerm_getSRef(t), arglist);
+
+ constraintExpr_free (e);
+
+ DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
+ constraintExpr_print (ret) ) ));
+ /*@-branchstate@*/
+ } /*@=branchstate@*/
+
+ break;
+ default:
+ BADEXIT;
+ }
+
+ return ret;
+
+}
/* bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term) */
/* } */
+/*drl added 6/11/01 */
+bool constraintExpr_isBinaryExpr (/*@observer@*/ constraintExpr c)
+{
+ if (c->kind == binaryexpr)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+/*drl added 8/08/001 */
+bool constraintExpr_isTerm (/*@observer@*/ constraintExpr c) /*@*/
+{
+ if (c->kind == term)
+ return TRUE;
+ else
+ return FALSE;
+}
+/*@observer@*/ /*@temp@*/ constraintTerm constraintExpr_getTerm ( /*@temp@*/ /*@observer@*/ constraintExpr c) /*@*/
+{
+ constraintTerm term;
+
+ llassert(constraintExpr_isTerm(c) );
+
+ term = constraintExprData_termGetTerm(c->data);
+
+ return term;
+}
+
+static void binaryExpr_dump (/*@observer@*/ constraintExprData data, FILE *f)
+{
+ constraintExpr expr1;
+ constraintExprBinaryOpKind binaryOp;
+ constraintExpr expr2;
+
+
+ binaryOp = constraintExprData_binaryExprGetOp (data);
+
+ fprintf(f, "%d\n", (int) binaryOp);
+
+ expr1 = constraintExprData_binaryExprGetExpr1 (data);
+ expr2 = constraintExprData_binaryExprGetExpr2 (data);
+
+ fprintf(f, "e1\n");
+
+ constraintExpr_dump(expr1, f);
+
+ fprintf(f, "e2\n");
+ constraintExpr_dump(expr2, f);
+}
+
+
+static constraintExpr binaryExpr_undump (FILE *f)
+{
+ constraintExpr expr1;
+ constraintExprBinaryOpKind binaryOp;
+ constraintExpr expr2;
+
+ constraintExpr ret;
+
+
+
+ char * str;
+ char * os;
+
+ str = mstring_create (MAX_DUMP_LINE_LENGTH);
+ os = str;
+ str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
+
+
+ binaryOp = (constraintExprBinaryOpKind) reader_getInt(&str);
+
+ str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
+
+ reader_checkChar (&str, 'e');
+ reader_checkChar (&str, '1');
+
+ expr1 = constraintExpr_undump (f);
+
+ str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
+
+ reader_checkChar (&str, 'e');
+ reader_checkChar (&str, '2');
+
+ expr2 = constraintExpr_undump (f);
+
+ ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
+ ret->data = constraintExprData_binaryExprSetOp(ret->data, binaryOp);
+
+ free(os);
+ return ret;
+}
+
+
+
+static void unaryExpr_dump (/*@observer@*/ constraintExprData data, FILE *f)
+{
+
+ constraintExpr expr;
+ constraintExprUnaryOpKind unaryOp;
+
+ unaryOp = constraintExprData_unaryExprGetOp (data);
+
+ fprintf(f, "%d\n", (int) unaryOp);
+
+ expr = constraintExprData_unaryExprGetExpr (data);
+
+ constraintExpr_dump(expr, f);
+}
+
+static constraintExpr unaryExpr_undump ( FILE *f)
+{
+
+ constraintExpr expr;
+ constraintExprUnaryOpKind unaryOp;
+ constraintExpr ret;
+
+ char * str;
+ char * os;
+
+ str = mstring_create (MAX_DUMP_LINE_LENGTH);
+ os = str;
+ str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
+
+ unaryOp = (constraintExprUnaryOpKind) reader_getInt(&str);
+
+ expr = constraintExpr_undump (f);
+
+ ret = constraintExpr_makeUnaryOp (expr, unaryOp);
+
+ free(os);
+
+ return ret;
+}
+
+void constraintExpr_dump (/*@observer@*/ constraintExpr expr, FILE *f)
+{
+ constraintExprKind kind;
+ constraintTerm t;
+
+
+ kind = expr->kind;
+
+ fprintf(f,"%d\n", (int) kind);
+
+ switch (kind)
+ {
+ case term:
+ t = constraintExprData_termGetTerm (expr->data);
+ constraintTerm_dump (t, f);
+ break;
+ case unaryExpr:
+ unaryExpr_dump (expr->data, f);
+ break;
+ case binaryexpr:
+ binaryExpr_dump (expr->data, f);
+ break;
+ }
+}
+
+/*@only@*/ constraintExpr constraintExpr_undump (FILE *f)
+{
+ constraintExprKind kind;
+ constraintTerm t;
+ constraintExpr ret;
+
+ char * s;
+ char * os;
+
+ s = mstring_create (MAX_DUMP_LINE_LENGTH);
+
+ os = s;
+
+ s = fgets(os, MAX_DUMP_LINE_LENGTH, f);
+
+ kind = (constraintExprKind) reader_getInt(&s);
+
+ free (os);
+
+ switch (kind)
+ {
+ case term:
+ t = constraintTerm_undump (f);
+ ret = constraintExpr_makeTerm(t);
+ break;
+ case unaryExpr:
+ ret = unaryExpr_undump (f);
+ break;
+ case binaryexpr:
+ ret = binaryExpr_undump (f);
+ break;
+ }
+
+ return ret;
+
+}
+
+int constraintExpr_getDepth (constraintExpr ex)
+{
+ int ret;
+
+ constraintExprKind kind;
+
+ llassert (ex != NULL);
+
+ kind = ex->kind;
+
+ switch (kind)
+ {
+ case term:
+ ret = 1;
+ break;
+ case unaryExpr:
+ ret = constraintExpr_getDepth (constraintExprData_unaryExprGetExpr (ex->data) );
+ ret++;
+
+ break;
+ case binaryexpr:
+ ret = 0;
+ ret = constraintExpr_getDepth (constraintExprData_binaryExprGetExpr1 (ex->data) );
+
+ ret++;
+
+ ret += constraintExpr_getDepth (constraintExprData_binaryExprGetExpr2 (ex->data) );
+
+ break;
+ default:
+ BADEXIT;
+ }
+
+ return ret;
+}
+
+
+