X-Git-Url: http://andersk.mit.edu/gitweb/splint.git/blobdiff_plain/795e7f345b576703a99b0c21e56518218528f1f5..35b9a1d988c06908076e3a6eeae55b1147879607:/src/sRef.c

diff --git a/src/sRef.c b/src/sRef.c
index ee5fe0d..3aaf720 100644
--- a/src/sRef.c
+++ b/src/sRef.c
@@ -1,6 +1,6 @@
 /*
-** LCLint - annotation-assisted static program checker
-** Copyright (C) 1994-2001 University of Virginia,
+** Splint - annotation-assisted static program checker
+** Copyright (C) 1994-2003 University of Virginia,
 **         Massachusetts Institute of Technology
 **
 ** This program is free software; you can redistribute it and/or modify it
@@ -17,9 +17,9 @@
 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 ** MA 02111-1307, USA.
 **
-** For information on lclint: lclint-request@cs.virginia.edu
-** To report a bug: lclint-bug@cs.virginia.edu
-** For more information: http://lclint.cs.virginia.edu
+** For information on splint: info@splint.org
+** To report a bug: splint-bug@splint.org
+** For more information: http://www.splint.org
 */
 /*
 ** storeRef.c
@@ -34,7 +34,7 @@
 **
 */
 
-# include "lclintMacros.nf"
+# include "splintMacros.nf"
 # include "basic.h"
 # include "exprChecks.h"
 # include "transferChecks.h"
@@ -62,10 +62,7 @@ static void sRef_updateNullState (sRef p_res, sRef p_other) /*@modifies p_res@*/
 
 static bool sRef_isAllocatedStorage (sRef p_s) /*@*/ ;
 static void sRef_setNullErrorLoc (sRef p_s, fileloc) /*@*/ ;
-
-static void
-  sRef_aliasSetComplete (void (p_predf) (sRef, fileloc), sRef p_s, fileloc p_loc)
-  /*@modifies p_s@*/ ;
+static void sRef_setNullStateN (sRef p_s, nstate p_n) /*@modifies p_s@*/ ;
 
 static int sRef_depth (sRef p_s) /*@*/ ;
 
@@ -78,22 +75,95 @@ static void
 sRef_innerAliasSetCompleteParam (void (p_predf) (sRef, sRef), sRef p_s, sRef p_t)
      /*@modifies p_s@*/ ;
      
-static void
-  sRef_aliasSetCompleteParam (void (p_predf) (sRef, alkind, fileloc), sRef p_s, 
-			      alkind p_kind, fileloc p_loc)
-  /*@modifies p_s@*/ ;
-
 static speckind speckind_fromInt (int p_i);
 static bool sRef_equivalent (sRef p_s1, sRef p_s2);
 static bool sRef_isDeepUnionField (sRef p_s);
 static void sRef_addDeriv (/*@notnull@*/ sRef p_s, /*@notnull@*/ /*@exposed@*/ sRef p_t);
-static /*@dependent@*/ sRef sRef_makeResultType (ctype p_ct) /*@*/ ;
 static bool sRef_checkModify (sRef p_s, sRefSet p_sl) /*@*/ ;
 
