** 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 information on splint: splint@cs.virginia.edu
+** To report a bug: splint-bug@cs.virginia.edu
** For more information: http://www.splint.org
*/
/*
* or, if not set "." will be used.
*/
-# include "lclintMacros.nf"
+# include "splintMacros.nf"
# include "llbasic.h"
# ifndef NOLCL
{
context_setFlag (code, FALSE);
}
- } end_allFlagCodes;
-
- }
+ } end_allFlagCodes;
+}
/*
** resetAllFlags
void
context_resetAllFlags (void)
{
+ DPRINTF (("******** Reset all flags"));
+
allFlagCodes (code)
{
gc.flags[code] = FALSE;
- if (flagcode_hasValue (code))
+ if (flagcode_hasNumber (code))
{
int val = 0;
case FLG_INDENTSPACES:
val = DEFAULT_INDENTSPACES; break;
case FLG_EXTERNALNAMELEN:
- val = DEFAULT_EXTERNALNAMELEN; break;
+ val = ISO99_EXTERNALNAMELEN; break;
case FLG_INTERNALNAMELEN:
- val = DEFAULT_INTERNALNAMELEN; break;
+ val = ISO99_INTERNALNAMELEN; break;
case FLG_COMMENTCHAR:
val = (int) DEFAULT_COMMENTCHAR; break;
case FLG_CONTROLNESTDEPTH:
- val = (int) DEFAULT_CONTROLNESTDEPTH; break;
+ val = (int) ISO99_CONTROLNESTDEPTH; break;
case FLG_STRINGLITERALLEN:
- val = (int) DEFAULT_STRINGLITERALLEN; break;
+ val = (int) ISO99_STRINGLITERALLEN; break;
case FLG_INCLUDENEST:
- val = (int) DEFAULT_INCLUDENEST; break;
+ val = (int) ISO99_INCLUDENEST; break;
case FLG_NUMSTRUCTFIELDS:
- val = (int) DEFAULT_NUMSTRUCTFIELDS; break;
+ val = (int) ISO99_NUMSTRUCTFIELDS; break;
case FLG_NUMENUMMEMBERS:
- val = (int) DEFAULT_NUMENUMMEMBERS; break;
+ val = (int) ISO99_NUMENUMMEMBERS; break;
case FLG_EXPECT:
case FLG_LCLEXPECT:
break;
}
/*@=loopswitchbreak@*/
+ DPRINTF (("Set value: [%s] / %d", flagcode_unparse (code), val));
context_setValue (code, val);
+ DPRINTF (("Set value: [%s] / %d", flagcode_unparse (code), context_getValue (code)));
+ llassert (context_getValue (code) == val);
+ }
+ else if (flagcode_hasChar (code))
+ {
+ llassert (code == FLG_COMMENTCHAR);
+ context_setCommentMarkerChar (DEFAULT_COMMENTCHAR);
}
else if (flagcode_hasString (code))
{
/*@i34 move this into flags.def */
+ gc.flags[FLG_OBVIOUSLOOPEXEC] = TRUE;
gc.flags[FLG_MODIFIES] = TRUE;
gc.flags[FLG_NESTCOMMENT] = TRUE;
gc.flags[FLG_GLOBALS] = TRUE;
gc.flags[FLG_TYPE] = TRUE;
gc.flags[FLG_INCOMPLETETYPE] = TRUE;
gc.flags[FLG_ABSTRACT] = TRUE;
- gc.flags[FLG_ITER] = TRUE;
- gc.flags[FLG_CONTROL] = TRUE;
+ gc.flags[FLG_ITERBALANCE] = TRUE;
+ gc.flags[FLG_ITERYIELD] = TRUE;
+ gc.flags[FLG_DUPLICATECASES] = TRUE;
+ gc.flags[FLG_ALWAYSEXITS] = TRUE;
+ gc.flags[FLG_EMPTYRETURN] = TRUE;
+ gc.flags[FLG_MACRORETURN] = TRUE;
gc.flags[FLG_UNRECOG] = TRUE;
gc.flags[FLG_SYSTEMUNRECOG] = TRUE;
gc.flags[FLG_LINTCOMMENTS] = TRUE;
gc.flags[FLG_GNUEXTENSIONS] = TRUE;
+ /*
+ Changed for 3.0.0.19
+ */
+ gc.flags[FLG_ORCONSTRAINT] = TRUE;
+ gc.flags[FLG_CONSTRAINTLOCATION] = TRUE;
/*
** On by default for Win32, but not Unix (to support MS/VC++ error message format).
*/
flagcode_unparse (modeflags[i]))); } \
else { context_setFlag (modeflags[i], TRUE); } i++; }}
+static void context_setModeAux (cstring p_s, bool p_warn) ;
+
void
context_setMode (cstring s)
+{
+ context_setModeAux (s, TRUE);
+}
+
+void
+context_setModeNoWarn (cstring s)
+{
+ context_setModeAux (s, FALSE);
+}
+
+void
+context_setModeAux (cstring s, bool warn)
{
intSet setflags = intSet_new ();
}
} end_intSet_elements ;
- voptgenerror (FLG_WARNFLAGS,
- message ("Setting mode %s after setting mode flags will "
- "override set values of flags: %s",
- s, rflags),
- g_currentloc);
+ if (warn)
+ {
+ voptgenerror (FLG_WARNFLAGS,
+ message ("Setting mode %s after setting mode flags will "
+ "override set values of flags: %s",
+ s, rflags),
+ g_currentloc);
+ }
cstring_free (rflags);
}
FLG_EXPORTLOCAL,
FLG_USERELEASED, FLG_ALIASUNIQUE, FLG_MAYALIASUNIQUE,
- FLG_MUSTFREE, FLG_MUSTDEFINE, FLG_GLOBSTATE,
+ FLG_MUSTFREEONLY,
+ FLG_MUSTFREEFRESH,
+ FLG_MUSTDEFINE, FLG_GLOBSTATE,
FLG_COMPDESTROY, FLG_MUSTNOTALIAS,
FLG_MEMIMPLICIT,
FLG_BRANCHSTATE,
FLG_MODGLOBS, FLG_WARNLINTCOMMENTS,
FLG_IFEMPTY, FLG_REALCOMPARE,
FLG_BOOLOPS, FLG_PTRNEGATE,
- FLG_SHIFTSIGNED,
+ FLG_SHIFTNEGATIVE,
+ FLG_SHIFTIMPLEMENTATION,
FLG_BUFFEROVERFLOWHIGH,
FLG_BUFFEROVERFLOW,
INVALID_FLAG
FLG_UNREACHABLE,
FLG_NORETURN, FLG_CASEBREAK, FLG_MISSCASE,
FLG_EVALORDER, FLG_USEDEF,
-
FLG_NESTEDEXTERN,
/* warn use flags */
FLG_IMMEDIATETRANS,
FLG_ONLYUNQGLOBALTRANS,
FLG_USERELEASED, FLG_ALIASUNIQUE, FLG_MAYALIASUNIQUE,
- FLG_MUSTFREE, FLG_MUSTDEFINE, FLG_GLOBSTATE,
+ FLG_MUSTFREEONLY,
+ FLG_MUSTFREEFRESH,
+ FLG_MUSTDEFINE, FLG_GLOBSTATE,
FLG_COMPDESTROY, FLG_MUSTNOTALIAS,
FLG_MEMIMPLICIT,
FLG_BRANCHSTATE,
FLG_MACROMATCHNAME, FLG_WARNLINTCOMMENTS,
FLG_INCLUDENEST, FLG_ANSIRESERVED, FLG_CPPNAMES,
FLG_NOPARAMS, FLG_IFEMPTY, FLG_WHILEEMPTY, FLG_REALCOMPARE,
- FLG_BOOLOPS, FLG_SHIFTSIGNED,
+ FLG_BOOLOPS, FLG_SHIFTNEGATIVE,
+ FLG_SHIFTIMPLEMENTATION,
FLG_BUFFEROVERFLOWHIGH, FLG_BUFFEROVERFLOW,
INVALID_FLAG } ;
FLG_UNKNOWNINITTRANS,
FLG_USERELEASED, FLG_ALIASUNIQUE, FLG_MAYALIASUNIQUE,
- FLG_MUSTFREE, FLG_MUSTDEFINE, FLG_GLOBSTATE,
+ FLG_MUSTFREEONLY,
+ FLG_MUSTFREEFRESH,
+ FLG_MUSTDEFINE, FLG_GLOBSTATE,
FLG_COMPDESTROY, FLG_MUSTNOTALIAS,
FLG_MEMIMPLICIT,
FLG_BRANCHSTATE,
FLG_REALCOMPARE, FLG_BOOLOPS,
FLG_SYSTEMDIRERRORS, FLG_UNUSEDSPECIAL,
- FLG_SHIFTSIGNED, FLG_BITWISEOPS,
+ FLG_SHIFTNEGATIVE,
+ FLG_SHIFTIMPLEMENTATION,
+ FLG_BITWISEOPS,
FLG_BUFFEROVERFLOWHIGH, FLG_BUFFEROVERFLOW,
INVALID_FLAG
} ;
context_setJustPopped ();
- if (context_getFlag (FLG_LOOPEXEC))
+ if (context_getFlag (FLG_ITERLOOPEXEC))
{
usymtab_popTrueExecBranch (exprNode_undefined, body, ITERCLAUSE);
}
** predicate must be false after while loop (unless there are breaks)
*/
- if (context_getFlag (FLG_LOOPEXEC))
+ if (context_getFlag (FLG_WHILELOOPEXEC))
{
usymtab_popTrueExecBranch (pred, body, WHILECLAUSE);
}
llassert (gc.inclause == FORCLAUSE);
context_setJustPopped ();
+ DPRINTF (("Exit for: %s / %s", exprNode_unparse (forPred), exprNode_unparse (body)));
+
/*
- ** predicate must be false after while loop (unless there are breaks)
+ ** Predicate must be false after for loop (unless there are breaks)
*/
- if (context_getFlag (FLG_LOOPEXEC))
+ if (context_getFlag (FLG_FORLOOPEXEC))
{
+ DPRINTF (("Here: for loop exec"));
usymtab_popTrueExecBranch (forPred, body, FORCLAUSE);
}
else
{
- usymtab_popTrueBranch (forPred, body, FORCLAUSE);
+ if (context_getFlag (FLG_OBVIOUSLOOPEXEC)
+ && exprNode_loopMustExec (forPred))
+ {
+ DPRINTF (("Here: loop must exec"));
+ usymtab_popTrueExecBranch (forPred, body, FORCLAUSE);
+ }
+ else
+ {
+ DPRINTF (("Pop true branch:"));
+ usymtab_popTrueBranch (forPred, body, FORCLAUSE);
+ }
}
usymtab_addGuards (invGuards);
case FLG_INDENTSPACES:
if (val < 0)
{
-
llerror_flagWarning (message ("Value for %s must be a non-negative "
- "number (given %d)",
- flagcode_unparse (flag), val));
+ "number (given %d)",
+ flagcode_unparse (flag), val));
return;
}
default:
break;
}
-
+
+ DPRINTF (("Set value [%s] %d = %d", flagcode_unparse (flag), index, val));
gc.values[index] = val;
}
int index = flagcode_valueIndex (flag);
llassert (index >= 0 && index <= NUMVALUEFLAGS);
+ DPRINTF (("Get value [%s] %d = %d", flagcode_unparse (flag), index, gc.values[index]));
return (gc.values[index]);
}
{
gc.setGlobally[code] = FALSE;
gc.setLocally[code] = FALSE;
- } end_allFlagCodes ;
-
+ }
+ end_allFlagCodes ;
+
usymtab_initMod ();
context_resetAllFlags ();
+
assertSet (gc.flags); /* Can't use global in defines */
assertSet (gc.saveflags);
assertSet (gc.values);
assertSet (gc.strings);
-
+
conext_resetAllCounters ();
assertSet (gc.counters);
gc.flags[ff] = b; } while (FALSE)
static void
- context_setFlagAux (flagcode f, bool b, bool
- inFile, /*@unused@*/ bool isRestore)
+context_setFlagAux (flagcode f, bool b, bool inFile,
+ /*@unused@*/ bool isRestore)
{
- DPRINTF (("set flag: %s / %s", flagcode_unparse (f), bool_unparse (b)));
+ DPRINTF (("Set flag: %s / %s", flagcode_unparse (f), bool_unparse (b)));
if (f == FLG_USESTDERR)
{
DOSET (FLG_SPECRETIMPONLY, b);
DOSET (FLG_SPECSTRUCTIMPONLY, b);
break;
- case FLG_ANSILIMITS:
- DOSET (FLG_ANSILIMITS, b);
+ case FLG_ANSI89LIMITS:
+ DOSET (FLG_ANSI89LIMITS, b);
+ DOSET (FLG_CONTROLNESTDEPTH, b);
+ DOSET (FLG_STRINGLITERALLEN, b);
+ DOSET (FLG_INCLUDENEST, b);
+ DOSET (FLG_NUMSTRUCTFIELDS, b);
+ DOSET (FLG_NUMENUMMEMBERS, b);
+
+ if (b)
+ {
+ context_setValue (FLG_CONTROLNESTDEPTH, ANSI89_CONTROLNESTDEPTH);
+ context_setValue (FLG_STRINGLITERALLEN, ANSI89_STRINGLITERALLEN);
+ context_setValue (FLG_INCLUDENEST, ANSI89_INCLUDENEST);
+ context_setValue (FLG_NUMSTRUCTFIELDS, ANSI89_NUMSTRUCTFIELDS);
+ context_setValue (FLG_NUMENUMMEMBERS, ANSI89_NUMENUMMEMBERS);
+ context_setValue (FLG_EXTERNALNAMELEN, ANSI89_EXTERNALNAMELEN);
+ context_setValue (FLG_INTERNALNAMELEN, ANSI89_INTERNALNAMELEN);
+ }
+ break;
+ case FLG_ISO99LIMITS:
+ DOSET (FLG_ISO99LIMITS, b);
DOSET (FLG_CONTROLNESTDEPTH, b);
DOSET (FLG_STRINGLITERALLEN, b);
DOSET (FLG_INCLUDENEST, b);
if (b)
{
- context_setValue (FLG_CONTROLNESTDEPTH, DEFAULT_CONTROLNESTDEPTH);
- context_setValue (FLG_STRINGLITERALLEN, DEFAULT_STRINGLITERALLEN);
- context_setValue (FLG_INCLUDENEST, DEFAULT_INCLUDENEST);
- context_setValue (FLG_NUMSTRUCTFIELDS, DEFAULT_NUMSTRUCTFIELDS);
- context_setValue (FLG_NUMENUMMEMBERS, DEFAULT_NUMENUMMEMBERS);
+ context_setValue (FLG_CONTROLNESTDEPTH, ISO99_CONTROLNESTDEPTH);
+ context_setValue (FLG_STRINGLITERALLEN, ISO99_STRINGLITERALLEN);
+ context_setValue (FLG_INCLUDENEST, ISO99_INCLUDENEST);
+ context_setValue (FLG_NUMSTRUCTFIELDS, ISO99_NUMSTRUCTFIELDS);
+ context_setValue (FLG_NUMENUMMEMBERS, ISO99_NUMENUMMEMBERS);
+ context_setValue (FLG_EXTERNALNAMELEN, ISO99_EXTERNALNAMELEN);
+ context_setValue (FLG_INTERNALNAMELEN, ISO99_INTERNALNAMELEN);
}
break;
case FLG_EXTERNALNAMELEN:
DOSET (FLG_LOOPLOOPCONTINUE, b);
DOSET (FLG_DEEPBREAK, b);
break;
+ case FLG_LOOPEXEC:
+ DOSET (FLG_FORLOOPEXEC, b);
+ DOSET (FLG_WHILELOOPEXEC, b);
+ DOSET (FLG_ITERLOOPEXEC, b);
+ break;
case FLG_ACCESSALL:
DOSET (FLG_ACCESSMODULE, b);
DOSET (FLG_ACCESSFILE, b);
DOSET (FLG_FCNMACROS, b);
DOSET (FLG_CONSTMACROS, b);
break;
+ case FLG_BOUNDS:
+ DOSET (FLG_BOUNDSREAD, b);
+ DOSET (FLG_BOUNDSWRITE, b);
+ break;
case FLG_CZECH:
if (b) { DOSET (FLG_ACCESSCZECH, b); }
DOSET (FLG_CZECHFUNCTIONS, b);
DOSET (FLG_NULLPASS, b);
DOSET (FLG_NULLRET, b);
break;
+ case FLG_MUSTFREE:
+ DOSET (FLG_MUSTFREEONLY, b);
+ DOSET (FLG_MUSTFREEFRESH, b);
+ break;
case FLG_MEMCHECKS:
DOSET (FLG_NULLSTATE, b);
DOSET (FLG_NULLDEREF, b);
DOSET (FLG_USERELEASED, b);
DOSET (FLG_ALIASUNIQUE, b);
DOSET (FLG_MAYALIASUNIQUE, b);
- DOSET (FLG_MUSTFREE, b);
+ DOSET (FLG_MUSTFREEONLY, b);
+ DOSET (FLG_MUSTFREEFRESH, b);
DOSET (FLG_MUSTDEFINE, b);
DOSET (FLG_GLOBSTATE, b);
DOSET (FLG_COMPDESTROY, b);
+/*drl 12/30/01 these are some ugly functions that were added to facilitate struct annotations */
+
+
+/*drl added */
+static ctype lastStruct;
+
+ctype context_setLastStruct (/*@returned@*/ ctype s) /*@globals lastStruct@*/
+{
+ lastStruct = s;
+ return s;
+}
+
+ctype context_getLastStruct (/*@returned@*/ /*ctype s*/) /*@globals lastStruct@*/
+{
+ return lastStruct;
+}
+
+
+/*@unused@*/ static int sInfoNum = 0;
+
+
+struct getUe {
+ /*@unused@*/ uentry ue;
+ /*@unused@*/ sRef s;
+};
+
+struct sInfo {
+ /*@unused@*/ ctype ct;
+ /*@unused@*/ constraintList inv;
+ /*@unused@*/ int ngetUe;
+ /*@unused@*/ struct getUe * t ;
+};
+
+
+static struct sInfo globalStructInfo;
+
+
+/*drl 1/6/2001: I didn't think these functions were solid enough to include in the
+ stable release of splint. I coomented them out so that they won't break anything
+ but didn't delete them because they will be fixed and included later
+*/
+
+/*
+void setGlobalStructInfo(ctype ct, constraintList list)
+{
+ int i;
+ uentryList f;
+
+ f = ctype_getFields (ct);
+
+ if (constraintList_isDefined(list) )
+ {
+ globalStructInfo.ct = ct;
+ globalStructInfo.inv = list;
+
+ globalStructInfo.ngetUe = 0;
+
+ / *abstraction violation fix it * /
+ globalStructInfo.t = dmalloc(f->nelements * sizeof(struct getUe) );
+
+ globalStructInfo.ngetUe = f->nelements;
+
+ i = 0;
+
+ uentryList_elements(f, ue)
+ {
+ globalStructInfo.t[i].ue = ue;
+ globalStructInfo.t[i].s = uentry_getSref(ue);
+ TPRINTF(( message(" setGlobalStructInfo:: adding ue=%s and sRef=%s",
+ uentry_unparse(ue), sRef_unparse( uentry_getSref(ue) )
+ )
+ ));
+ i++;
+ }
+ end_uentryList_elements;
+ }
+}
+
+*/
+
+bool hasInvariants (ctype ct) /*@*/
+{
+ if ( ctype_sameName(globalStructInfo.ct, ct) )
+
+ return TRUE;
+
+ else
+
+ return FALSE;
+
+}
+
+/*drl 1/6/2001: I didn't think these functions were solid enough to include in the
+ stable release of splint. I coomented them out so that they won't break anything
+ but didn't delete them because they will be fixed and included later
+*/
+
+/*
+constraintList getInvariants (ctype ct)
+{
+
+ llassert(hasInvariants(ct) );
+
+ return globalStructInfo.inv;
+}
+*/
+
+/*
+static int getSref (ctype ct, sRef s)
+{
+ int i;
+
+ i = 0;
+
+ / *
+ DEBUGGIN INFO
+
+ fprintf(stderr, "getSref: ct = %s (%x)\n", ctype_unparse(ct), ct );
+
+ fprintf(stderr,"getSref: s = (%s) %X \n", sRef_unparse(s), s);
+ * /
+
+ while (i < globalStructInfo.ngetUe)
+ {
+ DPRINTF(( message(" getSref:: comparing ue=%s and sRef=%s",
+ uentry_unparse(globalStructInfo.t[i].ue),
+ sRef_unparse(globalStructInfo.t[i].s)
+ )
+ ));
+
+ / *
+ fprintf (stderr, " globalStructInfo.t[i].s = %x\n ",
+ globalStructInfo.t[i].s );
+ * /
+
+ if (sRef_same(globalStructInfo.t[i].s,s) )
+ return i;
+
+ i++;
+ }
+ return -1;
+}
+
+
+sRef fixSref (ctype ct, sRef base, sRef fix)
+{
+ int index;
+ uentry ue;
+ cstring name;
+ index = getSref(ct, fix);
+
+ if (index < 0)
+ return fix;
+
+ ue = globalStructInfo.t[index].ue;
+ name = uentry_getName(ue);
+ fix = sRef_buildField(base, name );
+ cstring_free(name);
+ return fix;
+}
+
+*/
andersk / splint.git / blobdiff