[splint.git] / src / varKinds.c

/*
** LCLint - annotation-assisted static program checker
** Copyright (C) 1994-2000 University of Virginia,
**         Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 2 of the License, or (at your
** option) any later version.
** 
** This program is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** General Public License for more details.
** 
** The GNU General Public License is available from http://www.gnu.org/ or
** 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
*/
/*
** varKinds.c
*/

# include "lclintMacros.nf"
# include "basic.h"

alkind alkind_fromInt (int n)
{
  /*@+enumint@*/
  llassert (n >= AK_UNKNOWN && n <= AK_LOCAL);
  /*@=enumint@*/

  return ((alkind)n);
}

nstate nstate_fromInt (int n)
{
  /*@+enumint@*/
  llassert (n >= NS_ERROR && n <= NS_ABSNULL);
  /*@=enumint@*/

  return ((nstate)n);
}

sstate sstate_fromInt (int n)
{
  /*@+enumint@*/
  llassert (n >= SS_UNKNOWN && n < SS_LAST);
  /*@=enumint@*/

  return ((sstate)n);
}

exkind exkind_fromInt (int n)
{
  /*@+enumint@*/
  llassert (n >= XO_UNKNOWN && n <= XO_OBSERVER);
  /*@=enumint@*/

  return ((exkind) n);
}

cstring sstate_unparse (sstate s)
{
  switch (s)
    {
    case SS_UNKNOWN:   return cstring_makeLiteralTemp ("unknown");
    case SS_UNUSEABLE: return cstring_makeLiteralTemp ("unuseable");
    case SS_UNDEFINED: return cstring_makeLiteralTemp ("undefined");
    case SS_MUNDEFINED:return cstring_makeLiteralTemp ("possibly undefined");
    case SS_ALLOCATED: return cstring_makeLiteralTemp ("allocated");
    case SS_PDEFINED:  return cstring_makeLiteralTemp ("partially defined");
    case SS_DEFINED:   return cstring_makeLiteralTemp ("defined");
    case SS_PARTIAL:   return cstring_makeLiteralTemp ("partial");
    case SS_SPECIAL:   return cstring_makeLiteralTemp ("special");
    case SS_DEAD:      return cstring_makeLiteralTemp ("dead");
    case SS_HOFFA:     return cstring_makeLiteralTemp ("probably dead");
    case SS_FIXED:     return cstring_makeLiteralTemp ("unmodifiable");
    case SS_RELDEF:    return cstring_makeLiteralTemp ("reldef");
    case SS_LAST:      llcontbuglit ("sstate_unparse: last");
                       return cstring_makeLiteralTemp ("<error>");
    case SS_UNDEFGLOB:     return cstring_makeLiteralTemp ("undefglob");
    case SS_KILLED:    return cstring_makeLiteralTemp ("killed");
    case SS_UNDEFKILLED:
      return cstring_makeLiteralTemp ("undefkilled");
    }

  BADEXIT;
}

bool nstate_possiblyNull (nstate n)
{
  /*
  ** note: not NS_UNKNOWN or NS_ERROR 
  */

  return ((n >= NS_CONSTNULL) && (n <= NS_ABSNULL));
}

bool nstate_perhapsNull (nstate n)
{
  /*
  ** note: not NS_UNKNOWN or NS_ERROR 
  */

  return ((n >= NS_RELNULL) && (n <= NS_ABSNULL));
}

cstring nstate_unparse (nstate n)
{
  switch (n)
    {
    case NS_ERROR:     return cstring_makeLiteralTemp ("<null error>");
    case NS_UNKNOWN:   return cstring_makeLiteralTemp ("implicitly non-null");
    case NS_POSNULL:   return cstring_makeLiteralTemp ("null");
    case NS_DEFNULL:   return cstring_makeLiteralTemp ("null");
    case NS_NOTNULL:   return cstring_makeLiteralTemp ("notnull");
    case NS_MNOTNULL:  return cstring_makeLiteralTemp ("notnull");
    case NS_ABSNULL:   return cstring_makeLiteralTemp ("null");
    case NS_RELNULL:   return cstring_makeLiteralTemp ("relnull");
    case NS_CONSTNULL: return cstring_makeLiteralTemp ("null");
    }

  BADEXIT;
}

/*
** ??? (used to do something different for guarded)
*/

int nstate_compare (nstate n1, nstate n2)
{
  return (generic_compare (n1, n2));
}

/*
** This occurs when we select a field with alkind inner, 
** from a structure with alkind outer.  It is probably
** unnecessary.
*/

alkind alkind_derive (alkind outer, alkind inner)
{
  switch (outer)
    {
    case AK_ERROR:
    case AK_UNKNOWN: return inner;
    case AK_KEPT:
    case AK_KEEP:
    case AK_ONLY: 
    case AK_IMPONLY:
    case AK_OWNED:
    case AK_IMPDEPENDENT:
    case AK_DEPENDENT:
      if (inner == AK_SHARED) return AK_SHARED;
      else return outer;
      /* not so sure about these? */
    case AK_REFCOUNTED:
    case AK_NEWREF:
    case AK_KILLREF:
    case AK_REFS:
    case AK_STACK:
    case AK_STATIC:
      return outer;
    case AK_TEMP: 
    case AK_IMPTEMP:
    case AK_SHARED:
    case AK_UNIQUE:
    case AK_LOCAL: 
    case AK_FRESH:
    case AK_RETURNED:
      if (alkind_isKnown (inner)) return inner; 
      else return outer;
    }
  BADEXIT;
}