+/*
+** If s is definitely null, it has no memory state.
+*/
+
+static void sRef_resetAliasKind (/*@notnull@*/ sRef s) /*@modifies s->aliaskind@*/
+{
+  if (s->nullstate == NS_DEFNULL)
+    {
+      /* s->aliaskind = AK_ERROR; */
+    }
+}
+
+# ifdef DEBUGSPLINT
+extern void sRef_checkCompletelyReasonable (sRef s) /*@*/ 
+{
+  DPRINTF (("Check sRef: [%p] %s / %s", s, sRef_unparse (s),
+	    sRefSet_unparse (sRef_derivedFields (s))));
+
+  if (sRef_isReasonable (s))
+    {
+      sRefSet_elements (s->deriv, el)
+	{
+	  llassert (el != s);
+	  sRef_checkCompletelyReasonable (el);
+	} end_sRefSet_elements ;
+    }
+}
+# endif
+
+/*@falsewhennull@*/ bool sRef_isReasonable (sRef s) /*@*/
+{
+  if (sRef_isValid (s))
+    {
+# ifdef DEBUGSPLINT
+      if (!bool_isReasonable (s->safe)
+	  || !bool_isReasonable (s->modified)
+	  || !bool_isReasonable (s->immut))
+	{
+	  llcontbug (message ("Unreasonable sRef [%p]", s));
+	  return FALSE;
+	}
+
+      if (!sstate_isValid (s->defstate))
+	{
+	  llcontbug (message ("Unreasonable sRef [%p]", s));
+	  return FALSE;
+	}
+
+      if (!nstate_isValid (s->nullstate))
+	{
+	  llcontbug (message ("Unreasonable sRef [%p]", s));
+	  return FALSE;
+	}
+
+      if (!alkind_isValid (s->aliaskind)
+	  || !alkind_isValid (s->oaliaskind))
+	{
+	  llcontbug (message ("Unreasonable sRef [%p]", s));
+	  return FALSE;
+	}
+
+      if (!exkind_isValid (s->expkind)
+	  || !exkind_isValid (s->oexpkind))
+	{
+	  llcontbug (message ("Unreasonable sRef [%p]", s));
+	  return FALSE;
+	}
+# endif
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static /*@nullwhentrue@*/ bool sRef_isUnreasonable (sRef s) /*@*/
+{
+  return (!sRef_isReasonable (s));
+}
+
 static void sRef_checkMutable (/*@unused@*/ sRef s)
 {
-  /*@i235@*/
-  if (sRef_isValid (s) && s->immut)
+  if (sRef_isReasonable (s) && s->immut)
     {
       llcontbug (message ("Modification to sRef marked immutable: %q", 
 			  sRef_unparseFull (s)));
@@ -119,7 +189,8 @@ static void sinfo_free (/*@special@*/ /*@temp@*/ /*@notnull@*/ sRef p_s)
 static /*@null@*/ sinfo sinfo_copy (/*@notnull@*/ sRef p_s) /*@*/ ;
 static void sRef_setPartsFromUentry (sRef p_s, uentry p_ue)
    /*@modifies p_s@*/ ;
-static bool checkDeadState (/*@notnull@*/ sRef p_el, bool p_tbranch, fileloc p_loc);
+static bool checkDeadState (/*@notnull@*/ sRef p_el, /*@null@*/ sRef p_e2, 
+			    bool p_tbranch, fileloc p_loc);
 static /*@dependent@*/ sRef sRef_constructPointerAux (/*@notnull@*/ /*@exposed@*/ sRef p_t) /*@*/ ;
 
 static void 
@@ -183,6 +254,7 @@ static /*@only@*/ cstring sRef_unparseWithArgs (sRef p_s, uentryList p_args);
 static /*@only@*/ cstring sRef_unparseNoArgs (sRef p_s);
 
 static /*@exposed@*/ sRef sRef_findDerivedPointer (sRef p_s);
+static /*@exposed@*/ sRef sRef_findDerivedArrayFetch (/*@notnull@*/ sRef, bool, int, bool) ;
 static /*@exposed@*/ sRef sRef_findDerivedField (/*@notnull@*/ sRef p_rec, cstring p_f);
 static /*@exposed@*/ sRef
   sRef_getDeriv (/*@notnull@*/ /*@returned@*/ sRef p_set, sRef p_guide);
@@ -247,7 +319,7 @@ static void sRef_checkValidAux (sRef s, sRefSet checkedsofar)
 {
   llassert (FALSE);
 
-  if (!sRef_isValid (s)) return;
+  if (!sRef_isReasonable (s)) return;
 
   if (sRefSet_containsSameObject (checkedsofar, s))
     {
@@ -359,12 +431,15 @@ static /*@dependent@*/ /*@notnull@*/ /*@special@*/ sRef
   s->safe = TRUE;
   s->modified = FALSE;
   s->immut = FALSE;
+  s->val = multiVal_undefined;
 
   s->type = ctype_unknown;
   s->defstate = SS_UNKNOWN;
 
   /* start modifications */
   s->bufinfo.bufstate = BB_NOTNULLTERMINATED;
+  s->bufinfo.size = -1; /*@i24 unknown@*/
+  s->bufinfo.len = -1; /*@i24 unknown@*/
   /* end modifications */
 
   s->aliaskind = AK_UNKNOWN;
@@ -431,7 +506,7 @@ sRef_isRecursiveField (sRef s)
 	  fieldname = sRef_getField (s);
 	  base = sRef_getBase (s);
 	  
-	  while (sRef_isValid (base))
+	  while (sRef_isReasonable (base))
 	    {
 	      if (sRef_isField (base))
 		{
@@ -454,8 +529,8 @@ sRef_addDeriv (/*@notnull@*/ sRef s, /*@notnull@*/ /*@exposed@*/ sRef t)
 {
   if (!context_inProtectVars () 
       && !protectDerivs
-      && sRef_isValid (s)
-      && sRef_isValid (t)
+      && sRef_isReasonable (s)
+      && sRef_isReasonable (t)
       && !sRef_isConst (s))
     {
       int sd = sRef_depth (s);
@@ -466,6 +541,16 @@ sRef_addDeriv (/*@notnull@*/ sRef s, /*@notnull@*/ /*@exposed@*/ sRef t)
 	  return;
 	}
 
+      /* This sometimes fails: (evans 2001-07-12)
+      if (sRef_isArrayFetch (t))
+	{
+	  DPRINTF (("Derived fetch: %s / %s / %s",
+		    sRef_unparseFull (s), sRef_unparseFull (t),
+		    sRef_unparseFull (t->info->arrayfetch->arr)));
+	  llassert (t->info->arrayfetch->arr == s);
+	}
+      */
+
       if (sRef_isFileOrGlobalScope (s))
 	{
 	  if (context_inFunctionLike () 
@@ -490,6 +575,10 @@ sRef_addDeriv (/*@notnull@*/ sRef s, /*@notnull@*/ /*@exposed@*/ sRef t)
 		}
 	      else
 		{
+		  DPRINTF (("Add deriv: [%p] %s / [%p] %s",
+			    s, sRef_unparse (s),
+			    t, sRef_unparse (t)));
+		  
 		  s->deriv = sRefSet_insert (s->deriv, t);
 		}
 	    }
@@ -508,7 +597,7 @@ sRef_addDeriv (/*@notnull@*/ sRef s, /*@notnull@*/ /*@exposed@*/ sRef t)
 bool
 sRef_deepPred (bool (predf) (sRef), sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if ((*predf)(s)) return TRUE;
 
@@ -538,7 +627,7 @@ bool sRef_modInFunction (void)
 
 void sRef_setStateFromType (sRef s, ctype ct)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (ctype_isUser (ct))
 	{
@@ -561,38 +650,36 @@ void sRef_setStateFromType (sRef s, ctype ct)
 
 static void sRef_setTypeState (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_setStateFromType (s, s->type);
     }
 }
 
-static bool
-  sRef_hasAliasInfoLoc (sRef s)
+bool sRef_hasAliasInfoLoc (sRef s)
 {
-  return (sRef_isValid (s) && (s->aliasinfo != NULL)
+  return (sRef_isReasonable (s) && (s->aliasinfo != NULL)
 	  && (fileloc_isDefined (s->aliasinfo->loc)));
 }
 
-static /*@falsenull@*/ bool
-sRef_hasStateInfoLoc (sRef s)
+/*@falsewhennull@*/ bool sRef_hasStateInfoLoc (sRef s)
 {
-  return (sRef_isValid (s) && (s->definfo != NULL) 
+  return (sRef_isReasonable (s) && (s->definfo != NULL) 
 	  && (fileloc_isDefined (s->definfo->loc)));
 }
 
-static /*@falsenull@*/ bool
-sRef_hasExpInfoLoc (sRef s)
+/*@falsewhennull@*/ bool sRef_hasExpInfoLoc (sRef s)
 {
-  return (sRef_isValid (s) 
+  return (sRef_isReasonable (s) 
 	  && (s->expinfo != NULL) && (fileloc_isDefined (s->expinfo->loc)));
 }
 
+# if 0
 static /*@observer@*/ /*@unused@*/ stateInfo sRef_getInfo (sRef s, cstring key)
 {
   stateValue sv;
   
-  if (!sRef_isValid (s)) {
+  if (!sRef_isReasonable (s)) {
     return stateInfo_undefined;
   }
   
@@ -605,26 +692,26 @@ static /*@observer@*/ /*@unused@*/ stateInfo sRef_getInfo (sRef s, cstring key)
   
   return stateInfo_undefined;
 }
-
+# endif
 
 static bool
 sRef_hasNullInfoLoc (sRef s)
 {
-  return (sRef_isValid (s) && s->nullinfo != NULL
+  return (sRef_isReasonable (s) && s->nullinfo != NULL
 	  && (fileloc_isDefined (s->nullinfo->loc)));
 }
 
 bool
 sRef_hasAliasInfoRef (sRef s)
 {
-  return (sRef_isValid (s) && (s->aliasinfo != NULL) 
-	  && (sRef_isValid (s->aliasinfo->ref)));
+  return (sRef_isReasonable (s) && (s->aliasinfo != NULL) 
+	  && (sRef_isReasonable (s->aliasinfo->ref)));
 }
 
 static /*@observer@*/ fileloc
 sRef_getAliasInfoLoc (/*@exposed@*/ sRef s)
 {
-  llassert (sRef_isValid (s) && s->aliasinfo != NULL
+  llassert (sRef_isReasonable (s) && s->aliasinfo != NULL
 	    && (fileloc_isDefined (s->aliasinfo->loc)));
   return (s->aliasinfo->loc);
 }
@@ -632,7 +719,7 @@ sRef_getAliasInfoLoc (/*@exposed@*/ sRef s)
 static /*@observer@*/ fileloc
 sRef_getStateInfoLoc (/*@exposed@*/ sRef s)
 {
-  llassert (sRef_isValid (s) && s->definfo != NULL 
+  llassert (sRef_isReasonable (s) && s->definfo != NULL 
 	    && (fileloc_isDefined (s->definfo->loc)));
   return (s->definfo->loc);
 }
@@ -640,7 +727,7 @@ sRef_getStateInfoLoc (/*@exposed@*/ sRef s)
 static /*@observer@*/ fileloc
 sRef_getExpInfoLoc (/*@exposed@*/ sRef s)
 {
-  llassert (sRef_isValid (s) && s->expinfo != NULL 
+  llassert (sRef_isReasonable (s) && s->expinfo != NULL 
 	    && (fileloc_isDefined (s->expinfo->loc)));
   return (s->expinfo->loc);
 }
@@ -648,7 +735,7 @@ sRef_getExpInfoLoc (/*@exposed@*/ sRef s)
 static /*@observer@*/ fileloc
 sRef_getNullInfoLoc (/*@exposed@*/ sRef s)
 {
-  llassert (sRef_isValid (s) && s->nullinfo != NULL 
+  llassert (sRef_isReasonable (s) && s->nullinfo != NULL 
 	    && (fileloc_isDefined (s->nullinfo->loc)));
   return (s->nullinfo->loc);
 }
@@ -656,7 +743,7 @@ sRef_getNullInfoLoc (/*@exposed@*/ sRef s)
 /*@observer@*/ sRef
   sRef_getAliasInfoRef (/*@temp@*/ sRef s)
 {
-  llassert (sRef_isValid (s) && s->aliasinfo != NULL);
+  llassert (sRef_isReasonable (s) && s->aliasinfo != NULL);
   return (s->aliasinfo->ref);
 }
 
@@ -686,22 +773,43 @@ void sRef_clearGlobalScope ()
 }
 
 static bool oldInFunction = FALSE;
+static int nestedScope = 0;
 
 void sRef_setGlobalScopeSafe ()
 {
-  oldInFunction = inFunction;
-  DPRINTF (("leave function"));
+  if (nestedScope == 0)
+    {
+      oldInFunction = inFunction;
+    }
+  
+  nestedScope++;
+  DPRINTF (("leave function safe"));
   inFunction = FALSE;
 }
 
 void sRef_clearGlobalScopeSafe ()
 {
-    inFunction = oldInFunction;
-    DPRINTF (("clear function: %s", bool_unparse (inFunction)));
+  nestedScope--;
+  llassert (nestedScope >= 0);
+  
+  if (nestedScope == 0)
+    {
+      inFunction = oldInFunction;
+    }
+
+  DPRINTF (("clear function: %s", bool_unparse (inFunction)));
 }
 
 void sRef_enterFunctionScope ()
 {
+  /* evans 2001-09-09 - cleanup if we are in a macro! */
+  if (context_inMacro ())
+    {
+      if (inFunction) {
+	sRef_exitFunctionScope ();
+      }
+    }
+
   llassert (!inFunction);
   llassert (sRefTable_isEmpty (allRefs));
   inFunction = TRUE;
@@ -709,12 +817,12 @@ void sRef_enterFunctionScope ()
 }
 
 void sRef_exitFunctionScope ()
-{
-  
+{  
   if (inFunction)
     {
       DPRINTF (("Exit function scope."));
       sRefTable_clear (allRefs);
+      DPRINTF (("Exit function scope done."));
       inFunction = FALSE;
     }
   else
@@ -742,7 +850,7 @@ sRef_fixConj (/*@notnull@*/ sRef s)
 	s = sRef_getConjA (s);
       } while (sRef_isConj (s));
       
-      llassert (sRef_isValid (s));
+      llassert (sRef_isReasonable (s));
       return s; /* don't need to ref */
     }
   else
@@ -757,7 +865,7 @@ sRef_isExternallyVisibleAux (sRef s)
   bool res = FALSE;
   sRef base = sRef_getRootBase (s);
 
-  if (sRef_isValid (base))
+  if (sRef_isReasonable (base))
     {
       res = sRef_isParam (base) || sRef_isFileOrGlobalScope (base) || sRef_isExternal (base);
     }
@@ -777,7 +885,7 @@ sRef_getBaseUentry (sRef s)
   sRef base = sRef_getRootBase (s);
   uentry res = uentry_undefined;
   
-  if (sRef_isValid (base))
+  if (sRef_isReasonable (base))
     {
       switch (base->kind)
 	{
@@ -810,7 +918,7 @@ sRef_updateSref (sRef s)
   sRef ret;
   sRef res;
 
-  if (!sRef_isValid (s)) return sRef_undefined;
+  if (!sRef_isReasonable (s)) return sRef_undefined;
   
   switch (s->kind)
     {
@@ -940,7 +1048,7 @@ sRef_updateSref (sRef s)
 uentry
 sRef_getUentry (sRef s)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   switch (s->kind)
     {
@@ -960,6 +1068,7 @@ sRef_getUentry (sRef s)
 	    return sRef_getUentry (s->info->conj->b);
 	  }
       }
+    case SK_FIELD: /* evans 2002-07-17: added case for SK_FIELD */
     case SK_UNKNOWN:
     case SK_SPECIAL:
       return uentry_undefined;
@@ -970,7 +1079,7 @@ sRef_getUentry (sRef s)
 int
 sRef_getParam (sRef s)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   llassert (s->kind == SK_PARAM);
 
   return s->info->paramno;
@@ -979,12 +1088,12 @@ sRef_getParam (sRef s)
 bool
 sRef_isModified (sRef s)
 {
-    return (!sRef_isValid (s) || s->modified);
+    return (!sRef_isReasonable (s) || s->modified);
 }
 
 void sRef_setModified (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       s->modified = TRUE;
 
@@ -993,10 +1102,8 @@ void sRef_setModified (sRef s)
 	{
 	  sRef base = sRef_getBase (s);
 	  
-	  
 	  llassert (s->kind == SK_FIELD);
 	  
-	  
 	  if (sRef_isPointer (base))
 	    {
 	      base = sRef_getBase (base);
@@ -1031,7 +1138,6 @@ sRef_canModifyVal (sRef s, sRefSet sl)
 bool
 sRef_canModify (sRef s, sRefSet sl)
 {
-  
   if (context_getFlag (FLG_MUSTMOD))
     {
       return (sRef_doModify (s, sl));
@@ -1133,7 +1239,7 @@ bool sRef_checkModifyVal (sRef s, sRefSet sl)
 
 static bool sRef_checkModify (sRef s, sRefSet sl)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   switch (s->kind)
     {
@@ -1258,7 +1364,7 @@ cstring sRef_stateAltVerb (sRef s)
 static 
 bool sRef_doModifyVal (sRef s, sRefSet sl)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   
   switch (s->kind)
@@ -1347,7 +1453,7 @@ bool sRef_doModifyVal (sRef s, sRefSet sl)
 static 
 bool sRef_doModify (sRef s, sRefSet sl)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   
   switch (s->kind)
     {
@@ -1429,8 +1535,8 @@ static /*@exposed@*/ sRef
 {
   llassert (sRef_similar (s1, s2));
   
-  if (!sRef_isValid (s1)) return s1;
-  if (!sRef_isValid (s2)) return s1;
+  if (!sRef_isReasonable (s1)) return s1;
+  if (!sRef_isReasonable (s2)) return s1;
 
   sRef_combineDefState (s1, s2);
   sRef_combineNullState (s1, s2);
@@ -1925,8 +2031,13 @@ sRef_includedBy (sRef small, sRef big)
 bool
 sRef_realSame (sRef s1, sRef s2)
 {
-  if (s1 == s2) return TRUE;  
-  if (sRef_isInvalid (s1) || sRef_isInvalid (s2)) return FALSE;
+  if (s1 == s2) return TRUE;
+  
+  if (sRef_isUnreasonable (s1) 
+      || sRef_isUnreasonable (s2)) 
+    {
+      return FALSE;
+    }
 
   switch (s1->kind)
     {
@@ -2133,6 +2244,7 @@ sRef_closeEnough (sRef s1, sRef s2)
   s is an sRef of a formal paramenter in a function call constraint
   we trys to return a constraint expression derived from the actual parementer of a function call.
 */
+
 /*@only@*/ constraintExpr sRef_fixConstraintParam (/*@observer@*/  sRef s, /*@observer@*/ /*@temp@*/ exprNodeList args)
 {
   constraintExpr ce;
@@ -2144,7 +2256,7 @@ sRef_closeEnough (sRef s1, sRef s2)
     {
     case SK_RESULT:
       {
-	//	s = sRef_saveCopy(s);
+	/* s = sRef_saveCopy(s); */ /*@i523@*/
 	ce = constraintExpr_makeTermsRef (s);
 	return ce;
       }
@@ -2161,7 +2273,7 @@ sRef_closeEnough (sRef s1, sRef s2)
       {
 	sRef temp;
 	temp = (sRef_makePointer (sRef_fixBaseParam (s->info->ref, args)));
-	//temp = sRef_saveCopy(temp);
+	/* temp = sRef_saveCopy(temp); */ /*@i523@*/
 	ce = constraintExpr_makeTermsRef (temp);
 	return ce;
       }
@@ -2197,7 +2309,8 @@ sRef_closeEnough (sRef s1, sRef s2)
     default:
       {
 	sRef temp;
-      llcontbug ((message("Trying to do fixConstraintParam on nonparam, nonglobal: %q for function with arguments %q", sRef_unparse (s), exprNodeList_unparse(args) ) ));
+	llcontbug (message ("Trying to do fixConstraintParam on nonparam, nonglobal: %q for function with arguments %q",
+			    sRef_unparse (s), exprNodeList_unparse(args)));
       temp = sRef_saveCopy(s);
       ce = constraintExpr_makeTermsRef (temp);
 
@@ -2205,9 +2318,6 @@ sRef_closeEnough (sRef s1, sRef s2)
       return ce;
       }
     }
-
-  
-
 }
 
 /*@exposed@*/ sRef
@@ -2252,9 +2362,14 @@ sRef_fixBaseParam (/*@returned@*/ sRef s, exprNodeList args)
 		  (sRef_fixBaseParam (s->info->arrayfetch->arr, args)));
 	}
     case SK_FIELD:
-      return (sRef_makeField (sRef_fixBaseParam (s->info->field->rec, args),
-			      s->info->field->field));
-
+      {
+	sRef res;
+	DPRINTF (("Fix field: %s", sRef_unparseFull (s)));
+	res = sRef_makeField (sRef_fixBaseParam (s->info->field->rec, args),
+			      s->info->field->field);
+	DPRINTF (("Returns: %s", sRef_unparseFull (res)));
+	return res;
+      }
     case SK_PTR:
       return (sRef_makePointer (sRef_fixBaseParam (s->info->ref, args)));
 
@@ -2300,7 +2415,7 @@ sRef_undumpGlobal (char **c)
 	reader_checkChar (c, '@');
 	nullstate = nstate_fromInt (reader_getInt (c));
 
-	ret = sRef_makeGlobal (uid, ctype_unknown);
+	ret = sRef_makeGlobal (uid, ctype_unknown, stateInfo_currentLoc ());
 	sRef_setNullStateN (ret, nullstate);
 	ret->defstate = defstate;
 	return ret;
@@ -2333,8 +2448,7 @@ sRef_undumpGlobal (char **c)
   BADEXIT;
 }
 
-/*@exposed@*/ sRef
-sRef_undump (char **c)
+static /*@exposed@*/ sRef sRef_undumpBody (char **c)
 {
   char p = **c;
 
@@ -2343,11 +2457,13 @@ sRef_undump (char **c)
   switch (p)
     {
     case 'g':
-      return (sRef_makeGlobal (usymId_fromInt (reader_getInt (c)), ctype_unknown));
+      return (sRef_makeGlobal (usymId_fromInt (reader_getInt (c)), 
+			       ctype_unknown, stateInfo_currentLoc ()));
     case 'p':
-      return (sRef_makeParam (reader_getInt (c), ctype_unknown));
+      return (sRef_makeParam (reader_getInt (c), ctype_unknown, 
+			      stateInfo_makeLoc (g_currentloc, SA_DECLARED)));
     case 'r':
-      return (sRef_makeResultType (ctype_undump (c)));
+      return (sRef_makeResult (ctype_undump (c)));
     case 'a':
       {
 	if ((**c >= '0' && **c <= '9') || **c == '-')
@@ -2435,8 +2551,21 @@ sRef_undump (char **c)
   BADEXIT;
 }
 
-/*@only@*/ cstring
-sRef_dump (sRef s)
+/*@exposed@*/ sRef sRef_undump (char **c)
+{
+  sRef res = sRef_undumpBody (c);
+
+  if (reader_optCheckChar (c, '='))
+    {
+      multiVal mv = multiVal_undump (c);
+      sRef_setValue (res, mv);
+      reader_checkChar (c, '=');
+    }
+
+  return res;
+}
+
+static /*@only@*/ cstring sRef_dumpBody (sRef s)
 {
   if (sRef_isInvalid (s))
     {
@@ -2504,8 +2633,22 @@ sRef_dump (sRef s)
   BADEXIT;
 }
 
+/*@only@*/ cstring sRef_dump (sRef s)
+{
+  cstring res = sRef_dumpBody (s);
+
+  if (sRef_hasValue (s))
+    {
+      res = message ("%q=%q=", res, multiVal_dump (sRef_getValue (s)));
+    }
+
+  return res;
+}
+
 cstring sRef_dumpGlobal (sRef s)
 {
+  llassert (!sRef_hasValue (s));
+
   if (sRef_isInvalid (s))
     {
       return (cstring_makeLiteral ("-"));
@@ -2747,9 +2890,7 @@ sRef_unparseWithArgs (sRef s, uentryList args)
 	      return uentry_getName (ue);
 	  }
 
-	return (message ("<bad param: %q / args %q",
-			 sRef_unparseDebug (s),
-			 uentryList_unparse (args)));
+	return (message ("parameter %d", s->info->paramno + 1));
       }
     case SK_ARRAYFETCH:
       if (s->info->arrayfetch->indknown)
@@ -2919,7 +3060,14 @@ sRef_unparseDebug (sRef s)
     case SK_TYPE:
       return (message ("<type %s>", ctype_unparse (s->type)));
     case SK_CONST:
-      return (message ("<const %s>", ctype_unparse (s->type)));
+      if (sRef_hasValue (s))
+	{
+	  return (message ("<const %s=%q>", ctype_unparse (s->type), multiVal_unparse (sRef_getValue (s))));
+	}
+      else
+	{
+	  return (message ("<const %s>", ctype_unparse (s->type)));
+	}
     case SK_RESULT:
       return (message ("<result %s>", ctype_unparse (s->type)));
     case SK_SPECIAL:
@@ -3030,7 +3178,7 @@ sRef_unparseNoArgs (sRef s)
 
   s->kind = SK_UNCONSTRAINED;
   s->info = (sinfo) dmalloc (sizeof (*s->info));
-  s->info->fname = fname;
+  s->info->fname = cstring_copy (fname); /* evans 2002-07-12: this was exposed, causing memory errors */
 
   return (s);
 }
@@ -3044,11 +3192,11 @@ cstring sRef_unconstrainedName (sRef s)
 
 bool sRef_isUnconstrained (sRef s) 
 {
-  return (sRef_isValid(s) && s->kind == SK_UNCONSTRAINED);
+  return (sRef_isReasonable(s) && s->kind == SK_UNCONSTRAINED);
 }
 
 static /*@dependent@*/ /*@notnull@*/ sRef 
-  sRef_makeCvarAux (int level, usymId index, ctype ct)
+  sRef_makeCvarAux (int level, usymId index, ctype ct, /*@only@*/ stateInfo stinfo)
 {
   sRef s = sRef_newRef ();
   
@@ -3089,25 +3237,25 @@ static /*@dependent@*/ /*@notnull@*/ sRef
 
   DPRINTF (("Made cvar: [%p] %s", s, sRef_unparseDebug (s)));
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stinfo); 
   return s;
 }
 
-/*@dependent@*/ sRef sRef_makeCvar (int level, usymId index, ctype ct)
+/*@dependent@*/ sRef sRef_makeCvar (int level, usymId index, ctype ct, /*@only@*/ stateInfo stinfo)
 {
-  return (sRef_makeCvarAux (level, index, ct));
+  return (sRef_makeCvarAux (level, index, ct, stinfo));
 }
 
 int sRef_lexLevel (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef conj;
 
       conj = sRef_fixConj (s);
       s = sRef_getRootBase (conj);
       
-      if (sRef_isValid (s) && s->kind == SK_CVAR)
+      if (sRef_isReasonable (s) && s->kind == SK_CVAR)
 	{
 	  return (s->info->cvar->lexlevel);
 	}
@@ -3117,21 +3265,21 @@ int sRef_lexLevel (sRef s)
 }
 
 sRef
-sRef_makeGlobal (usymId l, ctype ct)
+sRef_makeGlobal (usymId l, ctype ct, /*@only@*/ stateInfo stinfo)
 {
-  return (sRef_makeCvar (globScope, l, ct));
+  return (sRef_makeCvar (globScope, l, ct, stinfo));
 }
 
 void
 sRef_setParamNo (sRef s, int l)
 {
-  llassert (sRef_isValid (s) && s->kind == SK_PARAM);
+  llassert (sRef_isReasonable (s) && s->kind == SK_PARAM);
   s->info->paramno = l;
   llassert (l >= -1);
 }
 
 /*@dependent@*/ sRef
-sRef_makeParam (int l, ctype ct)
+sRef_makeParam (int l, ctype ct, stateInfo stinfo)
 {
   sRef s = sRef_new ();
 
@@ -3145,7 +3293,7 @@ sRef_makeParam (int l, ctype ct)
   /* (probably defined, unless its an out parameter) */
 
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stinfo);
   return s;
 }
 
@@ -3154,7 +3302,7 @@ sRef_isIndexKnown (sRef arr)
 {
   bool res;
 
-  llassert (sRef_isValid (arr));
+  llassert (sRef_isReasonable (arr));
   arr = sRef_fixConj (arr);
   
   llassert (arr->kind == SK_ARRAYFETCH);  
@@ -3167,7 +3315,7 @@ sRef_getIndex (sRef arr)
 {
   int result;
 
-  llassert (sRef_isValid (arr));
+  llassert (sRef_isReasonable (arr));
   arr = sRef_fixConj (arr);
 
   llassert (arr->kind == SK_ARRAYFETCH);  
@@ -3233,7 +3381,8 @@ static bool sRef_isZerothArrayFetch (/*@notnull@*/ sRef s)
 	}
 
       llassert (valueTable_isUndefined (s->state));
-      s->state = context_createValueTable (s);
+      s->state = context_createValueTable (s, 
+					   stateInfo_makeLoc (g_currentloc, SA_CREATED));
       return s;
     }
 }
@@ -3242,10 +3391,10 @@ cstring sRef_getField (sRef s)
 {
   cstring res;
 
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   s = sRef_fixConj (s);
 
-  llassertprint (sRef_isValid (s) && (s->kind == SK_FIELD),
+  llassertprint (sRef_isReasonable (s) && (s->kind == SK_FIELD),
 		 ("s = %s", sRef_unparseDebug (s)));
 
   res = s->info->field->field;
@@ -3328,7 +3477,7 @@ sRef_getRootBaseAux (sRef s, int depth)
 		("Warning: reference base limit exceeded for %q. "
 		 "This either means there is a variable with at least "
 		 "%d indirections from this reference, or "
-		 "there is a bug in LCLint.",
+		 "there is a bug in Splint.",
 		 sRef_unparse (s),
 		 MAXBASEDEPTH),
 		g_currentloc);
@@ -3406,7 +3555,7 @@ sRef_makeObject (ctype o)
   s->info = (sinfo) dmalloc (sizeof (*s->info));
   s->info->object = o;
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
   return s;
 }
 
@@ -3418,20 +3567,20 @@ sRef sRef_makeExternal (sRef t)
 {
   sRef s = sRef_newRef ();
 
-  llassert (sRef_isValid (t));
+  llassert (sRef_isReasonable (t));
 
   s->kind = SK_EXTERNAL;
   s->info = (sinfo) dmalloc (sizeof (*s->info));
   s->type = t->type;
   s->info->ref = t; /* sRef_copy (t); */ /*@i32 was exposed@*/
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_DECLARED));
   return s;
 }
 
 /*@dependent@*/ sRef sRef_makeDerived (/*@exposed@*/ sRef t)
 {
-  if (sRef_isValid (t))
+  if (sRef_isReasonable (t))
     {
       sRef s = sRef_newRef ();
       
@@ -3441,7 +3590,7 @@ sRef sRef_makeExternal (sRef t)
       
       s->type = t->type;
       llassert (valueTable_isUndefined (s->state));
-      s->state = context_createValueTable (s);
+      s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
       return s;
     }
   else
@@ -3459,8 +3608,8 @@ sRef sRef_makeExternal (sRef t)
 void
 sRef_mergeStateQuiet (sRef res, sRef other)
 {
-  llassert (sRef_isValid (res));
-  llassert (sRef_isValid (other));
+  llassert (sRef_isReasonable (res));
+  llassert (sRef_isReasonable (other));
 
   res->modified = res->modified || other->modified;
   res->safe = res->safe && other->safe;
@@ -3519,8 +3668,8 @@ sRef_mergeStateQuietReverse (/*@dependent@*/ sRef res, /*@dependent@*/ sRef othe
 {
   bool changed = FALSE;
 
-  llassert (sRef_isValid (res));
-  llassert (sRef_isValid (other));
+  llassert (sRef_isReasonable (res));
+  llassert (sRef_isReasonable (other));
   sRef_checkMutable (res);
 
   if (res->kind != other->kind)
@@ -3579,6 +3728,7 @@ sRef_mergeStateQuietReverse (/*@dependent@*/ sRef res, /*@dependent@*/ sRef othe
       if (other->defstate != SS_UNKNOWN)
 	{
 	  res->defstate = other->defstate;
+	  res->definfo = stateInfo_update (res->definfo, other->definfo);
 	}
     }
 
@@ -3592,7 +3742,8 @@ sRef_mergeStateQuietReverse (/*@dependent@*/ sRef res, /*@dependent@*/ sRef othe
     }
   else
     {
-      if (sRef_getNullState (other) != NS_UNKNOWN && sRef_getNullState (other) != sRef_getNullState (res))
+      if (sRef_getNullState (other) != NS_UNKNOWN 
+	  && sRef_getNullState (other) != sRef_getNullState (res))
 	{
 	  changed = TRUE;
 	  sRef_updateNullState (res, other);
@@ -3608,7 +3759,7 @@ sRef_mergeStateQuietReverse (/*@dependent@*/ sRef res, /*@dependent@*/ sRef othe
 void 
 sRef_mergeState (sRef res, sRef other, clause cl, fileloc loc)
 {
-  if (sRef_isValid (res) && sRef_isValid (other))
+  if (sRef_isReasonable (res) && sRef_isReasonable (other))
     {
       sRef_mergeStateAux (res, other, cl, FALSE, loc, TRUE);
     }
@@ -3630,7 +3781,7 @@ sRef_mergeState (sRef res, sRef other, clause cl, fileloc loc)
 void 
 sRef_mergeOptState (sRef res, sRef other, clause cl, fileloc loc)
 {
-  if (sRef_isValid (res) && sRef_isValid (other))
+  if (sRef_isReasonable (res) && sRef_isReasonable (other))
     {
       sRef_mergeStateAux (res, other, cl, TRUE, loc, TRUE);
     }
@@ -3655,9 +3806,13 @@ sRef_mergeStateAux (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other,
 		    bool doDerivs)
    /*@modifies res@*/ 
 {
-  llassertfatal (sRef_isValid (res));
-  llassertfatal (sRef_isValid (other));
+  llassertfatal (sRef_isReasonable (res));
+  llassertfatal (sRef_isReasonable (other));
   
+  DPRINTF (("Merge aux: %s / %s",
+	    sRef_unparseFull (res),
+	    sRef_unparseFull (other)));
+
   sRef_checkMutable (res);
   sRef_checkMutable (other);
 
@@ -3710,6 +3865,7 @@ sRef_mergeStateAux (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other,
 	      res->defstate = SS_DEAD;
 	    }
 	  
+	  res->definfo = stateInfo_update (res->definfo, other->definfo);
 	  sRef_clearDerived (other);
 	  sRef_clearDerived (res);
 	}
@@ -3870,7 +4026,7 @@ sRef_mergeStateAux (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other,
 	{
 	  sRef nother = sRef_buildPointer (sRef_getBase (other));
 
-	  if (sRef_isValid (nother))
+	  if (sRef_isReasonable (nother))
 	    {
 	      sRef_copyState (nother, other);
 	      sRef_mergeStateAux (res, nother, cl, opt, loc, doDerivs);
@@ -3888,6 +4044,13 @@ sRef_mergeStateAux (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other,
   ** Merge value table states
   */
 
+
+  /*@i3245@*/
+# if 0
+  /*
+  ** This doesn't do anything.  And its broken too...
+  */
+
   valueTable_elements (res->state, key, sv) 
     {
       stateValue os = valueTable_lookup (other->state, key);
@@ -3907,6 +4070,11 @@ sRef_mergeStateAux (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other,
 	DPRINTF (("Val: %d / %s", val, msg));
       */
   } end_valueTable_elements ; 
+# endif
+
+  DPRINTF (("Merge aux: %s / %s",
+	    sRef_unparseFull (res),
+	    sRef_unparseFull (other)));
 }
 
 static sRefSet
@@ -3922,11 +4090,11 @@ sRef_mergeUnionDerivs (/*@only@*/ sRefSet res,
     {
       sRefSet_allElements (other, el)
 	{
-	  if (sRef_isValid (el))
+	  if (sRef_isReasonable (el))
 	    {
 	      sRef e2 = sRefSet_lookupMember (other, el);
 	      
-	      if (sRef_isValid (e2))
+	      if (sRef_isReasonable (e2))
 		{
 		  sRef_mergeStateAux (el, e2, cl, opt, loc, FALSE);
 		}
@@ -3949,11 +4117,11 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 
   sRefSet_allElements (res, el)
     {
-      if (sRef_isValid (el))
+      if (sRef_isReasonable (el))
 	{
 	  sRef e2 = sRefSet_lookupMember (other, el);
 
-	  if (sRef_isValid (e2))
+	  if (sRef_isReasonable (e2))
 	    {
 	      if (el->defstate == SS_ALLOCATED &&
 		  e2->defstate == SS_PDEFINED)
@@ -3964,13 +4132,16 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 		       el->defstate == SS_PDEFINED)
 		{
 		  el->defstate = SS_ALLOCATED;
+		  el->definfo = stateInfo_update (el->definfo, e2->definfo);
 		  sRef_clearDerived (el);
 		}
 	      else if ((el->defstate == SS_DEAD || sRef_isKept (el)) &&
 		       (e2->defstate == SS_DEFINED && !sRef_isKept (e2)))
 		{
-		  
-		  if (checkDeadState (el, TRUE, loc))
+		  DPRINTF (("Checking dead: %s / %s", sRef_unparseFull (el),
+			    sRef_unparseFull (e2)));
+
+		  if (checkDeadState (el, e2, TRUE, loc))
 		    {
 		      if (sRef_isThroughArrayFetch (el))
 			{
@@ -3982,8 +4153,10 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 	      else if ((e2->defstate == SS_DEAD || sRef_isKept (e2)) &&
 		       (el->defstate == SS_DEFINED && !sRef_isKept (el)))
 		{
-		  
-		  if (checkDeadState (e2, FALSE, loc))
+		  DPRINTF (("Checking dead: %s / %s", sRef_unparseFull (el),
+			    sRef_unparseFull (e2)));
+
+		  if (checkDeadState (e2, el, FALSE, loc))
 		    {
 		      if (sRef_isThroughArrayFetch (el))
 			{
@@ -3997,12 +4170,14 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 		{
 		  DPRINTF (("set pdefined: %s", sRef_unparseFull (el)));
 		  el->defstate = SS_PDEFINED;
+		  el->definfo = stateInfo_update (el->definfo, e2->definfo);
 		}
 	      else if (e2->defstate == SS_DEFINED &&
 		       el->defstate == SS_PDEFINED)
 		{
 		  DPRINTF (("set pdefined: %s", sRef_unparseFull (e2)));
 		  e2->defstate = SS_PDEFINED;
+		  e2->definfo = stateInfo_update (e2->definfo, el->definfo);
 		}
 	      else
 		{
@@ -4027,7 +4202,7 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 		{
 		  sRef sr = sRef_leastCommon (el, e2);
 
-		  if (sRef_isValid (sr))
+		  if (sRef_isReasonable (sr))
 		    {
 		      ret = sRefSet_insert (ret, sr);
 		    }
@@ -4041,16 +4216,18 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 	    }
 	  else /* not defined */
 	    {
-	      (void) checkDeadState (el, TRUE, loc);
+	      DPRINTF (("Checking dead: %s", sRef_unparseFull (el)));
+	      (void) checkDeadState (el, e2, TRUE, loc);
 	    }
 	}
     } end_sRefSet_allElements;
 
   sRefSet_allElements (other, el)
     {
-      if (sRef_isValid (el))
+      if (sRef_isReasonable (el))
 	{
-	  (void) checkDeadState (el, FALSE, loc);
+	  DPRINTF (("Checking dead: %s", sRef_unparseFull (el)));
+	  (void) checkDeadState (el, sRef_undefined, FALSE, loc);
 	}
     } end_sRefSet_allElements;
     
@@ -4062,7 +4239,7 @@ sRef_mergeDerivs (/*@only@*/ sRefSet res, sRefSet other,
 ** Returns TRUE is there is an error.
 */
 
-static bool checkDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
+static bool checkDeadState (/*@notnull@*/ sRef el, sRef e2, bool tbranch, fileloc loc)
 {
   /*
   ** usymtab_isGuarded --- the utab should still be in the
@@ -4079,7 +4256,8 @@ static bool checkDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
 
   
   if ((sRef_isDead (el) || sRef_isKept (el))
-      && !sRef_isDeepUnionField (el) && !sRef_isThroughArrayFetch (el))
+      && !sRef_isDeepUnionField (el) 
+      && !sRef_isThroughArrayFetch (el))
     {
        
       if (!tbranch)
@@ -4105,7 +4283,6 @@ static bool checkDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
 					 ? "kept" : "released")),
 	   loc))
 	{
-	  	  
 	  if (sRef_isKept (el))
 	    {
 	      sRef_showAliasInfo (el);      
@@ -4115,10 +4292,21 @@ static bool checkDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
 	      sRef_showStateInfo (el);
 	    }
 
+	  if (sRef_isValid (e2))
+	    {
+	      if (sRef_isKept (e2))
+		{
+		  sRef_showAliasInfo (e2);      
+		}
+	      else
+		{
+		  sRef_showStateInfo (e2);
+		}
+	    }
+
 	  /* prevent further errors */
 	  el->defstate = SS_UNKNOWN; 
-	  sRef_setAliasKind (el, AK_ERROR, fileloc_undefined);
-	  
+	  sRef_setAliasKind (el, AK_ERROR, fileloc_undefined);	  
 	  return FALSE;
 	}
     }
@@ -4129,14 +4317,13 @@ static bool checkDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
 static void 
 checkDerivDeadState (/*@notnull@*/ sRef el, bool tbranch, fileloc loc)
 {
-  
-  if (checkDeadState (el, tbranch, loc))
+  if (checkDeadState (el, sRef_undefined, tbranch, loc))
     {
       sRefSet_allElements (el->deriv, t)
 	{
-	  if (sRef_isValid (t))
+	  if (sRef_isReasonable (t))
 	    {
-	      	      checkDerivDeadState (t, tbranch, loc);
+	      checkDerivDeadState (t, tbranch, loc);
 	    }
 	} end_sRefSet_allElements;
     }
@@ -4150,11 +4337,11 @@ static sRefSet
 
   sRefSet_allElements (res, el)
     {
-      if (sRef_isValid (el))
+      if (sRef_isReasonable (el))
 	{
 	  sRef e2 = sRefSet_lookupMember (other, el);
 	  
-	  if (sRef_isValid (e2))
+	  if (sRef_isReasonable (e2))
 	    {
 	      if (sRef_isAllocated (el) && !sRef_isAllocated (e2))
 		{
@@ -4179,7 +4366,7 @@ static sRefSet
 	    {
 	      if (!opt)
 		{
-		  		  checkDerivDeadState (el, (cl == FALSECLAUSE), loc);
+		  checkDerivDeadState (el, (cl == FALSECLAUSE), loc);
 		}
 
 	      ret = sRefSet_insert (ret, el);
@@ -4189,7 +4376,7 @@ static sRefSet
   
   sRefSet_allElements (other, el)
     {
-      if (sRef_isValid (el))
+      if (sRef_isReasonable (el))
 	{
 	  if (!sRefSet_member (ret, el))
 	    {
@@ -4212,8 +4399,8 @@ static sRefSet
 
 sRef sRef_makeConj (/*@exposed@*/ /*@returned@*/ sRef a, /*@exposed@*/ sRef b)
 {
-  llassert (sRef_isValid (a));
-  llassert (sRef_isValid (b));
+  llassert (sRef_isReasonable (a));
+  llassert (sRef_isReasonable (b));
       
   if (!sRef_equivalent (a, b))
     {
@@ -4231,6 +4418,8 @@ sRef sRef_makeConj (/*@exposed@*/ /*@returned@*/ sRef a, /*@exposed@*/ sRef b)
       if (a->defstate == b->defstate)
 	{
 	  s->defstate = a->defstate;
+	  s->definfo = stateInfo_update (s->definfo, a->definfo);
+	  s->definfo = stateInfo_update (s->definfo, b->definfo);
 	}
       else
 	{
@@ -4243,7 +4432,7 @@ sRef sRef_makeConj (/*@exposed@*/ /*@returned@*/ sRef a, /*@exposed@*/ sRef b)
       s->aliaskind = alkind_resolve (a->aliaskind, b->aliaskind);
 
       llassert (valueTable_isUndefined (s->state));
-      s->state = context_createValueTable (s);
+      s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_MERGED));
       return s;
     }
   else
@@ -4261,7 +4450,7 @@ sRef_makeUnknown ()
   return s;
 }
 
-static /*@owned@*/ sRef
+static /*@owned@*/ /*@notnull@*/ sRef
 sRef_makeSpecial (speckind sk) /*@*/
 {
   sRef s = sRef_new ();
@@ -4328,31 +4517,22 @@ sRef_makeGlobalMarker (void)
 {
   sRef s = sRef_makeSpecial (SR_GLOBALMARKER);
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createGlobalMarkerValueTable ();
+  s->state = context_createGlobalMarkerValueTable (stateInfo_undefined);
   return s;
 }
 
-static sRef
-sRef_makeResultType (ctype ct)
-{
-  sRef res = sRef_makeResult ();
-
-  res->type = ct;
-  return res;
-}
-
 sRef
-sRef_makeResult ()
+sRef_makeResult (ctype c)
 {
   sRef s = sRef_newRef ();
   
   s->kind = SK_RESULT;
-  s->type = ctype_unknown;
+  s->type = c;
   s->defstate = SS_UNKNOWN; 
   s->aliaskind = AK_UNKNOWN;
   sRef_setNullStateN (s, NS_UNKNOWN);
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_DECLARED));
 
   DPRINTF (("Result: [%p] %s", s, sRef_unparseFull (s)));
   return s;
@@ -4387,7 +4567,7 @@ sRef_isSpecState (sRef s)
 bool
 sRef_isResult (sRef s)
 {
-  return (sRef_isValid (s) && s->kind == SK_RESULT);
+  return (sRef_isReasonable (s) && s->kind == SK_RESULT);
 }
 
 bool
@@ -4405,7 +4585,7 @@ sRef_isGlobalMarker (sRef s)
 usymId
 sRef_getScopeIndex (sRef s)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   llassert (sRef_isCvar (s));
 
   return (s->info->cvar->index);
@@ -4414,7 +4594,7 @@ sRef_getScopeIndex (sRef s)
 void
 sRef_makeSafe (sRef s)
 {
-  if (sRef_isValid (s)) 
+  if (sRef_isReasonable (s)) 
     {
       s->safe = TRUE;
     }
@@ -4423,7 +4603,7 @@ sRef_makeSafe (sRef s)
 void
 sRef_makeUnsafe (sRef s)
 {
-  if (sRef_isValid (s)) 
+  if (sRef_isReasonable (s)) 
     {
       s->safe = FALSE;
     }
@@ -4437,10 +4617,11 @@ sRef_makeUnsafe (sRef s)
 {
   if (sRef_isInvalid (s)) return (cstring_undefined);
 
-  return (message ("[%d] %q - %q [%s] { %q } < %q >", 
-		   (int) s,
+  return (message ("[%p] %q - %q { %q } [%s] { %q } < %q >", 
+		   s,
 		   sRef_unparseDebug (s), 
 		   sRef_unparseState (s),
+		   stateInfo_unparse (s->definfo),
 		   exkind_unparse (s->oexpkind),
 		   sRefSet_unparseDebug (s->deriv),
 		   valueTable_unparse (s->state)));
@@ -4452,7 +4633,7 @@ sRef_makeUnsafe (sRef s)
 
   st = message ("%q:", sRef_unparseFull (s));
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRefSet_allElements (s->deriv, el)
 	{
@@ -4526,10 +4707,17 @@ bool sRef_hasNoStorage (sRef s)
 
 bool sRef_isStrictReadable (sRef s)
 {
-  return (ynm_toBoolStrict (sRef_isReadable (s)));
+  return (ynm_toBoolStrict (sRef_isValidLvalue (s)));
 }
 
-ynm sRef_isReadable (sRef s)
+/*
+** Is this what is does?
+** Returns YES if s can be used as an rvalue,
+**         MAYBE if its not clear
+**         NO if s cannot be safely used as an rvalue.
+*/
+
+ynm sRef_isValidLvalue (sRef s)
 {
   sstate ss;
 
@@ -4539,9 +4727,9 @@ ynm sRef_isReadable (sRef s)
   
   if (sRef_isConj (s) && s->defstate == SS_UNKNOWN)
     {
-      if (ynm_toBoolStrict (sRef_isReadable (sRef_getConjA (s))))
+      if (ynm_toBoolStrict (sRef_isValidLvalue (sRef_getConjA (s))))
 	{
-	  if (ynm_toBoolStrict (sRef_isReadable (sRef_getConjB (s))))
+	  if (ynm_toBoolStrict (sRef_isValidLvalue (sRef_getConjB (s))))
 	    {
 	      return YES;
 	    }
@@ -4549,7 +4737,7 @@ ynm sRef_isReadable (sRef s)
 	}
       else
 	{
-	  if (ynm_toBoolStrict (sRef_isReadable (sRef_getConjB (s))))
+	  if (ynm_toBoolStrict (sRef_isValidLvalue (sRef_getConjB (s))))
 	    {
 	      return MAYBE;
 	    }
@@ -4573,9 +4761,9 @@ ynm sRef_isReadable (sRef s)
 			    || ss == SS_FIXED 
 			    || ss == SS_RELDEF 
 			    || ss == SS_PDEFINED 
-			    || ss == SS_PARTIAL
+			    || ss == SS_PARTIAL 
 			    || ss == SS_SPECIAL
-			    || ss == SS_ALLOCATED
+			    || ss == SS_ALLOCATED 
 			    || ss == SS_KILLED /* evans 2001-05-26: added this for killed globals */
 			    || ss == SS_UNKNOWN));
     }
@@ -4592,7 +4780,7 @@ static /*@exposed@*/ sRef whatUndefined (/*@exposed@*/ sRef fref, int depth)
 		("Warning: check definition limit exceeded, checking %q. "
 		 "This either means there is a variable with at least "
 		 "%d indirections apparent in the program text, or "
-		 "there is a bug in LCLint.",
+		 "there is a bug in Splint.",
 		 sRef_unparse (fref),
 		 MAXDEPTH),
 		g_currentloc);
@@ -4654,7 +4842,7 @@ static /*@exposed@*/ sRef whatUndefined (/*@exposed@*/ sRef fref, int depth)
 		    {
 		      sRef wdef = whatUndefined (fldref, depth + 1);
 
-		      if (sRef_isValid (wdef))
+		      if (sRef_isReasonable (wdef))
 			{
 			  return wdef;
 			}
@@ -4720,7 +4908,7 @@ static bool checkDefined (/*@temp@*/ sRef sr)
 
 bool sRef_isReallyDefined (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (sRef_isAnyDefined (s))
 	{
@@ -4746,7 +4934,7 @@ bool sRef_isReallyDefined (sRef s)
 
 void sRef_showNotReallyDefined (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (sRef_isAnyDefined (s))
 	{
@@ -4759,7 +4947,7 @@ void sRef_showNotReallyDefined (sRef s)
 	      /*@-temptrans@*/ /* the result of whatUndefined is lost */
 	      sRef ref = whatUndefined (s, 0);
 
-	      llassert (sRef_isValid (ref));
+	      llassert (sRef_isReasonable (ref));
 
 	      if (ref != s)
 		{
@@ -4808,21 +4996,21 @@ void sRef_clearAliasState (sRef s, fileloc loc)
 void sRef_setAliasKindComplete (sRef s, alkind kind, fileloc loc)
 {
   sRef_checkMutable (s);  
-  sRef_aliasSetCompleteParam (sRef_setAliasKind, s, kind, loc);
+  sRef_aliasSetCompleteAlkParam (sRef_setAliasKind, s, kind, loc); 
 }
 
 void sRef_setAliasKind (sRef s, alkind kind, fileloc loc)
 {
   sRef_checkMutable (s);  
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_clearDerived (s);
 
       if ((kind != s->aliaskind && kind != s->oaliaskind)
 	  && fileloc_isDefined (loc))
 	{
-	  s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+	  s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, stateAction_fromAlkind (kind), loc);
 	}
       
       s->aliaskind = kind;
@@ -4833,7 +5021,7 @@ void sRef_setOrigAliasKind (sRef s, alkind kind)
 {
   sRef_checkMutable (s);  
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       s->oaliaskind = kind;
     }
@@ -4841,7 +5029,7 @@ void sRef_setOrigAliasKind (sRef s, alkind kind)
 
 exkind sRef_getExKind (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       return (s->expkind);
     }
@@ -4853,7 +5041,7 @@ exkind sRef_getExKind (sRef s)
 
 exkind sRef_getOrigExKind (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       return (s->oexpkind);
     }
@@ -4890,11 +5078,11 @@ void sRef_setExKind (sRef s, exkind exp, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (s->expkind != exp)
 	{
-	  s->expinfo = stateInfo_updateLoc (s->expinfo, loc);
+	  s->expinfo = stateInfo_updateLoc (s->expinfo, stateAction_fromExkind (exp), loc);
 	}
       
       s->expkind = exp;
@@ -4910,7 +5098,7 @@ static void sRef_copyRealDerived (sRef s1, sRef s2)
   DPRINTF (("Copy real: %s / %s", sRef_unparse (s1), sRef_unparse (s2)));
   sRef_checkMutable (s1);
 
-  if (sRef_isValid (s1) && sRef_isValid (s2))
+  if (sRef_isReasonable (s1) && sRef_isReasonable (s2))
     {
       sRef sb = sRef_getRootBase (s1);
 
@@ -4918,7 +5106,7 @@ static void sRef_copyRealDerived (sRef s1, sRef s2)
 
       sRefSet_allElements (s2->deriv, el)
 	{
-	  if (sRef_isValid (el))
+	  if (sRef_isReasonable (el))
 	    {
 	      sRef rb = sRef_getRootBase (el);
 	      
@@ -4926,7 +5114,7 @@ static void sRef_copyRealDerived (sRef s1, sRef s2)
 		{
 		  sRef fb = sRef_fixDirectBase (el, s1);
 		  
-		  if (sRef_isValid (fb))
+		  if (sRef_isReasonable (fb))
 		    {
 		      sRef_copyRealDerived (fb, el);
 		      sRef_addDeriv (s1, fb);
@@ -4951,14 +5139,10 @@ void sRef_setUndefined (sRef s, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       s->defstate = SS_UNDEFINED;
-
-      if (fileloc_isDefined (loc))
-	{
-	  s->definfo = stateInfo_updateLoc (s->definfo, loc);
-	}
+      s->definfo = stateInfo_updateLoc (s->definfo, SA_UNDEFINED, loc);
 
       sRef_clearDerived (s);
     }
@@ -4969,23 +5153,36 @@ static void sRef_setDefinedAux (sRef s, fileloc loc, bool clear)
   sRef_checkMutable (s);
   if (sRef_isInvalid (s)) return;
 
-  if (s->defstate != SS_DEFINED && fileloc_isDefined (loc))
-    {
-      s->definfo = stateInfo_updateLoc (s->definfo, loc);
-    }
-  
+  DPRINTF (("Set defined: %s", sRef_unparseFull (s)));
+
+  s->definfo = stateInfo_updateLoc (s->definfo, SA_DEFINED, loc);  
   s->defstate = SS_DEFINED;
   
+  DPRINTF (("Set defined: %s", sRef_unparseFull (s)));
+
   /* e.g., if x is allocated, *x = 3 defines x */
   
   if (s->kind == SK_PTR)
     {
       sRef p = s->info->ref;
-      
-      if (p->defstate == SS_ALLOCATED)
+      sRef arr;
+
+      if (p->defstate == SS_ALLOCATED
+	  || p->defstate == SS_SPECIAL) /* evans 2001-07-12: shouldn't need this */
 	{
 	  sRef_setDefinedAux (p, loc, clear);
 	}
+
+      /* 
+      ** Defines a[0] also:
+      */
+
+      arr = sRef_findDerivedArrayFetch (p, FALSE, 0, FALSE);
+
+      if (sRef_isReasonable (arr))
+	{
+	  sRef_setDefinedAux (arr, loc, clear);
+	}
     }
   else if (s->kind == SK_ARRAYFETCH) 
     {
@@ -4994,11 +5191,12 @@ static void sRef_setDefinedAux (sRef s, fileloc loc, bool clear)
 	{
 	  sRef p = s->info->arrayfetch->arr;
 	  sRef ptr = sRef_constructPointer (p);
-	  
-	  if (sRef_isValid (ptr))
+
+	  if (sRef_isReasonable (ptr))
 	    {
 	      if (ptr->defstate == SS_ALLOCATED 
-		  || ptr->defstate == SS_UNDEFINED)
+		  || ptr->defstate == SS_UNDEFINED
+		  || ptr->defstate == SS_SPECIAL) /* evans 2001-07-12: shouldn't need this */
 		{
 		  sRef_setDefinedAux (ptr, loc, clear);
 		}
@@ -5008,7 +5206,8 @@ static void sRef_setDefinedAux (sRef s, fileloc loc, bool clear)
 	    {
 	      ;
 	    }
-	  else if (p->defstate == SS_ALLOCATED || p->defstate == SS_PDEFINED)
+	  else if (p->defstate == SS_ALLOCATED || p->defstate == SS_PDEFINED
+		   || p->defstate == SS_SPECIAL) /* evans 2001-07-12: shouldn't need this */
 	    {
 	      p->defstate = SS_DEFINED;
 	    }
@@ -5021,7 +5220,7 @@ static void sRef_setDefinedAux (sRef s, fileloc loc, bool clear)
     {
       sRef parent = s->info->field->rec;
       
-      if (sRef_isValid (parent))
+      if (sRef_isReasonable (parent))
 	{
 	  if (ctype_isUnion (ctype_realType (parent->type)))
 	    {
@@ -5046,7 +5245,18 @@ static void sRef_setDefinedAux (sRef s, fileloc loc, bool clear)
   if (clear)
     {
       sRef_clearDerived (s);
-    }  
+    } 
+  else
+    {
+      /* evans 2001-07-12: need to define the derived references */
+      sRefSet_elements (s->deriv, el)
+	{
+	  llassert (sRef_isReasonable (el));
+	  el->defstate = SS_DEFINED;
+	} end_sRefSet_elements ;
+    }
+  
+  DPRINTF (("Set defined: %s", sRef_unparseFull (s)));
 }
 
 static void sRef_setPartialDefined (sRef s, fileloc loc)
@@ -5069,6 +5279,29 @@ void sRef_setDefinedComplete (sRef s, fileloc loc)
   sRef_innerAliasSetComplete (sRef_setDefined, s, loc);
 }
 
+void sRef_setDefinedCompleteDirect (sRef s, fileloc loc)
+{
+  sRefSet aliases;
+  
+  aliases = usymtab_allAliases (s);
+  DPRINTF (("Set defined complete: %s", sRef_unparseFull (s)));
+  DPRINTF (("All aliases: %s", sRefSet_unparseFull (aliases)));
+  
+  sRef_setDefined (s, loc);
+
+  sRefSet_realElements (aliases, current)
+    {
+      if (sRef_isReasonable (current))
+	{
+	  current = sRef_updateSref (current);
+	  sRef_setDefined (current, loc);
+	}
+    } end_sRefSet_realElements;
+  
+  sRefSet_free (aliases);
+  sRef_innerAliasSetComplete (sRef_setDefined, s, loc);
+}
+
 void sRef_setDefined (sRef s, fileloc loc)
 {
   sRef_checkMutable (s);
@@ -5098,7 +5331,7 @@ static bool sRef_isDeepUnionField (sRef s)
 
 bool sRef_isUnionField (sRef s)
 {
-  if (sRef_isValid (s) && s->kind == SK_FIELD)
+  if (sRef_isReasonable (s) && s->kind == SK_FIELD)
     {
       /*
        ** defining one field of a union defines the union
@@ -5106,7 +5339,7 @@ bool sRef_isUnionField (sRef s)
       
       sRef base = s->info->field->rec;
 
-      if (sRef_isValid (base))
+      if (sRef_isReasonable (base))
 	{
 	  return (ctype_isUnion (ctype_realType (base->type)));
 	}
@@ -5118,7 +5351,7 @@ bool sRef_isUnionField (sRef s)
 void sRef_setPdefined (sRef s, fileloc loc)
 {
   sRef_checkMutable (s);
-  if (sRef_isValid (s) && !sRef_isPartial (s))
+  if (sRef_isReasonable (s) && !sRef_isPartial (s))
     {
       sRef base = sRef_getBaseSafe (s);
 
@@ -5127,22 +5360,18 @@ void sRef_setPdefined (sRef s, fileloc loc)
 	  return;
 	}
       
-      if (s->defstate != SS_PDEFINED && fileloc_isDefined (loc))
-	{
-	  s->definfo = stateInfo_updateLoc (s->definfo, loc);
-	}
-
-      DPRINTF (("set pdefined: %s", sRef_unparseFull (s)));
+      s->definfo = stateInfo_updateLoc (s->definfo, SA_PDEFINED, loc);
       s->defstate = SS_PDEFINED;
       
       /* e.g., if x is allocated, *x = 3 defines x */
       
-      while (sRef_isValid (base) && sRef_isKnown (base))
+      while (sRef_isReasonable (base) && sRef_isKnown (base))
 	{
 	  if (base->defstate == SS_DEFINED)
 	    { 
 	      sRef nb;
 	      
+	      DPRINTF (("set pdefined: %s", sRef_unparseFull (base)));
 	      base->defstate = SS_PDEFINED; 
 	      nb = sRef_getBaseSafe (base); 
 	      base = nb;
@@ -5159,13 +5388,16 @@ static void sRef_setStateAux (sRef s, sstate ss, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  DPRINTF (("Set state: %s => %s", sRef_unparseFull (s), sstate_unparse (ss)));
+
+  if (sRef_isReasonable (s))
     {
       /* if (s->defstate == SS_RELDEF) return; */
 
       if (s->defstate != ss && fileloc_isDefined (loc))
 	{
-	  s->definfo = stateInfo_updateLoc (s->definfo, loc);
+	  s->definfo = stateInfo_updateLoc (s->definfo, 
+					    stateAction_fromSState (ss), loc);
 	}
 
       s->defstate = ss;
@@ -5175,14 +5407,14 @@ static void sRef_setStateAux (sRef s, sstate ss, fileloc loc)
 	{
 	  sRef base = sRef_getBaseSafe (s);
 	  
-	  while (sRef_isValid (base) && sRef_isKnown (base))
+	  while (sRef_isReasonable (base) && sRef_isKnown (base))
 	    {
 	      if (base->defstate == SS_DEFINED) 
 		{ 
 		  sRef nb;
-		  
+
+		  DPRINTF (("set pdefined: %s", sRef_unparseFull (s)));		  
 		  base->defstate = SS_PDEFINED; 
-		  
 		  nb = sRef_getBaseSafe (base); 
 		  base = nb;
 		}
@@ -5192,8 +5424,7 @@ static void sRef_setStateAux (sRef s, sstate ss, fileloc loc)
 		}
 	    }
 	}
-
-          }
+    }
 }
 
 void sRef_setAllocatedComplete (sRef s, fileloc loc)
@@ -5205,16 +5436,12 @@ static void sRef_setAllocatedShallow (sRef s, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (s->defstate == SS_DEAD || s->defstate == SS_UNDEFINED)
 	{
 	  s->defstate = SS_ALLOCATED;
-	  
-	  if (fileloc_isDefined (loc))
-	    {
-	      s->definfo = stateInfo_updateLoc (s->definfo, loc);
-	    }
+	  s->definfo = stateInfo_updateLoc (s->definfo, SA_ALLOCATED, loc);
 	}
     }
 }
@@ -5240,11 +5467,11 @@ void sRef_setShared (sRef s, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (s->aliaskind != AK_SHARED && fileloc_isDefined (loc))
 	{
-	  s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+	  s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_SHARED, loc);
 	}
 
       s->aliaskind = AK_SHARED;
@@ -5256,29 +5483,29 @@ void sRef_setLastReference (sRef s, /*@exposed@*/ sRef ref, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       s->aliaskind = sRef_getAliasKind (ref);
-      s->aliasinfo = stateInfo_updateRefLoc (s->aliasinfo, ref, loc);
+      s->aliasinfo = stateInfo_updateRefLoc (s->aliasinfo, ref, stateAction_fromAlkind (s->aliaskind), loc);
     }
 }
 
 static
 void sRef_setNullStateAux (/*@notnull@*/ sRef s, nstate ns, fileloc loc)
 {
-  DPRINTF (("Set null state: %s / %s", sRef_unparse (s), nstate_unparse (ns)));
   sRef_checkMutable (s);
   s->nullstate = ns;
-  
+  sRef_resetAliasKind (s);
+
   if (fileloc_isDefined (loc))
     {
-      s->nullinfo = stateInfo_updateLoc (s->nullinfo, loc);
+      s->nullinfo = stateInfo_updateLoc (s->nullinfo, stateAction_fromNState (ns), loc);
     }
 }
 
 void sRef_setNotNull (sRef s, fileloc loc)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_setNullStateAux (s, NS_NOTNULL, loc);
     }
@@ -5286,34 +5513,39 @@ void sRef_setNotNull (sRef s, fileloc loc)
 
 void sRef_setNullStateN (sRef s, nstate n)
 {
-  sRef_checkMutable (s);
-  s->nullstate = n;
+  if (sRef_isReasonable (s))
+    {
+      sRef_checkMutable (s);
+      s->nullstate = n;
+      sRef_resetAliasKind (s);
+    }
 }
 
 void sRef_setNullState (sRef s, nstate n, fileloc loc)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_setNullStateAux (s, n, loc);
     }
 }
 
-void sRef_setNullTerminatedStateInnerComplete (sRef s, struct s_bbufinfo b, /*@unused@*/ fileloc loc) {
-   
+void sRef_setNullTerminatedStateInnerComplete (sRef s, struct s_bbufinfo b, /*@unused@*/ fileloc loc) 
+{
   switch (b.bufstate) {
-     case BB_NULLTERMINATED:
-	  sRef_setNullTerminatedState (s);
-          sRef_setLen (s, b.len);
-          break;
-     case BB_POSSIBLYNULLTERMINATED:
-          sRef_setPossiblyNullTerminatedState(s);
-          break;
-     case BB_NOTNULLTERMINATED:
-          sRef_setNotNullTerminatedState (s);
-          break;
+  case BB_NULLTERMINATED:
+    sRef_setNullTerminatedState (s);
+    sRef_setLen (s, b.len);
+    break;
+  case BB_POSSIBLYNULLTERMINATED:
+    sRef_setPossiblyNullTerminatedState(s);
+    break;
+  case BB_NOTNULLTERMINATED:
+    sRef_setNotNullTerminatedState (s);
+    break;
   }
-  sRef_setSize (s, b.size);
 
+  sRef_setSize (s, b.size);
+  
   /* PL: TO BE DONE : Aliases are not modified right now, have to be similar to
    * setNullStateInnerComplete.
    */
@@ -5359,7 +5591,7 @@ void sRef_setNullStateInnerComplete (sRef s, nstate n, fileloc loc)
 
 void sRef_setPosNull (sRef s, fileloc loc)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_setNullStateAux (s, NS_POSNULL, loc);
     }
@@ -5367,7 +5599,7 @@ void sRef_setPosNull (sRef s, fileloc loc)
   
 void sRef_setDefNull (sRef s, fileloc loc)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_setNullStateAux (s, NS_DEFNULL, loc);
     }
@@ -5375,7 +5607,7 @@ void sRef_setDefNull (sRef s, fileloc loc)
 
 void sRef_setNullUnknown (sRef s, fileloc loc)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef_setNullStateAux (s, NS_UNKNOWN, loc);
     }
@@ -5383,75 +5615,74 @@ void sRef_setNullUnknown (sRef s, fileloc loc)
 
 void sRef_setNullError (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s) && !sRef_isConst (s))
     {
       sRef_setNullStateAux (s, NS_UNKNOWN, fileloc_undefined);
     }
 }
 
-void sRef_setNullErrorLoc (sRef s, /*@unused@*/ fileloc loc)
+void sRef_setNullErrorLoc (sRef s, fileloc loc)
 {
-  sRef_setNullError (s);
+  if (sRef_isReasonable (s) && !sRef_isConst (s))
+    {
+      sRef_setNullStateAux (s, NS_UNKNOWN, loc);
+    }
 }
 
 void sRef_setOnly (sRef s, fileloc loc)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s) && s->aliaskind != AK_ONLY)
+  if (sRef_isReasonable (s) && s->aliaskind != AK_ONLY)
     {
+      sRef_checkMutable (s);
       s->aliaskind = AK_ONLY;
-      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
-          }
+      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_ONLY, loc);
+    }
 }
 
 void sRef_setDependent (sRef s, fileloc loc)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s) && !sRef_isConst (s) && (s->aliaskind != AK_DEPENDENT))
+  if (sRef_isReasonable (s) && !sRef_isConst (s) && (s->aliaskind != AK_DEPENDENT))
     {
+      sRef_checkMutable (s);
       DPRINTF (("Setting dependent: %s", sRef_unparseFull (s)));
       s->aliaskind = AK_DEPENDENT;
-      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_DEPENDENT, loc);
     }
 }
 
 void sRef_setOwned (sRef s, fileloc loc)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s) && !sRef_isConst (s) && (s->aliaskind != AK_OWNED))
+  if (sRef_isReasonable (s) && !sRef_isConst (s) && (s->aliaskind != AK_OWNED))
     {
+      sRef_checkMutable (s);
       s->aliaskind = AK_OWNED;
-      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_OWNED, loc);
     }
 }
 
 void sRef_setKept (sRef s, fileloc loc)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s) && !sRef_isConst (s) && (s->aliaskind != AK_KEPT))
+  if (sRef_isReasonable (s) && !sRef_isConst (s) && (s->aliaskind != AK_KEPT))
     {
       sRef base = sRef_getBaseSafe (s);  
-      
-      while (sRef_isValid (base) && sRef_isKnown (base))
+ 
+      while (sRef_isReasonable (base) && sRef_isKnown (base))
 	{
 	  if (base->defstate == SS_DEFINED) 
 	    {
+	      sRef_checkMutable (base);
 	      base->defstate = SS_PDEFINED; 
-	      	      base = sRef_getBaseSafe (base); 
+	      base = sRef_getBaseSafe (base); 
 	    }
 	  else 
 	    {
 	      break; 
 	    }
-
 	}
 
+      sRef_checkMutable (s);
       s->aliaskind = AK_KEPT;
-      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_KEPT, loc);
     }
 }
 
@@ -5483,28 +5714,29 @@ void sRef_setDependentComplete (sRef s, fileloc loc)
 
 void sRef_setFresh (sRef s, fileloc loc)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s) && !sRef_isConst (s))
     {
+      sRef_checkMutable (s);
       s->aliaskind = AK_FRESH;
-      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, loc);
+      s->aliasinfo = stateInfo_updateLoc (s->aliasinfo, SA_CREATED, loc);
+      DPRINTF (("SetFresh: %s", sRef_unparseFull (s)));
     }
 }
 
 void sRef_kill (sRef s, fileloc loc)
 {
   DPRINTF (("Kill: %s", sRef_unparseFull (s)));
-  sRef_checkMutable (s);
 
-  if (sRef_isValid (s) && !sRef_isShared (s) && !sRef_isConst (s))
+  if (sRef_isReasonable (s) && !sRef_isShared (s) && !sRef_isConst (s))
     {
       sRef base = sRef_getBaseSafe (s);  
-      
-      while (sRef_isValid (base) && sRef_isKnown (base))
+      sRef_checkMutable (s);
+	
+      while (sRef_isReasonable (base) && sRef_isKnown (base))
 	{
 	  if (base->defstate == SS_DEFINED) 
 	    {
+	      sRef_checkMutable (base);
 	      base->defstate = SS_PDEFINED; 
 	      base = sRef_getBaseSafe (base); 
 	    }
@@ -5516,25 +5748,24 @@ void sRef_kill (sRef s, fileloc loc)
       
       s->aliaskind = s->oaliaskind;
       s->defstate = SS_DEAD;
-      s->definfo = stateInfo_updateLoc (s->definfo, loc);
-
+      s->definfo = stateInfo_updateLoc (s->definfo, SA_KILLED, loc);
+      DPRINTF (("State info: %s", stateInfo_unparse (s->definfo)));
       sRef_clearDerived (s);
     }
 }
 
 void sRef_maybeKill (sRef s, fileloc loc)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef base = sRef_getBaseSafe (s);  
-
+      sRef_checkMutable (s);
             
-      while (sRef_isValid (base) && sRef_isKnown (base))
+      while (sRef_isReasonable (base) && sRef_isKnown (base))
 	{
 	  if (base->defstate == SS_DEFINED || base->defstate == SS_RELDEF)
 	    {
+	      sRef_checkMutable (base);
 	      base->defstate = SS_PDEFINED; 
 	      base = sRef_getBaseSafe (base); 
 	    }
@@ -5547,7 +5778,9 @@ void sRef_maybeKill (sRef s, fileloc loc)
       
       s->aliaskind = s->oaliaskind;
       s->defstate = SS_HOFFA; 
-      s->definfo = stateInfo_updateLoc (s->definfo, loc);
+      s->definfo = stateInfo_updateLoc (s->definfo, SA_PKILLED, loc);
+      DPRINTF (("State info: %s / %s", sRef_unparse (s), 
+		stateInfo_unparse (s->definfo)));
       sRef_clearDerived (s); 
     }
 
@@ -5559,7 +5792,7 @@ void sRef_maybeKill (sRef s, fileloc loc)
 
 static void sRef_killAux (sRef s, fileloc loc)
 {
-  if (sRef_isValid (s) && !sRef_isShared (s))
+  if (sRef_isReasonable (s) && !sRef_isShared (s))
     {
       if (sRef_isUnknownArrayFetch (s))
 	{
@@ -5595,7 +5828,7 @@ static bool sRef_equivalent (sRef s1, sRef s2)
 {
   sRef ret;
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       bool old = inFunction;
 
@@ -5629,7 +5862,7 @@ sRef sRef_copy (sRef s)
       /*@=retalias@*/
     }
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef t = sRef_alloc ();
 
@@ -5641,6 +5874,7 @@ sRef sRef_copy (sRef s)
       t->modified = s->modified;
       t->immut = FALSE; /* Note mutability is not copied. */
       t->type = s->type;
+      t->val = multiVal_copy (s->val);
 
       t->info = sinfo_copy (s);
       t->defstate = s->defstate;
@@ -5665,8 +5899,8 @@ sRef sRef_copy (sRef s)
 
       t->deriv = sRefSet_newDeepCopy (s->deriv);
       t->state = valueTable_copy (s->state);
-
-      DPRINTF (("Made copy: [%p] %s", t, sRef_unparse (t)));
+      
+      DPRINTF (("Made copy: %s => %s", sRef_unparseFull (s), sRef_unparseFull (t)));
       return t;
     }
   else
@@ -5694,7 +5928,7 @@ bool sRef_isAddress (sRef s)
 
 bool sRef_isThroughArrayFetch (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef tref = s;
 
@@ -5709,7 +5943,7 @@ bool sRef_isThroughArrayFetch (sRef s)
 	  
 	  lt = sRef_getBase (tref);
 	  tref = lt;
-	} while (sRef_isValid (tref));
+	} while (sRef_isReasonable (tref));
     } 
 
   return FALSE;
@@ -5860,6 +6094,8 @@ void sRef_free (/*@only@*/ sRef s)
       DPRINTF (("Free sref: [%p]", s));
 
       sRef_checkValid (s);
+      
+      multiVal_free (s->val); /* evans 2002-07-12 */
 
       stateInfo_free (s->expinfo);
       stateInfo_free (s->aliasinfo);
@@ -5869,7 +6105,7 @@ void sRef_free (/*@only@*/ sRef s)
       sRefSet_free (s->deriv);
       s->deriv = sRefSet_undefined;
 
-      /*@i43@*/ /* valueTable_free (s->state); */
+      valueTable_free (s->state); 
       sinfo_free (s);
       
       
@@ -5885,20 +6121,18 @@ void sRef_free (/*@only@*/ sRef s)
 
 void sRef_setType (sRef s, ctype t)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
+      sRef_checkMutable (s); 
       s->type = t;
     }
 }
 
 void sRef_setTypeFull (sRef s, ctype t)
 {
-  sRef_checkMutable (s);
-
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
+      sRef_checkMutable (s);
       s->type = t;
 
       sRefSet_allElements (s->deriv, current)
@@ -5917,17 +6151,24 @@ void sRef_setTypeFull (sRef s, ctype t)
 static /*@exposed@*/ sRef
 sRef_findDerivedField (/*@notnull@*/ sRef rec, cstring f)
 {
-  sRefSet_allElements (rec->deriv, sr)
+  sRefSet_allElements (sRef_derivedFields (rec), sr)
     {
-      if (sRef_isValid (sr))
+      if (sRef_isReasonable (sr))
 	{
-	  if (sr->info != NULL) 
+	  if (sRef_isReasonable (sr))
 	    {
-	      if (sr->kind == SK_FIELD && cstring_equal (sr->info->field->field, f))
+	      if (sr->info != NULL) 
 		{
-		  return sr;
+		  if (sr->kind == SK_FIELD && cstring_equal (sr->info->field->field, f))
+		    {
+		      return sr;
+		    }
 		}
 	    }
+	  else
+	    {
+	      llcontbug (message ("Invalid sRef as derived field of %s", sRef_unparse (rec)));
+	    }
 	}
     } end_sRefSet_allElements;
 
@@ -5936,7 +6177,7 @@ sRef_findDerivedField (/*@notnull@*/ sRef rec, cstring f)
 
 /*@dependent@*/ /*@observer@*/ sRefSet sRef_derivedFields (/*@temp@*/ sRef rec)
 {
-  if (sRef_isValid (rec))
+  if (sRef_isReasonable (rec))
     {
       sRefSet ret;
       ret = rec->deriv;
@@ -5951,11 +6192,11 @@ sRef_findDerivedField (/*@notnull@*/ sRef rec, cstring f)
 static /*@exposed@*/ sRef
   sRef_findDerivedPointer (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRefSet_realElements (s->deriv, sr)
 	{
-	  if (sRef_isValid (sr) && sr->kind == SK_PTR)
+	  if (sRef_isReasonable (sr) && sr->kind == SK_PTR)
 	    {
 	      return sr;
 	    }
@@ -5968,7 +6209,7 @@ static /*@exposed@*/ sRef
 bool
 sRef_isUnknownArrayFetch (sRef s)
 {
-  return (sRef_isValid (s) 
+  return (sRef_isReasonable (s) 
 	  && s->kind == SK_ARRAYFETCH
 	  && !s->info->arrayfetch->indknown);
 }
@@ -5981,7 +6222,7 @@ sRef_findDerivedArrayFetch (/*@notnull@*/ sRef s, bool isknown, int idx, bool de
     {
       sRefSet_realElements (s->deriv, sr)
 	{
-	  if (sRef_isValid (sr)
+	  if (sRef_isReasonable (sr)
 	      && sr->kind == SK_ARRAYFETCH
 	      && sr->info->arrayfetch->indknown
 	      && (sr->info->arrayfetch->ind == idx))
@@ -5994,7 +6235,7 @@ sRef_findDerivedArrayFetch (/*@notnull@*/ sRef s, bool isknown, int idx, bool de
     {
       sRefSet_realElements (s->deriv, sr)
 	{
-	  if (sRef_isValid (sr)
+	  if (sRef_isReasonable (sr)
 	      && sr->kind == SK_ARRAYFETCH
 	      && (!sr->info->arrayfetch->indknown
 		  || (sr->info->arrayfetch->indknown && 
@@ -6037,14 +6278,14 @@ sRef_buildNCField (/*@exposed@*/ sRef rec, /*@exposed@*/ cstring f)
 
   s = sRef_findDerivedField (rec, f);
   
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       return s;
     }
   else
     {
       ctype ct = ctype_realType (rec->type);
-
+      
       DPRINTF (("Field of: %s", sRef_unparse (rec)));
       
       s = sRef_newRef ();      
@@ -6164,7 +6405,7 @@ sRef_buildNCField (/*@exposed@*/ sRef rec, /*@exposed@*/ cstring f)
 bool
 sRef_isStackAllocated (sRef s)
 {
-  return (sRef_isValid(s) 
+  return (sRef_isReasonable(s) 
 	  && s->defstate == SS_ALLOCATED && ctype_isStackAllocated (s->type));
 }
 	  
@@ -6180,6 +6421,10 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
     }
 
   /* a hack, methinks... makeArrayFetch (&a[0]) ==> a[] */
+  /* evans - 2001-08-27: not sure where this was necessary - it
+  ** causes an assertion in in aliasCheckPred to fail.
+  */
+
   if (sRef_isAddress (arr)) 
     {
       sRef t = arr->info->ref;
@@ -6193,14 +6438,16 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
     {
       sRef sp = sRef_findDerivedPointer (arr);
       
-      if (sRef_isValid (sp))
+      if (sRef_isReasonable (sp))
 	{
 	  
 	  if (ctype_isMutable (s->type))
 	    {
-	      sRef_setExKind (s, sRef_getExKind (sp), fileloc_undefined);
-	      	      
+	      s->expkind = sRef_getExKind (sp);
+	      s->expinfo = stateInfo_copy (sp->expinfo);
+	      
 	      s->aliaskind = sp->aliaskind;
+	      s->aliasinfo = stateInfo_copy (sp->aliasinfo);
 	    }
 
 	  s->defstate = sp->defstate;
@@ -6213,6 +6460,7 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
 		}
 	    }
 
+	  DPRINTF (("Set null state: %s / %s", sRef_unparseFull (s), sRef_unparseFull (sp)));
 	  sRef_setNullStateN (s, sRef_getNullState (sp));
 	}
       else
@@ -6243,8 +6491,9 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
 	      */
 	    }
 
-	  sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);
-
+	  s->expkind = sRef_getExKind (arr);
+	  s->expinfo = stateInfo_copy (arr->expinfo);
+	  
 	  if (arr->aliaskind == AK_LOCAL || arr->aliaskind == AK_FRESH)
 	    {
 	      s->aliaskind = AK_LOCAL;
@@ -6295,32 +6544,38 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
 		  
 		  sRefSet_allElements (arr->deriv, sr)
 		    {
-		      if (sRef_isValid (sr))
+		      if (sRef_isReasonable (sr))
 			{
-			  if (sr->defstate == SS_ALLOCATED)
-			    {
-			      s->defstate = SS_ALLOCATED;
-			    }
-			  else 
+			  if (sRef_isReasonable (sr))
 			    {
-			      if (sr->defstate == SS_DEFINED)
+			      if (sr->defstate == SS_ALLOCATED)
 				{
-				  if (context_getFlag (FLG_STRICTDESTROY))
-				    {
-				      s->defstate = SS_DEFINED;
-				    }
-				  else
+				  s->defstate = SS_ALLOCATED;
+				}
+			      else 
+				{
+				  if (sr->defstate == SS_DEFINED)
 				    {
-				      s->defstate = SS_PARTIAL;
+				      if (context_getFlag (FLG_STRICTDESTROY))
+					{
+					  s->defstate = SS_DEFINED;
+					}
+				      else
+					{
+					  s->defstate = SS_PARTIAL;
+					}
+				      
+				      break;
 				    }
-
-				  break;
 				}
 			    }
+			  else
+			    {
+			      llcontbug (message ("Invalid sRef as derived element of %s", sRef_unparse (arr)));
+			    }
 			}
 		    } end_sRefSet_allElements;
-		  
-		  		}
+		}
 	      else
 		{
 		  s->defstate = SS_UNDEFINED;
@@ -6355,6 +6610,7 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
   if (sRef_isObserver (arr)) 
     {
       s->expkind = XO_OBSERVER;
+      s->expinfo = stateInfo_copy (arr->expinfo);
     }
 }  
 
@@ -6362,7 +6618,7 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
 {
   sRef s;
 
-  if (!sRef_isValid (arr)) {
+  if (!sRef_isReasonable (arr)) {
     /*@-nullret@*/ return arr /*@=nullret@*/;
   }
 
@@ -6373,9 +6629,22 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
   
   s = sRef_findDerivedArrayFetch (arr, FALSE, 0, FALSE);
   
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
-      sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);
+      /* evans 2001-07-12: this is bogus, clean-up hack */
+      if (s->info->arrayfetch->arr != arr)
+	{
+	  sRef res;
+	  check (sRefSet_delete (arr->deriv, s));
+	  res = sRef_buildArrayFetch (arr);
+	  sRef_copyState (res, s);
+	  llassert (res->info->arrayfetch->arr == arr); 
+	  return res;
+	}
+
+      s->expkind = sRef_getExKind (arr);
+      s->expinfo = stateInfo_copy (arr->expinfo);
+
       return s;
     }
   else
@@ -6388,7 +6657,9 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
       s->info->arrayfetch->indknown = FALSE;
       s->info->arrayfetch->ind = 0;
       s->info->arrayfetch->arr = arr; /* sRef_copy (arr); */ /*@i32@*/
+
       sRef_setArrayFetchState (s, arr);
+
       s->oaliaskind = s->aliaskind;
       s->oexpkind = s->expkind;
 
@@ -6397,9 +6668,12 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
 	  sRef_addDeriv (arr, s);
 	}
       
-      llassert (valueTable_isUndefined (s->state));
-      s->state = context_createValueTable (s);
-
+      if (valueTable_isUndefined (s->state))
+	{
+	  s->state = context_createValueTable 
+	    (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
+	}
+      
       return (s);
     }
 }
@@ -6409,20 +6683,37 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
 {
   sRef s;
 
-  if (!sRef_isValid (arr)) {
+  if (!sRef_isReasonable (arr)) {
     /*@-nullret@*/ return arr /*@=nullret@*/;
   }
 
   if (ctype_isRealPointer (arr->type))
     {
-       (void) sRef_buildPointer (arr); /* do this to define arr! */
+      (void) sRef_buildPointer (arr); /* do this to define arr! */
     }
 
   s = sRef_findDerivedArrayFetch (arr, TRUE, i, FALSE);
-      
-  if (sRef_isValid (s))
+
+  if (sRef_isReasonable (s))
     {
-      sRef_setExKind (s, sRef_getExKind (arr), g_currentloc);      
+      /* evans 2001-07-12: this is bogus, clean-up hack */
+      if (s->info->arrayfetch->arr != arr)
+	{
+	  sRef res;
+
+	  check (sRefSet_delete (arr->deriv, s));
+	  res = sRef_buildArrayFetchKnown (arr, i);
+
+	  llassert (res->info->arrayfetch->arr == arr);
+	  sRef_copyState (res, s);
+	  llassert (res->info->arrayfetch->arr == arr);
+	  return res;
+	}
+
+      s->expkind = sRef_getExKind (arr);
+      s->expinfo = stateInfo_copy (arr->expinfo);
+
+      llassert (s->info->arrayfetch->arr == arr);
       return s;
     }
   else
@@ -6435,16 +6726,16 @@ void sRef_setArrayFetchState (/*@notnull@*/ /*@exposed@*/ sRef s,
       s->info->arrayfetch->arr = arr; /* sRef_copy (arr); */ /*@i32@*/
       s->info->arrayfetch->indknown = TRUE;
       s->info->arrayfetch->ind = i;
-      
+
       sRef_setArrayFetchState (s, arr);
-      
+      /* evans 2001-08-27 no: can change this - llassert (s->info->arrayfetch->arr == arr); */
+
       s->oaliaskind = s->aliaskind;
       s->oexpkind = s->expkind;
       sRef_addDeriv (arr, s);
 
       llassert (valueTable_isUndefined (s->state));
-      s->state = context_createValueTable (s);
-
+      s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
       return (s);
     }
 }
@@ -6458,7 +6749,7 @@ sRef_setPartsFromUentry (sRef s, uentry ue)
 {    
   sRef uref = uentry_getSref (ue);
 
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   s->aliaskind = alkind_derive (s->aliaskind, uentry_getAliasKind (ue));
   s->oaliaskind = s->aliaskind;
@@ -6472,7 +6763,7 @@ sRef_setPartsFromUentry (sRef s, uentry ue)
   
   if (sRef_getNullState (s) == NS_UNKNOWN)
     {
-      DPRINTF (("Setting null state!"));
+      DPRINTF (("Set null state: %s / %s", sRef_unparseFull (s), uentry_unparseFull (ue)));
       sRef_setNullStateN (s, sRef_getNullState (uentry_getSref (ue)));
     }
   else
@@ -6485,7 +6776,7 @@ sRef_setPartsFromUentry (sRef s, uentry ue)
       s->oaliaskind = s->aliaskind = AK_IMPDEPENDENT;
     } 
 
-  if (sRef_isValid (uref))
+  if (sRef_isReasonable (uref))
     {
       valueTable utable = uref->state;
       valueTable_free (s->state);
@@ -6496,7 +6787,7 @@ sRef_setPartsFromUentry (sRef s, uentry ue)
 static void
 sRef_setStateFromAbstractUentry (sRef s, uentry ue)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   sRef_checkMutable (s);
 
   sRef_setPartsFromUentry (s, ue);
@@ -6518,7 +6809,7 @@ sRef_setStateFromUentry (sRef s, uentry ue)
   sstate defstate;
 
   sRef_checkMutable (s);
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   
   sRef_setPartsFromUentry (s, ue);
 
@@ -6552,10 +6843,11 @@ sRef_setStateFromUentry (sRef s, uentry ue)
 
       DPRINTF (("find derived: %s", sRef_unparse (s)));
 
-      if (sRef_isValid (s))
+      if (sRef_isReasonable (s))
 	{
-	  
-	  sRef_setExKind (s, sRef_getExKind (t), g_currentloc);
+	  s->expkind = sRef_getExKind (t);
+	  s->expinfo = stateInfo_copy (t->expinfo);	  
+
 	  s->oaliaskind = s->aliaskind;
 	  s->oexpkind = s->expkind;
 
@@ -6567,7 +6859,7 @@ sRef_setStateFromUentry (sRef s, uentry ue)
 	  
 	  DPRINTF (("construct: %s", sRef_unparse (s)));
 
-	  if (sRef_isValid (s))
+	  if (sRef_isReasonable (s))
 	    {
 	      sRef_addDeriv (t, s);
 
@@ -6589,7 +6881,7 @@ sRef_constructPointer (/*@exposed@*/ sRef t)
 
 static /*@exposed@*/ sRef sRef_constructDerefAux (sRef t, bool isdead)
 {
-  if (sRef_isValid (t))
+  if (sRef_isReasonable (t))
     {
       sRef s;
       
@@ -6599,28 +6891,18 @@ static /*@exposed@*/ sRef sRef_constructDerefAux (sRef t, bool isdead)
       
       s = sRef_findDerivedArrayFetch (t, FALSE, 0, isdead);
       
-      if (sRef_isValid (s))
+      if (sRef_isReasonable (s))
 	{
+	  DPRINTF (("Found array fetch: %s", sRef_unparseFull (s)));
 	  return s;
 	}
       else
 	{
 	  sRef ret = sRef_constructPointer (t);
 
-	  /*
-	  ** This is necessary to prevent infinite depth
-	  ** in checking complete destruction.  
-	  */
+	  DPRINTF (("Constructed pointer: %s", sRef_unparseFull (ret)));
 
-	  if (isdead)
-	    {
-	      /* ret->defstate = SS_UNKNOWN;  */
-	      return ret; 
-	    }
-	  else
-	    {
-	      return ret;
-	    }
+	  return ret;
 	}
     }
   else
@@ -6646,6 +6928,8 @@ sRef_constructPointerAux (/*@notnull@*/ /*@exposed@*/ sRef t)
   ctype rt = t->type;
   ctype st;
   
+  llassert (valueTable_isUndefined (s->state));
+
   s->kind = SK_PTR;
   s->info = (sinfo) dmalloc (sizeof (*s->info));
   s->info->ref = t; /* sRef_copy (t); */ /*@i32*/
@@ -6656,18 +6940,21 @@ sRef_constructPointerAux (/*@notnull@*/ /*@exposed@*/ sRef t)
     }
   
   st = ctype_realType (s->type);  
-    
+
   if (t->defstate == SS_UNDEFINED)
     {
       s->defstate = SS_UNUSEABLE;
+      s->definfo = stateInfo_copy (t->definfo);
     }
   else if ((t->defstate == SS_ALLOCATED) && !ctype_isSU (st))
     {
       s->defstate = SS_UNDEFINED;
+      s->definfo = stateInfo_copy (t->definfo);
     }
   else
     {
       s->defstate = t->defstate;
+      s->definfo = stateInfo_copy (t->definfo);
     }
   
   if (t->aliaskind == AK_LOCAL || t->aliaskind == AK_FRESH)
@@ -6678,28 +6965,35 @@ sRef_constructPointerAux (/*@notnull@*/ /*@exposed@*/ sRef t)
     {
       s->aliaskind = AK_UNKNOWN;
     }
-  
-  sRef_setExKind (s, sRef_getExKind (t), fileloc_undefined);
+
+  s->expkind = sRef_getExKind (t);
+  s->expinfo = stateInfo_copy (t->expinfo);
+
   sRef_setTypeState (s);
-  
+
   s->oaliaskind = s->aliaskind;
   s->oexpkind = s->expkind;
 
-  llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  if (valueTable_isUndefined (s->state))
+    {
+      s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
+    }
+
+  DPRINTF (("pointer: %s", sRef_unparseFull (s)));
   return s;
 }
 
 bool sRef_hasDerived (sRef s)
 {
-  return (sRef_isValid (s) && !sRefSet_isEmpty (s->deriv));
+  return (sRef_isReasonable (s) && !sRefSet_isEmpty (s->deriv));
 }
 
 void
 sRef_clearDerived (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
+      DPRINTF (("Clear derived: [%p] %s", s, sRef_unparseDebug (s)));
       sRefSet_clear (s->deriv); 
     }
 }
@@ -6707,17 +7001,18 @@ sRef_clearDerived (sRef s)
 void
 sRef_clearDerivedComplete (sRef s)
 {
-  
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sRef base = sRef_getBaseSafe (s);
-
-      while (sRef_isValid (base))
+      
+      while (sRef_isReasonable (base))
 	{
+	  DPRINTF (("Clear derived: [%p] %s", base, sRef_unparse (base)));
 	  sRefSet_clear (base->deriv); 
 	  base = sRef_getBaseSafe (base);
 	}
 
+      DPRINTF (("Clear derived: [%p] %s", s, sRef_unparse (s)));
       sRefSet_clear (s->deriv); 
     }
 }
@@ -6727,7 +7022,7 @@ sRef_clearDerivedComplete (sRef s)
 {
   sRef res = sRef_buildPointer (s); 
 
-  DPRINTF (("Res: %s", sRef_unparse (res)));
+  DPRINTF (("Res: %s", sRef_unparseFull (res)));
   return res;
 }
 
@@ -6737,8 +7032,7 @@ sRef_clearDerivedComplete (sRef s)
 
 /*@exposed@*/ sRef
 sRef_makeAnyArrayFetch (/*@exposed@*/ sRef arr)
-{
-  
+{  
   if (sRef_isAddress (arr))
     {
       return (arr->info->ref);
@@ -6942,7 +7236,7 @@ sRef_unparseKindNamePlain (sRef s)
 void
 sRef_copyState (sRef s1, sRef s2)
 {
-  if (sRef_isValid (s1) && sRef_isValid (s2))
+  if (sRef_isReasonable (s1) && sRef_isReasonable (s2))
     {
       s1->defstate = s2->defstate;
       
@@ -6957,7 +7251,7 @@ sRef_copyState (sRef s1, sRef s2)
 
       s1->expkind = s2->expkind;
       s1->expinfo = stateInfo_update (s1->expinfo, s2->expinfo);
-      
+
       s1->nullstate = s2->nullstate;
       s1->nullinfo = stateInfo_update (s1->nullinfo, s2->nullinfo);
 
@@ -6977,7 +7271,7 @@ sRef_makeNew (ctype ct, sRef t, cstring name)
   s->kind = SK_NEW;
   s->type = ct;
 
-  llassert (sRef_isValid (t));
+  llassert (sRef_isReasonable (t));
   s->defstate = t->defstate;
 
   s->aliaskind = t->aliaskind;
@@ -7035,7 +7329,7 @@ sRef_makeType (ctype ct)
   s->oaliaskind = s->aliaskind;
   s->oexpkind = s->expkind;
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
 
   DPRINTF (("Create: %s", sRef_unparseFull (s)));
   return s;
@@ -7057,8 +7351,8 @@ sRef_makeConst (ctype ct)
   s->bufinfo.bufstate = BB_NULLTERMINATED;
   /* end modification */
 
-  
-  if (ctype_isUA (ct))
+  /* evans 2002-04-22: added isManifestBool to avoid errors for -boolfalse initializations */
+  if (!ctype_isManifestBool (ct) && ctype_isUA (ct)) 
     {
       typeId uid = ctype_typeId (ct);
       uentry te = usymtab_getTypeEntrySafe (uid);
@@ -7069,12 +7363,11 @@ sRef_makeConst (ctype ct)
 	}
     }
   
-  
   s->oaliaskind = s->aliaskind;
   s->oexpkind = s->expkind;
 
   llassert (valueTable_isUndefined (s->state));
-  s->state = context_createValueTable (s);
+  s->state = context_createValueTable (s, stateInfo_makeLoc (g_currentloc, SA_CREATED));
 
   return s;
 }
@@ -7489,10 +7782,14 @@ sRef_showRefLost (sRef s)
 void
 sRef_showRefKilled (sRef s)
 {
-  if (sRef_hasStateInfoLoc (s))
+  if (sRef_isValid (s)) 
     {
-      llgenindentmsg (message ("Storage %q released", 
-			       sRef_unparse (s)), sRef_getStateInfoLoc (s));
+      DPRINTF (("Killed: %s", sRef_unparseFull (s)));
+      if (context_getLocIndentSpaces () == 0) {
+	stateInfo_display (s->definfo, message ("  Storage %q", sRef_unparseOpt (s)));
+      } else {
+	stateInfo_display (s->definfo, message ("Storage %q", sRef_unparseOpt (s)));
+      }
     }
 }
 
@@ -7511,49 +7808,25 @@ sRef_showStateInconsistent (sRef s)
 void
 sRef_showStateInfo (sRef s)
 {
-  if (sRef_hasStateInfoLoc (s))
-    {
-      if (s->defstate == SS_DEAD)
-	{
-	  llgenindentmsg 
-	    (message ("Storage %qis released", sRef_unparseOpt (s)),
-	     sRef_getStateInfoLoc (s));
-	}
-      else if (s->defstate == SS_ALLOCATED || s->defstate == SS_DEFINED)
-	{
-	  llgenindentmsg 
-	    (message ("Storage %qis %s", sRef_unparseOpt (s), 
-		      sstate_unparse (s->defstate)),
-	     sRef_getStateInfoLoc (s));
-	}
-      else if (s->defstate == SS_UNUSEABLE)
-	{
-	  llgenindentmsg 
-	    (message ("Storage %qbecomes inconsistent (clauses merge with"
-		      "%qreleased on one branch)",
-		      sRef_unparseOpt (s), 
-		      sRef_unparseOpt (s)),
-	     sRef_getStateInfoLoc (s));
-	}
-      else 
-	{
-	  llgenindentmsg (message ("Storage %qbecomes %s", 
-				   sRef_unparseOpt (s), 
-				   sstate_unparse (s->defstate)),
-			  sRef_getStateInfoLoc (s));
-	}
+  if (sRef_isValid (s)) {
+    if (context_getLocIndentSpaces () == 0) {
+      stateInfo_display (s->definfo, message ("   Storage %q", sRef_unparseOpt (s)));
+    } else {
+      stateInfo_display (s->definfo, message ("Storage %q", sRef_unparseOpt (s)));
     }
+  }
 }
 
 void
 sRef_showExpInfo (sRef s)
 {
-  if (sRef_hasExpInfoLoc (s))
-    {
-      llgenindentmsg (message ("Storage %qbecomes %s", sRef_unparseOpt (s), 
-			       exkind_unparse (s->expkind)),
-		      sRef_getExpInfoLoc (s));
+  if (sRef_isValid (s)) {
+    if (context_getLocIndentSpaces () == 0) {
+      stateInfo_display (s->expinfo, message ("   Storage %q", sRef_unparseOpt (s)));
+    } else {
+      stateInfo_display (s->expinfo, message ("Storage %q", sRef_unparseOpt (s)));
     }
+  }
 }
 
 void
@@ -7562,7 +7835,7 @@ sRef_showMetaStateInfo (sRef s, cstring key)
   stateValue val;
   metaStateInfo minfo = context_lookupMetaStateInfo (key);
 
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
   llassert (valueTable_isDefined (s->state));
   llassert (metaStateInfo_isDefined (minfo));
 
@@ -7571,8 +7844,8 @@ sRef_showMetaStateInfo (sRef s, cstring key)
   if (stateValue_hasLoc (val))
     {
       llgenindentmsg 
-	(message ("Meta state %qbecomes %s", sRef_unparseOpt (s), 
-		  metaStateInfo_unparseValue (minfo, stateValue_getValue (val))),
+	(message ("%qbecomes %q", sRef_unparseOpt (s), 
+		  stateValue_unparseValue (val, minfo)),
 	 stateValue_getLoc (val));
     }
 }
@@ -7650,24 +7923,23 @@ sRef_showNullInfo (sRef s)
 void
 sRef_showAliasInfo (sRef s)
 {
-  if (sRef_hasAliasInfoLoc (s))
+  if (sRef_isValid (s)) 
     {
       if (sRef_isFresh (s))
 	{
-	  llgenindentmsg 
-	    (message ("Fresh storage %qallocated", sRef_unparseOpt (s)),
-	     sRef_getAliasInfoLoc (s));
+	  if (context_getLocIndentSpaces () == 0) {
+	    stateInfo_display (s->aliasinfo, message ("   Fresh storage %q", sRef_unparseOpt (s)));
+	  } else {
+	    stateInfo_display (s->aliasinfo, message ("Fresh storage %q", sRef_unparseOpt (s)));
+	  }
 	}
-      else 
+      else
 	{
-	  if (!sRef_isRefCounted (s))
-	    {
-	      llgenindentmsg 
-		(message ("Storage %qbecomes %s", 
-			  sRef_unparseOpt (s),
-			  alkind_unparse (sRef_getAliasKind (s))),
-		 sRef_getAliasInfoLoc (s));
-	    }
+	  if (context_getLocIndentSpaces () == 0) {
+	    stateInfo_display (s->aliasinfo, message ("   Storage %q", sRef_unparseOpt (s))); 
+	  } else {
+	    stateInfo_display (s->aliasinfo, message ("Storage %q", sRef_unparseOpt (s)));
+	  }
 	}
     }
 }
@@ -7675,7 +7947,7 @@ sRef_showAliasInfo (sRef s)
 void
 sRef_mergeNullState (sRef s, nstate n)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       nstate old;
       
@@ -7683,7 +7955,7 @@ sRef_mergeNullState (sRef s, nstate n)
       
       if (n != old && n != NS_UNKNOWN)
 	{	  	  
-	    sRef_setNullState (s, n, g_currentloc);
+	  sRef_setNullState (s, n, g_currentloc);
 	}
     }
   else
@@ -7695,12 +7967,12 @@ sRef_mergeNullState (sRef s, nstate n)
 bool
 sRef_possiblyNull (sRef s)
 {
-  if (sRef_isValid (s))
-      {
-	if (sRef_getNullState (s) == NS_ABSNULL)
+  if (sRef_isReasonable (s))
+    {
+      if (sRef_getNullState (s) == NS_ABSNULL)
 	{
 	  ctype rct = ctype_realType (s->type);
-
+	  
 	  if (ctype_isAbstract (rct))
 	    {
 	      return FALSE;
@@ -7725,7 +7997,7 @@ sRef_possiblyNull (sRef s)
 	  return nstate_possiblyNull (sRef_getNullState (s));
 	}
     }
-
+  
   return FALSE;
 }
 
@@ -7770,7 +8042,7 @@ sRef_unparseScope (sRef s)
 int
 sRef_getScope (sRef s)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   if (sRef_isCvar (s))
     {
@@ -7789,13 +8061,13 @@ sRef_getScope (sRef s)
 bool
 sRef_isDead (sRef s)
 {
-  return (sRef_isValid (s) && (s)->defstate == SS_DEAD);
+  return (sRef_isReasonable (s) && (s)->defstate == SS_DEAD);
 }
 
 bool
 sRef_isDeadStorage (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (s->defstate == SS_DEAD
 	  || s->defstate == SS_UNUSEABLE
@@ -7818,12 +8090,12 @@ sRef_isDeadStorage (sRef s)
 bool
 sRef_isPossiblyDead (sRef s)
 {
-  return (sRef_isValid (s) && s->defstate == SS_HOFFA);
+  return (sRef_isReasonable (s) && s->defstate == SS_HOFFA);
 }
 
 bool sRef_isStateLive (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       sstate ds = s->defstate;
 
@@ -7841,7 +8113,7 @@ bool sRef_isStateLive (sRef s)
 
 bool sRef_isStateUndefined (sRef s)
 {
-  return ((sRef_isValid(s)) && ((s)->defstate == SS_UNDEFINED));
+  return ((sRef_isReasonable(s)) && ((s)->defstate == SS_UNDEFINED));
 }
 
 bool sRef_isJustAllocated (sRef s)
@@ -7865,7 +8137,7 @@ bool sRef_isJustAllocated (sRef s)
 static bool
 sRef_isAllocatedStorage (sRef s)
 {
-  if (sRef_isValid (s) && ynm_toBoolStrict (sRef_isReadable (s)))
+  if (sRef_isReasonable (s) && ynm_toBoolStrict (sRef_isValidLvalue (s)))
     {
       return (ctype_isVisiblySharable (sRef_getType (s)));
     }
@@ -7884,7 +8156,7 @@ sRef_isUnuseable (sRef s)
 bool
 sRef_perhapsNull (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (sRef_getNullState (s) == NS_ABSNULL)
 	{
@@ -7925,7 +8197,7 @@ sRef_perhapsNull (sRef s)
 bool 
 sRef_definitelyNull (sRef s)
 {
-  return (sRef_isValid (s)
+  return (sRef_isReasonable (s)
 	  && (sRef_getNullState (s) == NS_DEFNULL || sRef_getNullState (s) == NS_CONSTNULL));
 }
 
@@ -7936,11 +8208,11 @@ sRef_definitelyNull (sRef s)
 void
 sRef_setDerivNullState (sRef set, sRef guide, nstate ns)
 {
-  if (sRef_isValid (set))
+  if (sRef_isReasonable (set))
     {
       sRef deriv = sRef_getDeriv (set, guide);
       
-      if (sRef_isValid (deriv))
+      if (sRef_isReasonable (deriv))
 	{
 	  sRef_setNullStateN (deriv, ns);
 	}
@@ -7950,20 +8222,18 @@ sRef_setDerivNullState (sRef set, sRef guide, nstate ns)
 static /*@exposed@*/ sRef
 sRef_getDeriv (/*@returned@*/ /*@notnull@*/ sRef set, sRef guide)
 {
-  llassert (sRef_isValid (set));
-  llassert (sRef_isValid (guide));
+  llassert (sRef_isReasonable (set));
+  llassert (sRef_isReasonable (guide));
 
   switch (guide->kind)
     {
     case SK_CVAR:
-      llassert (set->kind == SK_CVAR);
-      
+      llassert (set->kind == SK_CVAR);      
       return set;
 
     case SK_PARAM:
       llassert (set->kind == guide->kind);
       llassert (set->info->paramno == guide->info->paramno);
-
       return set;
 
     case SK_ARRAYFETCH:
@@ -8062,18 +8332,24 @@ sRef_aliasCheckPred (bool (predf) (sRef, exprNode, sRef, exprNode),
   else
     {
       sRefSet aliases = usymtab_allAliases (s);
-
       
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
-	      if (!sRef_similar (current, s)
-		  || (error && sRef_sameName (current, s)))
+	      if (sRef_isReasonable (current))
 		{
-		  (void) (*predf)(current, e, s, err);
+		  if (!sRef_similar (current, s)
+		      || (error && sRef_sameName (current, s)))
+		    {
+		      (void) (*predf)(current, e, s, err);
+		    }
 		}
-	      }
+	      else
+		{
+		  llcontbug (message ("Invalid sRef as alias field of %s", sRef_unparse (s)));
+		}
+	    }
 	} end_sRefSet_realElements;
 
       sRefSet_free (aliases);
@@ -8100,7 +8376,7 @@ sRef_aliasCheckSimplePred (sRefTest predf, sRef s)
       
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      sRef cref = sRef_updateSref (current);
 	      
@@ -8138,7 +8414,7 @@ sRef_aliasCompleteSimplePred (bool (predf) (sRef), sRef s)
   
   sRefSet_realElements (aliases, current)
     {
-      if (sRef_isValid (current))
+      if (sRef_isReasonable (current))
 	{
 	  current = sRef_updateSref (current);
 	  if ((*predf)(current)) result = TRUE;
@@ -8149,7 +8425,7 @@ sRef_aliasCompleteSimplePred (bool (predf) (sRef), sRef s)
   return result;
 }
 
-static void
+void
 sRef_aliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
 {
   sRefSet aliases;
@@ -8162,22 +8438,55 @@ sRef_aliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
 
   sRefSet_realElements (aliases, current)
     {
-      if (sRef_isValid (current))
+      if (sRef_isReasonable (current))
 	{
 	  current = sRef_updateSref (current);
 	  ((*predf)(current, loc));
+	  DPRINTF (("Killed: %s", sRef_unparseFull (current)));
 	}
     } end_sRefSet_realElements;
 
   sRefSet_free (aliases);
 }
 
-static void
-sRef_aliasSetCompleteParam (void (predf) (sRef, alkind, fileloc), sRef s, 
-			    alkind kind, fileloc loc)
+void
+sRef_aliasSetCompleteParam (void (predf) (sRef, int, fileloc), sRef s, 
+			    int kind, fileloc loc)
 {
   sRefSet aliases;
+  
+  if (sRef_isDeep (s))
+    {
+      aliases = usymtab_allAliases (s);
+    }
+  else
+    {
+      aliases = usymtab_aliasedBy (s);
+    }
+
+  (*predf)(s, kind, loc);
 
+  sRefSet_realElements (aliases, current)
+    {
+      if (sRef_isReasonable (current))
+	{
+	  current = sRef_updateSref (current);
+	  ((*predf)(current, kind, loc));
+	}
+    } end_sRefSet_realElements;
+
+  sRefSet_free (aliases);
+}
+
+/*
+** Version of aliasSetCompleteParam for alkind parameters
+*/
+
+void
+sRef_aliasSetCompleteAlkParam (void (predf) (sRef, alkind, fileloc), sRef s, 
+			       alkind kind, fileloc loc)
+{
+  sRefSet aliases;
   
   if (sRef_isDeep (s))
     {
@@ -8192,7 +8501,7 @@ sRef_aliasSetCompleteParam (void (predf) (sRef, alkind, fileloc), sRef s,
 
   sRefSet_realElements (aliases, current)
     {
-      if (sRef_isValid (current))
+      if (sRef_isReasonable (current))
 	{
 	  current = sRef_updateSref (current);
 	  ((*predf)(current, kind, loc));
@@ -8209,9 +8518,8 @@ sRef_innerAliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
   sRefSet aliases;
   ctype ct;
 
-  if (!sRef_isValid (s)) return;
+  if (!sRef_isReasonable (s)) return;
 
-  
   /*
   ** Type equivalence checking is necessary --- there might be casting.
   */
@@ -8228,11 +8536,10 @@ sRef_innerAliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
       inner = s->info->ref;
       aliases = usymtab_allAliases (inner);
       ct = sRef_getType (inner);
-
       
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      current = sRef_updateSref (current);
 	      
@@ -8251,28 +8558,44 @@ sRef_innerAliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
       aliases = usymtab_allAliases (inner);
       ct = sRef_getType (inner);
 
+      DPRINTF (("Array fetch: %s", sRefSet_unparse (aliases)));
+
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      current = sRef_updateSref (current);
-	      
+	      DPRINTF (("Current: %s", sRef_unparseFull (current)));
+
 	      if (ctype_equal (ct, sRef_getType (current)))
 		{
-		  		  
 		  if (s->info->arrayfetch->indknown)
 		    {
 		      sRef af = sRef_makeArrayFetchKnown (current, s->info->arrayfetch->ind);
-		      
+		      DPRINTF (("Defining: %s", sRef_unparseFull (af)));
+		      /* evans 2001-08-27 This isn't true:
+			   llassert (af->info->arrayfetch->arr == current);
+			 see comments in buildArrayFetchKnown
+		      */
 		      ((*predf)(af, loc));
 		    }
 		  else
 		    {
 		      sRef af = sRef_makeArrayFetch (current);
-		      
+		      /* evans 2001-08-27 This isn't true:
+			 llassert (af->info->arrayfetch->arr == current);
+			 see comments in buildArrayFetch
+		      */ 
+		      DPRINTF (("Defining: %s", sRef_unparseFull (af)));
 		      ((*predf)(af, loc));
 		    }
 		}
+	      else
+		{
+		  DPRINTF (("Type mismatch: %s / %s",
+			    ctype_unparse (ct),
+			    ctype_unparse (sRef_getType (current))));
+		}
 	    }
 	} end_sRefSet_realElements;
 
@@ -8282,11 +8605,10 @@ sRef_innerAliasSetComplete (void (predf) (sRef, fileloc), sRef s, fileloc loc)
       inner = s->info->field->rec;
       aliases = usymtab_allAliases (inner);
       ct = sRef_getType (inner);
-
       
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      current = sRef_updateSref (current);
 	      
@@ -8326,9 +8648,8 @@ sRef_innerAliasSetCompleteParam (void (predf) (sRef, sRef), sRef s, sRef t)
   sRefSet aliases;
   ctype ct;
 
-  if (!sRef_isValid (s)) return;
+  if (!sRef_isReasonable (s)) return;
 
-  
   /*
   ** Type equivalence checking is necessary --- there might be casting.
   */
@@ -8345,11 +8666,10 @@ sRef_innerAliasSetCompleteParam (void (predf) (sRef, sRef), sRef s, sRef t)
       inner = s->info->ref;
       aliases = usymtab_allAliases (inner);
       ct = sRef_getType (inner);
-      
-      
+            
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      current = sRef_updateSref (current);
 	      
@@ -8371,7 +8691,7 @@ sRef_innerAliasSetCompleteParam (void (predf) (sRef, sRef), sRef s, sRef t)
 
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      current = sRef_updateSref (current);
 	      
@@ -8404,7 +8724,7 @@ sRef_innerAliasSetCompleteParam (void (predf) (sRef, sRef), sRef s, sRef t)
       
       sRefSet_realElements (aliases, current)
 	{
-	  if (sRef_isValid (current))
+	  if (sRef_isReasonable (current))
 	    {
 	      current = sRef_updateSref (current);
 	      
@@ -8561,6 +8881,16 @@ static void
     {
       res->aliaskind = AK_KEPT;
     }
+  else if ((ares == AK_OWNED && aother == AK_ONLY)
+	   || (aother == AK_OWNED && ares == AK_ONLY))
+    {
+      res->aliaskind = AK_OWNED;
+
+      if (aother == AK_OWNED)
+	{
+	  res->aliasinfo = stateInfo_update (res->aliasinfo, other->aliasinfo);
+	}
+    }
   else
     {
       hasError = TRUE;
@@ -8627,6 +8957,8 @@ static void
 
   sRef_checkMutable (res);
 
+  DPRINTF (("Combine alias kinds: \n\t%s / \n\t%s",
+	    sRef_unparseFull (res), sRef_unparseFull (other)));
   if (alkind_equal (ares, aother)
       || aother == AK_UNKNOWN
       || aother == AK_ERROR)
@@ -8639,12 +8971,14 @@ static void
       res ->aliaskind = AK_ERROR; 
     }
   else if (ares == AK_UNKNOWN || ares == AK_ERROR
-	   || sRef_isStateUndefined (res))
+	   || sRef_isStateUndefined (res)
+	   || sRef_isDefinitelyNull (res))
     { 
       res->aliasinfo = stateInfo_update (res->aliasinfo, other->aliasinfo);
       res->aliaskind = aother;  
     }
-  else if (sRef_isStateUndefined (other))
+  else if (sRef_isStateUndefined (other)
+	   || sRef_isDefinitelyNull (other))
     {
       ;
     }
@@ -8833,6 +9167,8 @@ extern /*@exposed@*/ sRef sRef_makeArrow (sRef s, /*@dependent@*/ cstring f)
   
   p = sRef_makePointer (s);
   ret = sRef_makeField (p, f);
+  DPRINTF (("Arrow: %s => %s",
+	    sRef_unparseFull (s), sRef_unparseFull (ret)));
   return ret;
 }
 
@@ -8904,11 +9240,13 @@ static /*@null@*/ sinfo sinfo_copy (/*@notnull@*/ sRef s)
       ret = (sinfo) dmalloc (sizeof (*ret));
       ret->spec = s->info->spec;
       break;
+
     case SK_UNCONSTRAINED:
     case SK_NEW:
       ret = (sinfo) dmalloc (sizeof (*ret));
       ret->fname = s->info->fname;
       break;
+
     case SK_RESULT:
     case SK_CONST:
     case SK_TYPE:
@@ -9197,11 +9535,12 @@ static speckind speckind_fromInt (int i)
 }
 
 
-static void sRef_updateNullState (sRef res, sRef other)
+static void sRef_updateNullState (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other)
      /*@modifies res@*/
 {
   res->nullstate = other->nullstate;
   res->nullinfo = stateInfo_update (res->nullinfo, other->nullinfo);
+  sRef_resetAliasKind (res);
 }
 
 void sRef_combineNullState (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other)
@@ -9261,11 +9600,12 @@ void sRef_combineNullState (/*@notnull@*/ sRef res, /*@notnull@*/ sRef other)
     }
 
   res->nullstate = nn;
+  sRef_resetAliasKind (res);
 }
 
 cstring sRef_nullMessage (sRef s)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   switch (sRef_getNullState (s))
     {
@@ -9280,7 +9620,7 @@ cstring sRef_nullMessage (sRef s)
 
 /*@observer@*/ cstring sRef_ntMessage (sRef s)
 {
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   switch (s->nullstate)
     {
@@ -9300,7 +9640,7 @@ sRef sRef_fixResultType (/*@returned@*/ sRef s, ctype typ, uentry ue)
   sRef tmp = sRef_undefined;
   sRef ret;
 
-  llassert (sRef_isValid (s));
+  llassert (sRef_isReasonable (s));
 
   switch (s->kind)
     {
@@ -9436,63 +9776,63 @@ bool sRef_isDependent (sRef s)
 
 bool sRef_isOwned (sRef s)
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_OWNED));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_OWNED));
 }
 
 bool sRef_isKeep (sRef s) 
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_KEEP));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_KEEP));
 }
 
 bool sRef_isTemp (sRef s)
 {
-  return (sRef_isValid (s) && alkind_isTemp (s->aliaskind));
+  return (sRef_isReasonable (s) && alkind_isTemp (s->aliaskind));
 }
 
 bool sRef_isLocalState (sRef s) 
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_LOCAL));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_LOCAL));
 }
 
 bool sRef_isUnique (sRef s)
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_UNIQUE));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_UNIQUE));
 }
 
 bool sRef_isShared (sRef s) 
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_SHARED));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_SHARED));
 }
 
 bool sRef_isExposed (sRef s) 
 {
-  return (sRef_isValid (s) && (s->expkind == XO_EXPOSED));
+  return (sRef_isReasonable (s) && (s->expkind == XO_EXPOSED));
 }
 
 bool sRef_isObserver (sRef s) 
 {
-  return (sRef_isValid (s) && (s->expkind == XO_OBSERVER));
+  return (sRef_isReasonable (s) && (s->expkind == XO_OBSERVER));
 }
 
 bool sRef_isFresh (sRef s) 
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_FRESH));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_FRESH));
 }
 
 bool sRef_isDefinitelyNull (sRef s) 
 {
-  return (sRef_isValid (s) && (sRef_getNullState (s) == NS_DEFNULL 
+  return (sRef_isReasonable (s) && (sRef_getNullState (s) == NS_DEFNULL 
 			       || sRef_getNullState (s) == NS_CONSTNULL));
 }
 
 bool sRef_isAllocated (sRef s)
 {
-  return (sRef_isValid (s) && (s->defstate == SS_ALLOCATED));
+  return (sRef_isReasonable (s) && (s->defstate == SS_ALLOCATED));
 }
 
 bool sRef_isStack (sRef s)
 {
-  return (sRef_isValid (s) && (s->aliaskind == AK_STACK));
+  return (sRef_isReasonable (s) && (s->aliaskind == AK_STACK));
 }
 
 bool sRef_isNotNull (sRef s)
@@ -9513,7 +9853,7 @@ alkind sRef_getAliasKind (sRef s)
 
 nstate sRef_getNullState (sRef s)
 {
-  if (sRef_isValid (s)) {
+  if (sRef_isReasonable (s)) {
     llassert (nstate_isValid (s->nullstate));
     return s->nullstate;
   }
@@ -9523,14 +9863,16 @@ nstate sRef_getNullState (sRef s)
 
 void sRef_reflectAnnotation (sRef s, annotationInfo a, fileloc loc)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (!valueTable_isDefined (s->state))
 	{
 	  s->state = valueTable_create (1);
-	  valueTable_insert (s->state, 
-			     cstring_copy (metaStateInfo_getName (annotationInfo_getState (a))),
-			     stateValue_create (annotationInfo_getValue (a), stateInfo_makeLoc (loc)));
+	  valueTable_insert
+	    (s->state, 
+	     cstring_copy (metaStateInfo_getName (annotationInfo_getState (a))),
+	     stateValue_create (annotationInfo_getValue (a), 
+				stateInfo_makeLoc (loc, SA_DECLARED)));
 	}
       else
 	{
@@ -9538,8 +9880,9 @@ void sRef_reflectAnnotation (sRef s, annotationInfo a, fileloc loc)
 	  valueTable_update 
 	    (s->state,
 	     metaStateInfo_getName (annotationInfo_getState (a)),
-	     stateValue_create (annotationInfo_getValue (a), stateInfo_makeLoc (loc)));
-	  DPRINTF (("state info: %s", stateInfo_unparse (stateInfo_makeLoc (loc))));
+	     stateValue_create (annotationInfo_getValue (a),
+				stateInfo_makeLoc (loc, SA_DECLARED)));
+	  
 	  DPRINTF (("sref: %s", sRef_unparse (s)));
 	  DPRINTF (("sref: %s", sRef_unparseFull (s)));
 	}
@@ -9554,7 +9897,7 @@ void sRef_setMetaStateValueComplete (sRef s, cstring key, int value, fileloc loc
 
   sRefSet_realElements (aliases, current)
     {
-      if (sRef_isValid (current))
+      if (sRef_isReasonable (current))
 	{
 	  current = sRef_updateSref (current);
 	  sRef_setMetaStateValue (current, key, value, loc);
@@ -9568,21 +9911,33 @@ void sRef_setMetaStateValue (sRef s, cstring key, int value, fileloc loc)
 {
   sRef_checkMutable (s);
 
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (!valueTable_isDefined (s->state))
 	{
 	  DPRINTF (("inserting state: %s: %s %d", sRef_unparse (s), key, value));
 	  s->state = valueTable_create (1);
 	  valueTable_insert (s->state, cstring_copy (key),
-			     stateValue_create (value, stateInfo_makeLoc (loc)));
+			     stateValue_create (value, 
+						stateInfo_makeLoc (loc, SA_CHANGED)));
 	}
       else
 	{
 	  DPRINTF (("Updating state: %s: %s %d / %s", sRef_unparse (s), key, value,
 		    fileloc_unparse (loc)));
-	  valueTable_update 
-	    (s->state, key, stateValue_create (value, stateInfo_makeLoc (loc)));
+	  if (valueTable_contains (s->state, key))
+	    {
+	      valueTable_update 
+		(s->state, key, stateValue_create (value,
+						   stateInfo_makeLoc (loc, SA_CHANGED)));
+	    }
+	  else
+	    {
+	      valueTable_insert 
+		(s->state, cstring_copy (key),
+		 stateValue_create (value, stateInfo_makeLoc (loc, SA_CHANGED)));
+	    }
+
 	  DPRINTF (("After: %s", sRef_unparseFull (s)));
 	}
     }
@@ -9590,7 +9945,7 @@ void sRef_setMetaStateValue (sRef s, cstring key, int value, fileloc loc)
 
 bool sRef_checkMetaStateValue (sRef s, cstring key, int value)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (valueTable_isDefined (s->state))
 	{
@@ -9616,14 +9971,14 @@ bool sRef_checkMetaStateValue (sRef s, cstring key, int value)
 
 /*@observer@*/ stateValue sRef_getMetaStateValue (sRef s, cstring key)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       if (valueTable_isDefined (s->state))
 	{
 	  stateValue val;
 	  
 	  val = valueTable_lookup (s->state, key);
-	  llassert (stateValue_isDefined (val));
+	  /* Okay if its not defined, just returns stateValue_undefined */
 	  return val;
 	}
       else
@@ -9641,9 +9996,9 @@ bool sRef_checkMetaStateValue (sRef s, cstring key, int value)
 {
   DPRINTF (("Get value table: %s", sRef_unparse (s)));
 
-  if (sRef_isValid (s)) 
+  if (sRef_isReasonable (s)) 
     {
-      llassert (sRef_isValid (s));
+      llassert (sRef_isReasonable (s));
       DPRINTF (("Value table: %s", valueTable_unparse (s->state)));
       return s->state;
     }  
@@ -9660,18 +10015,18 @@ bool sRef_makeStateSpecial (sRef s)
   ** Default defined state can be made special.
   */
 
-  llassert (sRef_isValid (s)); /*@i523 why doesn't null-checking work!??? */
+  llassert (sRef_isReasonable (s)); /*@i523 why doesn't null-checking work!??? */
 
   if (s->defstate == SS_UNKNOWN || s->defstate == SS_DEFINED || s->defstate == SS_SPECIAL)
     {
-      s->aliaskind = AK_IMPTEMP;
+      /* s->aliaskind = AK_IMPTEMP; */ /* evans 2001-07-23 shouldn't effect alias state */
       s->defstate = SS_SPECIAL;
       DPRINTF (("Made special: %s", sRef_unparseFull (s)));
       return TRUE;
     }
   else
     {
-      s->aliaskind = AK_IMPTEMP;
+      /* s->aliaskind = AK_IMPTEMP; */
       s->defstate = SS_SPECIAL;
       return FALSE;
     }
@@ -9679,7 +10034,7 @@ bool sRef_makeStateSpecial (sRef s)
 
 void sRef_markImmutable (sRef s)
 {
-  if (sRef_isValid (s))
+  if (sRef_isReasonable (s))
     {
       DPRINTF (("Mark immutable: %s", sRef_unparseFull (s)));
       s->immut = TRUE;
@@ -9712,7 +10067,7 @@ struct s_bbufinfo sRef_getNullTerminatedState (sRef p_s) {
 }
 
 void sRef_setNullTerminatedState(sRef p_s) {
-   if(sRef_isValid (p_s)) {
+   if(sRef_isReasonable (p_s)) {
       p_s->bufinfo.bufstate = BB_NULLTERMINATED;
    } else {
       llfatalbug( message("sRef_setNT passed a invalid sRef\n"));
@@ -9721,7 +10076,7 @@ void sRef_setNullTerminatedState(sRef p_s) {
 
 
 void sRef_setPossiblyNullTerminatedState(sRef p_s) {
-   if( sRef_isValid (p_s)) {
+   if( sRef_isReasonable (p_s)) {
       p_s->bufinfo.bufstate = BB_POSSIBLYNULLTERMINATED;
    } else {
       llfatalbug( message("sRef_setPossNT passed a invalid sRef\n"));
@@ -9729,7 +10084,7 @@ void sRef_setPossiblyNullTerminatedState(sRef p_s) {
 }
 
 void sRef_setNotNullTerminatedState(sRef p_s) {
-   if( sRef_isValid (p_s)) {
+   if( sRef_isReasonable (p_s)) {
       p_s->bufinfo.bufstate = BB_NOTNULLTERMINATED;
    } else {
       llfatalbug( message("sRef_unsetNT passed a invalid sRef\n"));
@@ -9737,28 +10092,37 @@ void sRef_setNotNullTerminatedState(sRef p_s) {
 }
 
 void sRef_setLen(sRef p_s, int len) {
-   if( sRef_isValid (p_s) && sRef_isNullTerminated(p_s)) {
-      p_s->bufinfo.len = len;
-   } else {
-      llfatalbug( message("sRef_setLen passed a invalid sRef\n"));
-   }
+   if (sRef_isReasonable (p_s) && sRef_isNullTerminated(p_s)) 
+     {
+       p_s->bufinfo.len = len;
+     } 
+   else 
+     {
+       llfatalbug( message("sRef_setLen passed an invalid sRef\n"));
+     }
 }
     
 
 void sRef_setSize(sRef p_s, int size) {
-   if( sRef_isValid(p_s)) {
+   if( sRef_isValid(p_s)) 
+     {
        p_s->bufinfo.size = size;
-   } else {
-      llfatalbug( message("sRef_setSize passed a invalid sRef\n"));
-   }
+     } 
+   else
+     {
+       llfatalbug( message("sRef_setSize passed a invalid sRef\n"));
+     }
 }
 
 void sRef_resetLen(sRef p_s) {
-	if (sRef_isValid (p_s)) {
-		p_s->bufinfo.len = 0;
-	} else {
-		llfatalbug (message ("sRef_setLen passed an invalid sRef\n"));
-	}
+  if (sRef_isReasonable (p_s)) 
+    {
+      p_s->bufinfo.len = 0;
+    }
+  else
+    {
+      llfatalbug (message ("sRef_setLen passed an invalid sRef\n"));
+    }
 }
 
 /*drl7x 11/28/2000 */
@@ -9769,21 +10133,41 @@ bool sRef_isFixedArray (sRef p_s) /*@*/ {
   return ( ctype_isFixedArray (c) );
 }
 
-long int sRef_getArraySize (sRef p_s) /*@*/ {
+size_t sRef_getArraySize (sRef p_s) /*@*/ 
+{
   ctype c;
   llassert (sRef_isFixedArray(p_s) );
   DPRINTF (( message ("sRef_getArraySize getting array size for %s", sRef_unparse(p_s) )  ));
   
   c = sRef_getType (p_s);
-
-  return (ctype_getArraySize (c) );
+  return (ctype_getArraySize (c));
 }
 
+void sRef_setValue (sRef s, multiVal val)
+{
+  if (!sRef_isReasonable (s))
+    {
+      llcontbuglit ("Unreasonable sRef");
+      llcontbug (message ("sRef: %s", sRef_unparse (s)));
+      return;
+    }
 
+  multiVal_free (s->val);
+  s->val = val;
+}
 
+bool sRef_hasValue (sRef s)
+{
+  return (sRef_isReasonable (s)
+	  && multiVal_isDefined (s->val));
+}
 
+multiVal sRef_getValue (sRef s)
+{
+  if (sRef_isReasonable (s))
+    {
+      return s->val;
+    }
 
-
-
-
-
+  return multiVal_undefined;
+}