+ char * str;
+ char * os;
+
+ os = mstring_create (MAX_DUMP_LINE_LENGTH);
+
+ 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;
+}
+
+
+bool constraintExpr_canGetCType (constraintExpr e) /*@*/
+{
+ if (e->kind == term)
+ {
+ return TRUE;
+ }
+ else
+ {
+ DPRINTF(( message("constraintExpr_canGetCType: can't get type for %s ",
+ constraintExpr_print(e) ) ));
+ return FALSE;
+ }
+}
+
+ctype constraintExpr_getCType (constraintExpr e) /*@*/
+{
+ constraintTerm t;
+
+ 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_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)
+{
+ if (constraintExpr_isDefined((e)) && (e->ct == TRUE) )
+ {
+ return TRUE;
+ }
+
+ if (e->kind == unaryExpr)
+ {
+ if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
+ {
+ constraintExpr ce;
+
+ ce = constraintExprData_unaryExprGetExpr(e->data);
+
+ return (constraintExpr_hasTypeChange(ce) );
+ }
+
+ }
+ return FALSE;
+}
+
+/* drl add 10-5-001 */
+
+static ctype constraintExpr_getOrigType (constraintExpr e)
+{
+
+ llassert(constraintExpr_hasTypeChange(e) );
+
+
+ if (e->ct == TRUE)
+ {
+ return e->origType;
+ }
+
+ if (e->kind == unaryExpr)
+ {
+ if (constraintExprData_unaryExprGetOp (e->data) == MAXSET)
+ {
+ constraintExpr ce;
+
+ 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, /*@unused@*/ ctype ct)
+{
+ return e;
+}
+
+static /*@only@*/ constraintExpr constraintTerm_simpleDivTypeExprNode(/*@only@*/ constraintExpr e, ctype ct)
+{
+ exprData data;
+ exprNode t1, t2, expr;
+ lltok tok;
+ constraintTerm t;
+
+ DPRINTF((
+ message("constraintTerm_simpleDivTypeExprNode e=%s, ct=%s",
+ constraintExpr_print(e), ctype_unparse(ct)
+ )
+ ));
+
+ t = constraintExprData_termGetTerm(e->data);
+
+ expr = constraintTerm_getExprNode(t);
+
+ 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 ((t1->kind == XPR_SIZEOF) || (t1->kind == XPR_SIZEOFT) )
+ {
+ ctype ct2;
+
+ if (t1->kind == XPR_SIZEOFT)
+ {
+ ct2 = qtype_getType (exprData_getType (t1->edata));
+ }
+ else
+ {
+ ct2 = qtype_getType (exprData_getType(exprData_getSingle (t1->edata)->edata ) );
+ }
+ if (ctype_match (ctype_makePointer(ct2), ct) )
+ {
+ /* this is a bit sloopy but ... */
+ constraintExpr_free(e);
+ return constraintExpr_makeExprNode(t2);
+ }
+ }
+
+
+ else if ((t2->kind == XPR_SIZEOF) || (t2->kind == XPR_SIZEOFT) )
+ {
+ ctype ct2;
+
+ if (t2->kind == XPR_SIZEOFT)
+ {
+ ct2 = qtype_getType (exprData_getType (t2->edata));
+ }
+ else
+ {
+ ct2 = qtype_getType (exprData_getType(exprData_getSingle (t2->edata)->edata ) );
+ }
+ if (ctype_match (ctype_makePointer(ct2),ct) )
+ {
+ /* sloopy way to do this... */ /*@i22*/
+ constraintExpr_free(e);
+ return constraintExpr_makeExprNode(t1);
+ }
+ }
+ else
+ {
+ /*empty*/
+ }
+
+ }
+ }
+ return (constraintExpr_div (e, ct) );
+}
+
+static /*@only@*/ constraintExpr simpleDivType (/*@only@*/ constraintExpr e, ctype ct)
+{
+ /*@i333*/
+ DPRINTF(( (message("simpleDiv got %s ", constraintExpr_unparse(e) ) )
+ ));
+
+ switch (e->kind)
+ {
+ case term:
+
+ {
+ constraintTerm t;
+
+ t = constraintExprData_termGetTerm(e->data);
+
+
+ if (constraintTerm_isExprNode (t) )
+ {
+ return constraintTerm_simpleDivTypeExprNode(e, ct);
+
+ /* search for * size of ct and remove */
+ }
+ return constraintExpr_div (e, ct);
+ }
+
+ case binaryexpr:
+ {
+ constraintExpr temp;
+
+ temp = constraintExprData_binaryExprGetExpr1 (e->data);
+ temp = constraintExpr_copy(temp);
+ temp = simpleDivType (temp, ct);
+
+ e->data = constraintExprData_binaryExprSetExpr1 (e->data, temp);
+
+ temp = constraintExprData_binaryExprGetExpr2 (e->data);
+ temp = constraintExpr_copy(temp);
+ temp = simpleDivType (temp, ct);
+ e->data = constraintExprData_binaryExprSetExpr2 (e->data, temp);
+
+ DPRINTF(( (message("simpleDiv binaryexpr returning %s ", constraintExpr_unparse(e) ) )
+ ));
+
+ return e;
+ }
+ case unaryExpr:
+ return constraintExpr_div (e, ct);
+
+ default:
+ BADEXIT;
+ }
+}
+
+static /*@only@*/ constraintExpr constraintExpr_adjustMaxSetForCast(/*@only@*/ constraintExpr e, ctype ct)
+{
+
+ DPRINTF(( (message("constraintExpr_adjustMaxSetForCast got %s ", constraintExpr_unparse(e) ) )
+ ));
+
+ e = constraintExpr_makeIncConstraintExpr(e);
+
+ e = constraintExpr_simplify(e);
+
+
+ e = simpleDivType (e, ct);
+
+ e = constraintExpr_makeDecConstraintExpr(e);
+
+ e = constraintExpr_simplify(e);
+
+ DPRINTF(( (message("constraintExpr_adjustMaxSetForCast returning %s ", constraintExpr_unparse(e) ) )
+ ));
+
+ return e;
+}