cstring alkind_unparse (alkind a)
{
  switch (a)
    {
    case AK_ERROR:           return cstring_makeLiteralTemp ("<error>");
    case AK_UNKNOWN:         return cstring_makeLiteralTemp ("unqualified");
    case AK_ONLY:            return cstring_makeLiteralTemp ("only");
    case AK_IMPONLY:         return cstring_makeLiteralTemp ("implicitly only");
    case AK_OWNED:           return cstring_makeLiteralTemp ("owned");
    case AK_IMPDEPENDENT:    return cstring_makeLiteralTemp ("implicitly dependent");
    case AK_DEPENDENT:       return cstring_makeLiteralTemp ("dependent");
    case AK_KEEP:            return cstring_makeLiteralTemp ("keep");
    case AK_KEPT:            return cstring_makeLiteralTemp ("kept");
    case AK_IMPTEMP:         return cstring_makeLiteralTemp ("implicitly temp");
    case AK_TEMP:            return cstring_makeLiteralTemp ("temp");
    case AK_SHARED:          return cstring_makeLiteralTemp ("shared");
    case AK_UNIQUE:          return cstring_makeLiteralTemp ("unique");
    case AK_RETURNED:        return cstring_makeLiteralTemp ("returned");
    case AK_FRESH:           return cstring_makeLiteralTemp ("fresh");
    case AK_STACK:           return cstring_makeLiteralTemp ("stack");
    case AK_REFCOUNTED:      return cstring_makeLiteralTemp ("refcounted");
    case AK_REFS:            return cstring_makeLiteralTemp ("refs");
    case AK_KILLREF:         return cstring_makeLiteralTemp ("killref");
    case AK_NEWREF:          return cstring_makeLiteralTemp ("newref");
    case AK_LOCAL:           return cstring_makeLiteralTemp ("local");
    case AK_STATIC:          return cstring_makeLiteralTemp ("unqualified static");
    }
    BADEXIT;
}

cstring exkind_unparse (exkind a)
{
  switch (a)
    {
    case XO_UNKNOWN:         return cstring_makeLiteralTemp ("unknown");
    case XO_NORMAL:          return cstring_makeLiteralTemp ("unexposed");
    case XO_EXPOSED:         return cstring_makeLiteralTemp ("exposed");
    case XO_OBSERVER:        return cstring_makeLiteralTemp ("observer");
    }
  BADEXIT;
}

cstring exkind_capName (exkind a)
{
  switch (a)
    {
    case XO_UNKNOWN:         return cstring_makeLiteralTemp ("Unknown");
    case XO_NORMAL:          return cstring_makeLiteralTemp ("Unexposed");
    case XO_EXPOSED:         return cstring_makeLiteralTemp ("Exposed");
    case XO_OBSERVER:        return cstring_makeLiteralTemp ("Observer");
    }
  BADEXIT;
}

cstring exkind_unparseError (exkind a)
{
  switch (a)
    {
    case XO_UNKNOWN:         return cstring_makeLiteralTemp ("unqualified");
    case XO_NORMAL:          return cstring_makeLiteralTemp ("unqualifier");
    case XO_EXPOSED:         return cstring_makeLiteralTemp ("exposed");
    case XO_OBSERVER:        return cstring_makeLiteralTemp ("observer");
    }
  BADEXIT;
}

cstring alkind_capName (alkind a)
{
  switch (a)
    {
    case AK_ERROR:    
      return cstring_makeLiteralTemp ("<Error>");
    case AK_UNKNOWN:     
      return cstring_makeLiteralTemp ("Unqualified");
    case AK_ONLY:  
      return cstring_makeLiteralTemp ("Only");
    case AK_IMPONLY:
      return cstring_makeLiteralTemp ("Implicitly only");
    case AK_OWNED:
      return cstring_makeLiteralTemp ("Owned");
    case AK_IMPDEPENDENT:  
      return cstring_makeLiteralTemp ("Implicitly dependent");
    case AK_DEPENDENT:  
      return cstring_makeLiteralTemp ("Dependent");
    case AK_KEEP:     
      return cstring_makeLiteralTemp ("Keep");
    case AK_KEPT:    
      return cstring_makeLiteralTemp ("Kept");
    case AK_IMPTEMP:   
      return cstring_makeLiteralTemp ("Implicitly temp");
    case AK_TEMP:    
      return cstring_makeLiteralTemp ("Temp");
    case AK_SHARED:
      return cstring_makeLiteralTemp ("Shared");
    case AK_UNIQUE:    
      return cstring_makeLiteralTemp ("Unique");
    case AK_RETURNED:
      return cstring_makeLiteralTemp ("Returned");
    case AK_FRESH:   
      return cstring_makeLiteralTemp ("Fresh");
    case AK_STACK:      
      return cstring_makeLiteralTemp ("Stack");
    case AK_REFCOUNTED: 
      return cstring_makeLiteralTemp ("Refcounted");
    case AK_REFS:
      return cstring_makeLiteralTemp ("Refs");
    case AK_KILLREF: 
      return cstring_makeLiteralTemp ("Killref");
    case AK_NEWREF:    
      return cstring_makeLiteralTemp ("Newref");
    case AK_LOCAL:    
      return cstring_makeLiteralTemp ("Local");
    case AK_STATIC: 
      return cstring_makeLiteralTemp ("Unqualified static");
    }
  BADEXIT;
}

exkind
exkind_fromQual (qual q)
{
  if (qual_isExposed (q))     return XO_EXPOSED;
  if (qual_isObserver (q))    return XO_OBSERVER;
  else
    {
      llcontbug (message ("exkind_fromQual: not exp qualifier: %d" , (int)q));
      return XO_UNKNOWN;
    }
}

sstate
sstate_fromQual (qual q)
{
  if (qual_isOut (q))          return SS_ALLOCATED;
  if (qual_isIn (q))           return SS_DEFINED;
  else if (qual_isPartial (q)) return SS_PARTIAL;
  else if (qual_isRelDef (q))  return SS_RELDEF;
  else if (qual_isUndef (q))   return SS_UNDEFGLOB;
  else if (qual_isKilled (q))  return SS_KILLED;
  else if (qual_isSpecial (q)) return SS_SPECIAL;
  else
    {
      llcontbug (message ("sstate_fromQual: not alias qualifier: %s (%d)" , 
			  qual_unparse (q),
			  (int)q));
      return SS_UNKNOWN;
    }
}

