*** empty log message ***

[splint.git] / src / constraintTerm.c

diff --git a/src/constraintTerm.c b/src/constraintTerm.c
index f4f27ac3cb6d7dfea0dcf876be03ebdb1652fafb..bbba3b7f9f518eb7ea127f31c53a3cb89b2ebdd8 100644 (file)
--- a/src/constraintTerm.c
+++ b/src/constraintTerm.c
@@ -19,7 +19,7 @@
 
 /*@access exprNode @*/
 
-static bool constraintTerm_isDefined (constraintTerm t)
+bool constraintTerm_isDefined (constraintTerm t)
 {
   return t != NULL;
 }
@@ -73,6 +73,51 @@ bool constraintTerm_isIntLiteral (constraintTerm term)
   return FALSE;
 }
 
+
+bool constraintTerm_isInitBlock (/*@observer@*/ /*@temp@*/ constraintTerm c) /*@*/
+{
+  llassert (c != NULL);
+  if (c->kind == EXPRNODE)
+    {
+      
+      if (exprNode_isInitBlock(c->value.expr) )
+       {
+         return TRUE;
+       }
+    }
+  return FALSE;
+}
+
+
+int constraintTerm_getInitBlockLength (/*@observer@*/ /*@temp@*/ constraintTerm c) /*@*/
+{
+
+  exprNodeList  list;
+  int ret;
+  llassert (c != NULL);
+  llassert (constraintTerm_isInitBlock (c) );
+  llassert (c->kind == EXPRNODE);
+
+  llassert(exprNode_isDefined(c->value.expr) );
+
+  if (exprNode_isUndefined(c->value.expr) )
+    {
+      return 1;
+    }
+
+  if (c->value.expr->edata == exprData_undefined)
+    {
+      return 1;
+    }
+  list = exprData_getArgs(c->value.expr->edata);
+
+  ret = exprNodeList_size(list);
+
+  return ret;  
+}
+
+
+
 bool constraintTerm_isStringLiteral (constraintTerm c) /*@*/
 {
   llassert (c != NULL);
@@ -86,6 +131,8 @@ bool constraintTerm_isStringLiteral (constraintTerm c) /*@*/
   return FALSE;
 }
 
+
+
 cstring constraintTerm_getStringLiteral (constraintTerm c)
 {
   llassert (c != NULL);
@@ -132,7 +179,7 @@ constraintTermType constraintTerm_getKind (constraintTerm t)
   return (t->value.sref);
 }
 
-/*@only@*/ constraintTerm constraintTerm_makeExprNode (/*@depenedent@*/  exprNode e)
+/*@only@*/ constraintTerm constraintTerm_makeExprNode (/*@dependent@*/  exprNode e)
 {
   constraintTerm ret = new_constraintTermExpr();
   ret->loc =  fileloc_copy(exprNode_getfileloc(e));
@@ -205,7 +252,7 @@ static cstring constraintTerm_getName (constraintTerm term)
       s = message ("%s", exprNode_unparse (term->value.expr) );
       break;
     case INTLITERAL:
-      s = message (" %d ", term->value.intlit);
+      s = message (" %d ", (int) term->value.intlit);
       break;
       
     case SREF:
@@ -264,7 +311,7 @@ cstring constraintTerm_print (constraintTerm term)  /*@*/
                   fileloc_unparse (term->loc) );
       break;
     case INTLITERAL:
-      s = message (" %d ", term->value.intlit);
+      s = message (" %d ", (int)term->value.intlit);
       break;
       
     case SREF:
@@ -279,7 +326,7 @@ cstring constraintTerm_print (constraintTerm term)  /*@*/
 }
 
 
