/*
** Splint - annotation-assisted static program checker
** Copyright (C) 1994-2003 University of Virginia,
** Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 2 of the License, or (at your
** option) any later version.
**
** This program is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** General Public License for more details.
**
** The GNU General Public License is available from http://www.gnu.org/ or
** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
** MA 02111-1307, USA.
**
** For information on splint: info@splint.org
** To report a bug: splint-bug@splint.org
** For more information: http://www.splint.org
*/
/*
** constraintExpr.c
*/
/* #define DEBUGPRINT 1 */
# include "splintMacros.nf"
# include "basic.h"
# include "cgrammar.h"
# include "cgrammar_tokens.h"
# include "exprChecks.h"
# include "exprNodeSList.h"
static ctype constraintExpr_getOrigType (constraintExpr p_e);
static bool constraintExpr_hasTypeChange(constraintExpr p_e) /*@*/;
static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/constraintExpr p_expr, int p_literal);
/*@only@*/ static constraintExpr
doSRefFixInvarConstraintTerm (/*@only@*/ constraintExpr p_e,
sRef p_s, ctype p_ct);
/*@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@*/;
static bool constraintExpr_canGetCType (constraintExpr p_e) /*@*/;
static ctype constraintExpr_getCType (constraintExpr p_e);
static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast (/*@only@*/ constraintExpr p_e,
ctype p_tfrom, ctype p_tto,
fileloc p_loc);
/*@special@*/ /*@notnull@*/ static constraintExpr constraintExpr_makeBinaryOp (void)
/* @allocates result->data @ @sets result->kind @ */ ;
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)
{
llassert (expr != NULL);
if (expr->kind == term)
{
constraintTerm term = constraintExprData_termGetTerm (expr->data);
if (constraintTerm_isIntLiteral (term) )
{
return TRUE;
}
}
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@*/ /*@notnull@*/ static constraintExpr removeZero (/*@only@*/ /*@returned@*/ constraintExpr expr)
{
constraintExpr expr1, expr2;
constraintExpr temp;
constraintExprBinaryOpKind op;
constraintExprBinaryOpKind tempOp;
llassert (expr != NULL); /* evans 2001-07-18 */
if (!isZeroBinaryOp(expr) )
return expr;
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;
}
/*@only@*//*@notnull@*/ constraintExpr constraintExpr_propagateConstants (/*@only@*/ constraintExpr expr,
/*@out@*/ bool * propagate,
/*@out@*/ int *literal)
{
constraintExpr expr1;
constraintExpr expr2;
bool propagate1, propagate2;
int literal1, literal2;
constraintExprBinaryOpKind op;
propagate1 = FALSE;
propagate2 = FALSE;
literal1 = 0;
literal2 = 0;
*propagate = FALSE;
*literal = 0;
llassert (expr != NULL);
/* we simplify unaryExpr elsewhere */
if (expr->kind != binaryexpr)
return expr;
op = constraintExprData_binaryExprGetOp (expr->data);
DPRINTF((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);
expr1 = removeZero(expr1);
expr2 = removeZero(expr2);
*propagate = propagate1 || propagate2;
if (op == BINARYOP_PLUS)
*literal = literal1 + literal2;
else if (op == BINARYOP_MINUS)
*literal = literal1 - literal2;
else
BADEXIT;
if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
{
long t1, t2;
t1 = constraintExpr_getValue (expr1);
t2 = constraintExpr_getValue (expr2);
llassert(*propagate == FALSE);
*propagate = FALSE;
constraintExpr_free (expr);
constraintExpr_free (expr1);
constraintExpr_free (expr2);
if (op == BINARYOP_PLUS )
return (constraintExpr_makeIntLiteral ((t1+t2) ));
else if (op == BINARYOP_MINUS)
return (constraintExpr_makeIntLiteral ((t1-t2) ));
else
BADEXIT;
}
if (constraintExpr_isLit (expr1) )
{
*propagate = TRUE;
*literal += constraintExpr_getValue (expr1);
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);
llassert (constraintExpr_isDefined(temp) );
return temp;
}
else
{
BADBRANCH; /* evans 2001-07-18 */
}
}
if (constraintExpr_isLit (expr2) )
{
*propagate = TRUE;
if ( op == BINARYOP_PLUS )
*literal += constraintExpr_getValue (expr2);
else if (op == BINARYOP_MINUS)
*literal -= constraintExpr_getValue (expr2);
else
BADEXIT;
constraintExpr_free(expr2);
constraintExpr_free(expr);
return expr1;
}
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;
}
/*@notnull@*/ /*@only@*/ static constraintExpr constraintExpr_combineConstants (/*@only@*/ constraintExpr expr ) /*@modifies expr@*/
{
bool propagate;
int literal;
DPRINTF ((message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
expr = constraintExpr_propagateConstants (expr, &propagate, &literal);
if (propagate)
{
constraintExpr ret;
if (literal != 0)
{
ret = constraintExpr_makeBinaryOpConstraintExprIntLiteral (expr, literal);
expr = ret;
}
}
DPRINTF ((message ("After combine %s", constraintExpr_unparse(expr) ) ) );
llassert(constraintExpr_isDefined(expr) );
return expr;
}
/*@special@*/
static /*@notnull@*/ constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
{
constraintExpr ret;
ret = dmalloc (sizeof (*ret) );
ret->kind = term;
ret->data = NULL;
ret->ct = FALSE;
ret->origType = ctype_undefined;
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 ();
/*drl 03/02/2003 this shouldn't be used to copy a null
expression but handle things cleanly if it is*/
llassert (!constraintExpr_isUndefined(expr) );
if (constraintExpr_isUndefined(expr) )
{
return constraintExpr_undefined;
}
ret->kind = expr->kind;
ret->data = copyExprData (expr->data, expr->kind);
ret->ct = expr->ct;
ret->origType = expr->origType;
return ret;
}
/*@only@*/ static constraintExpr oldconstraintExpr_makeTermExprNode ( /*@dependent@*/ exprNode e)
{
constraintExpr ret;
constraintTerm t;
ret = constraintExpr_alloc();
ret->kind = term;
ret->data = dmalloc (sizeof *(ret->data) );
t = constraintTerm_makeExprNode (e);
ret->data = constraintExprData_termSetTerm (ret->data, t);
ret->ct = FALSE;
ret->origType = ctype_undefined;
return ret;
}
/*@access exprNode@*/
constraintExpr constraintExpr_makeExprNode (exprNode e)
{
sRef s;
constraintExpr ret, ce1, ce2;
exprData data;
exprNode t, t1, t2;
lltok tok;
if (exprNode_isUndefined (e))
{
return constraintExpr_undefined;
}
data = e->edata;
switch (e->kind)
{
case XPR_SIZEOF:
t = exprData_getSingle (data);
while (exprNode_isInParens (t) )
{
t = exprData_getUopNode (t->edata);
}
s = exprNode_getSref (t);
if (sRef_isFixedArray(s) )
{
int size;
size = (int) sRef_getArraySize(s);
ret = constraintExpr_makeIntLiteral (size);
}
else if (exprNode_isStringLiteral (t))
{
cstring str = multiVal_forceString (exprNode_getValue(t));
ret = constraintExpr_makeIntLiteral (size_toLong (cstring_length (str) + 1));
}
else
{
DPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
ret = oldconstraintExpr_makeTermExprNode (e);
}
break;
case XPR_OP:
DPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
t1 = exprData_getOpA (data);
t2 = exprData_getOpB (data);
tok = exprData_getOpTok (data);
if (lltok_isPlus_Op (tok) || lltok_isMinus_Op (tok) )
{
ce1 = constraintExpr_makeExprNode (t1);
ce2 = constraintExpr_makeExprNode (t2);
ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2);
}
/* define this block to activate the cheesy heuristic
for handling sizeof expressions*/
#if 0
/*
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) )
{
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);
}
}
#endif
else
ret = oldconstraintExpr_makeTermExprNode (e);
break;
case XPR_PARENS:
t = exprData_getUopNode (data);
ret = constraintExpr_makeExprNode (t);
break;
case XPR_PREOP:
t = exprData_getUopNode (data);
tok = exprData_getUopTok (data);
if (lltok_isIncOp (tok))
{
constraintExpr temp;
temp = constraintExpr_makeExprNode(t);
ret = constraintExpr_makeIncConstraintExpr(temp);
}
else if (lltok_isDecOp (tok))
{
constraintExpr temp;
temp = constraintExpr_makeExprNode(t);
ret = constraintExpr_makeDecConstraintExpr(temp);
}
else
ret = oldconstraintExpr_makeTermExprNode (e);
break;
case XPR_POSTOP:
t = exprData_getUopNode (data);
ret = constraintExpr_makeExprNode (t);
break;
case XPR_CAST:
t = exprData_getCastNode (data);
ret = constraintExpr_makeExprNode (t);
break;
case XPR_COMMA:
t = exprData_getPairA (data);
ret = constraintExpr_makeExprNode(t);
break;
default:
ret = oldconstraintExpr_makeTermExprNode (e);
}
return ret;
}
/*@noaccess exprNode@*/
/*@only@*/ constraintExpr constraintExpr_makeTermExprNode (/*@exposed@*/ exprNode 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);
ret->ct = FALSE;
ret->origType = ctype_undefined;
return ret;
}
constraintExpr constraintExpr_makeTermsRef (/*@temp@*/ sRef s)
{
constraintExpr ret;
constraintTerm t;
ret = constraintExpr_alloc();
ret->kind = term;
ret->data = dmalloc (sizeof *(ret->data) );
t = constraintTerm_makesRef (s);
ret->data = constraintExprData_termSetTerm (ret->data, t);
ret->ct = FALSE;
ret->origType = ctype_undefined;
return ret;
}
/*@special@*/ /*@notnull@*/ 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;
}
/*@notnull@*/ /*@only@*/ static constraintExpr constraintExpr_makeUnaryOpConstraintExpr (/*@only@*/ constraintExpr cexpr)
{
constraintExpr ret;
ret = makeUnaryOpGeneric();
/*@-uniondef@*/
/*@-compdef@*/
ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
ret->data = constraintExprData_unaryExprSetOp (ret->data, UNARYOP_UNDEFINED);
return ret;
/*@=compdef@*/
/*@=uniondef@*/
}
/*@only@*/ /*@notnull@*/ static constraintExpr
constraintExpr_makeUnaryOp (/*@only@*/ constraintExpr cexpr, constraintExprUnaryOpKind Op)
{
constraintExpr ret;
ret = makeUnaryOpGeneric();
ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
ret->data = constraintExprData_unaryExprSetOp (ret->data, Op);
ret->ct = FALSE;
ret->origType = ctype_undefined;
return ret;
}
/*@only@*/ /*@notnull@*/
static constraintExpr constraintExpr_makeUnaryOpExprNode (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
constraintExpr sub;
sub = constraintExpr_makeExprNode (expr);
ret = constraintExpr_makeUnaryOpConstraintExpr(sub);
return ret;
}
/*@only@*/ /*@notnull@*/
static constraintExpr constraintExpr_makeMaxSetConstraintExpr (/*@only@*/ constraintExpr c)
{
constraintExpr ret;
ret = constraintExpr_makeUnaryOp (c, MAXSET);
return ret;
}
/*@only@*/ /*@notnull@*/
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;
}
/*@only@*/
constraintExpr constraintExpr_makeSRefMaxRead( sRef s)
{
return (constraintExpr_makeSRefUnaryOp (s, MAXREAD) );
}
/*@only@*/
constraintExpr constraintExpr_makeSRefMaxset ( sRef s)
{
return (constraintExpr_makeSRefUnaryOp (s, MAXSET) );
}
/*@only@*/
constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr)
{
constraintExpr ret;
ret = constraintExpr_makeUnaryOpConstraintExpr ( cexpr);
switch (lltok_getTok (op))
{
case QMAXSET:
ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
break;
case QMAXREAD:
ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
break;
default:
llfatalbug (message ("Unhandled operation in constraint: %s", lltok_unparse (op)));
}
return ret;
}
/*@only@*/
constraintExpr constraintExpr_makeMaxSetExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeExprNode (expr);
ret = constraintExpr_makeMaxSetConstraintExpr (ret);
llassert (ret != NULL);
return ret;
}
/*@only@*/
constraintExpr constraintExpr_makeMaxReadExpr (exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeUnaryOpExprNode(expr);
ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
return ret;
}
# if 0
/*@only@*/
/*@unused@*/ static constraintExpr constraintExpr_makeMinSetExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeUnaryOpExprNode(expr);
ret->data = constraintExprData_unaryExprSetOp (ret->data, MINSET);
return ret;
}
/*@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
/*@only@*/
constraintExpr constraintExpr_makeValueExpr (/*@exposed@*/ exprNode expr)
{
constraintExpr ret;
ret = constraintExpr_makeExprNode (expr);
return ret;
}
/*@only@*/ /*@notnull@*/
constraintExpr constraintExpr_makeIntLiteral (long i)
{
constraintExpr ret;
constraintTerm t;
ret = constraintExpr_alloc();
ret->kind = term;
ret->data = dmalloc (sizeof *(ret->data) );
t = constraintTerm_makeIntLiteral (i);
ret->data = constraintExprData_termSetTerm (ret->data, t);
ret->ct = FALSE;
ret->origType = ctype_undefined;
return ret;
}
/*
constraintExpr constraintExpr_makeValueInt (int i)
{
return constraintExpr_makeIntLiteral (i);
}
*/
/*@only@*/ /*@notnull@*/
/*@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->binaryOp.expr1 = constraintExpr_undefined;
ret->data->binaryOp.expr2 = constraintExpr_undefined;
return ret;
}
static /*@notnull@*/ /*@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);
ret->ct = FALSE;
ret->origType = ctype_undefined;
return ret;
}
/*@only@*/
constraintExpr constraintExpr_parseMakeBinaryOp (/*@only@*/ constraintExpr expr1, lltok op,/*@only@*/ constraintExpr expr2)
{
constraintExpr ret;
ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
if (lltok_getTok (op) == TPLUS)
{
ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_PLUS);
}
else if (lltok_getTok (op) == TMINUS)
{
ret->data = constraintExprData_binaryExprSetOp(ret->data, BINARYOP_MINUS);
}
else
{
llassert (FALSE);
}
return ret;
}
# if 0
/*@only@*/
/*@unused@*/ static constraintExpr constraintExpr_makeBinaryOpExprNode (/*@exposed@*/ exprNode expr1, /*@exposed@*/ exprNode expr2)
{
constraintExpr ret;
constraintExpr sub1, sub2;
sub1 = constraintExpr_makeTermExprNode (expr1);
sub2 = constraintExpr_makeTermExprNode (expr2);
ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2);
return ret;
}
# endif
static /*@notnull@*/ /*@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, BINARYOP_PLUS);
return ret;
}
/*@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, BINARYOP_MINUS);
return ret;
}
/*@only@*/ constraintExpr constraintExpr_makeSubtractExpr (/*@only@*/ constraintExpr expr, /*@only@*/ constraintExpr addent)
{
constraintExpr ret;
DPRINTF ((message ("Making subtract expression") ) );
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;
DPRINTF ((message ("Doing addTerm simplification") ) );
ret = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_PLUS);
return ret;
}
/*@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, BINARYOP_PLUS);
return ret;
}
/*@only@*/
static cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
{
switch (op)
{
case MAXSET:
return message("maxSet");
case MINSET:
return message("minSet");
case MAXREAD:
return message("maxRead");
case MINREAD:
return message("minRead");
default:
llassert(FALSE);
return message ("<(Unary OP OTHER>");
}
}
/*@only@*/
static cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
{
switch (op)
{
case BINARYOP_PLUS:
return message("+");
case BINARYOP_MINUS:
return message("-");
default:
llassert(FALSE);
return message ("<binary OP Unknown>");
}
}
bool constraintExpr_similar (constraintExpr expr1, constraintExpr expr2)
{
constraintExprKind kind;
llassert (expr1 != NULL);
llassert (expr2 != NULL);
if (expr1->kind != expr2->kind)
return FALSE;
kind = expr1->kind;
switch (kind)
{
case term:
return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
constraintExprData_termGetTerm(expr2->data) );
/*@notreached@*/ break;
case unaryExpr:
if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
return FALSE;
return (constraintExpr_similar (
constraintExprData_unaryExprGetExpr (expr1->data),
constraintExprData_unaryExprGetExpr (expr2->data)
));
case binaryexpr:
if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
return FALSE;
if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr1 (expr1->data),
constraintExprData_binaryExprGetExpr1 (expr2->data)) )
return FALSE;
if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr2 (expr1->data),
constraintExprData_binaryExprGetExpr2 (expr2->data)) )
return FALSE;
else
return TRUE;
/*@notreached@*/
break;
default:
llassert(FALSE);
return FALSE;
}
/*@notreached@*/
return FALSE;
}
bool constraintExpr_same (constraintExpr expr1, constraintExpr expr2)
{
constraintExprKind kind;
llassert (expr1 != NULL);
llassert (expr2 != NULL);
if (expr1->kind != expr2->kind)
return FALSE;
kind = expr1->kind;
switch (kind)
{
case term:
return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
constraintExprData_termGetTerm(expr2->data) );
/*@notreached@*/ break;
case unaryExpr:
if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
return FALSE;
return (constraintExpr_same (
constraintExprData_unaryExprGetExpr (expr1->data),
constraintExprData_unaryExprGetExpr (expr2->data)
));
case binaryexpr:
if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
return FALSE;
if (! constraintExpr_same (constraintExprData_binaryExprGetExpr1 (expr1->data),
constraintExprData_binaryExprGetExpr1 (expr2->data)) )
return FALSE;
if (! constraintExpr_same (constraintExprData_binaryExprGetExpr2 (expr1->data),
constraintExprData_binaryExprGetExpr2 (expr2->data)) )
return FALSE;
else
return TRUE;
/*@notreached@*/ break;
default:
llassert(FALSE);
return FALSE;
}
/*@notreached@*/
BADEXIT;
}
bool
constraintExpr_search (/*@observer@*/ constraintExpr c,
/*@observer@*/ constraintExpr old)
{
bool ret = FALSE;
constraintExprKind kind;
constraintExpr temp;
if (constraintExpr_similar (c, old))
{
DPRINTF (("Found %q", constraintExpr_unparse (old)));
return TRUE;
}
llassert (constraintExpr_isDefined (c) && constraintExpr_isDefined(old) );
if ( !(constraintExpr_isDefined (c) && constraintExpr_isDefined(old) ) )
return FALSE;
kind = c->kind;
switch (kind)
{
case term:
break;
case unaryExpr:
temp = constraintExprData_unaryExprGetExpr (c->data);
ret = ret || constraintExpr_search (temp, old);
break;
case binaryexpr:
temp = constraintExprData_binaryExprGetExpr1 (c->data);
ret = ret || constraintExpr_search(temp, old);
temp = constraintExprData_binaryExprGetExpr2 (c->data);
ret = ret || constraintExpr_search(temp, old);
break;
default:
llassert(FALSE);
}
return ret;
}
/*@only@*/ constraintExpr
constraintExpr_searchandreplace (/*@only@*/ /*@unique@*/ constraintExpr c, /*@temp@*/ constraintExpr old,
/*@temp@*/ constraintExpr newExpr )
{
constraintExprKind kind;
constraintExpr temp;
constraintExpr ret;
llassert (constraintExpr_isDefined (newExpr) && (constraintExpr_isDefined (old) && constraintExpr_isDefined(c) ) );
if (constraintExpr_similar (c, old))
{
ctype newType = ctype_unknown;
ctype cType = ctype_unknown;
ret = constraintExpr_copy (newExpr);
llassert(constraintExpr_isDefined(ret) );
/*drl if newExpr != NULL then ret will != NULL*/
DPRINTF (("Replacing %s with %s in %s",
constraintExpr_unparse (old), constraintExpr_unparse (newExpr),
constraintExpr_unparse (c)));
if (constraintExpr_canGetCType (c) && constraintExpr_canGetCType (newExpr))
{
cType = constraintExpr_getCType(c);
newType = constraintExpr_getCType (newExpr);
if (ctype_match (cType,newType))
{
DPRINTF (("constraintExpr_searchandreplace: replacing "
" %s with type %s with %s with type %s",
constraintExpr_unparse (c), ctype_unparse(cType),
constraintExpr_unparse (newExpr), ctype_unparse(newType)));
ret->ct = TRUE;
ret->origType = cType;
DPRINTF (("Type: %s", ctype_unparse (constraintExpr_getCType (ret))));
}
}
if (constraintExpr_hasMaxSet (c))
{
if (constraintExpr_hasTypeChange (c))
{
fileloc loc = constraintExpr_loc (c);
DPRINTF (("constraintExpr_searchandreplace: encountered "
"MaxSet with changed type %s ",
constraintExpr_unparse (c)));
if (c->kind == unaryExpr)
{
constraintExpr ce = constraintExprData_unaryExprGetExpr (c->data);
DPRINTF (("Its a unary! %s / %s",
ctype_unparse (constraintExpr_getCType (ce)),
ctype_unparse (constraintExpr_getOrigType (ce))));
ret = constraintExpr_adjustMaxSetForCast (ret, constraintExpr_getCType (ce),
constraintExpr_getOrigType (ce),
loc);
}
else
{
/* fix this with a conversation */
DPRINTF (("Types: %s / %s", ctype_unparse (newType), ctype_unparse (cType)));
ret = constraintExpr_adjustMaxSetForCast (ret, constraintExpr_getCType (c),
constraintExpr_getOrigType(c),
loc);
}
}
}
constraintExpr_free (c);
DPRINTF (("ret: %s", constraintExpr_unparse (ret)));
return ret;
}
kind = c->kind;
switch (kind)
{
case term:
break;
case unaryExpr:
DPRINTF (("Making unary expression!"));
temp = constraintExprData_unaryExprGetExpr (c->data);
temp = constraintExpr_copy (temp);
temp = constraintExpr_searchandreplace (temp, old, newExpr);
c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
break;
case binaryexpr:
DPRINTF (("Making binary expression!"));
temp = constraintExprData_binaryExprGetExpr1 (c->data);
temp = constraintExpr_copy (temp);
temp = constraintExpr_searchandreplace (temp, old, newExpr);
c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
temp = constraintExprData_binaryExprGetExpr2 (c->data);
temp = constraintExpr_copy (temp);
temp = constraintExpr_searchandreplace (temp, old, newExpr);
c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
break;
default:
llassert (FALSE);
}
DPRINTF (("ret: %s", constraintExpr_unparse (c)));
return c;
}
/*@notnull@*/ static constraintExpr constraintExpr_simplifyChildren (/*@returned@*/ /*@notnull@*/ constraintExpr c)
{
constraintExprKind kind;
constraintExpr temp;
kind = c->kind;
switch (kind)
{
case term:
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:
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);
break;
default:
llassert(FALSE);
}
return c;
}
constraintExpr constraintExpr_setFileloc (/*@returned@*/ constraintExpr c, fileloc loc) /*@modifies c @*/
{
constraintTerm t;
constraintExpr temp;
llassert(c != NULL);
switch (c->kind)
{
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;
}
static /*@only@*/ constraintExpr constraintExpr_simplifybinaryExpr (/*@only@*/ /*@notnull@*/ constraintExpr c)
{
constraintExpr e1, e2;
constraintExprBinaryOpKind op;
e1 = constraintExprData_binaryExprGetExpr1 (c->data);
e2 = constraintExprData_binaryExprGetExpr2 (c->data);
if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) )
{
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 */
/* the approach is a little Kludgy but seems to work. I should probably use something cleaner at some point ... */
/*@only@*/ constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, /*@only@*/ constraintExpr expr)
{
constraintExpr expr1, expr2;
constraintExprBinaryOpKind op;
llassert(constraintExpr_isDefined (lexpr) && constraintExpr_isDefined (expr) );
if (lexpr->kind != binaryexpr)
return expr;
expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data);
expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data);
op = constraintExprData_binaryExprGetOp (lexpr->data);
expr1 = constraintExpr_copy(expr1);
expr2 = constraintExpr_copy(expr2);
llassert(constraintExpr_isDefined (expr1) && constraintExpr_isDefined (expr2) );
/* 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;
*/
}
static /*@only@*/ constraintExpr constraintExpr_simplifyunaryExpr (/*@only@*/ constraintExpr c)
{
constraintExpr exp;
llassert(constraintExpr_isDefined (c) );
llassert (c->kind == unaryExpr);
DPRINTF ((message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
if ((constraintExprData_unaryExprGetOp (c->data) != MAXSET) &&
(constraintExprData_unaryExprGetOp (c->data) != MAXREAD) )
{
return c;
}
exp = constraintExprData_unaryExprGetExpr (c->data);
exp = constraintExpr_copy(exp);
llassert(constraintExpr_isDefined (exp) );
if (exp->kind == term)
{
constraintTerm cterm;
cterm = constraintExprData_termGetTerm (exp->data);
if (constraintTerm_isStringLiteral(cterm) )
{
cstring val;
val = constraintTerm_getStringLiteral (cterm);
if (constraintExprData_unaryExprGetOp (c->data) == MAXSET)
{
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)
{
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 handle var [] = { , , };
** type syntax I don't think this is sound but it should be good
** enough. The C standard is very confusing about initialization
** -- DRL 7/25/01
*/
if (constraintTerm_isInitBlock(cterm) )
{
constraintExpr temp;
int len;
len = constraintTerm_getInitBlockLength(cterm);
/* -- drl 12/08/2003 : decrementing to fix off by one error */
len--;
temp = constraintExpr_makeIntLiteral (len );
constraintExpr_free(c);
DPRINTF(( message("Changed to %q", constraintExpr_print(temp)
) ));
constraintExpr_free(exp);
return temp;
}
constraintExpr_free(exp);
return c;
}
if (exp->kind != binaryexpr)
{
constraintExpr_free(exp);
return c;
}
if (constraintExprData_binaryExprGetOp (exp->data) == BINARYOP_PLUS )
{
/* if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) ) */
{
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);
temp = constraintExpr_copy (temp);
c = constraintExpr_makeSubtractExpr (c, temp);
DPRINTF ((message ("Done fancy simplification:%s", constraintExpr_unparse (c) ) ) );
}
}
DPRINTF ((message ("constraintExpr_simplifyUnaryExpr: Done simplification:%s", constraintExpr_unparse (c) ) ) );
constraintExpr_free(exp);
return c;
}
/*@only@*/ constraintExpr constraintExpr_simplify (/*@only@*/ constraintExpr c)
{
constraintExprKind kind;
constraintExpr ret;
constraintTerm t;
DPRINTF ((message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) );
llassert ( constraintExpr_isDefined (c) );
if (constraintExpr_isUndefined (c) )
{
return constraintExpr_undefined;
}
ret = constraintExpr_copy(c);
llassert(constraintExpr_isDefined (ret) );
constraintExpr_free(c);
ret = constraintExpr_simplifyChildren (ret);
ret = constraintExpr_combineConstants (ret);
ret = constraintExpr_simplifyChildren (ret);
kind = ret->kind;
switch (kind)
{
case term:
t = constraintExprData_termGetTerm (ret->data);
t = constraintTerm_copy(t);
t = constraintTerm_simplify (t);
ret->data = constraintExprData_termSetTerm (ret->data, t);
break;
case unaryExpr:
ret = constraintExpr_simplifyunaryExpr (ret);
break;
case binaryexpr:
ret = constraintExpr_simplifybinaryExpr (ret);
break;
default:
llassert(FALSE);
}
DPRINTF ((message ("constraintExpr_simplify returning :%s", constraintExpr_unparse (ret) ) ) );
return ret;
}
/*@only@*/
cstring constraintExpr_unparse (/*@temp@*/ constraintExpr ex) /*@*/
{
cstring st;
constraintExprKind kind;
llassert (ex != NULL);
kind = ex->kind;
switch (kind)
{
case term:
if (context_getFlag (FLG_PARENCONSTRAINT) )
{
st = message ("(%q) ", constraintTerm_unparse (constraintExprData_termGetTerm (ex->data)));
}
else
{
st = message ("%q", constraintTerm_unparse (constraintExprData_termGetTerm (ex->data)));
}
break;
case unaryExpr:
st = message ("%q(%q)",
constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data) ),
constraintExpr_unparse (constraintExprData_unaryExprGetExpr (ex->data) )
);
break;
case binaryexpr:
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);
st = message ("error");
}
DPRINTF((message ("constraintExpr_unparse: '%s'",st) ) );
return st;
}
constraintExpr constraintExpr_doSRefFixBaseParam (/*@returned@*/ constraintExpr expr, exprNodeList arglist)
{
constraintTerm Term;
constraintExprKind kind;
constraintExpr expr1, expr2;
constraintExprData data;
llassert (expr != NULL);
data = expr->data;
kind = expr->kind;
switch (kind)
{
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;
case binaryexpr:
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);
data = constraintExprData_binaryExprSetExpr2 (data, expr2);
break;
default:
llassert(FALSE);
data = NULL;
}
return expr;
}
/*
/ *@only@* / constraintExpr constraintExpr_doSRefFixInvarConstraint (/ *@only@* / constraintExpr expr, sRef s, ctype ct)
{
constraintExprKind kind;
constraintExpr expr1, expr2;
constraintExprData data;
llassert (expr != NULL);
data = expr->data;
kind = expr->kind;
switch (kind)
{
case term:
expr = doSRefFixInvarConstraintTerm (expr, s, ct);
break;
case unaryExpr:
expr1 = constraintExprData_unaryExprGetExpr (data);
expr1 = constraintExpr_copy(expr1);
expr1 = constraintExpr_doSRefFixInvarConstraint (expr1, s, ct);
data = constraintExprData_unaryExprSetExpr (data, expr1);
break;
case binaryexpr:
expr1 = constraintExprData_binaryExprGetExpr1 (data);
expr2 = constraintExprData_binaryExprGetExpr2 (data);
expr1 = constraintExpr_copy(expr1);
expr2 = constraintExpr_copy(expr2);
expr1 = constraintExpr_doSRefFixInvarConstraint (expr1, s, ct);
data = constraintExprData_binaryExprSetExpr1 (data, expr1);
expr2 = constraintExpr_doSRefFixInvarConstraint (expr2, s, ct);
data = constraintExprData_binaryExprSetExpr2 (data, expr2);
break;
default:
llassert(FALSE);
data = NULL;
}
return expr;
}
*/
/*@only@*/ constraintExpr constraintExpr_doSRefFixConstraintParam (/*@only@*/ constraintExpr expr, exprNodeList arglist) /*@modifies expr@*/
{
constraintExprKind kind;
constraintExpr expr1, expr2;
constraintExprData data;
llassert (expr != NULL);
data = expr->data;
kind = expr->kind;
switch (kind)
{
case term:
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;
case binaryexpr:
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);
data = constraintExprData_binaryExprSetExpr2 (data, expr2);
break;
default:
llassert(FALSE);
data = NULL;
}
return expr;
}
/*@only@*/ constraintExpr constraintExpr_doFixResult (/*@only@*/ constraintExpr expr, /*@observer@*/ exprNode fcnCall)
{
constraintExprKind kind;
constraintExpr expr1, expr2;
constraintExprData data;
llassert (expr != NULL);
data = expr->data;
kind = expr->kind;
switch (kind)
{
case term:
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;
case binaryexpr:
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);
data = constraintExprData_binaryExprSetExpr2 (data, expr2);
break;
default:
llassert(FALSE);
data = NULL;
}
return expr;
}
cstring constraintExpr_print (constraintExpr expr) /*@*/
{
return constraintExpr_unparse (expr);
}
bool constraintExpr_hasMaxSet (constraintExpr expr) /*@*/
{
cstring t;
t = constraintExpr_unparse(expr);
if (cstring_containsLit(t, "maxSet") != NULL )
{
cstring_free(t);
return (TRUE);
}
else
{
cstring_free(t);
return FALSE;
}
}
/*returns 1 0 -1 like strcmp
1 => expr1 > expr2
0 => expr1 == expr2
-1 => expr1 < expr2
*/
int constraintExpr_compare (constraintExpr expr1, constraintExpr expr2)
{
long value1, value2;
if (constraintExpr_similar (expr1, expr2) )
{
return 0;
}
value1 = constraintExpr_getValue(expr1);
value2 = constraintExpr_getValue(expr2);
if (value1 > value2)
return 1;
if (value1 == value2)
return 0;
else
return -1;
}
long constraintExpr_getValue (constraintExpr expr)
{
llassert (constraintExpr_isDefined(expr) );
llassert (expr->kind == term);
return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data)));
}
bool constraintExpr_canGetValue (constraintExpr expr)
{
llassert ( constraintExpr_isDefined (expr) );
if (constraintExpr_isUndefined (expr) )
{
return FALSE;
}
switch (expr->kind)
{
case term:
return constraintTerm_canGetValue (constraintExprData_termGetTerm (expr->data) );
default:
return FALSE;
}
BADEXIT;
}
fileloc constraintExpr_loc (constraintExpr expr)
{
constraintExpr e;
constraintTerm t;
constraintExprKind kind;
llassert ( constraintExpr_isDefined (expr) );
if (constraintExpr_isUndefined (expr) )
{
return fileloc_undefined;
}
kind = expr->kind;
switch (kind)
{
case term:
t = constraintExprData_termGetTerm (expr->data);
return (constraintTerm_getFileloc (t) );
/*@notreached@*/
break;
case unaryExpr:
e = constraintExprData_unaryExprGetExpr (expr->data);
return (constraintExpr_loc (e) );
/*@notreached@*/
break;
case binaryexpr:
e = constraintExprData_binaryExprGetExpr1 (expr->data);
return (constraintExpr_loc (e) );
/*@notreached@*/
break;
}
llassert (FALSE);
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;
constraintExprData data;
constraintExprKind kind;
constraintExpr ret;
llassert (constraintExpr_isDefined (e) );
data = e->data;
kind = e->kind;
llassert (kind == term);
t = constraintExprData_termGetTerm (data);
llassert (constraintTerm_isDefined (t));
ret = e;
switch (constraintTerm_getKind (t))
{
case CTT_EXPR:
case CTT_INTLITERAL:
break;
case CTT_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;
}
#if 0
/*to be used for structure checking */
/ *@only@* / static constraintExpr
doSRefFixInvarConstraintTerm (/ *@only@* / constraintExpr e, sRef s, ctype ct)
{
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 CTT_EXPR:
DPRINTF((message ("%q @ %q ", constraintTerm_unparse(t),
fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
break;
case CTT_INTLITERAL:
DPRINTF((message (" %q ", constraintTerm_unparse (t)) ));
break;
case CTT_SREF:
/ * evans 2001-07-24: constants should use the original term * /
if (!constraintTerm_canGetValue (t))
{
sRef snew;
DPRINTF ((message("Doing sRef_fixInvarConstraint for %q ",
constraintTerm_unparse (t) ) ));
snew = fixSref (ct, s, constraintTerm_getSRef(t));
ret = constraintExpr_makeTermsRef(snew);
constraintExpr_free (e);
DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
constraintExpr_print (ret) ) ));
/ *@-branchstate@* /
} / *@=branchstate@* /
break;
default:
BADEXIT;
}
return ret;
}
#endif
/*drl moved from constriantTerm.c 5/20/001*/
/*@only@*/ static constraintExpr
doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, /*@observer@*/ /*@temp@*/ exprNodeList arglist)
{
constraintTerm t;
constraintExprData data;
constraintExprKind kind;
constraintExpr ret;
llassert(constraintExpr_isDefined (e) );
data = e->data;
kind = e->kind;
llassert(kind == term);
t = constraintExprData_termGetTerm (data);
llassert (constraintTerm_isDefined(t) );
ret = e;
DPRINTF (("Fixing: %s", constraintExpr_print (e)));
switch (constraintTerm_getKind(t))
{
case CTT_EXPR:
DPRINTF((message ("%q @ %q ", constraintTerm_unparse(t),
fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
break;
case CTT_INTLITERAL:
DPRINTF((message (" %q ", constraintTerm_unparse (t)) ));
break;
case CTT_SREF:
/* evans 2001-07-24: constants should use the original term */
if (!constraintTerm_canGetValue (t))
{
DPRINTF ((message("Doing sRef_fixConstraintParam for %q ",
constraintTerm_unparse (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;
}
#if 0
bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term)
{
if (constraintTerm_hasTerm (expr->term, term) )
return TRUE;
if ((expr->expr) != NULL)
{
return ( constraintExpr_includesTerm (expr->expr, term) );
}
return FALSE;
}
#endif
/*drl added 6/11/01 */
bool constraintExpr_isBinaryExpr (/*@observer@*/ constraintExpr c)
{
llassert(constraintExpr_isDefined (c) );
if ( ! (constraintExpr_isDefined (c) ) )
return FALSE;
if (c->kind == binaryexpr)
return TRUE;
else
return FALSE;
}
/*drl added 8/08/001 */
bool constraintExpr_isTerm (/*@observer@*/ constraintExpr c) /*@*/
{
llassert(constraintExpr_isDefined (c) );
if (c->kind == term)
return TRUE;
else
return FALSE;
}
/*@observer@*/ /*@temp@*/ constraintTerm constraintExpr_getTerm ( /*@temp@*/ /*@observer@*/ constraintExpr c) /*@*/
{
constraintTerm term;
llassert(constraintExpr_isDefined (c) );
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;
os = mstring_create (MAX_DUMP_LINE_LENGTH);
str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
if (! mstring_isDefined(str) )
{
llfatalbug(message("Library file is corrupted") );
}
binaryOp = (constraintExprBinaryOpKind) reader_getInt(&str);
str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
if (! mstring_isDefined(str) )
{
llfatalbug(message("Library file is corrupted") );
}
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);
if (! mstring_isDefined(str) )
{
llfatalbug(message("Library file is corrupted") );
}
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;
llassert(constraintExpr_isDefined(expr) );
DPRINTF((message("constraintExpr_dump:: dumping constraintExpr %s",
constraintExpr_unparse(expr)
) ));
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);
if (! mstring_isDefined(s) )
{
llfatalbug(message("Library file is corrupted") );
}
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;
}
bool constraintExpr_canGetCType (constraintExpr e) /*@*/
{
if (constraintExpr_isUndefined(e))
return FALSE;
if (e->kind == term)
{
return TRUE;
}
else
{
DPRINTF (("constraintExpr_canGetCType: can't get type for %s", constraintExpr_unparse (e)));
return FALSE;
}
}
ctype constraintExpr_getCType (constraintExpr e) /*@*/
{
constraintTerm t;
llassert (constraintExpr_isDefined (e));
llassert (constraintExpr_canGetCType (e));
switch (e->kind)
{
case term:
t = constraintExprData_termGetTerm (e->data);
return (constraintTerm_getCType(t) );
/* assume that a unary expression will be an int ... */
case unaryExpr:
return ctype_unknown; /* was ctype_signedintegral; */
/* drl for just return type of first operand */
case binaryexpr:
return (constraintExpr_getCType (constraintExprData_binaryExprGetExpr1 (e->data)));
default:
BADEXIT;
}
BADEXIT;
}
/* drl add 10-5-001 */
static bool constraintExpr_hasTypeChange (constraintExpr e)
{
llassert(constraintExpr_isDefined(e));
if (constraintExpr_isDefined((e)) && (e->ct == TRUE))
{
return TRUE;
}
if (e->kind == unaryExpr)
{
if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
{
constraintExpr ce = constraintExprData_unaryExprGetExpr(e->data);
DPRINTF (("Unary type change: [%x] %s", ce, constraintExpr_unparse (ce)));
DPRINTF (("Types: %s / %s", ctype_unparse (constraintExpr_getCType (ce)),
ctype_unparse (constraintExpr_getOrigType (ce))));
return (constraintExpr_hasTypeChange(ce));
}
}
return FALSE;
}
/* drl add 10-5-001 */
static ctype constraintExpr_getOrigType (constraintExpr e)
{
llassert (constraintExpr_isDefined (e));
llassert (constraintExpr_hasTypeChange (e));
if (e->ct == TRUE)
{
return e->origType;
}
if (e->kind == unaryExpr)
{
if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
{
constraintExpr ce = constraintExprData_unaryExprGetExpr (e->data);
return (constraintExpr_getOrigType(ce));
}
}
BADEXIT;
}
/*drl added these around 10/18/001*/
static /*@only@*/ constraintExpr
constraintExpr_div (/*@only@*/ constraintExpr e, ctype tfrom, ctype tto, fileloc loc)
{
int sizefrom = ctype_getSize (tfrom);
int sizeto = ctype_getSize (tto);
DPRINTF (("constraintExpr_div: %s", constraintExpr_unparse (e)));
DPRINTF (("Types: %s / %s",
ctype_unparse (tfrom),
ctype_unparse (tto)));
if (sizefrom == -1) {
llbug (message ("constraintExpr_div: type size unknown: %s", ctype_unparse (tfrom)));
}
if (sizeto == -1) {
llbug (message ("constraintExpr_div: type size unknown: %s", ctype_unparse (tto)));
}
if (sizeto == sizefrom)
{
DPRINTF (("Sizes match: %d / %d", sizeto, sizefrom));
; /* Sizes match, a-ok */
}
else
{
float scale = (float) sizefrom / (float) sizeto;
constraintTerm ct;
long val;
float fnewval;
long newval;
llassert (e != NULL);
llassert (e->kind == term);
ct = constraintExprData_termGetTerm (e->data);
DPRINTF (("constraint: %s / %s", constraintExpr_unparse (e), constraintTerm_unparse (ct)));
llassert (constraintTerm_canGetValue (ct));
val = constraintTerm_getValue (ct);
DPRINTF (("Scaling constraints by: %ld * %f", val, scale));
fnewval = ((float) val) * scale;
newval = (long) fnewval;
DPRINTF (("Values: %f / %ld", fnewval, newval));
if ((fnewval - (float) newval) > FLT_EPSILON)
{
voptgenerror (FLG_ALLOCMISMATCH,
message ("Allocated memory is converted to type %s of (size %d), "
"which is not divisible into original allocation of space "
"for %d elements of type %s (size %d)",
ctype_unparse (tto), sizeto,
long_toInt (val), ctype_unparse (tfrom), sizefrom),
loc);
}
constraintTerm_setValue (ct, newval);
}
DPRINTF (("After div: %s", constraintExpr_unparse (e)));
return e;
}
/*@access exprNode@*/
static /*@only@*/ constraintExpr
constraintTerm_simpleDivTypeExprNode (/*@only@*/ constraintExpr e, ctype tfrom, ctype tto, fileloc loc)
{
exprData data;
exprNode t1, t2, expr;
lltok tok;
constraintTerm t;
llassert (constraintExpr_isDefined(e) );
DPRINTF (("constraintTerm_simpleDivTypeExprNode e=%s [%s => %s]", constraintExpr_print(e),
ctype_unparse(tfrom), ctype_unparse (tto)));
t = constraintExprData_termGetTerm (e->data);
expr = constraintTerm_getExprNode (t);
llassert (constraintExpr_isDefined(e));
llassert (exprNode_isDefined(expr));
if (expr->kind == XPR_OP)
{
data = expr->edata;
t1 = exprData_getOpA (data);
t2 = exprData_getOpB (data);
tok = exprData_getOpTok (data);
if (lltok_isMult (tok))
{
/*
** If the sizeof is first, flip them.
*/
llassert (exprNode_isDefined(t1) && exprNode_isDefined(t2));
if (t2->kind == XPR_SIZEOF || t2->kind == XPR_SIZEOFT)
{
exprNode tmp = t1;
t1 = t2;
t2 = tmp;
}
/*drl 3/2/2003 we know this from the fact that it's a
multiplication operation...*/
if (t1->kind == XPR_SIZEOF || t1->kind == XPR_SIZEOFT)
{
ctype multype;
if (t1->kind == XPR_SIZEOFT)
{
multype = qtype_getType (exprData_getType (t1->edata));
}
else
{
exprNode tempE = exprData_getSingle (t1->edata);
multype = exprNode_getType (tempE);
}
DPRINTF (("Here we go sizeof: %s / %s / %s",
ctype_unparse (multype), ctype_unparse (tfrom), ctype_unparse (tto)));
llassert (ctype_isPointer (tfrom));
if (ctype_almostEqual (ctype_makePointer (multype), tto))
{
/* this is a bit sloopy but ... */
constraintExpr_free (e);
DPRINTF (("Sizeof types match okay!"));
return constraintExpr_makeExprNode (t2);
}
else
{
int sizemul = ctype_getSize (multype);
ctype tobase = ctype_baseArrayPtr (tto);
int sizeto = ctype_getSize (tobase);
DPRINTF (("Types: %s / %s / %s",
ctype_unparse (tfrom), ctype_unparse (tto), ctype_unparse (multype)));
voptgenerror (FLG_ALLOCMISMATCH,
message ("Allocated memory is used as a different type (%s) from the sizeof type (%s)",
ctype_unparse (tobase), ctype_unparse (multype)),
loc);
if (sizemul == sizeto)
{
constraintExpr_free (e);
DPRINTF (("Sizeof types match okay!"));
return constraintExpr_makeExprNode (t2);
}
else
{
/* nothing was here */
DPRINTF (("MISMATCHING TYPES!"));
return (constraintExpr_div (constraintExpr_makeExprNode (t2), multype, tto, loc));
}
}
}
else
{
DPRINTF (("NOT A SIZEOF!"));
/* empty */
}
}
else
{
DPRINTF (("Not a mult: %s", constraintExpr_unparse (e)));
}
}
return (constraintExpr_div (e, tfrom, tto, loc));
}
/*@noaccess exprNode@*/
static /*@only@*/ constraintExpr simpleDivType (/*@only@*/ constraintExpr e, ctype tfrom, ctype tto, fileloc loc)
{
DPRINTF (("simpleDiv got %s", constraintExpr_unparse(e)));
DPRINTF (("Types: %s / %s",
ctype_unparse (tfrom),
ctype_unparse (tto)));
llassert (constraintExpr_isDefined(e));
switch (e->kind)
{
case term:
{
constraintTerm t = constraintExprData_termGetTerm (e->data);
DPRINTF (("Term: %s", constraintTerm_unparse (t)));
if (constraintTerm_isExprNode (t))
{
return constraintTerm_simpleDivTypeExprNode (e, tfrom, tto, loc);
/* search for * size of ct and remove */
}
DPRINTF (("Here: %s / %s -> %s", constraintExpr_unparse (e), ctype_unparse (tfrom), ctype_unparse (tto)));
return constraintExpr_div (e, tfrom, tto, loc);
}
case binaryexpr:
{
constraintExpr temp;
temp = constraintExprData_binaryExprGetExpr1 (e->data);
temp = constraintExpr_copy(temp);
temp = simpleDivType (temp, tfrom, tto, loc);
e->data = constraintExprData_binaryExprSetExpr1 (e->data, temp);
temp = constraintExprData_binaryExprGetExpr2 (e->data);
temp = constraintExpr_copy(temp);
temp = simpleDivType (temp, tfrom, tto, loc);
e->data = constraintExprData_binaryExprSetExpr2 (e->data, temp);
DPRINTF (("simpleDiv binaryexpr returning %s ", constraintExpr_unparse(e)));
return e;
}
case unaryExpr:
{
return constraintExpr_div (e, tfrom, tto, loc);
}
default:
BADEXIT;
}
}
static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast (/*@only@*/ constraintExpr e, ctype tfrom,
ctype tto, fileloc loc)
{
DPRINTF (("constraintExpr_adjustMaxSetForCast got %s [%s => %s]", constraintExpr_unparse(e),
ctype_unparse (tfrom), ctype_unparse (tto)));
e = constraintExpr_makeIncConstraintExpr (e);
e = constraintExpr_simplify (e);
e = simpleDivType (e, tfrom, tto, loc);
e = constraintExpr_makeDecConstraintExpr (e);
e = constraintExpr_simplify (e);
DPRINTF (("constraintExpr_adjustMaxSetForCast returning %s ", constraintExpr_unparse(e)));
return e;
}
bool constraintExpr_isConstantOnly (constraintExpr e)
{
DPRINTF (("constraintExpr_isConstantOnly %s ", constraintExpr_unparse(e)));
llassert (constraintExpr_isDefined(e));
switch (e->kind)
{
case term:
{
constraintTerm t = constraintExprData_termGetTerm(e->data);
if (constraintTerm_isConstantOnly (t))
{
return TRUE;
}
else
{
return FALSE;
}
}
case binaryexpr:
{
constraintExpr temp1 = constraintExprData_binaryExprGetExpr1 (e->data);
constraintExpr temp2 = constraintExprData_binaryExprGetExpr2 (e->data);
if (constraintExpr_isConstantOnly(temp1) &&
constraintExpr_isConstantOnly(temp2) )
{
return TRUE;
}
else
{
return FALSE;
}
}
case unaryExpr:
{
constraintExpr temp;
temp = constraintExprData_unaryExprGetExpr (e->data );
if (constraintExpr_isConstantOnly(temp) )
{
return TRUE;
}
else
{
return FALSE;
}
}
default:
BADEXIT;
}
}
syntax highlighted by Code2HTML, v. 0.9.1