exitkind
exitkind_fromQual (qual q)
{
  if (qual_isExits (q))     return XK_MUSTEXIT;
  if (qual_isMayExit (q))   return XK_MAYEXIT;
  if (qual_isTrueExit (q))  return XK_TRUEEXIT;
  if (qual_isFalseExit (q)) return XK_FALSEEXIT;
  if (qual_isNeverExit (q)) return XK_NEVERESCAPE;
  else
    {
      llcontbug (message ("exitkind_fromQual: not exit qualifier: %s",
			  qual_unparse (q)));
      return XK_UNKNOWN;
    }
}

alkind
alkind_fromQual (qual q)
{
  if (qual_isOnly (q))       return AK_ONLY;
  if (qual_isImpOnly (q))    return AK_IMPONLY;
  if (qual_isKeep (q))       return AK_KEEP;
  if (qual_isKept (q))       return AK_KEPT;
  if (qual_isTemp (q))       return AK_TEMP;
  if (qual_isShared (q))     return AK_SHARED;
  if (qual_isUnique (q))     return AK_UNIQUE;
  if (qual_isRefCounted (q)) return AK_REFCOUNTED;
  if (qual_isRefs (q))       return AK_REFS;
  if (qual_isNewRef (q))     return AK_NEWREF;
  if (qual_isKillRef (q))    return AK_KILLREF;
  if (qual_isTempRef (q))    return AK_KILLREF; /* kludge? use kill ref for this */
  if (qual_isOwned (q))      return AK_OWNED;
  if (qual_isDependent (q))  return AK_DEPENDENT;

  llcontbug (message ("alkind_fromQual: not alias qualifier: %d" , (int)q));
  return AK_ERROR;
}    

static bool alkind_isMeaningless (alkind a1)
{
  return (a1 == AK_ERROR || a1 == AK_UNKNOWN || a1 == AK_RETURNED
	  || a1 == AK_STACK || a1 == AK_REFCOUNTED
	  || a1 == AK_REFS || a1 == AK_KILLREF || a1 == AK_NEWREF
	  || a1 == AK_LOCAL);
}

bool alkind_compatible (alkind a1, alkind a2)
{
  if (a1 == a2) return TRUE;
  if (a2 == AK_ERROR) return TRUE;
  if (a2 == AK_UNKNOWN)
    {
      return (alkind_isMeaningless (a1) || (a1 == AK_IMPTEMP));
    }

  switch (a1)
    {
    case AK_ERROR:               return TRUE;
    case AK_UNKNOWN:             return (alkind_isMeaningless (a2)
					 || (a2 == AK_IMPTEMP));
    case AK_IMPONLY:             return (a2 == AK_KEEP || a2 == AK_FRESH 
					 || a2 == AK_ONLY);
    case AK_ONLY:                return (a2 == AK_KEEP || a2 == AK_FRESH
					 || a2 == AK_IMPONLY);
    case AK_OWNED:               return FALSE;
    case AK_IMPDEPENDENT:        return (a2 == AK_DEPENDENT);
    case AK_DEPENDENT:           return (a2 == AK_IMPDEPENDENT);
    case AK_KEEP:                return (a2 == AK_ONLY || a2 == AK_FRESH
					 || a2 == AK_IMPONLY);
    case AK_KEPT:                return FALSE;
    case AK_IMPTEMP:             return (a2 == AK_TEMP);
    case AK_TEMP:                return (a2 == AK_IMPTEMP);
    case AK_SHARED:              return FALSE;
    case AK_UNIQUE:              return (a2 == AK_TEMP);
    case AK_RETURNED:            return (alkind_isMeaningless (a2));
    case AK_FRESH:               return (alkind_isOnly (a2));
    case AK_STACK:               return (alkind_isMeaningless (a2));
    case AK_REFCOUNTED:          return (alkind_isMeaningless (a2));
    case AK_REFS:                return (alkind_isMeaningless (a2));
    case AK_KILLREF:             return (alkind_isMeaningless (a2));
    case AK_NEWREF:              return (alkind_isMeaningless (a2));
    case AK_LOCAL:               return (alkind_isMeaningless (a2));
    case AK_STATIC:              return (alkind_isMeaningless (a2));
    }
  BADEXIT;
}

bool alkind_equal (alkind a1, alkind a2)
{
  if (a1 == a2) return TRUE;
  if (a2 == AK_ERROR) return TRUE;

  switch (a1)
    {
    case AK_ERROR:               return TRUE;
    case AK_IMPONLY:             return (a2 == AK_ONLY);
    case AK_ONLY:                return (a2 == AK_IMPONLY);
    case AK_IMPDEPENDENT:        return (a2 == AK_DEPENDENT);
    case AK_DEPENDENT:           return (a2 == AK_IMPDEPENDENT);
    case AK_IMPTEMP:             return (a2 == AK_TEMP);
    case AK_TEMP:                return (a2 == AK_IMPTEMP);
    default:                     return FALSE;
    }

  BADEXIT;
}

alkind
alkind_fixImplicit (alkind a)
{
  if (a == AK_IMPTEMP) return AK_TEMP;
  if (a == AK_IMPONLY) return AK_IMPONLY;
  if (a == AK_IMPDEPENDENT) return AK_DEPENDENT;

  return a;
}

cstring exitkind_unparse (exitkind k)
{
  switch (k)
    {
    case XK_ERROR:       return (cstring_makeLiteralTemp ("<error>"));
    case XK_UNKNOWN:     return (cstring_makeLiteralTemp ("?"));
    case XK_NEVERESCAPE: return (cstring_makeLiteralTemp ("never escape"));
    case XK_MAYEXIT:     return (cstring_makeLiteralTemp ("mayexit"));
    case XK_MUSTEXIT:    return (cstring_makeLiteralTemp ("exits"));
    case XK_TRUEEXIT:    return (cstring_makeLiteralTemp ("trueexit"));
    case XK_FALSEEXIT:   return (cstring_makeLiteralTemp ("falseexit"));
    case XK_MUSTRETURN:  return (cstring_makeLiteralTemp ("mustreturn"));
    case XK_MAYRETURN:   return (cstring_makeLiteralTemp ("mayreturn"));
    case XK_MUSTRETURNEXIT: return (cstring_makeLiteralTemp ("mustreturnexit"));
    case XK_MAYRETURNEXIT: return (cstring_makeLiteralTemp ("mayreturnexit"));
    case XK_GOTO:        return (cstring_makeLiteralTemp ("goto"));
    case XK_MAYGOTO:     return (cstring_makeLiteralTemp ("maygoto"));
    }
  
 BADEXIT;
}