-constraintTerm constraintTerm_makeIntLiteral (int i)
+constraintTerm constraintTerm_makeIntLiteral (long i)
 {
   constraintTerm ret = new_constraintTermExpr();
   ret->value.intlit = i;
@@ -291,15 +338,63 @@ constraintTerm constraintTerm_makeIntLiteral (int i)
 bool constraintTerm_canGetValue (constraintTerm term)
 {
   if (term->kind == INTLITERAL)
-    return TRUE;
+    {
+      return TRUE;
+    }
+  else if (term->kind == SREF)
+    {
+      if (sRef_hasValue (term->value.sref))
+       {
+         multiVal mval = sRef_getValue (term->value.sref);
+
+         return multiVal_isInt (mval); /* for now, only try to deal with int values */
+       }
+      else
+       {
+         return FALSE;
+       }
+    }
+  else if (term->kind == EXPRNODE)
+    {
+      return FALSE;
+    }
   else
-    return FALSE;
+    {
+      return FALSE;
+    }
 }
 
-int constraintTerm_getValue (constraintTerm term) 
+long constraintTerm_getValue (constraintTerm term) 
 {
-  llassert (term->kind == INTLITERAL);
-  return term->value.intlit;
+  llassert (constraintTerm_canGetValue (term));
+
+  if (term->kind == INTLITERAL)
+    {
+      return term->value.intlit; 
+    }
+  else if (term->kind == SREF)
+    {
+      if (sRef_hasValue (term->value.sref))
+       {
+         multiVal mval = sRef_getValue (term->value.sref);
+
+         return multiVal_forceInt (mval); /* for now, only try to deal with int values */
+       }
+      else
+       {
+         BADBRANCH;
+       }
+    }
+  else if (term->kind == EXPRNODE)
+    {
+      BADBRANCH;
+    }
+  else
+    {
+      BADBRANCH;
+    }
+
+  BADEXIT;
 }
 
 /* same and similar are similar but not the same*/
@@ -380,45 +475,47 @@ bool constraintTerm_similar (constraintTerm term1, constraintTerm term2)
   
   llassert (term1 !=NULL && term2 !=NULL);
   
-  if ( (term1->kind == INTLITERAL) && (term2->kind == INTLITERAL) )
+  if (constraintTerm_canGetValue (term1) && constraintTerm_canGetValue (term2))
+    /* evans 2001-07-24: was (term1->kind == INTLITERAL) && (term2->kind == INTLITERAL) ) */
     {
-      int t1, t2;
-      llassert (constraintTerm_canGetValue(term1) );
-      t1 = constraintTerm_getValue (term1);
+      long t1, t2;
 
-      llassert (constraintTerm_canGetValue(term2) );
+      t1 = constraintTerm_getValue (term1);
       t2 = constraintTerm_getValue (term2);
-      if (t1 == t2)
-       return TRUE;
-      
-       return FALSE;
+
+      return (t1 == t2);
     }
-    
+  
+  if (constraintTerm_canGetValue (term1) || constraintTerm_canGetValue (term2))
+    {
+      /* evans 2001-07-24: is this right? */ /*@i534@*/
+      return FALSE;
+    }
+
   s1 = constraintTerm_getsRef (term1);
   s2 = constraintTerm_getsRef (term2);
 
-  if ( ! (sRef_isValid(s1) && sRef_isValid(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_similarRelaxed(s1, s2)   || sRef_sameName (s1, s2) )
-   {
-     DPRINTF ((message (" %s and %s are same", constraintTerm_print(term1), constraintTerm_print(term2)  )  ));
-     return TRUE;
-   }
- else
-   {
-     DPRINTF ((message (" %s and %s are not same", constraintTerm_print(term1), constraintTerm_print(term2)  )  ));
-     return FALSE;
-   }     
-    
+  
+  if (sRef_similarRelaxed(s1, s2)   || sRef_sameName (s1, s2) )
+    {
+      DPRINTF ((message (" %s and %s are same", constraintTerm_print(term1), constraintTerm_print(term2)  )  ));
+      return TRUE;
+    }
+  else
+    {
+      DPRINTF ((message (" %s and %s are not same", constraintTerm_print(term1), constraintTerm_print(term2)  )  ));
+      return FALSE;
+    }       
 }
 
 void constraintTerm_dump ( /*@observer@*/ constraintTerm t,  FILE *f)
@@ -480,7 +577,7 @@ void constraintTerm_dump ( /*@observer@*/ constraintTerm t,  FILE *f)
       break;
       
     case INTLITERAL:
-      fprintf (f, "%d\n", t->value.intlit);
+      fprintf (f, "%ld\n", t->value.intlit);
       break;
       
     default:
@@ -497,12 +594,12 @@ void constraintTerm_dump ( /*@observer@*/ constraintTerm t,  FILE *f)
   
   uentry ue;
   
-  char * str;
-  char * os;
+  char *str;
+  char *os;
 
   str = mstring_create (MAX_DUMP_LINE_LENGTH);
   os = str;
-  str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
+  str = fgets (os, MAX_DUMP_LINE_LENGTH, f);
 
   kind = (constraintTermType) reader_getInt(&str);
   str = fgets(os, MAX_DUMP_LINE_LENGTH, f);
@@ -518,7 +615,7 @@ void constraintTerm_dump ( /*@observer@*/ constraintTerm t,  FILE *f)
        
        if (strcmp (term, "Result") == 0 )
          {
-           s = sRef_makeResult();
+           s = sRef_makeResult (ctype_unknown);
          }
        else if (strcmp (term, "Param" ) == 0 )
          {
@@ -533,7 +630,7 @@ void constraintTerm_dump ( /*@observer@*/ constraintTerm t,  FILE *f)
 
            ostr2 = str2;
            t = ctype_undump(&str2) ;
-           s = sRef_makeParam (param, t );
+           s = sRef_makeParam (param, t, stateInfo_makeLoc (g_currentloc));
            free (ostr2);
          }
        else  //This must be an identified that we can search for