X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/d46ce6a45c4df08223f6a9aeebb53ba1bd173925..920a3797c23377bfb7332b0c11bda1d708cabb72:/src/constraintTerm.c

diff --git a/src/constraintTerm.c b/src/constraintTerm.c
index 599e0fd..eded059 100644
--- a/src/constraintTerm.c
+++ b/src/constraintTerm.c
@@ -14,14 +14,14 @@
 # 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) ;
+
 void constraintTerm_free (/*@only@*/ constraintTerm term)
 {
   llassert(constraintTerm_isDefined(term) );
@@ -47,10 +47,11 @@ void constraintTerm_free (/*@only@*/ constraintTerm term)
   free (term);
 }
 
-static/*@out@*/ constraintTerm new_constraintTermExpr (void)
+/*@only@*/ static/*@out@*/ constraintTerm new_constraintTermExpr (void)
 {
   constraintTerm ret;
   ret = dmalloc (sizeof (* ret ) );
+  ret->value.intlit = 0;
   return ret;
 }
 
@@ -87,13 +88,14 @@ cstring constraintTerm_getStringLiteral (constraintTerm c)
   return (cstring_copy ( multiVal_forceString (exprNode_getValue (c->value.expr) ) ) );
 }
 
-/*@only@*/ constraintTerm constraintTerm_simplify (/*@returned@*/ constraintTerm term) /*@modifies 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;
@@ -122,7 +124,7 @@ constraintTermType constraintTerm_getKind (constraintTerm t)
   return (t->value.sref);
 }
 
-constraintTerm constraintTerm_makeExprNode (/*@only@*/ exprNode e)
+/*@only@*/ constraintTerm constraintTerm_makeExprNode (/*@dependent@*/ exprNode e)
 {
   constraintTerm ret = new_constraintTermExpr();
   ret->loc =  fileloc_copy(exprNode_getfileloc(e));
@@ -132,11 +134,11 @@ constraintTerm constraintTerm_makeExprNode (/*@only@*/ exprNode e)
   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;
@@ -275,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);
 
@@ -307,7 +306,7 @@ bool constraintTerm_same (constraintTerm term1, constraintTerm term2)
     
 }
 
-/*@exposed@*/ sRef constraintTerm_getsRef (constraintTerm t)
+static /*@exposed@*/ sRef constraintTerm_getsRef (constraintTerm t)
 {
   llassert (t != NULL);
   if (t->kind == EXPRNODE)
@@ -396,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;
+}
+
+
+
+