Added support for or constraints.

[splint.git] / src / constraintTerm.c

diff --git a/src/constraintTerm.c b/src/constraintTerm.c
index edfc88170b935b0c39d2790d7f8874de762ee0dc..adac9010f72bcfda93eef9954f88f40a91a5e4a8 100644 (file)
--- a/src/constraintTerm.c
+++ b/src/constraintTerm.c
@@ -21,11 +21,17 @@
 //#include "constraintExpr.h"
 
 
+constraintTerm new_constraintTermExpr (void)
+{
+  constraintTerm ret;
+  ret = dmalloc (sizeof (* ret ) );
+  return ret;
+}
 
 
 bool constraintTerm_isIntLiteral (constraintTerm term)
 {
-  llassert(term);
+  llassert(term != NULL);
   
   if (term->kind == INTLITERAL)
     return TRUE;
@@ -33,15 +39,37 @@ 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)
 {
   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;
        }
     }
@@ -63,7 +91,7 @@ constraintTerm constraintTerm_makeExprNode (/*@only@*/ exprNode e)
   return ret;
 }
 
-constraintTerm constraintTerm_makesRef  (/*@only@*/ sRef s)
+/*@only@*/ constraintTerm constraintTerm_makesRef  (/*@only@*/ sRef s)
 {
   constraintTerm ret = new_constraintTermExpr();
   ret->loc =  fileloc_undefined;
@@ -83,9 +111,9 @@ constraintTerm constraintTerm_copy (constraintTerm term)
   return ret;
 }
 
-constraintTerm constraintTerm_setFileloc (constraintTerm term, fileloc loc)
+constraintTerm constraintTerm_setFileloc (/*@returned@*/ constraintTerm term, fileloc loc)
 {
-  llassert(term);
+  llassert(term != NULL);
   term->loc = fileloc_copy(loc);
   return term;
 }
@@ -117,11 +145,47 @@ cstring constraintTerm_getName (constraintTerm term)
   return s;
 }
 
+constraintExpr 
+constraintTerm_doFixResult (constraintExpr e, exprNode fcnCall)
+{
+  constraintTerm t;
+  sRef s;
+  constraintExprData data = e->data;
+  
+  constraintExprKind kind = e->kind;
+  
+  constraintExpr ret;
 
-constraintTerm constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeList arglist)
+  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);
+       }
+      break;
+    }
+  return ret;
+  
+}
+
+constraintTerm 
+constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeList arglist)
 {
   llassert (term != NULL);
-
+  
   switch (term->kind)
     {
     case EXPRNODE:
@@ -143,6 +207,45 @@ constraintTerm constraintTerm_doSRefFixBaseParam (constraintTerm term, exprNodeL
   
 }
 
+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;
@@ -228,7 +331,7 @@ bool constraintTerm_same (constraintTerm term1, constraintTerm term2)
 
 sRef constraintTerm_getsRef (constraintTerm t)
 {
-  llassert (t);
+  llassert (t != NULL);
   if (t->kind == EXPRNODE)
     {
       return t->value.expr->sref;
@@ -236,7 +339,7 @@ sRef constraintTerm_getsRef (constraintTerm t)
 
   if (t->kind == SREF)
     {
-      return t->value.sref;
+      /*@i34*/  return t->value.sref;
     }
 
   return sRef_undefined;
@@ -274,7 +377,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);
 
@@ -289,7 +406,7 @@ bool constraintTerm_similar (constraintTerm term1, constraintTerm 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;
@@ -301,6 +418,3 @@ bool constraintTerm_similar (constraintTerm term1, constraintTerm term2)
    }     
     
 }
-
-
-