/*
-** 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
*/
/*
** abstract.c
** Massachusetts Institute of Technology
*/
-# include "lclintMacros.nf"
+# include "splintMacros.nf"
# include "llbasic.h"
# include "lslparse.h"
# include "llgrammar.h" /* need simpleOp, MULOP and logicalOp in makeInfixTermNode */
g_currentImports = lsymbolSet_new (); /* equal_symbol; */
(void) lsymbolSet_insert (g_currentImports,
- lsymbol_fromChars (cstring_toCharsSafe (current)));
+ lsymbol_fromString (current));
}
void
ti->modifiable = FALSE;
ti->abstract = FALSE;
ti->export = FALSE; /* this is implicit, not exported */
- ti->basedOn = sort_float;
+ ti->basedOn = g_sortFloat;
symtable_enterType (g_symtab, ti);
}
ti->modifiable = FALSE;
ti->abstract = TRUE;
- ti->basedOn = sort_bool;
- ti->export = FALSE; /* this wasn't set (detected by lclint) */
+ ti->basedOn = g_sortBool;
+ ti->export = FALSE; /* this wasn't set (detected by Splint) */
symtable_enterType (g_symtab, ti);
/* do "constant bool FALSE = false;" */
vi->id = ltoken_createType (simpleId, SID_VAR, lsymbol_fromChars ("FALSE"));
vi->kind = VRK_CONST;
- vi->sort = sort_bool;
+ vi->sort = g_sortBool;
vi->export = TRUE;
(void) symtable_enterVar (g_symtab, vi);
s = sort_makeImmutable (ltoken_undefined, lsymbol_bool);
range = ltoken_create (simpleId, lsymbol_bool);
- sign = makesigNode (ltoken_undefined, ltokenList_new (), range);
+ sign = makesigNode (ltoken_undefined, ltokenList_new (), range);
nn1 = (nameNode) dmalloc (sizeof (*nn1));
nn1->isOpId = TRUE;
privateNode e = (privateNode) dmalloc (sizeof (*e));
/*
- ** bug detected by lclint enum checking
+ ** bug detected by enum checking
** e->kind = XPK_FCN;
*/
sn = sort_lookup (s);
- if (sn.kind == SRT_PTR)
+ if (sn->kind == SRT_PTR)
{
char *lit = lsymbol_toChars (ltoken_getText (t->literal));
{
errtok = termNode_errorToken (term);
- /* errorShowPoint (tsource_thisLine (lclsource), ltoken_getCol (errtok)); */
+ /* errorShowPoint (inputStream_thisLine (lclsource), ltoken_getCol (errtok)); */
/* sprintf (ERRMSG, "expect `%s' type but given term has `%s' type",
sort_unparse (s), sort_unparse (termsort)); */
static cstring extractQuote (/*@only@*/ cstring s)
{
- int len = cstring_length (s);
+ size_t len = cstring_length (s);
char *sc = cstring_toCharsSafe (s);
cstring t;
imp->kind = IMPQUOTE;
- ltoken_setRawText (t, lsymbol_fromChars (cstring_toCharsSafe (q)));
+ ltoken_setRawText (t, lsymbol_fromString (q));
imp->val = t;
r->isCType = FALSE;
r->typename = tn;
r->content.renamesortname.name = nn;
- r->content.renamesortname.signature = (sigNode)NULL;
+ r->content.renamesortname.signature = (sigNode) NULL;
return (r);
}
makesigNode (ltoken t, /*@only@*/ ltokenList domain, ltoken range)
{
sigNode s = (sigNode) dmalloc (sizeof (*s));
- unsigned int key;
+ unsigned long int key;
/*
** Assign a hash key here to speed up lookup of operators.
} end_ltokenList_elements;
s->key = key;
- return (s);
+ return (s);
}
cstring sigNode_unparse (/*@null@*/ sigNode n)
return cstring_undefined;
}
-static unsigned int
- opFormNode2key (opFormNode op, opFormKind k)
+static unsigned long opFormNode2key (opFormNode op, opFormKind k)
{
- unsigned int key;
+ unsigned long int key;
switch (k)
{
ltoken close)
{
opFormNode n = (opFormNode) dmalloc (sizeof (*n));
- unsigned int key = 0;
+ unsigned long int key = 0;
/*
** Assign a hash key here to speed up lookup of operators.
n->tok = t;
n->close = close;
n->kind = k;
-
switch (k)
{
}
}
n->key = key;
- return (n);
+ return (n);
}
static cstring printMiddle (int j)
lclTypeSpecNode n = (lclTypeSpecNode) dmalloc (sizeof (*n));
n->kind = LTS_CONJ;
- n->pointers = 0;
+ n->pointers = pointers_undefined;
n->quals = qualList_new ();
n->content.conj = (lclconj) dmalloc (sizeof (*n->content.conj));
n->content.conj->a = a;
lclTypeSpecNode n = (lclTypeSpecNode) dmalloc (sizeof (*n));
n->kind = LTS_TYPE;
- n->pointers = 0;
+ n->pointers = pointers_undefined;
n->content.type = x;
n->quals = qualList_new ();
return (n);
lclTypeSpecNode n = (lclTypeSpecNode) dmalloc (sizeof (*n));
n->kind = LTS_STRUCTUNION;
- n->pointers = 0;
+ n->pointers = pointers_undefined;
n->content.structorunion = x;
n->quals = qualList_new ();
return (n);
n->quals = qualList_new ();
n->kind = LTS_ENUM;
- n->pointers = 0;
+ n->pointers = pointers_undefined;
n->content.enumspec = x;
return (n);
}
fcnNode_fromDeclarator (/*@only@*/ /*@null@*/ lclTypeSpecNode t,
/*@only@*/ declaratorNode d)
{
- return (makeFcnNode (QU_UNKNOWN, t, d,
- varDeclarationNodeList_new (),
- varDeclarationNodeList_new (),
- letDeclNodeList_new (),
+ return (makeFcnNode (qual_createUnknown (), t, d,
+ varDeclarationNodeList_new (),
+ varDeclarationNodeList_new (),
+ letDeclNodeList_new (),
(lclPredicateNode) 0,
(lclPredicateNode) 0,
(modifyNode) 0,
/*@null@*/ lclPredicateNode claims)
{
fcnNode x = (fcnNode) dmalloc (sizeof (*x));
-
+
if (d->type != (typeExpr)0 && (d->type)->kind != TEXPR_FCN)
{
lclerror (d->id, cstring_makeLiteral
("Attempt to specify function without parameter list"));
d->type = makeFunctionNode (d->type, paramNodeList_new ());
}
-
-
+
x->special = specQual;
x->typespec = t;
x->declarator = d;
llassert (lclTypeSpecNode_isDefined (t));
- if (t->pointers == 0
+ if (pointers_isUndefined (t->pointers)
&& (d != (typeExpr)0 && d->kind != TEXPR_PTR) && d->kind != TEXPR_ARRAY)
{
if (t->kind == LTS_TYPE)
sn = sort_quietLookup (sort_getUnderlying ((t->content.type)->sort));
- if (sn.kind == SRT_PTR || sn.kind == SRT_ARRAY
- || sn.kind == SRT_HOF || sn.kind == SRT_NONE)
+ if (sn->kind == SRT_PTR || sn->kind == SRT_ARRAY
+ || sn->kind == SRT_HOF || sn->kind == SRT_NONE)
{
isPointer = TRUE;
}
llassert (t->content.type != NULL);
sn = sort_quietLookup (sort_getUnderlying ((t->content.type)->sort));
- if (sn.kind == SRT_PTR || sn.kind == SRT_ARRAY
- || sn.kind == SRT_HOF || sn.kind == SRT_NONE)
+ if (sn->kind == SRT_PTR || sn->kind == SRT_ARRAY
+ || sn->kind == SRT_HOF || sn->kind == SRT_NONE)
{
isUser = TRUE;
}
return (message ("%q%s", s, ltoken_unparse (n->opttagid)));
}
- s = message ("%q%s {\n\2\1", s, ltoken_unparse (n->opttagid));
+ s = message ("%q%s {\n\t", s, ltoken_unparse (n->opttagid));
}
else
{
- s = message ("%q{\n\2\1", s);
+ s = message ("%q{\n\t", s);
}
decls = n->structdecls;
stDeclNodeList_elements (decls, f)
{
- s = message ("%q%q\1%q;\n\1", s,
+ s = message ("%q%q %q;\n\t", s,
lclTypeSpecNode_unparseAltComments (f->lcltypespec),
declaratorNodeList_unparse (f->declarators));
} end_stDeclNodeList_elements;
- return (message ("%q\3}", s));
+ return (message ("%q }", s));
}
case LTS_CONJ:
{
return (message ("%q%s", s, ltoken_unparse (n->opttagid)));
}
- s = message ("%q%s {\n\2\1", s, ltoken_unparse (n->opttagid));
+ s = message ("%q%s {\n\t", s, ltoken_unparse (n->opttagid));
}
else
{
- s = message ("%q{\n\2\1", s);
+ s = message ("%q{\n\t", s);
}
decls = n->structdecls;
stDeclNodeList_elements (decls, f)
{
- s = message ("%q%q\1%q;\n\1", s,
+ s = message ("%q%q %q;\n\t", s,
lclTypeSpecNode_unparseComments (f->lcltypespec),
declaratorNodeList_unparse (f->declarators));
} end_stDeclNodeList_elements;
- return (message ("%q\3}", s));
+ return (message ("%q }", s));
}
case LTS_CONJ:
{
t->kind = TRM_APPLICATION;
t->sort = sort_makeNoSort ();
t->given = t->sort;
- t->possibleSorts = sortSet_new (); /* sort_equal */
+ t->possibleSorts = sortSet_new (); /* sort_equal */
t->possibleOps = lslOpSet_new ();
return (t);
}
termNode n = (termNode) dmalloc (sizeof (*n));
quantifiedTermNode q = (quantifiedTermNode) dmalloc (sizeof (*q));
- n->name = NULL; /*> missing this --- detected by lclint <*/
+ n->name = NULL; /*> missing this --- detected by splint <*/
n->error_reported = FALSE;
n->wrapped = 0;
n->error_reported = FALSE;
termNodeList_free (t->args);
t->args = termNodeList_new ();
- sort = sort_bool;
+ sort = g_sortBool;
n->sort = sort;
(void) sortSet_insert (n->possibleSorts, sort);
/* look up signatures for this operator too */
range = ltoken_create (simpleId, sort_getLsymbol (s));
- sign = makesigNode (ltoken_undefined, ltokenList_new (),
+ sign = makesigNode (ltoken_undefined, ltokenList_new (),
ltoken_copy (range));
if (opInfo_exists (oi) && (oi->name->isOpId)
needed anyway. */
/* symtable_enterOp (g_symtab, nn, sign); */
- if (s == sort_int)
+ if (s == g_sortInt)
{
sigNode osign;
lslOp opn = (lslOp) dmalloc (sizeof (*opn));
/* if it is a C int, we should overload it as double too because
C allows you to say "x > 2". */
- (void) sortSet_insert (n->possibleSorts, sort_double);
+ (void) sortSet_insert (n->possibleSorts, g_sortDouble);
ltoken_setText (range, lsymbol_fromChars ("double"));
osign = makesigNode (ltoken_undefined, ltokenList_new (), range);
t->error_reported = FALSE;
t->wrapped = 0;
t->kind = TRM_UNCHANGEDALL;
- t->sort = sort_bool;
+ t->sort = g_sortBool;
t->literal = op;
t->given = sort_makeNoSort ();
t->name = NULL; /*< missing this >*/
t->error_reported = FALSE;
t->wrapped = 0;
t->kind = TRM_UNCHANGEDOTHERS;
- t->sort = sort_bool;
+ t->sort = g_sortBool;
t->literal = op;
t->unchanged = x;
t->given = sort_makeNoSort ();
t->error_reported = FALSE;
t->wrapped = 0;
t->kind = TRM_SIZEOF;
- t->sort = sort_int;
+ t->sort = g_sortInt;
t->literal = op;
t->sizeofField = type;
t->given = sort_makeNoSort ();
}
s = message ("%q%s", s, sortText);
- break; /*** <<<--- bug detected by LCLint ***/
+ break;
}
case OPF_MMIDDLE:
{
if (typeInfo_exists (ti))
{
- /* must we be concern about whether this type is exported by module?
- No. Because all typedef's are exported. No hiding supported. */
- /* Later, may want to keep types around too */
- /* 3/2/93, use underlying sort */
+ /* must we be concern about whether this type is exported by module?
+ No. Because all typedef's are exported. No hiding supported. */
+ /* Later, may want to keep types around too */
+ /* 3/2/93, use underlying sort */
newnode->sort = sort_getUnderlying (ti->basedOn);
}
else
lclerror (typedefname, message ("Unrecognized type: %s",
ltoken_getRawString (typedefname)));
/* evs --- Don't know how to get this message */
-
+
newnode->sort = sort_makeNoSort ();
}
return sort_makePtrN (type->content.type->sort, type->pointers);
case LTS_STRUCTUNION:
llassert (type->content.structorunion != NULL);
- return sort_makePtrN (type->content.structorunion->sort,
- type->pointers);
+ return sort_makePtrN (type->content.structorunion->sort, type->pointers);
case LTS_ENUM:
llassert (type->content.enumspec != NULL);
- return sort_makePtrN (type->content.enumspec->sort,
- type->pointers);
+ return sort_makePtrN (type->content.enumspec->sort, type->pointers);
case LTS_CONJ:
return (lclTypeSpecNode2sort (type->content.conj->a));
}
fctInfo fi = (fctInfo) dmalloc (sizeof (*fi));
signNode sign = (signNode) dmalloc (sizeof (*sign));
sortList domain = sortList_new ();
- unsigned int key;
+ unsigned long int key;
paramPairs = extractParams (d->type);
returnSort = extractReturnSort (t, d);
void opFormNode_free (/*@null@*/ opFormNode op)
{
- sfree (op);
+ if (op != NULL)
+ {
+ ltoken_free (op->tok);
+ ltoken_free (op->close);
+ sfree (op);
+ }
}
void nameNode_free (nameNode n)
}
else
{
- /* error should be detected by lclint: forgot to copy opform! */
+ /* error should be detected by splint: forgot to copy opform! */
return (makeNameNodeForm (opFormNode_copy (n->content.opform)));
}
}
void termNode_free (/*@only@*/ /*@null@*/ termNode t)
{
- sfree (t);
+ if (t != NULL)
+ {
+ sortSet_free (t->possibleSorts);
+ lslOpSet_free (t->possibleOps);
+ nameNode_free (t->name);
+ termNodeList_free (t->args);
+ sfree (t);
+ }
}
/*@only@*/ termNode termNode_copySafe (termNode t)
void importNode_free (/*@only@*/ /*@null@*/ importNode x)
{
- sfree (x);
+ if (x != NULL)
+ {
+ ltoken_free (x->val);
+ sfree (x);
+ }
}
void initDeclNode_free (/*@only@*/ /*@null@*/ initDeclNode x)
void pairNode_free (/*@only@*/ /*@null@*/ pairNode x)
{
- sfree (x);
+ if (x != NULL)
+ {
+ ltoken_free (x->tok);
+ sfree (x);
+ }
}
/*@null@*/ paramNode paramNode_copy (/*@null@*/ paramNode p)
{
return (cstring_makeLiteral ("<interface node undefined>"));
}
+
+ BADBRANCHRET (cstring_undefined);
}
void interfaceNode_free (/*@null@*/ /*@only@*/ interfaceNode x)
andersk / splint.git / blobdiff