exitkind exitkind_makeConditional (exitkind k)
{
  switch (k)
    {
    case XK_TRUEEXIT:
    case XK_FALSEEXIT: 
    case XK_MUSTEXIT:       return XK_MAYEXIT;
    case XK_MUSTRETURN:     return XK_MAYRETURN;
    case XK_MUSTRETURNEXIT: return XK_MAYRETURNEXIT;
    case XK_GOTO:           return XK_MAYGOTO;
    default:                return k;
    }
}

exitkind exitkind_combine (exitkind k1, exitkind k2)
{
  if (k1 == k2)
    {
      return k1;
    }

  if (k2 == XK_ERROR)
    {
      return XK_ERROR;
    }

  switch (k1)
    {
    case XK_ERROR: return XK_ERROR;
    case XK_UNKNOWN:     
    case XK_NEVERESCAPE: return (exitkind_makeConditional (k2));
    case XK_MUSTEXIT:    
      switch (k2)
	{
	case XK_MUSTRETURNEXIT:
	case XK_MUSTRETURN: return XK_MUSTRETURNEXIT;
	case XK_MAYRETURNEXIT:
	case XK_MAYRETURN:  return XK_MAYRETURNEXIT;
	default:             return XK_MAYEXIT;
	}
      BADEXIT;

    case XK_MAYEXIT:     
    case XK_TRUEEXIT:    
    case XK_FALSEEXIT:   
      switch (k2)
	{
	case XK_MUSTRETURNEXIT:
	case XK_MAYRETURNEXIT:
	case XK_MAYRETURN:
	case XK_MUSTRETURN: return XK_MAYRETURNEXIT;
	default:             return XK_MAYEXIT;
	}
      BADEXIT;

    case XK_MUSTRETURN:
      switch (k2)
	{
	case XK_MUSTRETURNEXIT:
	case XK_MUSTEXIT:    return XK_MUSTRETURNEXIT;
	case XK_MAYRETURNEXIT:
	case XK_TRUEEXIT:
	case XK_FALSEEXIT:
	case XK_MAYEXIT:     return XK_MAYRETURNEXIT;
	default:              return XK_MAYRETURN;
	}
      BADEXIT;

    case XK_MAYRETURN:
      if (exitkind_couldExit (k2))
	{
	  return XK_MAYRETURNEXIT;
	}
      else
	{
	  return XK_MAYRETURN;
	}

    case XK_MUSTRETURNEXIT: 
      switch (k2)
	{
	case XK_MUSTRETURN:
	case XK_MUSTEXIT:    return XK_MUSTRETURNEXIT;
	default:              return XK_MAYRETURNEXIT;
	}
      BADEXIT;

    case XK_MAYRETURNEXIT:   return XK_MAYRETURNEXIT;
    case XK_GOTO:
    case XK_MAYGOTO:         
      if (exitkind_couldExit (k2))
	{
	  return XK_MAYRETURNEXIT;
	}
      return XK_MAYGOTO;
    }
  
 BADEXIT;
}

bool exitkind_couldExit (exitkind e)
{
  switch (e)
    {
    case XK_MAYEXIT:
    case XK_MUSTEXIT:
    case XK_TRUEEXIT:
    case XK_FALSEEXIT:
    case XK_MAYRETURNEXIT:
    case XK_MUSTRETURNEXIT: 
    case XK_GOTO:
    case XK_MAYGOTO: return TRUE;
    default: return FALSE;
    }
}

static bool exitkind_couldReturn (exitkind e) /*@*/ 
{
  switch (e)
    {
    case XK_MUSTRETURN:
    case XK_MAYRETURN:
    case XK_MAYRETURNEXIT:
    case XK_MUSTRETURNEXIT:  return TRUE;
    default: return FALSE;
    }
}

static bool exitkind_couldGoto (exitkind e) /*@*/
{
  return (e == XK_GOTO || e == XK_MAYGOTO);
}

bool exitkind_couldEscape (exitkind e)
{
  return exitkind_couldReturn (e) || exitkind_couldExit (e)
    || exitkind_couldGoto (e);
}

