/*
-** LCLint - annotation-assisted static program checker
-** Copyright (C) 1994-2000 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
** 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
*/
/*
** usymtab
** weird C syntax.
*/
-# include "lclintMacros.nf"
+# include "splintMacros.nf"
# include "basic.h"
# include "structNames.h"
# include "exprChecks.h"
-# include "aliasChecks.h"
+# include "transferChecks.h"
+
+/* Needed to install macros when loading libraries */
+
+# include "cpplib.h"
+# include "cpperror.h"
+# include "cpphash.h"
/*
** Keep track of type definitions inside a function.
static bool dbgfree = FALSE;
static bool dbgload = TRUE;
-/*@access ekind usymId@*/
+/*@access ekind@*/
/*
** Hack to prevent shadow errors from appearing when function parameters
static /*@checkedstrict@*/ /*@owned@*/ usymtab oldtab;
static int usymtab_lexicalLevel (void) /*@globals utab@*/ ;
-static bool usymtab_isProbableNullAltBranch (sRef p_s) /*@globals utab@*/ ;
+static bool usymtab_isAltDefinitelyNull (sRef p_s) /*@globals utab@*/ ;
static void refTable_free (/*@only@*/ /*@null@*/ refTable p_x, int p_nentries);
static ctype usymtab_suFieldsType (uentryList p_f, bool p_isStruct) /*@globals globtab@*/ ;
+static void usymtab_freeAux (/*@only@*/ usymtab p_u)
+ /*@globals globtab, utab, filetab@*/
+ /*@modifies p_u@*/ ;
+
+extern int usymtab_getCurrentDepth (void) /*@globals utab@*/
+{
+ return utab->lexlevel;
+}
+
static void
usymtab_freeLevel (/*@notnull@*/ /*@only@*/ usymtab p_u)
/*@globals globtab, utab, filetab@*/ /*@modifies p_u@*/ ;
-static bool usymtab_isProbableNullAux (sRef p_s) /*@globals utab@*/ ;
+static bool usymtab_isDefinitelyNullAux (sRef p_s) /*@globals utab@*/ ;
static /*@only@*/ cstring usymtab_unparseStackTab (usymtab p_t);
static /*@exposed@*/ /*@dependent@*/ uentry
usymtab_getRefTab (/*@notnull@*/ usymtab p_u, int p_level, usymId p_index);
+
+# ifdef S_SPLINT_S
+/* These are not used anymore... */
static /*@unused@*/ /*@only@*/ cstring
usymtab_unparseLocalAux (/*@notnull@*/ usymtab p_s);
static /*@unused@*/ /*@only@*/ cstring
usymtab_unparseLocalList (/*@notnull@*/ usymtab p_s);
+# endif
+
static /*@only@*/ cstring usymtab_typeName (/*@notnull@*/ usymtab p_t);
static void usymtab_handleParams (void)
/*@globals utab, globtab, filetab@*/
static /*@exposed@*/ /*@dependent@*/ uentry
usymtab_getRefNoisy (/*@notnull@*/ usymtab p_s, int p_level, usymId p_index);
+static /*@exposed@*/ /*@dependent@*/ uentry
+ usymtab_lookupQuietAux (usymtab p_s, cstring p_k, bool p_noalt);
+
static /*@exposed@*/ /*@dependent@*/ uentry
usymtab_lookupQuiet (usymtab p_s, cstring p_k);
-static void usymtab_printAllAux (usymtab p_s) /*@modifies g_msgstream@*/ ;
-static int usymtab_getIndex (/*@notnull@*/ usymtab p_s, cstring p_k);
-static /*@exposed@*/ uentry usymtab_fetchIndex (/*@notnull@*/ usymtab p_s, int p_i);
-static /*@exposed@*/ uentry
- usymtab_lookupAux (usymtab p_s, cstring p_k);
-static /*@exposed@*/ /*@dependent@*/ /*@notnull@*/ usymtab
- usymtab_getFileTab (void) /*@globals filetab@*/ ;
-static int refTable_lookup (/*@notnull@*/ usymtab p_ut, int p_level, int p_index);
+
+static /*@exposed@*/ /*@dependent@*/ uentry
+ usymtab_lookupQuietNoAlt (usymtab p_s, cstring p_k);
+
+static void usymtab_printAllAux (usymtab p_s) /*@modifies g_warningstream@*/ ;
+
+/*@function bool usymtab_indexFound (usymId) @*/
+# define usymtab_indexFound(u) ((u) != usymId_notfound)
+
+static usymId usymtab_getIndex (/*@notnull@*/ usymtab p_s, cstring p_k);
+static /*@exposed@*/ uentry usymtab_fetchIndex (/*@notnull@*/ usymtab p_s, usymId p_ui);
+static /*@exposed@*/ uentry usymtab_lookupAux (usymtab p_s, cstring p_k);
+
+static /*@exposed@*/ /*@dependent@*/ /*@notnull@*/
+ usymtab usymtab_getFileTab (void) /*@globals filetab@*/ ;
+
+static int refTable_lookup (/*@notnull@*/ usymtab p_ut, int p_level, usymId p_index);
static bool usymtab_mustBreak (usymtab p_s);
static bool usymtab_mustEscape (usymtab p_s);
static void recordFunctionType (uentry ue)
{
- llassert (uentry_isDatatype (ue) || uentry_isAnyTag (ue)
+ llassert (uentry_isDatatype (ue) || uentry_isAnyTag (ue)
|| uentry_isEnumConstant (ue));
-
+ DPRINTF (("Function type: %s", uentry_unparseFull (ue)));
/*@-temptrans@*/
functypes = uentryList_add (functypes, ue);
/*@=temptrans@*/
{
if (cstring_isDefined (uentry_rawName (el)))
{
- if (globtab->htable != NULL)
+ if (cstringTable_isDefined (globtab->htable))
{
- hashTable_remove (globtab->htable, uentry_rawName (el));
+ cstringTable_remove (globtab->htable, uentry_rawName (el));
}
uentry_setName (el, cstring_undefined);
uentryList_clear (functypes);
}
-static /*@falsenull@*/ bool usymtab_isBranch (usymtab u)
+static /*@falsewhennull@*/ bool usymtab_isBranch (usymtab u)
{
return (usymtab_isDefined (u) &&
(u->kind == US_TBRANCH || u->kind == US_FBRANCH
}
}
-bool usymtab_isAltProbablyDeepNull (sRef s)
+bool usymtab_isAltDefinitelyNullDeep (sRef s)
{
- return (sRef_deepPred (usymtab_isProbableNullAltBranch, s));
+ return (sRef_deepPred (usymtab_isAltDefinitelyNull, s));
}
-static bool usymtab_isProbableNullAltBranch (sRef s)
+static bool usymtab_isAltDefinitelyNull (sRef s)
/*@globals utab@*/
{
guardSet t;
/*@=mods@*/
llassert (usymtab_isDefined (utab));
- res = usymtab_isProbableNull (s);
+ res = usymtab_isDefinitelyNull (s);
/*
** This reports a spurious error. It is okay, because of
t->nentries = 0;
t->nspace = CBASESIZE;
t->entries = (uentry *) dmalloc (sizeof (*t->entries) * CBASESIZE);
+
+ /* We only use a reftable for branch-level symbol tables.
+ */
+
t->reftable = (nextlevel
? NULL
: (refentry *) dmalloc (sizeof (*t->reftable) * CBASESIZE));
t->kind = kind;
t->lexlevel = (env == GLOBAL_ENV ? 0 : env->lexlevel) + (nextlevel ? 1 : 0);
-
+
t->env = env;
t->htable = NULL;
t->guards = guardSet_undefined;
t->aliases = aliasTable_undefined;
- t->mustBreak = FALSE;
+ t->mustBreak = FALSE;
t->exitCode = XK_NEVERESCAPE;
+ DPRINTF (("Create usymtab [%p]", t));
return t;
}
u->entries = (uentry *) dmalloc (sizeof (*u->entries) * CGLOBBASESIZE);
u->env = GLOBAL_ENV;
u->lexlevel = 0;
- u->htable = hashTable_create (CGLOBHASHSIZE);
+ u->htable = cstringTable_create (CGLOBHASHSIZE);
u->reftable = NULL;
-
+
u->guards = guardSet_new ();
u->aliases = aliasTable_new ();
u->exitCode = XK_NEVERESCAPE;
u->kind = US_NORMAL;
- /*@i23@*/ return (u);
+ return (u);
}
void
oldtab = usymtab_undefined;
}
+void
+usymtab_destroyMod (void) /*@modifies utab, globtab, filetab@*/ /*@globals killed utab@*/
+{
+ DPRINTF (("Destroy usymtab [%p]: %d", utab, utab->nentries));
+ usymtab_freeAux (utab);
+ utab = usymtab_undefined;
+ /*@-globstate@*/
+} /*@=globstate@*/
+
+void
+usymtab_initGlobalMarker () /*@globals globtab@*/
+{
+ if (uentry_isValid (usymtab_lookupAux (globtab, GLOBAL_MARKER_NAME)))
+ {
+ ; /* Already entered from load table. */
+ }
+ else
+ {
+ usymtab_addGlobalEntry (uentry_makeGlobalMarker ());
+ }
+}
+
/*
** utab should be empty? (requires?)
**
void
usymtab_initBool ()
{
+ DPRINTF (("Init bool!"));
+
if (context_getFlag (FLG_NOLIB))
{
ctype boolt = ctype_bool;
/* evs 2000-07-24: bool is now treated as abstract (always) */
- uentry boolentry = uentry_makeBoolDatatype (YES);
+ uentry boolentry = uentry_makeBoolDatatype (qual_createAbstract ());
usymtab_supGlobalEntry (boolentry);
context_addBoolAccess ();
*/
usymtab_supGlobalEntry
- (uentry_makeConstantAux (context_getFalseName (), boolt,
- fileloc_getBuiltin (), FALSE,
- multiVal_makeInt (0)));
+ (uentry_makeConstantValue (context_getFalseName (), boolt,
+ fileloc_getBuiltin (), FALSE,
+ multiVal_makeInt (0)));
+
usymtab_supGlobalEntry
- (uentry_makeConstantAux (context_getTrueName (), boolt,
- fileloc_getBuiltin (), FALSE,
- multiVal_makeInt (1)));
+ (uentry_makeConstantValue (context_getTrueName (), boolt,
+ fileloc_getBuiltin (), FALSE,
+ multiVal_makeInt (1)));
}
}
}
# endif
- if (s->htable != NULL)
+ if (cstringTable_isDefined (s->htable))
{
- hashTable_insert (s->htable, uentry_rawName (e), s->nentries);
+ cstringTable_insert (s->htable, cstring_copy (uentry_rawName (e)), s->nentries);
}
s->nentries++;
}
else
{
- int thisentry = s->nentries;
+ usymId thisentry = usymId_fromInt (s->nentries);
if (uentry_isVar (e))
{
- uentry_setSref (e, sRef_makeCvar (globScope, thisentry,
- uentry_getType (e)));
+ uentry_setSref
+ (e, sRef_makeCvar (globScope, thisentry,
+ uentry_getType (e),
+ stateInfo_makeLoc (uentry_whereLast (e), SA_DECLARED)));
}
usymtab_addEntryQuiet (s, e);
}
}
+
+static /*@observer@*/ uentry /*@alt void@*/
+usymtab_addEntryAlways (/*@notnull@*/ usymtab s, /*@only@*/ uentry e)
+{
+ /*
+ ** In theory, we shouldn't need this test because it this is
+ ** only called when a library is being read, and it shouldn't
+ ** ever have a duplicate entry. In practice, its safer to
+ ** leave it in, though.
+ */
+
+ uentry old;
+ usymId thisentry = usymId_fromInt (s->nentries);
+
+ if (uentry_isValid (old = usymtab_lookupQuiet (s, uentry_rawName (e))))
+ {
+ llcontbug
+ (message ("Duplicate entry in load library: %s. "
+ "Old entry: %q. New entry: %q",
+ uentry_rawName (e),
+ uentry_unparseFull (old),
+ uentry_unparseFull (e)));
+
+ uentry_setName (e, message ("__x_%s", uentry_rawName (e)));
+ /* This shouldn't happen...unless the library is bad! */
+ }
+
+
+ if (uentry_isVar (e) && !uentry_isGlobalMarker (e))
+ {
+ uentry_setSref
+ (e, sRef_makeCvar (globScope, thisentry,
+ uentry_getType (e),
+ stateInfo_makeLoc (uentry_whereLast (e), SA_DECLARED)));
+ }
+
+ usymtab_addEntryQuiet (s, e);
+ return e;
+}
+
static usymId
usymtab_addEntryAux (/*@notnull@*/ usymtab st, /*@keep@*/ uentry e, bool isSref)
/*@globals globtab@*/
/*@modifies st, e@*/
{
- usymId thisentry = st->nentries;
+ usymId thisentry = usymId_fromInt (st->nentries);
llassert (!uentry_isElipsisMarker (e));
if (uentry_isFunction (e) && ctype_isFunction (ct))
{
- ct = ctype_returnValue (ct);
+ ct = ctype_getReturnType (ct);
}
if (uentry_isStatic (e))
{
- sRef sr = sRef_makeCvar (st->lexlevel, thisentry, ct);
+ sRef sr = sRef_makeCvar (st->lexlevel, thisentry, ct,
+ stateInfo_makeLoc (uentry_whereLast (e), SA_DECLARED));
if (sRef_isStack (sr) || sRef_isLocalState (sr))
{
}
else
{
- uentry_setSref (e, sRef_makeCvar (st->lexlevel, thisentry, ct));
+ uentry_setSref
+ (e, sRef_makeCvar (st->lexlevel, thisentry, ct,
+ stateInfo_makeLoc (uentry_whereLast (e), SA_DECLARED)));
}
-
- }
+ }
if (uentry_isDatatype (e))
{
-
- uentry_setDatatype (e, thisentry);
+ uentry_setDatatype (e, typeId_fromUsymId (thisentry));
}
if (uentry_isFunction (e))
exprChecks_checkExport (e);
}
-
uentry_checkName (e);
usymtab_addEntryQuiet (st, e);
+ DPRINTF (("Adding entry: [%p] %s", e, uentry_unparseFull (e)));
return (thisentry);
}
usymtab_addEntry (uentry e)
/*@globals utab, globtab@*/
/*@modifies utab, e@*/
-{
-
+{
llassertprint (!usymtab_exists (uentry_rawName (e)),
("Entry already exists: %s", uentry_unparse (e)));
{
cstring ename = uentry_rawName (e);
bool staticEntry = FALSE;
- int eindex;
+ usymId eindex;
+ DPRINTF (("Sup entry aux: %s", uentry_unparseFull (e)));
+
/* static tags in global scope */
if (st->lexlevel == fileScope
&& (!(uentry_isStatic (e)) || uentry_isAnyTag (e)))
{
eindex = usymtab_getIndex (st, ename);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry ce = st->entries[eindex];
uentry_showWhereLast (ce);
}
- if (eindex == st->nentries - 1)
+ if (eindex == usymId_fromInt (st->nentries - 1))
{
;
}
st->entries[eindex] = st->entries[st->nentries - 1];
}
- if (st->htable != NULL)
+ if (cstringTable_isDefined (st->htable))
{
- hashTable_replaceKey (st->htable, uentry_rawName (ce),
- uentry_rawName (e));
+ cstringTable_replaceKey (st->htable, uentry_rawName (ce),
+ cstring_copy (uentry_rawName (e)));
}
uentry_free (ce);
if (uentry_isStatic (e)) {
if (uentry_isFunction (e)) {
- /* Static function declarations are at the file level, even if they are in a deeped scope. */
+ /*
+ ** Static function declarations are at the file level,
+ ** even if they are in a deeper scope.
+ */
+
st = usymtab_getFileTab ();
staticEntry = TRUE;
} else {
}
}
- DPRINTF (("Using symtab: %s", usymtab_unparseLocalAux (st)));
-
eindex = usymtab_getIndex (st, ename);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry ce = st->entries[eindex];
-
+
DPRINTF (("Found entry: %s", uentry_unparse (ce)));
if (uentry_isPriv (ce)
llassert ((st->lexlevel > fileScope || !sRef_modInFunction ()));
+ DPRINTF (("Overloading!"));
+
st->entries[eindex] = e;
if (uentry_isDatatype (e))
{
- uentry_setDatatype (e, eindex);
+ uentry_setDatatype (e, typeId_fromUsymId (eindex));
}
if (st == globtab && !uentry_isSpecified (e))
exprChecks_checkExport (e);
}
- if (st->htable != NULL)
+ if (cstringTable_isDefined (st->htable))
{
- hashTable_replaceKey (st->htable, uentry_rawName (ce),
- uentry_rawName (e));
+ cstringTable_replaceKey (st->htable, uentry_rawName (ce),
+ cstring_copy (uentry_rawName (e)));
}
uentry_free (ce);
{
if (uentry_isSpecified (e))
{
+ DPRINTF (("Here we are: %s", uentry_unparseFull (e)));
+
if (fileloc_isImport (uentry_whereSpecified (ce)))
- {
-
- if (st->htable != NULL)
+ {
+ if (cstringTable_isDefined (st->htable))
{
- hashTable_replaceKey (st->htable,
- uentry_rawName (ce),
- uentry_rawName (e));
+ cstringTable_replaceKey (st->htable,
+ uentry_rawName (ce),
+ cstring_copy (uentry_rawName (e)));
}
uentry_free (ce);
st->entries[eindex] = e;
ce = e;
- if (uentry_isDatatype (e)) uentry_setDatatype (e, eindex);
+ if (uentry_isDatatype (e)) uentry_setDatatype (e, typeId_fromUsymId (eindex));
}
else
{
}
else
{
- /* respecification errors already reported */
-
+ /* Respecification errors already reported */
+ DPRINTF (("Respecification: %s / %s",
+ fileloc_unparse (uentry_whereSpecified (e)),
+ bool_unparse (fileloc_isSpec (uentry_whereSpecified (e)))));
+
if (uentry_isDatatype (e))
{
- uentry_setDatatype (e, eindex);
+ uentry_setDatatype (e, typeId_fromUsymId (eindex));
}
- if (st->htable != NULL)
+ if (cstringTable_isDefined (st->htable))
{
- hashTable_replaceKey (st->htable,
- uentry_rawName (ce),
- uentry_rawName (e));
+ cstringTable_replaceKey (st->htable,
+ uentry_rawName (ce),
+ cstring_copy (uentry_rawName (e)));
}
llassert ((st->lexlevel > fileScope || !sRef_modInFunction ()));
}
else /* e not specified */
{
+ DPRINTF (("Merging..."));
+
if (uentry_isDeclared (ce))
{
- llassert ((st->lexlevel > fileScope || !sRef_modInFunction ()));
+ /* evans 2001-08-26
+ No - this can happen for internal typedefs
+ llassert ((st->lexlevel > fileScope || !sRef_modInFunction ()));
+ */
+
+ DPRINTF (("Merge defn"));
uentry_mergeDefinition (ce, e);
}
else
{
- llassert ((st->lexlevel > fileScope || !sRef_modInFunction ()));
+ /* evans 2001-08-26
+ No - this can happen for internal typedefs
+ llassert ((st->lexlevel > fileScope || !sRef_modInFunction ()));
+ */
+
+ DPRINTF (("Merge entries..."));
uentry_mergeEntries (ce, e);
+ DPRINTF (("After: %s", uentry_unparseFull (ce)));
}
}
}
if (!(st->lexlevel > fileScope || !sRef_modInFunction ()))
{
if (uentry_isDatatype (e) || uentry_isAnyTag (e)
- || uentry_isEnumConstant (e))
+ || uentry_isEnumConstant (e)
+ || uentry_isStatic (e)) /* bug fix from Brian St. Pierre */
{
; /*
** Not a bug. Code like,
}
}
+ DPRINTF (("Merge.."));
uentry_mergeDefinition (ce, e);
}
if (uentry_isFunction (ce) && ctype_isFunction (ct))
{
- ct = ctype_returnValue (ct);
+ ct = ctype_getReturnType (ct);
}
- uentry_setSref (ce, sRef_makeCvar (st->lexlevel, eindex, ct));
- }
+ uentry_setSref
+ (ce, sRef_makeCvar (st->lexlevel, eindex, ct,
+ stateInfo_makeLoc (uentry_whereLast (ce), SA_DECLARED)));
+ }
}
else /* no previous entry */
{
eindex = usymtab_getIndex (filetab, ename);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry ce = filetab->entries[eindex];
outer = usymtab_lookupQuiet (st->env, ename);
+ DPRINTF (("New : [%p] %s", e, uentry_unparseFull (e)));
+ DPRINTF (("Outer: [%p] %s", outer, uentry_unparseFull (outer)));
+
/*
** no previous definition, add the new one
*/
&& uentry_isValid (outer)
&& !(uentry_isYield (e) || uentry_isYield (outer))
&& fileloc_isDefined (uentry_whereLast (e))
- && fileloc_isDefined (uentry_whereLast (outer)))
+ && !fileloc_isXHFile (uentry_whereLast (e))
+ && fileloc_isDefined (uentry_whereLast (outer))
+ && !fileloc_isXHFile (uentry_whereLast (outer)))
{
if (!uentry_sameKind (outer, e))
{
}
exitPoint:
- return (staticEntry ? USYMIDINVALID : eindex);
+ return (staticEntry ? usymId_invalid : eindex);
}
-# ifndef NOLCL
static void
usymtab_replaceEntryAux (/*@notnull@*/ usymtab st, /*@only@*/ uentry e)
/*@globals globtab@*/ /*@modifies st, e@*/
{
cstring ename = uentry_rawName (e);
- int eindex;
+ usymId eindex;
/* static tags in global scope */
eindex = usymtab_getIndex (st, ename);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry ce = st->entries[eindex];
- if (st->htable != NULL)
+ if (cstringTable_isDefined (st->htable))
{
- hashTable_replaceKey (st->htable, uentry_rawName (ce), uentry_rawName (e));
+ cstringTable_replaceKey (st->htable, uentry_rawName (ce),
+ cstring_copy (uentry_rawName (e)));
}
uentry_free (ce);
eindex = usymtab_addEntryAux (st, e, FALSE);
}
}
-# endif
/*@=deparrays@*/
bool stat = (tab == globtab) && uentry_isStatic (e);
uentry ret;
-
(void) usymtab_supEntryAux (tab, e, isref);
if (stat)
ret = usymtab_supEntryReturnAux (globtab, e, FALSE);
+ /*
+ ** We need to keep track of internal function declarations, so
+ ** we can remove them from the symbol table after exiting this
+ ** function. This is a bit bogus, of course.
+ */
+
if (sRef_modInFunction ())
{
recordFunctionType (ret);
if (uentry_isAbstractDatatype (e))
{
- uid = usymtab_supAbstractTypeEntry (e, FALSE);
- ret = ctype_createAbstract (uid);
+ typeId tid = usymtab_supAbstractTypeEntry (e, FALSE);
+ ret = ctype_createAbstract (tid);
+ uid = typeId_toUsymId (tid);
}
else
{
uid = usymtab_supEntryAux (globtab, e, FALSE);
- ret = ctype_createUser (uid);
+ ret = ctype_createUser (typeId_fromUsymId (uid));
}
if (sRef_modInFunction ())
/*@modifies globtab@*/
{
usymId uid;
-
+
+ DPRINTF (("Abstract? %s", uentry_unparseFull (e)));
+
if (uentry_isAbstractDatatype (e))
{
- uid = usymtab_supAbstractTypeEntry (e, FALSE);
+ uid = typeId_toUsymId (usymtab_supAbstractTypeEntry (e, FALSE));
+ }
+ else if (uentry_isMaybeAbstract (e) && context_getFlag (FLG_IMPABSTRACT))
+ {
+ bool maybeabs = TRUE;
+ cstring sname = uentry_getName (e);
+ uentry ue = usymtab_lookupGlobSafe (sname);
+ cstring_free (sname);
+
+ if (uentry_isValid (ue))
+ {
+ DPRINTF (("Lookup: %s", uentry_unparseFull (ue)));
+
+ if (uentry_isDatatype (ue))
+ {
+ if (uentry_isMaybeAbstract (ue))
+ {
+ ;
+ }
+ else
+ {
+ maybeabs = FALSE;
+ }
+ }
+ else
+ {
+ DPRINTF (("Not datatype!"));
+ }
+ }
+
+ if (maybeabs)
+ {
+ uentry ux;
+ typeId tid = usymtab_supAbstractTypeEntry (e, FALSE);
+ ux = usymtab_getTypeEntry (tid);
+ uentry_setAbstract (ux);
+ uid = typeId_toUsymId (tid);
+ }
+ else
+ {
+ uid = usymtab_supEntryAux (globtab, e, FALSE);
+ e = usymtab_getTypeEntry (typeId_fromUsymId (uid));
+
+ if (uentry_isMaybeAbstract (e))
+ {
+ uentry_setConcrete (e);
+ }
+ }
}
else
{
uid = usymtab_supEntryAux (globtab, e, FALSE);
+ e = usymtab_getTypeEntry (typeId_fromUsymId (uid));
+
+ /*? evans 2002-12-16 removed this? it doesn't make sense
+ if (uentry_isMaybeAbstract (e))
+ {
+ uentry_setConcrete (e);
+ }
+ */
}
if (sRef_modInFunction ())
return (globtab->entries[uid]);
}
-usymId
+typeId
usymtab_supAbstractTypeEntry (/*@only@*/ uentry e, bool dodef)
/*@globals globtab, filetab@*/
/*@modifies globtab, e@*/
{
- usymId uid;
- uid = usymtab_supEntryAux (globtab, e, FALSE);
+ typeId uid;
+ uentry ue;
+
+ uid = typeId_fromUsymId (usymtab_supEntryAux (globtab, e, FALSE));
+ ue = usymtab_getTypeEntry (uid);
if (dodef)
{
- uentry ue = usymtab_getTypeEntry (uid);
uentry_setDatatype (ue, uid);
}
- if (context_getFlag (FLG_ACCESSMODULE))
+ if (context_getFlag (FLG_ACCESSMODULE)) /* was accessfile */
{
context_addFileAccessType (uid);
}
return (uid);
}
-# ifndef NOLCL
-usymId
+typeId
usymtab_supExposedTypeEntry (/*@only@*/ uentry e, bool dodef)
/*@globals globtab, filetab@*/
/*@modifies globtab, e@*/
{
- usymId uid;
+ typeId uid;
- uid = usymtab_supEntryAux (globtab, e, FALSE);
+ uid = typeId_fromUsymId (usymtab_supEntryAux (globtab, e, FALSE));
if (dodef)
{
recordFunctionType (globtab->entries[uid]);
}
- return (uid);
+ return uid;
}
-# endif
ctype
usymtab_supForwardTypeEntry (/*@only@*/ uentry e)
/*@globals globtab, filetab@*/
/*@modifies globtab, e@*/
{
- usymId uid = usymtab_supEntryAux (globtab, e, FALSE);
+ typeId uid = typeId_fromUsymId (usymtab_supEntryAux (globtab, e, FALSE));
uentry ue = usymtab_getTypeEntry (uid);
uentry_setDatatype (ue, uid);
/*@modifies utab, globtab, e@*/
{
sRef old = uentry_getSref (e);
-
if (sRef_isType (old))
{
return (utab->lexlevel > paramsScope);
}
-static int
+static usymId
usymtab_getIndex (/*@notnull@*/ usymtab s, cstring k)
{
int i;
- if (s->htable != NULL)
- {
- i = hashTable_lookup (s->htable, k);
+ DPRINTF (("Lookup %s", k));
- return i;
+ if (cstringTable_isDefined (s->htable))
+ {
+ i = cstringTable_lookup (s->htable, k);
+ return usymId_fromInt (i);
}
else
{
{
uentry current = s->entries[i];
+ DPRINTF (("Check %d: %s", i, uentry_rawName (current)));
+
if (!uentry_isUndefined (current)
&& cstring_equal (uentry_rawName (current), k))
{
- return i;
+ return usymId_fromInt (i);
}
}
- return NOT_FOUND;
+ return usymId_notfound;
}
}
static uentry
-usymtab_fetchIndex (/*@notnull@*/ usymtab s, int i)
+usymtab_fetchIndex (/*@notnull@*/ usymtab s, usymId ui)
{
+ int i = usymId_toInt (ui);
llassert (i >= 0 && i < s->nentries);
return (s->entries[i]);
}
-usymId
+typeId
usymtab_getTypeId (cstring k) /*@globals globtab@*/
{
usymId uid = usymtab_getIndex (globtab, k);
- if (uid == NOT_FOUND) return USYMIDINVALID;
-
- if (!(uentry_isDatatype (usymtab_getTypeEntry (uid)))) {
- return USYMIDINVALID;
- }
-
- return uid;
+ if (!usymtab_indexFound (uid)
+ || !(uentry_isDatatype (usymtab_getTypeEntry (typeId_fromUsymId (uid)))))
+
+ {
+ return typeId_invalid;
+ }
+ else
+ {
+ return typeId_fromUsymId (uid);
+ }
}
/*@dependent@*/ uentry
{
cstring sname = makeStruct (k);
uentry ue = usymtab_lookupGlob (sname);
- cstring_free (sname);
+
+ cstring_free (sname);
return (ue);
}
usymId uid = usymtab_getIndex (globtab, k);
uentry ue;
- if (uid == NOT_FOUND)
+ if (!usymtab_indexFound (uid))
{
- return USYMIDINVALID;
+ return usymId_invalid;
}
ue = usymtab_getGlobalEntry (uid);
if (uentry_isPriv (ue))
{
- return USYMIDINVALID;
+ return usymId_invalid;
}
return uid;
static /*@exposed@*/ uentry
usymtab_getEntryAux (/*@notnull@*/ usymtab s, usymId uid)
{
- llassert (uid != USYMIDINVALID);
+ llassert (uid != usymId_invalid);
- if (uid < 0 || uid >= s->nentries)
+ if (uid < 0 || uid >= usymId_fromInt (s->nentries))
{
llcontbug (message ("usymtab_getEntry: out of range: level = %d [%d]",
s->lexlevel, uid));
}
}
-/*@dependent@*/ /*@exposed@*/ uentry
- usymtab_getTypeEntry (usymId uid)
+/*@dependent@*/ /*@exposed@*/ uentry usymtab_getTypeEntry (typeId uid)
/*@globals globtab@*/
{
if (dbgload)
{
- if (uid >= 0 && uid < globtab->nentries)
+ if (uid >= 0 && uid < typeId_fromInt (globtab->nentries))
{
return (globtab->entries[uid]);
}
}
else
{
- llassert (uid >= 0 && uid < globtab->nentries);
-
+ llassert (uid >= 0 && uid < typeId_fromInt (globtab->nentries));
return (globtab->entries[uid]);
}
}
** in load files
*/
-/*@dependent@*/ /*@exposed@*/ uentry
- usymtab_getTypeEntrySafe (usymId uid)
+/*@dependent@*/ /*@exposed@*/ uentry usymtab_getTypeEntrySafe (typeId uid)
/*@globals globtab@*/
{
- if (uid < 0 || uid >= globtab->nentries)
+ if (uid < 0 || uid >= typeId_fromInt (globtab->nentries))
{
return uentry_undefined;
}
-
- return (globtab->entries[uid]);
+
+ return (globtab->entries[uid]);
}
-bool
- usymtab_isBoolType (usymId uid)
+bool usymtab_isBoolType (typeId uid)
/*@globals globtab@*/
{
- llassert (uid >= 0 && uid < globtab->nentries);
+ llassert (uid >= 0 && uid < typeId_fromInt (globtab->nentries));
return (cstring_equal (uentry_rawName (globtab->entries[uid]),
context_getBoolName ()));
}
-cstring
-usymtab_getTypeEntryName (usymId uid)
+cstring usymtab_getTypeEntryName (typeId uid)
/*@globals globtab@*/
{
uentry ue;
return (uentry_getName (ue));
}
-static void
+# if 0
+/*@unused@*/ static void
usymtab_rehash (/*@notnull@*/ usymtab s)
{
int i;
- if (s->htable != NULL)
+ if (cstringTable_isDefined (s->htable))
{
- hashTable_free (s->htable);
+ cstringTable_free (s->htable);
}
- s->htable = hashTable_create (LLHASHSIZE);
+ s->htable = cstringTable_create (LLAHSHSIZE);
for (i = 0; i < s->nentries; i++)
{
- hashTable_insert (s->htable, uentry_rawName (s->entries[i]), i);
+ cstringTable_insert (s->htable, cstring_copy (uentry_rawName (s->entries[i])), i);
}
}
+# endif
/*
** superficial copy of usymtab
/*@-compdestroy@*/ sfree (s); /*@=compdestroy@*/
}
+usymId usymtab_convertTypeId (typeId uid)
+{
+ return usymtab_convertId (typeId_toUsymId (uid));
+}
+
/*
-** converts usymId from old table to sorted one
+** usymtab_convertId: converts usymId from old table to sorted one
*/
-usymId
- usymtab_convertId (usymId uid)
+usymId usymtab_convertId (usymId uid)
/*@globals oldtab, utab@*/
{
uentry ue;
name = uentry_rawName (ue);
ret = usymtab_getIndex (utab, name);
+ llassert (ret == uid); /*! for now, no rehash! */
+ DPRINTF (("Convert: %s [%d] -> %s [%d]",
+ uentry_unparse (ue), uid,
+ uentry_unparse (utab->entries[ret]), ret));
- llassertprint (ret != USYMIDINVALID, ("convertId: return is invalid"));
+ llassertprint (ret != usymId_invalid, ("convertId: return is invalid"));
return (ret);
}
/*@modifies oldtab, utab@*/
{
llassert (usymtab_inGlobalScope ());
-
llassert (oldtab == usymtab_undefined);
+ /*
+ DPRINTF (("Preparing to dump:"));
+ usymtab_printAll ();
+ */
+
oldtab = usymtab_shallowCopy (utab);
/*
- alpha compare - make sure order is same on different platforms
- error messages appear in same order
+ ** alpha compare - make sure order is same on different platforms
+ ** error messages appear in same order
*/
+ /*
qsort (utab->entries, (size_t)utab->nentries,
- sizeof (*utab->entries), (int (*)(const void *, const void *)) uentry_xcomparealpha);
-
+ sizeof (*utab->entries),
+ (int (*)(const void *, const void *)) uentry_xcomparealpha);
+
usymtab_rehash (utab);
+ */
+
+ /*
+ DPRINTF (("After rehash:"));
+ usymtab_printAll ();
+ */
}
-void
- usymtab_dump (FILE *fout)
- /*@globals utab, oldtab@*/
+void usymtab_dump (FILE *fout)
+ /*@globals utab, oldtab@*/
{
int i;
bool neednl = FALSE;
uentry thisentry = utab->entries[i];
ekind thisekind = uentry_getKind (thisentry);
-
- if (uentry_hasRealName (thisentry)) {
- if (thisekind != lastekind)
- {
- if (neednl)
- {
- check (fputc ('\n', fout) == (int) '\n');
- }
-
- neednl = FALSE;
- lastentry = uentry_undefined;
- fprintf (fout, "*%d (%s)\n", ekind_toInt (thisekind),
- cstring_toCharsSafe (ekind_capName (thisekind)));
- lastekind = thisekind;
- linelen = 0;
- }
-
- if (uentry_isInvalid (lastentry) || !uentry_equiv (lastentry, thisentry)
- || (linelen > (MAX_DUMP_LINE_LENGTH - (2 * MAX_NAME_LENGTH))))
- {
- cstring cdump = uentry_dump (thisentry);
-
- lastentry = thisentry;
- if (neednl)
- {
- check (fputc ('\n', fout) == (int) '\n');
- linelen = 0;
- }
-
- linelen += cstring_length (cdump);
-
- /* no new line here! */
- if (cstring_length (cdump) > 0)
- {
- check (fputs (cstring_toCharsSafe (cdump), fout) != EOF);
- }
-
- cstring_free (cdump);
- neednl = TRUE;
- }
- else
- {
- cstring cdump = uentry_rawName (thisentry);
- linelen += cstring_length (cdump);
- fprintf (fout, "#%s", cstring_toCharsSafe (cdump));
- }
- }
+ if (!uentry_hasRealName (thisentry))
+ {
+ llassert (uentry_isGlobalMarker (thisentry));
+
+ if (neednl)
+ {
+ check (fputc ('\n', fout) == (int) '\n');
+ }
+
+ fprintf (fout, "*%d (GlobalMarker)\n", KGLOBALMARKER);
+ lastekind = KINVALID;
+ linelen = 0;
+ neednl = FALSE;
+ }
+ else
+ {
+ if (thisekind != lastekind)
+ {
+ if (neednl)
+ {
+ check (fputc ('\n', fout) == (int) '\n');
+ }
+
+ neednl = FALSE;
+ lastentry = uentry_undefined;
+ fprintf (fout, "*%d (%s)\n", ekind_toInt (thisekind),
+ cstring_toCharsSafe (ekind_capName (thisekind)));
+ lastekind = thisekind;
+ linelen = 0;
+ }
+
+ /*
+ ** evans - 2001-02-18 - added the - 48 fudge factor...
+ ** extra characters dumped, but I haven't counded them carefully...
+ */
+
+ if (uentry_isInvalid (lastentry) || !uentry_equiv (lastentry, thisentry)
+ || (linelen > (MAX_DUMP_LINE_LENGTH - (2 * MAX_NAME_LENGTH) - 48)))
+ {
+ cstring cdump;
+
+ DPRINTF (("Dumping entry: %d", i));
+ cdump = message ("^%d %q", i, uentry_dump (thisentry));
+ /* was: cdump = uentry_dump (thisentry)); */
+
+ lastentry = thisentry;
+ if (neednl)
+ {
+ check (fputc ('\n', fout) == (int) '\n');
+ linelen = 0;
+ }
+
+ linelen += cstring_length (cdump);
+
+ /* no new line here! */
+ if (cstring_length (cdump) > 0)
+ {
+ check (fputs (cstring_toCharsSafe (cdump), fout) != EOF);
+ }
+
+ cstring_free (cdump);
+ neednl = TRUE;
+ }
+ else
+ {
+ cstring cdump = uentry_rawName (thisentry);
+ DPRINTF (("Raw name: %s", cdump));
+ linelen += (cstring_length (cdump) + 1);
+ fprintf (fout, "#%s", cstring_toCharsSafe (cdump));
+ }
+ }
}
if (neednl)
{
check (fputc ('\n', fout) == (int) '\n');
}
+
+ lastekind = KINVALID;
+
+ fprintf(fout, ";; Library constraints\n");
+
+ /*drl July 27 added this so that libraries without
+ buffer constraints would be handled correctly.
+ I'm trying to do this without breaking older libraries.
+
+ Splint should still be able to handle libraries without this message.
+ */
+
+
+ fprintf(fout, "start_Buffer_Constraints\n");
+
+ for (i = 0; i < utab->nentries; i++)
+ {
+ uentry thisentry = utab->entries[i];
+
+ if (uentry_isFunction (thisentry) )
+ {
+ constraintList preconditions;
+ constraintList postconditions;
+
+ preconditions = uentry_getFcnPreconditions (thisentry);
+ postconditions = uentry_getFcnPostconditions (thisentry);
+
+ if ( constraintList_isDefined(preconditions) ||
+ constraintList_isDefined(postconditions) )
+ {
+ fprintf(fout,"%s\n", cstring_toCharsSafe (uentry_rawName(thisentry) ) );
+ if (constraintList_isDefined(preconditions) )
+ {
+ fprintf(fout,"pre:\n");
+ constraintList_dump(preconditions, fout);
+ fprintf (fout, ";; end precondition constraints\n" );
+ constraintList_free(preconditions);
+ }
+ else
+ {
+ fprintf(fout,"pre:EMPTY\n");
+ }
+ if (constraintList_isDefined(postconditions) )
+ {
+ fprintf(fout,"post:\n");
+ constraintList_dump(postconditions, fout);
+ fprintf (fout, ";; end precondition constraints\n" );
+ constraintList_free(postconditions);
+ }
+ else
+ {
+ fprintf(fout,"post:EMPTY\n");
+ }
+ }
+
+ }
+ }
}
+
void usymtab_load (FILE *f)
/*@globals utab, globtab@*/
/*@modifies utab, *f@*/
llassert (utab == globtab);
llassert (utab->nentries == 0);
- while (fgets (s, MAX_DUMP_LINE_LENGTH, f) != NULL
+ while (((s = reader_readLine (f, s, MAX_DUMP_LINE_LENGTH)) != NULL)
&& *s == ';')
{
- ; /* ignore ;-comments */
+ /* ignore ; comments */ ;
}
-
+
while (s != NULL && *s != ';')
{
-
+ int index;
+
if (*s == '*')
{
+ int ek;
s++;
- kind = ekind_fromInt (getInt (&s));
+ ek = reader_getInt (&s);
- goto nextiter;
+ if (ek == KGLOBALMARKER)
+ {
+ uentry lue = uentry_makeGlobalMarker ();
+ DPRINTF (("Adding global marker: %s", uentry_unparseFull (lue)));
+ usymtab_addEntryAlways (utab, lue);
+ kind = KINVALID;
+ goto nextiter;
+ }
+ else
+ {
+ kind = ekind_fromInt (ek);
+ goto nextiter;
+ }
}
if (*s == '$')
{
llfatalerror
(cstring_makeLiteral
- ("Library is in obsolete format. Use lclint +whichlib "
+ ("Library is in obsolete format. Use splint +whichlib "
"to see which library is being loaded."));
}
+ if (reader_optCheckChar (&s, '^'))
+ {
+ index = reader_getInt (&s);
+ }
+ else
+ {
+ index = -1;
+ }
+
+ llassert (kind != KINVALID);
ue = uentry_undump (kind, loc, &s);
- DPRINTF (("Load: %s", uentry_unparseFull (ue)));
+
+ llassert (utab->nentries == index || index == -1);
if (uentry_isValid (ue))
{
- ue = usymtab_addEntryBase (utab, ue);
+ int lastindex = utab->nentries;
+ ue = usymtab_addEntryAlways (utab, ue);
+
+
+# if 0
+ if (uentry_isConstant (ue)) /*@i23! isPreProcessorMacro */
+ {
+ cstring uname = uentry_getName (ue);
+
+ /* Also check its a macro... */
+ DPRINTF (("Installing: %s", uname));
+
+ cpphash_installMacro
+ (mstring_copy (cstring_toCharsSafe (uname)),
+ cstring_length (uname),
+ cpplib_createDefinition (message ("%s 255", uname),
+ loc,
+ FALSE, FALSE).defn,
+ cpphash_hashCode (cstring_toCharsSafe (uname),
+ cstring_length (uname),
+ CPP_HASHSIZE));
+
+ DPRINTF (("After install: %s", uname));
+ }
+# endif
+
+ if (utab->nentries != lastindex + 1)
+ {
+ DPRINTF (("No add: %s", uentry_unparseFull (ue)));
+ BADBRANCH;
+ }
/*@-branchstate@*/
}
/*@=branchstate@*/
while (*(s++) == '#')
{
- cstring name = cstring_fromCharsO (getWord (&s));
+ cstring name = cstring_fromCharsO (reader_getWord (&s));
uentry nue = uentry_nameCopy (name, ue);
+ /*
+ DPRINTF (("Name copy: %s", uentry_unparseFull (nue)));
+ BADBRANCH;
+ */
- DPRINTF (("Name copy: %s", uentry_unparseFull (nue)));
- usymtab_addEntryBase (utab, nue);
+ usymtab_addEntryAlways (utab, nue);
}
while ((c = *s) != '\0' && (c !='\n'))
}
nextiter:
- s = fgets (os, MAX_DUMP_LINE_LENGTH, f);
+ {
+ s = reader_readLine (f, os, MAX_DUMP_LINE_LENGTH);
+ }
}
+ /*DRL added 6/21/01
+ to handle reading of buffer overflow related constraints
+ */
+ while (fgets (s, MAX_DUMP_LINE_LENGTH, f) != NULL
+ && *s == ';')
+ {
+ ; /* ignore ;-comments */
+ }
+
+ /*drl July 27 added this so that libraries without
+ buffer constraints would be handled correctly.
+ I'm trying to do this without breaking older libraries*/
+
+ /*check for "optional" start buffer constraints message*/
+
+ if (mstring_equalPrefix (s, "start_Buffer_Constraints"))
+ {
+ (void) fgets (s, MAX_DUMP_LINE_LENGTH, f);
+ }
+
+ while (s != NULL && *s != ';')
+ {
+ constraintList preconditions;
+ constraintList postconditions;
+ cstring name = cstring_fromChars (reader_getWord (&s));
+ cstring temp;
+
+ ue = usymtab_lookup (name);
+ cstring_free (name);
+
+ preconditions = constraintList_undefined;
+ postconditions = constraintList_undefined;
+
+ if (!uentry_isValid(ue) )
+ {
+ llfatalbug ((message("Invalid uentry for %s library file may be corrupted", cstring_fromChars(s) ) ));
+ }
+ s = fgets (os, MAX_DUMP_LINE_LENGTH, f);
+
+ temp = cstring_fromChars (reader_getWord(&s) );
+
+ if (cstring_compareLit (temp,"pre:") == 0 )
+ {
+ preconditions = constraintList_undump (f);
+ }
+ else
+ {
+ if (cstring_compareLit (temp,"pre:EMPTY") != 0 )
+ llfatalbug ((message("Error reading library file pre:EMPTY expected but got %s", temp ) ));
+ }
+
+ cstring_free(temp);
+
+ s = fgets (os, MAX_DUMP_LINE_LENGTH, f);
+
+ temp = cstring_fromChars(reader_getWord(&s) );
+ if (cstring_compareLit (temp, "post:") == 0 )
+ {
+ postconditions = constraintList_undump (f);
+ }
+ else
+ {
+ if (cstring_compareLit (temp, "post:EMPTY") != 0 )
+ llfatalbug ((message("Error reading library file post:EMPTY expected but got %s", temp ) ));
+ }
+
+ cstring_free (temp);
+
+ uentry_setPreconditions (ue, functionConstraint_createBufferConstraint (preconditions));
+ uentry_setPostconditions (ue, functionConstraint_createBufferConstraint (postconditions));
+
+ s = fgets (os, MAX_DUMP_LINE_LENGTH, f);
+ }
+
dbgload = FALSE;
sfree (os);
}
{
if (sRef_hasDerived (uentry_getSref (ue)))
{
- fprintf (g_msgstream, "Derived Global: %s\n", uentry_unparse (ue));
- fprintf (g_msgstream, "sRef: %s\n", sRef_unparseFull (ue->sref));
+ fprintf (g_warningstream, "Derived Global: %s\n", uentry_unparse (ue));
+ fprintf (g_warningstream, "sRef: %s\n", sRef_unparseFull (ue->sref));
}
} end_usymtab_entries ;
usymtab ptab = utab->env;
uentry fcn = context_getHeader ();
-
usymtab_entries (ptab, param)
{
uentry ue;
{
sRef uref;
sRef pref = uentry_getSref (param);
-
- llassertprint (uentry_isAnyParam (param),
- ("not param: %s",
- uentry_unparseFull (param)));
-
-
- ue = uentry_makeVariable (fixParamName (uentry_rawName (param)),
- uentry_getType (param),
- fileloc_copy (uentry_whereDeclared (param)),
- FALSE);
- uentry_copyState (ue, param);
- uentry_setRefParam (ue);
-
- ue = usymtab_supEntrySrefReturn (ue);
-
- /* must be after supercede! */
+ /* Could be a global. */
- if (!sRef_stateKnown (pref))
- {
- uentry_setDefState (ue, SS_DEFINED);
- uentry_setDefState (param, SS_DEFINED);
- }
- else
- {
- if (sRef_isStateSpecial (pref))
+ if (uentry_isAnyParam (param))
+ {
+ ue = uentry_makeVariable (fixParamName (uentry_rawName (param)),
+ uentry_getType (param),
+ fileloc_copy (uentry_whereDeclared (param)),
+ FALSE);
+
+ uentry_copyState (ue, param);
+ uentry_setRefParam (ue);
+
+ ue = usymtab_supEntrySrefReturn (ue);
+
+ /* must be after supercede! */
+
+ if (!sRef_stateKnown (pref))
{
- uentry_setDefState (ue, SS_ALLOCATED);
+ uentry_setDefState (ue, SS_DEFINED);
+ uentry_setDefState (param, SS_DEFINED);
}
else
{
- uentry_setDefState (ue, sRef_getDefState (pref));
+ if (sRef_isStateSpecial (pref))
+ {
+ uentry_setDefState (ue, SS_SPECIAL); /* ALLOCATED); */
+ /* evans 2002-01-01: should be unnecessary, the pre clauses
+ ** set the state if necessary.
+ */
+ }
+ else
+ {
+ uentry_setDefState (ue, sRef_getDefState (pref));
+ }
}
- }
-
- uref = uentry_getSref (ue);
-
- if (sRef_isStack (uref))
- {
- alkind pkind = sRef_getAliasKind (pref);
+
+ uref = uentry_getSref (ue);
+
+ if (sRef_isStack (uref))
+ {
+ alkind pkind = sRef_getAliasKind (pref);
+
+ if (alkind_isKnown (pkind) && !alkind_isLocal (pkind)
+ && !alkind_isStack (pkind))
+ {
+ sRef_setAliasKind (uref, pkind, fileloc_undefined);
+ sRef_setOrigAliasKind (uref, pkind);
+ }
+ else
+ {
+ sRef_setAliasKind (uref, AK_IMPTEMP, fileloc_undefined);
+ sRef_setOrigAliasKind (uref, AK_IMPTEMP);
+
+ if (uentry_isOut (param))
+ {
+ ;
+ }
+ else
+ {
+ sRef_setDefined (uref, fileloc_undefined);
+ }
+ }
+
+ }
+
+ usymtab_addMustAlias (uref, pref);
+
+ if (!(uentry_isOnly (param) || uentry_isUnique (param)))
+ {
+ /*
+ ** This is needed for detecting possibly aliased parameters.
+ */
- if (alkind_isKnown (pkind) && !alkind_isLocal (pkind)
- && !alkind_isStack (pkind))
+ sRef s = sRef_makeExternal (uref);
+ usymtab_addMustAlias (uref, s);
+ }
+
+ if (sRef_isKillRef (pref))
+ {
+ sRef_setAliasKind (uref, AK_NEWREF, fileloc_undefined);
+ sRef_setOrigAliasKind (uref, AK_KILLREF);
+ }
+ else if (sRef_isRefCounted (uref))
{
- sRef_setAliasKind (uref, pkind, fileloc_undefined);
- sRef_setOrigAliasKind (uref, pkind);
+ sRef_setOrigAliasKind (uref, AK_REFCOUNTED);
}
else
{
- sRef_setAliasKind (uref, AK_IMPTEMP, fileloc_undefined);
- sRef_setOrigAliasKind (uref, AK_IMPTEMP);
-
- if (uentry_isOut (param))
- {
- ;
- }
- else
- {
- sRef_setDefined (uref, fileloc_undefined);
- }
+ /* was AK_UNIQUE */
+ sRef_setOrigAliasKind (uref, AK_LOCAL);
}
-
- }
-
- usymtab_addMustAlias (uref, pref);
-
- if (!(uentry_isOnly (param) || uentry_isUnique (param)))
- {
- sRef s = sRef_makeExternal (uref);
-
- usymtab_addMustAlias (uref, s);
- }
-
- if (sRef_isKillRef (pref))
- {
- sRef_setAliasKind (uref, AK_NEWREF, fileloc_undefined);
- sRef_setOrigAliasKind (uref, AK_KILLREF);
- }
- else if (sRef_isRefCounted (uref))
- {
- sRef_setOrigAliasKind (uref, AK_REFCOUNTED);
}
else
{
- /* was AK_UNIQUE */
- sRef_setOrigAliasKind (uref, AK_LOCAL);
}
}
- else
- {
- }
} end_usymtab_entries;
-
-
- if (uentry_hasSpecialClauses (fcn))
+
+
+ if (uentry_hasStateClauseList (fcn))
{
- specialClauses clauses = uentry_getSpecialClauses (fcn);
-
- specialClauses_preElements (clauses, cl)
+ stateClauseList clauses = uentry_getStateClauseList (fcn);
+
+ stateClauseList_preElements (clauses, cl)
{
- sRefSet refs = specialClause_getRefs (cl);
- sRefMod modf = specialClause_getEntryFunction (cl);
-
+ fileloc loc = stateClause_loc (cl);
+ sRefSet osrs = sRefSet_undefined;
+ sRefSet srs;
+
+ if (stateClause_isGlobal (cl))
+ {
+ DPRINTF (("Global Marker: %s",
+ sRef_unparseFull (usymtab_lookupGlobalMarker ())));
+ llassert (sRef_isGlobalMarker (usymtab_lookupGlobalMarker ()));
+ srs = sRefSet_single (usymtab_lookupGlobalMarker ());
+ osrs = srs;
+ }
+ else
+ {
+ srs = stateClause_getRefs (cl);
+ }
- sRefSet_elements (refs, el)
+ sRefSet_elements (srs, el)
{
sRef base = sRef_getRootBase (el);
-
+ sRef sb = sRef_updateSref (el);
+
if (sRef_isResult (base))
{
; /* nothing to do before */
}
- else if (sRef_isParam (base))
+ else if (sRef_isParam (base) || sRef_isGlobalMarker (base))
{
- if (modf != NULL)
+ if (stateClause_setsMetaState (cl))
{
- sRef sb = sRef_updateSref (el);
- sRefSet aliases = usymtab_allAliases (sb);
+ /* copied from exprNode.c:3040 */
+ qual ql = stateClause_getMetaQual (cl);
+ annotationInfo ainfo = qual_getAnnotationInfo (ql);
+ metaStateInfo minfo = annotationInfo_getState (ainfo);
+ cstring key = metaStateInfo_getName (minfo);
+ int mvalue = annotationInfo_getValue (ainfo);
- modf (sb, fileloc_undefined);
-
- sRefSet_elements (aliases, sr)
+ DPRINTF (("Sets meta state! %s", stateClause_unparse (cl)));
+
+ if (sRef_isResult (base))
{
- modf (sr, fileloc_undefined);
- } end_sRefSet_elements ;
-
- sRefSet_free (aliases);
+ BADBRANCH;
+ }
+ else
+ {
+ sRef_setMetaStateValueComplete (sb, key, mvalue, loc);
+ }
+ }
+ else
+ {
+ sRefMod modf = stateClause_getEntryFunction (cl);
+
+ if (modf != NULL)
+ {
+ sRefSet aliases = usymtab_allAliases (sb);
+
+ modf (sb, loc);
+
+ sRefSet_elements (aliases, sr)
+ {
+ modf (sr, loc);
+ } end_sRefSet_elements ;
+
+ sRefSet_free (aliases);
+ }
}
}
else
{
if (sRef_isValid (base))
{
+ DPRINTF (("Base: %s", sRef_unparseFull (base)));
BADBRANCH;
}
}
} end_sRefSet_elements ;
- } end_specialClauses_preElements ;
+ } end_stateClauseList_preElements ;
}
- }
-
+}
+
void
usymtab_enterFunctionScope (uentry fcn)
/*@globals utab, filetab, globtab@*/
{
usymtab t = usymtab_create (US_NORMAL, utab, TRUE);
+ DPRINTF (("Enter function: %s", uentry_unparse (fcn)));
+
if (utab->lexlevel != fileScope)
{
if (utab->lexlevel > fileScope)
{
- llparseerror (cstring_makeLiteral ("New function scope inside function."));
+ llparseerror (cstring_makeLiteral ("New function scope inside function"));
while (utab->lexlevel > fileScope)
{
}
/*@-branchstate@*/ } /*@=branchstate@*/
+ utab = t;
+
+ DPRINTF (("Globs: %s", globSet_unparse (uentry_getGlobs (fcn))));
+
globSet_allElements (uentry_getGlobs (fcn), el)
{
+ DPRINTF (("Here we go: %s", sRef_unparseFull (el)));
if (sRef_isUndefGlob (el))
{
- int index = sRef_getScopeIndex (el);
+ usymId index = sRef_getScopeIndex (el);
sRef sr = sRef_updateSref (el);
fileloc loc = uentry_whereEarliest (fcn);
-
+
+ DPRINTF (("update: %s", sRef_unparseFull (sr)));
+ DPRINTF (("Undef!"));
if (sRef_isFileStatic (el))
{
ctype ct = sRef_getType (el);
}
else
{
- /* defined */ ;
+ /*
+ sRef sr = sRef_updateSref (el);
+ fileloc loc = uentry_whereEarliest (fcn);
+
+ sRef_setDefined (sr, loc);
+ */
+
+ /* defined */
+ /* shouldn't need to do anything! */
}
} end_globSet_allElements;
- utab = t;
+ DPRINTF (("Globs after: %s", globSet_unparse (uentry_getGlobs (fcn))));
+# ifdef DEBUGSPLINT
+ usymtab_checkAllValid ();
+# endif
}
static void
usymtab t = usymtab_create (US_SWITCH, utab, FALSE);
t->aliases = aliasTable_copy (utab->aliases);
- utab = t;
+ utab = t;
}
void
guardSet_free (t->guards);
t->guards = guards;
-
- aliasTable_free (t->aliases);
+
+ aliasTable_free (t->aliases);
t->aliases = aliasTable_copy (utab->aliases);
- utab = t;
+ utab = t;
}
/*
*/
void
-usymtab_popTrueBranch (exprNode pred, exprNode expr, clause cl)
+usymtab_popTrueBranch (exprNode pred, exprNode expr, clause cl) /*@modifies utab@*/
{
/*
** add a false branch
** it is better to only maintain one version of the code)
*/
- usymtab_altBranch (guardSet_invert (exprNode_getGuards (pred)));
- usymtab_popBranches (pred, expr, exprNode_undefined, TRUE, cl);
+ if (utab->kind != US_TBRANCH
+ && context_inIterDef ())
+ {
+ usymtab_exitScope (expr);
+ }
+ else
+ {
+ DPRINTF (("pop true branch.."));
+ usymtab_altBranch (guardSet_invert (exprNode_getGuards (pred)));
+ usymtab_popBranches (pred, expr, exprNode_undefined, TRUE, cl);
+ }
}
void
bool mustReturn = usymtab_mustEscape (utab);
usymtab stab = utab;
+ DPRINTF (("New case!"));
+
/*
** Find last case (or outer switch)
*/
stab = stab->env;
llassert (stab != GLOBAL_ENV);
}
-
- /* ??? */
-
+
while (stab->kind == US_CBRANCH)
{
stab = stab->env;
usymtab otab= utab;
int i = 0;
- llassert (utab->kind == US_TBRANCH);
+ llassert (utab->kind == US_TBRANCH);
/*
** merge each entry in table with its original
}
}
+ DPRINTF (("Popping and: %s / %s",
+ guardSet_unparse (utab->guards),
+ guardSet_unparse (exprNode_getGuards (pred))));
+
utab->guards = guardSet_levelUnionFree (utab->guards,
guardSet_invert (exprNode_getGuards (pred)),
utab->lexlevel);
{
usymtab_entries (stab, current)
{
- if (usymtab_getIndex (ttab, uentry_rawName (current)) == NOT_FOUND)
+ if (!usymtab_indexFound (usymtab_getIndex (ttab, uentry_rawName (current))))
{
uentry old = /*@-compmempass@*/
usymtab_lookupAux (ltab, uentry_rawName (current));
/*@notnull@*/ usymtab ftab, bool trueGuard)
{
sRef base = sRef_getRootBase (el);
- int level = sRef_lexLevel (base);
-
-
+ int level = sRef_lexLevel (base);
if (sRef_isCvar (base))
{
if (!guardSet_isGuarded (ttab->guards, el)
&& !sRef_isNotNull (sr))
{
+ DPRINTF (("Here! %s / %s",
+ sRef_unparseFull (sr),
+ sRef_unparseFull (el)));
sRef_setDerivNullState (sr, el, NS_DEFNULL);
- }
+ }
}
}
else
{
- }
+ ;
+ }
ue = usymtab_getRefTab (ftab, level, index);
{
sRef sr = uentry_getSref (ue);
-
if (!trueGuard) /* yikes! forgot the ! */
{
sRef_setDerivNullState (sr, el, NS_NOTNULL);
&& !sRef_isNotNull (sr))
{
sRef_setDerivNullState (sr, el, NS_DEFNULL);
- }
+ }
}
}
else
{
- }
-
- }
-
- }
+ ;
+ }
+ }
+}
void
usymtab_popBranches (exprNode pred, exprNode tbranch, exprNode fbranch,
sRefSet fguards = guardSet_getFalseGuards (guards);
bool mustReturnT = exprNode_mustEscape (tbranch);
bool mustReturnF = exprNode_mustEscape (fbranch);
-
+
+ DPRINTF (("Pop branches: %s [mustreturn: %s/%s]", exprNode_unparse (pred),
+ bool_unparse (mustReturnT),
+ bool_unparse (mustReturnF)));
+
if (exprNode_isDefined (fbranch))
{
loc = exprNode_loc (fbranch);
**
** if an entry is in one table, merge it with the original.
*/
-
+
+ DPRINTF (("ftab: %d", ftab->nentries));
+
for (i = 0; i < ftab->nentries; i++)
{
uentry fthis = ftab->entries[i];
uentry old = usymtab_lookupAux (env, uentry_rawName (fthis));
- int tindex = usymtab_getIndex (ttab, uentry_rawName (fthis));
+ usymId tindex = usymtab_getIndex (ttab, uentry_rawName (fthis));
+ DPRINTF (("Entry: %s / %s", uentry_unparseFull (fthis), uentry_unparseFull (old)));
+
if (uentry_isUndefined (old))
{
/* possible entry was added as an undefined id */
+ DPRINTF (("Undefined! %s", uentry_rawName (fthis)));
continue;
}
- if (tindex != NOT_FOUND)
+ if (usymtab_indexFound (tindex))
{
uentry tthis = ttab->entries[tindex];
-
+
/* note that is this is in a nested branch,
it may create a "new" old entry. */
{
if (!mustReturnT)
{
-
uentry_mergeState (fthis, tthis, loc,
mustReturnT, FALSE, FALSE, cl);
}
{
uentry current = ttab->entries[i];
+ DPRINTF (("ttab: %s", uentry_unparseFull (current)));
+
if (!uentry_isUndefined (current))
{
uentry old = usymtab_lookupAux (env, uentry_rawName (current));
- llassertprint (!uentry_isUndefined (old), ("name: <%s>",
- uentry_rawName (current)));
+ DPRINTF (("Old: %s", uentry_unparseFull (old)));
+
+ if (uentry_isUndefined (old))
+ {
+ llcontbug (message ("Undefined entry: %s", uentry_rawName (current)));
+ continue;
+ }
+
if (mustReturnF)
{
uentry_mergeUses (current, old);
else
{
/*
- ** assumes false branch is a fall-through if
+ ** Assumes false branch is a fall-through if
** fbranch is not defined. This is true, unless
** where was some greivous error in processing
** the else branch of an if-then, in which case
uentry_mergeState (old, current, loc, mustReturnT,
FALSE, isOpt, cl);
}
+
+ DPRINTF (("==> %s", uentry_unparseFull (old)));
}
}
-
/*
** Plain levelUnion doesn't work, since we need to use the sRef's in env->aliases
ftab->aliases, env->lexlevel);
aliasTable_fixSrefs (env->aliases);
+
+ DPRINTF (("Aliases: %s", aliasTable_unparse (env->aliases)));
/* exit true and false scopes */
usymtab_quietPlainExitScope ();
usymtab_altBranch (/*@only@*/ guardSet guards)
/*@modifies utab@*/
{
- usymtab t = usymtab_create (US_FBRANCH, utab, FALSE);
+ usymtab t;
usymtab parent = utab->env;
+ t = usymtab_create (US_FBRANCH, utab, FALSE);
+
/*
** If we are in a case, need to close it. The C syntax
** is very liberal, so this kludge is necessary.
usymtab_fixCases ();
DPRINTF (("Current kind: %s", usymtab_unparseStack ()));
+
llassert (utab->kind == US_TBRANCH);
llassert (parent != GLOBAL_ENV);
-
+
guardSet_free (t->guards);
t->guards = guards;
-
+
aliasTable_free (t->aliases);
t->aliases = aliasTable_copy (parent->aliases);
-
+
utab = t;
}
{
fileloc dloc = uentry_whereDeclared (e);
- if (fileloc_isLib (dloc))
+ if (fileloc_isLib (dloc) || fileloc_isXHFile (dloc))
{
;
}
ekind_capName (uentry_getKind (e)),
uentry_getName (e)),
dloc);
+ DPRINTF (("decl: %s", uentry_unparseFull (e)));
}
}
}
if (fileloc_isDefined (fwhere)
&& !fileloc_isHeader (fwhere)
+ && !fileloc_isXHFile (fwhere)
&& !(fileloc_isSpecialFile (fwhere)
&& !context_getFlag (FLG_UNUSEDSPECIAL)))
{
/*@globals utab@*/
{
int i;
-
for (i = 0; i < utab->nentries; i++)
{
uentry ce = utab->entries[i];
-
if (!uentry_isDatatype (ce) && !uentry_isAnyTag (ce)
&& !uentry_isEitherConstant (ce)
; /* no errors */
}
} /* unused */
- else if (uentry_isDatatype (ce) || uentry_isAnyTag (ce))
+ else if ((uentry_isDatatype (ce) || uentry_isAnyTag (ce)))
{ /* check all fields */
ctype ct = uentry_getRealType (ce);
ct = ctype_getBaseType (ct);
}
-
if (ctype_isSU (ct))
{
uentryList fields = ctype_getFields (ct);
}
else
{
+ /*
+ ** evans 2001-06-08
+ ** Can't report these errors for unnamed structs.
+ ** No way to tell when there are multiple consistent
+ ** unnamed structure types. (Could go through table
+ ** and mark them all unused...)
+
hasError |= optgenerror
(FLG_FIELDUNUSED,
message ("Field %q of unnamed %s declared but not used",
cstring_makeLiteralTemp
(ctype_isStruct (ct) ? "structure" : "union")),
uentry_whereEarliest (field));
+
+ */
}
uentry_setUsed (field, fileloc_undefined);
{
sRef sr = uentry_getSref (glob);
-
+ DPRINTF (("Check global return: %s / orig: %s / sr: %s",
+ uentry_unparseFull (glob),
+ sRef_unparseFull (orig),
+ sRef_unparseFull (sr)));
+
+ DPRINTF (("Is killed: %s", bool_unparse (sRef_isKilledGlob (orig))));
+
if (context_getFlag (FLG_GLOBSTATE))
{
+ DPRINTF (("Is killed: %s", sRef_unparseFull (orig)));
+
if (sRef_isKilledGlob (orig))
{
if (sRef_isStateUndefined (sr)
else
{
ctype ct = ctype_realType (uentry_getType (glob));
+
+ DPRINTF (("Check global destroyed: %s", uentry_unparseFull (glob)));
if (ctype_isVisiblySharable (ct))
{
if (optgenerror
(FLG_GLOBSTATE,
message
- ("Killed global %q not released before return",
- uentry_getName (glob)),
+ ("Killed global %q (type %s) not released before return",
+ uentry_getName (glob),
+ ctype_unparse (ct)),
g_currentloc))
{
sRef_showStateInfo (sr);
- }
+ }
}
else
{
- sRef_protectDerivs ();
- (void) checkGlobalDestroyed (sr, g_currentloc);
+ sRef_protectDerivs ();
+ (void) transferChecks_globalDestroyed (sr, g_currentloc);
sRef_clearProtectDerivs ();
}
}
}
else
{
- if (sRef_isDead (sr))
+ if (sRef_isDead (sr) || sRef_isKept (sr))
{
if (optgenerror
(FLG_GLOBSTATE,
message ("Function returns with global %q "
- "referencing released storage",
- uentry_getName (glob)),
+ "referencing %s storage",
+ uentry_getName (glob),
+ cstring_makeLiteralTemp (sRef_isDead (sr) ? "released" : "kept")),
g_currentloc))
{
- sRef_showStateInfo (sr);
+ if (sRef_isKept (sr))
+ {
+ sRef_showAliasInfo (sr);
+ }
+ else
+ {
+ sRef_showStateInfo (sr);
+ }
+
sRef_setDefState (sr, SS_UNKNOWN, fileloc_undefined);
}
}
- if (ctype_isRealPointer (uentry_getType (glob)) &&
- sRef_possiblyNull (sr) && !uentry_possiblyNull (glob))
+ DPRINTF (("Here: %s / %s",
+ uentry_unparseFull (glob),
+ sRef_unparseFull (sr)));
+
+ if (ctype_isRealPointer (uentry_getType (glob))
+ && sRef_possiblyNull (sr)
+ && !uentry_possiblyNull (glob))
{
if (optgenerror
(FLG_GLOBSTATE,
}
else
{
- checkGlobReturn (glob);
+ DPRINTF (("Check transfer: %s", uentry_unparseFull (glob)));
+ transferChecks_globalReturn (glob);
}
}
}
void usymtab_checkFinalScope (bool isReturn)
/*@globals utab@*/
{
- bool mustFree = context_getFlag (FLG_MUSTFREE);
bool mustDefine = context_getFlag (FLG_MUSTDEFINE);
- /* bool mustNotAlias = context_getFlag (FLG_MUSTNOTALIAS); */
sRefSet checked = sRefSet_new ();
usymtab stab = utab;
int i;
uentry ce = stab->entries[i];
sRef sr = uentry_getSref (ce);
sRef rb = sRef_getRootBase (sr);
+ valueTable tvalues;
+
+ /*
+ ** Shouldn't check if shadow checked in deeper scope:
+ */
+
+ if (stab != utab)
+ {
+ uentry oue = usymtab_lookupQuietNoAlt (utab, uentry_observeRealName (ce));
+ if (!uentry_sameObject (ce, oue))
+ {
+ /* what if it is one an alternate branch? */
+ /*@innercontinue@*/ continue;
+ }
+ }
+
+ DPRINTF (("Here check final scope: %s", uentry_unparseFull (ce)));
+
if (ctype_isFunction (uentry_getType (ce)))
{
/*@innercontinue@*/ continue;
}
- if (mustFree)
+ if (uentry_isAnyParam (ce)
+ || uentry_isRefParam (ce)
+ || sRef_isFileOrGlobalScope (rb))
{
- DPRINTF (("Check entry: %s", uentry_unparseFull (ce)));
-
- if (!sRefSet_member (checked, sr) && !sRef_isGlobal (rb))
- {
- if (ctype_isRealSU (uentry_getType (ce))
- && !uentry_isAnyParam (ce)
- && !uentry_isRefParam (ce)
- && !uentry_isStatic (ce)
- && !sRef_isDependent (sr)
- && !sRef_isOwned (sr))
- {
- sRefSet als = usymtab_allAliases (sr);
-
-
- if (sRefSet_isEmpty (als))
- {
- checkLocalDestroyed (sr, g_currentloc);
- }
- else
- {
- /* aliased, no problem */ ;
- }
+ /* Don't do the loseref check...but should check state! */
+ DPRINTF (("Skipping check 1"));
+ }
+ else if (sRef_isDefinitelyNull (sr)
+ || usymtab_isDefinitelyNull (sr))
+ {
+ /*
+ ** No state reference errors for definitely null references.
+ */
- sRefSet_free (als);
- }
- else if
- (!uentry_isStatic (ce)
- && ((sRef_isNewRef (sr))
- || (((sRef_isOnly (sr) || sRef_isFresh (sr)
- || sRef_isKeep (sr) || sRef_isOwned (sr))
- && !sRef_isDead (sr))
- && (!sRef_definitelyNull (sr))
- && (!usymtab_isProbableNull (sr)))))
+ DPRINTF (("Skipping check 2"));
+ }
+ else
+ {
+ DPRINTF (("Lose ref: %s / %s", uentry_unparse (ce),
+ sRef_unparseFull (sr)));
+
+ tvalues = sRef_getValueTable (sr);
+
+ valueTable_elements (tvalues, fkey, fval) {
+ metaStateInfo minfo;
+ cstring msg = cstring_undefined;
+ int nval;
+
+ minfo = context_lookupMetaStateInfo (fkey);
+ llassert (metaStateInfo_isDefined (minfo));
+
+ if (stateValue_isError (fval)
+ || sRef_isStateUndefined (sr)) /* No errors for undefined state */
+ {
+ DPRINTF (("Skipping check 3"));
+ }
+ else
+ {
+ DPRINTF (("Check: %s / %s / %s", fkey,
+ metaStateInfo_unparse (minfo),
+ stateValue_unparse (fval)));
+
+ minfo = context_lookupMetaStateInfo (fkey);
+
+ nval = stateCombinationTable_lookupLoseReference
+ (metaStateInfo_getTransferTable (minfo),
+ stateValue_getValue (fval), &msg);
+
+ if (cstring_isDefined (msg))
{
- bool hasError = TRUE;
-
- /*
- ** If its a scope exit, check if there is an alias.
- ** If so, make it only. If not, there is an error.
- */
-
- if (!isReturn)
+ if (optgenerror
+ (FLG_STATETRANSFER,
+ message
+ ("%s loses reference %q in invalid state %q (%s)",
+ cstring_makeLiteralTemp (isReturn ? "Return" : "Scope exit"),
+ uentry_getName (ce),
+ stateValue_unparseValue (fval, minfo),
+ msg),
+ g_currentloc))
{
- if (canLoseReference (sr, g_currentloc))
- {
- hasError = FALSE;
- }
+ stateValue_show (fval, minfo);
}
-
- if (hasError)
+ else
{
- if (sRef_hasLastReference (sr))
- {
- sRef ar = sRef_getAliasInfoRef (sr);
-
- if (optgenerror
- (FLG_MUSTFREE,
- message
- ("Last reference %q to %s storage %qnot %q before %q",
- sRef_unparse (sr),
- alkind_unparse (sRef_getAliasKind (sr)),
- sRef_unparseOpt (ar),
- cstring_makeLiteral (sRef_isKeep (sr)
- ? "transferred" : "released"),
- cstring_makeLiteral (isReturn
- ? "return" : "scope exit")),
- g_currentloc))
- {
- sRef_showRefLost (sr);
- }
- }
- else if (sRef_isNewRef (sr))
- {
- if (optgenerror
- (FLG_MUSTFREE,
- message
- ("%q %q not released before %q",
- cstring_makeLiteral
- (alkind_isKillRef (sRef_getOrigAliasKind (sr))
- ? "Kill reference parameter" : "New reference"),
- uentry_getName (ce),
- cstring_makeLiteral (isReturn
- ? "return" : "scope exit")),
- g_currentloc))
- {
- sRef_showAliasInfo (sr);
- }
- }
- else
- {
- if (ctype_isRealSU (sRef_getType (sr)))
- {
- checkStructDestroyed (sr, g_currentloc);
- }
- else
- {
- if (optgenerror
- (FLG_MUSTFREE,
- message
- ("%s storage %q not %q before %q",
- alkind_capName (sRef_getAliasKind (sr)),
- uentry_getName (ce),
- cstring_makeLiteral (sRef_isKeep (sr)
- ? "transferred" : "released"),
- cstring_makeLiteral (isReturn
- ? "return" : "scope exit")),
- g_currentloc))
- {
- sRef_showAliasInfo (sr);
- }
- }
- }
+ DPRINTF (("Suppressed transfer error: %s", msg));
}
}
+ }
+ } end_valueTable_elements;
+ }
+
+ DPRINTF (("Check mustfree entry: %s", uentry_unparseFull (ce)));
+
+ if (!sRefSet_member (checked, sr) && !sRef_isFileOrGlobalScope (rb))
+ {
+ if (ctype_isRealSU (uentry_getType (ce))
+ && !uentry_isAnyParam (ce)
+ && !uentry_isRefParam (ce)
+ && !uentry_isStatic (ce)
+ && !sRef_isDependent (sr)
+ && !sRef_isOwned (sr))
+ {
+ sRefSet als = usymtab_allAliases (sr);
+
+ if (sRefSet_isEmpty (als))
+ {
+ transferChecks_localDestroyed (sr, g_currentloc);
+ }
else
{
- ;
+ /* aliased, no problem */ ;
}
+
+ sRefSet_free (als);
}
- else if (mustDefine && uentry_isOut (ce))
+ else if
+ (!uentry_isStatic (ce)
+ && ((sRef_isNewRef (sr))
+ || (((sRef_isOnly (sr) || sRef_isFresh (sr)
+ || sRef_isKeep (sr) || sRef_isOwned (sr))
+ && !sRef_isDead (sr))
+ && (!sRef_definitelyNull (sr))
+ && (!usymtab_isDefinitelyNull (sr)))))
{
- if (!ynm_toBoolStrict (sRef_isReadable (sr)))
+ bool hasError = TRUE;
+
+ DPRINTF (("Checking: %s", sRef_unparseFull (sr)));
+
+ /*
+ ** If its a scope exit, check if there is an alias.
+ ** If so, make it only. If not, there is an error.
+ */
+
+ if (!isReturn)
{
- voptgenerror
- (FLG_MUSTDEFINE,
- message ("Out storage %q not defined before %q",
- uentry_getName (ce),
- cstring_makeLiteral
- (isReturn ? "return" : "scope exit")),
- g_currentloc);
-
- /* uentry_showWhereDeclared (ce); */
+ if (transferChecks_canLoseReference (sr, g_currentloc))
+ {
+ DPRINTF (("Can lose!"));
+ hasError = FALSE;
+ }
+ }
+
+ if (hasError)
+ {
+ if (sRef_hasLastReference (sr))
+ {
+ sRef ar = sRef_getAliasInfoRef (sr);
+
+ if (optgenerror
+ (sRef_isFresh (ar) ? FLG_MUSTFREEFRESH : FLG_MUSTFREEONLY,
+ message
+ ("Last reference %q to %s storage %qnot %q before %q",
+ sRef_unparse (sr),
+ alkind_unparse (sRef_getAliasKind (sr)),
+ sRef_unparseOpt (ar),
+ cstring_makeLiteral (sRef_isKeep (sr)
+ ? "transferred" : "released"),
+ cstring_makeLiteral (isReturn
+ ? "return" : "scope exit")),
+ g_currentloc))
+ {
+ sRef_showRefLost (sr);
+ }
+ }
+ else if (sRef_isNewRef (sr))
+ {
+ if (optgenerror
+ (sRef_isFresh (sr) ? FLG_MUSTFREEFRESH : FLG_MUSTFREEONLY,
+ message
+ ("%q %q not released before %q",
+ cstring_makeLiteral
+ (alkind_isKillRef (sRef_getOrigAliasKind (sr))
+ ? "Kill reference parameter" : "New reference"),
+ uentry_getName (ce),
+ cstring_makeLiteral (isReturn
+ ? "return" : "scope exit")),
+ g_currentloc))
+ {
+ sRef_showAliasInfo (sr);
+ }
+ }
+ else
+ {
+ if (ctype_isRealSU (sRef_getType (sr)))
+ {
+ transferChecks_structDestroyed (sr, g_currentloc);
+ }
+ else
+ {
+ if (optgenerror
+ (sRef_isFresh (sr) ? FLG_MUSTFREEFRESH : FLG_MUSTFREEONLY,
+ message
+ ("%s storage %q not %q before %q",
+ alkind_capName (sRef_getAliasKind (sr)),
+ uentry_getName (ce),
+ cstring_makeLiteral (sRef_isKeep (sr)
+ ? "transferred" : "released"),
+ cstring_makeLiteral (isReturn
+ ? "return" : "scope exit")),
+ g_currentloc))
+ {
+ sRef_showAliasInfo (sr);
+ DPRINTF (("Storage: %s", sRef_unparseFull (sr)));
+ }
+ }
+ }
}
}
else
{
- ;
+ ;
}
-
- /*
- ** also check state is okay
- */
+ }
- if (usymtab_lexicalLevel () > functionScope
- && uentry_isVariable (ce)
- && (sRef_isLocalVar (sr)
- && (sRef_isDependent (sr) || sRef_isLocalState (sr))))
+ if (mustDefine && uentry_isOut (ce))
+ {
+ /* No error if its dead (either only or error already reported */
+ if (!sRef_isReallyDefined (sr) && !sRef_isDead (sr))
{
- sRefSet ab = usymtab_aliasedBy (sr);
-
- /* should do something more efficient here */
+ voptgenerror
+ (FLG_MUSTDEFINE,
+ message ("Out storage %q not defined before %q",
+ uentry_getName (ce),
+ cstring_makeLiteral
+ (isReturn ? "return" : "scope exit")),
+ g_currentloc);
- if (sRefSet_isEmpty (ab))
- {
- /* and no local ref */
- checkLoseRef (ce);
- }
- else
- {
- ;
- }
-
- sRefSet_free (ab);
+ DPRINTF (("sr: %s", sRef_unparseFull (sr)));
}
- else
+ }
+
+ /*
+ ** also check state is okay
+ */
+
+ if (usymtab_lexicalLevel () > functionScope
+ && uentry_isVariable (ce)
+ && (sRef_isLocalVar (sr)
+ && (sRef_isDependent (sr) || sRef_isLocalState (sr))))
+ {
+ sRefSet ab = usymtab_aliasedBy (sr);
+
+ /* should do something more efficient here */
+
+ if (sRefSet_isEmpty (ab))
+ {
+ /* and no local ref */
+ DPRINTF (("Check lose ref: %s", uentry_unparseFull (ce)));
+ transferChecks_loseReference (ce);
+ }
+ else
{
;
}
- checked = sRefSet_insert (checked, sr);
+ sRefSet_free (ab);
+ }
+ else
+ {
+ ;
}
+
+ checked = sRefSet_insert (checked, sr);
}
+
llassert (usymtab_isDefined (stab->env));
if (usymtab_isBranch (stab))
{
stab = stab->env;
}
-
+
llassert (stab != usymtab_undefined);
} while (isReturn && (stab->lexlevel >= paramsScope));
-
- sRefSet_free (checked);
-
+
+ sRefSet_free (checked);
+
/*
** for returns:
** all globals are appropriately defined
uentryList params = context_getParams ();
globSet uglobs = context_getUsedGlobs ();
globSet sglobs = context_getGlobs ();
-
if (isReturn && context_maybeSet (FLG_GLOBALIAS))
{
}
/*
- ** special clauses (defines, sets, allocates, releases)
+ ** state clauses (ensures, defines, sets, allocates, releases)
*/
-
- if (uentry_hasSpecialClauses (fcn))
+
+ if (uentry_hasStateClauseList (fcn))
{
- specialClauses clauses = uentry_getSpecialClauses (fcn);
+ stateClauseList clauses = uentry_getStateClauseList (fcn);
- specialClauses_elements (clauses, cl)
+ stateClauseList_elements (clauses, cl)
{
- if (specialClause_isAfter (cl))
- { /* evs - 2000 07 10 - added this */
- sRefTest tst = specialClause_getPostTestFunction (cl);
- sRefSet rfs = specialClause_getRefs (cl);
-
- sRefSet_elements (rfs, el)
+ if (stateClause_isAfter (cl) && !stateClause_isGlobal (cl))
+ {
+ if (stateClause_setsMetaState (cl))
{
- sRef base = sRef_getRootBase (el);
-
- if (sRef_isResult (base))
- {
- ;
- }
- else if (sRef_isParam (base))
+ sRefSet rfs = stateClause_getRefs (cl);
+ qual q = stateClause_getMetaQual (cl);
+ annotationInfo ainfo = qual_getAnnotationInfo (q);
+ metaStateInfo minfo = annotationInfo_getState (ainfo);
+ cstring key = metaStateInfo_getName (minfo);
+ int mvalue = annotationInfo_getValue (ainfo);
+
+ DPRINTF (("Post meta state clause: %s", stateClause_unparse (cl)));
+
+ sRefSet_elements (rfs, el)
{
- sRef sr = sRef_updateSref (base);
- sr = sRef_fixBase (el, sr);
+ sRef base = sRef_getRootBase (el);
- if (tst != NULL && !tst (sr))
+ if (sRef_isResult (base))
{
- if (optgenerror
- (specialClause_postErrorCode (cl),
- message ("%s storage %qcorresponds to "
- "storage listed in %q clause",
- specialClause_postErrorString (cl, sr),
- sRef_unparseOpt (sr),
- specialClause_unparseKind (cl)),
- g_currentloc))
+ /*
+ ** This is checked for return transfers.
+ */
+ ;
+ }
+ else if (sRef_isParam (base) || sRef_isGlobalMarker (base))
+ {
+ sRef sr = sRef_updateSref (base);
+ sr = sRef_fixBase (el, sr);
+
+ if (!sRef_checkMetaStateValue (sr, key, mvalue))
{
- sRefShower ss = specialClause_getPostTestShower (cl);
-
- if (ss != NULL)
+ if (optgenerror
+ (FLG_STATETRANSFER,
+ message
+ ("Ensures clause not satisfied%q (state is %q): %q",
+ sRef_isGlobalMarker (sr)
+ ? message ("")
+ : message (" by %q", sRef_unparse (sr)),
+ stateValue_unparseValue (sRef_getMetaStateValue (sr, key),
+ minfo),
+ stateClause_unparse (cl)),
+ g_currentloc))
{
- ss (sr);
- }
- }
+ sRef_showMetaStateInfo (sr, key);
+ }
+ }
}
- }
- else
+ else
+ {
+ if (sRef_isMeaningful (el))
+ {
+ BADBRANCH;
+ }
+ }
+ } end_sRefSet_elements ;
+ }
+ else
+ {
+ /* evs - 2000 07 10 - added this */
+ sRefTest tst = stateClause_getPostTestFunction (cl);
+ sRefSet rfs = stateClause_getRefs (cl);
+
+ sRefSet_elements (rfs, el)
{
- if (sRef_isMeaningful (el))
+ sRef base = sRef_getRootBase (el);
+
+ if (sRef_isResult (base))
{
- BADBRANCH;
+ /*
+ ** This is checked for return transfers.
+ */
+
+ ;
}
- }
- } end_sRefSet_elements ;
+ else if (sRef_isParam (base))
+ {
+ sRef sr = sRef_updateSref (base);
+ sr = sRef_fixBase (el, sr);
+
+ if (tst != NULL && !tst (sr))
+ {
+ if (optgenerror
+ (stateClause_postErrorCode (cl),
+ message ("%s storage %qcorresponds to "
+ "storage listed in %q clause",
+ stateClause_postErrorString (cl, sr),
+ sRef_unparseOpt (sr),
+ stateClause_unparseKind (cl)),
+ g_currentloc))
+ {
+ sRefShower ss = stateClause_getPostTestShower (cl);
+
+ if (ss != NULL)
+ {
+ ss (sr);
+ }
+
+ DPRINTF (("Storage: %s", sRef_unparseFull (sr)));
+ }
+ }
+ }
+ else
+ {
+ if (sRef_isMeaningful (el))
+ {
+ BADBRANCH;
+ }
+ }
+ } end_sRefSet_elements ;
+ }
}
- } end_specialClauses_elements ;
+ } end_stateClauseList_elements ;
}
/*
if (ctype_isMutable (rt) || ctype_isSU (rt))
{
uentry param = usymtab_lookupQuiet (utab, uentry_rawName (arg));
- checkParamReturn (param);
+ DPRINTF (("Check param return: %s", uentry_unparseFull (param)));
+ transferChecks_paramReturn (param);
}
}
} end_uentryList_elements;
+ DPRINTF (("Check global return: %s",
+ globSet_unparse (sglobs)));
+
globSet_allElements (sglobs, el)
{
+ sRef orig = el; /*! sRef_updateSref (el); */ /*!!!*/
uentry current = sRef_getUentry (el);
+ DPRINTF (("Check global return: %s / %s", sRef_unparseFull (el),
+ uentry_unparseFull (current)));
+
if (uentry_isVariable (current) && !uentry_isRealFunction (current))
{
- checkGlobalReturn (current, el);
+ checkGlobalReturn (current, orig);
}
} end_globSet_allElements;
{
uentry current = sRef_getUentry (el);
-
if (uentry_isVariable (current)
&& !uentry_isRealFunction (current))
{
}
}
} end_globSet_allElements;
- }
-
- }
+ }
+}
void
usymtab_quietExitScope (fileloc loc)
{
usymtab t = utab->env;
+ DPRINTF (("Quiet exit scope [%p]", utab));
+
if (utab->reftable != NULL)
{
int i;
t->mustBreak = utab->mustBreak;
t->exitCode = utab->exitCode;
+ DPRINTF (("Free level [%p]", utab));
usymtab_freeLevel (utab);
utab = t;
+
+# ifdef DEBUGSPLINT
+ usymtab_checkAllValid ();
+# endif
}
/*
usymtab ctab = usymtab_undefined;
usymtab lctab = usymtab_undefined;
bool mustReturn = exprNode_mustEscape (expr);
-
+
+ DPRINTF (("Exit scope [%p]", utab));
+
if (utab->kind == US_CBRANCH)
{
/*
}
if (utab->kind == US_TBRANCH || utab->kind == US_FBRANCH
- || utab->kind == US_CBRANCH || utab->kind == US_SWITCH) {
-
- if (context_inMacro ()) {
- /* evs 2000-07-25 */
- /* Unparseable macro may end inside nested scope. Deal with it. */
-
- llerror (FLG_SYNTAX, message ("Problem parsing macro body of %s (unbalanced scopes). Attempting to recover, recommend /*@notfunction@*/ before macro definition.",
- context_inFunctionName ()));
-
- while (utab->kind == US_TBRANCH
- || utab->kind == US_FBRANCH
- || utab->kind == US_CBRANCH
- || utab->kind == US_SWITCH)
+ || utab->kind == US_CBRANCH || utab->kind == US_SWITCH)
+ {
+ if (context_inMacro ())
{
- utab = utab->env;
- llassert (utab != GLOBAL_ENV);
- }
- } else {
- llcontbug (("exitScope: in branch: %s", usymtab_unparseStack ()));
- /*@-branchstate@*/
- } /*@=branchstate@*/
- }
-
+ /* evs 2000-07-25 */
+ /* Unparseable macro may end inside nested scope. Deal with it. */
+
+ llerror (FLG_SYNTAX,
+ message ("Problem parsing macro body of %s (unbalanced scopes). "
+ "Attempting to recover, recommend /*@notfunction@*/ before "
+ "macro definition.",
+ context_inFunctionName ()));
+
+ while (utab->kind == US_TBRANCH
+ || utab->kind == US_FBRANCH
+ || utab->kind == US_CBRANCH
+ || utab->kind == US_SWITCH)
+ {
+ utab = utab->env;
+ llassert (utab != GLOBAL_ENV);
+ }
+ } else
+ {
+ llcontbug (message ("exitScope: in branch: %q", usymtab_unparseStack ()));
+ /*@-branchstate@*/
+ } /*@=branchstate@*/
+ }
+
/*
** check all variables in scope were used
*/
** NOTE: note for exiting paramsScope, since checkReturn should be
** called first.
*/
-
+
if (!mustReturn && (usymtab_lexicalLevel () > functionScope))
{
/*
uentryList params = context_getParams ();
globSet globs = context_getUsedGlobs ();
-
uentryList_elements (params, ue)
{
uentry_fixupSref (ue);
clearFunctionTypes ();
-
+ DPRINTF (("Fixing up globals: %s", globSet_unparse (globs)));
+
globSet_allElements (globs, el)
{
+ DPRINTF (("Fix: %s", sRef_unparseDebug (el)));
+
if (sRef_isCvar (el))
{
uentry current;
- int index = sRef_getScopeIndex (el);
+ usymId index = sRef_getScopeIndex (el);
if (sRef_isFileStatic (el))
{
if (uentry_isVariable (current))
{
+ DPRINTF (("Fixup: %s", uentry_unparse (current)));
uentry_fixupSref (current);
}
else
{
+ DPRINTF (("Clear: %s", uentry_getSref (current)));
sRef_clearDerived (uentry_getSref (current));
}
}
+
+ sRef_clearDerived (el); /* evans 2002-03-14 - this is the likely source of many crashes! */
} end_globSet_allElements;
}
/*@i@*/ lctab->env = utab;
/*@i@*/ utab = ctab;
/*@-branchstate@*/ } /*@=branchstate@*/
-/*@-globstate@*/
+ /*@-globstate@*/
+
+
+# ifdef DEBUGSPLINT
+ usymtab_checkAllValid ();
+# endif
}
/*@=globstate@*/
** yikes! don't let the '170 kids see this one...
*/
-int
-uentry_directParamNo (uentry ue)
+usymId
+usymtab_directParamNo (uentry ue)
{
if (uentry_isVar (ue))
{
if (sRef_lexLevel (sr) == functionScope)
{
- /*@access sRef@*/ /*@-null@*/
- int index = sr->info->cvar->index;
- /*@noaccess sRef@*/ /*@=null@*/
+ usymId index = sRef_getScopeIndex (sr);
- if (index < uentryList_size (context_getParams ()))
+ if (index < usymId_fromInt (uentryList_size (context_getParams ())))
{
return index;
}
}
}
- return -1;
+ return usymId_invalid;
}
/*@dependent@*/ /*@exposed@*/ uentry
{
uentry ue;
-
ue = usymtab_getRefNoisy (u, level, index);
-
if (uentry_isUndefined (ue))
{
llbug (message ("usymtab_getRef: out of range: %d. level = %d",
index, level));
}
-
return ue;
}
llassert (index >= 0);
if (level > s->lexlevel)
- {
-
+ {
return uentry_undefined;
}
s = usymtab_dropEnv (s);
}
- if (index >= s->nentries)
+ if (index >= usymId_fromInt (s->nentries))
{
return uentry_undefined;
}
{
usymtab otab = s;
uentry ue = uentry_undefined;
-
llassert (index >= 0);
-
while (s->lexlevel > level)
{
-
if (usymtab_isBranch (s))
{
int eindex = refTable_lookup (s, level, index);
while (usymtab_isBranch (s) && s->lexlevel == level)
{
int eindex = refTable_lookup (s, level, index);
-
if (eindex != NOT_FOUND)
{
s = usymtab_dropEnv (s);
}
- if (s->lexlevel == level && (index < s->nentries))
+ if (s->lexlevel == level && (index < usymId_fromInt (s->nentries)))
{
ue = s->entries[index];
}
else
{
- }
+ }
}
-
+
return ue;
}
- if (index >= s->nentries)
+ if (index >= usymId_fromInt (s->nentries))
{
return uentry_undefined;
}
*/
static
-int refTable_lookup (/*@notnull@*/ usymtab ut, int level, int index)
+int refTable_lookup (/*@notnull@*/ usymtab ut, int level, usymId index)
{
refTable rt = ut->reftable;
int i;
llassert (rt != NULL);
-
for (i = 0; i < ut->nentries; i++)
{
- if (rt[i]->level == level && rt[i]->index == index)
+ if (rt[i]->level == level && rt[i]->index == usymId_toInt (index))
{
- return i;
+ return i;
}
}
-
- return NOT_FOUND;
+
+ return NOT_FOUND;
}
static
static /*@dependent@*/ /*@exposed@*/ uentry
usymtab_addRefEntry (/*@notnull@*/ usymtab s, cstring k)
{
- int eindex;
usymtab ut = s;
- llassert (ut->reftable != NULL);
+ if (ut->reftable == NULL)
+ {
+ DPRINTF (("Adding ref entry without reftable: %s", k));
+ return uentry_undefined;
+ }
+ llassert (ut->reftable != NULL);
+
while (s != GLOBAL_ENV)
{
- eindex = usymtab_getIndex (s, k);
+ usymId eindex = usymtab_getIndex (s, k);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry current = s->entries[eindex];
{
uentry ue;
- DPRINTF (("Here: copying %s", uentry_unparseFull (current)));
-
- ue = uentry_copy (current);
-
- DPRINTF (("Here: copying %s", uentry_unparseFull (ue)));
+ DPRINTF (("Here: copying %s", uentry_unparse (current)));
+ if (uentry_isNonLocal (current))
+ {
+ ue = uentry_copy (current);
+ }
+ else
+ {
+ ue = uentry_copyNoSave (current);
+ }
+ DPRINTF (("Here: copying %s", uentry_unparse (ue)));
usymtab_addEntryQuiet (ut, ue);
-
+ DPRINTF (("Okay..."));
+
if (s->reftable != NULL)
{
refentry ref = s->reftable[eindex];
-
ut->reftable[ut->nentries - 1]
= refentry_create (ref->level, ref->index);
else
{
ut->reftable[ut->nentries - 1]
- = refentry_create (s->lexlevel, eindex);
+ = refentry_create (s->lexlevel, usymId_toInt (eindex));
}
return (ue);
while (s != GLOBAL_ENV)
{
- int eindex = usymtab_getIndex (s, k);
+ usymId eindex = usymtab_getIndex (s, k);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry ret = s->entries[eindex];
+# if 0
+
+ if (s->kind == US_TBRANCH
+ || s->kind == US_FBRANCH
+ || s->kind == US_CBRANCH)
+ /* uentry_isGlobalVariable (ret) && os->lexlevel > fileScope) */
+ {
+ uentry ret;
+ DPRINTF (("Adding global ref entry: %s", k));
+ ret = usymtab_addRefEntry (os, k);
+ DPRINTF (("Adding ref entry: %s", uentry_unparseFull (ret)));
+ return ret;
+ }
+
+# endif
DPRINTF (("Found: %s", uentry_unparseFull (ret)));
return (ret);
}
-
+
if (s->kind == US_TBRANCH || s->kind == US_FBRANCH
|| s->kind == US_CBRANCH)
{
+ /* why isn't this os??? */
uentry ret = usymtab_addRefEntry (s, k);
- DPRINTF (("Ref entry: %s", uentry_unparseFull (ret)));
+ DPRINTF (("Adding ref entry: %s", uentry_unparseFull (ret)));
return ret;
}
}
static /*@dependent@*/ /*@exposed@*/ uentry
-usymtab_lookupQuiet (usymtab s, cstring k)
+usymtab_lookupQuietAux (usymtab s, cstring k, bool noalt)
{
- int eindex;
-
while (s != GLOBAL_ENV)
{
- eindex = usymtab_getIndex (s, k);
+ usymId eindex = usymtab_getIndex (s, k);
- if (eindex != NOT_FOUND)
+ if (usymtab_indexFound (eindex))
{
uentry ret = s->entries[eindex];
return (ret);
}
- s = s->env;
+ if (noalt && usymtab_isBranch (s))
+ {
+ s = usymtab_dropEnv (s);
+ }
+ else
+ {
+ llassert (s != NULL);
+ s = s->env;
+ }
}
return uentry_undefined;
}
+static /*@exposed@*/ /*@dependent@*/ uentry
+usymtab_lookupQuiet (usymtab s, cstring k)
+{
+ return usymtab_lookupQuietAux (s, k, FALSE);
+}
+
+static /*@exposed@*/ /*@dependent@*/ uentry
+usymtab_lookupQuietNoAlt (usymtab s, cstring k)
+{
+ return usymtab_lookupQuietAux (s, k, TRUE);
+}
+
/*@dependent@*/ /*@observer@*/ uentry
usymtab_lookupSafe (cstring k)
/*@globals utab@*/
return (usymtab_lookupAux (utab, k));
}
+/*@dependent@*/ /*@observer@*/ uentry
+ usymtab_lookupSafeScope (cstring k, int lexlevel)
+ /*@globals utab@*/
+{
+ /*
+ ** This is necessary to deal with shadowed variables that are referenced
+ ** through aliases inside the shadowed scope. It would be better if
+ ** lookup could take an sRef as a parameter.
+ */
+
+ usymtab tab = utab;
+
+ while (tab != GLOBAL_ENV && tab->lexlevel > lexlevel) {
+ uentry ret = usymtab_lookupAux (tab, k);
+
+ if (uentry_isValid (ret)) {
+ sRef sr = uentry_getSref (ret);
+
+ if (sRef_isCvar (sr) && sRef_lexLevel (sr) > lexlevel) {
+ tab = usymtab_dropEnv (tab);
+ } else {
+ return ret;
+ }
+ }
+ }
+
+ return uentry_undefined;
+}
+
uentry
usymtab_lookupExpose (cstring k)
/*@globals utab@*/
if (uentry_isPriv (ce))
llfatalbug (message ("usymtab_lookup: private: %s", k));
+ DPRINTF (("Lookup global: %s", uentry_unparseFull (ce)));
return ce;
}
/*@globals globtab@*/
{
uentry ce = usymtab_lookupAux (globtab, k);
-
+ DPRINTF (("Lookup global: %s", uentry_unparseFull (ce)));
return ce;
}
if (uentry_isUndefined (ce))
llfatalerror (message ("usymtab_lookup: not found: %s", k));
+ DPRINTF (("Lookup either: %s", uentry_unparseFull (ce)));
return ce;
}
-# ifndef NOLCL
ctype
usymtab_lookupType (cstring k)
/*@globals globtab@*/
{
- usymId uid = usymtab_getTypeId (k);
+ typeId uid = usymtab_getTypeId (k);
- if (uid == USYMIDINVALID)
+ if (typeId_isInvalid (uid))
{
llcontbug (message ("usymtab_lookupType: not found: %s", k));
return ctype_unknown;
return (uentry_getRealType (usymtab_getTypeEntry (uid)));
}
-# endif
ctype
usymtab_lookupAbstractType (cstring k) /*@globals globtab@*/
{
- usymId uid = usymtab_getTypeId (k);
+ typeId uid = usymtab_getTypeId (k);
- if (uid == USYMIDINVALID)
+ if (typeId_isInvalid (uid))
{
llcontbug (message ("usymtab_lookupType: not found: %s", k));
return ctype_unknown;
{
int i;
- if (fileloc_isSpec (g_currentloc)) return (ctype_undefined);
+ DPRINTF (("Fields: %s", uentryList_unparse (f)));
+
+ if (fileloc_isSpec (g_currentloc))
+ {
+ return (ctype_undefined);
+ }
for (i = 0; i < globtab->nentries; i++)
{
if (isFakeTag (uentry_rawName (current)))
{
ctype ct = uentry_getType (current);
+
+ DPRINTF (("Check: %s", ctype_unparse (ct)));
if ((isStruct ? ctype_isStruct (ct) : ctype_isUnion (ct))
- && (uentryList_matchFields (f, ctype_getFields (ct))))
+ &&
+ (uentry_isSpecified (current)
+ && uentryList_equivFields (f, ctype_getFields (ct))))
+ {
+ return uentry_getAbstractType (current);
+ }
+ else
{
- return uentry_getAbstractType (current);
+ ;
}
}
}
/*@globals utab@*/
{
uentry ce = usymtab_lookupSafe (k);
-
return (!(uentry_isUndefined (ce)) && !(uentry_isPriv (ce)));
}
return (!(uentry_isUndefined (ce)) && !(uentry_isPriv (ce)));
}
-# ifndef NOLCL
bool
usymtab_existsEither (cstring k)
/*@globals utab@*/
return (uentry_isValid (ce));
}
-# endif
bool
usymtab_existsType (cstring k)
usymtab_existsTypeEither (cstring k)
/*@globals globtab@*/
{
- uentry ce = usymtab_lookupAux (globtab, k);
-
- return (uentry_isValid (ce) && uentry_isDatatype (ce));
+ uentry ce;
+ ce = usymtab_lookupAux (globtab, k);
+ return (uentry_isValid (ce) && uentry_isDatatype (ce));
}
bool
{
cstring sname = makeStruct (k);
uentry ce = usymtab_lookupAux (globtab, sname);
-
- cstring_free (sname);
-
-
+ cstring_free (sname);
return (!(uentry_isUndefined (ce)) && !(uentry_isPriv (ce)));
}
return (!(uentry_isUndefined (ce)) && !(uentry_isPriv (ce)));
}
-# ifndef NOLCL
bool usymtab_existsVar (cstring k)
/*@globals utab@*/
{
return (!(uentry_isUndefined (ce)) && !(uentry_isPriv (ce)) && (uentry_isVar (ce)));
}
-# endif
/*
** destructors
{
int i;
+ DPRINTF (("Free level [%p]", u));
aliasTable_free (u->aliases);
- environmentTable_free (u->environment);
+
refTable_free (u->reftable, u->nentries);
if (u == filetab || u == globtab)
{
for (i = 0; i < u->nentries; i++)
{
+ DPRINTF (("Free complete: %d", i));
+ DPRINTF (("Uentry: %s", uentry_unparse (u->entries[i])));
uentry_freeComplete (u->entries[i]);
+ u->entries[i] = uentry_undefined;
}
}
else
for (i = 0; i < u->nentries; i++)
{
uentry_free (u->entries[i]);
+ u->entries[i] = uentry_undefined;
}
}
&& u != utab
&& u != filetab)
{
- llassert (u->htable == NULL);
- sfree (u);
+ llassert (!cstringTable_isDefined (u->htable));
}
-/*@-mustfree@*/
-} /*@=mustfree@*/
+ sfree (u); /* evans 2002-07-12: was inside if */
+}
static void
usymtab_freeAux (/*@only@*/ usymtab u)
{
dbgfree = TRUE;
usymtab_freeAux (utab);
-}
+ utab = usymtab_undefined;
+ /*@-globstate@*/
+} /*@=globstate@*/ /* Splint cannot tell that utab is killed */
static int usymtab_lexicalLevel (void) /*@globals utab@*/
{
return (utab->lexlevel == functionScope);
}
-# ifndef NOLCL
void
usymtab_replaceEntry (uentry s)
/*@globals utab, globtab@*/
{
usymtab_replaceEntryAux (utab, s);
}
-# endif
bool
-usymtab_matchForwardStruct (usymId u1, usymId u2)
+usymtab_matchForwardStruct (typeId u1, typeId u2)
/*@globals globtab@*/
{
uentry ue1 = usymtab_getTypeEntry (u1);
if (u2 == rtuid) return TRUE;
- if (usymId_isValid (rtuid))
+ if (typeId_isValid (rtuid))
{
- reptype = uentry_getType (usymtab_getTypeEntry (rtuid));
-
+ reptype = uentry_getType (usymtab_getTypeEntry (rtuid));
return (ctype_isUA (reptype) && (u2 == (ctype_typeId (reptype))));
}
}
while (tab->lexlevel >= lowlevel)
{
+ DPRINTF (("Is guarded? [%s] %s",
+ guardSet_unparse (tab->guards),
+ sRef_unparseFull (s)));
+
if (guardSet_isGuarded (tab->guards, s))
{
/*
bool usymtab_isGuarded (sRef s)
{
-
+ DPRINTF (("Is guarded? %s", sRef_unparseFull (s)));
return (sRef_aliasCompleteSimplePred (usymtab_isGuardedAux, s));
}
-bool usymtab_isProbableNull (sRef s)
+bool usymtab_isDefinitelyNull (sRef s)
{
- return (sRef_aliasCheckSimplePred (usymtab_isProbableNullAux, s));
+ return (sRef_aliasCheckSimplePred (usymtab_isDefinitelyNullAux, s));
}
-bool usymtab_isProbableDeepNull (sRef s)
+bool usymtab_isDefinitelyNullDeep (sRef s)
{
- return (sRef_deepPred (usymtab_isProbableNull, s));
+ return (sRef_deepPred (usymtab_isDefinitelyNull, s));
}
-static bool usymtab_isProbableNullAux (sRef s)
+static bool usymtab_isDefinitelyNullAux (sRef s)
/*@globals utab@*/
{
usymtab tab = utab;
while (tab->lexlevel >= lowlevel)
{
- if (guardSet_isProbableNull (tab->guards, s))
+ if (guardSet_mustBeNull (tab->guards, s))
{
return TRUE;
}
usymtab_entries (copy, ue)
{
- if (uentry_isValid (ue))
+ if (uentry_isValid (ue) && !uentry_isGlobalMarker (ue))
{
filelocList uses = uentry_getUses (ue);
int size = filelocList_realSize (uses);
&& !fileloc_isLib (uentry_whereDefined (ue))
&& (size > 0))
{
- llmsg (message ("%q (%q), %d use%p:\n %q",
+ llmsg (message ("%q (%q), %d use%&:\n %q",
uentry_getName (ue),
fileloc_unparse (uentry_whereDefined (ue)),
size, filelocList_unparseUses (uses)));
BADEXIT;
}
-void usymtab_testInRange (sRef s, int index) /*@globals utab;@*/
-{
- /*@i22*/
- /*@-globs*/
- environmentTable_testInRange (utab->environment, s, index);
- /*@=globs*/
-}
-void usymtab_postopVar (sRef sr) /*@globals utab;@*/
-{
- environmentTable_postOpvar (utab->environment, sr);
-
-}
-/* doesn't do much check here assumes checking is done before call*/
-void usymtab_addExactValue(sRef s1, int val)
-{
- /*@i22@*/ utab->environment = environmentTable_addExactValue (utab->environment, s1, val);
-}
-
-void usymtab_addMustAlias (sRef s, sRef al)
+void usymtab_addMustAlias (/*@exposed@*/ sRef s, /*@exposed@*/ sRef al)
/*@modifies utab@*/
{
- if (sRef_isMeaningful (s) && sRef_isMeaningful (al)
- && !(sRef_isConst (s) || sRef_isConst (al))
- && !(sRef_isAddress (al) && sRef_isDirectParam (sRef_getBase (al)))
- && !(sRef_similar (s, al)))
- {
- utab->aliases = aliasTable_addMustAlias (utab->aliases, s, al);
- DPRINTF (("Must alias: %s", aliasTable_unparse (utab->aliases)));
-
- /*
- ** for local variable, aliasing is symmetric
- */
-
- if (sRef_isLocalVar (s) && sRef_isLocalVar (al))
- {
- utab->aliases = aliasTable_addMustAlias (utab->aliases, al, s);
- }
- }
- else
+ if (!sRef_similar (s, al))
{
- ;
+ usymtab_addForceMustAlias (s, al);
}
}
** Same as usymtab_addMustAlias, except does not check sRef_isSimilar.
*/
-void usymtab_addForceMustAlias (sRef s, sRef al)
+void usymtab_addForceMustAlias (/*@exposed@*/ sRef s, /*@exposed@*/ sRef al)
/*@modifies utab@*/
{
+ /* evans 2002-03-3: was sRef_isMeaningful -- but we need to keep aliases for new storage also! */
if (sRef_isMeaningful (s)
&& sRef_isMeaningful (al)
&& !(sRef_isConst (s) || sRef_isConst (al))
}
else
{
- ;
+ DPRINTF (("Not aliasing! %s / %s", sRef_unparseFull (s), sRef_unparseFull (al)));
+ DPRINTF (("meaningful: %d %d", sRef_isMeaningful (s), sRef_isMeaningful (al)));
}
}
+void usymtab_addReallyForceMustAlias (/*@exposed@*/ sRef s, /*@exposed@*/ sRef al)
+ /*@modifies utab@*/
+{
+ utab->aliases = aliasTable_addMustAlias (utab->aliases, s, al);
+}
+
void usymtab_clearAlias (sRef s)
/*@modifies utab, s@*/
{
sRefSet usymtab_allAliases (sRef s)
/*@globals utab@*/
{
- if (sRef_isMeaningful (s))
+ if (sRef_isSomewhatMeaningful (s))
{
sRefSet ret;
-
ret = sRefSet_unionFree (aliasTable_aliasedBy (utab->aliases, s),
aliasTable_canAlias (utab->aliases, s));
- return (ret);
+ return (ret);
}
else
{
+ DPRINTF (("NOT A MEANINGFUL SREF!"));
return sRefSet_undefined;
}
}
/*@only@*/ sRefSet usymtab_canAlias (sRef s)
- /*@globals utab@*/
+ /*@globals utab@*/
{
- if (sRef_isMeaningful (s))
+ if (sRef_isSomewhatMeaningful (s))
{
sRefSet res = aliasTable_canAlias (utab->aliases, s);
-
return res;
}
-
+
return sRefSet_undefined;
}
/*@only@*/ sRefSet usymtab_aliasedBy (sRef s)
- /*@globals utab@*/
+ /*@globals utab@*/
{
return (aliasTable_aliasedBy (utab->aliases, s));
}
int depth = 0;
char *ind = mstring_copy (" ");
- fprintf (g_msgstream, "<<< [symbol table] >>>\n");
+ fprintf (g_warningstream, "<<< [symbol table] >>>\n");
while (s != GLOBAL_ENV && s->env != GLOBAL_ENV)
{
ind[depth * 3 + 1] = '\0';
}
- fprintf (g_msgstream, "level: %d (%s)\n", s->lexlevel,
+ fprintf (g_warningstream, "level: %d (%s)\n", s->lexlevel,
cstring_toCharsSafe (tname));
cstring_free (tname);
for (i = 0; i < s->nentries; i++)
{
cstring us = uentry_unparseFull (s->entries[i]);
- fprintf (g_msgstream, "%s\n", cstring_toCharsSafe (us));
+ fprintf (g_warningstream, "%s\n", cstring_toCharsSafe (us));
cstring_free (us);
}
if (s->reftable != NULL && s->nentries > 0)
{
- fprintf (g_msgstream, "\t<< Ref table >>\n");
+ fprintf (g_warningstream, "\t<< Ref table >>\n");
for (i = 0; i < s->nentries; i++)
{
- fprintf (g_msgstream, "\t%s %3d: %d, %d\n", ind, i,
+ fprintf (g_warningstream, "\t%s %3d: %d, %d\n", ind, i,
s->reftable[i]->level,
s->reftable[i]->index);
}
depth++;
s = s->env;
}
- fprintf (g_msgstream, "<<< end usymtab >>>\n");
+ fprintf (g_warningstream, "<<< end usymtab >>>\n");
mstring_free (ind);
return;
}
static void
usymtab_printAllAux (usymtab s)
- /*@modifies g_msgstream@*/
+ /*@modifies g_warningstream@*/
{
int i;
int depth = 0;
for (i = looplow; i < s->nentries; i++)
{
printf ("%s%3d %s\n", ind, i,
- cstring_toCharsSafe (uentry_unparse (s->entries[i])));
+ cstring_toCharsSafe (uentry_unparseFull (s->entries[i])));
}
}
else
for (i = 0; i < s->nentries; i++)
{
printf ("%s%3d %s\n", ind, i,
- cstring_toCharsSafe (uentry_unparse (s->entries[i])));
+ cstring_toCharsSafe (uentry_unparseFull (s->entries[i])));
}
}
mstring_free (ind);
}
+# ifdef S_SPLINT_S
static /*@only@*/ cstring /*@unused@*/
usymtab_unparseLocalAux (/*@notnull@*/ usymtab s)
{
return (c);
}
+# endif
void
usymtab_printLocal (void)
static bool checkDistinctExternalName (uentry e)
/*@globals globtab@*/
- /*@modifies *g_msgstream@*/
+ /*@modifies *g_warningstream@*/
{
- int checklen = context_getValue (FLG_EXTERNALNAMELEN);
+ size_t checklen = size_fromInt (context_getValue (FLG_EXTERNALNAMELEN));
bool ignorecase = context_getFlag (FLG_EXTERNALNAMECASEINSENSITIVE);
bool gotone = FALSE;
bool extras = FALSE;
"in the first %d characters (%q)",
uentry_getName (e),
uentry_getName (oe),
- checklen,
+ size_toInt (checklen),
cstring_clip (uentry_getName (e), checklen)),
/*@=sefparams@*/
uentry_whereLast (e)))
"is ignored",
uentry_getName (e),
uentry_getName (oe),
- checklen),
+ size_toInt (checklen)),
uentry_whereLast (e)))
{
uentry_showWhereAny (oe);
"in the first %d characters (%q)",
uentry_getName (e),
uentry_getName (oe),
- checklen,
+ size_toInt (checklen),
cstring_clip (uentry_getName (e), checklen)),
/*@=sefparams@*/
uentry_whereLast (e)))
static bool checkDistinctInternalName (uentry e)
/*@globals utab@*/
- /*@modifies *g_msgstream@*/
+ /*@modifies *g_warningstream@*/
{
usymtab ttab = utab;
cstring name = uentry_rawName (e);
- int numchars = context_getValue (FLG_INTERNALNAMELEN);
+ size_t numchars = size_fromInt (context_getValue (FLG_INTERNALNAMELEN));
bool caseinsensitive = context_getFlag (FLG_INTERNALNAMECASEINSENSITIVE);
bool lookalike = context_getFlag (FLG_INTERNALNAMELOOKALIKE);
"in the first %d characters (%q)",
uentry_getName (e),
uentry_getName (oe),
- numchars,
+ size_toInt (numchars),
cstring_clip (uentry_getName (e), numchars)),
/*@=sefparams@*/
uentry_whereLast (e)))
/*@switchbreak@*/
break;
case CGE_CASE:
- if (numchars == 0
- || (cstring_length (name) <= numchars))
+ if (numchars == 0 || (cstring_length (name) <= numchars))
{
if (optgenerror
(FLG_DISTINCTINTERNALNAMES,
"in the first %d characters without case sensitivity",
uentry_getName (e),
uentry_getName (oe),
- numchars),
+ size_toInt (numchars)),
uentry_whereLast (e)))
{
uentry_showWhereAny (oe);
"in the first %d characters except by lookalike characters",
uentry_getName (e),
uentry_getName (oe),
- numchars),
+ size_toInt (numchars)),
uentry_whereLast (e)))
{
uentry_showWhereAny (oe);
if (hasError)
{
- uentry_setHasNameError (e);
+ uentry_setHasNameError (e);
}
}
+/*@exposed@*/ sRef usymtab_lookupGlobalMarker (void) /*@globals utab@*/
+{
+ uentry ue;
+
+ ue = usymtab_lookupAux (utab, GLOBAL_MARKER_NAME);
+ llassert (uentry_isValid (ue));
+
+ return uentry_getSref (ue);
+}
+
+
+# ifdef DEBUGSPLINT
+/*
+** For debugging only
+*/
+
+void
+usymtab_checkAllValid () /*@globals utab@*/
+{
+ usymtab tab = utab;
+
+ while (tab != GLOBAL_ENV)
+ {
+ int i;
+
+ for (i = 0; i < utab->nentries; i++)
+ {
+ uentry e = utab->entries[i];
+
+ uentry_checkValid (e);
+ }
+
+ aliasTable_checkValid (tab->aliases);
+ tab = tab->env;
+ }
+}
+# endif
+
+
+
+
+
+
andersk / splint.git / blobdiff