X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/dc92450fdc57d377a0b65c158540a5e41b61fa9a..920a3797c23377bfb7332b0c11bda1d708cabb72:/src/constraintTerm.c diff --git a/src/constraintTerm.c b/src/constraintTerm.c index abadf41..eded059 100644 --- a/src/constraintTerm.c +++ b/src/constraintTerm.c @@ -14,17 +14,44 @@ # include "aliasChecks.h" # include "exprNodeSList.h" -//# include "exprData.i" - /*@-czechfcns@*/ //#include "constraintExpr.h" +/*@access exprNode, constraintTermValue @*/ + +/*@unused@*/ static bool constraintTerm_same (constraintTerm term1, constraintTerm term2) ; -constraintTerm new_constraintTermExpr (void) +void constraintTerm_free (/*@only@*/ constraintTerm term) +{ + llassert(constraintTerm_isDefined(term) ); + fileloc_free (term->loc); + + switch (term->kind) + { + case EXPRNODE: + /* we don't free an exprNode*/ + break; + case SREF: + /* sref */ + //sRef_free (term->value.sref); + break; + case INTLITERAL: + /* don't free an int */ + break; + case ERRORBADCONSTRAINTTERMTYPE: + default: + /* type was set incorrectly */ + llcontbug (message("constraintTerm_free type was set incorrectly")); + } + free (term); +} + +/*@only@*/ static/*@out@*/ constraintTerm new_constraintTermExpr (void) { constraintTerm ret; ret = dmalloc (sizeof (* ret ) ); + ret->value.intlit = 0; return ret; } @@ -61,13 +88,14 @@ cstring constraintTerm_getStringLiteral (constraintTerm c) return (cstring_copy ( multiVal_forceString (exprNode_getValue (c->value.expr) ) ) ); } -constraintTerm constraintTerm_simplify (/*@returned@*/ constraintTerm term) +constraintTerm constraintTerm_simplify (/*@returned@*/ constraintTerm term) /*@modifies term@*/ { if (term->kind == EXPRNODE) { if ( exprNode_knownIntValue (term->value.expr ) ) { long int temp; + #warning is this a leak? temp = exprNode_getLongValue (term->value.expr); term->value.intlit = (int)temp; term->kind = INTLITERAL; @@ -81,21 +109,36 @@ fileloc constraintTerm_getFileloc (constraintTerm t) return (fileloc_copy (t->loc) ); } -constraintTerm constraintTerm_makeExprNode (/*@only@*/ exprNode e) +constraintTermType constraintTerm_getKind (constraintTerm t) +{ + llassert (constraintTerm_isDefined(t) ); + + return (t->kind); +} + +/*@exposed@*/ sRef constraintTerm_getSRef (constraintTerm t) +{ + llassert (constraintTerm_isDefined(t) ); + llassert (t->kind == SREF); + + return (t->value.sref); +} + +/*@only@*/ constraintTerm constraintTerm_makeExprNode (/*@dependent@*/ exprNode e) { constraintTerm ret = new_constraintTermExpr(); - ret->loc = exprNode_getfileloc(e); + ret->loc = fileloc_copy(exprNode_getfileloc(e)); ret->value.expr = e; ret->kind = EXPRNODE; ret = constraintTerm_simplify(ret); return ret; } -/*@only@*/ constraintTerm constraintTerm_makesRef (/*@only@*/ sRef s) +/*@only@*/ constraintTerm constraintTerm_makesRef (/*@exposed@*/ sRef s) { constraintTerm ret = new_constraintTermExpr(); ret->loc = fileloc_undefined; - ret->value.sref = s; + ret->value.sref = sRef_saveCopy(s); ret->kind = SREF; ret = constraintTerm_simplify(ret); return ret; @@ -106,20 +149,24 @@ constraintTerm constraintTerm_copy (constraintTerm term) constraintTerm ret; ret = new_constraintTermExpr(); ret->loc = fileloc_copy (term->loc); - ret->value= term->value; + constraintTermValue_copy (ret->value, term->value); ret->kind = term->kind; return ret; } -constraintTerm constraintTerm_setFileloc (/*@returned@*/ constraintTerm term, fileloc loc) +constraintTerm constraintTerm_setFileloc (/*@returned@*/ constraintTerm term, fileloc loc) { llassert(term != NULL); + + if (term->loc != fileloc_undefined) + fileloc_free(term->loc); + term->loc = fileloc_copy(loc); return term; } -cstring constraintTerm_getName (constraintTerm term) +static cstring constraintTerm_getName (constraintTerm term) { cstring s; s = cstring_undefined; @@ -137,52 +184,20 @@ cstring constraintTerm_getName (constraintTerm term) break; case SREF: - s = message ("%s", sRef_unparse (term->value.sref) ); - - break; - } - - return s; -} - -constraintExpr -constraintTerm_doFixResult (constraintExpr e, exprNode fcnCall) -{ - constraintTerm t; - sRef s; - constraintExprData data = e->data; - - constraintExprKind kind = e->kind; - - constraintExpr ret; + s = message ("%q", sRef_unparse (term->value.sref) ); - llassert(kind == term); - - t = constraintExprData_termGetTerm (data); - llassert (t != NULL); - - ret = e; - switch (t->kind) - { - case EXPRNODE: break; - case INTLITERAL: - break; - - case SREF: - s = t->value.sref; - if (s->kind == SK_RESULT) - { - ret = constraintExpr_makeExprNode(fcnCall); - } + default: + BADEXIT; + /*@notreached@*/ break; } - return ret; + return s; } constraintTerm -constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeList arglist) +constraintTerm_doSRefFixBaseParam (/*@returned@*/constraintTerm term, exprNodeList arglist) /*@modifies term@*/ { llassert (term != NULL); @@ -202,50 +217,13 @@ constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeList arglist) // s = message ("%s ", sRef_unparse (term->value.sref) ); break; + default: + BADEXIT; } return term; } -constraintExpr -constraintTerm_doSRefFixConstraintParam (constraintExpr e, exprNodeList arglist) -{ - constraintTerm t; - - constraintExprData data = e->data; - - constraintExprKind kind = e->kind; - - constraintExpr ret; - - llassert(kind == term); - - t = constraintExprData_termGetTerm (data); - llassert (t != NULL); - - ret = e; - switch (t->kind) - { - case EXPRNODE: - /*@i334*/ //wtf - // s = message ("%s @ %s ", exprNode_unparse (term->value.expr), - // fileloc_unparse (term->loc) ); - break; - case INTLITERAL: - // s = message (" %d ", term->value.intlit); - break; - - case SREF: - ret = sRef_fixConstraintParam (t->value.sref, arglist); - - // s = message ("%s ", sRef_unparse (term->value.sref) ); - - break; - } - return ret; - -} - cstring constraintTerm_print (constraintTerm term) /*@*/ { cstring s; @@ -257,7 +235,7 @@ cstring constraintTerm_print (constraintTerm term) /*@*/ { case EXPRNODE: /*@i334*/ //wtf - s = message ("%s @ %s ", exprNode_unparse (term->value.expr), + s = message ("%s @ %q ", exprNode_unparse (term->value.expr), fileloc_unparse (term->loc) ); break; case INTLITERAL: @@ -265,9 +243,11 @@ cstring constraintTerm_print (constraintTerm term) /*@*/ break; case SREF: - s = message ("%s ", sRef_unparseDebug (term->value.sref) ); + s = message ("%q ", sRef_unparseDebug (term->value.sref) ); break; + default: + BADEXIT; } return s; @@ -297,11 +277,8 @@ int constraintTerm_getValue (constraintTerm term) return term->value.intlit; } - - /* same and similar are similar but not the same*/ - -bool constraintTerm_same (constraintTerm term1, constraintTerm term2) +static bool constraintTerm_same (constraintTerm term1, constraintTerm term2) { llassert (term1 !=NULL && term2 !=NULL); @@ -329,17 +306,17 @@ bool constraintTerm_same (constraintTerm term1, constraintTerm term2) } -sRef constraintTerm_getsRef (constraintTerm t) +static /*@exposed@*/ sRef constraintTerm_getsRef (constraintTerm t) { llassert (t != NULL); if (t->kind == EXPRNODE) { - return t->value.expr->sref; + return exprNode_getSref(t->value.expr); } if (t->kind == SREF) { - /*@i34*/ return t->value.sref; + return t->value.sref; } return sRef_undefined; @@ -362,12 +339,12 @@ bool constraintTerm_probSame (constraintTerm term1, constraintTerm term2) if (cstring_equal (s1, s2) ) { - DPRINTF ((message (" %s and %s are same", s1, s2 ) ) ); + DPRINTF ((message (" %q and %q are same", s1, s2 ) ) ); return TRUE; } else { - DPRINTF ((message (" %s and %s are not same", s1, s2 ) ) ); + DPRINTF ((message (" %q and %q are not same", s1, s2 ) ) ); return FALSE; } } @@ -377,7 +354,21 @@ bool constraintTerm_similar (constraintTerm term1, constraintTerm term2) sRef s1, s2; llassert (term1 !=NULL && term2 !=NULL); - + + if ( (term1->kind == INTLITERAL) && (term2->kind == INTLITERAL) ) + { + int t1, t2; + llassert (constraintTerm_canGetValue(term1) ); + t1 = constraintTerm_getValue (term1); + + llassert (constraintTerm_canGetValue(term2) ); + t2 = constraintTerm_getValue (term2); + if (t1 == t2) + return TRUE; + + return FALSE; + } + s1 = constraintTerm_getsRef (term1); s2 = constraintTerm_getsRef (term2); @@ -404,3 +395,171 @@ bool constraintTerm_similar (constraintTerm term1, constraintTerm term2) } } + +void constraintTerm_dump ( /*@observer@*/ constraintTerm t, FILE *f) +{ + fileloc loc; + constraintTermValue value; + constraintTermType kind; + uentry u; + + loc = t->loc; + + value = t->value; + + kind = t->kind; + + fprintf(f, "%d\n", (int) kind); + + switch (kind) + { + + case EXPRNODE: + u = exprNode_getUentry(t->value.expr); + fprintf(f, "%s\n", uentry_rawName (u) ); + break; + + case SREF: + { + sRef s; + + s = t->value.sref; + + if (sRef_isResult (s ) ) + { + fprintf(f, "Result\n"); + } + else if (sRef_isParam (s ) ) + { + int param; + ctype ct; + cstring ctString; + + + ct = sRef_getType (s); + param = sRef_getParam(s); + + ctString = ctype_dump(ct); + + fprintf(f, "Param %s %d\n", ctString, (int) param ); + cstring_free(ctString); + } + else + { + u = sRef_getUentry(s); + fprintf(f, "%s\n", uentry_rawName (u) ); + } + + } + break; + + case INTLITERAL: + fprintf (f, "%d\n", t->value.intlit); + break; + + default: + BADEXIT; + } + +} + + +/*@only@*/ constraintTerm constraintTerm_undump ( FILE *f) +{ + fileloc loc; + constraintTermType kind; + constraintTerm ret; + + uentry ue; + + char * str; + char * os; + + str = mstring_create (MAX_DUMP_LINE_LENGTH); + os = str; + str = fgets(os, MAX_DUMP_LINE_LENGTH, f); + + kind = (constraintTermType) getInt(&str); + str = fgets(os, MAX_DUMP_LINE_LENGTH, f); + + switch (kind) + { + + case SREF: + { + sRef s; + char * term; + term = getWord(&str); + + if (strcmp (term, "Result") == 0 ) + { + s = sRef_makeResult(); + } + else if (strcmp (term, "Param" ) == 0 ) + { + int param; + char *str2, *ostr2; + + ctype t; + + checkChar(&str, ' '); + str2 = getWord(&str); + param = getInt(&str); + + ostr2 = str2; + t = ctype_undump(&str2) ; + s = sRef_makeParam (param, t ); + free (ostr2); + } + else //This must be an identified that we can search for + // in usymTab + { + + ue = usymtab_lookup (term); + s = uentry_getSref(ue); + } + + ret = constraintTerm_makesRef(s); + + free(term); + } + break; + + case EXPRNODE: + { + sRef s; + char * term; + + term = getWord(&str); + //This must be an identifier that we can search for + // in usymTab + + ue = usymtab_lookup (term); + s = uentry_getSref(ue); + ret = constraintTerm_makesRef(s); + + free (term); + } + break; + + + case INTLITERAL: + { + int i; + + i = getInt(&str); + ret = constraintTerm_makeIntLiteral (i); + } + break; + + default: + BADEXIT; + } + free (os); + + return ret; +} + + + +