X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/f5ac53de936db2ac22f6878d5516e00c222a395f..28bf4b0bfd405a2057d865910f8589c54a40f17b:/src/constraintTerm.c diff --git a/src/constraintTerm.c b/src/constraintTerm.c index edfc881..55b2d8b 100644 --- a/src/constraintTerm.c +++ b/src/constraintTerm.c @@ -11,21 +11,53 @@ # include "cgrammar_tokens.h" # include "exprChecks.h" -# include "aliasChecks.h" # include "exprNodeSList.h" -//# include "exprData.i" - /*@-czechfcns@*/ //#include "constraintExpr.h" +/*@access exprNode @*/ + +/*@unused@*/ static bool constraintTerm_same (constraintTerm p_term1, constraintTerm p_term2) ; + +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; +} bool constraintTerm_isIntLiteral (constraintTerm term) { - llassert(term); + llassert(term != NULL); if (term->kind == INTLITERAL) return TRUE; @@ -33,15 +65,38 @@ bool constraintTerm_isIntLiteral (constraintTerm term) return FALSE; } -constraintTerm constraintTerm_simplify (constraintTerm term) +bool constraintTerm_isStringLiteral (constraintTerm c) /*@*/ +{ + llassert (c != NULL); + if (c->kind == EXPRNODE) + { + if (exprNode_knownStringValue(c->value.expr) ) + { + return TRUE; + } + } + return FALSE; +} + +cstring constraintTerm_getStringLiteral (constraintTerm c) +{ + llassert (c != NULL); + llassert (constraintTerm_isStringLiteral (c) ); + llassert (c->kind == EXPRNODE); + + return (cstring_copy ( multiVal_forceString (exprNode_getValue (c->value.expr) ) ) ); +} + +constraintTerm constraintTerm_simplify (/*@returned@*/ constraintTerm term) /*@modifies term@*/ { if (term->kind == EXPRNODE) { if ( exprNode_knownIntValue (term->value.expr ) ) { - int temp; + long int temp; + temp = exprNode_getLongValue (term->value.expr); - term->value.intlit = temp; + term->value.intlit = (int)temp; term->kind = INTLITERAL; } } @@ -53,21 +108,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 (/*@depenedent@*/ 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; } -constraintTerm constraintTerm_makesRef (/*@only@*/ sRef s) +/*@only@*/ constraintTerm constraintTerm_makesRef (/*@temp@*/ /*@observer@*/ 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; @@ -78,20 +148,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 (constraintTerm term, fileloc loc) +constraintTerm constraintTerm_setFileloc (/*@returned@*/ constraintTerm term, fileloc loc) { - llassert(term); + llassert(term != NULL); + + if ( fileloc_isDefined( term->loc ) ) + 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; @@ -109,19 +183,23 @@ cstring constraintTerm_getName (constraintTerm term) break; case SREF: - s = message ("%s", sRef_unparse (term->value.sref) ); + s = message ("%q", sRef_unparse (term->value.sref) ); + break; + default: + BADEXIT; + /*@notreached@*/ break; } return s; } - -constraintTerm constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeList arglist) +constraintTerm +constraintTerm_doSRefFixBaseParam (/*@returned@*/constraintTerm term, exprNodeList arglist) /*@modifies term@*/ { llassert (term != NULL); - + switch (term->kind) { case EXPRNODE: @@ -138,6 +216,8 @@ constraintTerm constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeL // s = message ("%s ", sRef_unparse (term->value.sref) ); break; + default: + BADEXIT; } return term; @@ -154,7 +234,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: @@ -162,9 +242,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; @@ -194,11 +276,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); @@ -226,12 +305,12 @@ bool constraintTerm_same (constraintTerm term1, constraintTerm term2) } -sRef constraintTerm_getsRef (constraintTerm t) +static /*@exposed@*/ sRef constraintTerm_getsRef (constraintTerm t) { - llassert (t); + llassert (t != NULL); if (t->kind == EXPRNODE) { - return t->value.expr->sref; + return exprNode_getSref(t->value.expr); } if (t->kind == SREF) @@ -259,12 +338,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; } } @@ -274,22 +353,36 @@ 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); - if ( ! (s1 && s2) ) + if ( ! (sRef_isValid(s1) && sRef_isValid(s2) ) ) { return FALSE; } - DPRINTF ( (message + DPRINTF( (message ("Comparing srefs for %s and %s ", constraintTerm_print(term1), constraintTerm_print(term2) ) ) ); - if (sRef_sameName (s1, s2) ) + if (sRef_similarRelaxed(s1, s2) || sRef_sameName (s1, s2) ) { DPRINTF ((message (" %s and %s are same", constraintTerm_print(term1), constraintTerm_print(term2) ) )); return TRUE; @@ -302,5 +395,173 @@ 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", cstring_toCharsSafe( 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", cstring_toCharsSafe(ctString), (int) param ); + cstring_free(ctString); + } + else + { + u = sRef_getUentry(s); + fprintf(f, "%s\n", cstring_toCharsSafe(uentry_rawName (u) ) ); + } + + } + break; + + case INTLITERAL: + fprintf (f, "%d\n", t->value.intlit); + break; + + default: + BADEXIT; + } + +} + + +/*@only@*/ constraintTerm constraintTerm_undump ( FILE *f) +{ + 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) reader_getInt(&str); + str = fgets(os, MAX_DUMP_LINE_LENGTH, f); + + switch (kind) + { + + case SREF: + { + sRef s; + char * term; + term = reader_getWord(&str); + + if (strcmp (term, "Result") == 0 ) + { + s = sRef_makeResult(); + } + else if (strcmp (term, "Param" ) == 0 ) + { + int param; + char *str2, *ostr2; + + ctype t; + + reader_checkChar(&str, ' '); + str2 = reader_getWord(&str); + param = reader_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 + { + cstring termStr = cstring_makeLiteralTemp(term); + + ue = usymtab_lookup (termStr); + s = uentry_getSref(ue); + } + + ret = constraintTerm_makesRef(s); + + free(term); + } + break; + + case EXPRNODE: + { + sRef s; + char * term; + cstring termStr; + + term = reader_getWord(&str); + //This must be an identifier that we can search for + // in usymTab + termStr = cstring_makeLiteralTemp(term); + + ue = usymtab_lookup (termStr); + s = uentry_getSref(ue); + ret = constraintTerm_makesRef(s); + + free (term); + } + break; + + + case INTLITERAL: + { + int i; + + i = reader_getInt(&str); + ret = constraintTerm_makeIntLiteral (i); + } + break; + + default: + BADEXIT; + } + free (os); + + return ret; +} + +