exitkind exitkind_fromInt (int x)
{
  /*@+enumint@*/
  llassert (x >= XK_ERROR && x <= XK_LAST);
  /*@=enumint@*/

  return (exitkind) x;
}
Commit	Line	Data
885824d3	1	/*
	2	** LCLint - annotation-assisted static program checker
	3	** Copyright (C) 1994-2000 University of Virginia,
	4	** Massachusetts Institute of Technology
	5	**
	6	** This program is free software; you can redistribute it and/or modify it
	7	** under the terms of the GNU General Public License as published by the
	8	** Free Software Foundation; either version 2 of the License, or (at your
	9	** option) any later version.
	10	**
	11	** This program is distributed in the hope that it will be useful, but
	12	** WITHOUT ANY WARRANTY; without even the implied warranty of
	13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	** General Public License for more details.
	15	**
	16	** The GNU General Public License is available from http://www.gnu.org/ or
	17	** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	18	** MA 02111-1307, USA.
	19	**
	20	** For information on lclint: lclint-request@cs.virginia.edu
	21	** To report a bug: lclint-bug@cs.virginia.edu
	22	** For more information: http://lclint.cs.virginia.edu
	23	*/
	24	/*
	25	** varKinds.c
	26	*/
	27
	28	# include "lclintMacros.nf"
	29	# include "basic.h"
	30
	31	alkind alkind_fromInt (int n)
	32	{
	33	/@+enumint@/
	34	llassert (n >= AK_UNKNOWN && n <= AK_LOCAL);
	35	/@=enumint@/
	36
	37	return ((alkind)n);
	38	}
	39
	40	nstate nstate_fromInt (int n)
	41	{
	42	/@+enumint@/
	43	llassert (n >= NS_ERROR && n <= NS_ABSNULL);
	44	/@=enumint@/
	45
	46	return ((nstate)n);
	47	}
	48
	49	sstate sstate_fromInt (int n)
	50	{
	51	/@+enumint@/
	52	llassert (n >= SS_UNKNOWN && n < SS_LAST);
	53	/@=enumint@/
	54
	55	return ((sstate)n);
	56	}
	57
	58	exkind exkind_fromInt (int n)
	59	{
	60	/@+enumint@/
	61	llassert (n >= XO_UNKNOWN && n <= XO_OBSERVER);
	62	/@=enumint@/
	63
	64	return ((exkind) n);
65	}
66
67	cstring sstate_unparse (sstate s)
68	{
69	switch (s)
70	{
71	case SS_UNKNOWN: return cstring_makeLiteralTemp ("unknown");
72	case SS_UNUSEABLE: return cstring_makeLiteralTemp ("unuseable");
73	case SS_UNDEFINED: return cstring_makeLiteralTemp ("undefined");
74	case SS_MUNDEFINED:return cstring_makeLiteralTemp ("possibly undefined");
75	case SS_ALLOCATED: return cstring_makeLiteralTemp ("allocated");
76	case SS_PDEFINED: return cstring_makeLiteralTemp ("partially defined");
77	case SS_DEFINED: return cstring_makeLiteralTemp ("defined");
78	case SS_PARTIAL: return cstring_makeLiteralTemp ("partial");
79	case SS_SPECIAL: return cstring_makeLiteralTemp ("special");
80	case SS_DEAD: return cstring_makeLiteralTemp ("dead");
81	case SS_HOFFA: return cstring_makeLiteralTemp ("probably dead");
82	case SS_FIXED: return cstring_makeLiteralTemp ("unmodifiable");
83	case SS_RELDEF: return cstring_makeLiteralTemp ("reldef");
84	case SS_LAST: llcontbuglit ("sstate_unparse: last");
85	return cstring_makeLiteralTemp ("<error>");
86	case SS_UNDEFGLOB: return cstring_makeLiteralTemp ("undefglob");
87	case SS_KILLED: return cstring_makeLiteralTemp ("killed");
88	case SS_UNDEFKILLED:
89	return cstring_makeLiteralTemp ("undefkilled");
90	}
91
92	BADEXIT;
93	}
94
95	bool nstate_possiblyNull (nstate n)
96	{
97	/*
98	** note: not NS_UNKNOWN or NS_ERROR
99	*/
100
101	return ((n >= NS_CONSTNULL) && (n <= NS_ABSNULL));
102	}
103
104	bool nstate_perhapsNull (nstate n)
105	{
106	/*
107	** note: not NS_UNKNOWN or NS_ERROR
108	*/
109
110	return ((n >= NS_RELNULL) && (n <= NS_ABSNULL));
111	}
112
113	cstring nstate_unparse (nstate n)
114	{
115	switch (n)
116	{
117	case NS_ERROR: return cstring_makeLiteralTemp ("<null error>");
118	case NS_UNKNOWN: return cstring_makeLiteralTemp ("implicitly non-null");
119	case NS_POSNULL: return cstring_makeLiteralTemp ("null");
120	case NS_DEFNULL: return cstring_makeLiteralTemp ("null");
121	case NS_NOTNULL: return cstring_makeLiteralTemp ("notnull");
122	case NS_MNOTNULL: return cstring_makeLiteralTemp ("notnull");
123	case NS_ABSNULL: return cstring_makeLiteralTemp ("null");
124	case NS_RELNULL: return cstring_makeLiteralTemp ("relnull");
125	case NS_CONSTNULL: return cstring_makeLiteralTemp ("null");
126	}
127
128	BADEXIT;
129	}
130
131	/*
132	** ??? (used to do something different for guarded)
133	*/
134
135	int nstate_compare (nstate n1, nstate n2)
136	{
137	return (generic_compare (n1, n2));
138	}
139
140	/*
141	** This occurs when we select a field with alkind inner,
142	** from a structure with alkind outer. It is probably
143	** unnecessary.
144	*/
145
146	alkind alkind_derive (alkind outer, alkind inner)
147	{
148	switch (outer)
149	{
150	case AK_ERROR:
151	case AK_UNKNOWN: return inner;
152	case AK_KEPT:
153	case AK_KEEP:
154	case AK_ONLY:
155	case AK_IMPONLY:
156	case AK_OWNED:
157	case AK_IMPDEPENDENT:
158	case AK_DEPENDENT:
159	if (inner == AK_SHARED) return AK_SHARED;
160	else return outer;
161	/* not so sure about these? */
162	case AK_REFCOUNTED:
163	case AK_NEWREF:
164	case AK_KILLREF:
165	case AK_REFS:
166	case AK_STACK:
167	case AK_STATIC:
168	return outer;
169	case AK_TEMP:
170	case AK_IMPTEMP:
171	case AK_SHARED:
172	case AK_UNIQUE:
173	case AK_LOCAL:
174	case AK_FRESH:
175	case AK_RETURNED:
176	if (alkind_isKnown (inner)) return inner;
177	else return outer;
178	}
179	BADEXIT;
180	}
181
182	cstring alkind_unparse (alkind a)
183	{
184	switch (a)
185	{
186	case AK_ERROR: return cstring_makeLiteralTemp ("<error>");
187	case AK_UNKNOWN: return cstring_makeLiteralTemp ("unqualified");
188	case AK_ONLY: return cstring_makeLiteralTemp ("only");
189	case AK_IMPONLY: return cstring_makeLiteralTemp ("implicitly only");
190	case AK_OWNED: return cstring_makeLiteralTemp ("owned");
191	case AK_IMPDEPENDENT: return cstring_makeLiteralTemp ("implicitly dependent");
192	case AK_DEPENDENT: return cstring_makeLiteralTemp ("dependent");
193	case AK_KEEP: return cstring_makeLiteralTemp ("keep");
194	case AK_KEPT: return cstring_makeLiteralTemp ("kept");
195	case AK_IMPTEMP: return cstring_makeLiteralTemp ("implicitly temp");
196	case AK_TEMP: return cstring_makeLiteralTemp ("temp");
197	case AK_SHARED: return cstring_makeLiteralTemp ("shared");
198	case AK_UNIQUE: return cstring_makeLiteralTemp ("unique");
199	case AK_RETURNED: return cstring_makeLiteralTemp ("returned");
200	case AK_FRESH: return cstring_makeLiteralTemp ("fresh");
201	case AK_STACK: return cstring_makeLiteralTemp ("stack");
202	case AK_REFCOUNTED: return cstring_makeLiteralTemp ("refcounted");
203	case AK_REFS: return cstring_makeLiteralTemp ("refs");
204	case AK_KILLREF: return cstring_makeLiteralTemp ("killref");
205	case AK_NEWREF: return cstring_makeLiteralTemp ("newref");
206	case AK_LOCAL: return cstring_makeLiteralTemp ("local");
207	case AK_STATIC: return cstring_makeLiteralTemp ("unqualified static");
208	}
209	BADEXIT;
210	}
211
212	cstring exkind_unparse (exkind a)
213	{
214	switch (a)
215	{
216	case XO_UNKNOWN: return cstring_makeLiteralTemp ("unknown");
217	case XO_NORMAL: return cstring_makeLiteralTemp ("unexposed");
218	case XO_EXPOSED: return cstring_makeLiteralTemp ("exposed");
219	case XO_OBSERVER: return cstring_makeLiteralTemp ("observer");
220	}
221	BADEXIT;
222	}
223
224	cstring exkind_capName (exkind a)
225	{
226	switch (a)
227	{
228	case XO_UNKNOWN: return cstring_makeLiteralTemp ("Unknown");
229	case XO_NORMAL: return cstring_makeLiteralTemp ("Unexposed");
230	case XO_EXPOSED: return cstring_makeLiteralTemp ("Exposed");
231	case XO_OBSERVER: return cstring_makeLiteralTemp ("Observer");
232	}
233	BADEXIT;
234	}
235
236	cstring exkind_unparseError (exkind a)
237	{
238	switch (a)
239	{
240	case XO_UNKNOWN: return cstring_makeLiteralTemp ("unqualified");
241	case XO_NORMAL: return cstring_makeLiteralTemp ("unqualifier");
242	case XO_EXPOSED: return cstring_makeLiteralTemp ("exposed");
243	case XO_OBSERVER: return cstring_makeLiteralTemp ("observer");
244	}
245	BADEXIT;
246	}
247
248	cstring alkind_capName (alkind a)
249	{
250	switch (a)
251	{
252	case AK_ERROR:
253	return cstring_makeLiteralTemp ("<Error>");
254	case AK_UNKNOWN:
255	return cstring_makeLiteralTemp ("Unqualified");
256	case AK_ONLY:
257	return cstring_makeLiteralTemp ("Only");
258	case AK_IMPONLY:
259	return cstring_makeLiteralTemp ("Implicitly only");
260	case AK_OWNED:
261	return cstring_makeLiteralTemp ("Owned");
262	case AK_IMPDEPENDENT:
263	return cstring_makeLiteralTemp ("Implicitly dependent");
264	case AK_DEPENDENT:
265	return cstring_makeLiteralTemp ("Dependent");
266	case AK_KEEP:
267	return cstring_makeLiteralTemp ("Keep");
268	case AK_KEPT:
269	return cstring_makeLiteralTemp ("Kept");
270	case AK_IMPTEMP:
271	return cstring_makeLiteralTemp ("Implicitly temp");
272	case AK_TEMP:
273	return cstring_makeLiteralTemp ("Temp");
274	case AK_SHARED:
275	return cstring_makeLiteralTemp ("Shared");
276	case AK_UNIQUE:
277	return cstring_makeLiteralTemp ("Unique");
278	case AK_RETURNED:
279	return cstring_makeLiteralTemp ("Returned");
280	case AK_FRESH:
281	return cstring_makeLiteralTemp ("Fresh");
282	case AK_STACK:
283	return cstring_makeLiteralTemp ("Stack");
284	case AK_REFCOUNTED:
285	return cstring_makeLiteralTemp ("Refcounted");
286	case AK_REFS:
287	return cstring_makeLiteralTemp ("Refs");
288	case AK_KILLREF:
289	return cstring_makeLiteralTemp ("Killref");
290	case AK_NEWREF:
291	return cstring_makeLiteralTemp ("Newref");
292	case AK_LOCAL:
293	return cstring_makeLiteralTemp ("Local");
294	case AK_STATIC:
295	return cstring_makeLiteralTemp ("Unqualified static");
296	}
297	BADEXIT;
298	}
299
300	exkind
301	exkind_fromQual (qual q)
302	{
303	if (qual_isExposed (q)) return XO_EXPOSED;
304	if (qual_isObserver (q)) return XO_OBSERVER;
305	else
306	{
307	llcontbug (message ("exkind_fromQual: not exp qualifier: %d" , (int)q));
308	return XO_UNKNOWN;
309	}
310	}
311
312	sstate
313	sstate_fromQual (qual q)
314	{
315	if (qual_isOut (q)) return SS_ALLOCATED;
316	if (qual_isIn (q)) return SS_DEFINED;
317	else if (qual_isPartial (q)) return SS_PARTIAL;
318	else if (qual_isRelDef (q)) return SS_RELDEF;
319	else if (qual_isUndef (q)) return SS_UNDEFGLOB;
320	else if (qual_isKilled (q)) return SS_KILLED;
321	else if (qual_isSpecial (q)) return SS_SPECIAL;
322	else
323	{
324	llcontbug (message ("sstate_fromQual: not alias qualifier: %s (%d)" ,
325	qual_unparse (q),
326	(int)q));
327	return SS_UNKNOWN;
328	}
329	}
330
331	exitkind
332	exitkind_fromQual (qual q)
333	{
334	if (qual_isExits (q)) return XK_MUSTEXIT;
335	if (qual_isMayExit (q)) return XK_MAYEXIT;
336	if (qual_isTrueExit (q)) return XK_TRUEEXIT;
337	if (qual_isFalseExit (q)) return XK_FALSEEXIT;
338	if (qual_isNeverExit (q)) return XK_NEVERESCAPE;
339	else
340	{
341	llcontbug (message ("exitkind_fromQual: not exit qualifier: %s",
342	qual_unparse (q)));
343	return XK_UNKNOWN;
344	}
345	}
346
347	alkind
348	alkind_fromQual (qual q)
349	{
350	if (qual_isOnly (q)) return AK_ONLY;
351	if (qual_isImpOnly (q)) return AK_IMPONLY;
352	if (qual_isKeep (q)) return AK_KEEP;
353	if (qual_isKept (q)) return AK_KEPT;
354	if (qual_isTemp (q)) return AK_TEMP;
355	if (qual_isShared (q)) return AK_SHARED;
356	if (qual_isUnique (q)) return AK_UNIQUE;
357	if (qual_isRefCounted (q)) return AK_REFCOUNTED;
358	if (qual_isRefs (q)) return AK_REFS;
359	if (qual_isNewRef (q)) return AK_NEWREF;
360	if (qual_isKillRef (q)) return AK_KILLREF;
361	if (qual_isTempRef (q)) return AK_KILLREF; /* kludge? use kill ref for this */
362	if (qual_isOwned (q)) return AK_OWNED;
363	if (qual_isDependent (q)) return AK_DEPENDENT;
364
365	llcontbug (message ("alkind_fromQual: not alias qualifier: %d" , (int)q));
366	return AK_ERROR;
367	}
368
369	static bool alkind_isMeaningless (alkind a1)
370	{
371	return (a1 == AK_ERROR \|\| a1 == AK_UNKNOWN \|\| a1 == AK_RETURNED
372	\|\| a1 == AK_STACK \|\| a1 == AK_REFCOUNTED
373	\|\| a1 == AK_REFS \|\| a1 == AK_KILLREF \|\| a1 == AK_NEWREF
374	\|\| a1 == AK_LOCAL);
375	}
376
377	bool alkind_compatible (alkind a1, alkind a2)
378	{
379	if (a1 == a2) return TRUE;
380	if (a2 == AK_ERROR) return TRUE;
381	if (a2 == AK_UNKNOWN)
382	{
383	return (alkind_isMeaningless (a1) \|\| (a1 == AK_IMPTEMP));
384	}
385
386	switch (a1)
387	{
388	case AK_ERROR: return TRUE;
389	case AK_UNKNOWN: return (alkind_isMeaningless (a2)
390	\|\| (a2 == AK_IMPTEMP));
391	case AK_IMPONLY: return (a2 == AK_KEEP \|\| a2 == AK_FRESH
392	\|\| a2 == AK_ONLY);
393	case AK_ONLY: return (a2 == AK_KEEP \|\| a2 == AK_FRESH
394	\|\| a2 == AK_IMPONLY);
395	case AK_OWNED: return FALSE;
396	case AK_IMPDEPENDENT: return (a2 == AK_DEPENDENT);
397	case AK_DEPENDENT: return (a2 == AK_IMPDEPENDENT);
398	case AK_KEEP: return (a2 == AK_ONLY \|\| a2 == AK_FRESH
399	\|\| a2 == AK_IMPONLY);
400	case AK_KEPT: return FALSE;
401	case AK_IMPTEMP: return (a2 == AK_TEMP);
402	case AK_TEMP: return (a2 == AK_IMPTEMP);
403	case AK_SHARED: return FALSE;
404	case AK_UNIQUE: return (a2 == AK_TEMP);
405	case AK_RETURNED: return (alkind_isMeaningless (a2));
406	case AK_FRESH: return (alkind_isOnly (a2));
407	case AK_STACK: return (alkind_isMeaningless (a2));
408	case AK_REFCOUNTED: return (alkind_isMeaningless (a2));
409	case AK_REFS: return (alkind_isMeaningless (a2));
410	case AK_KILLREF: return (alkind_isMeaningless (a2));
411	case AK_NEWREF: return (alkind_isMeaningless (a2));
412	case AK_LOCAL: return (alkind_isMeaningless (a2));
413	case AK_STATIC: return (alkind_isMeaningless (a2));
414	}
415	BADEXIT;
416	}
417
418	bool alkind_equal (alkind a1, alkind a2)
419	{
420	if (a1 == a2) return TRUE;
421	if (a2 == AK_ERROR) return TRUE;
422
423	switch (a1)
424	{
425	case AK_ERROR: return TRUE;
426	case AK_IMPONLY: return (a2 == AK_ONLY);
427	case AK_ONLY: return (a2 == AK_IMPONLY);
428	case AK_IMPDEPENDENT: return (a2 == AK_DEPENDENT);
429	case AK_DEPENDENT: return (a2 == AK_IMPDEPENDENT);
430	case AK_IMPTEMP: return (a2 == AK_TEMP);
431	case AK_TEMP: return (a2 == AK_IMPTEMP);
432	default: return FALSE;
433	}
434
435	BADEXIT;
436	}
437
438	alkind
439	alkind_fixImplicit (alkind a)
440	{
441	if (a == AK_IMPTEMP) return AK_TEMP;
442	if (a == AK_IMPONLY) return AK_IMPONLY;
443	if (a == AK_IMPDEPENDENT) return AK_DEPENDENT;
444
445	return a;
446	}
447
448	cstring exitkind_unparse (exitkind k)
449	{
450	switch (k)
451	{
452	case XK_ERROR: return (cstring_makeLiteralTemp ("<error>"));
453	case XK_UNKNOWN: return (cstring_makeLiteralTemp ("?"));
454	case XK_NEVERESCAPE: return (cstring_makeLiteralTemp ("never escape"));
455	case XK_MAYEXIT: return (cstring_makeLiteralTemp ("mayexit"));
456	case XK_MUSTEXIT: return (cstring_makeLiteralTemp ("exits"));
457	case XK_TRUEEXIT: return (cstring_makeLiteralTemp ("trueexit"));
458	case XK_FALSEEXIT: return (cstring_makeLiteralTemp ("falseexit"));
459	case XK_MUSTRETURN: return (cstring_makeLiteralTemp ("mustreturn"));
460	case XK_MAYRETURN: return (cstring_makeLiteralTemp ("mayreturn"));
461	case XK_MUSTRETURNEXIT: return (cstring_makeLiteralTemp ("mustreturnexit"));
462	case XK_MAYRETURNEXIT: return (cstring_makeLiteralTemp ("mayreturnexit"));
463	case XK_GOTO: return (cstring_makeLiteralTemp ("goto"));
464	case XK_MAYGOTO: return (cstring_makeLiteralTemp ("maygoto"));
465	}
466
467	BADEXIT;
468	}
469
470	exitkind exitkind_makeConditional (exitkind k)
471	{
472	switch (k)
473	{
474	case XK_TRUEEXIT:
475	case XK_FALSEEXIT:
476	case XK_MUSTEXIT: return XK_MAYEXIT;
477	case XK_MUSTRETURN: return XK_MAYRETURN;
478	case XK_MUSTRETURNEXIT: return XK_MAYRETURNEXIT;
479	case XK_GOTO: return XK_MAYGOTO;
480	default: return k;
481	}
482	}
483
484	exitkind exitkind_combine (exitkind k1, exitkind k2)
485	{
486	if (k1 == k2)
487	{
488	return k1;
489	}
490
491	if (k2 == XK_ERROR)
492	{
493	return XK_ERROR;
494	}
495
496	switch (k1)
497	{
498	case XK_ERROR: return XK_ERROR;
499	case XK_UNKNOWN:
500	case XK_NEVERESCAPE: return (exitkind_makeConditional (k2));
501	case XK_MUSTEXIT:
502	switch (k2)
503	{
504	case XK_MUSTRETURNEXIT:
505	case XK_MUSTRETURN: return XK_MUSTRETURNEXIT;
506	case XK_MAYRETURNEXIT:
507	case XK_MAYRETURN: return XK_MAYRETURNEXIT;
508	default: return XK_MAYEXIT;
509	}
510	BADEXIT;
511
512	case XK_MAYEXIT:
513	case XK_TRUEEXIT:
514	case XK_FALSEEXIT:
515	switch (k2)
516	{
517	case XK_MUSTRETURNEXIT:
518	case XK_MAYRETURNEXIT:
519	case XK_MAYRETURN:
520	case XK_MUSTRETURN: return XK_MAYRETURNEXIT;
521	default: return XK_MAYEXIT;
522	}
523	BADEXIT;
524
525	case XK_MUSTRETURN:
526	switch (k2)
527	{
528	case XK_MUSTRETURNEXIT:
529	case XK_MUSTEXIT: return XK_MUSTRETURNEXIT;
530	case XK_MAYRETURNEXIT:
531	case XK_TRUEEXIT:
532	case XK_FALSEEXIT:
533	case XK_MAYEXIT: return XK_MAYRETURNEXIT;
534	default: return XK_MAYRETURN;
535	}
536	BADEXIT;
537
538	case XK_MAYRETURN:
539	if (exitkind_couldExit (k2))
540	{
541	return XK_MAYRETURNEXIT;
542	}
543	else
544	{
545	return XK_MAYRETURN;
546	}
547
548	case XK_MUSTRETURNEXIT:
549	switch (k2)
550	{
551	case XK_MUSTRETURN:
552	case XK_MUSTEXIT: return XK_MUSTRETURNEXIT;
553	default: return XK_MAYRETURNEXIT;
554	}
555	BADEXIT;
556
557	case XK_MAYRETURNEXIT: return XK_MAYRETURNEXIT;
558	case XK_GOTO:
559	case XK_MAYGOTO:
560	if (exitkind_couldExit (k2))
561	{
562	return XK_MAYRETURNEXIT;
563	}
564	return XK_MAYGOTO;
565	}
566
567	BADEXIT;
568	}
569
570	bool exitkind_couldExit (exitkind e)
571	{
572	switch (e)
573	{
574	case XK_MAYEXIT:
575	case XK_MUSTEXIT:
576	case XK_TRUEEXIT:
577	case XK_FALSEEXIT:
578	case XK_MAYRETURNEXIT:
579	case XK_MUSTRETURNEXIT:
580	case XK_GOTO:
581	case XK_MAYGOTO: return TRUE;
582	default: return FALSE;
583	}
584	}
585
586	static bool exitkind_couldReturn (exitkind e) /@/
587	{
588	switch (e)
589	{
590	case XK_MUSTRETURN:
591	case XK_MAYRETURN:
592	case XK_MAYRETURNEXIT:
593	case XK_MUSTRETURNEXIT: return TRUE;
594	default: return FALSE;
595	}
596	}
597
598	static bool exitkind_couldGoto (exitkind e) /@/
599	{
600	return (e == XK_GOTO \|\| e == XK_MAYGOTO);
601	}
602
603	bool exitkind_couldEscape (exitkind e)
604	{
605	return exitkind_couldReturn (e) \|\| exitkind_couldExit (e)
606	\|\| exitkind_couldGoto (e);
607	}
608
609	exitkind exitkind_fromInt (int x)
610	{
611	/@+enumint@/
612	llassert (x >= XK_ERROR && x <= XK_LAST);
613	/@=enumint@/
614
615	return (exitkind) x;
616	}
617
618
619
620
621
622
623